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_STEP_DELAY(e) ( (element_info[e].step_delay_fixed) + \
883 RND(element_info[e].step_delay_random))
884 #define GET_MAX_STEP_DELAY(e) ( (element_info[e].step_delay_fixed) + \
885 (element_info[e].step_delay_random))
886 #define GET_NEW_CE_VALUE(e) ( (element_info[e].ce_value_fixed_initial) +\
887 RND(element_info[e].ce_value_random_initial))
888 #define GET_CE_SCORE(e) ( (element_info[e].collect_score))
889 #define GET_CHANGE_DELAY(c) ( ((c)->delay_fixed * (c)->delay_frames) + \
890 RND((c)->delay_random * (c)->delay_frames))
891 #define GET_CE_DELAY_VALUE(c) ( ((c)->delay_fixed) + \
892 RND((c)->delay_random))
895 #define GET_VALID_RUNTIME_ELEMENT(e) \
896 ((e) >= NUM_RUNTIME_ELEMENTS ? EL_UNKNOWN : (e))
898 #define RESOLVED_REFERENCE_ELEMENT(be, e) \
899 ((be) + (e) - EL_SELF < EL_CUSTOM_START ? EL_CUSTOM_START : \
900 (be) + (e) - EL_SELF > EL_CUSTOM_END ? EL_CUSTOM_END : \
901 (be) + (e) - EL_SELF)
903 #define GET_PLAYER_FROM_BITS(p) \
904 (EL_PLAYER_1 + ((p) != PLAYER_BITS_ANY ? log_2(p) : 0))
906 #define GET_TARGET_ELEMENT(be, e, ch, cv, cs) \
907 ((e) == EL_TRIGGER_PLAYER ? (ch)->actual_trigger_player : \
908 (e) == EL_TRIGGER_ELEMENT ? (ch)->actual_trigger_element : \
909 (e) == EL_TRIGGER_CE_VALUE ? (ch)->actual_trigger_ce_value : \
910 (e) == EL_TRIGGER_CE_SCORE ? (ch)->actual_trigger_ce_score : \
911 (e) == EL_CURRENT_CE_VALUE ? (cv) : \
912 (e) == EL_CURRENT_CE_SCORE ? (cs) : \
913 (e) >= EL_PREV_CE_8 && (e) <= EL_NEXT_CE_8 ? \
914 RESOLVED_REFERENCE_ELEMENT(be, e) : \
917 #define CAN_GROW_INTO(e) \
918 ((e) == EL_SAND || (IS_DIGGABLE(e) && level.grow_into_diggable))
920 #define ELEMENT_CAN_ENTER_FIELD_BASE_X(x, y, condition) \
921 (IN_LEV_FIELD(x, y) && (IS_FREE(x, y) || \
924 #define ELEMENT_CAN_ENTER_FIELD_BASE_2(e, x, y, condition) \
925 (IN_LEV_FIELD(x, y) && (IS_FREE(x, y) || \
926 (CAN_MOVE_INTO_ACID(e) && \
927 Tile[x][y] == EL_ACID) || \
930 #define ELEMENT_CAN_ENTER_FIELD_BASE_3(e, x, y, condition) \
931 (IN_LEV_FIELD(x, y) && (IS_FREE_OR_PLAYER(x, y) || \
932 (CAN_MOVE_INTO_ACID(e) && \
933 Tile[x][y] == EL_ACID) || \
936 #define ELEMENT_CAN_ENTER_FIELD_BASE_4(e, x, y, condition) \
937 (IN_LEV_FIELD(x, y) && (IS_FREE(x, y) || \
939 (CAN_MOVE_INTO_ACID(e) && \
940 Tile[x][y] == EL_ACID) || \
941 (DONT_COLLIDE_WITH(e) && \
943 !PLAYER_ENEMY_PROTECTED(x, y))))
945 #define ELEMENT_CAN_ENTER_FIELD(e, x, y) \
946 ELEMENT_CAN_ENTER_FIELD_BASE_4(e, x, y, 0)
948 #define SATELLITE_CAN_ENTER_FIELD(x, y) \
949 ELEMENT_CAN_ENTER_FIELD_BASE_2(EL_SATELLITE, x, y, 0)
951 #define ANDROID_CAN_ENTER_FIELD(e, x, y) \
952 ELEMENT_CAN_ENTER_FIELD_BASE_2(e, x, y, Tile[x][y] == EL_EMC_PLANT)
954 #define ANDROID_CAN_CLONE_FIELD(x, y) \
955 (IN_LEV_FIELD(x, y) && (CAN_BE_CLONED_BY_ANDROID(Tile[x][y]) || \
956 CAN_BE_CLONED_BY_ANDROID(EL_TRIGGER_ELEMENT)))
958 #define ENEMY_CAN_ENTER_FIELD(e, x, y) \
959 ELEMENT_CAN_ENTER_FIELD_BASE_2(e, x, y, 0)
961 #define YAMYAM_CAN_ENTER_FIELD(e, x, y) \
962 ELEMENT_CAN_ENTER_FIELD_BASE_3(e, x, y, Tile[x][y] == EL_DIAMOND)
964 #define DARK_YAMYAM_CAN_ENTER_FIELD(e, x, y) \
965 ELEMENT_CAN_ENTER_FIELD_BASE_3(e, x,y, IS_FOOD_DARK_YAMYAM(Tile[x][y]))
967 #define PACMAN_CAN_ENTER_FIELD(e, x, y) \
968 ELEMENT_CAN_ENTER_FIELD_BASE_3(e, x, y, IS_AMOEBOID(Tile[x][y]))
970 #define PIG_CAN_ENTER_FIELD(e, x, y) \
971 ELEMENT_CAN_ENTER_FIELD_BASE_2(e, x, y, IS_FOOD_PIG(Tile[x][y]))
973 #define PENGUIN_CAN_ENTER_FIELD(e, x, y) \
974 ELEMENT_CAN_ENTER_FIELD_BASE_2(e, x, y, (Tile[x][y] == EL_EXIT_OPEN || \
975 Tile[x][y] == EL_EM_EXIT_OPEN || \
976 Tile[x][y] == EL_STEEL_EXIT_OPEN || \
977 Tile[x][y] == EL_EM_STEEL_EXIT_OPEN || \
978 IS_FOOD_PENGUIN(Tile[x][y])))
979 #define DRAGON_CAN_ENTER_FIELD(e, x, y) \
980 ELEMENT_CAN_ENTER_FIELD_BASE_2(e, x, y, 0)
982 #define MOLE_CAN_ENTER_FIELD(e, x, y, condition) \
983 ELEMENT_CAN_ENTER_FIELD_BASE_2(e, x, y, (condition))
985 #define SPRING_CAN_ENTER_FIELD(e, x, y) \
986 ELEMENT_CAN_ENTER_FIELD_BASE_2(e, x, y, 0)
988 #define SPRING_CAN_BUMP_FROM_FIELD(x, y) \
989 (IN_LEV_FIELD(x, y) && (Tile[x][y] == EL_EMC_SPRING_BUMPER || \
990 Tile[x][y] == EL_EMC_SPRING_BUMPER_ACTIVE))
992 #define MOVE_ENTER_EL(e) (element_info[e].move_enter_element)
994 #define CE_ENTER_FIELD_COND(e, x, y) \
995 (!IS_PLAYER(x, y) && \
996 IS_EQUAL_OR_IN_GROUP(Tile[x][y], MOVE_ENTER_EL(e)))
998 #define CUSTOM_ELEMENT_CAN_ENTER_FIELD(e, x, y) \
999 ELEMENT_CAN_ENTER_FIELD_BASE_4(e, x, y, CE_ENTER_FIELD_COND(e, x, y))
1001 #define IN_LEV_FIELD_AND_IS_FREE(x, y) (IN_LEV_FIELD(x, y) && IS_FREE(x, y))
1002 #define IN_LEV_FIELD_AND_NOT_FREE(x, y) (IN_LEV_FIELD(x, y) && !IS_FREE(x, y))
1004 #define ACCESS_FROM(e, d) (element_info[e].access_direction &(d))
1005 #define IS_WALKABLE_FROM(e, d) (IS_WALKABLE(e) && ACCESS_FROM(e, d))
1006 #define IS_PASSABLE_FROM(e, d) (IS_PASSABLE(e) && ACCESS_FROM(e, d))
1007 #define IS_ACCESSIBLE_FROM(e, d) (IS_ACCESSIBLE(e) && ACCESS_FROM(e, d))
1009 #define MM_HEALTH(x) (MIN(MAX(0, MAX_HEALTH - (x)), MAX_HEALTH))
1011 // game button identifiers
1012 #define GAME_CTRL_ID_STOP 0
1013 #define GAME_CTRL_ID_PAUSE 1
1014 #define GAME_CTRL_ID_PLAY 2
1015 #define GAME_CTRL_ID_UNDO 3
1016 #define GAME_CTRL_ID_REDO 4
1017 #define GAME_CTRL_ID_SAVE 5
1018 #define GAME_CTRL_ID_PAUSE2 6
1019 #define GAME_CTRL_ID_LOAD 7
1020 #define GAME_CTRL_ID_PANEL_STOP 8
1021 #define GAME_CTRL_ID_PANEL_PAUSE 9
1022 #define GAME_CTRL_ID_PANEL_PLAY 10
1023 #define GAME_CTRL_ID_TOUCH_STOP 11
1024 #define GAME_CTRL_ID_TOUCH_PAUSE 12
1025 #define SOUND_CTRL_ID_MUSIC 13
1026 #define SOUND_CTRL_ID_LOOPS 14
1027 #define SOUND_CTRL_ID_SIMPLE 15
1028 #define SOUND_CTRL_ID_PANEL_MUSIC 16
1029 #define SOUND_CTRL_ID_PANEL_LOOPS 17
1030 #define SOUND_CTRL_ID_PANEL_SIMPLE 18
1032 #define NUM_GAME_BUTTONS 19
1035 // forward declaration for internal use
1037 static void CreateField(int, int, int);
1039 static void ResetGfxAnimation(int, int);
1041 static void SetPlayerWaiting(struct PlayerInfo *, boolean);
1042 static void AdvanceFrameAndPlayerCounters(int);
1044 static boolean MovePlayerOneStep(struct PlayerInfo *, int, int, int, int);
1045 static boolean MovePlayer(struct PlayerInfo *, int, int);
1046 static void ScrollPlayer(struct PlayerInfo *, int);
1047 static void ScrollScreen(struct PlayerInfo *, int);
1049 static int DigField(struct PlayerInfo *, int, int, int, int, int, int, int);
1050 static boolean DigFieldByCE(int, int, int);
1051 static boolean SnapField(struct PlayerInfo *, int, int);
1052 static boolean DropElement(struct PlayerInfo *);
1054 static void InitBeltMovement(void);
1055 static void CloseAllOpenTimegates(void);
1056 static void CheckGravityMovement(struct PlayerInfo *);
1057 static void CheckGravityMovementWhenNotMoving(struct PlayerInfo *);
1058 static void KillPlayerUnlessEnemyProtected(int, int);
1059 static void KillPlayerUnlessExplosionProtected(int, int);
1061 static void TestIfPlayerTouchesCustomElement(int, int);
1062 static void TestIfElementTouchesCustomElement(int, int);
1063 static void TestIfElementHitsCustomElement(int, int, int);
1065 static void HandleElementChange(int, int, int);
1066 static void ExecuteCustomElementAction(int, int, int, int);
1067 static boolean ChangeElement(int, int, int, int);
1069 static boolean CheckTriggeredElementChangeExt(int, int, int, int, int,int,int);
1070 #define CheckTriggeredElementChange(x, y, e, ev) \
1071 CheckTriggeredElementChangeExt(x,y,e,ev, CH_PLAYER_ANY,CH_SIDE_ANY, -1)
1072 #define CheckTriggeredElementChangeByPlayer(x, y, e, ev, p, s) \
1073 CheckTriggeredElementChangeExt(x, y, e, ev, p, s, -1)
1074 #define CheckTriggeredElementChangeBySide(x, y, e, ev, s) \
1075 CheckTriggeredElementChangeExt(x, y, e, ev, CH_PLAYER_ANY, s, -1)
1076 #define CheckTriggeredElementChangeByPage(x, y, e, ev, p) \
1077 CheckTriggeredElementChangeExt(x,y,e,ev, CH_PLAYER_ANY, CH_SIDE_ANY, p)
1078 #define CheckTriggeredElementChangeByMouse(x, y, e, ev, s) \
1079 CheckTriggeredElementChangeExt(x, y, e, ev, CH_PLAYER_ANY, s, -1)
1081 static boolean CheckElementChangeExt(int, int, int, int, int, int, int);
1082 #define CheckElementChange(x, y, e, te, ev) \
1083 CheckElementChangeExt(x, y, e, te, ev, CH_PLAYER_ANY, CH_SIDE_ANY)
1084 #define CheckElementChangeByPlayer(x, y, e, ev, p, s) \
1085 CheckElementChangeExt(x, y, e, EL_EMPTY, ev, p, s)
1086 #define CheckElementChangeBySide(x, y, e, te, ev, s) \
1087 CheckElementChangeExt(x, y, e, te, ev, CH_PLAYER_ANY, s)
1088 #define CheckElementChangeByMouse(x, y, e, ev, s) \
1089 CheckElementChangeExt(x, y, e, EL_UNDEFINED, ev, CH_PLAYER_ANY, s)
1091 static void PlayLevelSound(int, int, int);
1092 static void PlayLevelSoundNearest(int, int, int);
1093 static void PlayLevelSoundAction(int, int, int);
1094 static void PlayLevelSoundElementAction(int, int, int, int);
1095 static void PlayLevelSoundElementActionIfLoop(int, int, int, int);
1096 static void PlayLevelSoundActionIfLoop(int, int, int);
1097 static void StopLevelSoundActionIfLoop(int, int, int);
1098 static void PlayLevelMusic(void);
1099 static void FadeLevelSoundsAndMusic(void);
1101 static void HandleGameButtons(struct GadgetInfo *);
1103 int AmoebaNeighbourNr(int, int);
1104 void AmoebaToDiamond(int, int);
1105 void ContinueMoving(int, int);
1106 void Bang(int, int);
1107 void InitMovDir(int, int);
1108 void InitAmoebaNr(int, int);
1109 int NewHiScore(int);
1111 void TestIfGoodThingHitsBadThing(int, int, int);
1112 void TestIfBadThingHitsGoodThing(int, int, int);
1113 void TestIfPlayerTouchesBadThing(int, int);
1114 void TestIfPlayerRunsIntoBadThing(int, int, int);
1115 void TestIfBadThingTouchesPlayer(int, int);
1116 void TestIfBadThingRunsIntoPlayer(int, int, int);
1117 void TestIfFriendTouchesBadThing(int, int);
1118 void TestIfBadThingTouchesFriend(int, int);
1119 void TestIfBadThingTouchesOtherBadThing(int, int);
1120 void TestIfGoodThingGetsHitByBadThing(int, int, int);
1122 void KillPlayer(struct PlayerInfo *);
1123 void BuryPlayer(struct PlayerInfo *);
1124 void RemovePlayer(struct PlayerInfo *);
1125 void ExitPlayer(struct PlayerInfo *);
1127 static int getInvisibleActiveFromInvisibleElement(int);
1128 static int getInvisibleFromInvisibleActiveElement(int);
1130 static void TestFieldAfterSnapping(int, int, int, int, int);
1132 static struct GadgetInfo *game_gadget[NUM_GAME_BUTTONS];
1134 // for detection of endless loops, caused by custom element programming
1135 // (using maximal playfield width x 10 is just a rough approximation)
1136 #define MAX_ELEMENT_CHANGE_RECURSION_DEPTH (MAX_PLAYFIELD_WIDTH * 10)
1138 #define RECURSION_LOOP_DETECTION_START(e, rc) \
1140 if (recursion_loop_detected) \
1143 if (recursion_loop_depth > MAX_ELEMENT_CHANGE_RECURSION_DEPTH) \
1145 recursion_loop_detected = TRUE; \
1146 recursion_loop_element = (e); \
1149 recursion_loop_depth++; \
1152 #define RECURSION_LOOP_DETECTION_END() \
1154 recursion_loop_depth--; \
1157 static int recursion_loop_depth;
1158 static boolean recursion_loop_detected;
1159 static boolean recursion_loop_element;
1161 static int map_player_action[MAX_PLAYERS];
1164 // ----------------------------------------------------------------------------
1165 // definition of elements that automatically change to other elements after
1166 // a specified time, eventually calling a function when changing
1167 // ----------------------------------------------------------------------------
1169 // forward declaration for changer functions
1170 static void InitBuggyBase(int, int);
1171 static void WarnBuggyBase(int, int);
1173 static void InitTrap(int, int);
1174 static void ActivateTrap(int, int);
1175 static void ChangeActiveTrap(int, int);
1177 static void InitRobotWheel(int, int);
1178 static void RunRobotWheel(int, int);
1179 static void StopRobotWheel(int, int);
1181 static void InitTimegateWheel(int, int);
1182 static void RunTimegateWheel(int, int);
1184 static void InitMagicBallDelay(int, int);
1185 static void ActivateMagicBall(int, int);
1187 struct ChangingElementInfo
1192 void (*pre_change_function)(int x, int y);
1193 void (*change_function)(int x, int y);
1194 void (*post_change_function)(int x, int y);
1197 static struct ChangingElementInfo change_delay_list[] =
1232 EL_STEEL_EXIT_OPENING,
1240 EL_STEEL_EXIT_CLOSING,
1241 EL_STEEL_EXIT_CLOSED,
1264 EL_EM_STEEL_EXIT_OPENING,
1265 EL_EM_STEEL_EXIT_OPEN,
1272 EL_EM_STEEL_EXIT_CLOSING,
1296 EL_SWITCHGATE_OPENING,
1304 EL_SWITCHGATE_CLOSING,
1305 EL_SWITCHGATE_CLOSED,
1312 EL_TIMEGATE_OPENING,
1320 EL_TIMEGATE_CLOSING,
1329 EL_ACID_SPLASH_LEFT,
1337 EL_ACID_SPLASH_RIGHT,
1346 EL_SP_BUGGY_BASE_ACTIVATING,
1353 EL_SP_BUGGY_BASE_ACTIVATING,
1354 EL_SP_BUGGY_BASE_ACTIVE,
1361 EL_SP_BUGGY_BASE_ACTIVE,
1385 EL_ROBOT_WHEEL_ACTIVE,
1393 EL_TIMEGATE_SWITCH_ACTIVE,
1401 EL_DC_TIMEGATE_SWITCH_ACTIVE,
1402 EL_DC_TIMEGATE_SWITCH,
1409 EL_EMC_MAGIC_BALL_ACTIVE,
1410 EL_EMC_MAGIC_BALL_ACTIVE,
1417 EL_EMC_SPRING_BUMPER_ACTIVE,
1418 EL_EMC_SPRING_BUMPER,
1425 EL_DIAGONAL_SHRINKING,
1433 EL_DIAGONAL_GROWING,
1454 int push_delay_fixed, push_delay_random;
1458 { EL_SPRING, 0, 0 },
1459 { EL_BALLOON, 0, 0 },
1461 { EL_SOKOBAN_OBJECT, 2, 0 },
1462 { EL_SOKOBAN_FIELD_FULL, 2, 0 },
1463 { EL_SATELLITE, 2, 0 },
1464 { EL_SP_DISK_YELLOW, 2, 0 },
1466 { EL_UNDEFINED, 0, 0 },
1474 move_stepsize_list[] =
1476 { EL_AMOEBA_DROP, 2 },
1477 { EL_AMOEBA_DROPPING, 2 },
1478 { EL_QUICKSAND_FILLING, 1 },
1479 { EL_QUICKSAND_EMPTYING, 1 },
1480 { EL_QUICKSAND_FAST_FILLING, 2 },
1481 { EL_QUICKSAND_FAST_EMPTYING, 2 },
1482 { EL_MAGIC_WALL_FILLING, 2 },
1483 { EL_MAGIC_WALL_EMPTYING, 2 },
1484 { EL_BD_MAGIC_WALL_FILLING, 2 },
1485 { EL_BD_MAGIC_WALL_EMPTYING, 2 },
1486 { EL_DC_MAGIC_WALL_FILLING, 2 },
1487 { EL_DC_MAGIC_WALL_EMPTYING, 2 },
1489 { EL_UNDEFINED, 0 },
1497 collect_count_list[] =
1500 { EL_BD_DIAMOND, 1 },
1501 { EL_EMERALD_YELLOW, 1 },
1502 { EL_EMERALD_RED, 1 },
1503 { EL_EMERALD_PURPLE, 1 },
1505 { EL_SP_INFOTRON, 1 },
1509 { EL_UNDEFINED, 0 },
1517 access_direction_list[] =
1519 { EL_TUBE_ANY, MV_LEFT | MV_RIGHT | MV_UP | MV_DOWN },
1520 { EL_TUBE_VERTICAL, MV_UP | MV_DOWN },
1521 { EL_TUBE_HORIZONTAL, MV_LEFT | MV_RIGHT },
1522 { EL_TUBE_VERTICAL_LEFT, MV_LEFT | MV_UP | MV_DOWN },
1523 { EL_TUBE_VERTICAL_RIGHT, MV_RIGHT | MV_UP | MV_DOWN },
1524 { EL_TUBE_HORIZONTAL_UP, MV_LEFT | MV_RIGHT | MV_UP },
1525 { EL_TUBE_HORIZONTAL_DOWN, MV_LEFT | MV_RIGHT | MV_DOWN },
1526 { EL_TUBE_LEFT_UP, MV_LEFT | MV_UP },
1527 { EL_TUBE_LEFT_DOWN, MV_LEFT | MV_DOWN },
1528 { EL_TUBE_RIGHT_UP, MV_RIGHT | MV_UP },
1529 { EL_TUBE_RIGHT_DOWN, MV_RIGHT | MV_DOWN },
1531 { EL_SP_PORT_LEFT, MV_RIGHT },
1532 { EL_SP_PORT_RIGHT, MV_LEFT },
1533 { EL_SP_PORT_UP, MV_DOWN },
1534 { EL_SP_PORT_DOWN, MV_UP },
1535 { EL_SP_PORT_HORIZONTAL, MV_LEFT | MV_RIGHT },
1536 { EL_SP_PORT_VERTICAL, MV_UP | MV_DOWN },
1537 { EL_SP_PORT_ANY, MV_LEFT | MV_RIGHT | MV_UP | MV_DOWN },
1538 { EL_SP_GRAVITY_PORT_LEFT, MV_RIGHT },
1539 { EL_SP_GRAVITY_PORT_RIGHT, MV_LEFT },
1540 { EL_SP_GRAVITY_PORT_UP, MV_DOWN },
1541 { EL_SP_GRAVITY_PORT_DOWN, MV_UP },
1542 { EL_SP_GRAVITY_ON_PORT_LEFT, MV_RIGHT },
1543 { EL_SP_GRAVITY_ON_PORT_RIGHT, MV_LEFT },
1544 { EL_SP_GRAVITY_ON_PORT_UP, MV_DOWN },
1545 { EL_SP_GRAVITY_ON_PORT_DOWN, MV_UP },
1546 { EL_SP_GRAVITY_OFF_PORT_LEFT, MV_RIGHT },
1547 { EL_SP_GRAVITY_OFF_PORT_RIGHT, MV_LEFT },
1548 { EL_SP_GRAVITY_OFF_PORT_UP, MV_DOWN },
1549 { EL_SP_GRAVITY_OFF_PORT_DOWN, MV_UP },
1551 { EL_UNDEFINED, MV_NONE }
1554 static boolean trigger_events[MAX_NUM_ELEMENTS][NUM_CHANGE_EVENTS];
1556 #define IS_AUTO_CHANGING(e) (element_info[e].has_change_event[CE_DELAY])
1557 #define IS_JUST_CHANGING(x, y) (ChangeDelay[x][y] != 0)
1558 #define IS_CHANGING(x, y) (IS_AUTO_CHANGING(Tile[x][y]) || \
1559 IS_JUST_CHANGING(x, y))
1561 #define CE_PAGE(e, ce) (element_info[e].event_page[ce])
1563 // static variables for playfield scan mode (scanning forward or backward)
1564 static int playfield_scan_start_x = 0;
1565 static int playfield_scan_start_y = 0;
1566 static int playfield_scan_delta_x = 1;
1567 static int playfield_scan_delta_y = 1;
1569 #define SCAN_PLAYFIELD(x, y) for ((y) = playfield_scan_start_y; \
1570 (y) >= 0 && (y) <= lev_fieldy - 1; \
1571 (y) += playfield_scan_delta_y) \
1572 for ((x) = playfield_scan_start_x; \
1573 (x) >= 0 && (x) <= lev_fieldx - 1; \
1574 (x) += playfield_scan_delta_x)
1577 void DEBUG_SetMaximumDynamite(void)
1581 for (i = 0; i < MAX_INVENTORY_SIZE; i++)
1582 if (local_player->inventory_size < MAX_INVENTORY_SIZE)
1583 local_player->inventory_element[local_player->inventory_size++] =
1588 static void InitPlayfieldScanModeVars(void)
1590 if (game.use_reverse_scan_direction)
1592 playfield_scan_start_x = lev_fieldx - 1;
1593 playfield_scan_start_y = lev_fieldy - 1;
1595 playfield_scan_delta_x = -1;
1596 playfield_scan_delta_y = -1;
1600 playfield_scan_start_x = 0;
1601 playfield_scan_start_y = 0;
1603 playfield_scan_delta_x = 1;
1604 playfield_scan_delta_y = 1;
1608 static void InitPlayfieldScanMode(int mode)
1610 game.use_reverse_scan_direction =
1611 (mode == CA_ARG_SCAN_MODE_REVERSE ? TRUE : FALSE);
1613 InitPlayfieldScanModeVars();
1616 static int get_move_delay_from_stepsize(int move_stepsize)
1619 MIN(MAX(MOVE_STEPSIZE_MIN, move_stepsize), MOVE_STEPSIZE_MAX);
1621 // make sure that stepsize value is always a power of 2
1622 move_stepsize = (1 << log_2(move_stepsize));
1624 return TILEX / move_stepsize;
1627 static void SetPlayerMoveSpeed(struct PlayerInfo *player, int move_stepsize,
1630 int player_nr = player->index_nr;
1631 int move_delay = get_move_delay_from_stepsize(move_stepsize);
1632 boolean cannot_move = (move_stepsize == STEPSIZE_NOT_MOVING ? TRUE : FALSE);
1634 // do no immediately change move delay -- the player might just be moving
1635 player->move_delay_value_next = move_delay;
1637 // information if player can move must be set separately
1638 player->cannot_move = cannot_move;
1642 player->move_delay = game.initial_move_delay[player_nr];
1643 player->move_delay_value = game.initial_move_delay_value[player_nr];
1645 player->move_delay_value_next = -1;
1647 player->move_delay_reset_counter = 0;
1651 void GetPlayerConfig(void)
1653 GameFrameDelay = setup.game_frame_delay;
1655 if (!audio.sound_available)
1656 setup.sound_simple = FALSE;
1658 if (!audio.loops_available)
1659 setup.sound_loops = FALSE;
1661 if (!audio.music_available)
1662 setup.sound_music = FALSE;
1664 if (!video.fullscreen_available)
1665 setup.fullscreen = FALSE;
1667 setup.sound = (setup.sound_simple || setup.sound_loops || setup.sound_music);
1669 SetAudioMode(setup.sound);
1672 int GetElementFromGroupElement(int element)
1674 if (IS_GROUP_ELEMENT(element))
1676 struct ElementGroupInfo *group = element_info[element].group;
1677 int last_anim_random_frame = gfx.anim_random_frame;
1680 if (group->choice_mode == ANIM_RANDOM)
1681 gfx.anim_random_frame = RND(group->num_elements_resolved);
1683 element_pos = getAnimationFrame(group->num_elements_resolved, 1,
1684 group->choice_mode, 0,
1687 if (group->choice_mode == ANIM_RANDOM)
1688 gfx.anim_random_frame = last_anim_random_frame;
1690 group->choice_pos++;
1692 element = group->element_resolved[element_pos];
1698 static void IncrementSokobanFieldsNeeded(void)
1700 if (level.sb_fields_needed)
1701 game.sokoban_fields_still_needed++;
1704 static void IncrementSokobanObjectsNeeded(void)
1706 if (level.sb_objects_needed)
1707 game.sokoban_objects_still_needed++;
1710 static void DecrementSokobanFieldsNeeded(void)
1712 if (game.sokoban_fields_still_needed > 0)
1713 game.sokoban_fields_still_needed--;
1716 static void DecrementSokobanObjectsNeeded(void)
1718 if (game.sokoban_objects_still_needed > 0)
1719 game.sokoban_objects_still_needed--;
1722 static void InitPlayerField(int x, int y, int element, boolean init_game)
1724 if (element == EL_SP_MURPHY)
1728 if (stored_player[0].present)
1730 Tile[x][y] = EL_SP_MURPHY_CLONE;
1736 stored_player[0].initial_element = element;
1737 stored_player[0].use_murphy = TRUE;
1739 if (!level.use_artwork_element[0])
1740 stored_player[0].artwork_element = EL_SP_MURPHY;
1743 Tile[x][y] = EL_PLAYER_1;
1749 struct PlayerInfo *player = &stored_player[Tile[x][y] - EL_PLAYER_1];
1750 int jx = player->jx, jy = player->jy;
1752 player->present = TRUE;
1754 player->block_last_field = (element == EL_SP_MURPHY ?
1755 level.sp_block_last_field :
1756 level.block_last_field);
1758 // ---------- initialize player's last field block delay ------------------
1760 // always start with reliable default value (no adjustment needed)
1761 player->block_delay_adjustment = 0;
1763 // special case 1: in Supaplex, Murphy blocks last field one more frame
1764 if (player->block_last_field && element == EL_SP_MURPHY)
1765 player->block_delay_adjustment = 1;
1767 // special case 2: in game engines before 3.1.1, blocking was different
1768 if (game.use_block_last_field_bug)
1769 player->block_delay_adjustment = (player->block_last_field ? -1 : 1);
1771 if (!network.enabled || player->connected_network)
1773 player->active = TRUE;
1775 // remove potentially duplicate players
1776 if (StorePlayer[jx][jy] == Tile[x][y])
1777 StorePlayer[jx][jy] = 0;
1779 StorePlayer[x][y] = Tile[x][y];
1781 #if DEBUG_INIT_PLAYER
1782 Debug("game:init:player", "- player element %d activated",
1783 player->element_nr);
1784 Debug("game:init:player", " (local player is %d and currently %s)",
1785 local_player->element_nr,
1786 local_player->active ? "active" : "not active");
1790 Tile[x][y] = EL_EMPTY;
1792 player->jx = player->last_jx = x;
1793 player->jy = player->last_jy = y;
1796 // always check if player was just killed and should be reanimated
1798 int player_nr = GET_PLAYER_NR(element);
1799 struct PlayerInfo *player = &stored_player[player_nr];
1801 if (player->active && player->killed)
1802 player->reanimated = TRUE; // if player was just killed, reanimate him
1806 static void InitField(int x, int y, boolean init_game)
1808 int element = Tile[x][y];
1817 InitPlayerField(x, y, element, init_game);
1820 case EL_SOKOBAN_FIELD_PLAYER:
1821 element = Tile[x][y] = EL_PLAYER_1;
1822 InitField(x, y, init_game);
1824 element = Tile[x][y] = EL_SOKOBAN_FIELD_EMPTY;
1825 InitField(x, y, init_game);
1828 case EL_SOKOBAN_FIELD_EMPTY:
1829 IncrementSokobanFieldsNeeded();
1832 case EL_SOKOBAN_OBJECT:
1833 IncrementSokobanObjectsNeeded();
1837 if (x < lev_fieldx-1 && Tile[x+1][y] == EL_ACID)
1838 Tile[x][y] = EL_ACID_POOL_TOPLEFT;
1839 else if (x > 0 && Tile[x-1][y] == EL_ACID)
1840 Tile[x][y] = EL_ACID_POOL_TOPRIGHT;
1841 else if (y > 0 && Tile[x][y-1] == EL_ACID_POOL_TOPLEFT)
1842 Tile[x][y] = EL_ACID_POOL_BOTTOMLEFT;
1843 else if (y > 0 && Tile[x][y-1] == EL_ACID)
1844 Tile[x][y] = EL_ACID_POOL_BOTTOM;
1845 else if (y > 0 && Tile[x][y-1] == EL_ACID_POOL_TOPRIGHT)
1846 Tile[x][y] = EL_ACID_POOL_BOTTOMRIGHT;
1855 case EL_SPACESHIP_RIGHT:
1856 case EL_SPACESHIP_UP:
1857 case EL_SPACESHIP_LEFT:
1858 case EL_SPACESHIP_DOWN:
1859 case EL_BD_BUTTERFLY:
1860 case EL_BD_BUTTERFLY_RIGHT:
1861 case EL_BD_BUTTERFLY_UP:
1862 case EL_BD_BUTTERFLY_LEFT:
1863 case EL_BD_BUTTERFLY_DOWN:
1865 case EL_BD_FIREFLY_RIGHT:
1866 case EL_BD_FIREFLY_UP:
1867 case EL_BD_FIREFLY_LEFT:
1868 case EL_BD_FIREFLY_DOWN:
1869 case EL_PACMAN_RIGHT:
1871 case EL_PACMAN_LEFT:
1872 case EL_PACMAN_DOWN:
1874 case EL_YAMYAM_LEFT:
1875 case EL_YAMYAM_RIGHT:
1877 case EL_YAMYAM_DOWN:
1878 case EL_DARK_YAMYAM:
1881 case EL_SP_SNIKSNAK:
1882 case EL_SP_ELECTRON:
1888 case EL_SPRING_LEFT:
1889 case EL_SPRING_RIGHT:
1893 case EL_AMOEBA_FULL:
1898 case EL_AMOEBA_DROP:
1899 if (y == lev_fieldy - 1)
1901 Tile[x][y] = EL_AMOEBA_GROWING;
1902 Store[x][y] = EL_AMOEBA_WET;
1906 case EL_DYNAMITE_ACTIVE:
1907 case EL_SP_DISK_RED_ACTIVE:
1908 case EL_DYNABOMB_PLAYER_1_ACTIVE:
1909 case EL_DYNABOMB_PLAYER_2_ACTIVE:
1910 case EL_DYNABOMB_PLAYER_3_ACTIVE:
1911 case EL_DYNABOMB_PLAYER_4_ACTIVE:
1912 MovDelay[x][y] = 96;
1915 case EL_EM_DYNAMITE_ACTIVE:
1916 MovDelay[x][y] = 32;
1920 game.lights_still_needed++;
1924 game.friends_still_needed++;
1929 GfxDir[x][y] = MovDir[x][y] = 1 << RND(4);
1932 case EL_CONVEYOR_BELT_1_SWITCH_LEFT:
1933 case EL_CONVEYOR_BELT_1_SWITCH_MIDDLE:
1934 case EL_CONVEYOR_BELT_1_SWITCH_RIGHT:
1935 case EL_CONVEYOR_BELT_2_SWITCH_LEFT:
1936 case EL_CONVEYOR_BELT_2_SWITCH_MIDDLE:
1937 case EL_CONVEYOR_BELT_2_SWITCH_RIGHT:
1938 case EL_CONVEYOR_BELT_3_SWITCH_LEFT:
1939 case EL_CONVEYOR_BELT_3_SWITCH_MIDDLE:
1940 case EL_CONVEYOR_BELT_3_SWITCH_RIGHT:
1941 case EL_CONVEYOR_BELT_4_SWITCH_LEFT:
1942 case EL_CONVEYOR_BELT_4_SWITCH_MIDDLE:
1943 case EL_CONVEYOR_BELT_4_SWITCH_RIGHT:
1946 int belt_nr = getBeltNrFromBeltSwitchElement(Tile[x][y]);
1947 int belt_dir = getBeltDirFromBeltSwitchElement(Tile[x][y]);
1948 int belt_dir_nr = getBeltDirNrFromBeltSwitchElement(Tile[x][y]);
1950 if (game.belt_dir_nr[belt_nr] == 3) // initial value
1952 game.belt_dir[belt_nr] = belt_dir;
1953 game.belt_dir_nr[belt_nr] = belt_dir_nr;
1955 else // more than one switch -- set it like the first switch
1957 Tile[x][y] = Tile[x][y] - belt_dir_nr + game.belt_dir_nr[belt_nr];
1962 case EL_LIGHT_SWITCH_ACTIVE:
1964 game.light_time_left = level.time_light * FRAMES_PER_SECOND;
1967 case EL_INVISIBLE_STEELWALL:
1968 case EL_INVISIBLE_WALL:
1969 case EL_INVISIBLE_SAND:
1970 if (game.light_time_left > 0 ||
1971 game.lenses_time_left > 0)
1972 Tile[x][y] = getInvisibleActiveFromInvisibleElement(element);
1975 case EL_EMC_MAGIC_BALL:
1976 if (game.ball_active)
1977 Tile[x][y] = EL_EMC_MAGIC_BALL_ACTIVE;
1980 case EL_EMC_MAGIC_BALL_SWITCH:
1981 if (game.ball_active)
1982 Tile[x][y] = EL_EMC_MAGIC_BALL_SWITCH_ACTIVE;
1985 case EL_TRIGGER_PLAYER:
1986 case EL_TRIGGER_ELEMENT:
1987 case EL_TRIGGER_CE_VALUE:
1988 case EL_TRIGGER_CE_SCORE:
1990 case EL_ANY_ELEMENT:
1991 case EL_CURRENT_CE_VALUE:
1992 case EL_CURRENT_CE_SCORE:
2009 // reference elements should not be used on the playfield
2010 Tile[x][y] = EL_EMPTY;
2014 if (IS_CUSTOM_ELEMENT(element))
2016 if (CAN_MOVE(element))
2019 if (!element_info[element].use_last_ce_value || init_game)
2020 CustomValue[x][y] = GET_NEW_CE_VALUE(Tile[x][y]);
2022 else if (IS_GROUP_ELEMENT(element))
2024 Tile[x][y] = GetElementFromGroupElement(element);
2026 InitField(x, y, init_game);
2033 CheckTriggeredElementChange(x, y, element, CE_CREATION_OF_X);
2036 static void InitField_WithBug1(int x, int y, boolean init_game)
2038 InitField(x, y, init_game);
2040 // not needed to call InitMovDir() -- already done by InitField()!
2041 if (game.engine_version < VERSION_IDENT(3,1,0,0) &&
2042 CAN_MOVE(Tile[x][y]))
2046 static void InitField_WithBug2(int x, int y, boolean init_game)
2048 int old_element = Tile[x][y];
2050 InitField(x, y, init_game);
2052 // not needed to call InitMovDir() -- already done by InitField()!
2053 if (game.engine_version < VERSION_IDENT(3,1,0,0) &&
2054 CAN_MOVE(old_element) &&
2055 (old_element < EL_MOLE_LEFT || old_element > EL_MOLE_DOWN))
2058 /* this case is in fact a combination of not less than three bugs:
2059 first, it calls InitMovDir() for elements that can move, although this is
2060 already done by InitField(); then, it checks the element that was at this
2061 field _before_ the call to InitField() (which can change it); lastly, it
2062 was not called for "mole with direction" elements, which were treated as
2063 "cannot move" due to (fixed) wrong element initialization in "src/init.c"
2067 static int get_key_element_from_nr(int key_nr)
2069 int key_base_element = (key_nr >= STD_NUM_KEYS ? EL_EMC_KEY_5 - STD_NUM_KEYS :
2070 level.game_engine_type == GAME_ENGINE_TYPE_EM ?
2071 EL_EM_KEY_1 : EL_KEY_1);
2073 return key_base_element + key_nr;
2076 static int get_next_dropped_element(struct PlayerInfo *player)
2078 return (player->inventory_size > 0 ?
2079 player->inventory_element[player->inventory_size - 1] :
2080 player->inventory_infinite_element != EL_UNDEFINED ?
2081 player->inventory_infinite_element :
2082 player->dynabombs_left > 0 ?
2083 EL_DYNABOMB_PLAYER_1_ACTIVE + player->index_nr :
2087 static int get_inventory_element_from_pos(struct PlayerInfo *player, int pos)
2089 // pos >= 0: get element from bottom of the stack;
2090 // pos < 0: get element from top of the stack
2094 int min_inventory_size = -pos;
2095 int inventory_pos = player->inventory_size - min_inventory_size;
2096 int min_dynabombs_left = min_inventory_size - player->inventory_size;
2098 return (player->inventory_size >= min_inventory_size ?
2099 player->inventory_element[inventory_pos] :
2100 player->inventory_infinite_element != EL_UNDEFINED ?
2101 player->inventory_infinite_element :
2102 player->dynabombs_left >= min_dynabombs_left ?
2103 EL_DYNABOMB_PLAYER_1 + player->index_nr :
2108 int min_dynabombs_left = pos + 1;
2109 int min_inventory_size = pos + 1 - player->dynabombs_left;
2110 int inventory_pos = pos - player->dynabombs_left;
2112 return (player->inventory_infinite_element != EL_UNDEFINED ?
2113 player->inventory_infinite_element :
2114 player->dynabombs_left >= min_dynabombs_left ?
2115 EL_DYNABOMB_PLAYER_1 + player->index_nr :
2116 player->inventory_size >= min_inventory_size ?
2117 player->inventory_element[inventory_pos] :
2122 static int compareGamePanelOrderInfo(const void *object1, const void *object2)
2124 const struct GamePanelOrderInfo *gpo1 = (struct GamePanelOrderInfo *)object1;
2125 const struct GamePanelOrderInfo *gpo2 = (struct GamePanelOrderInfo *)object2;
2128 if (gpo1->sort_priority != gpo2->sort_priority)
2129 compare_result = gpo1->sort_priority - gpo2->sort_priority;
2131 compare_result = gpo1->nr - gpo2->nr;
2133 return compare_result;
2136 int getPlayerInventorySize(int player_nr)
2138 if (level.game_engine_type == GAME_ENGINE_TYPE_EM)
2139 return game_em.ply[player_nr]->dynamite;
2140 else if (level.game_engine_type == GAME_ENGINE_TYPE_SP)
2141 return game_sp.red_disk_count;
2143 return stored_player[player_nr].inventory_size;
2146 static void InitGameControlValues(void)
2150 for (i = 0; game_panel_controls[i].nr != -1; i++)
2152 struct GamePanelControlInfo *gpc = &game_panel_controls[i];
2153 struct GamePanelOrderInfo *gpo = &game_panel_order[i];
2154 struct TextPosInfo *pos = gpc->pos;
2156 int type = gpc->type;
2160 Error("'game_panel_controls' structure corrupted at %d", i);
2162 Fail("this should not happen -- please debug");
2165 // force update of game controls after initialization
2166 gpc->value = gpc->last_value = -1;
2167 gpc->frame = gpc->last_frame = -1;
2168 gpc->gfx_frame = -1;
2170 // determine panel value width for later calculation of alignment
2171 if (type == TYPE_INTEGER || type == TYPE_STRING)
2173 pos->width = pos->size * getFontWidth(pos->font);
2174 pos->height = getFontHeight(pos->font);
2176 else if (type == TYPE_ELEMENT)
2178 pos->width = pos->size;
2179 pos->height = pos->size;
2182 // fill structure for game panel draw order
2184 gpo->sort_priority = pos->sort_priority;
2187 // sort game panel controls according to sort_priority and control number
2188 qsort(game_panel_order, NUM_GAME_PANEL_CONTROLS,
2189 sizeof(struct GamePanelOrderInfo), compareGamePanelOrderInfo);
2192 static void UpdatePlayfieldElementCount(void)
2194 boolean use_element_count = FALSE;
2197 // first check if it is needed at all to calculate playfield element count
2198 for (i = GAME_PANEL_ELEMENT_COUNT_1; i <= GAME_PANEL_ELEMENT_COUNT_8; i++)
2199 if (!PANEL_DEACTIVATED(game_panel_controls[i].pos))
2200 use_element_count = TRUE;
2202 if (!use_element_count)
2205 for (i = 0; i < MAX_NUM_ELEMENTS; i++)
2206 element_info[i].element_count = 0;
2208 SCAN_PLAYFIELD(x, y)
2210 element_info[Tile[x][y]].element_count++;
2213 for (i = 0; i < NUM_GROUP_ELEMENTS; i++)
2214 for (j = 0; j < MAX_NUM_ELEMENTS; j++)
2215 if (IS_IN_GROUP(j, i))
2216 element_info[EL_GROUP_START + i].element_count +=
2217 element_info[j].element_count;
2220 static void UpdateGameControlValues(void)
2223 int time = (game.LevelSolved ?
2224 game.LevelSolved_CountingTime :
2225 level.game_engine_type == GAME_ENGINE_TYPE_EM ?
2227 level.game_engine_type == GAME_ENGINE_TYPE_SP ?
2228 game_sp.time_played :
2229 level.game_engine_type == GAME_ENGINE_TYPE_MM ?
2230 game_mm.energy_left :
2231 game.no_time_limit ? TimePlayed : TimeLeft);
2232 int score = (game.LevelSolved ?
2233 game.LevelSolved_CountingScore :
2234 level.game_engine_type == GAME_ENGINE_TYPE_EM ?
2235 game_em.lev->score :
2236 level.game_engine_type == GAME_ENGINE_TYPE_SP ?
2238 level.game_engine_type == GAME_ENGINE_TYPE_MM ?
2241 int gems = (level.game_engine_type == GAME_ENGINE_TYPE_EM ?
2242 game_em.lev->gems_needed :
2243 level.game_engine_type == GAME_ENGINE_TYPE_SP ?
2244 game_sp.infotrons_still_needed :
2245 level.game_engine_type == GAME_ENGINE_TYPE_MM ?
2246 game_mm.kettles_still_needed :
2247 game.gems_still_needed);
2248 int exit_closed = (level.game_engine_type == GAME_ENGINE_TYPE_EM ?
2249 game_em.lev->gems_needed > 0 :
2250 level.game_engine_type == GAME_ENGINE_TYPE_SP ?
2251 game_sp.infotrons_still_needed > 0 :
2252 level.game_engine_type == GAME_ENGINE_TYPE_MM ?
2253 game_mm.kettles_still_needed > 0 ||
2254 game_mm.lights_still_needed > 0 :
2255 game.gems_still_needed > 0 ||
2256 game.sokoban_fields_still_needed > 0 ||
2257 game.sokoban_objects_still_needed > 0 ||
2258 game.lights_still_needed > 0);
2259 int health = (game.LevelSolved ?
2260 game.LevelSolved_CountingHealth :
2261 level.game_engine_type == GAME_ENGINE_TYPE_MM ?
2262 MM_HEALTH(game_mm.laser_overload_value) :
2264 int sync_random_frame = INIT_GFX_RANDOM(); // random, but synchronized
2266 UpdatePlayfieldElementCount();
2268 // update game panel control values
2270 // used instead of "level_nr" (for network games)
2271 game_panel_controls[GAME_PANEL_LEVEL_NUMBER].value = levelset.level_nr;
2272 game_panel_controls[GAME_PANEL_GEMS].value = gems;
2274 game_panel_controls[GAME_PANEL_INVENTORY_COUNT].value = 0;
2275 for (i = 0; i < MAX_NUM_KEYS; i++)
2276 game_panel_controls[GAME_PANEL_KEY_1 + i].value = EL_EMPTY;
2277 game_panel_controls[GAME_PANEL_KEY_WHITE].value = EL_EMPTY;
2278 game_panel_controls[GAME_PANEL_KEY_WHITE_COUNT].value = 0;
2280 if (game.centered_player_nr == -1)
2282 for (i = 0; i < MAX_PLAYERS; i++)
2284 // only one player in Supaplex game engine
2285 if (level.game_engine_type == GAME_ENGINE_TYPE_SP && i > 0)
2288 for (k = 0; k < MAX_NUM_KEYS; k++)
2290 if (level.game_engine_type == GAME_ENGINE_TYPE_EM)
2292 if (game_em.ply[i]->keys & (1 << k))
2293 game_panel_controls[GAME_PANEL_KEY_1 + k].value =
2294 get_key_element_from_nr(k);
2296 else if (stored_player[i].key[k])
2297 game_panel_controls[GAME_PANEL_KEY_1 + k].value =
2298 get_key_element_from_nr(k);
2301 game_panel_controls[GAME_PANEL_INVENTORY_COUNT].value +=
2302 getPlayerInventorySize(i);
2304 if (stored_player[i].num_white_keys > 0)
2305 game_panel_controls[GAME_PANEL_KEY_WHITE].value =
2308 game_panel_controls[GAME_PANEL_KEY_WHITE_COUNT].value +=
2309 stored_player[i].num_white_keys;
2314 int player_nr = game.centered_player_nr;
2316 for (k = 0; k < MAX_NUM_KEYS; k++)
2318 if (level.game_engine_type == GAME_ENGINE_TYPE_EM)
2320 if (game_em.ply[player_nr]->keys & (1 << k))
2321 game_panel_controls[GAME_PANEL_KEY_1 + k].value =
2322 get_key_element_from_nr(k);
2324 else if (stored_player[player_nr].key[k])
2325 game_panel_controls[GAME_PANEL_KEY_1 + k].value =
2326 get_key_element_from_nr(k);
2329 game_panel_controls[GAME_PANEL_INVENTORY_COUNT].value +=
2330 getPlayerInventorySize(player_nr);
2332 if (stored_player[player_nr].num_white_keys > 0)
2333 game_panel_controls[GAME_PANEL_KEY_WHITE].value = EL_DC_KEY_WHITE;
2335 game_panel_controls[GAME_PANEL_KEY_WHITE_COUNT].value +=
2336 stored_player[player_nr].num_white_keys;
2339 // re-arrange keys on game panel, if needed or if defined by style settings
2340 for (i = 0; i < MAX_NUM_KEYS + 1; i++) // all normal keys + white key
2342 int nr = GAME_PANEL_KEY_1 + i;
2343 struct GamePanelControlInfo *gpc = &game_panel_controls[nr];
2344 struct TextPosInfo *pos = gpc->pos;
2346 // skip check if key is not in the player's inventory
2347 if (gpc->value == EL_EMPTY)
2350 // check if keys should be arranged on panel from left to right
2351 if (pos->style == STYLE_LEFTMOST_POSITION)
2353 // check previous key positions (left from current key)
2354 for (k = 0; k < i; k++)
2356 int nr_new = GAME_PANEL_KEY_1 + k;
2358 if (game_panel_controls[nr_new].value == EL_EMPTY)
2360 game_panel_controls[nr_new].value = gpc->value;
2361 gpc->value = EL_EMPTY;
2368 // check if "undefined" keys can be placed at some other position
2369 if (pos->x == -1 && pos->y == -1)
2371 int nr_new = GAME_PANEL_KEY_1 + i % STD_NUM_KEYS;
2373 // 1st try: display key at the same position as normal or EM keys
2374 if (game_panel_controls[nr_new].value == EL_EMPTY)
2376 game_panel_controls[nr_new].value = gpc->value;
2380 // 2nd try: display key at the next free position in the key panel
2381 for (k = 0; k < STD_NUM_KEYS; k++)
2383 nr_new = GAME_PANEL_KEY_1 + k;
2385 if (game_panel_controls[nr_new].value == EL_EMPTY)
2387 game_panel_controls[nr_new].value = gpc->value;
2396 for (i = 0; i < NUM_PANEL_INVENTORY; i++)
2398 game_panel_controls[GAME_PANEL_INVENTORY_FIRST_1 + i].value =
2399 get_inventory_element_from_pos(local_player, i);
2400 game_panel_controls[GAME_PANEL_INVENTORY_LAST_1 + i].value =
2401 get_inventory_element_from_pos(local_player, -i - 1);
2404 game_panel_controls[GAME_PANEL_SCORE].value = score;
2405 game_panel_controls[GAME_PANEL_HIGHSCORE].value = scores.entry[0].score;
2407 game_panel_controls[GAME_PANEL_TIME].value = time;
2409 game_panel_controls[GAME_PANEL_TIME_HH].value = time / 3600;
2410 game_panel_controls[GAME_PANEL_TIME_MM].value = (time / 60) % 60;
2411 game_panel_controls[GAME_PANEL_TIME_SS].value = time % 60;
2413 if (level.time == 0)
2414 game_panel_controls[GAME_PANEL_TIME_ANIM].value = 100;
2416 game_panel_controls[GAME_PANEL_TIME_ANIM].value = time * 100 / level.time;
2418 game_panel_controls[GAME_PANEL_HEALTH].value = health;
2419 game_panel_controls[GAME_PANEL_HEALTH_ANIM].value = health;
2421 game_panel_controls[GAME_PANEL_FRAME].value = FrameCounter;
2423 game_panel_controls[GAME_PANEL_SHIELD_NORMAL].value =
2424 (local_player->shield_normal_time_left > 0 ? EL_SHIELD_NORMAL_ACTIVE :
2426 game_panel_controls[GAME_PANEL_SHIELD_NORMAL_TIME].value =
2427 local_player->shield_normal_time_left;
2428 game_panel_controls[GAME_PANEL_SHIELD_DEADLY].value =
2429 (local_player->shield_deadly_time_left > 0 ? EL_SHIELD_DEADLY_ACTIVE :
2431 game_panel_controls[GAME_PANEL_SHIELD_DEADLY_TIME].value =
2432 local_player->shield_deadly_time_left;
2434 game_panel_controls[GAME_PANEL_EXIT].value =
2435 (exit_closed ? EL_EXIT_CLOSED : EL_EXIT_OPEN);
2437 game_panel_controls[GAME_PANEL_EMC_MAGIC_BALL].value =
2438 (game.ball_active ? EL_EMC_MAGIC_BALL_ACTIVE : EL_EMC_MAGIC_BALL);
2439 game_panel_controls[GAME_PANEL_EMC_MAGIC_BALL_SWITCH].value =
2440 (game.ball_active ? EL_EMC_MAGIC_BALL_SWITCH_ACTIVE :
2441 EL_EMC_MAGIC_BALL_SWITCH);
2443 game_panel_controls[GAME_PANEL_LIGHT_SWITCH].value =
2444 (game.light_time_left > 0 ? EL_LIGHT_SWITCH_ACTIVE : EL_LIGHT_SWITCH);
2445 game_panel_controls[GAME_PANEL_LIGHT_SWITCH_TIME].value =
2446 game.light_time_left;
2448 game_panel_controls[GAME_PANEL_TIMEGATE_SWITCH].value =
2449 (game.timegate_time_left > 0 ? EL_TIMEGATE_OPEN : EL_TIMEGATE_CLOSED);
2450 game_panel_controls[GAME_PANEL_TIMEGATE_SWITCH_TIME].value =
2451 game.timegate_time_left;
2453 game_panel_controls[GAME_PANEL_SWITCHGATE_SWITCH].value =
2454 EL_SWITCHGATE_SWITCH_UP + game.switchgate_pos;
2456 game_panel_controls[GAME_PANEL_EMC_LENSES].value =
2457 (game.lenses_time_left > 0 ? EL_EMC_LENSES : EL_EMPTY);
2458 game_panel_controls[GAME_PANEL_EMC_LENSES_TIME].value =
2459 game.lenses_time_left;
2461 game_panel_controls[GAME_PANEL_EMC_MAGNIFIER].value =
2462 (game.magnify_time_left > 0 ? EL_EMC_MAGNIFIER : EL_EMPTY);
2463 game_panel_controls[GAME_PANEL_EMC_MAGNIFIER_TIME].value =
2464 game.magnify_time_left;
2466 game_panel_controls[GAME_PANEL_BALLOON_SWITCH].value =
2467 (game.wind_direction == MV_LEFT ? EL_BALLOON_SWITCH_LEFT :
2468 game.wind_direction == MV_RIGHT ? EL_BALLOON_SWITCH_RIGHT :
2469 game.wind_direction == MV_UP ? EL_BALLOON_SWITCH_UP :
2470 game.wind_direction == MV_DOWN ? EL_BALLOON_SWITCH_DOWN :
2471 EL_BALLOON_SWITCH_NONE);
2473 game_panel_controls[GAME_PANEL_DYNABOMB_NUMBER].value =
2474 local_player->dynabomb_count;
2475 game_panel_controls[GAME_PANEL_DYNABOMB_SIZE].value =
2476 local_player->dynabomb_size;
2477 game_panel_controls[GAME_PANEL_DYNABOMB_POWER].value =
2478 (local_player->dynabomb_xl ? EL_DYNABOMB_INCREASE_POWER : EL_EMPTY);
2480 game_panel_controls[GAME_PANEL_PENGUINS].value =
2481 game.friends_still_needed;
2483 game_panel_controls[GAME_PANEL_SOKOBAN_OBJECTS].value =
2484 game.sokoban_objects_still_needed;
2485 game_panel_controls[GAME_PANEL_SOKOBAN_FIELDS].value =
2486 game.sokoban_fields_still_needed;
2488 game_panel_controls[GAME_PANEL_ROBOT_WHEEL].value =
2489 (game.robot_wheel_active ? EL_ROBOT_WHEEL_ACTIVE : EL_ROBOT_WHEEL);
2491 for (i = 0; i < NUM_BELTS; i++)
2493 game_panel_controls[GAME_PANEL_CONVEYOR_BELT_1 + i].value =
2494 (game.belt_dir[i] != MV_NONE ? EL_CONVEYOR_BELT_1_MIDDLE_ACTIVE :
2495 EL_CONVEYOR_BELT_1_MIDDLE) + i;
2496 game_panel_controls[GAME_PANEL_CONVEYOR_BELT_1_SWITCH + i].value =
2497 getBeltSwitchElementFromBeltNrAndBeltDir(i, game.belt_dir[i]);
2500 game_panel_controls[GAME_PANEL_MAGIC_WALL].value =
2501 (game.magic_wall_active ? EL_MAGIC_WALL_ACTIVE : EL_MAGIC_WALL);
2502 game_panel_controls[GAME_PANEL_MAGIC_WALL_TIME].value =
2503 game.magic_wall_time_left;
2505 game_panel_controls[GAME_PANEL_GRAVITY_STATE].value =
2506 local_player->gravity;
2508 for (i = 0; i < NUM_PANEL_GRAPHICS; i++)
2509 game_panel_controls[GAME_PANEL_GRAPHIC_1 + i].value = EL_GRAPHIC_1 + i;
2511 for (i = 0; i < NUM_PANEL_ELEMENTS; i++)
2512 game_panel_controls[GAME_PANEL_ELEMENT_1 + i].value =
2513 (IS_DRAWABLE_ELEMENT(game.panel.element[i].id) ?
2514 game.panel.element[i].id : EL_UNDEFINED);
2516 for (i = 0; i < NUM_PANEL_ELEMENTS; i++)
2517 game_panel_controls[GAME_PANEL_ELEMENT_COUNT_1 + i].value =
2518 (IS_VALID_ELEMENT(game.panel.element_count[i].id) ?
2519 element_info[game.panel.element_count[i].id].element_count : 0);
2521 for (i = 0; i < NUM_PANEL_CE_SCORE; i++)
2522 game_panel_controls[GAME_PANEL_CE_SCORE_1 + i].value =
2523 (IS_CUSTOM_ELEMENT(game.panel.ce_score[i].id) ?
2524 element_info[game.panel.ce_score[i].id].collect_score : 0);
2526 for (i = 0; i < NUM_PANEL_CE_SCORE; i++)
2527 game_panel_controls[GAME_PANEL_CE_SCORE_1_ELEMENT + i].value =
2528 (IS_CUSTOM_ELEMENT(game.panel.ce_score_element[i].id) ?
2529 element_info[game.panel.ce_score_element[i].id].collect_score :
2532 game_panel_controls[GAME_PANEL_PLAYER_NAME].value = 0;
2533 game_panel_controls[GAME_PANEL_LEVEL_NAME].value = 0;
2534 game_panel_controls[GAME_PANEL_LEVEL_AUTHOR].value = 0;
2536 // update game panel control frames
2538 for (i = 0; game_panel_controls[i].nr != -1; i++)
2540 struct GamePanelControlInfo *gpc = &game_panel_controls[i];
2542 if (gpc->type == TYPE_ELEMENT)
2544 if (gpc->value != EL_UNDEFINED && gpc->value != EL_EMPTY)
2546 int last_anim_random_frame = gfx.anim_random_frame;
2547 int element = gpc->value;
2548 int graphic = el2panelimg(element);
2549 int init_gfx_random = (graphic_info[graphic].anim_global_sync ?
2550 sync_random_frame : INIT_GFX_RANDOM());
2552 if (gpc->value != gpc->last_value)
2555 gpc->gfx_random = init_gfx_random;
2561 if (ANIM_MODE(graphic) == ANIM_RANDOM &&
2562 IS_NEXT_FRAME(gpc->gfx_frame, graphic))
2563 gpc->gfx_random = init_gfx_random;
2566 if (ANIM_MODE(graphic) == ANIM_RANDOM)
2567 gfx.anim_random_frame = gpc->gfx_random;
2569 if (ANIM_MODE(graphic) == ANIM_CE_SCORE)
2570 gpc->gfx_frame = element_info[element].collect_score;
2572 gpc->frame = getGraphicAnimationFrame(graphic, gpc->gfx_frame);
2574 if (ANIM_MODE(graphic) == ANIM_RANDOM)
2575 gfx.anim_random_frame = last_anim_random_frame;
2578 else if (gpc->type == TYPE_GRAPHIC)
2580 if (gpc->graphic != IMG_UNDEFINED)
2582 int last_anim_random_frame = gfx.anim_random_frame;
2583 int graphic = gpc->graphic;
2584 int init_gfx_random = (graphic_info[graphic].anim_global_sync ?
2585 sync_random_frame : INIT_GFX_RANDOM());
2587 if (gpc->value != gpc->last_value)
2590 gpc->gfx_random = init_gfx_random;
2596 if (ANIM_MODE(graphic) == ANIM_RANDOM &&
2597 IS_NEXT_FRAME(gpc->gfx_frame, graphic))
2598 gpc->gfx_random = init_gfx_random;
2601 if (ANIM_MODE(graphic) == ANIM_RANDOM)
2602 gfx.anim_random_frame = gpc->gfx_random;
2604 gpc->frame = getGraphicAnimationFrame(graphic, gpc->gfx_frame);
2606 if (ANIM_MODE(graphic) == ANIM_RANDOM)
2607 gfx.anim_random_frame = last_anim_random_frame;
2613 static void DisplayGameControlValues(void)
2615 boolean redraw_panel = FALSE;
2618 for (i = 0; game_panel_controls[i].nr != -1; i++)
2620 struct GamePanelControlInfo *gpc = &game_panel_controls[i];
2622 if (PANEL_DEACTIVATED(gpc->pos))
2625 if (gpc->value == gpc->last_value &&
2626 gpc->frame == gpc->last_frame)
2629 redraw_panel = TRUE;
2635 // copy default game door content to main double buffer
2637 // !!! CHECK AGAIN !!!
2638 SetPanelBackground();
2639 // SetDoorBackgroundImage(IMG_BACKGROUND_PANEL);
2640 DrawBackground(DX, DY, DXSIZE, DYSIZE);
2642 // redraw game control buttons
2643 RedrawGameButtons();
2645 SetGameStatus(GAME_MODE_PSEUDO_PANEL);
2647 for (i = 0; i < NUM_GAME_PANEL_CONTROLS; i++)
2649 int nr = game_panel_order[i].nr;
2650 struct GamePanelControlInfo *gpc = &game_panel_controls[nr];
2651 struct TextPosInfo *pos = gpc->pos;
2652 int type = gpc->type;
2653 int value = gpc->value;
2654 int frame = gpc->frame;
2655 int size = pos->size;
2656 int font = pos->font;
2657 boolean draw_masked = pos->draw_masked;
2658 int mask_mode = (draw_masked ? BLIT_MASKED : BLIT_OPAQUE);
2660 if (PANEL_DEACTIVATED(pos))
2663 if (pos->class == get_hash_from_key("extra_panel_items") &&
2664 !setup.prefer_extra_panel_items)
2667 gpc->last_value = value;
2668 gpc->last_frame = frame;
2670 if (type == TYPE_INTEGER)
2672 if (nr == GAME_PANEL_LEVEL_NUMBER ||
2673 nr == GAME_PANEL_TIME)
2675 boolean use_dynamic_size = (size == -1 ? TRUE : FALSE);
2677 if (use_dynamic_size) // use dynamic number of digits
2679 int value_change = (nr == GAME_PANEL_LEVEL_NUMBER ? 100 : 1000);
2680 int size1 = (nr == GAME_PANEL_LEVEL_NUMBER ? 2 : 3);
2681 int size2 = size1 + 1;
2682 int font1 = pos->font;
2683 int font2 = pos->font_alt;
2685 size = (value < value_change ? size1 : size2);
2686 font = (value < value_change ? font1 : font2);
2690 // correct text size if "digits" is zero or less
2692 size = strlen(int2str(value, size));
2694 // dynamically correct text alignment
2695 pos->width = size * getFontWidth(font);
2697 DrawTextExt(drawto, PANEL_XPOS(pos), PANEL_YPOS(pos),
2698 int2str(value, size), font, mask_mode);
2700 else if (type == TYPE_ELEMENT)
2702 int element, graphic;
2706 int dst_x = PANEL_XPOS(pos);
2707 int dst_y = PANEL_YPOS(pos);
2709 if (value != EL_UNDEFINED && value != EL_EMPTY)
2712 graphic = el2panelimg(value);
2715 Debug("game:DisplayGameControlValues", "%d, '%s' [%d]",
2716 element, EL_NAME(element), size);
2719 if (element >= EL_GRAPHIC_1 && element <= EL_GRAPHIC_8 && size == 0)
2722 getSizedGraphicSource(graphic, frame, size, &src_bitmap,
2725 width = graphic_info[graphic].width * size / TILESIZE;
2726 height = graphic_info[graphic].height * size / TILESIZE;
2729 BlitBitmapMasked(src_bitmap, drawto, src_x, src_y, width, height,
2732 BlitBitmap(src_bitmap, drawto, src_x, src_y, width, height,
2736 else if (type == TYPE_GRAPHIC)
2738 int graphic = gpc->graphic;
2739 int graphic_active = gpc->graphic_active;
2743 int dst_x = PANEL_XPOS(pos);
2744 int dst_y = PANEL_YPOS(pos);
2745 boolean skip = (pos->class == get_hash_from_key("mm_engine_only") &&
2746 level.game_engine_type != GAME_ENGINE_TYPE_MM);
2748 if (graphic != IMG_UNDEFINED && !skip)
2750 if (pos->style == STYLE_REVERSE)
2751 value = 100 - value;
2753 getGraphicSource(graphic_active, frame, &src_bitmap, &src_x, &src_y);
2755 if (pos->direction & MV_HORIZONTAL)
2757 width = graphic_info[graphic_active].width * value / 100;
2758 height = graphic_info[graphic_active].height;
2760 if (pos->direction == MV_LEFT)
2762 src_x += graphic_info[graphic_active].width - width;
2763 dst_x += graphic_info[graphic_active].width - width;
2768 width = graphic_info[graphic_active].width;
2769 height = graphic_info[graphic_active].height * value / 100;
2771 if (pos->direction == MV_UP)
2773 src_y += graphic_info[graphic_active].height - height;
2774 dst_y += graphic_info[graphic_active].height - height;
2779 BlitBitmapMasked(src_bitmap, drawto, src_x, src_y, width, height,
2782 BlitBitmap(src_bitmap, drawto, src_x, src_y, width, height,
2785 getGraphicSource(graphic, frame, &src_bitmap, &src_x, &src_y);
2787 if (pos->direction & MV_HORIZONTAL)
2789 if (pos->direction == MV_RIGHT)
2796 dst_x = PANEL_XPOS(pos);
2799 width = graphic_info[graphic].width - width;
2803 if (pos->direction == MV_DOWN)
2810 dst_y = PANEL_YPOS(pos);
2813 height = graphic_info[graphic].height - height;
2817 BlitBitmapMasked(src_bitmap, drawto, src_x, src_y, width, height,
2820 BlitBitmap(src_bitmap, drawto, src_x, src_y, width, height,
2824 else if (type == TYPE_STRING)
2826 boolean active = (value != 0);
2827 char *state_normal = "off";
2828 char *state_active = "on";
2829 char *state = (active ? state_active : state_normal);
2830 char *s = (nr == GAME_PANEL_GRAVITY_STATE ? state :
2831 nr == GAME_PANEL_PLAYER_NAME ? setup.player_name :
2832 nr == GAME_PANEL_LEVEL_NAME ? level.name :
2833 nr == GAME_PANEL_LEVEL_AUTHOR ? level.author : NULL);
2835 if (nr == GAME_PANEL_GRAVITY_STATE)
2837 int font1 = pos->font; // (used for normal state)
2838 int font2 = pos->font_alt; // (used for active state)
2840 font = (active ? font2 : font1);
2849 // don't truncate output if "chars" is zero or less
2852 // dynamically correct text alignment
2853 pos->width = size * getFontWidth(font);
2856 s_cut = getStringCopyN(s, size);
2858 DrawTextExt(drawto, PANEL_XPOS(pos), PANEL_YPOS(pos),
2859 s_cut, font, mask_mode);
2865 redraw_mask |= REDRAW_DOOR_1;
2868 SetGameStatus(GAME_MODE_PLAYING);
2871 void UpdateAndDisplayGameControlValues(void)
2873 if (tape.deactivate_display)
2876 UpdateGameControlValues();
2877 DisplayGameControlValues();
2880 void UpdateGameDoorValues(void)
2882 UpdateGameControlValues();
2885 void DrawGameDoorValues(void)
2887 DisplayGameControlValues();
2891 // ============================================================================
2893 // ----------------------------------------------------------------------------
2894 // initialize game engine due to level / tape version number
2895 // ============================================================================
2897 static void InitGameEngine(void)
2899 int i, j, k, l, x, y;
2901 // set game engine from tape file when re-playing, else from level file
2902 game.engine_version = (tape.playing ? tape.engine_version :
2903 level.game_version);
2905 // set single or multi-player game mode (needed for re-playing tapes)
2906 game.team_mode = setup.team_mode;
2910 int num_players = 0;
2912 for (i = 0; i < MAX_PLAYERS; i++)
2913 if (tape.player_participates[i])
2916 // multi-player tapes contain input data for more than one player
2917 game.team_mode = (num_players > 1);
2921 Debug("game:init:level", "level %d: level.game_version == %06d", level_nr,
2922 level.game_version);
2923 Debug("game:init:level", " tape.file_version == %06d",
2925 Debug("game:init:level", " tape.game_version == %06d",
2927 Debug("game:init:level", " tape.engine_version == %06d",
2928 tape.engine_version);
2929 Debug("game:init:level", " => game.engine_version == %06d [tape mode: %s]",
2930 game.engine_version, (tape.playing ? "PLAYING" : "RECORDING"));
2933 // --------------------------------------------------------------------------
2934 // set flags for bugs and changes according to active game engine version
2935 // --------------------------------------------------------------------------
2939 Fixed property "can fall" for run-time element "EL_AMOEBA_DROPPING"
2941 Bug was introduced in version:
2944 Bug was fixed in version:
2948 In version 2.0.1, a new run-time element "EL_AMOEBA_DROPPING" was added,
2949 but the property "can fall" was missing, which caused some levels to be
2950 unsolvable. This was fixed in version 4.2.0.0.
2952 Affected levels/tapes:
2953 An example for a tape that was fixed by this bugfix is tape 029 from the
2954 level set "rnd_sam_bateman".
2955 The wrong behaviour will still be used for all levels or tapes that were
2956 created/recorded with it. An example for this is tape 023 from the level
2957 set "rnd_gerhard_haeusler", which was recorded with a buggy game engine.
2960 boolean use_amoeba_dropping_cannot_fall_bug =
2961 ((game.engine_version >= VERSION_IDENT(2,0,1,0) &&
2962 game.engine_version < VERSION_IDENT(4,2,0,0)) ||
2964 tape.game_version >= VERSION_IDENT(2,0,1,0) &&
2965 tape.game_version < VERSION_IDENT(4,2,0,0)));
2968 Summary of bugfix/change:
2969 Fixed move speed of elements entering or leaving magic wall.
2971 Fixed/changed in version:
2975 Before 2.0.1, move speed of elements entering or leaving magic wall was
2976 twice as fast as it is now.
2977 Since 2.0.1, this is set to a lower value by using move_stepsize_list[].
2979 Affected levels/tapes:
2980 The first condition is generally needed for all levels/tapes before version
2981 2.0.1, which might use the old behaviour before it was changed; known tapes
2982 that are affected: Tape 014 from the level set "rnd_conor_mancone".
2983 The second condition is an exception from the above case and is needed for
2984 the special case of tapes recorded with game (not engine!) version 2.0.1 or
2985 above, but before it was known that this change would break tapes like the
2986 above and was fixed in 4.2.0.0, so that the changed behaviour was active
2987 although the engine version while recording maybe was before 2.0.1. There
2988 are a lot of tapes that are affected by this exception, like tape 006 from
2989 the level set "rnd_conor_mancone".
2992 boolean use_old_move_stepsize_for_magic_wall =
2993 (game.engine_version < VERSION_IDENT(2,0,1,0) &&
2995 tape.game_version >= VERSION_IDENT(2,0,1,0) &&
2996 tape.game_version < VERSION_IDENT(4,2,0,0)));
2999 Summary of bugfix/change:
3000 Fixed handling for custom elements that change when pushed by the player.
3002 Fixed/changed in version:
3006 Before 3.1.0, custom elements that "change when pushing" changed directly
3007 after the player started pushing them (until then handled in "DigField()").
3008 Since 3.1.0, these custom elements are not changed until the "pushing"
3009 move of the element is finished (now handled in "ContinueMoving()").
3011 Affected levels/tapes:
3012 The first condition is generally needed for all levels/tapes before version
3013 3.1.0, which might use the old behaviour before it was changed; known tapes
3014 that are affected are some tapes from the level set "Walpurgis Gardens" by
3016 The second condition is an exception from the above case and is needed for
3017 the special case of tapes recorded with game (not engine!) version 3.1.0 or
3018 above (including some development versions of 3.1.0), but before it was
3019 known that this change would break tapes like the above and was fixed in
3020 3.1.1, so that the changed behaviour was active although the engine version
3021 while recording maybe was before 3.1.0. There is at least one tape that is
3022 affected by this exception, which is the tape for the one-level set "Bug
3023 Machine" by Juergen Bonhagen.
3026 game.use_change_when_pushing_bug =
3027 (game.engine_version < VERSION_IDENT(3,1,0,0) &&
3029 tape.game_version >= VERSION_IDENT(3,1,0,0) &&
3030 tape.game_version < VERSION_IDENT(3,1,1,0)));
3033 Summary of bugfix/change:
3034 Fixed handling for blocking the field the player leaves when moving.
3036 Fixed/changed in version:
3040 Before 3.1.1, when "block last field when moving" was enabled, the field
3041 the player is leaving when moving was blocked for the time of the move,
3042 and was directly unblocked afterwards. This resulted in the last field
3043 being blocked for exactly one less than the number of frames of one player
3044 move. Additionally, even when blocking was disabled, the last field was
3045 blocked for exactly one frame.
3046 Since 3.1.1, due to changes in player movement handling, the last field
3047 is not blocked at all when blocking is disabled. When blocking is enabled,
3048 the last field is blocked for exactly the number of frames of one player
3049 move. Additionally, if the player is Murphy, the hero of Supaplex, the
3050 last field is blocked for exactly one more than the number of frames of
3053 Affected levels/tapes:
3054 (!!! yet to be determined -- probably many !!!)
3057 game.use_block_last_field_bug =
3058 (game.engine_version < VERSION_IDENT(3,1,1,0));
3060 /* various special flags and settings for native Emerald Mine game engine */
3062 game_em.use_single_button =
3063 (game.engine_version > VERSION_IDENT(4,0,0,2));
3065 game_em.use_snap_key_bug =
3066 (game.engine_version < VERSION_IDENT(4,0,1,0));
3068 game_em.use_random_bug =
3069 (tape.property_bits & TAPE_PROPERTY_EM_RANDOM_BUG);
3071 boolean use_old_em_engine = (game.engine_version < VERSION_IDENT(4,2,0,0));
3073 game_em.use_old_explosions = use_old_em_engine;
3074 game_em.use_old_android = use_old_em_engine;
3075 game_em.use_old_push_elements = use_old_em_engine;
3076 game_em.use_old_push_into_acid = use_old_em_engine;
3078 game_em.use_wrap_around = !use_old_em_engine;
3080 // --------------------------------------------------------------------------
3082 // set maximal allowed number of custom element changes per game frame
3083 game.max_num_changes_per_frame = 1;
3085 // default scan direction: scan playfield from top/left to bottom/right
3086 InitPlayfieldScanMode(CA_ARG_SCAN_MODE_NORMAL);
3088 // dynamically adjust element properties according to game engine version
3089 InitElementPropertiesEngine(game.engine_version);
3091 // ---------- initialize special element properties -------------------------
3093 // "EL_AMOEBA_DROPPING" missed property "can fall" in older game versions
3094 if (use_amoeba_dropping_cannot_fall_bug)
3095 SET_PROPERTY(EL_AMOEBA_DROPPING, EP_CAN_FALL, FALSE);
3097 // ---------- initialize player's initial move delay ------------------------
3099 // dynamically adjust player properties according to level information
3100 for (i = 0; i < MAX_PLAYERS; i++)
3101 game.initial_move_delay_value[i] =
3102 get_move_delay_from_stepsize(level.initial_player_stepsize[i]);
3104 // dynamically adjust player properties according to game engine version
3105 for (i = 0; i < MAX_PLAYERS; i++)
3106 game.initial_move_delay[i] =
3107 (game.engine_version <= VERSION_IDENT(2,0,1,0) ?
3108 game.initial_move_delay_value[i] : 0);
3110 // ---------- initialize player's initial push delay ------------------------
3112 // dynamically adjust player properties according to game engine version
3113 game.initial_push_delay_value =
3114 (game.engine_version < VERSION_IDENT(3,0,7,1) ? 5 : -1);
3116 // ---------- initialize changing elements ----------------------------------
3118 // initialize changing elements information
3119 for (i = 0; i < MAX_NUM_ELEMENTS; i++)
3121 struct ElementInfo *ei = &element_info[i];
3123 // this pointer might have been changed in the level editor
3124 ei->change = &ei->change_page[0];
3126 if (!IS_CUSTOM_ELEMENT(i))
3128 ei->change->target_element = EL_EMPTY_SPACE;
3129 ei->change->delay_fixed = 0;
3130 ei->change->delay_random = 0;
3131 ei->change->delay_frames = 1;
3134 for (j = 0; j < NUM_CHANGE_EVENTS; j++)
3136 ei->has_change_event[j] = FALSE;
3138 ei->event_page_nr[j] = 0;
3139 ei->event_page[j] = &ei->change_page[0];
3143 // add changing elements from pre-defined list
3144 for (i = 0; change_delay_list[i].element != EL_UNDEFINED; i++)
3146 struct ChangingElementInfo *ch_delay = &change_delay_list[i];
3147 struct ElementInfo *ei = &element_info[ch_delay->element];
3149 ei->change->target_element = ch_delay->target_element;
3150 ei->change->delay_fixed = ch_delay->change_delay;
3152 ei->change->pre_change_function = ch_delay->pre_change_function;
3153 ei->change->change_function = ch_delay->change_function;
3154 ei->change->post_change_function = ch_delay->post_change_function;
3156 ei->change->can_change = TRUE;
3157 ei->change->can_change_or_has_action = TRUE;
3159 ei->has_change_event[CE_DELAY] = TRUE;
3161 SET_PROPERTY(ch_delay->element, EP_CAN_CHANGE, TRUE);
3162 SET_PROPERTY(ch_delay->element, EP_CAN_CHANGE_OR_HAS_ACTION, TRUE);
3165 // ---------- initialize internal run-time variables ------------------------
3167 for (i = 0; i < NUM_CUSTOM_ELEMENTS; i++)
3169 struct ElementInfo *ei = &element_info[EL_CUSTOM_START + i];
3171 for (j = 0; j < ei->num_change_pages; j++)
3173 ei->change_page[j].can_change_or_has_action =
3174 (ei->change_page[j].can_change |
3175 ei->change_page[j].has_action);
3179 // add change events from custom element configuration
3180 for (i = 0; i < NUM_CUSTOM_ELEMENTS; i++)
3182 struct ElementInfo *ei = &element_info[EL_CUSTOM_START + i];
3184 for (j = 0; j < ei->num_change_pages; j++)
3186 if (!ei->change_page[j].can_change_or_has_action)
3189 for (k = 0; k < NUM_CHANGE_EVENTS; k++)
3191 // only add event page for the first page found with this event
3192 if (ei->change_page[j].has_event[k] && !(ei->has_change_event[k]))
3194 ei->has_change_event[k] = TRUE;
3196 ei->event_page_nr[k] = j;
3197 ei->event_page[k] = &ei->change_page[j];
3203 // ---------- initialize reference elements in change conditions ------------
3205 for (i = 0; i < NUM_CUSTOM_ELEMENTS; i++)
3207 int element = EL_CUSTOM_START + i;
3208 struct ElementInfo *ei = &element_info[element];
3210 for (j = 0; j < ei->num_change_pages; j++)
3212 int trigger_element = ei->change_page[j].initial_trigger_element;
3214 if (trigger_element >= EL_PREV_CE_8 &&
3215 trigger_element <= EL_NEXT_CE_8)
3216 trigger_element = RESOLVED_REFERENCE_ELEMENT(element, trigger_element);
3218 ei->change_page[j].trigger_element = trigger_element;
3222 // ---------- initialize run-time trigger player and element ----------------
3224 for (i = 0; i < NUM_CUSTOM_ELEMENTS; i++)
3226 struct ElementInfo *ei = &element_info[EL_CUSTOM_START + i];
3228 for (j = 0; j < ei->num_change_pages; j++)
3230 ei->change_page[j].actual_trigger_element = EL_EMPTY;
3231 ei->change_page[j].actual_trigger_player = EL_EMPTY;
3232 ei->change_page[j].actual_trigger_player_bits = CH_PLAYER_NONE;
3233 ei->change_page[j].actual_trigger_side = CH_SIDE_NONE;
3234 ei->change_page[j].actual_trigger_ce_value = 0;
3235 ei->change_page[j].actual_trigger_ce_score = 0;
3239 // ---------- initialize trigger events -------------------------------------
3241 // initialize trigger events information
3242 for (i = 0; i < MAX_NUM_ELEMENTS; i++)
3243 for (j = 0; j < NUM_CHANGE_EVENTS; j++)
3244 trigger_events[i][j] = FALSE;
3246 // add trigger events from element change event properties
3247 for (i = 0; i < MAX_NUM_ELEMENTS; i++)
3249 struct ElementInfo *ei = &element_info[i];
3251 for (j = 0; j < ei->num_change_pages; j++)
3253 if (!ei->change_page[j].can_change_or_has_action)
3256 if (ei->change_page[j].has_event[CE_BY_OTHER_ACTION])
3258 int trigger_element = ei->change_page[j].trigger_element;
3260 for (k = 0; k < NUM_CHANGE_EVENTS; k++)
3262 if (ei->change_page[j].has_event[k])
3264 if (IS_GROUP_ELEMENT(trigger_element))
3266 struct ElementGroupInfo *group =
3267 element_info[trigger_element].group;
3269 for (l = 0; l < group->num_elements_resolved; l++)
3270 trigger_events[group->element_resolved[l]][k] = TRUE;
3272 else if (trigger_element == EL_ANY_ELEMENT)
3273 for (l = 0; l < MAX_NUM_ELEMENTS; l++)
3274 trigger_events[l][k] = TRUE;
3276 trigger_events[trigger_element][k] = TRUE;
3283 // ---------- initialize push delay -----------------------------------------
3285 // initialize push delay values to default
3286 for (i = 0; i < MAX_NUM_ELEMENTS; i++)
3288 if (!IS_CUSTOM_ELEMENT(i))
3290 // set default push delay values (corrected since version 3.0.7-1)
3291 if (game.engine_version < VERSION_IDENT(3,0,7,1))
3293 element_info[i].push_delay_fixed = 2;
3294 element_info[i].push_delay_random = 8;
3298 element_info[i].push_delay_fixed = 8;
3299 element_info[i].push_delay_random = 8;
3304 // set push delay value for certain elements from pre-defined list
3305 for (i = 0; push_delay_list[i].element != EL_UNDEFINED; i++)
3307 int e = push_delay_list[i].element;
3309 element_info[e].push_delay_fixed = push_delay_list[i].push_delay_fixed;
3310 element_info[e].push_delay_random = push_delay_list[i].push_delay_random;
3313 // set push delay value for Supaplex elements for newer engine versions
3314 if (game.engine_version >= VERSION_IDENT(3,1,0,0))
3316 for (i = 0; i < MAX_NUM_ELEMENTS; i++)
3318 if (IS_SP_ELEMENT(i))
3320 // set SP push delay to just enough to push under a falling zonk
3321 int delay = (game.engine_version >= VERSION_IDENT(3,1,1,0) ? 8 : 6);
3323 element_info[i].push_delay_fixed = delay;
3324 element_info[i].push_delay_random = 0;
3329 // ---------- initialize move stepsize --------------------------------------
3331 // initialize move stepsize values to default
3332 for (i = 0; i < MAX_NUM_ELEMENTS; i++)
3333 if (!IS_CUSTOM_ELEMENT(i))
3334 element_info[i].move_stepsize = MOVE_STEPSIZE_NORMAL;
3336 // set move stepsize value for certain elements from pre-defined list
3337 for (i = 0; move_stepsize_list[i].element != EL_UNDEFINED; i++)
3339 int e = move_stepsize_list[i].element;
3341 element_info[e].move_stepsize = move_stepsize_list[i].move_stepsize;
3343 // set move stepsize value for certain elements for older engine versions
3344 if (use_old_move_stepsize_for_magic_wall)
3346 if (e == EL_MAGIC_WALL_FILLING ||
3347 e == EL_MAGIC_WALL_EMPTYING ||
3348 e == EL_BD_MAGIC_WALL_FILLING ||
3349 e == EL_BD_MAGIC_WALL_EMPTYING)
3350 element_info[e].move_stepsize *= 2;
3354 // ---------- initialize collect score --------------------------------------
3356 // initialize collect score values for custom elements from initial value
3357 for (i = 0; i < MAX_NUM_ELEMENTS; i++)
3358 if (IS_CUSTOM_ELEMENT(i))
3359 element_info[i].collect_score = element_info[i].collect_score_initial;
3361 // ---------- initialize collect count --------------------------------------
3363 // initialize collect count values for non-custom elements
3364 for (i = 0; i < MAX_NUM_ELEMENTS; i++)
3365 if (!IS_CUSTOM_ELEMENT(i))
3366 element_info[i].collect_count_initial = 0;
3368 // add collect count values for all elements from pre-defined list
3369 for (i = 0; collect_count_list[i].element != EL_UNDEFINED; i++)
3370 element_info[collect_count_list[i].element].collect_count_initial =
3371 collect_count_list[i].count;
3373 // ---------- initialize access direction -----------------------------------
3375 // initialize access direction values to default (access from every side)
3376 for (i = 0; i < MAX_NUM_ELEMENTS; i++)
3377 if (!IS_CUSTOM_ELEMENT(i))
3378 element_info[i].access_direction = MV_ALL_DIRECTIONS;
3380 // set access direction value for certain elements from pre-defined list
3381 for (i = 0; access_direction_list[i].element != EL_UNDEFINED; i++)
3382 element_info[access_direction_list[i].element].access_direction =
3383 access_direction_list[i].direction;
3385 // ---------- initialize explosion content ----------------------------------
3386 for (i = 0; i < MAX_NUM_ELEMENTS; i++)
3388 if (IS_CUSTOM_ELEMENT(i))
3391 for (y = 0; y < 3; y++) for (x = 0; x < 3; x++)
3393 // (content for EL_YAMYAM set at run-time with game.yamyam_content_nr)
3395 element_info[i].content.e[x][y] =
3396 (i == EL_PLAYER_1 ? EL_EMERALD_YELLOW :
3397 i == EL_PLAYER_2 ? EL_EMERALD_RED :
3398 i == EL_PLAYER_3 ? EL_EMERALD :
3399 i == EL_PLAYER_4 ? EL_EMERALD_PURPLE :
3400 i == EL_MOLE ? EL_EMERALD_RED :
3401 i == EL_PENGUIN ? EL_EMERALD_PURPLE :
3402 i == EL_BUG ? (x == 1 && y == 1 ? EL_DIAMOND : EL_EMERALD) :
3403 i == EL_BD_BUTTERFLY ? EL_BD_DIAMOND :
3404 i == EL_SP_ELECTRON ? EL_SP_INFOTRON :
3405 i == EL_AMOEBA_TO_DIAMOND ? level.amoeba_content :
3406 i == EL_WALL_EMERALD ? EL_EMERALD :
3407 i == EL_WALL_DIAMOND ? EL_DIAMOND :
3408 i == EL_WALL_BD_DIAMOND ? EL_BD_DIAMOND :
3409 i == EL_WALL_EMERALD_YELLOW ? EL_EMERALD_YELLOW :
3410 i == EL_WALL_EMERALD_RED ? EL_EMERALD_RED :
3411 i == EL_WALL_EMERALD_PURPLE ? EL_EMERALD_PURPLE :
3412 i == EL_WALL_PEARL ? EL_PEARL :
3413 i == EL_WALL_CRYSTAL ? EL_CRYSTAL :
3418 // ---------- initialize recursion detection --------------------------------
3419 recursion_loop_depth = 0;
3420 recursion_loop_detected = FALSE;
3421 recursion_loop_element = EL_UNDEFINED;
3423 // ---------- initialize graphics engine ------------------------------------
3424 game.scroll_delay_value =
3425 (game.forced_scroll_delay_value != -1 ? game.forced_scroll_delay_value :
3426 level.game_engine_type == GAME_ENGINE_TYPE_EM &&
3427 !setup.forced_scroll_delay ? 0 :
3428 setup.scroll_delay ? setup.scroll_delay_value : 0);
3429 game.scroll_delay_value =
3430 MIN(MAX(MIN_SCROLL_DELAY, game.scroll_delay_value), MAX_SCROLL_DELAY);
3432 // ---------- initialize game engine snapshots ------------------------------
3433 for (i = 0; i < MAX_PLAYERS; i++)
3434 game.snapshot.last_action[i] = 0;
3435 game.snapshot.changed_action = FALSE;
3436 game.snapshot.collected_item = FALSE;
3437 game.snapshot.mode =
3438 (strEqual(setup.engine_snapshot_mode, STR_SNAPSHOT_MODE_EVERY_STEP) ?
3439 SNAPSHOT_MODE_EVERY_STEP :
3440 strEqual(setup.engine_snapshot_mode, STR_SNAPSHOT_MODE_EVERY_MOVE) ?
3441 SNAPSHOT_MODE_EVERY_MOVE :
3442 strEqual(setup.engine_snapshot_mode, STR_SNAPSHOT_MODE_EVERY_COLLECT) ?
3443 SNAPSHOT_MODE_EVERY_COLLECT : SNAPSHOT_MODE_OFF);
3444 game.snapshot.save_snapshot = FALSE;
3446 // ---------- initialize level time for Supaplex engine ---------------------
3447 // Supaplex levels with time limit currently unsupported -- should be added
3448 if (level.game_engine_type == GAME_ENGINE_TYPE_SP)
3451 // ---------- initialize flags for handling game actions --------------------
3453 // set flags for game actions to default values
3454 game.use_key_actions = TRUE;
3455 game.use_mouse_actions = FALSE;
3457 // when using Mirror Magic game engine, handle mouse events only
3458 if (level.game_engine_type == GAME_ENGINE_TYPE_MM)
3460 game.use_key_actions = FALSE;
3461 game.use_mouse_actions = TRUE;
3464 // check for custom elements with mouse click events
3465 if (level.game_engine_type == GAME_ENGINE_TYPE_RND)
3467 for (i = 0; i < NUM_CUSTOM_ELEMENTS; i++)
3469 int element = EL_CUSTOM_START + i;
3471 if (HAS_CHANGE_EVENT(element, CE_CLICKED_BY_MOUSE) ||
3472 HAS_CHANGE_EVENT(element, CE_PRESSED_BY_MOUSE) ||
3473 HAS_CHANGE_EVENT(element, CE_MOUSE_CLICKED_ON_X) ||
3474 HAS_CHANGE_EVENT(element, CE_MOUSE_PRESSED_ON_X))
3475 game.use_mouse_actions = TRUE;
3480 static int get_num_special_action(int element, int action_first,
3483 int num_special_action = 0;
3486 for (i = action_first; i <= action_last; i++)
3488 boolean found = FALSE;
3490 for (j = 0; j < NUM_DIRECTIONS; j++)
3491 if (el_act_dir2img(element, i, j) !=
3492 el_act_dir2img(element, ACTION_DEFAULT, j))
3496 num_special_action++;
3501 return num_special_action;
3505 // ============================================================================
3507 // ----------------------------------------------------------------------------
3508 // initialize and start new game
3509 // ============================================================================
3511 #if DEBUG_INIT_PLAYER
3512 static void DebugPrintPlayerStatus(char *message)
3519 Debug("game:init:player", "%s:", message);
3521 for (i = 0; i < MAX_PLAYERS; i++)
3523 struct PlayerInfo *player = &stored_player[i];
3525 Debug("game:init:player",
3526 "- player %d: present == %d, connected == %d [%d/%d], active == %d%s",
3530 player->connected_locally,
3531 player->connected_network,
3533 (local_player == player ? " (local player)" : ""));
3540 int full_lev_fieldx = lev_fieldx + (BorderElement != EL_EMPTY ? 2 : 0);
3541 int full_lev_fieldy = lev_fieldy + (BorderElement != EL_EMPTY ? 2 : 0);
3542 int fade_mask = REDRAW_FIELD;
3544 boolean emulate_bd = TRUE; // unless non-BOULDERDASH elements found
3545 boolean emulate_sb = TRUE; // unless non-SOKOBAN elements found
3546 boolean emulate_sp = TRUE; // unless non-SUPAPLEX elements found
3547 int initial_move_dir = MV_DOWN;
3550 // required here to update video display before fading (FIX THIS)
3551 DrawMaskedBorder(REDRAW_DOOR_2);
3553 if (!game.restart_level)
3554 CloseDoor(DOOR_CLOSE_1);
3556 SetGameStatus(GAME_MODE_PLAYING);
3558 if (level_editor_test_game)
3559 FadeSkipNextFadeOut();
3561 FadeSetEnterScreen();
3564 fade_mask = REDRAW_ALL;
3566 FadeLevelSoundsAndMusic();
3568 ExpireSoundLoops(TRUE);
3572 if (level_editor_test_game)
3573 FadeSkipNextFadeIn();
3575 // needed if different viewport properties defined for playing
3576 ChangeViewportPropertiesIfNeeded();
3580 DrawCompleteVideoDisplay();
3582 OpenDoor(GetDoorState() | DOOR_NO_DELAY | DOOR_FORCE_REDRAW);
3585 InitGameControlValues();
3589 // initialize tape actions from game when recording tape
3590 tape.use_key_actions = game.use_key_actions;
3591 tape.use_mouse_actions = game.use_mouse_actions;
3593 // initialize visible playfield size when recording tape (for team mode)
3594 tape.scr_fieldx = SCR_FIELDX;
3595 tape.scr_fieldy = SCR_FIELDY;
3598 // don't play tapes over network
3599 network_playing = (network.enabled && !tape.playing);
3601 for (i = 0; i < MAX_PLAYERS; i++)
3603 struct PlayerInfo *player = &stored_player[i];
3605 player->index_nr = i;
3606 player->index_bit = (1 << i);
3607 player->element_nr = EL_PLAYER_1 + i;
3609 player->present = FALSE;
3610 player->active = FALSE;
3611 player->mapped = FALSE;
3613 player->killed = FALSE;
3614 player->reanimated = FALSE;
3615 player->buried = FALSE;
3618 player->effective_action = 0;
3619 player->programmed_action = 0;
3620 player->snap_action = 0;
3622 player->mouse_action.lx = 0;
3623 player->mouse_action.ly = 0;
3624 player->mouse_action.button = 0;
3625 player->mouse_action.button_hint = 0;
3627 player->effective_mouse_action.lx = 0;
3628 player->effective_mouse_action.ly = 0;
3629 player->effective_mouse_action.button = 0;
3630 player->effective_mouse_action.button_hint = 0;
3632 for (j = 0; j < MAX_NUM_KEYS; j++)
3633 player->key[j] = FALSE;
3635 player->num_white_keys = 0;
3637 player->dynabomb_count = 0;
3638 player->dynabomb_size = 1;
3639 player->dynabombs_left = 0;
3640 player->dynabomb_xl = FALSE;
3642 player->MovDir = initial_move_dir;
3645 player->GfxDir = initial_move_dir;
3646 player->GfxAction = ACTION_DEFAULT;
3648 player->StepFrame = 0;
3650 player->initial_element = player->element_nr;
3651 player->artwork_element =
3652 (level.use_artwork_element[i] ? level.artwork_element[i] :
3653 player->element_nr);
3654 player->use_murphy = FALSE;
3656 player->block_last_field = FALSE; // initialized in InitPlayerField()
3657 player->block_delay_adjustment = 0; // initialized in InitPlayerField()
3659 player->gravity = level.initial_player_gravity[i];
3661 player->can_fall_into_acid = CAN_MOVE_INTO_ACID(player->element_nr);
3663 player->actual_frame_counter = 0;
3665 player->step_counter = 0;
3667 player->last_move_dir = initial_move_dir;
3669 player->is_active = FALSE;
3671 player->is_waiting = FALSE;
3672 player->is_moving = FALSE;
3673 player->is_auto_moving = FALSE;
3674 player->is_digging = FALSE;
3675 player->is_snapping = FALSE;
3676 player->is_collecting = FALSE;
3677 player->is_pushing = FALSE;
3678 player->is_switching = FALSE;
3679 player->is_dropping = FALSE;
3680 player->is_dropping_pressed = FALSE;
3682 player->is_bored = FALSE;
3683 player->is_sleeping = FALSE;
3685 player->was_waiting = TRUE;
3686 player->was_moving = FALSE;
3687 player->was_snapping = FALSE;
3688 player->was_dropping = FALSE;
3690 player->force_dropping = FALSE;
3692 player->frame_counter_bored = -1;
3693 player->frame_counter_sleeping = -1;
3695 player->anim_delay_counter = 0;
3696 player->post_delay_counter = 0;
3698 player->dir_waiting = initial_move_dir;
3699 player->action_waiting = ACTION_DEFAULT;
3700 player->last_action_waiting = ACTION_DEFAULT;
3701 player->special_action_bored = ACTION_DEFAULT;
3702 player->special_action_sleeping = ACTION_DEFAULT;
3704 player->switch_x = -1;
3705 player->switch_y = -1;
3707 player->drop_x = -1;
3708 player->drop_y = -1;
3710 player->show_envelope = 0;
3712 SetPlayerMoveSpeed(player, level.initial_player_stepsize[i], TRUE);
3714 player->push_delay = -1; // initialized when pushing starts
3715 player->push_delay_value = game.initial_push_delay_value;
3717 player->drop_delay = 0;
3718 player->drop_pressed_delay = 0;
3720 player->last_jx = -1;
3721 player->last_jy = -1;
3725 player->shield_normal_time_left = 0;
3726 player->shield_deadly_time_left = 0;
3728 player->last_removed_element = EL_UNDEFINED;
3730 player->inventory_infinite_element = EL_UNDEFINED;
3731 player->inventory_size = 0;
3733 if (level.use_initial_inventory[i])
3735 for (j = 0; j < level.initial_inventory_size[i]; j++)
3737 int element = level.initial_inventory_content[i][j];
3738 int collect_count = element_info[element].collect_count_initial;
3741 if (!IS_CUSTOM_ELEMENT(element))
3744 if (collect_count == 0)
3745 player->inventory_infinite_element = element;
3747 for (k = 0; k < collect_count; k++)
3748 if (player->inventory_size < MAX_INVENTORY_SIZE)
3749 player->inventory_element[player->inventory_size++] = element;
3753 DigField(player, 0, 0, 0, 0, 0, 0, DF_NO_PUSH);
3754 SnapField(player, 0, 0);
3756 map_player_action[i] = i;
3759 network_player_action_received = FALSE;
3761 // initial null action
3762 if (network_playing)
3763 SendToServer_MovePlayer(MV_NONE);
3768 TimeLeft = level.time;
3771 ScreenMovDir = MV_NONE;
3775 ScrollStepSize = 0; // will be correctly initialized by ScrollScreen()
3777 game.robot_wheel_x = -1;
3778 game.robot_wheel_y = -1;
3783 game.all_players_gone = FALSE;
3785 game.LevelSolved = FALSE;
3786 game.GameOver = FALSE;
3788 game.GamePlayed = !tape.playing;
3790 game.LevelSolved_GameWon = FALSE;
3791 game.LevelSolved_GameEnd = FALSE;
3792 game.LevelSolved_SaveTape = FALSE;
3793 game.LevelSolved_SaveScore = FALSE;
3795 game.LevelSolved_CountingTime = 0;
3796 game.LevelSolved_CountingScore = 0;
3797 game.LevelSolved_CountingHealth = 0;
3799 game.panel.active = TRUE;
3801 game.no_time_limit = (level.time == 0);
3803 game.yamyam_content_nr = 0;
3804 game.robot_wheel_active = FALSE;
3805 game.magic_wall_active = FALSE;
3806 game.magic_wall_time_left = 0;
3807 game.light_time_left = 0;
3808 game.timegate_time_left = 0;
3809 game.switchgate_pos = 0;
3810 game.wind_direction = level.wind_direction_initial;
3812 game.time_final = 0;
3813 game.score_time_final = 0;
3816 game.score_final = 0;
3818 game.health = MAX_HEALTH;
3819 game.health_final = MAX_HEALTH;
3821 game.gems_still_needed = level.gems_needed;
3822 game.sokoban_fields_still_needed = 0;
3823 game.sokoban_objects_still_needed = 0;
3824 game.lights_still_needed = 0;
3825 game.players_still_needed = 0;
3826 game.friends_still_needed = 0;
3828 game.lenses_time_left = 0;
3829 game.magnify_time_left = 0;
3831 game.ball_active = level.ball_active_initial;
3832 game.ball_content_nr = 0;
3834 game.explosions_delayed = TRUE;
3836 game.envelope_active = FALSE;
3838 for (i = 0; i < NUM_BELTS; i++)
3840 game.belt_dir[i] = MV_NONE;
3841 game.belt_dir_nr[i] = 3; // not moving, next moving left
3844 for (i = 0; i < MAX_NUM_AMOEBA; i++)
3845 AmoebaCnt[i] = AmoebaCnt2[i] = 0;
3847 #if DEBUG_INIT_PLAYER
3848 DebugPrintPlayerStatus("Player status at level initialization");
3851 SCAN_PLAYFIELD(x, y)
3853 Tile[x][y] = Last[x][y] = level.field[x][y];
3854 MovPos[x][y] = MovDir[x][y] = MovDelay[x][y] = 0;
3855 ChangeDelay[x][y] = 0;
3856 ChangePage[x][y] = -1;
3857 CustomValue[x][y] = 0; // initialized in InitField()
3858 Store[x][y] = Store2[x][y] = StorePlayer[x][y] = Back[x][y] = 0;
3860 WasJustMoving[x][y] = 0;
3861 WasJustFalling[x][y] = 0;
3862 CheckCollision[x][y] = 0;
3863 CheckImpact[x][y] = 0;
3865 Pushed[x][y] = FALSE;
3867 ChangeCount[x][y] = 0;
3868 ChangeEvent[x][y] = -1;
3870 ExplodePhase[x][y] = 0;
3871 ExplodeDelay[x][y] = 0;
3872 ExplodeField[x][y] = EX_TYPE_NONE;
3874 RunnerVisit[x][y] = 0;
3875 PlayerVisit[x][y] = 0;
3878 GfxRandom[x][y] = INIT_GFX_RANDOM();
3879 GfxElement[x][y] = EL_UNDEFINED;
3880 GfxAction[x][y] = ACTION_DEFAULT;
3881 GfxDir[x][y] = MV_NONE;
3882 GfxRedraw[x][y] = GFX_REDRAW_NONE;
3885 SCAN_PLAYFIELD(x, y)
3887 if (emulate_bd && !IS_BD_ELEMENT(Tile[x][y]))
3889 if (emulate_sb && !IS_SB_ELEMENT(Tile[x][y]))
3891 if (emulate_sp && !IS_SP_ELEMENT(Tile[x][y]))
3894 InitField(x, y, TRUE);
3896 ResetGfxAnimation(x, y);
3901 for (i = 0; i < MAX_PLAYERS; i++)
3903 struct PlayerInfo *player = &stored_player[i];
3905 // set number of special actions for bored and sleeping animation
3906 player->num_special_action_bored =
3907 get_num_special_action(player->artwork_element,
3908 ACTION_BORING_1, ACTION_BORING_LAST);
3909 player->num_special_action_sleeping =
3910 get_num_special_action(player->artwork_element,
3911 ACTION_SLEEPING_1, ACTION_SLEEPING_LAST);
3914 game.emulation = (emulate_bd ? EMU_BOULDERDASH :
3915 emulate_sb ? EMU_SOKOBAN :
3916 emulate_sp ? EMU_SUPAPLEX : EMU_NONE);
3918 // initialize type of slippery elements
3919 for (i = 0; i < MAX_NUM_ELEMENTS; i++)
3921 if (!IS_CUSTOM_ELEMENT(i))
3923 // default: elements slip down either to the left or right randomly
3924 element_info[i].slippery_type = SLIPPERY_ANY_RANDOM;
3926 // SP style elements prefer to slip down on the left side
3927 if (game.engine_version >= VERSION_IDENT(3,1,1,0) && IS_SP_ELEMENT(i))
3928 element_info[i].slippery_type = SLIPPERY_ANY_LEFT_RIGHT;
3930 // BD style elements prefer to slip down on the left side
3931 if (game.emulation == EMU_BOULDERDASH)
3932 element_info[i].slippery_type = SLIPPERY_ANY_LEFT_RIGHT;
3936 // initialize explosion and ignition delay
3937 for (i = 0; i < MAX_NUM_ELEMENTS; i++)
3939 if (!IS_CUSTOM_ELEMENT(i))
3942 int delay = (((IS_SP_ELEMENT(i) && i != EL_EMPTY_SPACE) &&
3943 game.engine_version >= VERSION_IDENT(3,1,0,0)) ||
3944 game.emulation == EMU_SUPAPLEX ? 3 : 2);
3945 int last_phase = (num_phase + 1) * delay;
3946 int half_phase = (num_phase / 2) * delay;
3948 element_info[i].explosion_delay = last_phase - 1;
3949 element_info[i].ignition_delay = half_phase;
3951 if (i == EL_BLACK_ORB)
3952 element_info[i].ignition_delay = 1;
3956 // correct non-moving belts to start moving left
3957 for (i = 0; i < NUM_BELTS; i++)
3958 if (game.belt_dir[i] == MV_NONE)
3959 game.belt_dir_nr[i] = 3; // not moving, next moving left
3961 #if USE_NEW_PLAYER_ASSIGNMENTS
3962 // use preferred player also in local single-player mode
3963 if (!network.enabled && !game.team_mode)
3965 int new_index_nr = setup.network_player_nr;
3967 if (new_index_nr >= 0 && new_index_nr < MAX_PLAYERS)
3969 for (i = 0; i < MAX_PLAYERS; i++)
3970 stored_player[i].connected_locally = FALSE;
3972 stored_player[new_index_nr].connected_locally = TRUE;
3976 for (i = 0; i < MAX_PLAYERS; i++)
3978 stored_player[i].connected = FALSE;
3980 // in network game mode, the local player might not be the first player
3981 if (stored_player[i].connected_locally)
3982 local_player = &stored_player[i];
3985 if (!network.enabled)
3986 local_player->connected = TRUE;
3990 for (i = 0; i < MAX_PLAYERS; i++)
3991 stored_player[i].connected = tape.player_participates[i];
3993 else if (network.enabled)
3995 // add team mode players connected over the network (needed for correct
3996 // assignment of player figures from level to locally playing players)
3998 for (i = 0; i < MAX_PLAYERS; i++)
3999 if (stored_player[i].connected_network)
4000 stored_player[i].connected = TRUE;
4002 else if (game.team_mode)
4004 // try to guess locally connected team mode players (needed for correct
4005 // assignment of player figures from level to locally playing players)
4007 for (i = 0; i < MAX_PLAYERS; i++)
4008 if (setup.input[i].use_joystick ||
4009 setup.input[i].key.left != KSYM_UNDEFINED)
4010 stored_player[i].connected = TRUE;
4013 #if DEBUG_INIT_PLAYER
4014 DebugPrintPlayerStatus("Player status after level initialization");
4017 #if DEBUG_INIT_PLAYER
4018 Debug("game:init:player", "Reassigning players ...");
4021 // check if any connected player was not found in playfield
4022 for (i = 0; i < MAX_PLAYERS; i++)
4024 struct PlayerInfo *player = &stored_player[i];
4026 if (player->connected && !player->present)
4028 struct PlayerInfo *field_player = NULL;
4030 #if DEBUG_INIT_PLAYER
4031 Debug("game:init:player",
4032 "- looking for field player for player %d ...", i + 1);
4035 // assign first free player found that is present in the playfield
4037 // first try: look for unmapped playfield player that is not connected
4038 for (j = 0; j < MAX_PLAYERS; j++)
4039 if (field_player == NULL &&
4040 stored_player[j].present &&
4041 !stored_player[j].mapped &&
4042 !stored_player[j].connected)
4043 field_player = &stored_player[j];
4045 // second try: look for *any* unmapped playfield player
4046 for (j = 0; j < MAX_PLAYERS; j++)
4047 if (field_player == NULL &&
4048 stored_player[j].present &&
4049 !stored_player[j].mapped)
4050 field_player = &stored_player[j];
4052 if (field_player != NULL)
4054 int jx = field_player->jx, jy = field_player->jy;
4056 #if DEBUG_INIT_PLAYER
4057 Debug("game:init:player", "- found player %d",
4058 field_player->index_nr + 1);
4061 player->present = FALSE;
4062 player->active = FALSE;
4064 field_player->present = TRUE;
4065 field_player->active = TRUE;
4068 player->initial_element = field_player->initial_element;
4069 player->artwork_element = field_player->artwork_element;
4071 player->block_last_field = field_player->block_last_field;
4072 player->block_delay_adjustment = field_player->block_delay_adjustment;
4075 StorePlayer[jx][jy] = field_player->element_nr;
4077 field_player->jx = field_player->last_jx = jx;
4078 field_player->jy = field_player->last_jy = jy;
4080 if (local_player == player)
4081 local_player = field_player;
4083 map_player_action[field_player->index_nr] = i;
4085 field_player->mapped = TRUE;
4087 #if DEBUG_INIT_PLAYER
4088 Debug("game:init:player", "- map_player_action[%d] == %d",
4089 field_player->index_nr + 1, i + 1);
4094 if (player->connected && player->present)
4095 player->mapped = TRUE;
4098 #if DEBUG_INIT_PLAYER
4099 DebugPrintPlayerStatus("Player status after player assignment (first stage)");
4104 // check if any connected player was not found in playfield
4105 for (i = 0; i < MAX_PLAYERS; i++)
4107 struct PlayerInfo *player = &stored_player[i];
4109 if (player->connected && !player->present)
4111 for (j = 0; j < MAX_PLAYERS; j++)
4113 struct PlayerInfo *field_player = &stored_player[j];
4114 int jx = field_player->jx, jy = field_player->jy;
4116 // assign first free player found that is present in the playfield
4117 if (field_player->present && !field_player->connected)
4119 player->present = TRUE;
4120 player->active = TRUE;
4122 field_player->present = FALSE;
4123 field_player->active = FALSE;
4125 player->initial_element = field_player->initial_element;
4126 player->artwork_element = field_player->artwork_element;
4128 player->block_last_field = field_player->block_last_field;
4129 player->block_delay_adjustment = field_player->block_delay_adjustment;
4131 StorePlayer[jx][jy] = player->element_nr;
4133 player->jx = player->last_jx = jx;
4134 player->jy = player->last_jy = jy;
4144 Debug("game:init:player", "local_player->present == %d",
4145 local_player->present);
4148 // set focus to local player for network games, else to all players
4149 game.centered_player_nr = (network_playing ? local_player->index_nr : -1);
4150 game.centered_player_nr_next = game.centered_player_nr;
4151 game.set_centered_player = FALSE;
4152 game.set_centered_player_wrap = FALSE;
4154 if (network_playing && tape.recording)
4156 // store client dependent player focus when recording network games
4157 tape.centered_player_nr_next = game.centered_player_nr_next;
4158 tape.set_centered_player = TRUE;
4163 // when playing a tape, eliminate all players who do not participate
4165 #if USE_NEW_PLAYER_ASSIGNMENTS
4167 if (!game.team_mode)
4169 for (i = 0; i < MAX_PLAYERS; i++)
4171 if (stored_player[i].active &&
4172 !tape.player_participates[map_player_action[i]])
4174 struct PlayerInfo *player = &stored_player[i];
4175 int jx = player->jx, jy = player->jy;
4177 #if DEBUG_INIT_PLAYER
4178 Debug("game:init:player", "Removing player %d at (%d, %d)",
4182 player->active = FALSE;
4183 StorePlayer[jx][jy] = 0;
4184 Tile[jx][jy] = EL_EMPTY;
4191 for (i = 0; i < MAX_PLAYERS; i++)
4193 if (stored_player[i].active &&
4194 !tape.player_participates[i])
4196 struct PlayerInfo *player = &stored_player[i];
4197 int jx = player->jx, jy = player->jy;
4199 player->active = FALSE;
4200 StorePlayer[jx][jy] = 0;
4201 Tile[jx][jy] = EL_EMPTY;
4206 else if (!network.enabled && !game.team_mode) // && !tape.playing
4208 // when in single player mode, eliminate all but the local player
4210 for (i = 0; i < MAX_PLAYERS; i++)
4212 struct PlayerInfo *player = &stored_player[i];
4214 if (player->active && player != local_player)
4216 int jx = player->jx, jy = player->jy;
4218 player->active = FALSE;
4219 player->present = FALSE;
4221 StorePlayer[jx][jy] = 0;
4222 Tile[jx][jy] = EL_EMPTY;
4227 for (i = 0; i < MAX_PLAYERS; i++)
4228 if (stored_player[i].active)
4229 game.players_still_needed++;
4231 if (level.solved_by_one_player)
4232 game.players_still_needed = 1;
4234 // when recording the game, store which players take part in the game
4237 #if USE_NEW_PLAYER_ASSIGNMENTS
4238 for (i = 0; i < MAX_PLAYERS; i++)
4239 if (stored_player[i].connected)
4240 tape.player_participates[i] = TRUE;
4242 for (i = 0; i < MAX_PLAYERS; i++)
4243 if (stored_player[i].active)
4244 tape.player_participates[i] = TRUE;
4248 #if DEBUG_INIT_PLAYER
4249 DebugPrintPlayerStatus("Player status after player assignment (final stage)");
4252 if (BorderElement == EL_EMPTY)
4255 SBX_Right = lev_fieldx - SCR_FIELDX;
4257 SBY_Lower = lev_fieldy - SCR_FIELDY;
4262 SBX_Right = lev_fieldx - SCR_FIELDX + 1;
4264 SBY_Lower = lev_fieldy - SCR_FIELDY + 1;
4267 if (full_lev_fieldx <= SCR_FIELDX)
4268 SBX_Left = SBX_Right = -1 * (SCR_FIELDX - lev_fieldx) / 2;
4269 if (full_lev_fieldy <= SCR_FIELDY)
4270 SBY_Upper = SBY_Lower = -1 * (SCR_FIELDY - lev_fieldy) / 2;
4272 if (EVEN(SCR_FIELDX) && full_lev_fieldx > SCR_FIELDX)
4274 if (EVEN(SCR_FIELDY) && full_lev_fieldy > SCR_FIELDY)
4277 // if local player not found, look for custom element that might create
4278 // the player (make some assumptions about the right custom element)
4279 if (!local_player->present)
4281 int start_x = 0, start_y = 0;
4282 int found_rating = 0;
4283 int found_element = EL_UNDEFINED;
4284 int player_nr = local_player->index_nr;
4286 SCAN_PLAYFIELD(x, y)
4288 int element = Tile[x][y];
4293 if (level.use_start_element[player_nr] &&
4294 level.start_element[player_nr] == element &&
4301 found_element = element;
4304 if (!IS_CUSTOM_ELEMENT(element))
4307 if (CAN_CHANGE(element))
4309 for (i = 0; i < element_info[element].num_change_pages; i++)
4311 // check for player created from custom element as single target
4312 content = element_info[element].change_page[i].target_element;
4313 is_player = ELEM_IS_PLAYER(content);
4315 if (is_player && (found_rating < 3 ||
4316 (found_rating == 3 && element < found_element)))
4322 found_element = element;
4327 for (yy = 0; yy < 3; yy++) for (xx = 0; xx < 3; xx++)
4329 // check for player created from custom element as explosion content
4330 content = element_info[element].content.e[xx][yy];
4331 is_player = ELEM_IS_PLAYER(content);
4333 if (is_player && (found_rating < 2 ||
4334 (found_rating == 2 && element < found_element)))
4336 start_x = x + xx - 1;
4337 start_y = y + yy - 1;
4340 found_element = element;
4343 if (!CAN_CHANGE(element))
4346 for (i = 0; i < element_info[element].num_change_pages; i++)
4348 // check for player created from custom element as extended target
4350 element_info[element].change_page[i].target_content.e[xx][yy];
4352 is_player = ELEM_IS_PLAYER(content);
4354 if (is_player && (found_rating < 1 ||
4355 (found_rating == 1 && element < found_element)))
4357 start_x = x + xx - 1;
4358 start_y = y + yy - 1;
4361 found_element = element;
4367 scroll_x = SCROLL_POSITION_X(start_x);
4368 scroll_y = SCROLL_POSITION_Y(start_y);
4372 scroll_x = SCROLL_POSITION_X(local_player->jx);
4373 scroll_y = SCROLL_POSITION_Y(local_player->jy);
4376 // !!! FIX THIS (START) !!!
4377 if (level.game_engine_type == GAME_ENGINE_TYPE_EM)
4379 InitGameEngine_EM();
4381 else if (level.game_engine_type == GAME_ENGINE_TYPE_SP)
4383 InitGameEngine_SP();
4385 else if (level.game_engine_type == GAME_ENGINE_TYPE_MM)
4387 InitGameEngine_MM();
4391 DrawLevel(REDRAW_FIELD);
4394 // after drawing the level, correct some elements
4395 if (game.timegate_time_left == 0)
4396 CloseAllOpenTimegates();
4399 // blit playfield from scroll buffer to normal back buffer for fading in
4400 BlitScreenToBitmap(backbuffer);
4401 // !!! FIX THIS (END) !!!
4403 DrawMaskedBorder(fade_mask);
4408 // full screen redraw is required at this point in the following cases:
4409 // - special editor door undrawn when game was started from level editor
4410 // - drawing area (playfield) was changed and has to be removed completely
4411 redraw_mask = REDRAW_ALL;
4415 if (!game.restart_level)
4417 // copy default game door content to main double buffer
4419 // !!! CHECK AGAIN !!!
4420 SetPanelBackground();
4421 // SetDoorBackgroundImage(IMG_BACKGROUND_PANEL);
4422 DrawBackground(DX, DY, DXSIZE, DYSIZE);
4425 SetPanelBackground();
4426 SetDrawBackgroundMask(REDRAW_DOOR_1);
4428 UpdateAndDisplayGameControlValues();
4430 if (!game.restart_level)
4436 CreateGameButtons();
4441 // copy actual game door content to door double buffer for OpenDoor()
4442 BlitBitmap(drawto, bitmap_db_door_1, DX, DY, DXSIZE, DYSIZE, 0, 0);
4444 OpenDoor(DOOR_OPEN_ALL);
4446 KeyboardAutoRepeatOffUnlessAutoplay();
4448 #if DEBUG_INIT_PLAYER
4449 DebugPrintPlayerStatus("Player status (final)");
4458 if (!game.restart_level && !tape.playing)
4460 LevelStats_incPlayed(level_nr);
4462 SaveLevelSetup_SeriesInfo();
4465 game.restart_level = FALSE;
4466 game.restart_game_message = NULL;
4468 game.request_active = FALSE;
4469 game.request_active_or_moving = FALSE;
4471 if (level.game_engine_type == GAME_ENGINE_TYPE_MM)
4472 InitGameActions_MM();
4474 SaveEngineSnapshotToListInitial();
4476 if (!game.restart_level)
4478 PlaySound(SND_GAME_STARTING);
4480 if (setup.sound_music)
4485 void UpdateEngineValues(int actual_scroll_x, int actual_scroll_y,
4486 int actual_player_x, int actual_player_y)
4488 // this is used for non-R'n'D game engines to update certain engine values
4490 // needed to determine if sounds are played within the visible screen area
4491 scroll_x = actual_scroll_x;
4492 scroll_y = actual_scroll_y;
4494 // needed to get player position for "follow finger" playing input method
4495 local_player->jx = actual_player_x;
4496 local_player->jy = actual_player_y;
4499 void InitMovDir(int x, int y)
4501 int i, element = Tile[x][y];
4502 static int xy[4][2] =
4509 static int direction[3][4] =
4511 { MV_RIGHT, MV_UP, MV_LEFT, MV_DOWN },
4512 { MV_LEFT, MV_DOWN, MV_RIGHT, MV_UP },
4513 { MV_LEFT, MV_RIGHT, MV_UP, MV_DOWN }
4522 Tile[x][y] = EL_BUG;
4523 MovDir[x][y] = direction[0][element - EL_BUG_RIGHT];
4526 case EL_SPACESHIP_RIGHT:
4527 case EL_SPACESHIP_UP:
4528 case EL_SPACESHIP_LEFT:
4529 case EL_SPACESHIP_DOWN:
4530 Tile[x][y] = EL_SPACESHIP;
4531 MovDir[x][y] = direction[0][element - EL_SPACESHIP_RIGHT];
4534 case EL_BD_BUTTERFLY_RIGHT:
4535 case EL_BD_BUTTERFLY_UP:
4536 case EL_BD_BUTTERFLY_LEFT:
4537 case EL_BD_BUTTERFLY_DOWN:
4538 Tile[x][y] = EL_BD_BUTTERFLY;
4539 MovDir[x][y] = direction[0][element - EL_BD_BUTTERFLY_RIGHT];
4542 case EL_BD_FIREFLY_RIGHT:
4543 case EL_BD_FIREFLY_UP:
4544 case EL_BD_FIREFLY_LEFT:
4545 case EL_BD_FIREFLY_DOWN:
4546 Tile[x][y] = EL_BD_FIREFLY;
4547 MovDir[x][y] = direction[0][element - EL_BD_FIREFLY_RIGHT];
4550 case EL_PACMAN_RIGHT:
4552 case EL_PACMAN_LEFT:
4553 case EL_PACMAN_DOWN:
4554 Tile[x][y] = EL_PACMAN;
4555 MovDir[x][y] = direction[0][element - EL_PACMAN_RIGHT];
4558 case EL_YAMYAM_LEFT:
4559 case EL_YAMYAM_RIGHT:
4561 case EL_YAMYAM_DOWN:
4562 Tile[x][y] = EL_YAMYAM;
4563 MovDir[x][y] = direction[2][element - EL_YAMYAM_LEFT];
4566 case EL_SP_SNIKSNAK:
4567 MovDir[x][y] = MV_UP;
4570 case EL_SP_ELECTRON:
4571 MovDir[x][y] = MV_LEFT;
4578 Tile[x][y] = EL_MOLE;
4579 MovDir[x][y] = direction[2][element - EL_MOLE_LEFT];
4582 case EL_SPRING_LEFT:
4583 case EL_SPRING_RIGHT:
4584 Tile[x][y] = EL_SPRING;
4585 MovDir[x][y] = direction[2][element - EL_SPRING_LEFT];
4589 if (IS_CUSTOM_ELEMENT(element))
4591 struct ElementInfo *ei = &element_info[element];
4592 int move_direction_initial = ei->move_direction_initial;
4593 int move_pattern = ei->move_pattern;
4595 if (move_direction_initial == MV_START_PREVIOUS)
4597 if (MovDir[x][y] != MV_NONE)
4600 move_direction_initial = MV_START_AUTOMATIC;
4603 if (move_direction_initial == MV_START_RANDOM)
4604 MovDir[x][y] = 1 << RND(4);
4605 else if (move_direction_initial & MV_ANY_DIRECTION)
4606 MovDir[x][y] = move_direction_initial;
4607 else if (move_pattern == MV_ALL_DIRECTIONS ||
4608 move_pattern == MV_TURNING_LEFT ||
4609 move_pattern == MV_TURNING_RIGHT ||
4610 move_pattern == MV_TURNING_LEFT_RIGHT ||
4611 move_pattern == MV_TURNING_RIGHT_LEFT ||
4612 move_pattern == MV_TURNING_RANDOM)
4613 MovDir[x][y] = 1 << RND(4);
4614 else if (move_pattern == MV_HORIZONTAL)
4615 MovDir[x][y] = (RND(2) ? MV_LEFT : MV_RIGHT);
4616 else if (move_pattern == MV_VERTICAL)
4617 MovDir[x][y] = (RND(2) ? MV_UP : MV_DOWN);
4618 else if (move_pattern & MV_ANY_DIRECTION)
4619 MovDir[x][y] = element_info[element].move_pattern;
4620 else if (move_pattern == MV_ALONG_LEFT_SIDE ||
4621 move_pattern == MV_ALONG_RIGHT_SIDE)
4623 // use random direction as default start direction
4624 if (game.engine_version >= VERSION_IDENT(3,1,0,0))
4625 MovDir[x][y] = 1 << RND(4);
4627 for (i = 0; i < NUM_DIRECTIONS; i++)
4629 int x1 = x + xy[i][0];
4630 int y1 = y + xy[i][1];
4632 if (!IN_LEV_FIELD(x1, y1) || !IS_FREE(x1, y1))
4634 if (move_pattern == MV_ALONG_RIGHT_SIDE)
4635 MovDir[x][y] = direction[0][i];
4637 MovDir[x][y] = direction[1][i];
4646 MovDir[x][y] = 1 << RND(4);
4648 if (element != EL_BUG &&
4649 element != EL_SPACESHIP &&
4650 element != EL_BD_BUTTERFLY &&
4651 element != EL_BD_FIREFLY)
4654 for (i = 0; i < NUM_DIRECTIONS; i++)
4656 int x1 = x + xy[i][0];
4657 int y1 = y + xy[i][1];
4659 if (!IN_LEV_FIELD(x1, y1) || !IS_FREE(x1, y1))
4661 if (element == EL_BUG || element == EL_BD_BUTTERFLY)
4663 MovDir[x][y] = direction[0][i];
4666 else if (element == EL_SPACESHIP || element == EL_BD_FIREFLY ||
4667 element == EL_SP_SNIKSNAK || element == EL_SP_ELECTRON)
4669 MovDir[x][y] = direction[1][i];
4678 GfxDir[x][y] = MovDir[x][y];
4681 void InitAmoebaNr(int x, int y)
4684 int group_nr = AmoebaNeighbourNr(x, y);
4688 for (i = 1; i < MAX_NUM_AMOEBA; i++)
4690 if (AmoebaCnt[i] == 0)
4698 AmoebaNr[x][y] = group_nr;
4699 AmoebaCnt[group_nr]++;
4700 AmoebaCnt2[group_nr]++;
4703 static void LevelSolved(void)
4705 if (level.game_engine_type == GAME_ENGINE_TYPE_RND &&
4706 game.players_still_needed > 0)
4709 game.LevelSolved = TRUE;
4710 game.GameOver = TRUE;
4715 static int time_count_steps;
4716 static int time, time_final;
4717 static float score, score_final; // needed for time score < 10 for 10 seconds
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 time_score_base = MIN(MAX(1, level.time_score_base), 10);
4723 float time_score = (float)level.score[SC_TIME_BONUS] / time_score_base;
4725 if (!game.LevelSolved_GameWon)
4729 // do not start end game actions before the player stops moving (to exit)
4730 if (local_player->active && local_player->MovPos)
4733 game.time_final = (game.no_time_limit ? TimePlayed : TimeLeft);
4734 game.score_time_final = (level.use_step_counter ? TimePlayed :
4735 TimePlayed * FRAMES_PER_SECOND + TimeFrames);
4737 game.score_final = (level.game_engine_type == GAME_ENGINE_TYPE_EM ?
4738 game_em.lev->score :
4739 level.game_engine_type == GAME_ENGINE_TYPE_MM ?
4743 game.health_final = (level.game_engine_type == GAME_ENGINE_TYPE_MM ?
4744 MM_HEALTH(game_mm.laser_overload_value) :
4747 game.LevelSolved_CountingTime = game.time_final;
4748 game.LevelSolved_CountingScore = game.score_final;
4749 game.LevelSolved_CountingHealth = game.health_final;
4751 game.LevelSolved_GameWon = TRUE;
4752 game.LevelSolved_SaveTape = tape.recording;
4753 game.LevelSolved_SaveScore = !tape.playing;
4757 LevelStats_incSolved(level_nr);
4759 SaveLevelSetup_SeriesInfo();
4762 if (tape.auto_play) // tape might already be stopped here
4763 tape.auto_play_level_solved = TRUE;
4767 game_over_delay_1 = FRAMES_PER_SECOND; // delay before counting time
4768 game_over_delay_2 = FRAMES_PER_SECOND / 2; // delay before counting health
4769 game_over_delay_3 = FRAMES_PER_SECOND; // delay before ending the game
4771 time = time_final = game.time_final;
4772 score = score_final = game.score_final;
4773 health = health_final = game.health_final;
4777 int time_final_max = 999;
4778 int time_frames_final_max = time_final_max * FRAMES_PER_SECOND;
4779 int time_frames = 0;
4780 int time_frames_left = TimeLeft * FRAMES_PER_SECOND - TimeFrames;
4781 int time_frames_played = TimePlayed * FRAMES_PER_SECOND + TimeFrames;
4786 time_frames = time_frames_left;
4788 else if (game.no_time_limit && TimePlayed < time_final_max)
4790 time_final = time_final_max;
4791 time_frames = time_frames_final_max - time_frames_played;
4794 score_final += time_score * time_frames / FRAMES_PER_SECOND + 0.5;
4796 time_count_steps = MAX(1, ABS(time_final - time) / 100);
4798 if (level.game_engine_type == GAME_ENGINE_TYPE_MM)
4801 score_final += health * time_score;
4804 game.score_final = score_final;
4805 game.health_final = health_final;
4808 if (level_editor_test_game || !setup.count_score_after_game)
4811 score = score_final;
4813 game.LevelSolved_CountingTime = time;
4814 game.LevelSolved_CountingScore = score;
4816 game_panel_controls[GAME_PANEL_TIME].value = time;
4817 game_panel_controls[GAME_PANEL_SCORE].value = score;
4819 DisplayGameControlValues();
4822 if (level.game_engine_type == GAME_ENGINE_TYPE_RND)
4824 // check if last player has left the level
4825 if (game.exit_x >= 0 &&
4828 int x = game.exit_x;
4829 int y = game.exit_y;
4830 int element = Tile[x][y];
4832 // close exit door after last player
4833 if ((game.all_players_gone &&
4834 (element == EL_EXIT_OPEN ||
4835 element == EL_SP_EXIT_OPEN ||
4836 element == EL_STEEL_EXIT_OPEN)) ||
4837 element == EL_EM_EXIT_OPEN ||
4838 element == EL_EM_STEEL_EXIT_OPEN)
4842 (element == EL_EXIT_OPEN ? EL_EXIT_CLOSING :
4843 element == EL_EM_EXIT_OPEN ? EL_EM_EXIT_CLOSING :
4844 element == EL_SP_EXIT_OPEN ? EL_SP_EXIT_CLOSING:
4845 element == EL_STEEL_EXIT_OPEN ? EL_STEEL_EXIT_CLOSING:
4846 EL_EM_STEEL_EXIT_CLOSING);
4848 PlayLevelSoundElementAction(x, y, element, ACTION_CLOSING);
4851 // player disappears
4852 DrawLevelField(x, y);
4855 for (i = 0; i < MAX_PLAYERS; i++)
4857 struct PlayerInfo *player = &stored_player[i];
4859 if (player->present)
4861 RemovePlayer(player);
4863 // player disappears
4864 DrawLevelField(player->jx, player->jy);
4869 PlaySound(SND_GAME_WINNING);
4872 if (setup.count_score_after_game)
4874 if (time != time_final)
4876 if (game_over_delay_1 > 0)
4878 game_over_delay_1--;
4883 int time_to_go = ABS(time_final - time);
4884 int time_count_dir = (time < time_final ? +1 : -1);
4886 if (time_to_go < time_count_steps)
4887 time_count_steps = 1;
4889 time += time_count_steps * time_count_dir;
4890 score += time_count_steps * time_score;
4892 // set final score to correct rounding differences after counting score
4893 if (time == time_final)
4894 score = score_final;
4896 game.LevelSolved_CountingTime = time;
4897 game.LevelSolved_CountingScore = score;
4899 game_panel_controls[GAME_PANEL_TIME].value = time;
4900 game_panel_controls[GAME_PANEL_SCORE].value = score;
4902 DisplayGameControlValues();
4904 if (time == time_final)
4905 StopSound(SND_GAME_LEVELTIME_BONUS);
4906 else if (setup.sound_loops)
4907 PlaySoundLoop(SND_GAME_LEVELTIME_BONUS);
4909 PlaySound(SND_GAME_LEVELTIME_BONUS);
4914 if (health != health_final)
4916 if (game_over_delay_2 > 0)
4918 game_over_delay_2--;
4923 int health_count_dir = (health < health_final ? +1 : -1);
4925 health += health_count_dir;
4926 score += time_score;
4928 game.LevelSolved_CountingHealth = health;
4929 game.LevelSolved_CountingScore = score;
4931 game_panel_controls[GAME_PANEL_HEALTH].value = health;
4932 game_panel_controls[GAME_PANEL_SCORE].value = score;
4934 DisplayGameControlValues();
4936 if (health == health_final)
4937 StopSound(SND_GAME_LEVELTIME_BONUS);
4938 else if (setup.sound_loops)
4939 PlaySoundLoop(SND_GAME_LEVELTIME_BONUS);
4941 PlaySound(SND_GAME_LEVELTIME_BONUS);
4947 game.panel.active = FALSE;
4949 if (game_over_delay_3 > 0)
4951 game_over_delay_3--;
4961 // used instead of "level_nr" (needed for network games)
4962 int last_level_nr = levelset.level_nr;
4965 game.LevelSolved_GameEnd = TRUE;
4967 if (game.LevelSolved_SaveTape)
4969 // make sure that request dialog to save tape does not open door again
4970 if (!global.use_envelope_request)
4971 CloseDoor(DOOR_CLOSE_1);
4973 SaveTapeChecked_LevelSolved(tape.level_nr); // ask to save tape
4976 // if no tape is to be saved, close both doors simultaneously
4977 CloseDoor(DOOR_CLOSE_ALL);
4979 if (level_editor_test_game)
4981 SetGameStatus(GAME_MODE_MAIN);
4988 if (!game.LevelSolved_SaveScore)
4990 SetGameStatus(GAME_MODE_MAIN);
4997 if (level_nr == leveldir_current->handicap_level)
4999 leveldir_current->handicap_level++;
5001 SaveLevelSetup_SeriesInfo();
5004 if (setup.increment_levels &&
5005 level_nr < leveldir_current->last_level &&
5008 level_nr++; // advance to next level
5009 TapeErase(); // start with empty tape
5011 if (setup.auto_play_next_level)
5013 LoadLevel(level_nr);
5015 SaveLevelSetup_SeriesInfo();
5019 hi_pos = NewHiScore(last_level_nr);
5021 if (hi_pos >= 0 && setup.show_scores_after_game)
5023 SetGameStatus(GAME_MODE_SCORES);
5025 DrawHallOfFame(last_level_nr, hi_pos);
5027 else if (setup.auto_play_next_level && setup.increment_levels &&
5028 last_level_nr < leveldir_current->last_level &&
5031 StartGameActions(network.enabled, setup.autorecord, level.random_seed);
5035 SetGameStatus(GAME_MODE_MAIN);
5041 int NewHiScore(int level_nr)
5045 boolean one_score_entry_per_name = !program.many_scores_per_name;
5047 LoadScore(level_nr);
5049 if (strEqual(setup.player_name, EMPTY_PLAYER_NAME) ||
5050 game.score_final < scores.entry[MAX_SCORE_ENTRIES - 1].score)
5053 for (k = 0; k < MAX_SCORE_ENTRIES; k++)
5055 boolean score_is_better = (game.score_final > scores.entry[k].score);
5056 boolean score_is_equal = (game.score_final == scores.entry[k].score);
5057 boolean time_is_better = (game.score_time_final < scores.entry[k].time);
5058 boolean time_is_equal = (game.score_time_final == scores.entry[k].time);
5059 boolean better_by_score = (score_is_better ||
5060 (score_is_equal && time_is_better));
5061 boolean better_by_time = (time_is_better ||
5062 (time_is_equal && score_is_better));
5063 boolean is_better = (level.rate_time_over_score ? better_by_time :
5065 boolean entry_is_empty = (scores.entry[k].score == 0 &&
5066 scores.entry[k].time == 0);
5068 if (is_better || entry_is_empty)
5070 // player has made it to the hall of fame
5072 if (k < MAX_SCORE_ENTRIES - 1)
5074 int m = MAX_SCORE_ENTRIES - 1;
5076 if (one_score_entry_per_name)
5078 for (l = k; l < MAX_SCORE_ENTRIES; l++)
5079 if (strEqual(setup.player_name, scores.entry[l].name))
5082 if (m == k) // player's new highscore overwrites his old one
5086 for (l = m; l > k; l--)
5088 strcpy(scores.entry[l].name, scores.entry[l - 1].name);
5089 scores.entry[l].score = scores.entry[l - 1].score;
5090 scores.entry[l].time = scores.entry[l - 1].time;
5096 strncpy(scores.entry[k].name, setup.player_name, MAX_PLAYER_NAME_LEN);
5097 scores.entry[k].name[MAX_PLAYER_NAME_LEN] = '\0';
5098 scores.entry[k].score = game.score_final;
5099 scores.entry[k].time = game.score_time_final;
5104 else if (one_score_entry_per_name &&
5105 !strncmp(setup.player_name, scores.entry[k].name,
5106 MAX_PLAYER_NAME_LEN))
5107 break; // player already there with a higher score
5111 SaveScore(level_nr);
5116 static int getElementMoveStepsizeExt(int x, int y, int direction)
5118 int element = Tile[x][y];
5119 int dx = (direction == MV_LEFT ? -1 : direction == MV_RIGHT ? +1 : 0);
5120 int dy = (direction == MV_UP ? -1 : direction == MV_DOWN ? +1 : 0);
5121 int horiz_move = (dx != 0);
5122 int sign = (horiz_move ? dx : dy);
5123 int step = sign * element_info[element].move_stepsize;
5125 // special values for move stepsize for spring and things on conveyor belt
5128 if (CAN_FALL(element) &&
5129 y < lev_fieldy - 1 && IS_BELT_ACTIVE(Tile[x][y + 1]))
5130 step = sign * MOVE_STEPSIZE_NORMAL / 2;
5131 else if (element == EL_SPRING)
5132 step = sign * MOVE_STEPSIZE_NORMAL * 2;
5138 static int getElementMoveStepsize(int x, int y)
5140 return getElementMoveStepsizeExt(x, y, MovDir[x][y]);
5143 void InitPlayerGfxAnimation(struct PlayerInfo *player, int action, int dir)
5145 if (player->GfxAction != action || player->GfxDir != dir)
5147 player->GfxAction = action;
5148 player->GfxDir = dir;
5150 player->StepFrame = 0;
5154 static void ResetGfxFrame(int x, int y)
5156 // profiling showed that "autotest" spends 10~20% of its time in this function
5157 if (DrawingDeactivatedField())
5160 int element = Tile[x][y];
5161 int graphic = el_act_dir2img(element, GfxAction[x][y], GfxDir[x][y]);
5163 if (graphic_info[graphic].anim_global_sync)
5164 GfxFrame[x][y] = FrameCounter;
5165 else if (ANIM_MODE(graphic) == ANIM_CE_VALUE)
5166 GfxFrame[x][y] = CustomValue[x][y];
5167 else if (ANIM_MODE(graphic) == ANIM_CE_SCORE)
5168 GfxFrame[x][y] = element_info[element].collect_score;
5169 else if (ANIM_MODE(graphic) == ANIM_CE_DELAY)
5170 GfxFrame[x][y] = ChangeDelay[x][y];
5173 static void ResetGfxAnimation(int x, int y)
5175 GfxAction[x][y] = ACTION_DEFAULT;
5176 GfxDir[x][y] = MovDir[x][y];
5179 ResetGfxFrame(x, y);
5182 static void ResetRandomAnimationValue(int x, int y)
5184 GfxRandom[x][y] = INIT_GFX_RANDOM();
5187 static void InitMovingField(int x, int y, int direction)
5189 int element = Tile[x][y];
5190 int dx = (direction == MV_LEFT ? -1 : direction == MV_RIGHT ? +1 : 0);
5191 int dy = (direction == MV_UP ? -1 : direction == MV_DOWN ? +1 : 0);
5194 boolean is_moving_before, is_moving_after;
5196 // check if element was/is moving or being moved before/after mode change
5197 is_moving_before = (WasJustMoving[x][y] != 0);
5198 is_moving_after = (getElementMoveStepsizeExt(x, y, direction) != 0);
5200 // reset animation only for moving elements which change direction of moving
5201 // or which just started or stopped moving
5202 // (else CEs with property "can move" / "not moving" are reset each frame)
5203 if (is_moving_before != is_moving_after ||
5204 direction != MovDir[x][y])
5205 ResetGfxAnimation(x, y);
5207 MovDir[x][y] = direction;
5208 GfxDir[x][y] = direction;
5210 GfxAction[x][y] = (!is_moving_after ? ACTION_WAITING :
5211 direction == MV_DOWN && CAN_FALL(element) ?
5212 ACTION_FALLING : ACTION_MOVING);
5214 // this is needed for CEs with property "can move" / "not moving"
5216 if (is_moving_after)
5218 if (Tile[newx][newy] == EL_EMPTY)
5219 Tile[newx][newy] = EL_BLOCKED;
5221 MovDir[newx][newy] = MovDir[x][y];
5223 CustomValue[newx][newy] = CustomValue[x][y];
5225 GfxFrame[newx][newy] = GfxFrame[x][y];
5226 GfxRandom[newx][newy] = GfxRandom[x][y];
5227 GfxAction[newx][newy] = GfxAction[x][y];
5228 GfxDir[newx][newy] = GfxDir[x][y];
5232 void Moving2Blocked(int x, int y, int *goes_to_x, int *goes_to_y)
5234 int direction = MovDir[x][y];
5235 int newx = x + (direction & MV_LEFT ? -1 : direction & MV_RIGHT ? +1 : 0);
5236 int newy = y + (direction & MV_UP ? -1 : direction & MV_DOWN ? +1 : 0);
5242 void Blocked2Moving(int x, int y, int *comes_from_x, int *comes_from_y)
5244 int oldx = x, oldy = y;
5245 int direction = MovDir[x][y];
5247 if (direction == MV_LEFT)
5249 else if (direction == MV_RIGHT)
5251 else if (direction == MV_UP)
5253 else if (direction == MV_DOWN)
5256 *comes_from_x = oldx;
5257 *comes_from_y = oldy;
5260 static int MovingOrBlocked2Element(int x, int y)
5262 int element = Tile[x][y];
5264 if (element == EL_BLOCKED)
5268 Blocked2Moving(x, y, &oldx, &oldy);
5269 return Tile[oldx][oldy];
5275 static int MovingOrBlocked2ElementIfNotLeaving(int x, int y)
5277 // like MovingOrBlocked2Element(), but if element is moving
5278 // and (x,y) is the field the moving element is just leaving,
5279 // return EL_BLOCKED instead of the element value
5280 int element = Tile[x][y];
5282 if (IS_MOVING(x, y))
5284 if (element == EL_BLOCKED)
5288 Blocked2Moving(x, y, &oldx, &oldy);
5289 return Tile[oldx][oldy];
5298 static void RemoveField(int x, int y)
5300 Tile[x][y] = EL_EMPTY;
5306 CustomValue[x][y] = 0;
5309 ChangeDelay[x][y] = 0;
5310 ChangePage[x][y] = -1;
5311 Pushed[x][y] = FALSE;
5313 GfxElement[x][y] = EL_UNDEFINED;
5314 GfxAction[x][y] = ACTION_DEFAULT;
5315 GfxDir[x][y] = MV_NONE;
5318 static void RemoveMovingField(int x, int y)
5320 int oldx = x, oldy = y, newx = x, newy = y;
5321 int element = Tile[x][y];
5322 int next_element = EL_UNDEFINED;
5324 if (element != EL_BLOCKED && !IS_MOVING(x, y))
5327 if (IS_MOVING(x, y))
5329 Moving2Blocked(x, y, &newx, &newy);
5331 if (Tile[newx][newy] != EL_BLOCKED)
5333 // element is moving, but target field is not free (blocked), but
5334 // already occupied by something different (example: acid pool);
5335 // in this case, only remove the moving field, but not the target
5337 RemoveField(oldx, oldy);
5339 Store[oldx][oldy] = Store2[oldx][oldy] = 0;
5341 TEST_DrawLevelField(oldx, oldy);
5346 else if (element == EL_BLOCKED)
5348 Blocked2Moving(x, y, &oldx, &oldy);
5349 if (!IS_MOVING(oldx, oldy))
5353 if (element == EL_BLOCKED &&
5354 (Tile[oldx][oldy] == EL_QUICKSAND_EMPTYING ||
5355 Tile[oldx][oldy] == EL_QUICKSAND_FAST_EMPTYING ||
5356 Tile[oldx][oldy] == EL_MAGIC_WALL_EMPTYING ||
5357 Tile[oldx][oldy] == EL_BD_MAGIC_WALL_EMPTYING ||
5358 Tile[oldx][oldy] == EL_DC_MAGIC_WALL_EMPTYING ||
5359 Tile[oldx][oldy] == EL_AMOEBA_DROPPING))
5360 next_element = get_next_element(Tile[oldx][oldy]);
5362 RemoveField(oldx, oldy);
5363 RemoveField(newx, newy);
5365 Store[oldx][oldy] = Store2[oldx][oldy] = 0;
5367 if (next_element != EL_UNDEFINED)
5368 Tile[oldx][oldy] = next_element;
5370 TEST_DrawLevelField(oldx, oldy);
5371 TEST_DrawLevelField(newx, newy);
5374 void DrawDynamite(int x, int y)
5376 int sx = SCREENX(x), sy = SCREENY(y);
5377 int graphic = el2img(Tile[x][y]);
5380 if (!IN_SCR_FIELD(sx, sy) || IS_PLAYER(x, y))
5383 if (IS_WALKABLE_INSIDE(Back[x][y]))
5387 DrawLevelElement(x, y, Back[x][y]);
5388 else if (Store[x][y])
5389 DrawLevelElement(x, y, Store[x][y]);
5390 else if (game.use_masked_elements)
5391 DrawLevelElement(x, y, EL_EMPTY);
5393 frame = getGraphicAnimationFrame(graphic, GfxFrame[x][y]);
5395 if (Back[x][y] || Store[x][y] || game.use_masked_elements)
5396 DrawGraphicThruMask(sx, sy, graphic, frame);
5398 DrawGraphic(sx, sy, graphic, frame);
5401 static void CheckDynamite(int x, int y)
5403 if (MovDelay[x][y] != 0) // dynamite is still waiting to explode
5407 if (MovDelay[x][y] != 0)
5410 PlayLevelSoundActionIfLoop(x, y, ACTION_ACTIVE);
5416 StopLevelSoundActionIfLoop(x, y, ACTION_ACTIVE);
5421 static void setMinimalPlayerBoundaries(int *sx1, int *sy1, int *sx2, int *sy2)
5423 boolean num_checked_players = 0;
5426 for (i = 0; i < MAX_PLAYERS; i++)
5428 if (stored_player[i].active)
5430 int sx = stored_player[i].jx;
5431 int sy = stored_player[i].jy;
5433 if (num_checked_players == 0)
5440 *sx1 = MIN(*sx1, sx);
5441 *sy1 = MIN(*sy1, sy);
5442 *sx2 = MAX(*sx2, sx);
5443 *sy2 = MAX(*sy2, sy);
5446 num_checked_players++;
5451 static boolean checkIfAllPlayersFitToScreen_RND(void)
5453 int sx1 = 0, sy1 = 0, sx2 = 0, sy2 = 0;
5455 setMinimalPlayerBoundaries(&sx1, &sy1, &sx2, &sy2);
5457 return (sx2 - sx1 < SCR_FIELDX &&
5458 sy2 - sy1 < SCR_FIELDY);
5461 static void setScreenCenteredToAllPlayers(int *sx, int *sy)
5463 int sx1 = scroll_x, sy1 = scroll_y, sx2 = scroll_x, sy2 = scroll_y;
5465 setMinimalPlayerBoundaries(&sx1, &sy1, &sx2, &sy2);
5467 *sx = (sx1 + sx2) / 2;
5468 *sy = (sy1 + sy2) / 2;
5471 static void DrawRelocateScreen(int old_x, int old_y, int x, int y, int move_dir,
5472 boolean center_screen, boolean quick_relocation)
5474 unsigned int frame_delay_value_old = GetVideoFrameDelay();
5475 boolean ffwd_delay = (tape.playing && tape.fast_forward);
5476 boolean no_delay = (tape.warp_forward);
5477 int frame_delay_value = (ffwd_delay ? FfwdFrameDelay : GameFrameDelay);
5478 int wait_delay_value = (no_delay ? 0 : frame_delay_value);
5479 int new_scroll_x, new_scroll_y;
5481 if (level.lazy_relocation && IN_VIS_FIELD(SCREENX(x), SCREENY(y)))
5483 // case 1: quick relocation inside visible screen (without scrolling)
5490 if (!level.shifted_relocation || center_screen)
5492 // relocation _with_ centering of screen
5494 new_scroll_x = SCROLL_POSITION_X(x);
5495 new_scroll_y = SCROLL_POSITION_Y(y);
5499 // relocation _without_ centering of screen
5501 int center_scroll_x = SCROLL_POSITION_X(old_x);
5502 int center_scroll_y = SCROLL_POSITION_Y(old_y);
5503 int offset_x = x + (scroll_x - center_scroll_x);
5504 int offset_y = y + (scroll_y - center_scroll_y);
5506 // for new screen position, apply previous offset to center position
5507 new_scroll_x = SCROLL_POSITION_X(offset_x);
5508 new_scroll_y = SCROLL_POSITION_Y(offset_y);
5511 if (quick_relocation)
5513 // case 2: quick relocation (redraw without visible scrolling)
5515 scroll_x = new_scroll_x;
5516 scroll_y = new_scroll_y;
5523 // case 3: visible relocation (with scrolling to new position)
5525 ScrollScreen(NULL, SCROLL_GO_ON); // scroll last frame to full tile
5527 SetVideoFrameDelay(wait_delay_value);
5529 while (scroll_x != new_scroll_x || scroll_y != new_scroll_y)
5531 int dx = (new_scroll_x < scroll_x ? +1 : new_scroll_x > scroll_x ? -1 : 0);
5532 int dy = (new_scroll_y < scroll_y ? +1 : new_scroll_y > scroll_y ? -1 : 0);
5534 if (dx == 0 && dy == 0) // no scrolling needed at all
5540 // set values for horizontal/vertical screen scrolling (half tile size)
5541 int dir_x = (dx != 0 ? MV_HORIZONTAL : 0);
5542 int dir_y = (dy != 0 ? MV_VERTICAL : 0);
5543 int pos_x = dx * TILEX / 2;
5544 int pos_y = dy * TILEY / 2;
5545 int fx = getFieldbufferOffsetX_RND(dir_x, pos_x);
5546 int fy = getFieldbufferOffsetY_RND(dir_y, pos_y);
5548 ScrollLevel(dx, dy);
5551 // scroll in two steps of half tile size to make things smoother
5552 BlitScreenToBitmapExt_RND(window, fx, fy);
5554 // scroll second step to align at full tile size
5555 BlitScreenToBitmap(window);
5561 SetVideoFrameDelay(frame_delay_value_old);
5564 static void RelocatePlayer(int jx, int jy, int el_player_raw)
5566 int el_player = GET_PLAYER_ELEMENT(el_player_raw);
5567 int player_nr = GET_PLAYER_NR(el_player);
5568 struct PlayerInfo *player = &stored_player[player_nr];
5569 boolean ffwd_delay = (tape.playing && tape.fast_forward);
5570 boolean no_delay = (tape.warp_forward);
5571 int frame_delay_value = (ffwd_delay ? FfwdFrameDelay : GameFrameDelay);
5572 int wait_delay_value = (no_delay ? 0 : frame_delay_value);
5573 int old_jx = player->jx;
5574 int old_jy = player->jy;
5575 int old_element = Tile[old_jx][old_jy];
5576 int element = Tile[jx][jy];
5577 boolean player_relocated = (old_jx != jx || old_jy != jy);
5579 int move_dir_horiz = (jx < old_jx ? MV_LEFT : jx > old_jx ? MV_RIGHT : 0);
5580 int move_dir_vert = (jy < old_jy ? MV_UP : jy > old_jy ? MV_DOWN : 0);
5581 int enter_side_horiz = MV_DIR_OPPOSITE(move_dir_horiz);
5582 int enter_side_vert = MV_DIR_OPPOSITE(move_dir_vert);
5583 int leave_side_horiz = move_dir_horiz;
5584 int leave_side_vert = move_dir_vert;
5585 int enter_side = enter_side_horiz | enter_side_vert;
5586 int leave_side = leave_side_horiz | leave_side_vert;
5588 if (player->buried) // do not reanimate dead player
5591 if (!player_relocated) // no need to relocate the player
5594 if (IS_PLAYER(jx, jy)) // player already placed at new position
5596 RemoveField(jx, jy); // temporarily remove newly placed player
5597 DrawLevelField(jx, jy);
5600 if (player->present)
5602 while (player->MovPos)
5604 ScrollPlayer(player, SCROLL_GO_ON);
5605 ScrollScreen(NULL, SCROLL_GO_ON);
5607 AdvanceFrameAndPlayerCounters(player->index_nr);
5611 BackToFront_WithFrameDelay(wait_delay_value);
5614 DrawPlayer(player); // needed here only to cleanup last field
5615 DrawLevelField(player->jx, player->jy); // remove player graphic
5617 player->is_moving = FALSE;
5620 if (IS_CUSTOM_ELEMENT(old_element))
5621 CheckElementChangeByPlayer(old_jx, old_jy, old_element,
5623 player->index_bit, leave_side);
5625 CheckTriggeredElementChangeByPlayer(old_jx, old_jy, old_element,
5627 player->index_bit, leave_side);
5629 Tile[jx][jy] = el_player;
5630 InitPlayerField(jx, jy, el_player, TRUE);
5632 /* "InitPlayerField()" above sets Tile[jx][jy] to EL_EMPTY, but it may be
5633 possible that the relocation target field did not contain a player element,
5634 but a walkable element, to which the new player was relocated -- in this
5635 case, restore that (already initialized!) element on the player field */
5636 if (!ELEM_IS_PLAYER(element)) // player may be set on walkable element
5638 Tile[jx][jy] = element; // restore previously existing element
5641 // only visually relocate centered player
5642 DrawRelocateScreen(old_jx, old_jy, player->jx, player->jy, player->MovDir,
5643 FALSE, level.instant_relocation);
5645 TestIfPlayerTouchesBadThing(jx, jy);
5646 TestIfPlayerTouchesCustomElement(jx, jy);
5648 if (IS_CUSTOM_ELEMENT(element))
5649 CheckElementChangeByPlayer(jx, jy, element, CE_ENTERED_BY_PLAYER,
5650 player->index_bit, enter_side);
5652 CheckTriggeredElementChangeByPlayer(jx, jy, element, CE_PLAYER_ENTERS_X,
5653 player->index_bit, enter_side);
5655 if (player->is_switching)
5657 /* ensure that relocation while still switching an element does not cause
5658 a new element to be treated as also switched directly after relocation
5659 (this is important for teleporter switches that teleport the player to
5660 a place where another teleporter switch is in the same direction, which
5661 would then incorrectly be treated as immediately switched before the
5662 direction key that caused the switch was released) */
5664 player->switch_x += jx - old_jx;
5665 player->switch_y += jy - old_jy;
5669 static void Explode(int ex, int ey, int phase, int mode)
5675 // !!! eliminate this variable !!!
5676 int delay = (game.emulation == EMU_SUPAPLEX ? 3 : 2);
5678 if (game.explosions_delayed)
5680 ExplodeField[ex][ey] = mode;
5684 if (phase == EX_PHASE_START) // initialize 'Store[][]' field
5686 int center_element = Tile[ex][ey];
5687 int artwork_element, explosion_element; // set these values later
5689 // remove things displayed in background while burning dynamite
5690 if (Back[ex][ey] != EL_EMPTY && !IS_INDESTRUCTIBLE(Back[ex][ey]))
5693 if (IS_MOVING(ex, ey) || IS_BLOCKED(ex, ey))
5695 // put moving element to center field (and let it explode there)
5696 center_element = MovingOrBlocked2Element(ex, ey);
5697 RemoveMovingField(ex, ey);
5698 Tile[ex][ey] = center_element;
5701 // now "center_element" is finally determined -- set related values now
5702 artwork_element = center_element; // for custom player artwork
5703 explosion_element = center_element; // for custom player artwork
5705 if (IS_PLAYER(ex, ey))
5707 int player_nr = GET_PLAYER_NR(StorePlayer[ex][ey]);
5709 artwork_element = stored_player[player_nr].artwork_element;
5711 if (level.use_explosion_element[player_nr])
5713 explosion_element = level.explosion_element[player_nr];
5714 artwork_element = explosion_element;
5718 if (mode == EX_TYPE_NORMAL ||
5719 mode == EX_TYPE_CENTER ||
5720 mode == EX_TYPE_CROSS)
5721 PlayLevelSoundElementAction(ex, ey, artwork_element, ACTION_EXPLODING);
5723 last_phase = element_info[explosion_element].explosion_delay + 1;
5725 for (y = ey - 1; y <= ey + 1; y++) for (x = ex - 1; x <= ex + 1; x++)
5727 int xx = x - ex + 1;
5728 int yy = y - ey + 1;
5731 if (!IN_LEV_FIELD(x, y) ||
5732 (mode & EX_TYPE_SINGLE_TILE && (x != ex || y != ey)) ||
5733 (mode == EX_TYPE_CROSS && (x != ex && y != ey)))
5736 element = Tile[x][y];
5738 if (IS_MOVING(x, y) || IS_BLOCKED(x, y))
5740 element = MovingOrBlocked2Element(x, y);
5742 if (!IS_EXPLOSION_PROOF(element))
5743 RemoveMovingField(x, y);
5746 // indestructible elements can only explode in center (but not flames)
5747 if ((IS_EXPLOSION_PROOF(element) && (x != ex || y != ey ||
5748 mode == EX_TYPE_BORDER)) ||
5749 element == EL_FLAMES)
5752 /* no idea why this was changed from 3.0.8 to 3.1.0 -- this causes buggy
5753 behaviour, for example when touching a yamyam that explodes to rocks
5754 with active deadly shield, a rock is created under the player !!! */
5755 // (case 1 (surely buggy): >= 3.1.0, case 2 (maybe buggy): <= 3.0.8)
5757 if (IS_PLAYER(x, y) && SHIELD_ON(PLAYERINFO(x, y)) &&
5758 (game.engine_version < VERSION_IDENT(3,1,0,0) ||
5759 (x == ex && y == ey && mode != EX_TYPE_BORDER)))
5761 if (IS_PLAYER(x, y) && SHIELD_ON(PLAYERINFO(x, y)))
5764 if (IS_ACTIVE_BOMB(element))
5766 // re-activate things under the bomb like gate or penguin
5767 Tile[x][y] = (Back[x][y] ? Back[x][y] : EL_EMPTY);
5774 // save walkable background elements while explosion on same tile
5775 if (IS_WALKABLE(element) && IS_INDESTRUCTIBLE(element) &&
5776 (x != ex || y != ey || mode == EX_TYPE_BORDER))
5777 Back[x][y] = element;
5779 // ignite explodable elements reached by other explosion
5780 if (element == EL_EXPLOSION)
5781 element = Store2[x][y];
5783 if (AmoebaNr[x][y] &&
5784 (element == EL_AMOEBA_FULL ||
5785 element == EL_BD_AMOEBA ||
5786 element == EL_AMOEBA_GROWING))
5788 AmoebaCnt[AmoebaNr[x][y]]--;
5789 AmoebaCnt2[AmoebaNr[x][y]]--;
5794 if (IS_PLAYER(ex, ey) && !PLAYER_EXPLOSION_PROTECTED(ex, ey))
5796 int player_nr = StorePlayer[ex][ey] - EL_PLAYER_1;
5798 Store[x][y] = EL_PLAYER_IS_EXPLODING_1 + player_nr;
5800 if (PLAYERINFO(ex, ey)->use_murphy)
5801 Store[x][y] = EL_EMPTY;
5804 // !!! check this case -- currently needed for rnd_rado_negundo_v,
5805 // !!! levels 015 018 019 020 021 022 023 026 027 028 !!!
5806 else if (ELEM_IS_PLAYER(center_element))
5807 Store[x][y] = EL_EMPTY;
5808 else if (center_element == EL_YAMYAM)
5809 Store[x][y] = level.yamyam_content[game.yamyam_content_nr].e[xx][yy];
5810 else if (element_info[center_element].content.e[xx][yy] != EL_EMPTY)
5811 Store[x][y] = element_info[center_element].content.e[xx][yy];
5813 // needed because EL_BD_BUTTERFLY is not defined as "CAN_EXPLODE"
5814 // (killing EL_BD_BUTTERFLY with dynamite would result in BD diamond
5815 // otherwise) -- FIX THIS !!!
5816 else if (!CAN_EXPLODE(element) && element != EL_BD_BUTTERFLY)
5817 Store[x][y] = element_info[element].content.e[1][1];
5819 else if (!CAN_EXPLODE(element))
5820 Store[x][y] = element_info[element].content.e[1][1];
5823 Store[x][y] = EL_EMPTY;
5825 if (x != ex || y != ey || mode == EX_TYPE_BORDER ||
5826 center_element == EL_AMOEBA_TO_DIAMOND)
5827 Store2[x][y] = element;
5829 Tile[x][y] = EL_EXPLOSION;
5830 GfxElement[x][y] = artwork_element;
5832 ExplodePhase[x][y] = 1;
5833 ExplodeDelay[x][y] = last_phase;
5838 if (center_element == EL_YAMYAM)
5839 game.yamyam_content_nr =
5840 (game.yamyam_content_nr + 1) % level.num_yamyam_contents;
5852 GfxFrame[x][y] = 0; // restart explosion animation
5854 last_phase = ExplodeDelay[x][y];
5856 ExplodePhase[x][y] = (phase < last_phase ? phase + 1 : 0);
5858 // this can happen if the player leaves an explosion just in time
5859 if (GfxElement[x][y] == EL_UNDEFINED)
5860 GfxElement[x][y] = EL_EMPTY;
5862 border_element = Store2[x][y];
5863 if (IS_PLAYER(x, y) && !PLAYER_EXPLOSION_PROTECTED(x, y))
5864 border_element = StorePlayer[x][y];
5866 if (phase == element_info[border_element].ignition_delay ||
5867 phase == last_phase)
5869 boolean border_explosion = FALSE;
5871 if (IS_PLAYER(x, y) && PLAYERINFO(x, y)->present &&
5872 !PLAYER_EXPLOSION_PROTECTED(x, y))
5874 KillPlayerUnlessExplosionProtected(x, y);
5875 border_explosion = TRUE;
5877 else if (CAN_EXPLODE_BY_EXPLOSION(border_element))
5879 Tile[x][y] = Store2[x][y];
5882 border_explosion = TRUE;
5884 else if (border_element == EL_AMOEBA_TO_DIAMOND)
5886 AmoebaToDiamond(x, y);
5888 border_explosion = TRUE;
5891 // if an element just explodes due to another explosion (chain-reaction),
5892 // do not immediately end the new explosion when it was the last frame of
5893 // the explosion (as it would be done in the following "if"-statement!)
5894 if (border_explosion && phase == last_phase)
5898 if (phase == last_phase)
5902 element = Tile[x][y] = Store[x][y];
5903 Store[x][y] = Store2[x][y] = 0;
5904 GfxElement[x][y] = EL_UNDEFINED;
5906 // player can escape from explosions and might therefore be still alive
5907 if (element >= EL_PLAYER_IS_EXPLODING_1 &&
5908 element <= EL_PLAYER_IS_EXPLODING_4)
5910 int player_nr = element - EL_PLAYER_IS_EXPLODING_1;
5911 int explosion_element = EL_PLAYER_1 + player_nr;
5912 int xx = MIN(MAX(0, x - stored_player[player_nr].jx + 1), 2);
5913 int yy = MIN(MAX(0, y - stored_player[player_nr].jy + 1), 2);
5915 if (level.use_explosion_element[player_nr])
5916 explosion_element = level.explosion_element[player_nr];
5918 Tile[x][y] = (stored_player[player_nr].active ? EL_EMPTY :
5919 element_info[explosion_element].content.e[xx][yy]);
5922 // restore probably existing indestructible background element
5923 if (Back[x][y] && IS_INDESTRUCTIBLE(Back[x][y]))
5924 element = Tile[x][y] = Back[x][y];
5927 MovDir[x][y] = MovPos[x][y] = MovDelay[x][y] = 0;
5928 GfxDir[x][y] = MV_NONE;
5929 ChangeDelay[x][y] = 0;
5930 ChangePage[x][y] = -1;
5932 CustomValue[x][y] = 0;
5934 InitField_WithBug2(x, y, FALSE);
5936 TEST_DrawLevelField(x, y);
5938 TestIfElementTouchesCustomElement(x, y);
5940 if (GFX_CRUMBLED(element))
5941 TEST_DrawLevelFieldCrumbledNeighbours(x, y);
5943 if (IS_PLAYER(x, y) && !PLAYERINFO(x, y)->present)
5944 StorePlayer[x][y] = 0;
5946 if (ELEM_IS_PLAYER(element))
5947 RelocatePlayer(x, y, element);
5949 else if (IN_SCR_FIELD(SCREENX(x), SCREENY(y)))
5951 int graphic = el_act2img(GfxElement[x][y], ACTION_EXPLODING);
5952 int frame = getGraphicAnimationFrame(graphic, GfxFrame[x][y]);
5955 TEST_DrawLevelFieldCrumbled(x, y);
5957 if (IS_WALKABLE_OVER(Back[x][y]) && Back[x][y] != EL_EMPTY)
5959 DrawLevelElement(x, y, Back[x][y]);
5960 DrawGraphicThruMask(SCREENX(x), SCREENY(y), graphic, frame);
5962 else if (IS_WALKABLE_UNDER(Back[x][y]))
5964 DrawGraphic(SCREENX(x), SCREENY(y), graphic, frame);
5965 DrawLevelElementThruMask(x, y, Back[x][y]);
5967 else if (!IS_WALKABLE_INSIDE(Back[x][y]))
5968 DrawScreenGraphic(SCREENX(x), SCREENY(y), graphic, frame);
5972 static void DynaExplode(int ex, int ey)
5975 int dynabomb_element = Tile[ex][ey];
5976 int dynabomb_size = 1;
5977 boolean dynabomb_xl = FALSE;
5978 struct PlayerInfo *player;
5979 static int xy[4][2] =
5987 if (IS_ACTIVE_BOMB(dynabomb_element))
5989 player = &stored_player[dynabomb_element - EL_DYNABOMB_PLAYER_1_ACTIVE];
5990 dynabomb_size = player->dynabomb_size;
5991 dynabomb_xl = player->dynabomb_xl;
5992 player->dynabombs_left++;
5995 Explode(ex, ey, EX_PHASE_START, EX_TYPE_CENTER);
5997 for (i = 0; i < NUM_DIRECTIONS; i++)
5999 for (j = 1; j <= dynabomb_size; j++)
6001 int x = ex + j * xy[i][0];
6002 int y = ey + j * xy[i][1];
6005 if (!IN_LEV_FIELD(x, y) || IS_INDESTRUCTIBLE(Tile[x][y]))
6008 element = Tile[x][y];
6010 // do not restart explosions of fields with active bombs
6011 if (element == EL_EXPLOSION && IS_ACTIVE_BOMB(Store2[x][y]))
6014 Explode(x, y, EX_PHASE_START, EX_TYPE_BORDER);
6016 if (element != EL_EMPTY && element != EL_EXPLOSION &&
6017 !IS_DIGGABLE(element) && !dynabomb_xl)
6023 void Bang(int x, int y)
6025 int element = MovingOrBlocked2Element(x, y);
6026 int explosion_type = EX_TYPE_NORMAL;
6028 if (IS_PLAYER(x, y) && !PLAYER_EXPLOSION_PROTECTED(x, y))
6030 struct PlayerInfo *player = PLAYERINFO(x, y);
6032 element = Tile[x][y] = player->initial_element;
6034 if (level.use_explosion_element[player->index_nr])
6036 int explosion_element = level.explosion_element[player->index_nr];
6038 if (element_info[explosion_element].explosion_type == EXPLODES_CROSS)
6039 explosion_type = EX_TYPE_CROSS;
6040 else if (element_info[explosion_element].explosion_type == EXPLODES_1X1)
6041 explosion_type = EX_TYPE_CENTER;
6049 case EL_BD_BUTTERFLY:
6052 case EL_DARK_YAMYAM:
6056 RaiseScoreElement(element);
6059 case EL_DYNABOMB_PLAYER_1_ACTIVE:
6060 case EL_DYNABOMB_PLAYER_2_ACTIVE:
6061 case EL_DYNABOMB_PLAYER_3_ACTIVE:
6062 case EL_DYNABOMB_PLAYER_4_ACTIVE:
6063 case EL_DYNABOMB_INCREASE_NUMBER:
6064 case EL_DYNABOMB_INCREASE_SIZE:
6065 case EL_DYNABOMB_INCREASE_POWER:
6066 explosion_type = EX_TYPE_DYNA;
6069 case EL_DC_LANDMINE:
6070 explosion_type = EX_TYPE_CENTER;
6075 case EL_LAMP_ACTIVE:
6076 case EL_AMOEBA_TO_DIAMOND:
6077 if (!IS_PLAYER(x, y)) // penguin and player may be at same field
6078 explosion_type = EX_TYPE_CENTER;
6082 if (element_info[element].explosion_type == EXPLODES_CROSS)
6083 explosion_type = EX_TYPE_CROSS;
6084 else if (element_info[element].explosion_type == EXPLODES_1X1)
6085 explosion_type = EX_TYPE_CENTER;
6089 if (explosion_type == EX_TYPE_DYNA)
6092 Explode(x, y, EX_PHASE_START, explosion_type);
6094 CheckTriggeredElementChange(x, y, element, CE_EXPLOSION_OF_X);
6097 static void SplashAcid(int x, int y)
6099 if (IN_LEV_FIELD(x - 1, y - 1) && IS_FREE(x - 1, y - 1) &&
6100 (!IN_LEV_FIELD(x - 1, y - 2) ||
6101 !CAN_FALL(MovingOrBlocked2Element(x - 1, y - 2))))
6102 Tile[x - 1][y - 1] = EL_ACID_SPLASH_LEFT;
6104 if (IN_LEV_FIELD(x + 1, y - 1) && IS_FREE(x + 1, y - 1) &&
6105 (!IN_LEV_FIELD(x + 1, y - 2) ||
6106 !CAN_FALL(MovingOrBlocked2Element(x + 1, y - 2))))
6107 Tile[x + 1][y - 1] = EL_ACID_SPLASH_RIGHT;
6109 PlayLevelSound(x, y, SND_ACID_SPLASHING);
6112 static void InitBeltMovement(void)
6114 static int belt_base_element[4] =
6116 EL_CONVEYOR_BELT_1_LEFT,
6117 EL_CONVEYOR_BELT_2_LEFT,
6118 EL_CONVEYOR_BELT_3_LEFT,
6119 EL_CONVEYOR_BELT_4_LEFT
6121 static int belt_base_active_element[4] =
6123 EL_CONVEYOR_BELT_1_LEFT_ACTIVE,
6124 EL_CONVEYOR_BELT_2_LEFT_ACTIVE,
6125 EL_CONVEYOR_BELT_3_LEFT_ACTIVE,
6126 EL_CONVEYOR_BELT_4_LEFT_ACTIVE
6131 // set frame order for belt animation graphic according to belt direction
6132 for (i = 0; i < NUM_BELTS; i++)
6136 for (j = 0; j < NUM_BELT_PARTS; j++)
6138 int element = belt_base_active_element[belt_nr] + j;
6139 int graphic_1 = el2img(element);
6140 int graphic_2 = el2panelimg(element);
6142 if (game.belt_dir[i] == MV_LEFT)
6144 graphic_info[graphic_1].anim_mode &= ~ANIM_REVERSE;
6145 graphic_info[graphic_2].anim_mode &= ~ANIM_REVERSE;
6149 graphic_info[graphic_1].anim_mode |= ANIM_REVERSE;
6150 graphic_info[graphic_2].anim_mode |= ANIM_REVERSE;
6155 SCAN_PLAYFIELD(x, y)
6157 int element = Tile[x][y];
6159 for (i = 0; i < NUM_BELTS; i++)
6161 if (IS_BELT(element) && game.belt_dir[i] != MV_NONE)
6163 int e_belt_nr = getBeltNrFromBeltElement(element);
6166 if (e_belt_nr == belt_nr)
6168 int belt_part = Tile[x][y] - belt_base_element[belt_nr];
6170 Tile[x][y] = belt_base_active_element[belt_nr] + belt_part;
6177 static void ToggleBeltSwitch(int x, int y)
6179 static int belt_base_element[4] =
6181 EL_CONVEYOR_BELT_1_LEFT,
6182 EL_CONVEYOR_BELT_2_LEFT,
6183 EL_CONVEYOR_BELT_3_LEFT,
6184 EL_CONVEYOR_BELT_4_LEFT
6186 static int belt_base_active_element[4] =
6188 EL_CONVEYOR_BELT_1_LEFT_ACTIVE,
6189 EL_CONVEYOR_BELT_2_LEFT_ACTIVE,
6190 EL_CONVEYOR_BELT_3_LEFT_ACTIVE,
6191 EL_CONVEYOR_BELT_4_LEFT_ACTIVE
6193 static int belt_base_switch_element[4] =
6195 EL_CONVEYOR_BELT_1_SWITCH_LEFT,
6196 EL_CONVEYOR_BELT_2_SWITCH_LEFT,
6197 EL_CONVEYOR_BELT_3_SWITCH_LEFT,
6198 EL_CONVEYOR_BELT_4_SWITCH_LEFT
6200 static int belt_move_dir[4] =
6208 int element = Tile[x][y];
6209 int belt_nr = getBeltNrFromBeltSwitchElement(element);
6210 int belt_dir_nr = (game.belt_dir_nr[belt_nr] + 1) % 4;
6211 int belt_dir = belt_move_dir[belt_dir_nr];
6214 if (!IS_BELT_SWITCH(element))
6217 game.belt_dir_nr[belt_nr] = belt_dir_nr;
6218 game.belt_dir[belt_nr] = belt_dir;
6220 if (belt_dir_nr == 3)
6223 // set frame order for belt animation graphic according to belt direction
6224 for (i = 0; i < NUM_BELT_PARTS; i++)
6226 int element = belt_base_active_element[belt_nr] + i;
6227 int graphic_1 = el2img(element);
6228 int graphic_2 = el2panelimg(element);
6230 if (belt_dir == MV_LEFT)
6232 graphic_info[graphic_1].anim_mode &= ~ANIM_REVERSE;
6233 graphic_info[graphic_2].anim_mode &= ~ANIM_REVERSE;
6237 graphic_info[graphic_1].anim_mode |= ANIM_REVERSE;
6238 graphic_info[graphic_2].anim_mode |= ANIM_REVERSE;
6242 SCAN_PLAYFIELD(xx, yy)
6244 int element = Tile[xx][yy];
6246 if (IS_BELT_SWITCH(element))
6248 int e_belt_nr = getBeltNrFromBeltSwitchElement(element);
6250 if (e_belt_nr == belt_nr)
6252 Tile[xx][yy] = belt_base_switch_element[belt_nr] + belt_dir_nr;
6253 TEST_DrawLevelField(xx, yy);
6256 else if (IS_BELT(element) && belt_dir != MV_NONE)
6258 int e_belt_nr = getBeltNrFromBeltElement(element);
6260 if (e_belt_nr == belt_nr)
6262 int belt_part = Tile[xx][yy] - belt_base_element[belt_nr];
6264 Tile[xx][yy] = belt_base_active_element[belt_nr] + belt_part;
6265 TEST_DrawLevelField(xx, yy);
6268 else if (IS_BELT_ACTIVE(element) && belt_dir == MV_NONE)
6270 int e_belt_nr = getBeltNrFromBeltActiveElement(element);
6272 if (e_belt_nr == belt_nr)
6274 int belt_part = Tile[xx][yy] - belt_base_active_element[belt_nr];
6276 Tile[xx][yy] = belt_base_element[belt_nr] + belt_part;
6277 TEST_DrawLevelField(xx, yy);
6283 static void ToggleSwitchgateSwitch(int x, int y)
6287 game.switchgate_pos = !game.switchgate_pos;
6289 SCAN_PLAYFIELD(xx, yy)
6291 int element = Tile[xx][yy];
6293 if (element == EL_SWITCHGATE_SWITCH_UP)
6295 Tile[xx][yy] = EL_SWITCHGATE_SWITCH_DOWN;
6296 TEST_DrawLevelField(xx, yy);
6298 else if (element == EL_SWITCHGATE_SWITCH_DOWN)
6300 Tile[xx][yy] = EL_SWITCHGATE_SWITCH_UP;
6301 TEST_DrawLevelField(xx, yy);
6303 else if (element == EL_DC_SWITCHGATE_SWITCH_UP)
6305 Tile[xx][yy] = EL_DC_SWITCHGATE_SWITCH_DOWN;
6306 TEST_DrawLevelField(xx, yy);
6308 else if (element == EL_DC_SWITCHGATE_SWITCH_DOWN)
6310 Tile[xx][yy] = EL_DC_SWITCHGATE_SWITCH_UP;
6311 TEST_DrawLevelField(xx, yy);
6313 else if (element == EL_SWITCHGATE_OPEN ||
6314 element == EL_SWITCHGATE_OPENING)
6316 Tile[xx][yy] = EL_SWITCHGATE_CLOSING;
6318 PlayLevelSoundAction(xx, yy, ACTION_CLOSING);
6320 else if (element == EL_SWITCHGATE_CLOSED ||
6321 element == EL_SWITCHGATE_CLOSING)
6323 Tile[xx][yy] = EL_SWITCHGATE_OPENING;
6325 PlayLevelSoundAction(xx, yy, ACTION_OPENING);
6330 static int getInvisibleActiveFromInvisibleElement(int element)
6332 return (element == EL_INVISIBLE_STEELWALL ? EL_INVISIBLE_STEELWALL_ACTIVE :
6333 element == EL_INVISIBLE_WALL ? EL_INVISIBLE_WALL_ACTIVE :
6334 element == EL_INVISIBLE_SAND ? EL_INVISIBLE_SAND_ACTIVE :
6338 static int getInvisibleFromInvisibleActiveElement(int element)
6340 return (element == EL_INVISIBLE_STEELWALL_ACTIVE ? EL_INVISIBLE_STEELWALL :
6341 element == EL_INVISIBLE_WALL_ACTIVE ? EL_INVISIBLE_WALL :
6342 element == EL_INVISIBLE_SAND_ACTIVE ? EL_INVISIBLE_SAND :
6346 static void RedrawAllLightSwitchesAndInvisibleElements(void)
6350 SCAN_PLAYFIELD(x, y)
6352 int element = Tile[x][y];
6354 if (element == EL_LIGHT_SWITCH &&
6355 game.light_time_left > 0)
6357 Tile[x][y] = EL_LIGHT_SWITCH_ACTIVE;
6358 TEST_DrawLevelField(x, y);
6360 else if (element == EL_LIGHT_SWITCH_ACTIVE &&
6361 game.light_time_left == 0)
6363 Tile[x][y] = EL_LIGHT_SWITCH;
6364 TEST_DrawLevelField(x, y);
6366 else if (element == EL_EMC_DRIPPER &&
6367 game.light_time_left > 0)
6369 Tile[x][y] = EL_EMC_DRIPPER_ACTIVE;
6370 TEST_DrawLevelField(x, y);
6372 else if (element == EL_EMC_DRIPPER_ACTIVE &&
6373 game.light_time_left == 0)
6375 Tile[x][y] = EL_EMC_DRIPPER;
6376 TEST_DrawLevelField(x, y);
6378 else if (element == EL_INVISIBLE_STEELWALL ||
6379 element == EL_INVISIBLE_WALL ||
6380 element == EL_INVISIBLE_SAND)
6382 if (game.light_time_left > 0)
6383 Tile[x][y] = getInvisibleActiveFromInvisibleElement(element);
6385 TEST_DrawLevelField(x, y);
6387 // uncrumble neighbour fields, if needed
6388 if (element == EL_INVISIBLE_SAND)
6389 TEST_DrawLevelFieldCrumbledNeighbours(x, y);
6391 else if (element == EL_INVISIBLE_STEELWALL_ACTIVE ||
6392 element == EL_INVISIBLE_WALL_ACTIVE ||
6393 element == EL_INVISIBLE_SAND_ACTIVE)
6395 if (game.light_time_left == 0)
6396 Tile[x][y] = getInvisibleFromInvisibleActiveElement(element);
6398 TEST_DrawLevelField(x, y);
6400 // re-crumble neighbour fields, if needed
6401 if (element == EL_INVISIBLE_SAND)
6402 TEST_DrawLevelFieldCrumbledNeighbours(x, y);
6407 static void RedrawAllInvisibleElementsForLenses(void)
6411 SCAN_PLAYFIELD(x, y)
6413 int element = Tile[x][y];
6415 if (element == EL_EMC_DRIPPER &&
6416 game.lenses_time_left > 0)
6418 Tile[x][y] = EL_EMC_DRIPPER_ACTIVE;
6419 TEST_DrawLevelField(x, y);
6421 else if (element == EL_EMC_DRIPPER_ACTIVE &&
6422 game.lenses_time_left == 0)
6424 Tile[x][y] = EL_EMC_DRIPPER;
6425 TEST_DrawLevelField(x, y);
6427 else if (element == EL_INVISIBLE_STEELWALL ||
6428 element == EL_INVISIBLE_WALL ||
6429 element == EL_INVISIBLE_SAND)
6431 if (game.lenses_time_left > 0)
6432 Tile[x][y] = getInvisibleActiveFromInvisibleElement(element);
6434 TEST_DrawLevelField(x, y);
6436 // uncrumble neighbour fields, if needed
6437 if (element == EL_INVISIBLE_SAND)
6438 TEST_DrawLevelFieldCrumbledNeighbours(x, y);
6440 else if (element == EL_INVISIBLE_STEELWALL_ACTIVE ||
6441 element == EL_INVISIBLE_WALL_ACTIVE ||
6442 element == EL_INVISIBLE_SAND_ACTIVE)
6444 if (game.lenses_time_left == 0)
6445 Tile[x][y] = getInvisibleFromInvisibleActiveElement(element);
6447 TEST_DrawLevelField(x, y);
6449 // re-crumble neighbour fields, if needed
6450 if (element == EL_INVISIBLE_SAND)
6451 TEST_DrawLevelFieldCrumbledNeighbours(x, y);
6456 static void RedrawAllInvisibleElementsForMagnifier(void)
6460 SCAN_PLAYFIELD(x, y)
6462 int element = Tile[x][y];
6464 if (element == EL_EMC_FAKE_GRASS &&
6465 game.magnify_time_left > 0)
6467 Tile[x][y] = EL_EMC_FAKE_GRASS_ACTIVE;
6468 TEST_DrawLevelField(x, y);
6470 else if (element == EL_EMC_FAKE_GRASS_ACTIVE &&
6471 game.magnify_time_left == 0)
6473 Tile[x][y] = EL_EMC_FAKE_GRASS;
6474 TEST_DrawLevelField(x, y);
6476 else if (IS_GATE_GRAY(element) &&
6477 game.magnify_time_left > 0)
6479 Tile[x][y] = (IS_RND_GATE_GRAY(element) ?
6480 element - EL_GATE_1_GRAY + EL_GATE_1_GRAY_ACTIVE :
6481 IS_EM_GATE_GRAY(element) ?
6482 element - EL_EM_GATE_1_GRAY + EL_EM_GATE_1_GRAY_ACTIVE :
6483 IS_EMC_GATE_GRAY(element) ?
6484 element - EL_EMC_GATE_5_GRAY + EL_EMC_GATE_5_GRAY_ACTIVE :
6485 IS_DC_GATE_GRAY(element) ?
6486 EL_DC_GATE_WHITE_GRAY_ACTIVE :
6488 TEST_DrawLevelField(x, y);
6490 else if (IS_GATE_GRAY_ACTIVE(element) &&
6491 game.magnify_time_left == 0)
6493 Tile[x][y] = (IS_RND_GATE_GRAY_ACTIVE(element) ?
6494 element - EL_GATE_1_GRAY_ACTIVE + EL_GATE_1_GRAY :
6495 IS_EM_GATE_GRAY_ACTIVE(element) ?
6496 element - EL_EM_GATE_1_GRAY_ACTIVE + EL_EM_GATE_1_GRAY :
6497 IS_EMC_GATE_GRAY_ACTIVE(element) ?
6498 element - EL_EMC_GATE_5_GRAY_ACTIVE + EL_EMC_GATE_5_GRAY :
6499 IS_DC_GATE_GRAY_ACTIVE(element) ?
6500 EL_DC_GATE_WHITE_GRAY :
6502 TEST_DrawLevelField(x, y);
6507 static void ToggleLightSwitch(int x, int y)
6509 int element = Tile[x][y];
6511 game.light_time_left =
6512 (element == EL_LIGHT_SWITCH ?
6513 level.time_light * FRAMES_PER_SECOND : 0);
6515 RedrawAllLightSwitchesAndInvisibleElements();
6518 static void ActivateTimegateSwitch(int x, int y)
6522 game.timegate_time_left = level.time_timegate * FRAMES_PER_SECOND;
6524 SCAN_PLAYFIELD(xx, yy)
6526 int element = Tile[xx][yy];
6528 if (element == EL_TIMEGATE_CLOSED ||
6529 element == EL_TIMEGATE_CLOSING)
6531 Tile[xx][yy] = EL_TIMEGATE_OPENING;
6532 PlayLevelSound(xx, yy, SND_CLASS_TIMEGATE_OPENING);
6536 else if (element == EL_TIMEGATE_SWITCH_ACTIVE)
6538 Tile[xx][yy] = EL_TIMEGATE_SWITCH;
6539 TEST_DrawLevelField(xx, yy);
6545 Tile[x][y] = (Tile[x][y] == EL_TIMEGATE_SWITCH ? EL_TIMEGATE_SWITCH_ACTIVE :
6546 EL_DC_TIMEGATE_SWITCH_ACTIVE);
6549 static void Impact(int x, int y)
6551 boolean last_line = (y == lev_fieldy - 1);
6552 boolean object_hit = FALSE;
6553 boolean impact = (last_line || object_hit);
6554 int element = Tile[x][y];
6555 int smashed = EL_STEELWALL;
6557 if (!last_line) // check if element below was hit
6559 if (Tile[x][y + 1] == EL_PLAYER_IS_LEAVING)
6562 object_hit = (!IS_FREE(x, y + 1) && (!IS_MOVING(x, y + 1) ||
6563 MovDir[x][y + 1] != MV_DOWN ||
6564 MovPos[x][y + 1] <= TILEY / 2));
6566 // do not smash moving elements that left the smashed field in time
6567 if (game.engine_version >= VERSION_IDENT(2,2,0,7) && IS_MOVING(x, y + 1) &&
6568 ABS(MovPos[x][y + 1] + getElementMoveStepsize(x, y + 1)) >= TILEX)
6571 #if USE_QUICKSAND_IMPACT_BUGFIX
6572 if (Tile[x][y + 1] == EL_QUICKSAND_EMPTYING && object_hit == FALSE)
6574 RemoveMovingField(x, y + 1);
6575 Tile[x][y + 1] = EL_QUICKSAND_EMPTY;
6576 Tile[x][y + 2] = EL_ROCK;
6577 TEST_DrawLevelField(x, y + 2);
6582 if (Tile[x][y + 1] == EL_QUICKSAND_FAST_EMPTYING && object_hit == FALSE)
6584 RemoveMovingField(x, y + 1);
6585 Tile[x][y + 1] = EL_QUICKSAND_FAST_EMPTY;
6586 Tile[x][y + 2] = EL_ROCK;
6587 TEST_DrawLevelField(x, y + 2);
6594 smashed = MovingOrBlocked2Element(x, y + 1);
6596 impact = (last_line || object_hit);
6599 if (!last_line && smashed == EL_ACID) // element falls into acid
6601 SplashAcid(x, y + 1);
6605 // !!! not sufficient for all cases -- see EL_PEARL below !!!
6606 // only reset graphic animation if graphic really changes after impact
6608 el_act_dir2img(element, GfxAction[x][y], MV_DOWN) != el2img(element))
6610 ResetGfxAnimation(x, y);
6611 TEST_DrawLevelField(x, y);
6614 if (impact && CAN_EXPLODE_IMPACT(element))
6619 else if (impact && element == EL_PEARL &&
6620 smashed != EL_DC_MAGIC_WALL && smashed != EL_DC_MAGIC_WALL_ACTIVE)
6622 ResetGfxAnimation(x, y);
6624 Tile[x][y] = EL_PEARL_BREAKING;
6625 PlayLevelSound(x, y, SND_PEARL_BREAKING);
6628 else if (impact && CheckElementChange(x, y, element, smashed, CE_IMPACT))
6630 PlayLevelSoundElementAction(x, y, element, ACTION_IMPACT);
6635 if (impact && element == EL_AMOEBA_DROP)
6637 if (object_hit && IS_PLAYER(x, y + 1))
6638 KillPlayerUnlessEnemyProtected(x, y + 1);
6639 else if (object_hit && smashed == EL_PENGUIN)
6643 Tile[x][y] = EL_AMOEBA_GROWING;
6644 Store[x][y] = EL_AMOEBA_WET;
6646 ResetRandomAnimationValue(x, y);
6651 if (object_hit) // check which object was hit
6653 if ((CAN_PASS_MAGIC_WALL(element) &&
6654 (smashed == EL_MAGIC_WALL ||
6655 smashed == EL_BD_MAGIC_WALL)) ||
6656 (CAN_PASS_DC_MAGIC_WALL(element) &&
6657 smashed == EL_DC_MAGIC_WALL))
6660 int activated_magic_wall =
6661 (smashed == EL_MAGIC_WALL ? EL_MAGIC_WALL_ACTIVE :
6662 smashed == EL_BD_MAGIC_WALL ? EL_BD_MAGIC_WALL_ACTIVE :
6663 EL_DC_MAGIC_WALL_ACTIVE);
6665 // activate magic wall / mill
6666 SCAN_PLAYFIELD(xx, yy)
6668 if (Tile[xx][yy] == smashed)
6669 Tile[xx][yy] = activated_magic_wall;
6672 game.magic_wall_time_left = level.time_magic_wall * FRAMES_PER_SECOND;
6673 game.magic_wall_active = TRUE;
6675 PlayLevelSound(x, y, (smashed == EL_MAGIC_WALL ?
6676 SND_MAGIC_WALL_ACTIVATING :
6677 smashed == EL_BD_MAGIC_WALL ?
6678 SND_BD_MAGIC_WALL_ACTIVATING :
6679 SND_DC_MAGIC_WALL_ACTIVATING));
6682 if (IS_PLAYER(x, y + 1))
6684 if (CAN_SMASH_PLAYER(element))
6686 KillPlayerUnlessEnemyProtected(x, y + 1);
6690 else if (smashed == EL_PENGUIN)
6692 if (CAN_SMASH_PLAYER(element))
6698 else if (element == EL_BD_DIAMOND)
6700 if (IS_CLASSIC_ENEMY(smashed) && IS_BD_ELEMENT(smashed))
6706 else if (((element == EL_SP_INFOTRON ||
6707 element == EL_SP_ZONK) &&
6708 (smashed == EL_SP_SNIKSNAK ||
6709 smashed == EL_SP_ELECTRON ||
6710 smashed == EL_SP_DISK_ORANGE)) ||
6711 (element == EL_SP_INFOTRON &&
6712 smashed == EL_SP_DISK_YELLOW))
6717 else if (CAN_SMASH_EVERYTHING(element))
6719 if (IS_CLASSIC_ENEMY(smashed) ||
6720 CAN_EXPLODE_SMASHED(smashed))
6725 else if (!IS_MOVING(x, y + 1) && !IS_BLOCKED(x, y + 1))
6727 if (smashed == EL_LAMP ||
6728 smashed == EL_LAMP_ACTIVE)
6733 else if (smashed == EL_NUT)
6735 Tile[x][y + 1] = EL_NUT_BREAKING;
6736 PlayLevelSound(x, y, SND_NUT_BREAKING);
6737 RaiseScoreElement(EL_NUT);
6740 else if (smashed == EL_PEARL)
6742 ResetGfxAnimation(x, y);
6744 Tile[x][y + 1] = EL_PEARL_BREAKING;
6745 PlayLevelSound(x, y, SND_PEARL_BREAKING);
6748 else if (smashed == EL_DIAMOND)
6750 Tile[x][y + 1] = EL_DIAMOND_BREAKING;
6751 PlayLevelSound(x, y, SND_DIAMOND_BREAKING);
6754 else if (IS_BELT_SWITCH(smashed))
6756 ToggleBeltSwitch(x, y + 1);
6758 else if (smashed == EL_SWITCHGATE_SWITCH_UP ||
6759 smashed == EL_SWITCHGATE_SWITCH_DOWN ||
6760 smashed == EL_DC_SWITCHGATE_SWITCH_UP ||
6761 smashed == EL_DC_SWITCHGATE_SWITCH_DOWN)
6763 ToggleSwitchgateSwitch(x, y + 1);
6765 else if (smashed == EL_LIGHT_SWITCH ||
6766 smashed == EL_LIGHT_SWITCH_ACTIVE)
6768 ToggleLightSwitch(x, y + 1);
6772 CheckElementChange(x, y + 1, smashed, element, CE_SMASHED);
6774 CheckElementChangeBySide(x, y + 1, smashed, element,
6775 CE_SWITCHED, CH_SIDE_TOP);
6776 CheckTriggeredElementChangeBySide(x, y + 1, smashed, CE_SWITCH_OF_X,
6782 CheckElementChange(x, y + 1, smashed, element, CE_SMASHED);
6787 // play sound of magic wall / mill
6789 (Tile[x][y + 1] == EL_MAGIC_WALL_ACTIVE ||
6790 Tile[x][y + 1] == EL_BD_MAGIC_WALL_ACTIVE ||
6791 Tile[x][y + 1] == EL_DC_MAGIC_WALL_ACTIVE))
6793 if (Tile[x][y + 1] == EL_MAGIC_WALL_ACTIVE)
6794 PlayLevelSound(x, y, SND_MAGIC_WALL_FILLING);
6795 else if (Tile[x][y + 1] == EL_BD_MAGIC_WALL_ACTIVE)
6796 PlayLevelSound(x, y, SND_BD_MAGIC_WALL_FILLING);
6797 else if (Tile[x][y + 1] == EL_DC_MAGIC_WALL_ACTIVE)
6798 PlayLevelSound(x, y, SND_DC_MAGIC_WALL_FILLING);
6803 // play sound of object that hits the ground
6804 if (last_line || object_hit)
6805 PlayLevelSoundElementAction(x, y, element, ACTION_IMPACT);
6808 static void TurnRoundExt(int x, int y)
6820 { 0, 0 }, { 0, 0 }, { 0, 0 },
6825 int left, right, back;
6829 { MV_DOWN, MV_UP, MV_RIGHT },
6830 { MV_UP, MV_DOWN, MV_LEFT },
6832 { MV_LEFT, MV_RIGHT, MV_DOWN },
6836 { MV_RIGHT, MV_LEFT, MV_UP }
6839 int element = Tile[x][y];
6840 int move_pattern = element_info[element].move_pattern;
6842 int old_move_dir = MovDir[x][y];
6843 int left_dir = turn[old_move_dir].left;
6844 int right_dir = turn[old_move_dir].right;
6845 int back_dir = turn[old_move_dir].back;
6847 int left_dx = move_xy[left_dir].dx, left_dy = move_xy[left_dir].dy;
6848 int right_dx = move_xy[right_dir].dx, right_dy = move_xy[right_dir].dy;
6849 int move_dx = move_xy[old_move_dir].dx, move_dy = move_xy[old_move_dir].dy;
6850 int back_dx = move_xy[back_dir].dx, back_dy = move_xy[back_dir].dy;
6852 int left_x = x + left_dx, left_y = y + left_dy;
6853 int right_x = x + right_dx, right_y = y + right_dy;
6854 int move_x = x + move_dx, move_y = y + move_dy;
6858 if (element == EL_BUG || element == EL_BD_BUTTERFLY)
6860 TestIfBadThingTouchesOtherBadThing(x, y);
6862 if (ENEMY_CAN_ENTER_FIELD(element, right_x, right_y))
6863 MovDir[x][y] = right_dir;
6864 else if (!ENEMY_CAN_ENTER_FIELD(element, move_x, move_y))
6865 MovDir[x][y] = left_dir;
6867 if (element == EL_BUG && MovDir[x][y] != old_move_dir)
6869 else if (element == EL_BD_BUTTERFLY) // && MovDir[x][y] == left_dir)
6872 else if (element == EL_SPACESHIP || element == EL_BD_FIREFLY)
6874 TestIfBadThingTouchesOtherBadThing(x, y);
6876 if (ENEMY_CAN_ENTER_FIELD(element, left_x, left_y))
6877 MovDir[x][y] = left_dir;
6878 else if (!ENEMY_CAN_ENTER_FIELD(element, move_x, move_y))
6879 MovDir[x][y] = right_dir;
6881 if (element == EL_SPACESHIP && MovDir[x][y] != old_move_dir)
6883 else if (element == EL_BD_FIREFLY) // && MovDir[x][y] == right_dir)
6886 else if (element == EL_SP_SNIKSNAK || element == EL_SP_ELECTRON)
6888 TestIfBadThingTouchesOtherBadThing(x, y);
6890 if (ELEMENT_CAN_ENTER_FIELD_BASE_4(element, left_x, left_y, 0))
6891 MovDir[x][y] = left_dir;
6892 else if (!ELEMENT_CAN_ENTER_FIELD_BASE_4(element, move_x, move_y, 0))
6893 MovDir[x][y] = right_dir;
6895 if (MovDir[x][y] != old_move_dir)
6898 else if (element == EL_YAMYAM)
6900 boolean can_turn_left = YAMYAM_CAN_ENTER_FIELD(element, left_x, left_y);
6901 boolean can_turn_right = YAMYAM_CAN_ENTER_FIELD(element, right_x, right_y);
6903 if (can_turn_left && can_turn_right)
6904 MovDir[x][y] = (RND(3) ? (RND(2) ? left_dir : right_dir) : back_dir);
6905 else if (can_turn_left)
6906 MovDir[x][y] = (RND(2) ? left_dir : back_dir);
6907 else if (can_turn_right)
6908 MovDir[x][y] = (RND(2) ? right_dir : back_dir);
6910 MovDir[x][y] = back_dir;
6912 MovDelay[x][y] = 16 + 16 * RND(3);
6914 else if (element == EL_DARK_YAMYAM)
6916 boolean can_turn_left = DARK_YAMYAM_CAN_ENTER_FIELD(element,
6918 boolean can_turn_right = DARK_YAMYAM_CAN_ENTER_FIELD(element,
6921 if (can_turn_left && can_turn_right)
6922 MovDir[x][y] = (RND(3) ? (RND(2) ? left_dir : right_dir) : back_dir);
6923 else if (can_turn_left)
6924 MovDir[x][y] = (RND(2) ? left_dir : back_dir);
6925 else if (can_turn_right)
6926 MovDir[x][y] = (RND(2) ? right_dir : back_dir);
6928 MovDir[x][y] = back_dir;
6930 MovDelay[x][y] = 16 + 16 * RND(3);
6932 else if (element == EL_PACMAN)
6934 boolean can_turn_left = PACMAN_CAN_ENTER_FIELD(element, left_x, left_y);
6935 boolean can_turn_right = PACMAN_CAN_ENTER_FIELD(element, right_x, right_y);
6937 if (can_turn_left && can_turn_right)
6938 MovDir[x][y] = (RND(3) ? (RND(2) ? left_dir : right_dir) : back_dir);
6939 else if (can_turn_left)
6940 MovDir[x][y] = (RND(2) ? left_dir : back_dir);
6941 else if (can_turn_right)
6942 MovDir[x][y] = (RND(2) ? right_dir : back_dir);
6944 MovDir[x][y] = back_dir;
6946 MovDelay[x][y] = 6 + RND(40);
6948 else if (element == EL_PIG)
6950 boolean can_turn_left = PIG_CAN_ENTER_FIELD(element, left_x, left_y);
6951 boolean can_turn_right = PIG_CAN_ENTER_FIELD(element, right_x, right_y);
6952 boolean can_move_on = PIG_CAN_ENTER_FIELD(element, move_x, move_y);
6953 boolean should_turn_left, should_turn_right, should_move_on;
6955 int rnd = RND(rnd_value);
6957 should_turn_left = (can_turn_left &&
6959 IN_LEV_FIELD_AND_NOT_FREE(x + back_dx + left_dx,
6960 y + back_dy + left_dy)));
6961 should_turn_right = (can_turn_right &&
6963 IN_LEV_FIELD_AND_NOT_FREE(x + back_dx + right_dx,
6964 y + back_dy + right_dy)));
6965 should_move_on = (can_move_on &&
6968 IN_LEV_FIELD_AND_NOT_FREE(x + move_dx + left_dx,
6969 y + move_dy + left_dy) ||
6970 IN_LEV_FIELD_AND_NOT_FREE(x + move_dx + right_dx,
6971 y + move_dy + right_dy)));
6973 if (should_turn_left || should_turn_right || should_move_on)
6975 if (should_turn_left && should_turn_right && should_move_on)
6976 MovDir[x][y] = (rnd < rnd_value / 3 ? left_dir :
6977 rnd < 2 * rnd_value / 3 ? right_dir :
6979 else if (should_turn_left && should_turn_right)
6980 MovDir[x][y] = (rnd < rnd_value / 2 ? left_dir : right_dir);
6981 else if (should_turn_left && should_move_on)
6982 MovDir[x][y] = (rnd < rnd_value / 2 ? left_dir : old_move_dir);
6983 else if (should_turn_right && should_move_on)
6984 MovDir[x][y] = (rnd < rnd_value / 2 ? right_dir : old_move_dir);
6985 else if (should_turn_left)
6986 MovDir[x][y] = left_dir;
6987 else if (should_turn_right)
6988 MovDir[x][y] = right_dir;
6989 else if (should_move_on)
6990 MovDir[x][y] = old_move_dir;
6992 else if (can_move_on && rnd > rnd_value / 8)
6993 MovDir[x][y] = old_move_dir;
6994 else if (can_turn_left && can_turn_right)
6995 MovDir[x][y] = (rnd < rnd_value / 2 ? left_dir : right_dir);
6996 else if (can_turn_left && rnd > rnd_value / 8)
6997 MovDir[x][y] = left_dir;
6998 else if (can_turn_right && rnd > rnd_value/8)
6999 MovDir[x][y] = right_dir;
7001 MovDir[x][y] = back_dir;
7003 xx = x + move_xy[MovDir[x][y]].dx;
7004 yy = y + move_xy[MovDir[x][y]].dy;
7006 if (!IN_LEV_FIELD(xx, yy) ||
7007 (!IS_FREE(xx, yy) && !IS_FOOD_PIG(Tile[xx][yy])))
7008 MovDir[x][y] = old_move_dir;
7012 else if (element == EL_DRAGON)
7014 boolean can_turn_left = DRAGON_CAN_ENTER_FIELD(element, left_x, left_y);
7015 boolean can_turn_right = DRAGON_CAN_ENTER_FIELD(element, right_x, right_y);
7016 boolean can_move_on = DRAGON_CAN_ENTER_FIELD(element, move_x, move_y);
7018 int rnd = RND(rnd_value);
7020 if (can_move_on && rnd > rnd_value / 8)
7021 MovDir[x][y] = old_move_dir;
7022 else if (can_turn_left && can_turn_right)
7023 MovDir[x][y] = (rnd < rnd_value / 2 ? left_dir : right_dir);
7024 else if (can_turn_left && rnd > rnd_value / 8)
7025 MovDir[x][y] = left_dir;
7026 else if (can_turn_right && rnd > rnd_value / 8)
7027 MovDir[x][y] = right_dir;
7029 MovDir[x][y] = back_dir;
7031 xx = x + move_xy[MovDir[x][y]].dx;
7032 yy = y + move_xy[MovDir[x][y]].dy;
7034 if (!IN_LEV_FIELD_AND_IS_FREE(xx, yy))
7035 MovDir[x][y] = old_move_dir;
7039 else if (element == EL_MOLE)
7041 boolean can_move_on =
7042 (MOLE_CAN_ENTER_FIELD(element, move_x, move_y,
7043 IS_AMOEBOID(Tile[move_x][move_y]) ||
7044 Tile[move_x][move_y] == EL_AMOEBA_SHRINKING));
7047 boolean can_turn_left =
7048 (MOLE_CAN_ENTER_FIELD(element, left_x, left_y,
7049 IS_AMOEBOID(Tile[left_x][left_y])));
7051 boolean can_turn_right =
7052 (MOLE_CAN_ENTER_FIELD(element, right_x, right_y,
7053 IS_AMOEBOID(Tile[right_x][right_y])));
7055 if (can_turn_left && can_turn_right)
7056 MovDir[x][y] = (RND(2) ? left_dir : right_dir);
7057 else if (can_turn_left)
7058 MovDir[x][y] = left_dir;
7060 MovDir[x][y] = right_dir;
7063 if (MovDir[x][y] != old_move_dir)
7066 else if (element == EL_BALLOON)
7068 MovDir[x][y] = game.wind_direction;
7071 else if (element == EL_SPRING)
7073 if (MovDir[x][y] & MV_HORIZONTAL)
7075 if (SPRING_CAN_BUMP_FROM_FIELD(move_x, move_y) &&
7076 !SPRING_CAN_ENTER_FIELD(element, x, y + 1))
7078 Tile[move_x][move_y] = EL_EMC_SPRING_BUMPER_ACTIVE;
7079 ResetGfxAnimation(move_x, move_y);
7080 TEST_DrawLevelField(move_x, move_y);
7082 MovDir[x][y] = back_dir;
7084 else if (!SPRING_CAN_ENTER_FIELD(element, move_x, move_y) ||
7085 SPRING_CAN_ENTER_FIELD(element, x, y + 1))
7086 MovDir[x][y] = MV_NONE;
7091 else if (element == EL_ROBOT ||
7092 element == EL_SATELLITE ||
7093 element == EL_PENGUIN ||
7094 element == EL_EMC_ANDROID)
7096 int attr_x = -1, attr_y = -1;
7098 if (game.all_players_gone)
7100 attr_x = game.exit_x;
7101 attr_y = game.exit_y;
7107 for (i = 0; i < MAX_PLAYERS; i++)
7109 struct PlayerInfo *player = &stored_player[i];
7110 int jx = player->jx, jy = player->jy;
7112 if (!player->active)
7116 ABS(jx - x) + ABS(jy - y) < ABS(attr_x - x) + ABS(attr_y - y))
7124 if (element == EL_ROBOT &&
7125 game.robot_wheel_x >= 0 &&
7126 game.robot_wheel_y >= 0 &&
7127 (Tile[game.robot_wheel_x][game.robot_wheel_y] == EL_ROBOT_WHEEL_ACTIVE ||
7128 game.engine_version < VERSION_IDENT(3,1,0,0)))
7130 attr_x = game.robot_wheel_x;
7131 attr_y = game.robot_wheel_y;
7134 if (element == EL_PENGUIN)
7137 static int xy[4][2] =
7145 for (i = 0; i < NUM_DIRECTIONS; i++)
7147 int ex = x + xy[i][0];
7148 int ey = y + xy[i][1];
7150 if (IN_LEV_FIELD(ex, ey) && (Tile[ex][ey] == EL_EXIT_OPEN ||
7151 Tile[ex][ey] == EL_EM_EXIT_OPEN ||
7152 Tile[ex][ey] == EL_STEEL_EXIT_OPEN ||
7153 Tile[ex][ey] == EL_EM_STEEL_EXIT_OPEN))
7162 MovDir[x][y] = MV_NONE;
7164 MovDir[x][y] |= (game.all_players_gone ? MV_RIGHT : MV_LEFT);
7165 else if (attr_x > x)
7166 MovDir[x][y] |= (game.all_players_gone ? MV_LEFT : MV_RIGHT);
7168 MovDir[x][y] |= (game.all_players_gone ? MV_DOWN : MV_UP);
7169 else if (attr_y > y)
7170 MovDir[x][y] |= (game.all_players_gone ? MV_UP : MV_DOWN);
7172 if (element == EL_ROBOT)
7176 if (MovDir[x][y] & MV_HORIZONTAL && MovDir[x][y] & MV_VERTICAL)
7177 MovDir[x][y] &= (RND(2) ? MV_HORIZONTAL : MV_VERTICAL);
7178 Moving2Blocked(x, y, &newx, &newy);
7180 if (IN_LEV_FIELD(newx, newy) && IS_FREE_OR_PLAYER(newx, newy))
7181 MovDelay[x][y] = 8 + 8 * !RND(3);
7183 MovDelay[x][y] = 16;
7185 else if (element == EL_PENGUIN)
7191 if (MovDir[x][y] & MV_HORIZONTAL && MovDir[x][y] & MV_VERTICAL)
7193 boolean first_horiz = RND(2);
7194 int new_move_dir = MovDir[x][y];
7197 new_move_dir & (first_horiz ? MV_HORIZONTAL : MV_VERTICAL);
7198 Moving2Blocked(x, y, &newx, &newy);
7200 if (PENGUIN_CAN_ENTER_FIELD(element, newx, newy))
7204 new_move_dir & (!first_horiz ? MV_HORIZONTAL : MV_VERTICAL);
7205 Moving2Blocked(x, y, &newx, &newy);
7207 if (PENGUIN_CAN_ENTER_FIELD(element, newx, newy))
7210 MovDir[x][y] = old_move_dir;
7214 else if (element == EL_SATELLITE)
7220 if (MovDir[x][y] & MV_HORIZONTAL && MovDir[x][y] & MV_VERTICAL)
7222 boolean first_horiz = RND(2);
7223 int new_move_dir = MovDir[x][y];
7226 new_move_dir & (first_horiz ? MV_HORIZONTAL : MV_VERTICAL);
7227 Moving2Blocked(x, y, &newx, &newy);
7229 if (SATELLITE_CAN_ENTER_FIELD(newx, newy))
7233 new_move_dir & (!first_horiz ? MV_HORIZONTAL : MV_VERTICAL);
7234 Moving2Blocked(x, y, &newx, &newy);
7236 if (SATELLITE_CAN_ENTER_FIELD(newx, newy))
7239 MovDir[x][y] = old_move_dir;
7243 else if (element == EL_EMC_ANDROID)
7245 static int check_pos[16] =
7247 -1, // 0 => (invalid)
7250 -1, // 3 => (invalid)
7252 0, // 5 => MV_LEFT | MV_UP
7253 2, // 6 => MV_RIGHT | MV_UP
7254 -1, // 7 => (invalid)
7256 6, // 9 => MV_LEFT | MV_DOWN
7257 4, // 10 => MV_RIGHT | MV_DOWN
7258 -1, // 11 => (invalid)
7259 -1, // 12 => (invalid)
7260 -1, // 13 => (invalid)
7261 -1, // 14 => (invalid)
7262 -1, // 15 => (invalid)
7270 { -1, -1, MV_LEFT | MV_UP },
7272 { +1, -1, MV_RIGHT | MV_UP },
7273 { +1, 0, MV_RIGHT },
7274 { +1, +1, MV_RIGHT | MV_DOWN },
7276 { -1, +1, MV_LEFT | MV_DOWN },
7279 int start_pos, check_order;
7280 boolean can_clone = FALSE;
7283 // check if there is any free field around current position
7284 for (i = 0; i < 8; i++)
7286 int newx = x + check_xy[i].dx;
7287 int newy = y + check_xy[i].dy;
7289 if (IN_LEV_FIELD_AND_IS_FREE(newx, newy))
7297 if (can_clone) // randomly find an element to clone
7301 start_pos = check_pos[RND(8)];
7302 check_order = (RND(2) ? -1 : +1);
7304 for (i = 0; i < 8; i++)
7306 int pos_raw = start_pos + i * check_order;
7307 int pos = (pos_raw + 8) % 8;
7308 int newx = x + check_xy[pos].dx;
7309 int newy = y + check_xy[pos].dy;
7311 if (ANDROID_CAN_CLONE_FIELD(newx, newy))
7313 element_info[element].move_leave_type = LEAVE_TYPE_LIMITED;
7314 element_info[element].move_leave_element = EL_TRIGGER_ELEMENT;
7316 Store[x][y] = Tile[newx][newy];
7325 if (can_clone) // randomly find a direction to move
7329 start_pos = check_pos[RND(8)];
7330 check_order = (RND(2) ? -1 : +1);
7332 for (i = 0; i < 8; i++)
7334 int pos_raw = start_pos + i * check_order;
7335 int pos = (pos_raw + 8) % 8;
7336 int newx = x + check_xy[pos].dx;
7337 int newy = y + check_xy[pos].dy;
7338 int new_move_dir = check_xy[pos].dir;
7340 if (IN_LEV_FIELD_AND_IS_FREE(newx, newy))
7342 MovDir[x][y] = new_move_dir;
7343 MovDelay[x][y] = level.android_clone_time * 8 + 1;
7352 if (can_clone) // cloning and moving successful
7355 // cannot clone -- try to move towards player
7357 start_pos = check_pos[MovDir[x][y] & 0x0f];
7358 check_order = (RND(2) ? -1 : +1);
7360 for (i = 0; i < 3; i++)
7362 // first check start_pos, then previous/next or (next/previous) pos
7363 int pos_raw = start_pos + (i < 2 ? i : -1) * check_order;
7364 int pos = (pos_raw + 8) % 8;
7365 int newx = x + check_xy[pos].dx;
7366 int newy = y + check_xy[pos].dy;
7367 int new_move_dir = check_xy[pos].dir;
7369 if (IS_PLAYER(newx, newy))
7372 if (ANDROID_CAN_ENTER_FIELD(element, newx, newy))
7374 MovDir[x][y] = new_move_dir;
7375 MovDelay[x][y] = level.android_move_time * 8 + 1;
7382 else if (move_pattern == MV_TURNING_LEFT ||
7383 move_pattern == MV_TURNING_RIGHT ||
7384 move_pattern == MV_TURNING_LEFT_RIGHT ||
7385 move_pattern == MV_TURNING_RIGHT_LEFT ||
7386 move_pattern == MV_TURNING_RANDOM ||
7387 move_pattern == MV_ALL_DIRECTIONS)
7389 boolean can_turn_left =
7390 CUSTOM_ELEMENT_CAN_ENTER_FIELD(element, left_x, left_y);
7391 boolean can_turn_right =
7392 CUSTOM_ELEMENT_CAN_ENTER_FIELD(element, right_x,right_y);
7394 if (element_info[element].move_stepsize == 0) // "not moving"
7397 if (move_pattern == MV_TURNING_LEFT)
7398 MovDir[x][y] = left_dir;
7399 else if (move_pattern == MV_TURNING_RIGHT)
7400 MovDir[x][y] = right_dir;
7401 else if (move_pattern == MV_TURNING_LEFT_RIGHT)
7402 MovDir[x][y] = (can_turn_left || !can_turn_right ? left_dir : right_dir);
7403 else if (move_pattern == MV_TURNING_RIGHT_LEFT)
7404 MovDir[x][y] = (can_turn_right || !can_turn_left ? right_dir : left_dir);
7405 else if (move_pattern == MV_TURNING_RANDOM)
7406 MovDir[x][y] = (can_turn_left && !can_turn_right ? left_dir :
7407 can_turn_right && !can_turn_left ? right_dir :
7408 RND(2) ? left_dir : right_dir);
7409 else if (can_turn_left && can_turn_right)
7410 MovDir[x][y] = (RND(3) ? (RND(2) ? left_dir : right_dir) : back_dir);
7411 else if (can_turn_left)
7412 MovDir[x][y] = (RND(2) ? left_dir : back_dir);
7413 else if (can_turn_right)
7414 MovDir[x][y] = (RND(2) ? right_dir : back_dir);
7416 MovDir[x][y] = back_dir;
7418 MovDelay[x][y] = GET_NEW_MOVE_DELAY(element);
7420 else if (move_pattern == MV_HORIZONTAL ||
7421 move_pattern == MV_VERTICAL)
7423 if (move_pattern & old_move_dir)
7424 MovDir[x][y] = back_dir;
7425 else if (move_pattern == MV_HORIZONTAL)
7426 MovDir[x][y] = (RND(2) ? MV_LEFT : MV_RIGHT);
7427 else if (move_pattern == MV_VERTICAL)
7428 MovDir[x][y] = (RND(2) ? MV_UP : MV_DOWN);
7430 MovDelay[x][y] = GET_NEW_MOVE_DELAY(element);
7432 else if (move_pattern & MV_ANY_DIRECTION)
7434 MovDir[x][y] = move_pattern;
7435 MovDelay[x][y] = GET_NEW_MOVE_DELAY(element);
7437 else if (move_pattern & MV_WIND_DIRECTION)
7439 MovDir[x][y] = game.wind_direction;
7440 MovDelay[x][y] = GET_NEW_MOVE_DELAY(element);
7442 else if (move_pattern == MV_ALONG_LEFT_SIDE)
7444 if (CUSTOM_ELEMENT_CAN_ENTER_FIELD(element, left_x, left_y))
7445 MovDir[x][y] = left_dir;
7446 else if (!CUSTOM_ELEMENT_CAN_ENTER_FIELD(element, move_x, move_y))
7447 MovDir[x][y] = right_dir;
7449 if (MovDir[x][y] != old_move_dir)
7450 MovDelay[x][y] = GET_NEW_MOVE_DELAY(element);
7452 else if (move_pattern == MV_ALONG_RIGHT_SIDE)
7454 if (CUSTOM_ELEMENT_CAN_ENTER_FIELD(element, right_x, right_y))
7455 MovDir[x][y] = right_dir;
7456 else if (!CUSTOM_ELEMENT_CAN_ENTER_FIELD(element, move_x, move_y))
7457 MovDir[x][y] = left_dir;
7459 if (MovDir[x][y] != old_move_dir)
7460 MovDelay[x][y] = GET_NEW_MOVE_DELAY(element);
7462 else if (move_pattern == MV_TOWARDS_PLAYER ||
7463 move_pattern == MV_AWAY_FROM_PLAYER)
7465 int attr_x = -1, attr_y = -1;
7467 boolean move_away = (move_pattern == MV_AWAY_FROM_PLAYER);
7469 if (game.all_players_gone)
7471 attr_x = game.exit_x;
7472 attr_y = game.exit_y;
7478 for (i = 0; i < MAX_PLAYERS; i++)
7480 struct PlayerInfo *player = &stored_player[i];
7481 int jx = player->jx, jy = player->jy;
7483 if (!player->active)
7487 ABS(jx - x) + ABS(jy - y) < ABS(attr_x - x) + ABS(attr_y - y))
7495 MovDir[x][y] = MV_NONE;
7497 MovDir[x][y] |= (move_away ? MV_RIGHT : MV_LEFT);
7498 else if (attr_x > x)
7499 MovDir[x][y] |= (move_away ? MV_LEFT : MV_RIGHT);
7501 MovDir[x][y] |= (move_away ? MV_DOWN : MV_UP);
7502 else if (attr_y > y)
7503 MovDir[x][y] |= (move_away ? MV_UP : MV_DOWN);
7505 MovDelay[x][y] = GET_NEW_MOVE_DELAY(element);
7507 if (MovDir[x][y] & MV_HORIZONTAL && MovDir[x][y] & MV_VERTICAL)
7509 boolean first_horiz = RND(2);
7510 int new_move_dir = MovDir[x][y];
7512 if (element_info[element].move_stepsize == 0) // "not moving"
7514 first_horiz = (ABS(attr_x - x) >= ABS(attr_y - y));
7515 MovDir[x][y] &= (first_horiz ? MV_HORIZONTAL : MV_VERTICAL);
7521 new_move_dir & (first_horiz ? MV_HORIZONTAL : MV_VERTICAL);
7522 Moving2Blocked(x, y, &newx, &newy);
7524 if (CUSTOM_ELEMENT_CAN_ENTER_FIELD(element, newx, newy))
7528 new_move_dir & (!first_horiz ? MV_HORIZONTAL : MV_VERTICAL);
7529 Moving2Blocked(x, y, &newx, &newy);
7531 if (CUSTOM_ELEMENT_CAN_ENTER_FIELD(element, newx, newy))
7534 MovDir[x][y] = old_move_dir;
7537 else if (move_pattern == MV_WHEN_PUSHED ||
7538 move_pattern == MV_WHEN_DROPPED)
7540 if (!CUSTOM_ELEMENT_CAN_ENTER_FIELD(element, move_x, move_y))
7541 MovDir[x][y] = MV_NONE;
7545 else if (move_pattern & MV_MAZE_RUNNER_STYLE)
7547 static int test_xy[7][2] =
7557 static int test_dir[7] =
7567 boolean hunter_mode = (move_pattern == MV_MAZE_HUNTER);
7568 int move_preference = -1000000; // start with very low preference
7569 int new_move_dir = MV_NONE;
7570 int start_test = RND(4);
7573 for (i = 0; i < NUM_DIRECTIONS; i++)
7575 int move_dir = test_dir[start_test + i];
7576 int move_dir_preference;
7578 xx = x + test_xy[start_test + i][0];
7579 yy = y + test_xy[start_test + i][1];
7581 if (hunter_mode && IN_LEV_FIELD(xx, yy) &&
7582 (IS_PLAYER(xx, yy) || Tile[xx][yy] == EL_PLAYER_IS_LEAVING))
7584 new_move_dir = move_dir;
7589 if (!CUSTOM_ELEMENT_CAN_ENTER_FIELD(element, xx, yy))
7592 move_dir_preference = -1 * RunnerVisit[xx][yy];
7593 if (hunter_mode && PlayerVisit[xx][yy] > 0)
7594 move_dir_preference = PlayerVisit[xx][yy];
7596 if (move_dir_preference > move_preference)
7598 // prefer field that has not been visited for the longest time
7599 move_preference = move_dir_preference;
7600 new_move_dir = move_dir;
7602 else if (move_dir_preference == move_preference &&
7603 move_dir == old_move_dir)
7605 // prefer last direction when all directions are preferred equally
7606 move_preference = move_dir_preference;
7607 new_move_dir = move_dir;
7611 MovDir[x][y] = new_move_dir;
7612 if (old_move_dir != new_move_dir)
7613 MovDelay[x][y] = GET_NEW_MOVE_DELAY(element);
7617 static void TurnRound(int x, int y)
7619 int direction = MovDir[x][y];
7623 GfxDir[x][y] = MovDir[x][y];
7625 if (direction != MovDir[x][y])
7629 GfxAction[x][y] = ACTION_TURNING_FROM_LEFT + MV_DIR_TO_BIT(direction);
7631 ResetGfxFrame(x, y);
7634 static boolean JustBeingPushed(int x, int y)
7638 for (i = 0; i < MAX_PLAYERS; i++)
7640 struct PlayerInfo *player = &stored_player[i];
7642 if (player->active && player->is_pushing && player->MovPos)
7644 int next_jx = player->jx + (player->jx - player->last_jx);
7645 int next_jy = player->jy + (player->jy - player->last_jy);
7647 if (x == next_jx && y == next_jy)
7655 static void StartMoving(int x, int y)
7657 boolean started_moving = FALSE; // some elements can fall _and_ move
7658 int element = Tile[x][y];
7663 if (MovDelay[x][y] == 0)
7664 GfxAction[x][y] = ACTION_DEFAULT;
7666 if (CAN_FALL(element) && y < lev_fieldy - 1)
7668 if ((x > 0 && IS_PLAYER(x - 1, y)) ||
7669 (x < lev_fieldx - 1 && IS_PLAYER(x + 1, y)))
7670 if (JustBeingPushed(x, y))
7673 if (element == EL_QUICKSAND_FULL)
7675 if (IS_FREE(x, y + 1))
7677 InitMovingField(x, y, MV_DOWN);
7678 started_moving = TRUE;
7680 Tile[x][y] = EL_QUICKSAND_EMPTYING;
7681 #if USE_QUICKSAND_BD_ROCK_BUGFIX
7682 if (Store[x][y] != EL_ROCK && Store[x][y] != EL_BD_ROCK)
7683 Store[x][y] = EL_ROCK;
7685 Store[x][y] = EL_ROCK;
7688 PlayLevelSoundAction(x, y, ACTION_EMPTYING);
7690 else if (Tile[x][y + 1] == EL_QUICKSAND_EMPTY)
7692 if (!MovDelay[x][y])
7694 MovDelay[x][y] = TILEY + 1;
7696 ResetGfxAnimation(x, y);
7697 ResetGfxAnimation(x, y + 1);
7702 DrawLevelElement(x, y, EL_QUICKSAND_EMPTYING);
7703 DrawLevelElement(x, y + 1, EL_QUICKSAND_FILLING);
7710 Tile[x][y] = EL_QUICKSAND_EMPTY;
7711 Tile[x][y + 1] = EL_QUICKSAND_FULL;
7712 Store[x][y + 1] = Store[x][y];
7715 PlayLevelSoundAction(x, y, ACTION_FILLING);
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_EMPTYING);
7730 DrawLevelElement(x, y + 1, EL_QUICKSAND_FAST_FILLING);
7737 Tile[x][y] = EL_QUICKSAND_EMPTY;
7738 Tile[x][y + 1] = EL_QUICKSAND_FAST_FULL;
7739 Store[x][y + 1] = Store[x][y];
7742 PlayLevelSoundAction(x, y, ACTION_FILLING);
7745 else if (element == EL_QUICKSAND_FAST_FULL)
7747 if (IS_FREE(x, y + 1))
7749 InitMovingField(x, y, MV_DOWN);
7750 started_moving = TRUE;
7752 Tile[x][y] = EL_QUICKSAND_FAST_EMPTYING;
7753 #if USE_QUICKSAND_BD_ROCK_BUGFIX
7754 if (Store[x][y] != EL_ROCK && Store[x][y] != EL_BD_ROCK)
7755 Store[x][y] = EL_ROCK;
7757 Store[x][y] = EL_ROCK;
7760 PlayLevelSoundAction(x, y, ACTION_EMPTYING);
7762 else if (Tile[x][y + 1] == EL_QUICKSAND_FAST_EMPTY)
7764 if (!MovDelay[x][y])
7766 MovDelay[x][y] = TILEY + 1;
7768 ResetGfxAnimation(x, y);
7769 ResetGfxAnimation(x, y + 1);
7774 DrawLevelElement(x, y, EL_QUICKSAND_FAST_EMPTYING);
7775 DrawLevelElement(x, y + 1, EL_QUICKSAND_FAST_FILLING);
7782 Tile[x][y] = EL_QUICKSAND_FAST_EMPTY;
7783 Tile[x][y + 1] = EL_QUICKSAND_FAST_FULL;
7784 Store[x][y + 1] = Store[x][y];
7787 PlayLevelSoundAction(x, y, ACTION_FILLING);
7789 else if (Tile[x][y + 1] == EL_QUICKSAND_EMPTY)
7791 if (!MovDelay[x][y])
7793 MovDelay[x][y] = TILEY + 1;
7795 ResetGfxAnimation(x, y);
7796 ResetGfxAnimation(x, y + 1);
7801 DrawLevelElement(x, y, EL_QUICKSAND_FAST_EMPTYING);
7802 DrawLevelElement(x, y + 1, EL_QUICKSAND_FILLING);
7809 Tile[x][y] = EL_QUICKSAND_FAST_EMPTY;
7810 Tile[x][y + 1] = EL_QUICKSAND_FULL;
7811 Store[x][y + 1] = Store[x][y];
7814 PlayLevelSoundAction(x, y, ACTION_FILLING);
7817 else if ((element == EL_ROCK || element == EL_BD_ROCK) &&
7818 Tile[x][y + 1] == EL_QUICKSAND_EMPTY)
7820 InitMovingField(x, y, MV_DOWN);
7821 started_moving = TRUE;
7823 Tile[x][y] = EL_QUICKSAND_FILLING;
7824 Store[x][y] = element;
7826 PlayLevelSoundAction(x, y, ACTION_FILLING);
7828 else if ((element == EL_ROCK || element == EL_BD_ROCK) &&
7829 Tile[x][y + 1] == EL_QUICKSAND_FAST_EMPTY)
7831 InitMovingField(x, y, MV_DOWN);
7832 started_moving = TRUE;
7834 Tile[x][y] = EL_QUICKSAND_FAST_FILLING;
7835 Store[x][y] = element;
7837 PlayLevelSoundAction(x, y, ACTION_FILLING);
7839 else if (element == EL_MAGIC_WALL_FULL)
7841 if (IS_FREE(x, y + 1))
7843 InitMovingField(x, y, MV_DOWN);
7844 started_moving = TRUE;
7846 Tile[x][y] = EL_MAGIC_WALL_EMPTYING;
7847 Store[x][y] = EL_CHANGED(Store[x][y]);
7849 else if (Tile[x][y + 1] == EL_MAGIC_WALL_ACTIVE)
7851 if (!MovDelay[x][y])
7852 MovDelay[x][y] = TILEY / 4 + 1;
7861 Tile[x][y] = EL_MAGIC_WALL_ACTIVE;
7862 Tile[x][y + 1] = EL_MAGIC_WALL_FULL;
7863 Store[x][y + 1] = EL_CHANGED(Store[x][y]);
7867 else if (element == EL_BD_MAGIC_WALL_FULL)
7869 if (IS_FREE(x, y + 1))
7871 InitMovingField(x, y, MV_DOWN);
7872 started_moving = TRUE;
7874 Tile[x][y] = EL_BD_MAGIC_WALL_EMPTYING;
7875 Store[x][y] = EL_CHANGED_BD(Store[x][y]);
7877 else if (Tile[x][y + 1] == EL_BD_MAGIC_WALL_ACTIVE)
7879 if (!MovDelay[x][y])
7880 MovDelay[x][y] = TILEY / 4 + 1;
7889 Tile[x][y] = EL_BD_MAGIC_WALL_ACTIVE;
7890 Tile[x][y + 1] = EL_BD_MAGIC_WALL_FULL;
7891 Store[x][y + 1] = EL_CHANGED_BD(Store[x][y]);
7895 else if (element == EL_DC_MAGIC_WALL_FULL)
7897 if (IS_FREE(x, y + 1))
7899 InitMovingField(x, y, MV_DOWN);
7900 started_moving = TRUE;
7902 Tile[x][y] = EL_DC_MAGIC_WALL_EMPTYING;
7903 Store[x][y] = EL_CHANGED_DC(Store[x][y]);
7905 else if (Tile[x][y + 1] == EL_DC_MAGIC_WALL_ACTIVE)
7907 if (!MovDelay[x][y])
7908 MovDelay[x][y] = TILEY / 4 + 1;
7917 Tile[x][y] = EL_DC_MAGIC_WALL_ACTIVE;
7918 Tile[x][y + 1] = EL_DC_MAGIC_WALL_FULL;
7919 Store[x][y + 1] = EL_CHANGED_DC(Store[x][y]);
7923 else if ((CAN_PASS_MAGIC_WALL(element) &&
7924 (Tile[x][y + 1] == EL_MAGIC_WALL_ACTIVE ||
7925 Tile[x][y + 1] == EL_BD_MAGIC_WALL_ACTIVE)) ||
7926 (CAN_PASS_DC_MAGIC_WALL(element) &&
7927 (Tile[x][y + 1] == EL_DC_MAGIC_WALL_ACTIVE)))
7930 InitMovingField(x, y, MV_DOWN);
7931 started_moving = TRUE;
7934 (Tile[x][y + 1] == EL_MAGIC_WALL_ACTIVE ? EL_MAGIC_WALL_FILLING :
7935 Tile[x][y + 1] == EL_BD_MAGIC_WALL_ACTIVE ? EL_BD_MAGIC_WALL_FILLING :
7936 EL_DC_MAGIC_WALL_FILLING);
7937 Store[x][y] = element;
7939 else if (CAN_FALL(element) && Tile[x][y + 1] == EL_ACID)
7941 SplashAcid(x, y + 1);
7943 InitMovingField(x, y, MV_DOWN);
7944 started_moving = TRUE;
7946 Store[x][y] = EL_ACID;
7949 (game.engine_version >= VERSION_IDENT(3,1,0,0) &&
7950 CheckImpact[x][y] && !IS_FREE(x, y + 1)) ||
7951 (game.engine_version >= VERSION_IDENT(3,0,7,0) &&
7952 CAN_FALL(element) && WasJustFalling[x][y] &&
7953 (Tile[x][y + 1] == EL_BLOCKED || IS_PLAYER(x, y + 1))) ||
7955 (game.engine_version < VERSION_IDENT(2,2,0,7) &&
7956 CAN_FALL(element) && WasJustMoving[x][y] && !Pushed[x][y + 1] &&
7957 (Tile[x][y + 1] == EL_BLOCKED)))
7959 /* this is needed for a special case not covered by calling "Impact()"
7960 from "ContinueMoving()": if an element moves to a tile directly below
7961 another element which was just falling on that tile (which was empty
7962 in the previous frame), the falling element above would just stop
7963 instead of smashing the element below (in previous version, the above
7964 element was just checked for "moving" instead of "falling", resulting
7965 in incorrect smashes caused by horizontal movement of the above
7966 element; also, the case of the player being the element to smash was
7967 simply not covered here... :-/ ) */
7969 CheckCollision[x][y] = 0;
7970 CheckImpact[x][y] = 0;
7974 else if (IS_FREE(x, y + 1) && element == EL_SPRING && level.use_spring_bug)
7976 if (MovDir[x][y] == MV_NONE)
7978 InitMovingField(x, y, MV_DOWN);
7979 started_moving = TRUE;
7982 else if (IS_FREE(x, y + 1) || Tile[x][y + 1] == EL_DIAMOND_BREAKING)
7984 if (WasJustFalling[x][y]) // prevent animation from being restarted
7985 MovDir[x][y] = MV_DOWN;
7987 InitMovingField(x, y, MV_DOWN);
7988 started_moving = TRUE;
7990 else if (element == EL_AMOEBA_DROP)
7992 Tile[x][y] = EL_AMOEBA_GROWING;
7993 Store[x][y] = EL_AMOEBA_WET;
7995 else if (((IS_SLIPPERY(Tile[x][y + 1]) && !IS_PLAYER(x, y + 1)) ||
7996 (IS_EM_SLIPPERY_WALL(Tile[x][y + 1]) && IS_GEM(element))) &&
7997 !IS_FALLING(x, y + 1) && !WasJustMoving[x][y + 1] &&
7998 element != EL_DX_SUPABOMB && element != EL_SP_DISK_ORANGE)
8000 boolean can_fall_left = (x > 0 && IS_FREE(x - 1, y) &&
8001 (IS_FREE(x - 1, y + 1) ||
8002 Tile[x - 1][y + 1] == EL_ACID));
8003 boolean can_fall_right = (x < lev_fieldx - 1 && IS_FREE(x + 1, y) &&
8004 (IS_FREE(x + 1, y + 1) ||
8005 Tile[x + 1][y + 1] == EL_ACID));
8006 boolean can_fall_any = (can_fall_left || can_fall_right);
8007 boolean can_fall_both = (can_fall_left && can_fall_right);
8008 int slippery_type = element_info[Tile[x][y + 1]].slippery_type;
8010 if (can_fall_any && slippery_type != SLIPPERY_ANY_RANDOM)
8012 if (slippery_type == SLIPPERY_ANY_LEFT_RIGHT && can_fall_both)
8013 can_fall_right = FALSE;
8014 else if (slippery_type == SLIPPERY_ANY_RIGHT_LEFT && can_fall_both)
8015 can_fall_left = FALSE;
8016 else if (slippery_type == SLIPPERY_ONLY_LEFT)
8017 can_fall_right = FALSE;
8018 else if (slippery_type == SLIPPERY_ONLY_RIGHT)
8019 can_fall_left = FALSE;
8021 can_fall_any = (can_fall_left || can_fall_right);
8022 can_fall_both = FALSE;
8027 if (element == EL_BD_ROCK || element == EL_BD_DIAMOND)
8028 can_fall_right = FALSE; // slip down on left side
8030 can_fall_left = !(can_fall_right = RND(2));
8032 can_fall_both = FALSE;
8037 // if not determined otherwise, prefer left side for slipping down
8038 InitMovingField(x, y, can_fall_left ? MV_LEFT : MV_RIGHT);
8039 started_moving = TRUE;
8042 else if (IS_BELT_ACTIVE(Tile[x][y + 1]))
8044 boolean left_is_free = (x > 0 && IS_FREE(x - 1, y));
8045 boolean right_is_free = (x < lev_fieldx - 1 && IS_FREE(x + 1, y));
8046 int belt_nr = getBeltNrFromBeltActiveElement(Tile[x][y + 1]);
8047 int belt_dir = game.belt_dir[belt_nr];
8049 if ((belt_dir == MV_LEFT && left_is_free) ||
8050 (belt_dir == MV_RIGHT && right_is_free))
8052 int nextx = (belt_dir == MV_LEFT ? x - 1 : x + 1);
8054 InitMovingField(x, y, belt_dir);
8055 started_moving = TRUE;
8057 Pushed[x][y] = TRUE;
8058 Pushed[nextx][y] = TRUE;
8060 GfxAction[x][y] = ACTION_DEFAULT;
8064 MovDir[x][y] = 0; // if element was moving, stop it
8069 // not "else if" because of elements that can fall and move (EL_SPRING)
8070 if (CAN_MOVE(element) && !started_moving)
8072 int move_pattern = element_info[element].move_pattern;
8075 Moving2Blocked(x, y, &newx, &newy);
8077 if (IS_PUSHABLE(element) && JustBeingPushed(x, y))
8080 if (game.engine_version >= VERSION_IDENT(3,1,0,0) &&
8081 CheckCollision[x][y] && !IN_LEV_FIELD_AND_IS_FREE(newx, newy))
8083 WasJustMoving[x][y] = 0;
8084 CheckCollision[x][y] = 0;
8086 TestIfElementHitsCustomElement(x, y, MovDir[x][y]);
8088 if (Tile[x][y] != element) // element has changed
8092 if (!MovDelay[x][y]) // start new movement phase
8094 // all objects that can change their move direction after each step
8095 // (YAMYAM, DARK_YAMYAM and PACMAN go straight until they hit a wall
8097 if (element != EL_YAMYAM &&
8098 element != EL_DARK_YAMYAM &&
8099 element != EL_PACMAN &&
8100 !(move_pattern & MV_ANY_DIRECTION) &&
8101 move_pattern != MV_TURNING_LEFT &&
8102 move_pattern != MV_TURNING_RIGHT &&
8103 move_pattern != MV_TURNING_LEFT_RIGHT &&
8104 move_pattern != MV_TURNING_RIGHT_LEFT &&
8105 move_pattern != MV_TURNING_RANDOM)
8109 if (MovDelay[x][y] && (element == EL_BUG ||
8110 element == EL_SPACESHIP ||
8111 element == EL_SP_SNIKSNAK ||
8112 element == EL_SP_ELECTRON ||
8113 element == EL_MOLE))
8114 TEST_DrawLevelField(x, y);
8118 if (MovDelay[x][y]) // wait some time before next movement
8122 if (element == EL_ROBOT ||
8123 element == EL_YAMYAM ||
8124 element == EL_DARK_YAMYAM)
8126 DrawLevelElementAnimationIfNeeded(x, y, element);
8127 PlayLevelSoundAction(x, y, ACTION_WAITING);
8129 else if (element == EL_SP_ELECTRON)
8130 DrawLevelElementAnimationIfNeeded(x, y, element);
8131 else if (element == EL_DRAGON)
8134 int dir = MovDir[x][y];
8135 int dx = (dir == MV_LEFT ? -1 : dir == MV_RIGHT ? +1 : 0);
8136 int dy = (dir == MV_UP ? -1 : dir == MV_DOWN ? +1 : 0);
8137 int graphic = (dir == MV_LEFT ? IMG_FLAMES_1_LEFT :
8138 dir == MV_RIGHT ? IMG_FLAMES_1_RIGHT :
8139 dir == MV_UP ? IMG_FLAMES_1_UP :
8140 dir == MV_DOWN ? IMG_FLAMES_1_DOWN : IMG_EMPTY);
8141 int frame = getGraphicAnimationFrame(graphic, GfxFrame[x][y]);
8143 GfxAction[x][y] = ACTION_ATTACKING;
8145 if (IS_PLAYER(x, y))
8146 DrawPlayerField(x, y);
8148 TEST_DrawLevelField(x, y);
8150 PlayLevelSoundActionIfLoop(x, y, ACTION_ATTACKING);
8152 for (i = 1; i <= 3; i++)
8154 int xx = x + i * dx;
8155 int yy = y + i * dy;
8156 int sx = SCREENX(xx);
8157 int sy = SCREENY(yy);
8158 int flame_graphic = graphic + (i - 1);
8160 if (!IN_LEV_FIELD(xx, yy) || IS_DRAGONFIRE_PROOF(Tile[xx][yy]))
8165 int flamed = MovingOrBlocked2Element(xx, yy);
8167 if (IS_CLASSIC_ENEMY(flamed) || CAN_EXPLODE_BY_DRAGONFIRE(flamed))
8170 RemoveMovingField(xx, yy);
8172 ChangeDelay[xx][yy] = 0;
8174 Tile[xx][yy] = EL_FLAMES;
8176 if (IN_SCR_FIELD(sx, sy))
8178 TEST_DrawLevelFieldCrumbled(xx, yy);
8179 DrawGraphic(sx, sy, flame_graphic, frame);
8184 if (Tile[xx][yy] == EL_FLAMES)
8185 Tile[xx][yy] = EL_EMPTY;
8186 TEST_DrawLevelField(xx, yy);
8191 if (MovDelay[x][y]) // element still has to wait some time
8193 PlayLevelSoundAction(x, y, ACTION_WAITING);
8199 // now make next step
8201 Moving2Blocked(x, y, &newx, &newy); // get next screen position
8203 if (DONT_COLLIDE_WITH(element) &&
8204 IN_LEV_FIELD(newx, newy) && IS_PLAYER(newx, newy) &&
8205 !PLAYER_ENEMY_PROTECTED(newx, newy))
8207 TestIfBadThingRunsIntoPlayer(x, y, MovDir[x][y]);
8212 else if (CAN_MOVE_INTO_ACID(element) &&
8213 IN_LEV_FIELD(newx, newy) && Tile[newx][newy] == EL_ACID &&
8214 !IS_MV_DIAGONAL(MovDir[x][y]) &&
8215 (MovDir[x][y] == MV_DOWN ||
8216 game.engine_version >= VERSION_IDENT(3,1,0,0)))
8218 SplashAcid(newx, newy);
8219 Store[x][y] = EL_ACID;
8221 else if (element == EL_PENGUIN && IN_LEV_FIELD(newx, newy))
8223 if (Tile[newx][newy] == EL_EXIT_OPEN ||
8224 Tile[newx][newy] == EL_EM_EXIT_OPEN ||
8225 Tile[newx][newy] == EL_STEEL_EXIT_OPEN ||
8226 Tile[newx][newy] == EL_EM_STEEL_EXIT_OPEN)
8229 TEST_DrawLevelField(x, y);
8231 PlayLevelSound(newx, newy, SND_PENGUIN_PASSING);
8232 if (IN_SCR_FIELD(SCREENX(newx), SCREENY(newy)))
8233 DrawGraphicThruMask(SCREENX(newx),SCREENY(newy), el2img(element), 0);
8235 game.friends_still_needed--;
8236 if (!game.friends_still_needed &&
8238 game.all_players_gone)
8243 else if (IS_FOOD_PENGUIN(Tile[newx][newy]))
8245 if (DigField(local_player, x, y, newx, newy, 0,0, DF_DIG) == MP_MOVING)
8246 TEST_DrawLevelField(newx, newy);
8248 GfxDir[x][y] = MovDir[x][y] = MV_NONE;
8250 else if (!IS_FREE(newx, newy))
8252 GfxAction[x][y] = ACTION_WAITING;
8254 if (IS_PLAYER(x, y))
8255 DrawPlayerField(x, y);
8257 TEST_DrawLevelField(x, y);
8262 else if (element == EL_PIG && IN_LEV_FIELD(newx, newy))
8264 if (IS_FOOD_PIG(Tile[newx][newy]))
8266 if (IS_MOVING(newx, newy))
8267 RemoveMovingField(newx, newy);
8270 Tile[newx][newy] = EL_EMPTY;
8271 TEST_DrawLevelField(newx, newy);
8274 PlayLevelSound(x, y, SND_PIG_DIGGING);
8276 else if (!IS_FREE(newx, newy))
8278 if (IS_PLAYER(x, y))
8279 DrawPlayerField(x, y);
8281 TEST_DrawLevelField(x, y);
8286 else if (element == EL_EMC_ANDROID && IN_LEV_FIELD(newx, newy))
8288 if (Store[x][y] != EL_EMPTY)
8290 boolean can_clone = FALSE;
8293 // check if element to clone is still there
8294 for (yy = y - 1; yy <= y + 1; yy++) for (xx = x - 1; xx <= x + 1; xx++)
8296 if (IN_LEV_FIELD(xx, yy) && Tile[xx][yy] == Store[x][y])
8304 // cannot clone or target field not free anymore -- do not clone
8305 if (!can_clone || !ANDROID_CAN_ENTER_FIELD(element, newx, newy))
8306 Store[x][y] = EL_EMPTY;
8309 if (ANDROID_CAN_ENTER_FIELD(element, newx, newy))
8311 if (IS_MV_DIAGONAL(MovDir[x][y]))
8313 int diagonal_move_dir = MovDir[x][y];
8314 int stored = Store[x][y];
8315 int change_delay = 8;
8318 // android is moving diagonally
8320 CreateField(x, y, EL_DIAGONAL_SHRINKING);
8322 Store[x][y] = (stored == EL_ACID ? EL_EMPTY : stored);
8323 GfxElement[x][y] = EL_EMC_ANDROID;
8324 GfxAction[x][y] = ACTION_SHRINKING;
8325 GfxDir[x][y] = diagonal_move_dir;
8326 ChangeDelay[x][y] = change_delay;
8328 graphic = el_act_dir2img(GfxElement[x][y], GfxAction[x][y],
8331 DrawLevelGraphicAnimation(x, y, graphic);
8332 PlayLevelSoundAction(x, y, ACTION_SHRINKING);
8334 if (Tile[newx][newy] == EL_ACID)
8336 SplashAcid(newx, newy);
8341 CreateField(newx, newy, EL_DIAGONAL_GROWING);
8343 Store[newx][newy] = EL_EMC_ANDROID;
8344 GfxElement[newx][newy] = EL_EMC_ANDROID;
8345 GfxAction[newx][newy] = ACTION_GROWING;
8346 GfxDir[newx][newy] = diagonal_move_dir;
8347 ChangeDelay[newx][newy] = change_delay;
8349 graphic = el_act_dir2img(GfxElement[newx][newy],
8350 GfxAction[newx][newy], GfxDir[newx][newy]);
8352 DrawLevelGraphicAnimation(newx, newy, graphic);
8353 PlayLevelSoundAction(newx, newy, ACTION_GROWING);
8359 Tile[newx][newy] = EL_EMPTY;
8360 TEST_DrawLevelField(newx, newy);
8362 PlayLevelSoundAction(x, y, ACTION_DIGGING);
8365 else if (!IS_FREE(newx, newy))
8370 else if (IS_CUSTOM_ELEMENT(element) &&
8371 CUSTOM_ELEMENT_CAN_ENTER_FIELD(element, newx, newy))
8373 if (!DigFieldByCE(newx, newy, element))
8376 if (move_pattern & MV_MAZE_RUNNER_STYLE)
8378 RunnerVisit[x][y] = FrameCounter;
8379 PlayerVisit[x][y] /= 8; // expire player visit path
8382 else if (element == EL_DRAGON && IN_LEV_FIELD(newx, newy))
8384 if (!IS_FREE(newx, newy))
8386 if (IS_PLAYER(x, y))
8387 DrawPlayerField(x, y);
8389 TEST_DrawLevelField(x, y);
8395 boolean wanna_flame = !RND(10);
8396 int dx = newx - x, dy = newy - y;
8397 int newx1 = newx + 1 * dx, newy1 = newy + 1 * dy;
8398 int newx2 = newx + 2 * dx, newy2 = newy + 2 * dy;
8399 int element1 = (IN_LEV_FIELD(newx1, newy1) ?
8400 MovingOrBlocked2Element(newx1, newy1) : EL_STEELWALL);
8401 int element2 = (IN_LEV_FIELD(newx2, newy2) ?
8402 MovingOrBlocked2Element(newx2, newy2) : EL_STEELWALL);
8405 IS_CLASSIC_ENEMY(element1) ||
8406 IS_CLASSIC_ENEMY(element2)) &&
8407 element1 != EL_DRAGON && element2 != EL_DRAGON &&
8408 element1 != EL_FLAMES && element2 != EL_FLAMES)
8410 ResetGfxAnimation(x, y);
8411 GfxAction[x][y] = ACTION_ATTACKING;
8413 if (IS_PLAYER(x, y))
8414 DrawPlayerField(x, y);
8416 TEST_DrawLevelField(x, y);
8418 PlayLevelSound(x, y, SND_DRAGON_ATTACKING);
8420 MovDelay[x][y] = 50;
8422 Tile[newx][newy] = EL_FLAMES;
8423 if (IN_LEV_FIELD(newx1, newy1) && Tile[newx1][newy1] == EL_EMPTY)
8424 Tile[newx1][newy1] = EL_FLAMES;
8425 if (IN_LEV_FIELD(newx2, newy2) && Tile[newx2][newy2] == EL_EMPTY)
8426 Tile[newx2][newy2] = EL_FLAMES;
8432 else if (element == EL_YAMYAM && IN_LEV_FIELD(newx, newy) &&
8433 Tile[newx][newy] == EL_DIAMOND)
8435 if (IS_MOVING(newx, newy))
8436 RemoveMovingField(newx, newy);
8439 Tile[newx][newy] = EL_EMPTY;
8440 TEST_DrawLevelField(newx, newy);
8443 PlayLevelSound(x, y, SND_YAMYAM_DIGGING);
8445 else if (element == EL_DARK_YAMYAM && IN_LEV_FIELD(newx, newy) &&
8446 IS_FOOD_DARK_YAMYAM(Tile[newx][newy]))
8448 if (AmoebaNr[newx][newy])
8450 AmoebaCnt2[AmoebaNr[newx][newy]]--;
8451 if (Tile[newx][newy] == EL_AMOEBA_FULL ||
8452 Tile[newx][newy] == EL_BD_AMOEBA)
8453 AmoebaCnt[AmoebaNr[newx][newy]]--;
8456 if (IS_MOVING(newx, newy))
8458 RemoveMovingField(newx, newy);
8462 Tile[newx][newy] = EL_EMPTY;
8463 TEST_DrawLevelField(newx, newy);
8466 PlayLevelSound(x, y, SND_DARK_YAMYAM_DIGGING);
8468 else if ((element == EL_PACMAN || element == EL_MOLE)
8469 && IN_LEV_FIELD(newx, newy) && IS_AMOEBOID(Tile[newx][newy]))
8471 if (AmoebaNr[newx][newy])
8473 AmoebaCnt2[AmoebaNr[newx][newy]]--;
8474 if (Tile[newx][newy] == EL_AMOEBA_FULL ||
8475 Tile[newx][newy] == EL_BD_AMOEBA)
8476 AmoebaCnt[AmoebaNr[newx][newy]]--;
8479 if (element == EL_MOLE)
8481 Tile[newx][newy] = EL_AMOEBA_SHRINKING;
8482 PlayLevelSound(x, y, SND_MOLE_DIGGING);
8484 ResetGfxAnimation(x, y);
8485 GfxAction[x][y] = ACTION_DIGGING;
8486 TEST_DrawLevelField(x, y);
8488 MovDelay[newx][newy] = 0; // start amoeba shrinking delay
8490 return; // wait for shrinking amoeba
8492 else // element == EL_PACMAN
8494 Tile[newx][newy] = EL_EMPTY;
8495 TEST_DrawLevelField(newx, newy);
8496 PlayLevelSound(x, y, SND_PACMAN_DIGGING);
8499 else if (element == EL_MOLE && IN_LEV_FIELD(newx, newy) &&
8500 (Tile[newx][newy] == EL_AMOEBA_SHRINKING ||
8501 (Tile[newx][newy] == EL_EMPTY && Stop[newx][newy])))
8503 // wait for shrinking amoeba to completely disappear
8506 else if (!IN_LEV_FIELD(newx, newy) || !IS_FREE(newx, newy))
8508 // object was running against a wall
8512 if (GFX_ELEMENT(element) != EL_SAND) // !!! FIX THIS (crumble) !!!
8513 DrawLevelElementAnimation(x, y, element);
8515 if (DONT_TOUCH(element))
8516 TestIfBadThingTouchesPlayer(x, y);
8521 InitMovingField(x, y, MovDir[x][y]);
8523 PlayLevelSoundAction(x, y, ACTION_MOVING);
8527 ContinueMoving(x, y);
8530 void ContinueMoving(int x, int y)
8532 int element = Tile[x][y];
8533 struct ElementInfo *ei = &element_info[element];
8534 int direction = MovDir[x][y];
8535 int dx = (direction == MV_LEFT ? -1 : direction == MV_RIGHT ? +1 : 0);
8536 int dy = (direction == MV_UP ? -1 : direction == MV_DOWN ? +1 : 0);
8537 int newx = x + dx, newy = y + dy;
8538 int stored = Store[x][y];
8539 int stored_new = Store[newx][newy];
8540 boolean pushed_by_player = (Pushed[x][y] && IS_PLAYER(x, y));
8541 boolean pushed_by_conveyor = (Pushed[x][y] && !IS_PLAYER(x, y));
8542 boolean last_line = (newy == lev_fieldy - 1);
8543 boolean use_step_delay = (GET_MAX_STEP_DELAY(element) != 0);
8545 if (pushed_by_player) // special case: moving object pushed by player
8547 MovPos[x][y] = SIGN(MovPos[x][y]) * (TILEX - ABS(PLAYERINFO(x,y)->MovPos));
8549 else if (use_step_delay) // special case: moving object has step delay
8551 if (!MovDelay[x][y])
8552 MovPos[x][y] += getElementMoveStepsize(x, y);
8557 MovDelay[x][y] = GET_NEW_STEP_DELAY(element);
8561 TEST_DrawLevelField(x, y);
8563 return; // element is still waiting
8566 else // normal case: generically moving object
8568 MovPos[x][y] += getElementMoveStepsize(x, y);
8571 if (ABS(MovPos[x][y]) < TILEX)
8573 TEST_DrawLevelField(x, y);
8575 return; // element is still moving
8578 // element reached destination field
8580 Tile[x][y] = EL_EMPTY;
8581 Tile[newx][newy] = element;
8582 MovPos[x][y] = 0; // force "not moving" for "crumbled sand"
8584 if (Store[x][y] == EL_ACID) // element is moving into acid pool
8586 element = Tile[newx][newy] = EL_ACID;
8588 else if (element == EL_MOLE)
8590 Tile[x][y] = EL_SAND;
8592 TEST_DrawLevelFieldCrumbledNeighbours(x, y);
8594 else if (element == EL_QUICKSAND_FILLING)
8596 element = Tile[newx][newy] = get_next_element(element);
8597 Store[newx][newy] = Store[x][y];
8599 else if (element == EL_QUICKSAND_EMPTYING)
8601 Tile[x][y] = get_next_element(element);
8602 element = Tile[newx][newy] = Store[x][y];
8604 else if (element == EL_QUICKSAND_FAST_FILLING)
8606 element = Tile[newx][newy] = get_next_element(element);
8607 Store[newx][newy] = Store[x][y];
8609 else if (element == EL_QUICKSAND_FAST_EMPTYING)
8611 Tile[x][y] = get_next_element(element);
8612 element = Tile[newx][newy] = Store[x][y];
8614 else if (element == EL_MAGIC_WALL_FILLING)
8616 element = Tile[newx][newy] = get_next_element(element);
8617 if (!game.magic_wall_active)
8618 element = Tile[newx][newy] = EL_MAGIC_WALL_DEAD;
8619 Store[newx][newy] = Store[x][y];
8621 else if (element == EL_MAGIC_WALL_EMPTYING)
8623 Tile[x][y] = get_next_element(element);
8624 if (!game.magic_wall_active)
8625 Tile[x][y] = EL_MAGIC_WALL_DEAD;
8626 element = Tile[newx][newy] = Store[x][y];
8628 InitField(newx, newy, FALSE);
8630 else if (element == EL_BD_MAGIC_WALL_FILLING)
8632 element = Tile[newx][newy] = get_next_element(element);
8633 if (!game.magic_wall_active)
8634 element = Tile[newx][newy] = EL_BD_MAGIC_WALL_DEAD;
8635 Store[newx][newy] = Store[x][y];
8637 else if (element == EL_BD_MAGIC_WALL_EMPTYING)
8639 Tile[x][y] = get_next_element(element);
8640 if (!game.magic_wall_active)
8641 Tile[x][y] = EL_BD_MAGIC_WALL_DEAD;
8642 element = Tile[newx][newy] = Store[x][y];
8644 InitField(newx, newy, FALSE);
8646 else if (element == EL_DC_MAGIC_WALL_FILLING)
8648 element = Tile[newx][newy] = get_next_element(element);
8649 if (!game.magic_wall_active)
8650 element = Tile[newx][newy] = EL_DC_MAGIC_WALL_DEAD;
8651 Store[newx][newy] = Store[x][y];
8653 else if (element == EL_DC_MAGIC_WALL_EMPTYING)
8655 Tile[x][y] = get_next_element(element);
8656 if (!game.magic_wall_active)
8657 Tile[x][y] = EL_DC_MAGIC_WALL_DEAD;
8658 element = Tile[newx][newy] = Store[x][y];
8660 InitField(newx, newy, FALSE);
8662 else if (element == EL_AMOEBA_DROPPING)
8664 Tile[x][y] = get_next_element(element);
8665 element = Tile[newx][newy] = Store[x][y];
8667 else if (element == EL_SOKOBAN_OBJECT)
8670 Tile[x][y] = Back[x][y];
8672 if (Back[newx][newy])
8673 Tile[newx][newy] = EL_SOKOBAN_FIELD_FULL;
8675 Back[x][y] = Back[newx][newy] = 0;
8678 Store[x][y] = EL_EMPTY;
8683 MovDelay[newx][newy] = 0;
8685 if (CAN_CHANGE_OR_HAS_ACTION(element))
8687 // copy element change control values to new field
8688 ChangeDelay[newx][newy] = ChangeDelay[x][y];
8689 ChangePage[newx][newy] = ChangePage[x][y];
8690 ChangeCount[newx][newy] = ChangeCount[x][y];
8691 ChangeEvent[newx][newy] = ChangeEvent[x][y];
8694 CustomValue[newx][newy] = CustomValue[x][y];
8696 ChangeDelay[x][y] = 0;
8697 ChangePage[x][y] = -1;
8698 ChangeCount[x][y] = 0;
8699 ChangeEvent[x][y] = -1;
8701 CustomValue[x][y] = 0;
8703 // copy animation control values to new field
8704 GfxFrame[newx][newy] = GfxFrame[x][y];
8705 GfxRandom[newx][newy] = GfxRandom[x][y]; // keep same random value
8706 GfxAction[newx][newy] = GfxAction[x][y]; // keep action one frame
8707 GfxDir[newx][newy] = GfxDir[x][y]; // keep element direction
8709 Pushed[x][y] = Pushed[newx][newy] = FALSE;
8711 // some elements can leave other elements behind after moving
8712 if (ei->move_leave_element != EL_EMPTY &&
8713 (ei->move_leave_type == LEAVE_TYPE_UNLIMITED || stored != EL_EMPTY) &&
8714 (!IS_PLAYER(x, y) || IS_WALKABLE(ei->move_leave_element)))
8716 int move_leave_element = ei->move_leave_element;
8718 // this makes it possible to leave the removed element again
8719 if (ei->move_leave_element == EL_TRIGGER_ELEMENT)
8720 move_leave_element = (stored == EL_ACID ? EL_EMPTY : stored);
8722 Tile[x][y] = move_leave_element;
8724 if (element_info[Tile[x][y]].move_direction_initial == MV_START_PREVIOUS)
8725 MovDir[x][y] = direction;
8727 InitField(x, y, FALSE);
8729 if (GFX_CRUMBLED(Tile[x][y]))
8730 TEST_DrawLevelFieldCrumbledNeighbours(x, y);
8732 if (ELEM_IS_PLAYER(move_leave_element))
8733 RelocatePlayer(x, y, move_leave_element);
8736 // do this after checking for left-behind element
8737 ResetGfxAnimation(x, y); // reset animation values for old field
8739 if (!CAN_MOVE(element) ||
8740 (CAN_FALL(element) && direction == MV_DOWN &&
8741 (element == EL_SPRING ||
8742 element_info[element].move_pattern == MV_WHEN_PUSHED ||
8743 element_info[element].move_pattern == MV_WHEN_DROPPED)))
8744 GfxDir[x][y] = MovDir[newx][newy] = 0;
8746 TEST_DrawLevelField(x, y);
8747 TEST_DrawLevelField(newx, newy);
8749 Stop[newx][newy] = TRUE; // ignore this element until the next frame
8751 // prevent pushed element from moving on in pushed direction
8752 if (pushed_by_player && CAN_MOVE(element) &&
8753 element_info[element].move_pattern & MV_ANY_DIRECTION &&
8754 !(element_info[element].move_pattern & direction))
8755 TurnRound(newx, newy);
8757 // prevent elements on conveyor belt from moving on in last direction
8758 if (pushed_by_conveyor && CAN_FALL(element) &&
8759 direction & MV_HORIZONTAL)
8760 MovDir[newx][newy] = 0;
8762 if (!pushed_by_player)
8764 int nextx = newx + dx, nexty = newy + dy;
8765 boolean check_collision_again = IN_LEV_FIELD_AND_IS_FREE(nextx, nexty);
8767 WasJustMoving[newx][newy] = CHECK_DELAY_MOVING;
8769 if (CAN_FALL(element) && direction == MV_DOWN)
8770 WasJustFalling[newx][newy] = CHECK_DELAY_FALLING;
8772 if ((!CAN_FALL(element) || direction == MV_DOWN) && check_collision_again)
8773 CheckCollision[newx][newy] = CHECK_DELAY_COLLISION;
8775 if (CAN_FALL(element) && direction == MV_DOWN && check_collision_again)
8776 CheckImpact[newx][newy] = CHECK_DELAY_IMPACT;
8779 if (DONT_TOUCH(element)) // object may be nasty to player or others
8781 TestIfBadThingTouchesPlayer(newx, newy);
8782 TestIfBadThingTouchesFriend(newx, newy);
8784 if (!IS_CUSTOM_ELEMENT(element))
8785 TestIfBadThingTouchesOtherBadThing(newx, newy);
8787 else if (element == EL_PENGUIN)
8788 TestIfFriendTouchesBadThing(newx, newy);
8790 if (DONT_GET_HIT_BY(element))
8792 TestIfGoodThingGetsHitByBadThing(newx, newy, direction);
8795 // give the player one last chance (one more frame) to move away
8796 if (CAN_FALL(element) && direction == MV_DOWN &&
8797 (last_line || (!IS_FREE(x, newy + 1) &&
8798 (!IS_PLAYER(x, newy + 1) ||
8799 game.engine_version < VERSION_IDENT(3,1,1,0)))))
8802 if (pushed_by_player && !game.use_change_when_pushing_bug)
8804 int push_side = MV_DIR_OPPOSITE(direction);
8805 struct PlayerInfo *player = PLAYERINFO(x, y);
8807 CheckElementChangeByPlayer(newx, newy, element, CE_PUSHED_BY_PLAYER,
8808 player->index_bit, push_side);
8809 CheckTriggeredElementChangeByPlayer(newx,newy, element, CE_PLAYER_PUSHES_X,
8810 player->index_bit, push_side);
8813 if (element == EL_EMC_ANDROID && pushed_by_player) // make another move
8814 MovDelay[newx][newy] = 1;
8816 CheckTriggeredElementChangeBySide(x, y, element, CE_MOVE_OF_X, direction);
8818 TestIfElementTouchesCustomElement(x, y); // empty or new element
8819 TestIfElementHitsCustomElement(newx, newy, direction);
8820 TestIfPlayerTouchesCustomElement(newx, newy);
8821 TestIfElementTouchesCustomElement(newx, newy);
8823 if (IS_CUSTOM_ELEMENT(element) && ei->move_enter_element != EL_EMPTY &&
8824 IS_EQUAL_OR_IN_GROUP(stored_new, ei->move_enter_element))
8825 CheckElementChangeBySide(newx, newy, element, stored_new, CE_DIGGING_X,
8826 MV_DIR_OPPOSITE(direction));
8829 int AmoebaNeighbourNr(int ax, int ay)
8832 int element = Tile[ax][ay];
8834 static int xy[4][2] =
8842 for (i = 0; i < NUM_DIRECTIONS; i++)
8844 int x = ax + xy[i][0];
8845 int y = ay + xy[i][1];
8847 if (!IN_LEV_FIELD(x, y))
8850 if (Tile[x][y] == element && AmoebaNr[x][y] > 0)
8851 group_nr = AmoebaNr[x][y];
8857 static void AmoebaMerge(int ax, int ay)
8859 int i, x, y, xx, yy;
8860 int new_group_nr = AmoebaNr[ax][ay];
8861 static int xy[4][2] =
8869 if (new_group_nr == 0)
8872 for (i = 0; i < NUM_DIRECTIONS; i++)
8877 if (!IN_LEV_FIELD(x, y))
8880 if ((Tile[x][y] == EL_AMOEBA_FULL ||
8881 Tile[x][y] == EL_BD_AMOEBA ||
8882 Tile[x][y] == EL_AMOEBA_DEAD) &&
8883 AmoebaNr[x][y] != new_group_nr)
8885 int old_group_nr = AmoebaNr[x][y];
8887 if (old_group_nr == 0)
8890 AmoebaCnt[new_group_nr] += AmoebaCnt[old_group_nr];
8891 AmoebaCnt[old_group_nr] = 0;
8892 AmoebaCnt2[new_group_nr] += AmoebaCnt2[old_group_nr];
8893 AmoebaCnt2[old_group_nr] = 0;
8895 SCAN_PLAYFIELD(xx, yy)
8897 if (AmoebaNr[xx][yy] == old_group_nr)
8898 AmoebaNr[xx][yy] = new_group_nr;
8904 void AmoebaToDiamond(int ax, int ay)
8908 if (Tile[ax][ay] == EL_AMOEBA_DEAD)
8910 int group_nr = AmoebaNr[ax][ay];
8915 Debug("game:playing:AmoebaToDiamond", "ax = %d, ay = %d", ax, ay);
8916 Debug("game:playing:AmoebaToDiamond", "This should never happen!");
8922 SCAN_PLAYFIELD(x, y)
8924 if (Tile[x][y] == EL_AMOEBA_DEAD && AmoebaNr[x][y] == group_nr)
8927 Tile[x][y] = EL_AMOEBA_TO_DIAMOND;
8931 PlayLevelSound(ax, ay, (IS_GEM(level.amoeba_content) ?
8932 SND_AMOEBA_TURNING_TO_GEM :
8933 SND_AMOEBA_TURNING_TO_ROCK));
8938 static int xy[4][2] =
8946 for (i = 0; i < NUM_DIRECTIONS; i++)
8951 if (!IN_LEV_FIELD(x, y))
8954 if (Tile[x][y] == EL_AMOEBA_TO_DIAMOND)
8956 PlayLevelSound(x, y, (IS_GEM(level.amoeba_content) ?
8957 SND_AMOEBA_TURNING_TO_GEM :
8958 SND_AMOEBA_TURNING_TO_ROCK));
8965 static void AmoebaToDiamondBD(int ax, int ay, int new_element)
8968 int group_nr = AmoebaNr[ax][ay];
8969 boolean done = FALSE;
8974 Debug("game:playing:AmoebaToDiamondBD", "ax = %d, ay = %d", ax, ay);
8975 Debug("game:playing:AmoebaToDiamondBD", "This should never happen!");
8981 SCAN_PLAYFIELD(x, y)
8983 if (AmoebaNr[x][y] == group_nr &&
8984 (Tile[x][y] == EL_AMOEBA_DEAD ||
8985 Tile[x][y] == EL_BD_AMOEBA ||
8986 Tile[x][y] == EL_AMOEBA_GROWING))
8989 Tile[x][y] = new_element;
8990 InitField(x, y, FALSE);
8991 TEST_DrawLevelField(x, y);
8997 PlayLevelSound(ax, ay, (new_element == EL_BD_ROCK ?
8998 SND_BD_AMOEBA_TURNING_TO_ROCK :
8999 SND_BD_AMOEBA_TURNING_TO_GEM));
9002 static void AmoebaGrowing(int x, int y)
9004 static unsigned int sound_delay = 0;
9005 static unsigned int sound_delay_value = 0;
9007 if (!MovDelay[x][y]) // start new growing cycle
9011 if (DelayReached(&sound_delay, sound_delay_value))
9013 PlayLevelSoundElementAction(x, y, Store[x][y], ACTION_GROWING);
9014 sound_delay_value = 30;
9018 if (MovDelay[x][y]) // wait some time before growing bigger
9021 if (MovDelay[x][y]/2 && IN_SCR_FIELD(SCREENX(x), SCREENY(y)))
9023 int frame = getGraphicAnimationFrame(IMG_AMOEBA_GROWING,
9024 6 - MovDelay[x][y]);
9026 DrawGraphic(SCREENX(x), SCREENY(y), IMG_AMOEBA_GROWING, frame);
9029 if (!MovDelay[x][y])
9031 Tile[x][y] = Store[x][y];
9033 TEST_DrawLevelField(x, y);
9038 static void AmoebaShrinking(int x, int y)
9040 static unsigned int sound_delay = 0;
9041 static unsigned int sound_delay_value = 0;
9043 if (!MovDelay[x][y]) // start new shrinking cycle
9047 if (DelayReached(&sound_delay, sound_delay_value))
9048 sound_delay_value = 30;
9051 if (MovDelay[x][y]) // wait some time before shrinking
9054 if (MovDelay[x][y]/2 && IN_SCR_FIELD(SCREENX(x), SCREENY(y)))
9056 int frame = getGraphicAnimationFrame(IMG_AMOEBA_SHRINKING,
9057 6 - MovDelay[x][y]);
9059 DrawGraphic(SCREENX(x), SCREENY(y), IMG_AMOEBA_SHRINKING, frame);
9062 if (!MovDelay[x][y])
9064 Tile[x][y] = EL_EMPTY;
9065 TEST_DrawLevelField(x, y);
9067 // don't let mole enter this field in this cycle;
9068 // (give priority to objects falling to this field from above)
9074 static void AmoebaReproduce(int ax, int ay)
9077 int element = Tile[ax][ay];
9078 int graphic = el2img(element);
9079 int newax = ax, neway = ay;
9080 boolean can_drop = (element == EL_AMOEBA_WET || element == EL_EMC_DRIPPER);
9081 static int xy[4][2] =
9089 if (!level.amoeba_speed && element != EL_EMC_DRIPPER)
9091 Tile[ax][ay] = EL_AMOEBA_DEAD;
9092 TEST_DrawLevelField(ax, ay);
9096 if (IS_ANIMATED(graphic))
9097 DrawLevelGraphicAnimationIfNeeded(ax, ay, graphic);
9099 if (!MovDelay[ax][ay]) // start making new amoeba field
9100 MovDelay[ax][ay] = RND(FRAMES_PER_SECOND * 25 / (1 + level.amoeba_speed));
9102 if (MovDelay[ax][ay]) // wait some time before making new amoeba
9105 if (MovDelay[ax][ay])
9109 if (can_drop) // EL_AMOEBA_WET or EL_EMC_DRIPPER
9112 int x = ax + xy[start][0];
9113 int y = ay + xy[start][1];
9115 if (!IN_LEV_FIELD(x, y))
9118 if (IS_FREE(x, y) ||
9119 CAN_GROW_INTO(Tile[x][y]) ||
9120 Tile[x][y] == EL_QUICKSAND_EMPTY ||
9121 Tile[x][y] == EL_QUICKSAND_FAST_EMPTY)
9127 if (newax == ax && neway == ay)
9130 else // normal or "filled" (BD style) amoeba
9133 boolean waiting_for_player = FALSE;
9135 for (i = 0; i < NUM_DIRECTIONS; i++)
9137 int j = (start + i) % 4;
9138 int x = ax + xy[j][0];
9139 int y = ay + xy[j][1];
9141 if (!IN_LEV_FIELD(x, y))
9144 if (IS_FREE(x, y) ||
9145 CAN_GROW_INTO(Tile[x][y]) ||
9146 Tile[x][y] == EL_QUICKSAND_EMPTY ||
9147 Tile[x][y] == EL_QUICKSAND_FAST_EMPTY)
9153 else if (IS_PLAYER(x, y))
9154 waiting_for_player = TRUE;
9157 if (newax == ax && neway == ay) // amoeba cannot grow
9159 if (i == 4 && (!waiting_for_player || element == EL_BD_AMOEBA))
9161 Tile[ax][ay] = EL_AMOEBA_DEAD;
9162 TEST_DrawLevelField(ax, ay);
9163 AmoebaCnt[AmoebaNr[ax][ay]]--;
9165 if (AmoebaCnt[AmoebaNr[ax][ay]] <= 0) // amoeba is completely dead
9167 if (element == EL_AMOEBA_FULL)
9168 AmoebaToDiamond(ax, ay);
9169 else if (element == EL_BD_AMOEBA)
9170 AmoebaToDiamondBD(ax, ay, level.amoeba_content);
9175 else if (element == EL_AMOEBA_FULL || element == EL_BD_AMOEBA)
9177 // amoeba gets larger by growing in some direction
9179 int new_group_nr = AmoebaNr[ax][ay];
9182 if (new_group_nr == 0)
9184 Debug("game:playing:AmoebaReproduce", "newax = %d, neway = %d",
9186 Debug("game:playing:AmoebaReproduce", "This should never happen!");
9192 AmoebaNr[newax][neway] = new_group_nr;
9193 AmoebaCnt[new_group_nr]++;
9194 AmoebaCnt2[new_group_nr]++;
9196 // if amoeba touches other amoeba(s) after growing, unify them
9197 AmoebaMerge(newax, neway);
9199 if (element == EL_BD_AMOEBA && AmoebaCnt2[new_group_nr] >= 200)
9201 AmoebaToDiamondBD(newax, neway, EL_BD_ROCK);
9207 if (!can_drop || neway < ay || !IS_FREE(newax, neway) ||
9208 (neway == lev_fieldy - 1 && newax != ax))
9210 Tile[newax][neway] = EL_AMOEBA_GROWING; // creation of new amoeba
9211 Store[newax][neway] = element;
9213 else if (neway == ay || element == EL_EMC_DRIPPER)
9215 Tile[newax][neway] = EL_AMOEBA_DROP; // drop left/right of amoeba
9217 PlayLevelSoundAction(newax, neway, ACTION_GROWING);
9221 InitMovingField(ax, ay, MV_DOWN); // drop dripping from amoeba
9222 Tile[ax][ay] = EL_AMOEBA_DROPPING;
9223 Store[ax][ay] = EL_AMOEBA_DROP;
9224 ContinueMoving(ax, ay);
9228 TEST_DrawLevelField(newax, neway);
9231 static void Life(int ax, int ay)
9235 int element = Tile[ax][ay];
9236 int graphic = el2img(element);
9237 int *life_parameter = (element == EL_GAME_OF_LIFE ? level.game_of_life :
9239 boolean changed = FALSE;
9241 if (IS_ANIMATED(graphic))
9242 DrawLevelGraphicAnimationIfNeeded(ax, ay, graphic);
9247 if (!MovDelay[ax][ay]) // start new "game of life" cycle
9248 MovDelay[ax][ay] = life_time;
9250 if (MovDelay[ax][ay]) // wait some time before next cycle
9253 if (MovDelay[ax][ay])
9257 for (y1 = -1; y1 < 2; y1++) for (x1 = -1; x1 < 2; x1++)
9259 int xx = ax+x1, yy = ay+y1;
9260 int old_element = Tile[xx][yy];
9261 int num_neighbours = 0;
9263 if (!IN_LEV_FIELD(xx, yy))
9266 for (y2 = -1; y2 < 2; y2++) for (x2 = -1; x2 < 2; x2++)
9268 int x = xx+x2, y = yy+y2;
9270 if (!IN_LEV_FIELD(x, y) || (x == xx && y == yy))
9273 boolean is_player_cell = (element == EL_GAME_OF_LIFE && IS_PLAYER(x, y));
9274 boolean is_neighbour = FALSE;
9276 if (level.use_life_bugs)
9278 (((Tile[x][y] == element || is_player_cell) && !Stop[x][y]) ||
9279 (IS_FREE(x, y) && Stop[x][y]));
9282 (Last[x][y] == element || is_player_cell);
9288 boolean is_free = FALSE;
9290 if (level.use_life_bugs)
9291 is_free = (IS_FREE(xx, yy));
9293 is_free = (IS_FREE(xx, yy) && Last[xx][yy] == EL_EMPTY);
9295 if (xx == ax && yy == ay) // field in the middle
9297 if (num_neighbours < life_parameter[0] ||
9298 num_neighbours > life_parameter[1])
9300 Tile[xx][yy] = EL_EMPTY;
9301 if (Tile[xx][yy] != old_element)
9302 TEST_DrawLevelField(xx, yy);
9303 Stop[xx][yy] = TRUE;
9307 else if (is_free || CAN_GROW_INTO(Tile[xx][yy]))
9308 { // free border field
9309 if (num_neighbours >= life_parameter[2] &&
9310 num_neighbours <= life_parameter[3])
9312 Tile[xx][yy] = element;
9313 MovDelay[xx][yy] = (element == EL_GAME_OF_LIFE ? 0 : life_time-1);
9314 if (Tile[xx][yy] != old_element)
9315 TEST_DrawLevelField(xx, yy);
9316 Stop[xx][yy] = TRUE;
9323 PlayLevelSound(ax, ay, element == EL_BIOMAZE ? SND_BIOMAZE_GROWING :
9324 SND_GAME_OF_LIFE_GROWING);
9327 static void InitRobotWheel(int x, int y)
9329 ChangeDelay[x][y] = level.time_wheel * FRAMES_PER_SECOND;
9332 static void RunRobotWheel(int x, int y)
9334 PlayLevelSound(x, y, SND_ROBOT_WHEEL_ACTIVE);
9337 static void StopRobotWheel(int x, int y)
9339 if (game.robot_wheel_x == x &&
9340 game.robot_wheel_y == y)
9342 game.robot_wheel_x = -1;
9343 game.robot_wheel_y = -1;
9344 game.robot_wheel_active = FALSE;
9348 static void InitTimegateWheel(int x, int y)
9350 ChangeDelay[x][y] = level.time_timegate * FRAMES_PER_SECOND;
9353 static void RunTimegateWheel(int x, int y)
9355 PlayLevelSound(x, y, SND_CLASS_TIMEGATE_SWITCH_ACTIVE);
9358 static void InitMagicBallDelay(int x, int y)
9360 ChangeDelay[x][y] = (level.ball_time + 1) * 8 + 1;
9363 static void ActivateMagicBall(int bx, int by)
9367 if (level.ball_random)
9369 int pos_border = RND(8); // select one of the eight border elements
9370 int pos_content = (pos_border > 3 ? pos_border + 1 : pos_border);
9371 int xx = pos_content % 3;
9372 int yy = pos_content / 3;
9377 if (IN_LEV_FIELD(x, y) && Tile[x][y] == EL_EMPTY)
9378 CreateField(x, y, level.ball_content[game.ball_content_nr].e[xx][yy]);
9382 for (y = by - 1; y <= by + 1; y++) for (x = bx - 1; x <= bx + 1; x++)
9384 int xx = x - bx + 1;
9385 int yy = y - by + 1;
9387 if (IN_LEV_FIELD(x, y) && Tile[x][y] == EL_EMPTY)
9388 CreateField(x, y, level.ball_content[game.ball_content_nr].e[xx][yy]);
9392 game.ball_content_nr = (game.ball_content_nr + 1) % level.num_ball_contents;
9395 static void CheckExit(int x, int y)
9397 if (game.gems_still_needed > 0 ||
9398 game.sokoban_fields_still_needed > 0 ||
9399 game.sokoban_objects_still_needed > 0 ||
9400 game.lights_still_needed > 0)
9402 int element = Tile[x][y];
9403 int graphic = el2img(element);
9405 if (IS_ANIMATED(graphic))
9406 DrawLevelGraphicAnimationIfNeeded(x, y, graphic);
9411 // do not re-open exit door closed after last player
9412 if (game.all_players_gone)
9415 Tile[x][y] = EL_EXIT_OPENING;
9417 PlayLevelSoundNearest(x, y, SND_CLASS_EXIT_OPENING);
9420 static void CheckExitEM(int x, int y)
9422 if (game.gems_still_needed > 0 ||
9423 game.sokoban_fields_still_needed > 0 ||
9424 game.sokoban_objects_still_needed > 0 ||
9425 game.lights_still_needed > 0)
9427 int element = Tile[x][y];
9428 int graphic = el2img(element);
9430 if (IS_ANIMATED(graphic))
9431 DrawLevelGraphicAnimationIfNeeded(x, y, graphic);
9436 // do not re-open exit door closed after last player
9437 if (game.all_players_gone)
9440 Tile[x][y] = EL_EM_EXIT_OPENING;
9442 PlayLevelSoundNearest(x, y, SND_CLASS_EM_EXIT_OPENING);
9445 static void CheckExitSteel(int x, int y)
9447 if (game.gems_still_needed > 0 ||
9448 game.sokoban_fields_still_needed > 0 ||
9449 game.sokoban_objects_still_needed > 0 ||
9450 game.lights_still_needed > 0)
9452 int element = Tile[x][y];
9453 int graphic = el2img(element);
9455 if (IS_ANIMATED(graphic))
9456 DrawLevelGraphicAnimationIfNeeded(x, y, graphic);
9461 // do not re-open exit door closed after last player
9462 if (game.all_players_gone)
9465 Tile[x][y] = EL_STEEL_EXIT_OPENING;
9467 PlayLevelSoundNearest(x, y, SND_CLASS_STEEL_EXIT_OPENING);
9470 static void CheckExitSteelEM(int x, int y)
9472 if (game.gems_still_needed > 0 ||
9473 game.sokoban_fields_still_needed > 0 ||
9474 game.sokoban_objects_still_needed > 0 ||
9475 game.lights_still_needed > 0)
9477 int element = Tile[x][y];
9478 int graphic = el2img(element);
9480 if (IS_ANIMATED(graphic))
9481 DrawLevelGraphicAnimationIfNeeded(x, y, graphic);
9486 // do not re-open exit door closed after last player
9487 if (game.all_players_gone)
9490 Tile[x][y] = EL_EM_STEEL_EXIT_OPENING;
9492 PlayLevelSoundNearest(x, y, SND_CLASS_EM_STEEL_EXIT_OPENING);
9495 static void CheckExitSP(int x, int y)
9497 if (game.gems_still_needed > 0)
9499 int element = Tile[x][y];
9500 int graphic = el2img(element);
9502 if (IS_ANIMATED(graphic))
9503 DrawLevelGraphicAnimationIfNeeded(x, y, graphic);
9508 // do not re-open exit door closed after last player
9509 if (game.all_players_gone)
9512 Tile[x][y] = EL_SP_EXIT_OPENING;
9514 PlayLevelSoundNearest(x, y, SND_CLASS_SP_EXIT_OPENING);
9517 static void CloseAllOpenTimegates(void)
9521 SCAN_PLAYFIELD(x, y)
9523 int element = Tile[x][y];
9525 if (element == EL_TIMEGATE_OPEN || element == EL_TIMEGATE_OPENING)
9527 Tile[x][y] = EL_TIMEGATE_CLOSING;
9529 PlayLevelSoundAction(x, y, ACTION_CLOSING);
9534 static void DrawTwinkleOnField(int x, int y)
9536 if (!IN_SCR_FIELD(SCREENX(x), SCREENY(y)) || IS_MOVING(x, y))
9539 if (Tile[x][y] == EL_BD_DIAMOND)
9542 if (MovDelay[x][y] == 0) // next animation frame
9543 MovDelay[x][y] = 11 * !GetSimpleRandom(500);
9545 if (MovDelay[x][y] != 0) // wait some time before next frame
9549 DrawLevelElementAnimation(x, y, Tile[x][y]);
9551 if (MovDelay[x][y] != 0)
9553 int frame = getGraphicAnimationFrame(IMG_TWINKLE_WHITE,
9554 10 - MovDelay[x][y]);
9556 DrawGraphicThruMask(SCREENX(x), SCREENY(y), IMG_TWINKLE_WHITE, frame);
9561 static void MauerWaechst(int x, int y)
9565 if (!MovDelay[x][y]) // next animation frame
9566 MovDelay[x][y] = 3 * delay;
9568 if (MovDelay[x][y]) // wait some time before next frame
9572 if (IN_SCR_FIELD(SCREENX(x), SCREENY(y)))
9574 int graphic = el_dir2img(Tile[x][y], GfxDir[x][y]);
9575 int frame = getGraphicAnimationFrame(graphic, 17 - MovDelay[x][y]);
9577 DrawGraphic(SCREENX(x), SCREENY(y), graphic, frame);
9580 if (!MovDelay[x][y])
9582 if (MovDir[x][y] == MV_LEFT)
9584 if (IN_LEV_FIELD(x - 1, y) && IS_WALL(Tile[x - 1][y]))
9585 TEST_DrawLevelField(x - 1, y);
9587 else if (MovDir[x][y] == MV_RIGHT)
9589 if (IN_LEV_FIELD(x + 1, y) && IS_WALL(Tile[x + 1][y]))
9590 TEST_DrawLevelField(x + 1, y);
9592 else if (MovDir[x][y] == MV_UP)
9594 if (IN_LEV_FIELD(x, y - 1) && IS_WALL(Tile[x][y - 1]))
9595 TEST_DrawLevelField(x, y - 1);
9599 if (IN_LEV_FIELD(x, y + 1) && IS_WALL(Tile[x][y + 1]))
9600 TEST_DrawLevelField(x, y + 1);
9603 Tile[x][y] = Store[x][y];
9605 GfxDir[x][y] = MovDir[x][y] = MV_NONE;
9606 TEST_DrawLevelField(x, y);
9611 static void MauerAbleger(int ax, int ay)
9613 int element = Tile[ax][ay];
9614 int graphic = el2img(element);
9615 boolean oben_frei = FALSE, unten_frei = FALSE;
9616 boolean links_frei = FALSE, rechts_frei = FALSE;
9617 boolean oben_massiv = FALSE, unten_massiv = FALSE;
9618 boolean links_massiv = FALSE, rechts_massiv = FALSE;
9619 boolean new_wall = FALSE;
9621 if (IS_ANIMATED(graphic))
9622 DrawLevelGraphicAnimationIfNeeded(ax, ay, graphic);
9624 if (!MovDelay[ax][ay]) // start building new wall
9625 MovDelay[ax][ay] = 6;
9627 if (MovDelay[ax][ay]) // wait some time before building new wall
9630 if (MovDelay[ax][ay])
9634 if (IN_LEV_FIELD(ax, ay-1) && IS_FREE(ax, ay-1))
9636 if (IN_LEV_FIELD(ax, ay+1) && IS_FREE(ax, ay+1))
9638 if (IN_LEV_FIELD(ax-1, ay) && IS_FREE(ax-1, ay))
9640 if (IN_LEV_FIELD(ax+1, ay) && IS_FREE(ax+1, ay))
9643 if (element == EL_EXPANDABLE_WALL_VERTICAL ||
9644 element == EL_EXPANDABLE_WALL_ANY)
9648 Tile[ax][ay-1] = EL_EXPANDABLE_WALL_GROWING;
9649 Store[ax][ay-1] = element;
9650 GfxDir[ax][ay-1] = MovDir[ax][ay-1] = MV_UP;
9651 if (IN_SCR_FIELD(SCREENX(ax), SCREENY(ay-1)))
9652 DrawGraphic(SCREENX(ax), SCREENY(ay - 1),
9653 IMG_EXPANDABLE_WALL_GROWING_UP, 0);
9658 Tile[ax][ay+1] = EL_EXPANDABLE_WALL_GROWING;
9659 Store[ax][ay+1] = element;
9660 GfxDir[ax][ay+1] = MovDir[ax][ay+1] = MV_DOWN;
9661 if (IN_SCR_FIELD(SCREENX(ax), SCREENY(ay+1)))
9662 DrawGraphic(SCREENX(ax), SCREENY(ay + 1),
9663 IMG_EXPANDABLE_WALL_GROWING_DOWN, 0);
9668 if (element == EL_EXPANDABLE_WALL_HORIZONTAL ||
9669 element == EL_EXPANDABLE_WALL_ANY ||
9670 element == EL_EXPANDABLE_WALL ||
9671 element == EL_BD_EXPANDABLE_WALL)
9675 Tile[ax-1][ay] = EL_EXPANDABLE_WALL_GROWING;
9676 Store[ax-1][ay] = element;
9677 GfxDir[ax-1][ay] = MovDir[ax-1][ay] = MV_LEFT;
9678 if (IN_SCR_FIELD(SCREENX(ax-1), SCREENY(ay)))
9679 DrawGraphic(SCREENX(ax - 1), SCREENY(ay),
9680 IMG_EXPANDABLE_WALL_GROWING_LEFT, 0);
9686 Tile[ax+1][ay] = EL_EXPANDABLE_WALL_GROWING;
9687 Store[ax+1][ay] = element;
9688 GfxDir[ax+1][ay] = MovDir[ax+1][ay] = MV_RIGHT;
9689 if (IN_SCR_FIELD(SCREENX(ax+1), SCREENY(ay)))
9690 DrawGraphic(SCREENX(ax + 1), SCREENY(ay),
9691 IMG_EXPANDABLE_WALL_GROWING_RIGHT, 0);
9696 if (element == EL_EXPANDABLE_WALL && (links_frei || rechts_frei))
9697 TEST_DrawLevelField(ax, ay);
9699 if (!IN_LEV_FIELD(ax, ay-1) || IS_WALL(Tile[ax][ay-1]))
9701 if (!IN_LEV_FIELD(ax, ay+1) || IS_WALL(Tile[ax][ay+1]))
9702 unten_massiv = TRUE;
9703 if (!IN_LEV_FIELD(ax-1, ay) || IS_WALL(Tile[ax-1][ay]))
9704 links_massiv = TRUE;
9705 if (!IN_LEV_FIELD(ax+1, ay) || IS_WALL(Tile[ax+1][ay]))
9706 rechts_massiv = TRUE;
9708 if (((oben_massiv && unten_massiv) ||
9709 element == EL_EXPANDABLE_WALL_HORIZONTAL ||
9710 element == EL_EXPANDABLE_WALL) &&
9711 ((links_massiv && rechts_massiv) ||
9712 element == EL_EXPANDABLE_WALL_VERTICAL))
9713 Tile[ax][ay] = EL_WALL;
9716 PlayLevelSoundAction(ax, ay, ACTION_GROWING);
9719 static void MauerAblegerStahl(int ax, int ay)
9721 int element = Tile[ax][ay];
9722 int graphic = el2img(element);
9723 boolean oben_frei = FALSE, unten_frei = FALSE;
9724 boolean links_frei = FALSE, rechts_frei = FALSE;
9725 boolean oben_massiv = FALSE, unten_massiv = FALSE;
9726 boolean links_massiv = FALSE, rechts_massiv = FALSE;
9727 boolean new_wall = FALSE;
9729 if (IS_ANIMATED(graphic))
9730 DrawLevelGraphicAnimationIfNeeded(ax, ay, graphic);
9732 if (!MovDelay[ax][ay]) // start building new wall
9733 MovDelay[ax][ay] = 6;
9735 if (MovDelay[ax][ay]) // wait some time before building new wall
9738 if (MovDelay[ax][ay])
9742 if (IN_LEV_FIELD(ax, ay-1) && IS_FREE(ax, ay-1))
9744 if (IN_LEV_FIELD(ax, ay+1) && IS_FREE(ax, ay+1))
9746 if (IN_LEV_FIELD(ax-1, ay) && IS_FREE(ax-1, ay))
9748 if (IN_LEV_FIELD(ax+1, ay) && IS_FREE(ax+1, ay))
9751 if (element == EL_EXPANDABLE_STEELWALL_VERTICAL ||
9752 element == EL_EXPANDABLE_STEELWALL_ANY)
9756 Tile[ax][ay-1] = EL_EXPANDABLE_STEELWALL_GROWING;
9757 Store[ax][ay-1] = element;
9758 GfxDir[ax][ay-1] = MovDir[ax][ay-1] = MV_UP;
9759 if (IN_SCR_FIELD(SCREENX(ax), SCREENY(ay-1)))
9760 DrawGraphic(SCREENX(ax), SCREENY(ay - 1),
9761 IMG_EXPANDABLE_STEELWALL_GROWING_UP, 0);
9766 Tile[ax][ay+1] = EL_EXPANDABLE_STEELWALL_GROWING;
9767 Store[ax][ay+1] = element;
9768 GfxDir[ax][ay+1] = MovDir[ax][ay+1] = MV_DOWN;
9769 if (IN_SCR_FIELD(SCREENX(ax), SCREENY(ay+1)))
9770 DrawGraphic(SCREENX(ax), SCREENY(ay + 1),
9771 IMG_EXPANDABLE_STEELWALL_GROWING_DOWN, 0);
9776 if (element == EL_EXPANDABLE_STEELWALL_HORIZONTAL ||
9777 element == EL_EXPANDABLE_STEELWALL_ANY)
9781 Tile[ax-1][ay] = EL_EXPANDABLE_STEELWALL_GROWING;
9782 Store[ax-1][ay] = element;
9783 GfxDir[ax-1][ay] = MovDir[ax-1][ay] = MV_LEFT;
9784 if (IN_SCR_FIELD(SCREENX(ax-1), SCREENY(ay)))
9785 DrawGraphic(SCREENX(ax - 1), SCREENY(ay),
9786 IMG_EXPANDABLE_STEELWALL_GROWING_LEFT, 0);
9792 Tile[ax+1][ay] = EL_EXPANDABLE_STEELWALL_GROWING;
9793 Store[ax+1][ay] = element;
9794 GfxDir[ax+1][ay] = MovDir[ax+1][ay] = MV_RIGHT;
9795 if (IN_SCR_FIELD(SCREENX(ax+1), SCREENY(ay)))
9796 DrawGraphic(SCREENX(ax + 1), SCREENY(ay),
9797 IMG_EXPANDABLE_STEELWALL_GROWING_RIGHT, 0);
9802 if (!IN_LEV_FIELD(ax, ay-1) || IS_WALL(Tile[ax][ay-1]))
9804 if (!IN_LEV_FIELD(ax, ay+1) || IS_WALL(Tile[ax][ay+1]))
9805 unten_massiv = TRUE;
9806 if (!IN_LEV_FIELD(ax-1, ay) || IS_WALL(Tile[ax-1][ay]))
9807 links_massiv = TRUE;
9808 if (!IN_LEV_FIELD(ax+1, ay) || IS_WALL(Tile[ax+1][ay]))
9809 rechts_massiv = TRUE;
9811 if (((oben_massiv && unten_massiv) ||
9812 element == EL_EXPANDABLE_STEELWALL_HORIZONTAL) &&
9813 ((links_massiv && rechts_massiv) ||
9814 element == EL_EXPANDABLE_STEELWALL_VERTICAL))
9815 Tile[ax][ay] = EL_STEELWALL;
9818 PlayLevelSoundAction(ax, ay, ACTION_GROWING);
9821 static void CheckForDragon(int x, int y)
9824 boolean dragon_found = FALSE;
9825 static int xy[4][2] =
9833 for (i = 0; i < NUM_DIRECTIONS; i++)
9835 for (j = 0; j < 4; j++)
9837 int xx = x + j * xy[i][0], yy = y + j * xy[i][1];
9839 if (IN_LEV_FIELD(xx, yy) &&
9840 (Tile[xx][yy] == EL_FLAMES || Tile[xx][yy] == EL_DRAGON))
9842 if (Tile[xx][yy] == EL_DRAGON)
9843 dragon_found = TRUE;
9852 for (i = 0; i < NUM_DIRECTIONS; i++)
9854 for (j = 0; j < 3; j++)
9856 int xx = x + j * xy[i][0], yy = y + j * xy[i][1];
9858 if (IN_LEV_FIELD(xx, yy) && Tile[xx][yy] == EL_FLAMES)
9860 Tile[xx][yy] = EL_EMPTY;
9861 TEST_DrawLevelField(xx, yy);
9870 static void InitBuggyBase(int x, int y)
9872 int element = Tile[x][y];
9873 int activating_delay = FRAMES_PER_SECOND / 4;
9876 (element == EL_SP_BUGGY_BASE ?
9877 2 * FRAMES_PER_SECOND + RND(5 * FRAMES_PER_SECOND) - activating_delay :
9878 element == EL_SP_BUGGY_BASE_ACTIVATING ?
9880 element == EL_SP_BUGGY_BASE_ACTIVE ?
9881 1 * FRAMES_PER_SECOND + RND(1 * FRAMES_PER_SECOND) : 1);
9884 static void WarnBuggyBase(int x, int y)
9887 static int xy[4][2] =
9895 for (i = 0; i < NUM_DIRECTIONS; i++)
9897 int xx = x + xy[i][0];
9898 int yy = y + xy[i][1];
9900 if (IN_LEV_FIELD(xx, yy) && IS_PLAYER(xx, yy))
9902 PlayLevelSound(x, y, SND_SP_BUGGY_BASE_ACTIVE);
9909 static void InitTrap(int x, int y)
9911 ChangeDelay[x][y] = 2 * FRAMES_PER_SECOND + RND(5 * FRAMES_PER_SECOND);
9914 static void ActivateTrap(int x, int y)
9916 PlayLevelSound(x, y, SND_TRAP_ACTIVATING);
9919 static void ChangeActiveTrap(int x, int y)
9921 int graphic = IMG_TRAP_ACTIVE;
9923 // if new animation frame was drawn, correct crumbled sand border
9924 if (IS_NEW_FRAME(GfxFrame[x][y], graphic))
9925 TEST_DrawLevelFieldCrumbled(x, y);
9928 static int getSpecialActionElement(int element, int number, int base_element)
9930 return (element != EL_EMPTY ? element :
9931 number != -1 ? base_element + number - 1 :
9935 static int getModifiedActionNumber(int value_old, int operator, int operand,
9936 int value_min, int value_max)
9938 int value_new = (operator == CA_MODE_SET ? operand :
9939 operator == CA_MODE_ADD ? value_old + operand :
9940 operator == CA_MODE_SUBTRACT ? value_old - operand :
9941 operator == CA_MODE_MULTIPLY ? value_old * operand :
9942 operator == CA_MODE_DIVIDE ? value_old / MAX(1, operand) :
9943 operator == CA_MODE_MODULO ? value_old % MAX(1, operand) :
9946 return (value_new < value_min ? value_min :
9947 value_new > value_max ? value_max :
9951 static void ExecuteCustomElementAction(int x, int y, int element, int page)
9953 struct ElementInfo *ei = &element_info[element];
9954 struct ElementChangeInfo *change = &ei->change_page[page];
9955 int target_element = change->target_element;
9956 int action_type = change->action_type;
9957 int action_mode = change->action_mode;
9958 int action_arg = change->action_arg;
9959 int action_element = change->action_element;
9962 if (!change->has_action)
9965 // ---------- determine action paramater values -----------------------------
9967 int level_time_value =
9968 (level.time > 0 ? TimeLeft :
9971 int action_arg_element_raw =
9972 (action_arg == CA_ARG_PLAYER_TRIGGER ? change->actual_trigger_player :
9973 action_arg == CA_ARG_ELEMENT_TRIGGER ? change->actual_trigger_element :
9974 action_arg == CA_ARG_ELEMENT_TARGET ? change->target_element :
9975 action_arg == CA_ARG_ELEMENT_ACTION ? change->action_element :
9976 action_arg == CA_ARG_INVENTORY_RM_TRIGGER ? change->actual_trigger_element:
9977 action_arg == CA_ARG_INVENTORY_RM_TARGET ? change->target_element :
9978 action_arg == CA_ARG_INVENTORY_RM_ACTION ? change->action_element :
9980 int action_arg_element = GetElementFromGroupElement(action_arg_element_raw);
9982 int action_arg_direction =
9983 (action_arg >= CA_ARG_DIRECTION_LEFT &&
9984 action_arg <= CA_ARG_DIRECTION_DOWN ? action_arg - CA_ARG_DIRECTION :
9985 action_arg == CA_ARG_DIRECTION_TRIGGER ?
9986 change->actual_trigger_side :
9987 action_arg == CA_ARG_DIRECTION_TRIGGER_BACK ?
9988 MV_DIR_OPPOSITE(change->actual_trigger_side) :
9991 int action_arg_number_min =
9992 (action_type == CA_SET_PLAYER_SPEED ? STEPSIZE_NOT_MOVING :
9995 int action_arg_number_max =
9996 (action_type == CA_SET_PLAYER_SPEED ? STEPSIZE_EVEN_FASTER :
9997 action_type == CA_SET_LEVEL_GEMS ? 999 :
9998 action_type == CA_SET_LEVEL_TIME ? 9999 :
9999 action_type == CA_SET_LEVEL_SCORE ? 99999 :
10000 action_type == CA_SET_CE_VALUE ? 9999 :
10001 action_type == CA_SET_CE_SCORE ? 9999 :
10004 int action_arg_number_reset =
10005 (action_type == CA_SET_PLAYER_SPEED ? level.initial_player_stepsize[0] :
10006 action_type == CA_SET_LEVEL_GEMS ? level.gems_needed :
10007 action_type == CA_SET_LEVEL_TIME ? level.time :
10008 action_type == CA_SET_LEVEL_SCORE ? 0 :
10009 action_type == CA_SET_CE_VALUE ? GET_NEW_CE_VALUE(element) :
10010 action_type == CA_SET_CE_SCORE ? 0 :
10013 int action_arg_number =
10014 (action_arg <= CA_ARG_MAX ? action_arg :
10015 action_arg >= CA_ARG_SPEED_NOT_MOVING &&
10016 action_arg <= CA_ARG_SPEED_EVEN_FASTER ? (action_arg - CA_ARG_SPEED) :
10017 action_arg == CA_ARG_SPEED_RESET ? action_arg_number_reset :
10018 action_arg == CA_ARG_NUMBER_MIN ? action_arg_number_min :
10019 action_arg == CA_ARG_NUMBER_MAX ? action_arg_number_max :
10020 action_arg == CA_ARG_NUMBER_RESET ? action_arg_number_reset :
10021 action_arg == CA_ARG_NUMBER_CE_VALUE ? CustomValue[x][y] :
10022 action_arg == CA_ARG_NUMBER_CE_SCORE ? ei->collect_score :
10023 action_arg == CA_ARG_NUMBER_CE_DELAY ? GET_CE_DELAY_VALUE(change) :
10024 action_arg == CA_ARG_NUMBER_LEVEL_TIME ? level_time_value :
10025 action_arg == CA_ARG_NUMBER_LEVEL_GEMS ? game.gems_still_needed :
10026 action_arg == CA_ARG_NUMBER_LEVEL_SCORE ? game.score :
10027 action_arg == CA_ARG_ELEMENT_CV_TARGET ? GET_NEW_CE_VALUE(target_element):
10028 action_arg == CA_ARG_ELEMENT_CV_TRIGGER ? change->actual_trigger_ce_value:
10029 action_arg == CA_ARG_ELEMENT_CV_ACTION ? GET_NEW_CE_VALUE(action_element):
10030 action_arg == CA_ARG_ELEMENT_CS_TARGET ? GET_CE_SCORE(target_element) :
10031 action_arg == CA_ARG_ELEMENT_CS_TRIGGER ? change->actual_trigger_ce_score:
10032 action_arg == CA_ARG_ELEMENT_CS_ACTION ? GET_CE_SCORE(action_element) :
10033 action_arg == CA_ARG_ELEMENT_NR_TARGET ? change->target_element :
10034 action_arg == CA_ARG_ELEMENT_NR_TRIGGER ? change->actual_trigger_element :
10035 action_arg == CA_ARG_ELEMENT_NR_ACTION ? change->action_element :
10038 int action_arg_number_old =
10039 (action_type == CA_SET_LEVEL_GEMS ? game.gems_still_needed :
10040 action_type == CA_SET_LEVEL_TIME ? TimeLeft :
10041 action_type == CA_SET_LEVEL_SCORE ? game.score :
10042 action_type == CA_SET_CE_VALUE ? CustomValue[x][y] :
10043 action_type == CA_SET_CE_SCORE ? ei->collect_score :
10046 int action_arg_number_new =
10047 getModifiedActionNumber(action_arg_number_old,
10048 action_mode, action_arg_number,
10049 action_arg_number_min, action_arg_number_max);
10051 int trigger_player_bits =
10052 (change->actual_trigger_player_bits != CH_PLAYER_NONE ?
10053 change->actual_trigger_player_bits : change->trigger_player);
10055 int action_arg_player_bits =
10056 (action_arg >= CA_ARG_PLAYER_1 &&
10057 action_arg <= CA_ARG_PLAYER_4 ? action_arg - CA_ARG_PLAYER :
10058 action_arg == CA_ARG_PLAYER_TRIGGER ? trigger_player_bits :
10059 action_arg == CA_ARG_PLAYER_ACTION ? 1 << GET_PLAYER_NR(action_element) :
10062 // ---------- execute action -----------------------------------------------
10064 switch (action_type)
10071 // ---------- level actions ----------------------------------------------
10073 case CA_RESTART_LEVEL:
10075 game.restart_level = TRUE;
10080 case CA_SHOW_ENVELOPE:
10082 int element = getSpecialActionElement(action_arg_element,
10083 action_arg_number, EL_ENVELOPE_1);
10085 if (IS_ENVELOPE(element))
10086 local_player->show_envelope = element;
10091 case CA_SET_LEVEL_TIME:
10093 if (level.time > 0) // only modify limited time value
10095 TimeLeft = action_arg_number_new;
10097 game_panel_controls[GAME_PANEL_TIME].value = TimeLeft;
10099 DisplayGameControlValues();
10101 if (!TimeLeft && setup.time_limit)
10102 for (i = 0; i < MAX_PLAYERS; i++)
10103 KillPlayer(&stored_player[i]);
10109 case CA_SET_LEVEL_SCORE:
10111 game.score = action_arg_number_new;
10113 game_panel_controls[GAME_PANEL_SCORE].value = game.score;
10115 DisplayGameControlValues();
10120 case CA_SET_LEVEL_GEMS:
10122 game.gems_still_needed = action_arg_number_new;
10124 game.snapshot.collected_item = TRUE;
10126 game_panel_controls[GAME_PANEL_GEMS].value = game.gems_still_needed;
10128 DisplayGameControlValues();
10133 case CA_SET_LEVEL_WIND:
10135 game.wind_direction = action_arg_direction;
10140 case CA_SET_LEVEL_RANDOM_SEED:
10142 // ensure that setting a new random seed while playing is predictable
10143 InitRND(action_arg_number_new ? action_arg_number_new : RND(1000000) + 1);
10148 // ---------- player actions ---------------------------------------------
10150 case CA_MOVE_PLAYER:
10151 case CA_MOVE_PLAYER_NEW:
10153 // automatically move to the next field in specified direction
10154 for (i = 0; i < MAX_PLAYERS; i++)
10155 if (trigger_player_bits & (1 << i))
10156 if (action_type == CA_MOVE_PLAYER ||
10157 stored_player[i].MovPos == 0)
10158 stored_player[i].programmed_action = action_arg_direction;
10163 case CA_EXIT_PLAYER:
10165 for (i = 0; i < MAX_PLAYERS; i++)
10166 if (action_arg_player_bits & (1 << i))
10167 ExitPlayer(&stored_player[i]);
10169 if (game.players_still_needed == 0)
10175 case CA_KILL_PLAYER:
10177 for (i = 0; i < MAX_PLAYERS; i++)
10178 if (action_arg_player_bits & (1 << i))
10179 KillPlayer(&stored_player[i]);
10184 case CA_SET_PLAYER_KEYS:
10186 int key_state = (action_mode == CA_MODE_ADD ? TRUE : FALSE);
10187 int element = getSpecialActionElement(action_arg_element,
10188 action_arg_number, EL_KEY_1);
10190 if (IS_KEY(element))
10192 for (i = 0; i < MAX_PLAYERS; i++)
10194 if (trigger_player_bits & (1 << i))
10196 stored_player[i].key[KEY_NR(element)] = key_state;
10198 DrawGameDoorValues();
10206 case CA_SET_PLAYER_SPEED:
10208 for (i = 0; i < MAX_PLAYERS; i++)
10210 if (trigger_player_bits & (1 << i))
10212 int move_stepsize = TILEX / stored_player[i].move_delay_value;
10214 if (action_arg == CA_ARG_SPEED_FASTER &&
10215 stored_player[i].cannot_move)
10217 action_arg_number = STEPSIZE_VERY_SLOW;
10219 else if (action_arg == CA_ARG_SPEED_SLOWER ||
10220 action_arg == CA_ARG_SPEED_FASTER)
10222 action_arg_number = 2;
10223 action_mode = (action_arg == CA_ARG_SPEED_SLOWER ? CA_MODE_DIVIDE :
10226 else if (action_arg == CA_ARG_NUMBER_RESET)
10228 action_arg_number = level.initial_player_stepsize[i];
10232 getModifiedActionNumber(move_stepsize,
10235 action_arg_number_min,
10236 action_arg_number_max);
10238 SetPlayerMoveSpeed(&stored_player[i], move_stepsize, FALSE);
10245 case CA_SET_PLAYER_SHIELD:
10247 for (i = 0; i < MAX_PLAYERS; i++)
10249 if (trigger_player_bits & (1 << i))
10251 if (action_arg == CA_ARG_SHIELD_OFF)
10253 stored_player[i].shield_normal_time_left = 0;
10254 stored_player[i].shield_deadly_time_left = 0;
10256 else if (action_arg == CA_ARG_SHIELD_NORMAL)
10258 stored_player[i].shield_normal_time_left = 999999;
10260 else if (action_arg == CA_ARG_SHIELD_DEADLY)
10262 stored_player[i].shield_normal_time_left = 999999;
10263 stored_player[i].shield_deadly_time_left = 999999;
10271 case CA_SET_PLAYER_GRAVITY:
10273 for (i = 0; i < MAX_PLAYERS; i++)
10275 if (trigger_player_bits & (1 << i))
10277 stored_player[i].gravity =
10278 (action_arg == CA_ARG_GRAVITY_OFF ? FALSE :
10279 action_arg == CA_ARG_GRAVITY_ON ? TRUE :
10280 action_arg == CA_ARG_GRAVITY_TOGGLE ? !stored_player[i].gravity :
10281 stored_player[i].gravity);
10288 case CA_SET_PLAYER_ARTWORK:
10290 for (i = 0; i < MAX_PLAYERS; i++)
10292 if (trigger_player_bits & (1 << i))
10294 int artwork_element = action_arg_element;
10296 if (action_arg == CA_ARG_ELEMENT_RESET)
10298 (level.use_artwork_element[i] ? level.artwork_element[i] :
10299 stored_player[i].element_nr);
10301 if (stored_player[i].artwork_element != artwork_element)
10302 stored_player[i].Frame = 0;
10304 stored_player[i].artwork_element = artwork_element;
10306 SetPlayerWaiting(&stored_player[i], FALSE);
10308 // set number of special actions for bored and sleeping animation
10309 stored_player[i].num_special_action_bored =
10310 get_num_special_action(artwork_element,
10311 ACTION_BORING_1, ACTION_BORING_LAST);
10312 stored_player[i].num_special_action_sleeping =
10313 get_num_special_action(artwork_element,
10314 ACTION_SLEEPING_1, ACTION_SLEEPING_LAST);
10321 case CA_SET_PLAYER_INVENTORY:
10323 for (i = 0; i < MAX_PLAYERS; i++)
10325 struct PlayerInfo *player = &stored_player[i];
10328 if (trigger_player_bits & (1 << i))
10330 int inventory_element = action_arg_element;
10332 if (action_arg == CA_ARG_ELEMENT_TARGET ||
10333 action_arg == CA_ARG_ELEMENT_TRIGGER ||
10334 action_arg == CA_ARG_ELEMENT_ACTION)
10336 int element = inventory_element;
10337 int collect_count = element_info[element].collect_count_initial;
10339 if (!IS_CUSTOM_ELEMENT(element))
10342 if (collect_count == 0)
10343 player->inventory_infinite_element = element;
10345 for (k = 0; k < collect_count; k++)
10346 if (player->inventory_size < MAX_INVENTORY_SIZE)
10347 player->inventory_element[player->inventory_size++] =
10350 else if (action_arg == CA_ARG_INVENTORY_RM_TARGET ||
10351 action_arg == CA_ARG_INVENTORY_RM_TRIGGER ||
10352 action_arg == CA_ARG_INVENTORY_RM_ACTION)
10354 if (player->inventory_infinite_element != EL_UNDEFINED &&
10355 IS_EQUAL_OR_IN_GROUP(player->inventory_infinite_element,
10356 action_arg_element_raw))
10357 player->inventory_infinite_element = EL_UNDEFINED;
10359 for (k = 0, j = 0; j < player->inventory_size; j++)
10361 if (!IS_EQUAL_OR_IN_GROUP(player->inventory_element[j],
10362 action_arg_element_raw))
10363 player->inventory_element[k++] = player->inventory_element[j];
10366 player->inventory_size = k;
10368 else if (action_arg == CA_ARG_INVENTORY_RM_FIRST)
10370 if (player->inventory_size > 0)
10372 for (j = 0; j < player->inventory_size - 1; j++)
10373 player->inventory_element[j] = player->inventory_element[j + 1];
10375 player->inventory_size--;
10378 else if (action_arg == CA_ARG_INVENTORY_RM_LAST)
10380 if (player->inventory_size > 0)
10381 player->inventory_size--;
10383 else if (action_arg == CA_ARG_INVENTORY_RM_ALL)
10385 player->inventory_infinite_element = EL_UNDEFINED;
10386 player->inventory_size = 0;
10388 else if (action_arg == CA_ARG_INVENTORY_RESET)
10390 player->inventory_infinite_element = EL_UNDEFINED;
10391 player->inventory_size = 0;
10393 if (level.use_initial_inventory[i])
10395 for (j = 0; j < level.initial_inventory_size[i]; j++)
10397 int element = level.initial_inventory_content[i][j];
10398 int collect_count = element_info[element].collect_count_initial;
10400 if (!IS_CUSTOM_ELEMENT(element))
10403 if (collect_count == 0)
10404 player->inventory_infinite_element = element;
10406 for (k = 0; k < collect_count; k++)
10407 if (player->inventory_size < MAX_INVENTORY_SIZE)
10408 player->inventory_element[player->inventory_size++] =
10419 // ---------- CE actions -------------------------------------------------
10421 case CA_SET_CE_VALUE:
10423 int last_ce_value = CustomValue[x][y];
10425 CustomValue[x][y] = action_arg_number_new;
10427 if (CustomValue[x][y] != last_ce_value)
10429 CheckElementChange(x, y, element, EL_UNDEFINED, CE_VALUE_CHANGES);
10430 CheckTriggeredElementChange(x, y, element, CE_VALUE_CHANGES_OF_X);
10432 if (CustomValue[x][y] == 0)
10434 // reset change counter (else CE_VALUE_GETS_ZERO would not work)
10435 ChangeCount[x][y] = 0; // allow at least one more change
10437 CheckElementChange(x, y, element, EL_UNDEFINED, CE_VALUE_GETS_ZERO);
10438 CheckTriggeredElementChange(x, y, element, CE_VALUE_GETS_ZERO_OF_X);
10445 case CA_SET_CE_SCORE:
10447 int last_ce_score = ei->collect_score;
10449 ei->collect_score = action_arg_number_new;
10451 if (ei->collect_score != last_ce_score)
10453 CheckElementChange(x, y, element, EL_UNDEFINED, CE_SCORE_CHANGES);
10454 CheckTriggeredElementChange(x, y, element, CE_SCORE_CHANGES_OF_X);
10456 if (ei->collect_score == 0)
10460 // reset change counter (else CE_SCORE_GETS_ZERO would not work)
10461 ChangeCount[x][y] = 0; // allow at least one more change
10463 CheckElementChange(x, y, element, EL_UNDEFINED, CE_SCORE_GETS_ZERO);
10464 CheckTriggeredElementChange(x, y, element, CE_SCORE_GETS_ZERO_OF_X);
10467 This is a very special case that seems to be a mixture between
10468 CheckElementChange() and CheckTriggeredElementChange(): while
10469 the first one only affects single elements that are triggered
10470 directly, the second one affects multiple elements in the playfield
10471 that are triggered indirectly by another element. This is a third
10472 case: Changing the CE score always affects multiple identical CEs,
10473 so every affected CE must be checked, not only the single CE for
10474 which the CE score was changed in the first place (as every instance
10475 of that CE shares the same CE score, and therefore also can change)!
10477 SCAN_PLAYFIELD(xx, yy)
10479 if (Tile[xx][yy] == element)
10480 CheckElementChange(xx, yy, element, EL_UNDEFINED,
10481 CE_SCORE_GETS_ZERO);
10489 case CA_SET_CE_ARTWORK:
10491 int artwork_element = action_arg_element;
10492 boolean reset_frame = FALSE;
10495 if (action_arg == CA_ARG_ELEMENT_RESET)
10496 artwork_element = (ei->use_gfx_element ? ei->gfx_element_initial :
10499 if (ei->gfx_element != artwork_element)
10500 reset_frame = TRUE;
10502 ei->gfx_element = artwork_element;
10504 SCAN_PLAYFIELD(xx, yy)
10506 if (Tile[xx][yy] == element)
10510 ResetGfxAnimation(xx, yy);
10511 ResetRandomAnimationValue(xx, yy);
10514 TEST_DrawLevelField(xx, yy);
10521 // ---------- engine actions ---------------------------------------------
10523 case CA_SET_ENGINE_SCAN_MODE:
10525 InitPlayfieldScanMode(action_arg);
10535 static void CreateFieldExt(int x, int y, int element, boolean is_change)
10537 int old_element = Tile[x][y];
10538 int new_element = GetElementFromGroupElement(element);
10539 int previous_move_direction = MovDir[x][y];
10540 int last_ce_value = CustomValue[x][y];
10541 boolean player_explosion_protected = PLAYER_EXPLOSION_PROTECTED(x, y);
10542 boolean new_element_is_player = ELEM_IS_PLAYER(new_element);
10543 boolean add_player_onto_element = (new_element_is_player &&
10544 new_element != EL_SOKOBAN_FIELD_PLAYER &&
10545 IS_WALKABLE(old_element));
10547 if (!add_player_onto_element)
10549 if (IS_MOVING(x, y) || IS_BLOCKED(x, y))
10550 RemoveMovingField(x, y);
10554 Tile[x][y] = new_element;
10556 if (element_info[new_element].move_direction_initial == MV_START_PREVIOUS)
10557 MovDir[x][y] = previous_move_direction;
10559 if (element_info[new_element].use_last_ce_value)
10560 CustomValue[x][y] = last_ce_value;
10562 InitField_WithBug1(x, y, FALSE);
10564 new_element = Tile[x][y]; // element may have changed
10566 ResetGfxAnimation(x, y);
10567 ResetRandomAnimationValue(x, y);
10569 TEST_DrawLevelField(x, y);
10571 if (GFX_CRUMBLED(new_element))
10572 TEST_DrawLevelFieldCrumbledNeighbours(x, y);
10575 // check if element under the player changes from accessible to unaccessible
10576 // (needed for special case of dropping element which then changes)
10577 // (must be checked after creating new element for walkable group elements)
10578 if (IS_PLAYER(x, y) && !player_explosion_protected &&
10579 IS_ACCESSIBLE(old_element) && !IS_ACCESSIBLE(new_element))
10586 // "ChangeCount" not set yet to allow "entered by player" change one time
10587 if (new_element_is_player)
10588 RelocatePlayer(x, y, new_element);
10591 ChangeCount[x][y]++; // count number of changes in the same frame
10593 TestIfBadThingTouchesPlayer(x, y);
10594 TestIfPlayerTouchesCustomElement(x, y);
10595 TestIfElementTouchesCustomElement(x, y);
10598 static void CreateField(int x, int y, int element)
10600 CreateFieldExt(x, y, element, FALSE);
10603 static void CreateElementFromChange(int x, int y, int element)
10605 element = GET_VALID_RUNTIME_ELEMENT(element);
10607 if (game.engine_version >= VERSION_IDENT(3,2,0,7))
10609 int old_element = Tile[x][y];
10611 // prevent changed element from moving in same engine frame
10612 // unless both old and new element can either fall or move
10613 if ((!CAN_FALL(old_element) || !CAN_FALL(element)) &&
10614 (!CAN_MOVE(old_element) || !CAN_MOVE(element)))
10618 CreateFieldExt(x, y, element, TRUE);
10621 static boolean ChangeElement(int x, int y, int element, int page)
10623 struct ElementInfo *ei = &element_info[element];
10624 struct ElementChangeInfo *change = &ei->change_page[page];
10625 int ce_value = CustomValue[x][y];
10626 int ce_score = ei->collect_score;
10627 int target_element;
10628 int old_element = Tile[x][y];
10630 // always use default change event to prevent running into a loop
10631 if (ChangeEvent[x][y] == -1)
10632 ChangeEvent[x][y] = CE_DELAY;
10634 if (ChangeEvent[x][y] == CE_DELAY)
10636 // reset actual trigger element, trigger player and action element
10637 change->actual_trigger_element = EL_EMPTY;
10638 change->actual_trigger_player = EL_EMPTY;
10639 change->actual_trigger_player_bits = CH_PLAYER_NONE;
10640 change->actual_trigger_side = CH_SIDE_NONE;
10641 change->actual_trigger_ce_value = 0;
10642 change->actual_trigger_ce_score = 0;
10645 // do not change elements more than a specified maximum number of changes
10646 if (ChangeCount[x][y] >= game.max_num_changes_per_frame)
10649 ChangeCount[x][y]++; // count number of changes in the same frame
10651 if (change->explode)
10658 if (change->use_target_content)
10660 boolean complete_replace = TRUE;
10661 boolean can_replace[3][3];
10664 for (yy = 0; yy < 3; yy++) for (xx = 0; xx < 3 ; xx++)
10667 boolean is_walkable;
10668 boolean is_diggable;
10669 boolean is_collectible;
10670 boolean is_removable;
10671 boolean is_destructible;
10672 int ex = x + xx - 1;
10673 int ey = y + yy - 1;
10674 int content_element = change->target_content.e[xx][yy];
10677 can_replace[xx][yy] = TRUE;
10679 if (ex == x && ey == y) // do not check changing element itself
10682 if (content_element == EL_EMPTY_SPACE)
10684 can_replace[xx][yy] = FALSE; // do not replace border with space
10689 if (!IN_LEV_FIELD(ex, ey))
10691 can_replace[xx][yy] = FALSE;
10692 complete_replace = FALSE;
10699 if (IS_MOVING(ex, ey) || IS_BLOCKED(ex, ey))
10700 e = MovingOrBlocked2Element(ex, ey);
10702 is_empty = (IS_FREE(ex, ey) ||
10703 (IS_FREE_OR_PLAYER(ex, ey) && IS_WALKABLE(content_element)));
10705 is_walkable = (is_empty || IS_WALKABLE(e));
10706 is_diggable = (is_empty || IS_DIGGABLE(e));
10707 is_collectible = (is_empty || IS_COLLECTIBLE(e));
10708 is_destructible = (is_empty || !IS_INDESTRUCTIBLE(e));
10709 is_removable = (is_diggable || is_collectible);
10711 can_replace[xx][yy] =
10712 (((change->replace_when == CP_WHEN_EMPTY && is_empty) ||
10713 (change->replace_when == CP_WHEN_WALKABLE && is_walkable) ||
10714 (change->replace_when == CP_WHEN_DIGGABLE && is_diggable) ||
10715 (change->replace_when == CP_WHEN_COLLECTIBLE && is_collectible) ||
10716 (change->replace_when == CP_WHEN_REMOVABLE && is_removable) ||
10717 (change->replace_when == CP_WHEN_DESTRUCTIBLE && is_destructible)) &&
10718 !(IS_PLAYER(ex, ey) && ELEM_IS_PLAYER(content_element)));
10720 if (!can_replace[xx][yy])
10721 complete_replace = FALSE;
10724 if (!change->only_if_complete || complete_replace)
10726 boolean something_has_changed = FALSE;
10728 if (change->only_if_complete && change->use_random_replace &&
10729 RND(100) < change->random_percentage)
10732 for (yy = 0; yy < 3; yy++) for (xx = 0; xx < 3 ; xx++)
10734 int ex = x + xx - 1;
10735 int ey = y + yy - 1;
10736 int content_element;
10738 if (can_replace[xx][yy] && (!change->use_random_replace ||
10739 RND(100) < change->random_percentage))
10741 if (IS_MOVING(ex, ey) || IS_BLOCKED(ex, ey))
10742 RemoveMovingField(ex, ey);
10744 ChangeEvent[ex][ey] = ChangeEvent[x][y];
10746 content_element = change->target_content.e[xx][yy];
10747 target_element = GET_TARGET_ELEMENT(element, content_element, change,
10748 ce_value, ce_score);
10750 CreateElementFromChange(ex, ey, target_element);
10752 something_has_changed = TRUE;
10754 // for symmetry reasons, freeze newly created border elements
10755 if (ex != x || ey != y)
10756 Stop[ex][ey] = TRUE; // no more moving in this frame
10760 if (something_has_changed)
10762 PlayLevelSoundElementAction(x, y, element, ACTION_CHANGING);
10763 PlayLevelSoundElementAction(x, y, element, ACTION_PAGE_1 + page);
10769 target_element = GET_TARGET_ELEMENT(element, change->target_element, change,
10770 ce_value, ce_score);
10772 if (element == EL_DIAGONAL_GROWING ||
10773 element == EL_DIAGONAL_SHRINKING)
10775 target_element = Store[x][y];
10777 Store[x][y] = EL_EMPTY;
10780 CreateElementFromChange(x, y, target_element);
10782 PlayLevelSoundElementAction(x, y, element, ACTION_CHANGING);
10783 PlayLevelSoundElementAction(x, y, element, ACTION_PAGE_1 + page);
10786 // this uses direct change before indirect change
10787 CheckTriggeredElementChangeByPage(x, y, old_element, CE_CHANGE_OF_X, page);
10792 static void HandleElementChange(int x, int y, int page)
10794 int element = MovingOrBlocked2Element(x, y);
10795 struct ElementInfo *ei = &element_info[element];
10796 struct ElementChangeInfo *change = &ei->change_page[page];
10797 boolean handle_action_before_change = FALSE;
10800 if (!CAN_CHANGE_OR_HAS_ACTION(element) &&
10801 !CAN_CHANGE_OR_HAS_ACTION(Back[x][y]))
10803 Debug("game:playing:HandleElementChange", "%d,%d: element = %d ('%s')",
10804 x, y, element, element_info[element].token_name);
10805 Debug("game:playing:HandleElementChange", "This should never happen!");
10809 // this can happen with classic bombs on walkable, changing elements
10810 if (!CAN_CHANGE_OR_HAS_ACTION(element))
10815 if (ChangeDelay[x][y] == 0) // initialize element change
10817 ChangeDelay[x][y] = GET_CHANGE_DELAY(change) + 1;
10819 if (change->can_change)
10821 // !!! not clear why graphic animation should be reset at all here !!!
10822 // !!! UPDATE: but is needed for correct Snake Bite tail animation !!!
10823 // !!! SOLUTION: do not reset if graphics engine set to 4 or above !!!
10826 GRAPHICAL BUG ADDRESSED BY CHECKING GRAPHICS ENGINE VERSION:
10828 When using an animation frame delay of 1 (this only happens with
10829 "sp_zonk.moving.left/right" in the classic graphics), the default
10830 (non-moving) animation shows wrong animation frames (while the
10831 moving animation, like "sp_zonk.moving.left/right", is correct,
10832 so this graphical bug never shows up with the classic graphics).
10833 For an animation with 4 frames, this causes wrong frames 0,0,1,2
10834 be drawn instead of the correct frames 0,1,2,3. This is caused by
10835 "GfxFrame[][]" being reset *twice* (in two successive frames) after
10836 an element change: First when the change delay ("ChangeDelay[][]")
10837 counter has reached zero after decrementing, then a second time in
10838 the next frame (after "GfxFrame[][]" was already incremented) when
10839 "ChangeDelay[][]" is reset to the initial delay value again.
10841 This causes frame 0 to be drawn twice, while the last frame won't
10842 be drawn anymore, resulting in the wrong frame sequence 0,0,1,2.
10844 As some animations may already be cleverly designed around this bug
10845 (at least the "Snake Bite" snake tail animation does this), it cannot
10846 simply be fixed here without breaking such existing animations.
10847 Unfortunately, it cannot easily be detected if a graphics set was
10848 designed "before" or "after" the bug was fixed. As a workaround,
10849 a new graphics set option "game.graphics_engine_version" was added
10850 to be able to specify the game's major release version for which the
10851 graphics set was designed, which can then be used to decide if the
10852 bugfix should be used (version 4 and above) or not (version 3 or
10853 below, or if no version was specified at all, as with old sets).
10855 (The wrong/fixed animation frames can be tested with the test level set
10856 "test_gfxframe" and level "000", which contains a specially prepared
10857 custom element at level position (x/y) == (11/9) which uses the zonk
10858 animation mentioned above. Using "game.graphics_engine_version: 4"
10859 fixes the wrong animation frames, showing the correct frames 0,1,2,3.
10860 This can also be seen from the debug output for this test element.)
10863 // when a custom element is about to change (for example by change delay),
10864 // do not reset graphic animation when the custom element is moving
10865 if (game.graphics_engine_version < 4 &&
10868 ResetGfxAnimation(x, y);
10869 ResetRandomAnimationValue(x, y);
10872 if (change->pre_change_function)
10873 change->pre_change_function(x, y);
10877 ChangeDelay[x][y]--;
10879 if (ChangeDelay[x][y] != 0) // continue element change
10881 if (change->can_change)
10883 int graphic = el_act_dir2img(element, GfxAction[x][y], GfxDir[x][y]);
10885 if (IS_ANIMATED(graphic))
10886 DrawLevelGraphicAnimationIfNeeded(x, y, graphic);
10888 if (change->change_function)
10889 change->change_function(x, y);
10892 else // finish element change
10894 if (ChangePage[x][y] != -1) // remember page from delayed change
10896 page = ChangePage[x][y];
10897 ChangePage[x][y] = -1;
10899 change = &ei->change_page[page];
10902 if (IS_MOVING(x, y)) // never change a running system ;-)
10904 ChangeDelay[x][y] = 1; // try change after next move step
10905 ChangePage[x][y] = page; // remember page to use for change
10910 // special case: set new level random seed before changing element
10911 if (change->has_action && change->action_type == CA_SET_LEVEL_RANDOM_SEED)
10912 handle_action_before_change = TRUE;
10914 if (change->has_action && handle_action_before_change)
10915 ExecuteCustomElementAction(x, y, element, page);
10917 if (change->can_change)
10919 if (ChangeElement(x, y, element, page))
10921 if (change->post_change_function)
10922 change->post_change_function(x, y);
10926 if (change->has_action && !handle_action_before_change)
10927 ExecuteCustomElementAction(x, y, element, page);
10931 static boolean CheckTriggeredElementChangeExt(int trigger_x, int trigger_y,
10932 int trigger_element,
10934 int trigger_player,
10938 boolean change_done_any = FALSE;
10939 int trigger_page_bits = (trigger_page < 0 ? CH_PAGE_ANY : 1 << trigger_page);
10942 if (!(trigger_events[trigger_element][trigger_event]))
10945 RECURSION_LOOP_DETECTION_START(trigger_element, FALSE);
10947 for (i = 0; i < NUM_CUSTOM_ELEMENTS; i++)
10949 int element = EL_CUSTOM_START + i;
10950 boolean change_done = FALSE;
10953 if (!CAN_CHANGE_OR_HAS_ACTION(element) ||
10954 !HAS_ANY_CHANGE_EVENT(element, trigger_event))
10957 for (p = 0; p < element_info[element].num_change_pages; p++)
10959 struct ElementChangeInfo *change = &element_info[element].change_page[p];
10961 if (change->can_change_or_has_action &&
10962 change->has_event[trigger_event] &&
10963 change->trigger_side & trigger_side &&
10964 change->trigger_player & trigger_player &&
10965 change->trigger_page & trigger_page_bits &&
10966 IS_EQUAL_OR_IN_GROUP(trigger_element, change->trigger_element))
10968 change->actual_trigger_element = trigger_element;
10969 change->actual_trigger_player = GET_PLAYER_FROM_BITS(trigger_player);
10970 change->actual_trigger_player_bits = trigger_player;
10971 change->actual_trigger_side = trigger_side;
10972 change->actual_trigger_ce_value = CustomValue[trigger_x][trigger_y];
10973 change->actual_trigger_ce_score = GET_CE_SCORE(trigger_element);
10975 if ((change->can_change && !change_done) || change->has_action)
10979 SCAN_PLAYFIELD(x, y)
10981 if (Tile[x][y] == element)
10983 if (change->can_change && !change_done)
10985 // if element already changed in this frame, not only prevent
10986 // another element change (checked in ChangeElement()), but
10987 // also prevent additional element actions for this element
10989 if (ChangeCount[x][y] >= game.max_num_changes_per_frame &&
10990 !level.use_action_after_change_bug)
10993 ChangeDelay[x][y] = 1;
10994 ChangeEvent[x][y] = trigger_event;
10996 HandleElementChange(x, y, p);
10998 else if (change->has_action)
11000 // if element already changed in this frame, not only prevent
11001 // another element change (checked in ChangeElement()), but
11002 // also prevent additional element actions for this element
11004 if (ChangeCount[x][y] >= game.max_num_changes_per_frame &&
11005 !level.use_action_after_change_bug)
11008 ExecuteCustomElementAction(x, y, element, p);
11009 PlayLevelSoundElementAction(x, y, element, ACTION_PAGE_1 + p);
11014 if (change->can_change)
11016 change_done = TRUE;
11017 change_done_any = TRUE;
11024 RECURSION_LOOP_DETECTION_END();
11026 return change_done_any;
11029 static boolean CheckElementChangeExt(int x, int y,
11031 int trigger_element,
11033 int trigger_player,
11036 boolean change_done = FALSE;
11039 if (!CAN_CHANGE_OR_HAS_ACTION(element) ||
11040 !HAS_ANY_CHANGE_EVENT(element, trigger_event))
11043 if (Tile[x][y] == EL_BLOCKED)
11045 Blocked2Moving(x, y, &x, &y);
11046 element = Tile[x][y];
11049 // check if element has already changed or is about to change after moving
11050 if ((game.engine_version < VERSION_IDENT(3,2,0,7) &&
11051 Tile[x][y] != element) ||
11053 (game.engine_version >= VERSION_IDENT(3,2,0,7) &&
11054 (ChangeCount[x][y] >= game.max_num_changes_per_frame ||
11055 ChangePage[x][y] != -1)))
11058 RECURSION_LOOP_DETECTION_START(trigger_element, FALSE);
11060 for (p = 0; p < element_info[element].num_change_pages; p++)
11062 struct ElementChangeInfo *change = &element_info[element].change_page[p];
11064 /* check trigger element for all events where the element that is checked
11065 for changing interacts with a directly adjacent element -- this is
11066 different to element changes that affect other elements to change on the
11067 whole playfield (which is handeld by CheckTriggeredElementChangeExt()) */
11068 boolean check_trigger_element =
11069 (trigger_event == CE_TOUCHING_X ||
11070 trigger_event == CE_HITTING_X ||
11071 trigger_event == CE_HIT_BY_X ||
11072 trigger_event == CE_DIGGING_X); // this one was forgotten until 3.2.3
11074 if (change->can_change_or_has_action &&
11075 change->has_event[trigger_event] &&
11076 change->trigger_side & trigger_side &&
11077 change->trigger_player & trigger_player &&
11078 (!check_trigger_element ||
11079 IS_EQUAL_OR_IN_GROUP(trigger_element, change->trigger_element)))
11081 change->actual_trigger_element = trigger_element;
11082 change->actual_trigger_player = GET_PLAYER_FROM_BITS(trigger_player);
11083 change->actual_trigger_player_bits = trigger_player;
11084 change->actual_trigger_side = trigger_side;
11085 change->actual_trigger_ce_value = CustomValue[x][y];
11086 change->actual_trigger_ce_score = GET_CE_SCORE(trigger_element);
11088 // special case: trigger element not at (x,y) position for some events
11089 if (check_trigger_element)
11101 { 0, 0 }, { 0, 0 }, { 0, 0 },
11105 int xx = x + move_xy[MV_DIR_OPPOSITE(trigger_side)].dx;
11106 int yy = y + move_xy[MV_DIR_OPPOSITE(trigger_side)].dy;
11108 change->actual_trigger_ce_value = CustomValue[xx][yy];
11109 change->actual_trigger_ce_score = GET_CE_SCORE(trigger_element);
11112 if (change->can_change && !change_done)
11114 ChangeDelay[x][y] = 1;
11115 ChangeEvent[x][y] = trigger_event;
11117 HandleElementChange(x, y, p);
11119 change_done = TRUE;
11121 else if (change->has_action)
11123 ExecuteCustomElementAction(x, y, element, p);
11124 PlayLevelSoundElementAction(x, y, element, ACTION_PAGE_1 + p);
11129 RECURSION_LOOP_DETECTION_END();
11131 return change_done;
11134 static void PlayPlayerSound(struct PlayerInfo *player)
11136 int jx = player->jx, jy = player->jy;
11137 int sound_element = player->artwork_element;
11138 int last_action = player->last_action_waiting;
11139 int action = player->action_waiting;
11141 if (player->is_waiting)
11143 if (action != last_action)
11144 PlayLevelSoundElementAction(jx, jy, sound_element, action);
11146 PlayLevelSoundElementActionIfLoop(jx, jy, sound_element, action);
11150 if (action != last_action)
11151 StopSound(element_info[sound_element].sound[last_action]);
11153 if (last_action == ACTION_SLEEPING)
11154 PlayLevelSoundElementAction(jx, jy, sound_element, ACTION_AWAKENING);
11158 static void PlayAllPlayersSound(void)
11162 for (i = 0; i < MAX_PLAYERS; i++)
11163 if (stored_player[i].active)
11164 PlayPlayerSound(&stored_player[i]);
11167 static void SetPlayerWaiting(struct PlayerInfo *player, boolean is_waiting)
11169 boolean last_waiting = player->is_waiting;
11170 int move_dir = player->MovDir;
11172 player->dir_waiting = move_dir;
11173 player->last_action_waiting = player->action_waiting;
11177 if (!last_waiting) // not waiting -> waiting
11179 player->is_waiting = TRUE;
11181 player->frame_counter_bored =
11183 game.player_boring_delay_fixed +
11184 GetSimpleRandom(game.player_boring_delay_random);
11185 player->frame_counter_sleeping =
11187 game.player_sleeping_delay_fixed +
11188 GetSimpleRandom(game.player_sleeping_delay_random);
11190 InitPlayerGfxAnimation(player, ACTION_WAITING, move_dir);
11193 if (game.player_sleeping_delay_fixed +
11194 game.player_sleeping_delay_random > 0 &&
11195 player->anim_delay_counter == 0 &&
11196 player->post_delay_counter == 0 &&
11197 FrameCounter >= player->frame_counter_sleeping)
11198 player->is_sleeping = TRUE;
11199 else if (game.player_boring_delay_fixed +
11200 game.player_boring_delay_random > 0 &&
11201 FrameCounter >= player->frame_counter_bored)
11202 player->is_bored = TRUE;
11204 player->action_waiting = (player->is_sleeping ? ACTION_SLEEPING :
11205 player->is_bored ? ACTION_BORING :
11208 if (player->is_sleeping && player->use_murphy)
11210 // special case for sleeping Murphy when leaning against non-free tile
11212 if (!IN_LEV_FIELD(player->jx - 1, player->jy) ||
11213 (Tile[player->jx - 1][player->jy] != EL_EMPTY &&
11214 !IS_MOVING(player->jx - 1, player->jy)))
11215 move_dir = MV_LEFT;
11216 else if (!IN_LEV_FIELD(player->jx + 1, player->jy) ||
11217 (Tile[player->jx + 1][player->jy] != EL_EMPTY &&
11218 !IS_MOVING(player->jx + 1, player->jy)))
11219 move_dir = MV_RIGHT;
11221 player->is_sleeping = FALSE;
11223 player->dir_waiting = move_dir;
11226 if (player->is_sleeping)
11228 if (player->num_special_action_sleeping > 0)
11230 if (player->anim_delay_counter == 0 && player->post_delay_counter == 0)
11232 int last_special_action = player->special_action_sleeping;
11233 int num_special_action = player->num_special_action_sleeping;
11234 int special_action =
11235 (last_special_action == ACTION_DEFAULT ? ACTION_SLEEPING_1 :
11236 last_special_action == ACTION_SLEEPING ? ACTION_SLEEPING :
11237 last_special_action < ACTION_SLEEPING_1 + num_special_action - 1 ?
11238 last_special_action + 1 : ACTION_SLEEPING);
11239 int special_graphic =
11240 el_act_dir2img(player->artwork_element, special_action, move_dir);
11242 player->anim_delay_counter =
11243 graphic_info[special_graphic].anim_delay_fixed +
11244 GetSimpleRandom(graphic_info[special_graphic].anim_delay_random);
11245 player->post_delay_counter =
11246 graphic_info[special_graphic].post_delay_fixed +
11247 GetSimpleRandom(graphic_info[special_graphic].post_delay_random);
11249 player->special_action_sleeping = special_action;
11252 if (player->anim_delay_counter > 0)
11254 player->action_waiting = player->special_action_sleeping;
11255 player->anim_delay_counter--;
11257 else if (player->post_delay_counter > 0)
11259 player->post_delay_counter--;
11263 else if (player->is_bored)
11265 if (player->num_special_action_bored > 0)
11267 if (player->anim_delay_counter == 0 && player->post_delay_counter == 0)
11269 int special_action =
11270 ACTION_BORING_1 + GetSimpleRandom(player->num_special_action_bored);
11271 int special_graphic =
11272 el_act_dir2img(player->artwork_element, special_action, move_dir);
11274 player->anim_delay_counter =
11275 graphic_info[special_graphic].anim_delay_fixed +
11276 GetSimpleRandom(graphic_info[special_graphic].anim_delay_random);
11277 player->post_delay_counter =
11278 graphic_info[special_graphic].post_delay_fixed +
11279 GetSimpleRandom(graphic_info[special_graphic].post_delay_random);
11281 player->special_action_bored = special_action;
11284 if (player->anim_delay_counter > 0)
11286 player->action_waiting = player->special_action_bored;
11287 player->anim_delay_counter--;
11289 else if (player->post_delay_counter > 0)
11291 player->post_delay_counter--;
11296 else if (last_waiting) // waiting -> not waiting
11298 player->is_waiting = FALSE;
11299 player->is_bored = FALSE;
11300 player->is_sleeping = FALSE;
11302 player->frame_counter_bored = -1;
11303 player->frame_counter_sleeping = -1;
11305 player->anim_delay_counter = 0;
11306 player->post_delay_counter = 0;
11308 player->dir_waiting = player->MovDir;
11309 player->action_waiting = ACTION_DEFAULT;
11311 player->special_action_bored = ACTION_DEFAULT;
11312 player->special_action_sleeping = ACTION_DEFAULT;
11316 static void CheckSaveEngineSnapshot(struct PlayerInfo *player)
11318 if ((!player->is_moving && player->was_moving) ||
11319 (player->MovPos == 0 && player->was_moving) ||
11320 (player->is_snapping && !player->was_snapping) ||
11321 (player->is_dropping && !player->was_dropping))
11323 if (!CheckSaveEngineSnapshotToList())
11326 player->was_moving = FALSE;
11327 player->was_snapping = TRUE;
11328 player->was_dropping = TRUE;
11332 if (player->is_moving)
11333 player->was_moving = TRUE;
11335 if (!player->is_snapping)
11336 player->was_snapping = FALSE;
11338 if (!player->is_dropping)
11339 player->was_dropping = FALSE;
11342 static struct MouseActionInfo mouse_action_last = { 0 };
11343 struct MouseActionInfo mouse_action = player->effective_mouse_action;
11344 boolean new_released = (!mouse_action.button && mouse_action_last.button);
11347 CheckSaveEngineSnapshotToList();
11349 mouse_action_last = mouse_action;
11352 static void CheckSingleStepMode(struct PlayerInfo *player)
11354 if (tape.single_step && tape.recording && !tape.pausing)
11356 // as it is called "single step mode", just return to pause mode when the
11357 // player stopped moving after one tile (or never starts moving at all)
11358 // (reverse logic needed here in case single step mode used in team mode)
11359 if (player->is_moving ||
11360 player->is_pushing ||
11361 player->is_dropping_pressed ||
11362 player->effective_mouse_action.button)
11363 game.enter_single_step_mode = FALSE;
11366 CheckSaveEngineSnapshot(player);
11369 static byte PlayerActions(struct PlayerInfo *player, byte player_action)
11371 int left = player_action & JOY_LEFT;
11372 int right = player_action & JOY_RIGHT;
11373 int up = player_action & JOY_UP;
11374 int down = player_action & JOY_DOWN;
11375 int button1 = player_action & JOY_BUTTON_1;
11376 int button2 = player_action & JOY_BUTTON_2;
11377 int dx = (left ? -1 : right ? 1 : 0);
11378 int dy = (up ? -1 : down ? 1 : 0);
11380 if (!player->active || tape.pausing)
11386 SnapField(player, dx, dy);
11390 DropElement(player);
11392 MovePlayer(player, dx, dy);
11395 CheckSingleStepMode(player);
11397 SetPlayerWaiting(player, FALSE);
11399 return player_action;
11403 // no actions for this player (no input at player's configured device)
11405 DigField(player, 0, 0, 0, 0, 0, 0, DF_NO_PUSH);
11406 SnapField(player, 0, 0);
11407 CheckGravityMovementWhenNotMoving(player);
11409 if (player->MovPos == 0)
11410 SetPlayerWaiting(player, TRUE);
11412 if (player->MovPos == 0) // needed for tape.playing
11413 player->is_moving = FALSE;
11415 player->is_dropping = FALSE;
11416 player->is_dropping_pressed = FALSE;
11417 player->drop_pressed_delay = 0;
11419 CheckSingleStepMode(player);
11425 static void SetMouseActionFromTapeAction(struct MouseActionInfo *mouse_action,
11428 if (!tape.use_mouse_actions)
11431 mouse_action->lx = tape_action[TAPE_ACTION_LX];
11432 mouse_action->ly = tape_action[TAPE_ACTION_LY];
11433 mouse_action->button = tape_action[TAPE_ACTION_BUTTON];
11436 static void SetTapeActionFromMouseAction(byte *tape_action,
11437 struct MouseActionInfo *mouse_action)
11439 if (!tape.use_mouse_actions)
11442 tape_action[TAPE_ACTION_LX] = mouse_action->lx;
11443 tape_action[TAPE_ACTION_LY] = mouse_action->ly;
11444 tape_action[TAPE_ACTION_BUTTON] = mouse_action->button;
11447 static void CheckLevelSolved(void)
11449 if (level.game_engine_type == GAME_ENGINE_TYPE_EM)
11451 if (game_em.level_solved &&
11452 !game_em.game_over) // game won
11456 game_em.game_over = TRUE;
11458 game.all_players_gone = TRUE;
11461 if (game_em.game_over) // game lost
11462 game.all_players_gone = TRUE;
11464 else if (level.game_engine_type == GAME_ENGINE_TYPE_SP)
11466 if (game_sp.level_solved &&
11467 !game_sp.game_over) // game won
11471 game_sp.game_over = TRUE;
11473 game.all_players_gone = TRUE;
11476 if (game_sp.game_over) // game lost
11477 game.all_players_gone = TRUE;
11479 else if (level.game_engine_type == GAME_ENGINE_TYPE_MM)
11481 if (game_mm.level_solved &&
11482 !game_mm.game_over) // game won
11486 game_mm.game_over = TRUE;
11488 game.all_players_gone = TRUE;
11491 if (game_mm.game_over) // game lost
11492 game.all_players_gone = TRUE;
11496 static void CheckLevelTime(void)
11500 if (TimeFrames >= FRAMES_PER_SECOND)
11505 for (i = 0; i < MAX_PLAYERS; i++)
11507 struct PlayerInfo *player = &stored_player[i];
11509 if (SHIELD_ON(player))
11511 player->shield_normal_time_left--;
11513 if (player->shield_deadly_time_left > 0)
11514 player->shield_deadly_time_left--;
11518 if (!game.LevelSolved && !level.use_step_counter)
11526 if (TimeLeft <= 10 && setup.time_limit)
11527 PlaySound(SND_GAME_RUNNING_OUT_OF_TIME);
11529 /* this does not make sense: game_panel_controls[GAME_PANEL_TIME].value
11530 is reset from other values in UpdateGameDoorValues() -- FIX THIS */
11532 game_panel_controls[GAME_PANEL_TIME].value = TimeLeft;
11534 if (!TimeLeft && setup.time_limit)
11536 if (level.game_engine_type == GAME_ENGINE_TYPE_EM)
11537 game_em.lev->killed_out_of_time = TRUE;
11539 for (i = 0; i < MAX_PLAYERS; i++)
11540 KillPlayer(&stored_player[i]);
11543 else if (game.no_time_limit && !game.all_players_gone)
11545 game_panel_controls[GAME_PANEL_TIME].value = TimePlayed;
11548 game_em.lev->time = (game.no_time_limit ? TimePlayed : TimeLeft);
11551 if (tape.recording || tape.playing)
11552 DrawVideoDisplay(VIDEO_STATE_TIME_ON, TapeTime);
11555 if (tape.recording || tape.playing)
11556 DrawVideoDisplay(VIDEO_STATE_FRAME_ON, FrameCounter);
11558 UpdateAndDisplayGameControlValues();
11561 void AdvanceFrameAndPlayerCounters(int player_nr)
11565 // advance frame counters (global frame counter and time frame counter)
11569 // advance player counters (counters for move delay, move animation etc.)
11570 for (i = 0; i < MAX_PLAYERS; i++)
11572 boolean advance_player_counters = (player_nr == -1 || player_nr == i);
11573 int move_delay_value = stored_player[i].move_delay_value;
11574 int move_frames = MOVE_DELAY_NORMAL_SPEED / move_delay_value;
11576 if (!advance_player_counters) // not all players may be affected
11579 if (move_frames == 0) // less than one move per game frame
11581 int stepsize = TILEX / move_delay_value;
11582 int delay = move_delay_value / MOVE_DELAY_NORMAL_SPEED;
11583 int count = (stored_player[i].is_moving ?
11584 ABS(stored_player[i].MovPos) / stepsize : FrameCounter);
11586 if (count % delay == 0)
11590 stored_player[i].Frame += move_frames;
11592 if (stored_player[i].MovPos != 0)
11593 stored_player[i].StepFrame += move_frames;
11595 if (stored_player[i].move_delay > 0)
11596 stored_player[i].move_delay--;
11598 // due to bugs in previous versions, counter must count up, not down
11599 if (stored_player[i].push_delay != -1)
11600 stored_player[i].push_delay++;
11602 if (stored_player[i].drop_delay > 0)
11603 stored_player[i].drop_delay--;
11605 if (stored_player[i].is_dropping_pressed)
11606 stored_player[i].drop_pressed_delay++;
11610 void StartGameActions(boolean init_network_game, boolean record_tape,
11613 unsigned int new_random_seed = InitRND(random_seed);
11616 TapeStartRecording(new_random_seed);
11618 if (init_network_game)
11620 SendToServer_LevelFile();
11621 SendToServer_StartPlaying();
11629 static void GameActionsExt(void)
11632 static unsigned int game_frame_delay = 0;
11634 unsigned int game_frame_delay_value;
11635 byte *recorded_player_action;
11636 byte summarized_player_action = 0;
11637 byte tape_action[MAX_TAPE_ACTIONS] = { 0 };
11640 // detect endless loops, caused by custom element programming
11641 if (recursion_loop_detected && recursion_loop_depth == 0)
11643 char *message = getStringCat3("Internal Error! Element ",
11644 EL_NAME(recursion_loop_element),
11645 " caused endless loop! Quit the game?");
11647 Warn("element '%s' caused endless loop in game engine",
11648 EL_NAME(recursion_loop_element));
11650 RequestQuitGameExt(FALSE, level_editor_test_game, message);
11652 recursion_loop_detected = FALSE; // if game should be continued
11659 if (game.restart_level)
11660 StartGameActions(network.enabled, setup.autorecord, level.random_seed);
11662 CheckLevelSolved();
11664 if (game.LevelSolved && !game.LevelSolved_GameEnd)
11667 if (game.all_players_gone && !TAPE_IS_STOPPED(tape))
11670 if (game_status != GAME_MODE_PLAYING) // status might have changed
11673 game_frame_delay_value =
11674 (tape.playing && tape.fast_forward ? FfwdFrameDelay : GameFrameDelay);
11676 if (tape.playing && tape.warp_forward && !tape.pausing)
11677 game_frame_delay_value = 0;
11679 SetVideoFrameDelay(game_frame_delay_value);
11681 // (de)activate virtual buttons depending on current game status
11682 if (strEqual(setup.touch.control_type, TOUCH_CONTROL_VIRTUAL_BUTTONS))
11684 if (game.all_players_gone) // if no players there to be controlled anymore
11685 SetOverlayActive(FALSE);
11686 else if (!tape.playing) // if game continues after tape stopped playing
11687 SetOverlayActive(TRUE);
11692 // ---------- main game synchronization point ----------
11694 int skip = WaitUntilDelayReached(&game_frame_delay, game_frame_delay_value);
11696 Debug("game:playing:skip", "skip == %d", skip);
11699 // ---------- main game synchronization point ----------
11701 WaitUntilDelayReached(&game_frame_delay, game_frame_delay_value);
11705 if (network_playing && !network_player_action_received)
11707 // try to get network player actions in time
11709 // last chance to get network player actions without main loop delay
11710 HandleNetworking();
11712 // game was quit by network peer
11713 if (game_status != GAME_MODE_PLAYING)
11716 // check if network player actions still missing and game still running
11717 if (!network_player_action_received && !checkGameEnded())
11718 return; // failed to get network player actions in time
11720 // do not yet reset "network_player_action_received" (for tape.pausing)
11726 // at this point we know that we really continue executing the game
11728 network_player_action_received = FALSE;
11730 // when playing tape, read previously recorded player input from tape data
11731 recorded_player_action = (tape.playing ? TapePlayAction() : NULL);
11733 local_player->effective_mouse_action = local_player->mouse_action;
11735 if (recorded_player_action != NULL)
11736 SetMouseActionFromTapeAction(&local_player->effective_mouse_action,
11737 recorded_player_action);
11739 // TapePlayAction() may return NULL when toggling to "pause before death"
11743 if (tape.set_centered_player)
11745 game.centered_player_nr_next = tape.centered_player_nr_next;
11746 game.set_centered_player = TRUE;
11749 for (i = 0; i < MAX_PLAYERS; i++)
11751 summarized_player_action |= stored_player[i].action;
11753 if (!network_playing && (game.team_mode || tape.playing))
11754 stored_player[i].effective_action = stored_player[i].action;
11757 if (network_playing && !checkGameEnded())
11758 SendToServer_MovePlayer(summarized_player_action);
11760 // summarize all actions at local players mapped input device position
11761 // (this allows using different input devices in single player mode)
11762 if (!network.enabled && !game.team_mode)
11763 stored_player[map_player_action[local_player->index_nr]].effective_action =
11764 summarized_player_action;
11766 // summarize all actions at centered player in local team mode
11767 if (tape.recording &&
11768 setup.team_mode && !network.enabled &&
11769 setup.input_on_focus &&
11770 game.centered_player_nr != -1)
11772 for (i = 0; i < MAX_PLAYERS; i++)
11773 stored_player[map_player_action[i]].effective_action =
11774 (i == game.centered_player_nr ? summarized_player_action : 0);
11777 if (recorded_player_action != NULL)
11778 for (i = 0; i < MAX_PLAYERS; i++)
11779 stored_player[i].effective_action = recorded_player_action[i];
11781 for (i = 0; i < MAX_PLAYERS; i++)
11783 tape_action[i] = stored_player[i].effective_action;
11785 /* (this may happen in the RND game engine if a player was not present on
11786 the playfield on level start, but appeared later from a custom element */
11787 if (setup.team_mode &&
11790 !tape.player_participates[i])
11791 tape.player_participates[i] = TRUE;
11794 SetTapeActionFromMouseAction(tape_action,
11795 &local_player->effective_mouse_action);
11797 // only record actions from input devices, but not programmed actions
11798 if (tape.recording)
11799 TapeRecordAction(tape_action);
11801 // remember if game was played (especially after tape stopped playing)
11802 if (!tape.playing && summarized_player_action)
11803 game.GamePlayed = TRUE;
11805 #if USE_NEW_PLAYER_ASSIGNMENTS
11806 // !!! also map player actions in single player mode !!!
11807 // if (game.team_mode)
11810 byte mapped_action[MAX_PLAYERS];
11812 #if DEBUG_PLAYER_ACTIONS
11813 for (i = 0; i < MAX_PLAYERS; i++)
11814 DebugContinued("", "%d, ", stored_player[i].effective_action);
11817 for (i = 0; i < MAX_PLAYERS; i++)
11818 mapped_action[i] = stored_player[map_player_action[i]].effective_action;
11820 for (i = 0; i < MAX_PLAYERS; i++)
11821 stored_player[i].effective_action = mapped_action[i];
11823 #if DEBUG_PLAYER_ACTIONS
11824 DebugContinued("", "=> ");
11825 for (i = 0; i < MAX_PLAYERS; i++)
11826 DebugContinued("", "%d, ", stored_player[i].effective_action);
11827 DebugContinued("game:playing:player", "\n");
11830 #if DEBUG_PLAYER_ACTIONS
11833 for (i = 0; i < MAX_PLAYERS; i++)
11834 DebugContinued("", "%d, ", stored_player[i].effective_action);
11835 DebugContinued("game:playing:player", "\n");
11840 for (i = 0; i < MAX_PLAYERS; i++)
11842 // allow engine snapshot in case of changed movement attempt
11843 if ((game.snapshot.last_action[i] & KEY_MOTION) !=
11844 (stored_player[i].effective_action & KEY_MOTION))
11845 game.snapshot.changed_action = TRUE;
11847 // allow engine snapshot in case of snapping/dropping attempt
11848 if ((game.snapshot.last_action[i] & KEY_BUTTON) == 0 &&
11849 (stored_player[i].effective_action & KEY_BUTTON) != 0)
11850 game.snapshot.changed_action = TRUE;
11852 game.snapshot.last_action[i] = stored_player[i].effective_action;
11855 if (level.game_engine_type == GAME_ENGINE_TYPE_EM)
11857 GameActions_EM_Main();
11859 else if (level.game_engine_type == GAME_ENGINE_TYPE_SP)
11861 GameActions_SP_Main();
11863 else if (level.game_engine_type == GAME_ENGINE_TYPE_MM)
11865 GameActions_MM_Main();
11869 GameActions_RND_Main();
11872 BlitScreenToBitmap(backbuffer);
11874 CheckLevelSolved();
11877 AdvanceFrameAndPlayerCounters(-1); // advance counters for all players
11879 if (global.show_frames_per_second)
11881 static unsigned int fps_counter = 0;
11882 static int fps_frames = 0;
11883 unsigned int fps_delay_ms = Counter() - fps_counter;
11887 if (fps_delay_ms >= 500) // calculate FPS every 0.5 seconds
11889 global.frames_per_second = 1000 * (float)fps_frames / fps_delay_ms;
11892 fps_counter = Counter();
11894 // always draw FPS to screen after FPS value was updated
11895 redraw_mask |= REDRAW_FPS;
11898 // only draw FPS if no screen areas are deactivated (invisible warp mode)
11899 if (GetDrawDeactivationMask() == REDRAW_NONE)
11900 redraw_mask |= REDRAW_FPS;
11904 static void GameActions_CheckSaveEngineSnapshot(void)
11906 if (!game.snapshot.save_snapshot)
11909 // clear flag for saving snapshot _before_ saving snapshot
11910 game.snapshot.save_snapshot = FALSE;
11912 SaveEngineSnapshotToList();
11915 void GameActions(void)
11919 GameActions_CheckSaveEngineSnapshot();
11922 void GameActions_EM_Main(void)
11924 byte effective_action[MAX_PLAYERS];
11925 boolean warp_mode = (tape.playing && tape.warp_forward && !tape.pausing);
11928 for (i = 0; i < MAX_PLAYERS; i++)
11929 effective_action[i] = stored_player[i].effective_action;
11931 GameActions_EM(effective_action, warp_mode);
11934 void GameActions_SP_Main(void)
11936 byte effective_action[MAX_PLAYERS];
11937 boolean warp_mode = (tape.playing && tape.warp_forward && !tape.pausing);
11940 for (i = 0; i < MAX_PLAYERS; i++)
11941 effective_action[i] = stored_player[i].effective_action;
11943 GameActions_SP(effective_action, warp_mode);
11945 for (i = 0; i < MAX_PLAYERS; i++)
11947 if (stored_player[i].force_dropping)
11948 stored_player[i].action |= KEY_BUTTON_DROP;
11950 stored_player[i].force_dropping = FALSE;
11954 void GameActions_MM_Main(void)
11956 boolean warp_mode = (tape.playing && tape.warp_forward && !tape.pausing);
11958 GameActions_MM(local_player->effective_mouse_action, warp_mode);
11961 void GameActions_RND_Main(void)
11966 void GameActions_RND(void)
11968 static struct MouseActionInfo mouse_action_last = { 0 };
11969 struct MouseActionInfo mouse_action = local_player->effective_mouse_action;
11970 int magic_wall_x = 0, magic_wall_y = 0;
11971 int i, x, y, element, graphic, last_gfx_frame;
11973 InitPlayfieldScanModeVars();
11975 if (game.engine_version >= VERSION_IDENT(3,2,0,7))
11977 SCAN_PLAYFIELD(x, y)
11979 ChangeCount[x][y] = 0;
11980 ChangeEvent[x][y] = -1;
11984 if (game.set_centered_player)
11986 boolean all_players_fit_to_screen = checkIfAllPlayersFitToScreen_RND();
11988 // switching to "all players" only possible if all players fit to screen
11989 if (game.centered_player_nr_next == -1 && !all_players_fit_to_screen)
11991 game.centered_player_nr_next = game.centered_player_nr;
11992 game.set_centered_player = FALSE;
11995 // do not switch focus to non-existing (or non-active) player
11996 if (game.centered_player_nr_next >= 0 &&
11997 !stored_player[game.centered_player_nr_next].active)
11999 game.centered_player_nr_next = game.centered_player_nr;
12000 game.set_centered_player = FALSE;
12004 if (game.set_centered_player &&
12005 ScreenMovPos == 0) // screen currently aligned at tile position
12009 if (game.centered_player_nr_next == -1)
12011 setScreenCenteredToAllPlayers(&sx, &sy);
12015 sx = stored_player[game.centered_player_nr_next].jx;
12016 sy = stored_player[game.centered_player_nr_next].jy;
12019 game.centered_player_nr = game.centered_player_nr_next;
12020 game.set_centered_player = FALSE;
12022 DrawRelocateScreen(0, 0, sx, sy, MV_NONE, TRUE, setup.quick_switch);
12023 DrawGameDoorValues();
12026 // check single step mode (set flag and clear again if any player is active)
12027 game.enter_single_step_mode =
12028 (tape.single_step && tape.recording && !tape.pausing);
12030 for (i = 0; i < MAX_PLAYERS; i++)
12032 int actual_player_action = stored_player[i].effective_action;
12035 /* !!! THIS BREAKS THE FOLLOWING TAPES: !!!
12036 - rnd_equinox_tetrachloride 048
12037 - rnd_equinox_tetrachloride_ii 096
12038 - rnd_emanuel_schmieg 002
12039 - doctor_sloan_ww 001, 020
12041 if (stored_player[i].MovPos == 0)
12042 CheckGravityMovement(&stored_player[i]);
12045 // overwrite programmed action with tape action
12046 if (stored_player[i].programmed_action)
12047 actual_player_action = stored_player[i].programmed_action;
12049 PlayerActions(&stored_player[i], actual_player_action);
12051 ScrollPlayer(&stored_player[i], SCROLL_GO_ON);
12054 // single step pause mode may already have been toggled by "ScrollPlayer()"
12055 if (game.enter_single_step_mode && !tape.pausing)
12056 TapeTogglePause(TAPE_TOGGLE_AUTOMATIC);
12058 ScrollScreen(NULL, SCROLL_GO_ON);
12060 /* for backwards compatibility, the following code emulates a fixed bug that
12061 occured when pushing elements (causing elements that just made their last
12062 pushing step to already (if possible) make their first falling step in the
12063 same game frame, which is bad); this code is also needed to use the famous
12064 "spring push bug" which is used in older levels and might be wanted to be
12065 used also in newer levels, but in this case the buggy pushing code is only
12066 affecting the "spring" element and no other elements */
12068 if (game.engine_version < VERSION_IDENT(2,2,0,7) || level.use_spring_bug)
12070 for (i = 0; i < MAX_PLAYERS; i++)
12072 struct PlayerInfo *player = &stored_player[i];
12073 int x = player->jx;
12074 int y = player->jy;
12076 if (player->active && player->is_pushing && player->is_moving &&
12078 (game.engine_version < VERSION_IDENT(2,2,0,7) ||
12079 Tile[x][y] == EL_SPRING))
12081 ContinueMoving(x, y);
12083 // continue moving after pushing (this is actually a bug)
12084 if (!IS_MOVING(x, y))
12085 Stop[x][y] = FALSE;
12090 SCAN_PLAYFIELD(x, y)
12092 Last[x][y] = Tile[x][y];
12094 ChangeCount[x][y] = 0;
12095 ChangeEvent[x][y] = -1;
12097 // this must be handled before main playfield loop
12098 if (Tile[x][y] == EL_PLAYER_IS_LEAVING)
12101 if (MovDelay[x][y] <= 0)
12105 if (Tile[x][y] == EL_ELEMENT_SNAPPING)
12108 if (MovDelay[x][y] <= 0)
12110 int element = Store[x][y];
12111 int move_direction = MovDir[x][y];
12112 int player_index_bit = Store2[x][y];
12118 TEST_DrawLevelField(x, y);
12120 TestFieldAfterSnapping(x, y, element, move_direction, player_index_bit);
12125 if (ChangePage[x][y] != -1 && ChangeDelay[x][y] != 1)
12127 Debug("game:playing:GameActions_RND", "x = %d, y = %d: ChangePage != -1",
12129 Debug("game:playing:GameActions_RND", "This should never happen!");
12131 ChangePage[x][y] = -1;
12135 Stop[x][y] = FALSE;
12136 if (WasJustMoving[x][y] > 0)
12137 WasJustMoving[x][y]--;
12138 if (WasJustFalling[x][y] > 0)
12139 WasJustFalling[x][y]--;
12140 if (CheckCollision[x][y] > 0)
12141 CheckCollision[x][y]--;
12142 if (CheckImpact[x][y] > 0)
12143 CheckImpact[x][y]--;
12147 /* reset finished pushing action (not done in ContinueMoving() to allow
12148 continuous pushing animation for elements with zero push delay) */
12149 if (GfxAction[x][y] == ACTION_PUSHING && !IS_MOVING(x, y))
12151 ResetGfxAnimation(x, y);
12152 TEST_DrawLevelField(x, y);
12156 if (IS_BLOCKED(x, y))
12160 Blocked2Moving(x, y, &oldx, &oldy);
12161 if (!IS_MOVING(oldx, oldy))
12163 Debug("game:playing:GameActions_RND", "(BLOCKED => MOVING) context corrupted!");
12164 Debug("game:playing:GameActions_RND", "BLOCKED: x = %d, y = %d", x, y);
12165 Debug("game:playing:GameActions_RND", "!MOVING: oldx = %d, oldy = %d", oldx, oldy);
12166 Debug("game:playing:GameActions_RND", "This should never happen!");
12172 if (mouse_action.button)
12174 int new_button = (mouse_action.button && mouse_action_last.button == 0);
12175 int ch_button = CH_SIDE_FROM_BUTTON(mouse_action.button);
12177 x = mouse_action.lx;
12178 y = mouse_action.ly;
12179 element = Tile[x][y];
12183 CheckElementChangeByMouse(x, y, element, CE_CLICKED_BY_MOUSE, ch_button);
12184 CheckTriggeredElementChangeByMouse(x, y, element, CE_MOUSE_CLICKED_ON_X,
12188 CheckElementChangeByMouse(x, y, element, CE_PRESSED_BY_MOUSE, ch_button);
12189 CheckTriggeredElementChangeByMouse(x, y, element, CE_MOUSE_PRESSED_ON_X,
12193 SCAN_PLAYFIELD(x, y)
12195 element = Tile[x][y];
12196 graphic = el_act_dir2img(element, GfxAction[x][y], GfxDir[x][y]);
12197 last_gfx_frame = GfxFrame[x][y];
12199 ResetGfxFrame(x, y);
12201 if (GfxFrame[x][y] != last_gfx_frame && !Stop[x][y])
12202 DrawLevelGraphicAnimation(x, y, graphic);
12204 if (ANIM_MODE(graphic) == ANIM_RANDOM &&
12205 IS_NEXT_FRAME(GfxFrame[x][y], graphic))
12206 ResetRandomAnimationValue(x, y);
12208 SetRandomAnimationValue(x, y);
12210 PlayLevelSoundActionIfLoop(x, y, GfxAction[x][y]);
12212 if (IS_INACTIVE(element))
12214 if (IS_ANIMATED(graphic))
12215 DrawLevelGraphicAnimationIfNeeded(x, y, graphic);
12220 // this may take place after moving, so 'element' may have changed
12221 if (IS_CHANGING(x, y) &&
12222 (game.engine_version < VERSION_IDENT(3,0,7,1) || !Stop[x][y]))
12224 int page = element_info[element].event_page_nr[CE_DELAY];
12226 HandleElementChange(x, y, page);
12228 element = Tile[x][y];
12229 graphic = el_act_dir2img(element, GfxAction[x][y], GfxDir[x][y]);
12232 if (!IS_MOVING(x, y) && (CAN_FALL(element) || CAN_MOVE(element)))
12236 element = Tile[x][y];
12237 graphic = el_act_dir2img(element, GfxAction[x][y], GfxDir[x][y]);
12239 if (IS_ANIMATED(graphic) &&
12240 !IS_MOVING(x, y) &&
12242 DrawLevelGraphicAnimationIfNeeded(x, y, graphic);
12244 if (IS_GEM(element) || element == EL_SP_INFOTRON)
12245 TEST_DrawTwinkleOnField(x, y);
12247 else if (element == EL_ACID)
12250 DrawLevelGraphicAnimationIfNeeded(x, y, graphic);
12252 else if ((element == EL_EXIT_OPEN ||
12253 element == EL_EM_EXIT_OPEN ||
12254 element == EL_SP_EXIT_OPEN ||
12255 element == EL_STEEL_EXIT_OPEN ||
12256 element == EL_EM_STEEL_EXIT_OPEN ||
12257 element == EL_SP_TERMINAL ||
12258 element == EL_SP_TERMINAL_ACTIVE ||
12259 element == EL_EXTRA_TIME ||
12260 element == EL_SHIELD_NORMAL ||
12261 element == EL_SHIELD_DEADLY) &&
12262 IS_ANIMATED(graphic))
12263 DrawLevelGraphicAnimationIfNeeded(x, y, graphic);
12264 else if (IS_MOVING(x, y))
12265 ContinueMoving(x, y);
12266 else if (IS_ACTIVE_BOMB(element))
12267 CheckDynamite(x, y);
12268 else if (element == EL_AMOEBA_GROWING)
12269 AmoebaGrowing(x, y);
12270 else if (element == EL_AMOEBA_SHRINKING)
12271 AmoebaShrinking(x, y);
12273 #if !USE_NEW_AMOEBA_CODE
12274 else if (IS_AMOEBALIVE(element))
12275 AmoebaReproduce(x, y);
12278 else if (element == EL_GAME_OF_LIFE || element == EL_BIOMAZE)
12280 else if (element == EL_EXIT_CLOSED)
12282 else if (element == EL_EM_EXIT_CLOSED)
12284 else if (element == EL_STEEL_EXIT_CLOSED)
12285 CheckExitSteel(x, y);
12286 else if (element == EL_EM_STEEL_EXIT_CLOSED)
12287 CheckExitSteelEM(x, y);
12288 else if (element == EL_SP_EXIT_CLOSED)
12290 else if (element == EL_EXPANDABLE_WALL_GROWING ||
12291 element == EL_EXPANDABLE_STEELWALL_GROWING)
12292 MauerWaechst(x, y);
12293 else if (element == EL_EXPANDABLE_WALL ||
12294 element == EL_EXPANDABLE_WALL_HORIZONTAL ||
12295 element == EL_EXPANDABLE_WALL_VERTICAL ||
12296 element == EL_EXPANDABLE_WALL_ANY ||
12297 element == EL_BD_EXPANDABLE_WALL)
12298 MauerAbleger(x, y);
12299 else if (element == EL_EXPANDABLE_STEELWALL_HORIZONTAL ||
12300 element == EL_EXPANDABLE_STEELWALL_VERTICAL ||
12301 element == EL_EXPANDABLE_STEELWALL_ANY)
12302 MauerAblegerStahl(x, y);
12303 else if (element == EL_FLAMES)
12304 CheckForDragon(x, y);
12305 else if (element == EL_EXPLOSION)
12306 ; // drawing of correct explosion animation is handled separately
12307 else if (element == EL_ELEMENT_SNAPPING ||
12308 element == EL_DIAGONAL_SHRINKING ||
12309 element == EL_DIAGONAL_GROWING)
12311 graphic = el_act_dir2img(GfxElement[x][y], GfxAction[x][y],GfxDir[x][y]);
12313 DrawLevelGraphicAnimationIfNeeded(x, y, graphic);
12315 else if (IS_ANIMATED(graphic) && !IS_CHANGING(x, y))
12316 DrawLevelGraphicAnimationIfNeeded(x, y, graphic);
12318 if (IS_BELT_ACTIVE(element))
12319 PlayLevelSoundAction(x, y, ACTION_ACTIVE);
12321 if (game.magic_wall_active)
12323 int jx = local_player->jx, jy = local_player->jy;
12325 // play the element sound at the position nearest to the player
12326 if ((element == EL_MAGIC_WALL_FULL ||
12327 element == EL_MAGIC_WALL_ACTIVE ||
12328 element == EL_MAGIC_WALL_EMPTYING ||
12329 element == EL_BD_MAGIC_WALL_FULL ||
12330 element == EL_BD_MAGIC_WALL_ACTIVE ||
12331 element == EL_BD_MAGIC_WALL_EMPTYING ||
12332 element == EL_DC_MAGIC_WALL_FULL ||
12333 element == EL_DC_MAGIC_WALL_ACTIVE ||
12334 element == EL_DC_MAGIC_WALL_EMPTYING) &&
12335 ABS(x - jx) + ABS(y - jy) <
12336 ABS(magic_wall_x - jx) + ABS(magic_wall_y - jy))
12344 #if USE_NEW_AMOEBA_CODE
12345 // new experimental amoeba growth stuff
12346 if (!(FrameCounter % 8))
12348 static unsigned int random = 1684108901;
12350 for (i = 0; i < level.amoeba_speed * 28 / 8; i++)
12352 x = RND(lev_fieldx);
12353 y = RND(lev_fieldy);
12354 element = Tile[x][y];
12356 if (!IS_PLAYER(x,y) &&
12357 (element == EL_EMPTY ||
12358 CAN_GROW_INTO(element) ||
12359 element == EL_QUICKSAND_EMPTY ||
12360 element == EL_QUICKSAND_FAST_EMPTY ||
12361 element == EL_ACID_SPLASH_LEFT ||
12362 element == EL_ACID_SPLASH_RIGHT))
12364 if ((IN_LEV_FIELD(x, y-1) && Tile[x][y-1] == EL_AMOEBA_WET) ||
12365 (IN_LEV_FIELD(x-1, y) && Tile[x-1][y] == EL_AMOEBA_WET) ||
12366 (IN_LEV_FIELD(x+1, y) && Tile[x+1][y] == EL_AMOEBA_WET) ||
12367 (IN_LEV_FIELD(x, y+1) && Tile[x][y+1] == EL_AMOEBA_WET))
12368 Tile[x][y] = EL_AMOEBA_DROP;
12371 random = random * 129 + 1;
12376 game.explosions_delayed = FALSE;
12378 SCAN_PLAYFIELD(x, y)
12380 element = Tile[x][y];
12382 if (ExplodeField[x][y])
12383 Explode(x, y, EX_PHASE_START, ExplodeField[x][y]);
12384 else if (element == EL_EXPLOSION)
12385 Explode(x, y, ExplodePhase[x][y], EX_TYPE_NORMAL);
12387 ExplodeField[x][y] = EX_TYPE_NONE;
12390 game.explosions_delayed = TRUE;
12392 if (game.magic_wall_active)
12394 if (!(game.magic_wall_time_left % 4))
12396 int element = Tile[magic_wall_x][magic_wall_y];
12398 if (element == EL_BD_MAGIC_WALL_FULL ||
12399 element == EL_BD_MAGIC_WALL_ACTIVE ||
12400 element == EL_BD_MAGIC_WALL_EMPTYING)
12401 PlayLevelSound(magic_wall_x, magic_wall_y, SND_BD_MAGIC_WALL_ACTIVE);
12402 else if (element == EL_DC_MAGIC_WALL_FULL ||
12403 element == EL_DC_MAGIC_WALL_ACTIVE ||
12404 element == EL_DC_MAGIC_WALL_EMPTYING)
12405 PlayLevelSound(magic_wall_x, magic_wall_y, SND_DC_MAGIC_WALL_ACTIVE);
12407 PlayLevelSound(magic_wall_x, magic_wall_y, SND_MAGIC_WALL_ACTIVE);
12410 if (game.magic_wall_time_left > 0)
12412 game.magic_wall_time_left--;
12414 if (!game.magic_wall_time_left)
12416 SCAN_PLAYFIELD(x, y)
12418 element = Tile[x][y];
12420 if (element == EL_MAGIC_WALL_ACTIVE ||
12421 element == EL_MAGIC_WALL_FULL)
12423 Tile[x][y] = EL_MAGIC_WALL_DEAD;
12424 TEST_DrawLevelField(x, y);
12426 else if (element == EL_BD_MAGIC_WALL_ACTIVE ||
12427 element == EL_BD_MAGIC_WALL_FULL)
12429 Tile[x][y] = EL_BD_MAGIC_WALL_DEAD;
12430 TEST_DrawLevelField(x, y);
12432 else if (element == EL_DC_MAGIC_WALL_ACTIVE ||
12433 element == EL_DC_MAGIC_WALL_FULL)
12435 Tile[x][y] = EL_DC_MAGIC_WALL_DEAD;
12436 TEST_DrawLevelField(x, y);
12440 game.magic_wall_active = FALSE;
12445 if (game.light_time_left > 0)
12447 game.light_time_left--;
12449 if (game.light_time_left == 0)
12450 RedrawAllLightSwitchesAndInvisibleElements();
12453 if (game.timegate_time_left > 0)
12455 game.timegate_time_left--;
12457 if (game.timegate_time_left == 0)
12458 CloseAllOpenTimegates();
12461 if (game.lenses_time_left > 0)
12463 game.lenses_time_left--;
12465 if (game.lenses_time_left == 0)
12466 RedrawAllInvisibleElementsForLenses();
12469 if (game.magnify_time_left > 0)
12471 game.magnify_time_left--;
12473 if (game.magnify_time_left == 0)
12474 RedrawAllInvisibleElementsForMagnifier();
12477 for (i = 0; i < MAX_PLAYERS; i++)
12479 struct PlayerInfo *player = &stored_player[i];
12481 if (SHIELD_ON(player))
12483 if (player->shield_deadly_time_left)
12484 PlayLevelSound(player->jx, player->jy, SND_SHIELD_DEADLY_ACTIVE);
12485 else if (player->shield_normal_time_left)
12486 PlayLevelSound(player->jx, player->jy, SND_SHIELD_NORMAL_ACTIVE);
12490 #if USE_DELAYED_GFX_REDRAW
12491 SCAN_PLAYFIELD(x, y)
12493 if (GfxRedraw[x][y] != GFX_REDRAW_NONE)
12495 /* !!! PROBLEM: THIS REDRAWS THE PLAYFIELD _AFTER_ THE SCAN, BUT TILES
12496 !!! MAY HAVE CHANGED AFTER BEING DRAWN DURING PLAYFIELD SCAN !!! */
12498 if (GfxRedraw[x][y] & GFX_REDRAW_TILE)
12499 DrawLevelField(x, y);
12501 if (GfxRedraw[x][y] & GFX_REDRAW_TILE_CRUMBLED)
12502 DrawLevelFieldCrumbled(x, y);
12504 if (GfxRedraw[x][y] & GFX_REDRAW_TILE_CRUMBLED_NEIGHBOURS)
12505 DrawLevelFieldCrumbledNeighbours(x, y);
12507 if (GfxRedraw[x][y] & GFX_REDRAW_TILE_TWINKLED)
12508 DrawTwinkleOnField(x, y);
12511 GfxRedraw[x][y] = GFX_REDRAW_NONE;
12516 PlayAllPlayersSound();
12518 for (i = 0; i < MAX_PLAYERS; i++)
12520 struct PlayerInfo *player = &stored_player[i];
12522 if (player->show_envelope != 0 && (!player->active ||
12523 player->MovPos == 0))
12525 ShowEnvelope(player->show_envelope - EL_ENVELOPE_1);
12527 player->show_envelope = 0;
12531 // use random number generator in every frame to make it less predictable
12532 if (game.engine_version >= VERSION_IDENT(3,1,1,0))
12535 mouse_action_last = mouse_action;
12538 static boolean AllPlayersInSight(struct PlayerInfo *player, int x, int y)
12540 int min_x = x, min_y = y, max_x = x, max_y = y;
12541 int scr_fieldx = getScreenFieldSizeX();
12542 int scr_fieldy = getScreenFieldSizeY();
12545 for (i = 0; i < MAX_PLAYERS; i++)
12547 int jx = stored_player[i].jx, jy = stored_player[i].jy;
12549 if (!stored_player[i].active || &stored_player[i] == player)
12552 min_x = MIN(min_x, jx);
12553 min_y = MIN(min_y, jy);
12554 max_x = MAX(max_x, jx);
12555 max_y = MAX(max_y, jy);
12558 return (max_x - min_x < scr_fieldx && max_y - min_y < scr_fieldy);
12561 static boolean AllPlayersInVisibleScreen(void)
12565 for (i = 0; i < MAX_PLAYERS; i++)
12567 int jx = stored_player[i].jx, jy = stored_player[i].jy;
12569 if (!stored_player[i].active)
12572 if (!IN_VIS_FIELD(SCREENX(jx), SCREENY(jy)))
12579 void ScrollLevel(int dx, int dy)
12581 int scroll_offset = 2 * TILEX_VAR;
12584 BlitBitmap(drawto_field, drawto_field,
12585 FX + TILEX_VAR * (dx == -1) - scroll_offset,
12586 FY + TILEY_VAR * (dy == -1) - scroll_offset,
12587 SXSIZE - TILEX_VAR * (dx != 0) + 2 * scroll_offset,
12588 SYSIZE - TILEY_VAR * (dy != 0) + 2 * scroll_offset,
12589 FX + TILEX_VAR * (dx == 1) - scroll_offset,
12590 FY + TILEY_VAR * (dy == 1) - scroll_offset);
12594 x = (dx == 1 ? BX1 : BX2);
12595 for (y = BY1; y <= BY2; y++)
12596 DrawScreenField(x, y);
12601 y = (dy == 1 ? BY1 : BY2);
12602 for (x = BX1; x <= BX2; x++)
12603 DrawScreenField(x, y);
12606 redraw_mask |= REDRAW_FIELD;
12609 static boolean canFallDown(struct PlayerInfo *player)
12611 int jx = player->jx, jy = player->jy;
12613 return (IN_LEV_FIELD(jx, jy + 1) &&
12614 (IS_FREE(jx, jy + 1) ||
12615 (Tile[jx][jy + 1] == EL_ACID && player->can_fall_into_acid)) &&
12616 IS_WALKABLE_FROM(Tile[jx][jy], MV_DOWN) &&
12617 !IS_WALKABLE_INSIDE(Tile[jx][jy]));
12620 static boolean canPassField(int x, int y, int move_dir)
12622 int opposite_dir = MV_DIR_OPPOSITE(move_dir);
12623 int dx = (move_dir & MV_LEFT ? -1 : move_dir & MV_RIGHT ? +1 : 0);
12624 int dy = (move_dir & MV_UP ? -1 : move_dir & MV_DOWN ? +1 : 0);
12625 int nextx = x + dx;
12626 int nexty = y + dy;
12627 int element = Tile[x][y];
12629 return (IS_PASSABLE_FROM(element, opposite_dir) &&
12630 !CAN_MOVE(element) &&
12631 IN_LEV_FIELD(nextx, nexty) && !IS_PLAYER(nextx, nexty) &&
12632 IS_WALKABLE_FROM(Tile[nextx][nexty], move_dir) &&
12633 (level.can_pass_to_walkable || IS_FREE(nextx, nexty)));
12636 static boolean canMoveToValidFieldWithGravity(int x, int y, int move_dir)
12638 int opposite_dir = MV_DIR_OPPOSITE(move_dir);
12639 int dx = (move_dir & MV_LEFT ? -1 : move_dir & MV_RIGHT ? +1 : 0);
12640 int dy = (move_dir & MV_UP ? -1 : move_dir & MV_DOWN ? +1 : 0);
12644 return (IN_LEV_FIELD(newx, newy) && !IS_FREE_OR_PLAYER(newx, newy) &&
12645 IS_GRAVITY_REACHABLE(Tile[newx][newy]) &&
12646 (IS_DIGGABLE(Tile[newx][newy]) ||
12647 IS_WALKABLE_FROM(Tile[newx][newy], opposite_dir) ||
12648 canPassField(newx, newy, move_dir)));
12651 static void CheckGravityMovement(struct PlayerInfo *player)
12653 if (player->gravity && !player->programmed_action)
12655 int move_dir_horizontal = player->effective_action & MV_HORIZONTAL;
12656 int move_dir_vertical = player->effective_action & MV_VERTICAL;
12657 boolean player_is_snapping = (player->effective_action & JOY_BUTTON_1);
12658 int jx = player->jx, jy = player->jy;
12659 boolean player_is_moving_to_valid_field =
12660 (!player_is_snapping &&
12661 (canMoveToValidFieldWithGravity(jx, jy, move_dir_horizontal) ||
12662 canMoveToValidFieldWithGravity(jx, jy, move_dir_vertical)));
12663 boolean player_can_fall_down = canFallDown(player);
12665 if (player_can_fall_down &&
12666 !player_is_moving_to_valid_field)
12667 player->programmed_action = MV_DOWN;
12671 static void CheckGravityMovementWhenNotMoving(struct PlayerInfo *player)
12673 return CheckGravityMovement(player);
12675 if (player->gravity && !player->programmed_action)
12677 int jx = player->jx, jy = player->jy;
12678 boolean field_under_player_is_free =
12679 (IN_LEV_FIELD(jx, jy + 1) && IS_FREE(jx, jy + 1));
12680 boolean player_is_standing_on_valid_field =
12681 (IS_WALKABLE_INSIDE(Tile[jx][jy]) ||
12682 (IS_WALKABLE(Tile[jx][jy]) &&
12683 !(element_info[Tile[jx][jy]].access_direction & MV_DOWN)));
12685 if (field_under_player_is_free && !player_is_standing_on_valid_field)
12686 player->programmed_action = MV_DOWN;
12691 MovePlayerOneStep()
12692 -----------------------------------------------------------------------------
12693 dx, dy: direction (non-diagonal) to try to move the player to
12694 real_dx, real_dy: direction as read from input device (can be diagonal)
12697 boolean MovePlayerOneStep(struct PlayerInfo *player,
12698 int dx, int dy, int real_dx, int real_dy)
12700 int jx = player->jx, jy = player->jy;
12701 int new_jx = jx + dx, new_jy = jy + dy;
12703 boolean player_can_move = !player->cannot_move;
12705 if (!player->active || (!dx && !dy))
12706 return MP_NO_ACTION;
12708 player->MovDir = (dx < 0 ? MV_LEFT :
12709 dx > 0 ? MV_RIGHT :
12711 dy > 0 ? MV_DOWN : MV_NONE);
12713 if (!IN_LEV_FIELD(new_jx, new_jy))
12714 return MP_NO_ACTION;
12716 if (!player_can_move)
12718 if (player->MovPos == 0)
12720 player->is_moving = FALSE;
12721 player->is_digging = FALSE;
12722 player->is_collecting = FALSE;
12723 player->is_snapping = FALSE;
12724 player->is_pushing = FALSE;
12728 if (!network.enabled && game.centered_player_nr == -1 &&
12729 !AllPlayersInSight(player, new_jx, new_jy))
12730 return MP_NO_ACTION;
12732 can_move = DigField(player, jx, jy, new_jx, new_jy, real_dx,real_dy, DF_DIG);
12733 if (can_move != MP_MOVING)
12736 // check if DigField() has caused relocation of the player
12737 if (player->jx != jx || player->jy != jy)
12738 return MP_NO_ACTION; // <-- !!! CHECK THIS [-> MP_ACTION ?] !!!
12740 StorePlayer[jx][jy] = 0;
12741 player->last_jx = jx;
12742 player->last_jy = jy;
12743 player->jx = new_jx;
12744 player->jy = new_jy;
12745 StorePlayer[new_jx][new_jy] = player->element_nr;
12747 if (player->move_delay_value_next != -1)
12749 player->move_delay_value = player->move_delay_value_next;
12750 player->move_delay_value_next = -1;
12754 (dx > 0 || dy > 0 ? -1 : 1) * (TILEX - TILEX / player->move_delay_value);
12756 player->step_counter++;
12758 PlayerVisit[jx][jy] = FrameCounter;
12760 player->is_moving = TRUE;
12763 // should better be called in MovePlayer(), but this breaks some tapes
12764 ScrollPlayer(player, SCROLL_INIT);
12770 boolean MovePlayer(struct PlayerInfo *player, int dx, int dy)
12772 int jx = player->jx, jy = player->jy;
12773 int old_jx = jx, old_jy = jy;
12774 int moved = MP_NO_ACTION;
12776 if (!player->active)
12781 if (player->MovPos == 0)
12783 player->is_moving = FALSE;
12784 player->is_digging = FALSE;
12785 player->is_collecting = FALSE;
12786 player->is_snapping = FALSE;
12787 player->is_pushing = FALSE;
12793 if (player->move_delay > 0)
12796 player->move_delay = -1; // set to "uninitialized" value
12798 // store if player is automatically moved to next field
12799 player->is_auto_moving = (player->programmed_action != MV_NONE);
12801 // remove the last programmed player action
12802 player->programmed_action = 0;
12804 if (player->MovPos)
12806 // should only happen if pre-1.2 tape recordings are played
12807 // this is only for backward compatibility
12809 int original_move_delay_value = player->move_delay_value;
12812 Debug("game:playing:MovePlayer",
12813 "THIS SHOULD ONLY HAPPEN WITH PRE-1.2 LEVEL TAPES. [%d]",
12817 // scroll remaining steps with finest movement resolution
12818 player->move_delay_value = MOVE_DELAY_NORMAL_SPEED;
12820 while (player->MovPos)
12822 ScrollPlayer(player, SCROLL_GO_ON);
12823 ScrollScreen(NULL, SCROLL_GO_ON);
12825 AdvanceFrameAndPlayerCounters(player->index_nr);
12828 BackToFront_WithFrameDelay(0);
12831 player->move_delay_value = original_move_delay_value;
12834 player->is_active = FALSE;
12836 if (player->last_move_dir & MV_HORIZONTAL)
12838 if (!(moved |= MovePlayerOneStep(player, 0, dy, dx, dy)))
12839 moved |= MovePlayerOneStep(player, dx, 0, dx, dy);
12843 if (!(moved |= MovePlayerOneStep(player, dx, 0, dx, dy)))
12844 moved |= MovePlayerOneStep(player, 0, dy, dx, dy);
12847 if (!moved && !player->is_active)
12849 player->is_moving = FALSE;
12850 player->is_digging = FALSE;
12851 player->is_collecting = FALSE;
12852 player->is_snapping = FALSE;
12853 player->is_pushing = FALSE;
12859 if (moved & MP_MOVING && !ScreenMovPos &&
12860 (player->index_nr == game.centered_player_nr ||
12861 game.centered_player_nr == -1))
12863 int old_scroll_x = scroll_x, old_scroll_y = scroll_y;
12865 if (!IN_VIS_FIELD(SCREENX(jx), SCREENY(jy)))
12867 // actual player has left the screen -- scroll in that direction
12868 if (jx != old_jx) // player has moved horizontally
12869 scroll_x += (jx - old_jx);
12870 else // player has moved vertically
12871 scroll_y += (jy - old_jy);
12875 int offset_raw = game.scroll_delay_value;
12877 if (jx != old_jx) // player has moved horizontally
12879 int offset = MIN(offset_raw, (SCR_FIELDX - 2) / 2);
12880 int offset_x = offset * (player->MovDir == MV_LEFT ? +1 : -1);
12881 int new_scroll_x = jx - MIDPOSX + offset_x;
12883 if ((player->MovDir == MV_LEFT && scroll_x > new_scroll_x) ||
12884 (player->MovDir == MV_RIGHT && scroll_x < new_scroll_x))
12885 scroll_x = new_scroll_x;
12887 // don't scroll over playfield boundaries
12888 scroll_x = MIN(MAX(SBX_Left, scroll_x), SBX_Right);
12890 // don't scroll more than one field at a time
12891 scroll_x = old_scroll_x + SIGN(scroll_x - old_scroll_x);
12893 // don't scroll against the player's moving direction
12894 if ((player->MovDir == MV_LEFT && scroll_x > old_scroll_x) ||
12895 (player->MovDir == MV_RIGHT && scroll_x < old_scroll_x))
12896 scroll_x = old_scroll_x;
12898 else // player has moved vertically
12900 int offset = MIN(offset_raw, (SCR_FIELDY - 2) / 2);
12901 int offset_y = offset * (player->MovDir == MV_UP ? +1 : -1);
12902 int new_scroll_y = jy - MIDPOSY + offset_y;
12904 if ((player->MovDir == MV_UP && scroll_y > new_scroll_y) ||
12905 (player->MovDir == MV_DOWN && scroll_y < new_scroll_y))
12906 scroll_y = new_scroll_y;
12908 // don't scroll over playfield boundaries
12909 scroll_y = MIN(MAX(SBY_Upper, scroll_y), SBY_Lower);
12911 // don't scroll more than one field at a time
12912 scroll_y = old_scroll_y + SIGN(scroll_y - old_scroll_y);
12914 // don't scroll against the player's moving direction
12915 if ((player->MovDir == MV_UP && scroll_y > old_scroll_y) ||
12916 (player->MovDir == MV_DOWN && scroll_y < old_scroll_y))
12917 scroll_y = old_scroll_y;
12921 if (scroll_x != old_scroll_x || scroll_y != old_scroll_y)
12923 if (!network.enabled && game.centered_player_nr == -1 &&
12924 !AllPlayersInVisibleScreen())
12926 scroll_x = old_scroll_x;
12927 scroll_y = old_scroll_y;
12931 ScrollScreen(player, SCROLL_INIT);
12932 ScrollLevel(old_scroll_x - scroll_x, old_scroll_y - scroll_y);
12937 player->StepFrame = 0;
12939 if (moved & MP_MOVING)
12941 if (old_jx != jx && old_jy == jy)
12942 player->MovDir = (old_jx < jx ? MV_RIGHT : MV_LEFT);
12943 else if (old_jx == jx && old_jy != jy)
12944 player->MovDir = (old_jy < jy ? MV_DOWN : MV_UP);
12946 TEST_DrawLevelField(jx, jy); // for "crumbled sand"
12948 player->last_move_dir = player->MovDir;
12949 player->is_moving = TRUE;
12950 player->is_snapping = FALSE;
12951 player->is_switching = FALSE;
12952 player->is_dropping = FALSE;
12953 player->is_dropping_pressed = FALSE;
12954 player->drop_pressed_delay = 0;
12957 // should better be called here than above, but this breaks some tapes
12958 ScrollPlayer(player, SCROLL_INIT);
12963 CheckGravityMovementWhenNotMoving(player);
12965 player->is_moving = FALSE;
12967 /* at this point, the player is allowed to move, but cannot move right now
12968 (e.g. because of something blocking the way) -- ensure that the player
12969 is also allowed to move in the next frame (in old versions before 3.1.1,
12970 the player was forced to wait again for eight frames before next try) */
12972 if (game.engine_version >= VERSION_IDENT(3,1,1,0))
12973 player->move_delay = 0; // allow direct movement in the next frame
12976 if (player->move_delay == -1) // not yet initialized by DigField()
12977 player->move_delay = player->move_delay_value;
12979 if (game.engine_version < VERSION_IDENT(3,0,7,0))
12981 TestIfPlayerTouchesBadThing(jx, jy);
12982 TestIfPlayerTouchesCustomElement(jx, jy);
12985 if (!player->active)
12986 RemovePlayer(player);
12991 void ScrollPlayer(struct PlayerInfo *player, int mode)
12993 int jx = player->jx, jy = player->jy;
12994 int last_jx = player->last_jx, last_jy = player->last_jy;
12995 int move_stepsize = TILEX / player->move_delay_value;
12997 if (!player->active)
13000 if (player->MovPos == 0 && mode == SCROLL_GO_ON) // player not moving
13003 if (mode == SCROLL_INIT)
13005 player->actual_frame_counter = FrameCounter;
13006 player->GfxPos = move_stepsize * (player->MovPos / move_stepsize);
13008 if ((player->block_last_field || player->block_delay_adjustment > 0) &&
13009 Tile[last_jx][last_jy] == EL_EMPTY)
13011 int last_field_block_delay = 0; // start with no blocking at all
13012 int block_delay_adjustment = player->block_delay_adjustment;
13014 // if player blocks last field, add delay for exactly one move
13015 if (player->block_last_field)
13017 last_field_block_delay += player->move_delay_value;
13019 // when blocking enabled, prevent moving up despite gravity
13020 if (player->gravity && player->MovDir == MV_UP)
13021 block_delay_adjustment = -1;
13024 // add block delay adjustment (also possible when not blocking)
13025 last_field_block_delay += block_delay_adjustment;
13027 Tile[last_jx][last_jy] = EL_PLAYER_IS_LEAVING;
13028 MovDelay[last_jx][last_jy] = last_field_block_delay + 1;
13031 if (player->MovPos != 0) // player has not yet reached destination
13034 else if (!FrameReached(&player->actual_frame_counter, 1))
13037 if (player->MovPos != 0)
13039 player->MovPos += (player->MovPos > 0 ? -1 : 1) * move_stepsize;
13040 player->GfxPos = move_stepsize * (player->MovPos / move_stepsize);
13042 // before DrawPlayer() to draw correct player graphic for this case
13043 if (player->MovPos == 0)
13044 CheckGravityMovement(player);
13047 if (player->MovPos == 0) // player reached destination field
13049 if (player->move_delay_reset_counter > 0)
13051 player->move_delay_reset_counter--;
13053 if (player->move_delay_reset_counter == 0)
13055 // continue with normal speed after quickly moving through gate
13056 HALVE_PLAYER_SPEED(player);
13058 // be able to make the next move without delay
13059 player->move_delay = 0;
13063 player->last_jx = jx;
13064 player->last_jy = jy;
13066 if (Tile[jx][jy] == EL_EXIT_OPEN ||
13067 Tile[jx][jy] == EL_EM_EXIT_OPEN ||
13068 Tile[jx][jy] == EL_EM_EXIT_OPENING ||
13069 Tile[jx][jy] == EL_STEEL_EXIT_OPEN ||
13070 Tile[jx][jy] == EL_EM_STEEL_EXIT_OPEN ||
13071 Tile[jx][jy] == EL_EM_STEEL_EXIT_OPENING ||
13072 Tile[jx][jy] == EL_SP_EXIT_OPEN ||
13073 Tile[jx][jy] == EL_SP_EXIT_OPENING) // <-- special case
13075 ExitPlayer(player);
13077 if (game.players_still_needed == 0 &&
13078 (game.friends_still_needed == 0 ||
13079 IS_SP_ELEMENT(Tile[jx][jy])))
13083 // this breaks one level: "machine", level 000
13085 int move_direction = player->MovDir;
13086 int enter_side = MV_DIR_OPPOSITE(move_direction);
13087 int leave_side = move_direction;
13088 int old_jx = last_jx;
13089 int old_jy = last_jy;
13090 int old_element = Tile[old_jx][old_jy];
13091 int new_element = Tile[jx][jy];
13093 if (IS_CUSTOM_ELEMENT(old_element))
13094 CheckElementChangeByPlayer(old_jx, old_jy, old_element,
13096 player->index_bit, leave_side);
13098 CheckTriggeredElementChangeByPlayer(old_jx, old_jy, old_element,
13099 CE_PLAYER_LEAVES_X,
13100 player->index_bit, leave_side);
13102 if (IS_CUSTOM_ELEMENT(new_element))
13103 CheckElementChangeByPlayer(jx, jy, new_element, CE_ENTERED_BY_PLAYER,
13104 player->index_bit, enter_side);
13106 CheckTriggeredElementChangeByPlayer(jx, jy, new_element,
13107 CE_PLAYER_ENTERS_X,
13108 player->index_bit, enter_side);
13110 CheckTriggeredElementChangeBySide(jx, jy, player->initial_element,
13111 CE_MOVE_OF_X, move_direction);
13114 if (game.engine_version >= VERSION_IDENT(3,0,7,0))
13116 TestIfPlayerTouchesBadThing(jx, jy);
13117 TestIfPlayerTouchesCustomElement(jx, jy);
13119 /* needed because pushed element has not yet reached its destination,
13120 so it would trigger a change event at its previous field location */
13121 if (!player->is_pushing)
13122 TestIfElementTouchesCustomElement(jx, jy); // for empty space
13124 if (level.finish_dig_collect &&
13125 (player->is_digging || player->is_collecting))
13127 int last_element = player->last_removed_element;
13128 int move_direction = player->MovDir;
13129 int enter_side = MV_DIR_OPPOSITE(move_direction);
13130 int change_event = (player->is_digging ? CE_PLAYER_DIGS_X :
13131 CE_PLAYER_COLLECTS_X);
13133 CheckTriggeredElementChangeByPlayer(jx, jy, last_element, change_event,
13134 player->index_bit, enter_side);
13136 player->last_removed_element = EL_UNDEFINED;
13139 if (!player->active)
13140 RemovePlayer(player);
13143 if (level.use_step_counter)
13153 if (TimeLeft <= 10 && setup.time_limit && !game.LevelSolved)
13154 PlaySound(SND_GAME_RUNNING_OUT_OF_TIME);
13156 game_panel_controls[GAME_PANEL_TIME].value = TimeLeft;
13158 DisplayGameControlValues();
13160 if (!TimeLeft && setup.time_limit && !game.LevelSolved)
13161 for (i = 0; i < MAX_PLAYERS; i++)
13162 KillPlayer(&stored_player[i]);
13164 else if (game.no_time_limit && !game.all_players_gone)
13166 game_panel_controls[GAME_PANEL_TIME].value = TimePlayed;
13168 DisplayGameControlValues();
13172 if (tape.single_step && tape.recording && !tape.pausing &&
13173 !player->programmed_action)
13174 TapeTogglePause(TAPE_TOGGLE_AUTOMATIC);
13176 if (!player->programmed_action)
13177 CheckSaveEngineSnapshot(player);
13181 void ScrollScreen(struct PlayerInfo *player, int mode)
13183 static unsigned int screen_frame_counter = 0;
13185 if (mode == SCROLL_INIT)
13187 // set scrolling step size according to actual player's moving speed
13188 ScrollStepSize = TILEX / player->move_delay_value;
13190 screen_frame_counter = FrameCounter;
13191 ScreenMovDir = player->MovDir;
13192 ScreenMovPos = player->MovPos;
13193 ScreenGfxPos = ScrollStepSize * (ScreenMovPos / ScrollStepSize);
13196 else if (!FrameReached(&screen_frame_counter, 1))
13201 ScreenMovPos += (ScreenMovPos > 0 ? -1 : 1) * ScrollStepSize;
13202 ScreenGfxPos = ScrollStepSize * (ScreenMovPos / ScrollStepSize);
13203 redraw_mask |= REDRAW_FIELD;
13206 ScreenMovDir = MV_NONE;
13209 void TestIfPlayerTouchesCustomElement(int x, int y)
13211 static int xy[4][2] =
13218 static int trigger_sides[4][2] =
13220 // center side border side
13221 { CH_SIDE_TOP, CH_SIDE_BOTTOM }, // check top
13222 { CH_SIDE_LEFT, CH_SIDE_RIGHT }, // check left
13223 { CH_SIDE_RIGHT, CH_SIDE_LEFT }, // check right
13224 { CH_SIDE_BOTTOM, CH_SIDE_TOP } // check bottom
13226 static int touch_dir[4] =
13228 MV_LEFT | MV_RIGHT,
13233 int center_element = Tile[x][y]; // should always be non-moving!
13236 for (i = 0; i < NUM_DIRECTIONS; i++)
13238 int xx = x + xy[i][0];
13239 int yy = y + xy[i][1];
13240 int center_side = trigger_sides[i][0];
13241 int border_side = trigger_sides[i][1];
13242 int border_element;
13244 if (!IN_LEV_FIELD(xx, yy))
13247 if (IS_PLAYER(x, y)) // player found at center element
13249 struct PlayerInfo *player = PLAYERINFO(x, y);
13251 if (game.engine_version < VERSION_IDENT(3,0,7,0))
13252 border_element = Tile[xx][yy]; // may be moving!
13253 else if (!IS_MOVING(xx, yy) && !IS_BLOCKED(xx, yy))
13254 border_element = Tile[xx][yy];
13255 else if (MovDir[xx][yy] & touch_dir[i]) // elements are touching
13256 border_element = MovingOrBlocked2Element(xx, yy);
13258 continue; // center and border element do not touch
13260 CheckElementChangeByPlayer(xx, yy, border_element, CE_TOUCHED_BY_PLAYER,
13261 player->index_bit, border_side);
13262 CheckTriggeredElementChangeByPlayer(xx, yy, border_element,
13263 CE_PLAYER_TOUCHES_X,
13264 player->index_bit, border_side);
13267 /* use player element that is initially defined in the level playfield,
13268 not the player element that corresponds to the runtime player number
13269 (example: a level that contains EL_PLAYER_3 as the only player would
13270 incorrectly give EL_PLAYER_1 for "player->element_nr") */
13271 int player_element = PLAYERINFO(x, y)->initial_element;
13273 CheckElementChangeBySide(xx, yy, border_element, player_element,
13274 CE_TOUCHING_X, border_side);
13277 else if (IS_PLAYER(xx, yy)) // player found at border element
13279 struct PlayerInfo *player = PLAYERINFO(xx, yy);
13281 if (game.engine_version >= VERSION_IDENT(3,0,7,0))
13283 if (player->MovPos != 0 && !(player->MovDir & touch_dir[i]))
13284 continue; // center and border element do not touch
13287 CheckElementChangeByPlayer(x, y, center_element, CE_TOUCHED_BY_PLAYER,
13288 player->index_bit, center_side);
13289 CheckTriggeredElementChangeByPlayer(x, y, center_element,
13290 CE_PLAYER_TOUCHES_X,
13291 player->index_bit, center_side);
13294 /* use player element that is initially defined in the level playfield,
13295 not the player element that corresponds to the runtime player number
13296 (example: a level that contains EL_PLAYER_3 as the only player would
13297 incorrectly give EL_PLAYER_1 for "player->element_nr") */
13298 int player_element = PLAYERINFO(xx, yy)->initial_element;
13300 CheckElementChangeBySide(x, y, center_element, player_element,
13301 CE_TOUCHING_X, center_side);
13309 void TestIfElementTouchesCustomElement(int x, int y)
13311 static int xy[4][2] =
13318 static int trigger_sides[4][2] =
13320 // center side border side
13321 { CH_SIDE_TOP, CH_SIDE_BOTTOM }, // check top
13322 { CH_SIDE_LEFT, CH_SIDE_RIGHT }, // check left
13323 { CH_SIDE_RIGHT, CH_SIDE_LEFT }, // check right
13324 { CH_SIDE_BOTTOM, CH_SIDE_TOP } // check bottom
13326 static int touch_dir[4] =
13328 MV_LEFT | MV_RIGHT,
13333 boolean change_center_element = FALSE;
13334 int center_element = Tile[x][y]; // should always be non-moving!
13335 int border_element_old[NUM_DIRECTIONS];
13338 for (i = 0; i < NUM_DIRECTIONS; i++)
13340 int xx = x + xy[i][0];
13341 int yy = y + xy[i][1];
13342 int border_element;
13344 border_element_old[i] = -1;
13346 if (!IN_LEV_FIELD(xx, yy))
13349 if (game.engine_version < VERSION_IDENT(3,0,7,0))
13350 border_element = Tile[xx][yy]; // may be moving!
13351 else if (!IS_MOVING(xx, yy) && !IS_BLOCKED(xx, yy))
13352 border_element = Tile[xx][yy];
13353 else if (MovDir[xx][yy] & touch_dir[i]) // elements are touching
13354 border_element = MovingOrBlocked2Element(xx, yy);
13356 continue; // center and border element do not touch
13358 border_element_old[i] = border_element;
13361 for (i = 0; i < NUM_DIRECTIONS; i++)
13363 int xx = x + xy[i][0];
13364 int yy = y + xy[i][1];
13365 int center_side = trigger_sides[i][0];
13366 int border_element = border_element_old[i];
13368 if (border_element == -1)
13371 // check for change of border element
13372 CheckElementChangeBySide(xx, yy, border_element, center_element,
13373 CE_TOUCHING_X, center_side);
13375 // (center element cannot be player, so we dont have to check this here)
13378 for (i = 0; i < NUM_DIRECTIONS; i++)
13380 int xx = x + xy[i][0];
13381 int yy = y + xy[i][1];
13382 int border_side = trigger_sides[i][1];
13383 int border_element = border_element_old[i];
13385 if (border_element == -1)
13388 // check for change of center element (but change it only once)
13389 if (!change_center_element)
13390 change_center_element =
13391 CheckElementChangeBySide(x, y, center_element, border_element,
13392 CE_TOUCHING_X, border_side);
13394 if (IS_PLAYER(xx, yy))
13396 /* use player element that is initially defined in the level playfield,
13397 not the player element that corresponds to the runtime player number
13398 (example: a level that contains EL_PLAYER_3 as the only player would
13399 incorrectly give EL_PLAYER_1 for "player->element_nr") */
13400 int player_element = PLAYERINFO(xx, yy)->initial_element;
13402 CheckElementChangeBySide(x, y, center_element, player_element,
13403 CE_TOUCHING_X, border_side);
13408 void TestIfElementHitsCustomElement(int x, int y, int direction)
13410 int dx = (direction == MV_LEFT ? -1 : direction == MV_RIGHT ? +1 : 0);
13411 int dy = (direction == MV_UP ? -1 : direction == MV_DOWN ? +1 : 0);
13412 int hitx = x + dx, hity = y + dy;
13413 int hitting_element = Tile[x][y];
13414 int touched_element;
13416 if (IN_LEV_FIELD(hitx, hity) && IS_FREE(hitx, hity))
13419 touched_element = (IN_LEV_FIELD(hitx, hity) ?
13420 MovingOrBlocked2Element(hitx, hity) : EL_STEELWALL);
13422 if (IN_LEV_FIELD(hitx, hity))
13424 int opposite_direction = MV_DIR_OPPOSITE(direction);
13425 int hitting_side = direction;
13426 int touched_side = opposite_direction;
13427 boolean object_hit = (!IS_MOVING(hitx, hity) ||
13428 MovDir[hitx][hity] != direction ||
13429 ABS(MovPos[hitx][hity]) <= TILEY / 2);
13435 CheckElementChangeBySide(x, y, hitting_element, touched_element,
13436 CE_HITTING_X, touched_side);
13438 CheckElementChangeBySide(hitx, hity, touched_element, hitting_element,
13439 CE_HIT_BY_X, hitting_side);
13441 CheckElementChangeBySide(hitx, hity, touched_element, hitting_element,
13442 CE_HIT_BY_SOMETHING, opposite_direction);
13444 if (IS_PLAYER(hitx, hity))
13446 /* use player element that is initially defined in the level playfield,
13447 not the player element that corresponds to the runtime player number
13448 (example: a level that contains EL_PLAYER_3 as the only player would
13449 incorrectly give EL_PLAYER_1 for "player->element_nr") */
13450 int player_element = PLAYERINFO(hitx, hity)->initial_element;
13452 CheckElementChangeBySide(x, y, hitting_element, player_element,
13453 CE_HITTING_X, touched_side);
13458 // "hitting something" is also true when hitting the playfield border
13459 CheckElementChangeBySide(x, y, hitting_element, touched_element,
13460 CE_HITTING_SOMETHING, direction);
13463 void TestIfGoodThingHitsBadThing(int good_x, int good_y, int good_move_dir)
13465 int i, kill_x = -1, kill_y = -1;
13467 int bad_element = -1;
13468 static int test_xy[4][2] =
13475 static int test_dir[4] =
13483 for (i = 0; i < NUM_DIRECTIONS; i++)
13485 int test_x, test_y, test_move_dir, test_element;
13487 test_x = good_x + test_xy[i][0];
13488 test_y = good_y + test_xy[i][1];
13490 if (!IN_LEV_FIELD(test_x, test_y))
13494 (IS_MOVING(test_x, test_y) ? MovDir[test_x][test_y] : MV_NONE);
13496 test_element = MovingOrBlocked2ElementIfNotLeaving(test_x, test_y);
13498 /* 1st case: good thing is moving towards DONT_RUN_INTO style bad thing;
13499 2nd case: DONT_TOUCH style bad thing does not move away from good thing
13501 if ((DONT_RUN_INTO(test_element) && good_move_dir == test_dir[i]) ||
13502 (DONT_TOUCH(test_element) && test_move_dir != test_dir[i]))
13506 bad_element = test_element;
13512 if (kill_x != -1 || kill_y != -1)
13514 if (IS_PLAYER(good_x, good_y))
13516 struct PlayerInfo *player = PLAYERINFO(good_x, good_y);
13518 if (player->shield_deadly_time_left > 0 &&
13519 !IS_INDESTRUCTIBLE(bad_element))
13520 Bang(kill_x, kill_y);
13521 else if (!PLAYER_ENEMY_PROTECTED(good_x, good_y))
13522 KillPlayer(player);
13525 Bang(good_x, good_y);
13529 void TestIfBadThingHitsGoodThing(int bad_x, int bad_y, int bad_move_dir)
13531 int i, kill_x = -1, kill_y = -1;
13532 int bad_element = Tile[bad_x][bad_y];
13533 static int test_xy[4][2] =
13540 static int touch_dir[4] =
13542 MV_LEFT | MV_RIGHT,
13547 static int test_dir[4] =
13555 if (bad_element == EL_EXPLOSION) // skip just exploding bad things
13558 for (i = 0; i < NUM_DIRECTIONS; i++)
13560 int test_x, test_y, test_move_dir, test_element;
13562 test_x = bad_x + test_xy[i][0];
13563 test_y = bad_y + test_xy[i][1];
13565 if (!IN_LEV_FIELD(test_x, test_y))
13569 (IS_MOVING(test_x, test_y) ? MovDir[test_x][test_y] : MV_NONE);
13571 test_element = Tile[test_x][test_y];
13573 /* 1st case: good thing is moving towards DONT_RUN_INTO style bad thing;
13574 2nd case: DONT_TOUCH style bad thing does not move away from good thing
13576 if ((DONT_RUN_INTO(bad_element) && bad_move_dir == test_dir[i]) ||
13577 (DONT_TOUCH(bad_element) && test_move_dir != test_dir[i]))
13579 // good thing is player or penguin that does not move away
13580 if (IS_PLAYER(test_x, test_y))
13582 struct PlayerInfo *player = PLAYERINFO(test_x, test_y);
13584 if (bad_element == EL_ROBOT && player->is_moving)
13585 continue; // robot does not kill player if he is moving
13587 if (game.engine_version >= VERSION_IDENT(3,0,7,0))
13589 if (player->MovPos != 0 && !(player->MovDir & touch_dir[i]))
13590 continue; // center and border element do not touch
13598 else if (test_element == EL_PENGUIN)
13608 if (kill_x != -1 || kill_y != -1)
13610 if (IS_PLAYER(kill_x, kill_y))
13612 struct PlayerInfo *player = PLAYERINFO(kill_x, kill_y);
13614 if (player->shield_deadly_time_left > 0 &&
13615 !IS_INDESTRUCTIBLE(bad_element))
13616 Bang(bad_x, bad_y);
13617 else if (!PLAYER_ENEMY_PROTECTED(kill_x, kill_y))
13618 KillPlayer(player);
13621 Bang(kill_x, kill_y);
13625 void TestIfGoodThingGetsHitByBadThing(int bad_x, int bad_y, int bad_move_dir)
13627 int bad_element = Tile[bad_x][bad_y];
13628 int dx = (bad_move_dir == MV_LEFT ? -1 : bad_move_dir == MV_RIGHT ? +1 : 0);
13629 int dy = (bad_move_dir == MV_UP ? -1 : bad_move_dir == MV_DOWN ? +1 : 0);
13630 int test_x = bad_x + dx, test_y = bad_y + dy;
13631 int test_move_dir, test_element;
13632 int kill_x = -1, kill_y = -1;
13634 if (!IN_LEV_FIELD(test_x, test_y))
13638 (IS_MOVING(test_x, test_y) ? MovDir[test_x][test_y] : MV_NONE);
13640 test_element = Tile[test_x][test_y];
13642 if (test_move_dir != bad_move_dir)
13644 // good thing can be player or penguin that does not move away
13645 if (IS_PLAYER(test_x, test_y))
13647 struct PlayerInfo *player = PLAYERINFO(test_x, test_y);
13649 /* (note: in comparison to DONT_RUN_TO and DONT_TOUCH, also handle the
13650 player as being hit when he is moving towards the bad thing, because
13651 the "get hit by" condition would be lost after the player stops) */
13652 if (player->MovPos != 0 && player->MovDir == bad_move_dir)
13653 return; // player moves away from bad thing
13658 else if (test_element == EL_PENGUIN)
13665 if (kill_x != -1 || kill_y != -1)
13667 if (IS_PLAYER(kill_x, kill_y))
13669 struct PlayerInfo *player = PLAYERINFO(kill_x, kill_y);
13671 if (player->shield_deadly_time_left > 0 &&
13672 !IS_INDESTRUCTIBLE(bad_element))
13673 Bang(bad_x, bad_y);
13674 else if (!PLAYER_ENEMY_PROTECTED(kill_x, kill_y))
13675 KillPlayer(player);
13678 Bang(kill_x, kill_y);
13682 void TestIfPlayerTouchesBadThing(int x, int y)
13684 TestIfGoodThingHitsBadThing(x, y, MV_NONE);
13687 void TestIfPlayerRunsIntoBadThing(int x, int y, int move_dir)
13689 TestIfGoodThingHitsBadThing(x, y, move_dir);
13692 void TestIfBadThingTouchesPlayer(int x, int y)
13694 TestIfBadThingHitsGoodThing(x, y, MV_NONE);
13697 void TestIfBadThingRunsIntoPlayer(int x, int y, int move_dir)
13699 TestIfBadThingHitsGoodThing(x, y, move_dir);
13702 void TestIfFriendTouchesBadThing(int x, int y)
13704 TestIfGoodThingHitsBadThing(x, y, MV_NONE);
13707 void TestIfBadThingTouchesFriend(int x, int y)
13709 TestIfBadThingHitsGoodThing(x, y, MV_NONE);
13712 void TestIfBadThingTouchesOtherBadThing(int bad_x, int bad_y)
13714 int i, kill_x = bad_x, kill_y = bad_y;
13715 static int xy[4][2] =
13723 for (i = 0; i < NUM_DIRECTIONS; i++)
13727 x = bad_x + xy[i][0];
13728 y = bad_y + xy[i][1];
13729 if (!IN_LEV_FIELD(x, y))
13732 element = Tile[x][y];
13733 if (IS_AMOEBOID(element) || element == EL_GAME_OF_LIFE ||
13734 element == EL_AMOEBA_GROWING || element == EL_AMOEBA_DROP)
13742 if (kill_x != bad_x || kill_y != bad_y)
13743 Bang(bad_x, bad_y);
13746 void KillPlayer(struct PlayerInfo *player)
13748 int jx = player->jx, jy = player->jy;
13750 if (!player->active)
13754 Debug("game:playing:KillPlayer",
13755 "0: killed == %d, active == %d, reanimated == %d",
13756 player->killed, player->active, player->reanimated);
13759 /* the following code was introduced to prevent an infinite loop when calling
13761 -> CheckTriggeredElementChangeExt()
13762 -> ExecuteCustomElementAction()
13764 -> (infinitely repeating the above sequence of function calls)
13765 which occurs when killing the player while having a CE with the setting
13766 "kill player X when explosion of <player X>"; the solution using a new
13767 field "player->killed" was chosen for backwards compatibility, although
13768 clever use of the fields "player->active" etc. would probably also work */
13770 if (player->killed)
13774 player->killed = TRUE;
13776 // remove accessible field at the player's position
13777 Tile[jx][jy] = EL_EMPTY;
13779 // deactivate shield (else Bang()/Explode() would not work right)
13780 player->shield_normal_time_left = 0;
13781 player->shield_deadly_time_left = 0;
13784 Debug("game:playing:KillPlayer",
13785 "1: killed == %d, active == %d, reanimated == %d",
13786 player->killed, player->active, player->reanimated);
13792 Debug("game:playing:KillPlayer",
13793 "2: killed == %d, active == %d, reanimated == %d",
13794 player->killed, player->active, player->reanimated);
13797 if (player->reanimated) // killed player may have been reanimated
13798 player->killed = player->reanimated = FALSE;
13800 BuryPlayer(player);
13803 static void KillPlayerUnlessEnemyProtected(int x, int y)
13805 if (!PLAYER_ENEMY_PROTECTED(x, y))
13806 KillPlayer(PLAYERINFO(x, y));
13809 static void KillPlayerUnlessExplosionProtected(int x, int y)
13811 if (!PLAYER_EXPLOSION_PROTECTED(x, y))
13812 KillPlayer(PLAYERINFO(x, y));
13815 void BuryPlayer(struct PlayerInfo *player)
13817 int jx = player->jx, jy = player->jy;
13819 if (!player->active)
13822 PlayLevelSoundElementAction(jx, jy, player->artwork_element, ACTION_DYING);
13823 PlayLevelSound(jx, jy, SND_GAME_LOSING);
13825 RemovePlayer(player);
13827 player->buried = TRUE;
13829 if (game.all_players_gone)
13830 game.GameOver = TRUE;
13833 void RemovePlayer(struct PlayerInfo *player)
13835 int jx = player->jx, jy = player->jy;
13836 int i, found = FALSE;
13838 player->present = FALSE;
13839 player->active = FALSE;
13841 // required for some CE actions (even if the player is not active anymore)
13842 player->MovPos = 0;
13844 if (!ExplodeField[jx][jy])
13845 StorePlayer[jx][jy] = 0;
13847 if (player->is_moving)
13848 TEST_DrawLevelField(player->last_jx, player->last_jy);
13850 for (i = 0; i < MAX_PLAYERS; i++)
13851 if (stored_player[i].active)
13856 game.all_players_gone = TRUE;
13857 game.GameOver = TRUE;
13860 game.exit_x = game.robot_wheel_x = jx;
13861 game.exit_y = game.robot_wheel_y = jy;
13864 void ExitPlayer(struct PlayerInfo *player)
13866 DrawPlayer(player); // needed here only to cleanup last field
13867 RemovePlayer(player);
13869 if (game.players_still_needed > 0)
13870 game.players_still_needed--;
13873 static void SetFieldForSnapping(int x, int y, int element, int direction,
13874 int player_index_bit)
13876 struct ElementInfo *ei = &element_info[element];
13877 int direction_bit = MV_DIR_TO_BIT(direction);
13878 int graphic_snapping = ei->direction_graphic[ACTION_SNAPPING][direction_bit];
13879 int action = (graphic_snapping != IMG_EMPTY_SPACE ? ACTION_SNAPPING :
13880 IS_DIGGABLE(element) ? ACTION_DIGGING : ACTION_COLLECTING);
13882 Tile[x][y] = EL_ELEMENT_SNAPPING;
13883 MovDelay[x][y] = MOVE_DELAY_NORMAL_SPEED + 1 - 1;
13884 MovDir[x][y] = direction;
13885 Store[x][y] = element;
13886 Store2[x][y] = player_index_bit;
13888 ResetGfxAnimation(x, y);
13890 GfxElement[x][y] = element;
13891 GfxAction[x][y] = action;
13892 GfxDir[x][y] = direction;
13893 GfxFrame[x][y] = -1;
13896 static void TestFieldAfterSnapping(int x, int y, int element, int direction,
13897 int player_index_bit)
13899 TestIfElementTouchesCustomElement(x, y); // for empty space
13901 if (level.finish_dig_collect)
13903 int dig_side = MV_DIR_OPPOSITE(direction);
13905 CheckTriggeredElementChangeByPlayer(x, y, element, CE_PLAYER_SNAPS_X,
13906 player_index_bit, dig_side);
13911 =============================================================================
13912 checkDiagonalPushing()
13913 -----------------------------------------------------------------------------
13914 check if diagonal input device direction results in pushing of object
13915 (by checking if the alternative direction is walkable, diggable, ...)
13916 =============================================================================
13919 static boolean checkDiagonalPushing(struct PlayerInfo *player,
13920 int x, int y, int real_dx, int real_dy)
13922 int jx, jy, dx, dy, xx, yy;
13924 if (real_dx == 0 || real_dy == 0) // no diagonal direction => push
13927 // diagonal direction: check alternative direction
13932 xx = jx + (dx == 0 ? real_dx : 0);
13933 yy = jy + (dy == 0 ? real_dy : 0);
13935 return (!IN_LEV_FIELD(xx, yy) || IS_SOLID_FOR_PUSHING(Tile[xx][yy]));
13939 =============================================================================
13941 -----------------------------------------------------------------------------
13942 x, y: field next to player (non-diagonal) to try to dig to
13943 real_dx, real_dy: direction as read from input device (can be diagonal)
13944 =============================================================================
13947 static int DigField(struct PlayerInfo *player,
13948 int oldx, int oldy, int x, int y,
13949 int real_dx, int real_dy, int mode)
13951 boolean is_player = (IS_PLAYER(oldx, oldy) || mode != DF_DIG);
13952 boolean player_was_pushing = player->is_pushing;
13953 boolean player_can_move = (!player->cannot_move && mode != DF_SNAP);
13954 boolean player_can_move_or_snap = (!player->cannot_move || mode == DF_SNAP);
13955 int jx = oldx, jy = oldy;
13956 int dx = x - jx, dy = y - jy;
13957 int nextx = x + dx, nexty = y + dy;
13958 int move_direction = (dx == -1 ? MV_LEFT :
13959 dx == +1 ? MV_RIGHT :
13961 dy == +1 ? MV_DOWN : MV_NONE);
13962 int opposite_direction = MV_DIR_OPPOSITE(move_direction);
13963 int dig_side = MV_DIR_OPPOSITE(move_direction);
13964 int old_element = Tile[jx][jy];
13965 int element = MovingOrBlocked2ElementIfNotLeaving(x, y);
13968 if (is_player) // function can also be called by EL_PENGUIN
13970 if (player->MovPos == 0)
13972 player->is_digging = FALSE;
13973 player->is_collecting = FALSE;
13976 if (player->MovPos == 0) // last pushing move finished
13977 player->is_pushing = FALSE;
13979 if (mode == DF_NO_PUSH) // player just stopped pushing
13981 player->is_switching = FALSE;
13982 player->push_delay = -1;
13984 return MP_NO_ACTION;
13988 if (IS_TUBE(Back[jx][jy]) && game.engine_version >= VERSION_IDENT(2,2,0,0))
13989 old_element = Back[jx][jy];
13991 // in case of element dropped at player position, check background
13992 else if (Back[jx][jy] != EL_EMPTY &&
13993 game.engine_version >= VERSION_IDENT(2,2,0,0))
13994 old_element = Back[jx][jy];
13996 if (IS_WALKABLE(old_element) && !ACCESS_FROM(old_element, move_direction))
13997 return MP_NO_ACTION; // field has no opening in this direction
13999 if (IS_PASSABLE(old_element) && !ACCESS_FROM(old_element,opposite_direction))
14000 return MP_NO_ACTION; // field has no opening in this direction
14002 if (player_can_move && element == EL_ACID && move_direction == MV_DOWN)
14006 Tile[jx][jy] = player->artwork_element;
14007 InitMovingField(jx, jy, MV_DOWN);
14008 Store[jx][jy] = EL_ACID;
14009 ContinueMoving(jx, jy);
14010 BuryPlayer(player);
14012 return MP_DONT_RUN_INTO;
14015 if (player_can_move && DONT_RUN_INTO(element))
14017 TestIfPlayerRunsIntoBadThing(jx, jy, player->MovDir);
14019 return MP_DONT_RUN_INTO;
14022 if (IS_MOVING(x, y) || IS_PLAYER(x, y))
14023 return MP_NO_ACTION;
14025 collect_count = element_info[element].collect_count_initial;
14027 if (!is_player && !IS_COLLECTIBLE(element)) // penguin cannot collect it
14028 return MP_NO_ACTION;
14030 if (game.engine_version < VERSION_IDENT(2,2,0,0))
14031 player_can_move = player_can_move_or_snap;
14033 if (mode == DF_SNAP && !IS_SNAPPABLE(element) &&
14034 game.engine_version >= VERSION_IDENT(2,2,0,0))
14036 CheckElementChangeByPlayer(x, y, element, CE_SNAPPED_BY_PLAYER,
14037 player->index_bit, dig_side);
14038 CheckTriggeredElementChangeByPlayer(x, y, element, CE_PLAYER_SNAPS_X,
14039 player->index_bit, dig_side);
14041 if (element == EL_DC_LANDMINE)
14044 if (Tile[x][y] != element) // field changed by snapping
14047 return MP_NO_ACTION;
14050 if (player->gravity && is_player && !player->is_auto_moving &&
14051 canFallDown(player) && move_direction != MV_DOWN &&
14052 !canMoveToValidFieldWithGravity(jx, jy, move_direction))
14053 return MP_NO_ACTION; // player cannot walk here due to gravity
14055 if (player_can_move &&
14056 IS_WALKABLE(element) && ACCESS_FROM(element, opposite_direction))
14058 int sound_element = SND_ELEMENT(element);
14059 int sound_action = ACTION_WALKING;
14061 if (IS_RND_GATE(element))
14063 if (!player->key[RND_GATE_NR(element)])
14064 return MP_NO_ACTION;
14066 else if (IS_RND_GATE_GRAY(element))
14068 if (!player->key[RND_GATE_GRAY_NR(element)])
14069 return MP_NO_ACTION;
14071 else if (IS_RND_GATE_GRAY_ACTIVE(element))
14073 if (!player->key[RND_GATE_GRAY_ACTIVE_NR(element)])
14074 return MP_NO_ACTION;
14076 else if (element == EL_EXIT_OPEN ||
14077 element == EL_EM_EXIT_OPEN ||
14078 element == EL_EM_EXIT_OPENING ||
14079 element == EL_STEEL_EXIT_OPEN ||
14080 element == EL_EM_STEEL_EXIT_OPEN ||
14081 element == EL_EM_STEEL_EXIT_OPENING ||
14082 element == EL_SP_EXIT_OPEN ||
14083 element == EL_SP_EXIT_OPENING)
14085 sound_action = ACTION_PASSING; // player is passing exit
14087 else if (element == EL_EMPTY)
14089 sound_action = ACTION_MOVING; // nothing to walk on
14092 // play sound from background or player, whatever is available
14093 if (element_info[sound_element].sound[sound_action] != SND_UNDEFINED)
14094 PlayLevelSoundElementAction(x, y, sound_element, sound_action);
14096 PlayLevelSoundElementAction(x, y, player->artwork_element, sound_action);
14098 else if (player_can_move &&
14099 IS_PASSABLE(element) && canPassField(x, y, move_direction))
14101 if (!ACCESS_FROM(element, opposite_direction))
14102 return MP_NO_ACTION; // field not accessible from this direction
14104 if (CAN_MOVE(element)) // only fixed elements can be passed!
14105 return MP_NO_ACTION;
14107 if (IS_EM_GATE(element))
14109 if (!player->key[EM_GATE_NR(element)])
14110 return MP_NO_ACTION;
14112 else if (IS_EM_GATE_GRAY(element))
14114 if (!player->key[EM_GATE_GRAY_NR(element)])
14115 return MP_NO_ACTION;
14117 else if (IS_EM_GATE_GRAY_ACTIVE(element))
14119 if (!player->key[EM_GATE_GRAY_ACTIVE_NR(element)])
14120 return MP_NO_ACTION;
14122 else if (IS_EMC_GATE(element))
14124 if (!player->key[EMC_GATE_NR(element)])
14125 return MP_NO_ACTION;
14127 else if (IS_EMC_GATE_GRAY(element))
14129 if (!player->key[EMC_GATE_GRAY_NR(element)])
14130 return MP_NO_ACTION;
14132 else if (IS_EMC_GATE_GRAY_ACTIVE(element))
14134 if (!player->key[EMC_GATE_GRAY_ACTIVE_NR(element)])
14135 return MP_NO_ACTION;
14137 else if (element == EL_DC_GATE_WHITE ||
14138 element == EL_DC_GATE_WHITE_GRAY ||
14139 element == EL_DC_GATE_WHITE_GRAY_ACTIVE)
14141 if (player->num_white_keys == 0)
14142 return MP_NO_ACTION;
14144 player->num_white_keys--;
14146 else if (IS_SP_PORT(element))
14148 if (element == EL_SP_GRAVITY_PORT_LEFT ||
14149 element == EL_SP_GRAVITY_PORT_RIGHT ||
14150 element == EL_SP_GRAVITY_PORT_UP ||
14151 element == EL_SP_GRAVITY_PORT_DOWN)
14152 player->gravity = !player->gravity;
14153 else if (element == EL_SP_GRAVITY_ON_PORT_LEFT ||
14154 element == EL_SP_GRAVITY_ON_PORT_RIGHT ||
14155 element == EL_SP_GRAVITY_ON_PORT_UP ||
14156 element == EL_SP_GRAVITY_ON_PORT_DOWN)
14157 player->gravity = TRUE;
14158 else if (element == EL_SP_GRAVITY_OFF_PORT_LEFT ||
14159 element == EL_SP_GRAVITY_OFF_PORT_RIGHT ||
14160 element == EL_SP_GRAVITY_OFF_PORT_UP ||
14161 element == EL_SP_GRAVITY_OFF_PORT_DOWN)
14162 player->gravity = FALSE;
14165 // automatically move to the next field with double speed
14166 player->programmed_action = move_direction;
14168 if (player->move_delay_reset_counter == 0)
14170 player->move_delay_reset_counter = 2; // two double speed steps
14172 DOUBLE_PLAYER_SPEED(player);
14175 PlayLevelSoundAction(x, y, ACTION_PASSING);
14177 else if (player_can_move_or_snap && IS_DIGGABLE(element))
14181 if (mode != DF_SNAP)
14183 GfxElement[x][y] = GFX_ELEMENT(element);
14184 player->is_digging = TRUE;
14187 PlayLevelSoundElementAction(x, y, element, ACTION_DIGGING);
14189 // use old behaviour for old levels (digging)
14190 if (!level.finish_dig_collect)
14192 CheckTriggeredElementChangeByPlayer(x, y, element, CE_PLAYER_DIGS_X,
14193 player->index_bit, dig_side);
14195 // if digging triggered player relocation, finish digging tile
14196 if (mode == DF_DIG && (player->jx != jx || player->jy != jy))
14197 SetFieldForSnapping(x, y, element, move_direction, player->index_bit);
14200 if (mode == DF_SNAP)
14202 if (level.block_snap_field)
14203 SetFieldForSnapping(x, y, element, move_direction, player->index_bit);
14205 TestFieldAfterSnapping(x, y, element, move_direction, player->index_bit);
14207 // use old behaviour for old levels (snapping)
14208 if (!level.finish_dig_collect)
14209 CheckTriggeredElementChangeByPlayer(x, y, element, CE_PLAYER_SNAPS_X,
14210 player->index_bit, dig_side);
14213 else if (player_can_move_or_snap && IS_COLLECTIBLE(element))
14217 if (is_player && mode != DF_SNAP)
14219 GfxElement[x][y] = element;
14220 player->is_collecting = TRUE;
14223 if (element == EL_SPEED_PILL)
14225 player->move_delay_value = MOVE_DELAY_HIGH_SPEED;
14227 else if (element == EL_EXTRA_TIME && level.time > 0)
14229 TimeLeft += level.extra_time;
14231 game_panel_controls[GAME_PANEL_TIME].value = TimeLeft;
14233 DisplayGameControlValues();
14235 else if (element == EL_SHIELD_NORMAL || element == EL_SHIELD_DEADLY)
14237 player->shield_normal_time_left += level.shield_normal_time;
14238 if (element == EL_SHIELD_DEADLY)
14239 player->shield_deadly_time_left += level.shield_deadly_time;
14241 else if (element == EL_DYNAMITE ||
14242 element == EL_EM_DYNAMITE ||
14243 element == EL_SP_DISK_RED)
14245 if (player->inventory_size < MAX_INVENTORY_SIZE)
14246 player->inventory_element[player->inventory_size++] = element;
14248 DrawGameDoorValues();
14250 else if (element == EL_DYNABOMB_INCREASE_NUMBER)
14252 player->dynabomb_count++;
14253 player->dynabombs_left++;
14255 else if (element == EL_DYNABOMB_INCREASE_SIZE)
14257 player->dynabomb_size++;
14259 else if (element == EL_DYNABOMB_INCREASE_POWER)
14261 player->dynabomb_xl = TRUE;
14263 else if (IS_KEY(element))
14265 player->key[KEY_NR(element)] = TRUE;
14267 DrawGameDoorValues();
14269 else if (element == EL_DC_KEY_WHITE)
14271 player->num_white_keys++;
14273 // display white keys?
14274 // DrawGameDoorValues();
14276 else if (IS_ENVELOPE(element))
14278 player->show_envelope = element;
14280 else if (element == EL_EMC_LENSES)
14282 game.lenses_time_left = level.lenses_time * FRAMES_PER_SECOND;
14284 RedrawAllInvisibleElementsForLenses();
14286 else if (element == EL_EMC_MAGNIFIER)
14288 game.magnify_time_left = level.magnify_time * FRAMES_PER_SECOND;
14290 RedrawAllInvisibleElementsForMagnifier();
14292 else if (IS_DROPPABLE(element) ||
14293 IS_THROWABLE(element)) // can be collected and dropped
14297 if (collect_count == 0)
14298 player->inventory_infinite_element = element;
14300 for (i = 0; i < collect_count; i++)
14301 if (player->inventory_size < MAX_INVENTORY_SIZE)
14302 player->inventory_element[player->inventory_size++] = element;
14304 DrawGameDoorValues();
14306 else if (collect_count > 0)
14308 game.gems_still_needed -= collect_count;
14309 if (game.gems_still_needed < 0)
14310 game.gems_still_needed = 0;
14312 game.snapshot.collected_item = TRUE;
14314 game_panel_controls[GAME_PANEL_GEMS].value = game.gems_still_needed;
14316 DisplayGameControlValues();
14319 RaiseScoreElement(element);
14320 PlayLevelSoundElementAction(x, y, element, ACTION_COLLECTING);
14322 // use old behaviour for old levels (collecting)
14323 if (!level.finish_dig_collect && is_player)
14325 CheckTriggeredElementChangeByPlayer(x, y, element, CE_PLAYER_COLLECTS_X,
14326 player->index_bit, dig_side);
14328 // if collecting triggered player relocation, finish collecting tile
14329 if (mode == DF_DIG && (player->jx != jx || player->jy != jy))
14330 SetFieldForSnapping(x, y, element, move_direction, player->index_bit);
14333 if (mode == DF_SNAP)
14335 if (level.block_snap_field)
14336 SetFieldForSnapping(x, y, element, move_direction, player->index_bit);
14338 TestFieldAfterSnapping(x, y, element, move_direction, player->index_bit);
14340 // use old behaviour for old levels (snapping)
14341 if (!level.finish_dig_collect)
14342 CheckTriggeredElementChangeByPlayer(x, y, element, CE_PLAYER_SNAPS_X,
14343 player->index_bit, dig_side);
14346 else if (player_can_move_or_snap && IS_PUSHABLE(element))
14348 if (mode == DF_SNAP && element != EL_BD_ROCK)
14349 return MP_NO_ACTION;
14351 if (CAN_FALL(element) && dy)
14352 return MP_NO_ACTION;
14354 if (CAN_FALL(element) && IN_LEV_FIELD(x, y + 1) && IS_FREE(x, y + 1) &&
14355 !(element == EL_SPRING && level.use_spring_bug))
14356 return MP_NO_ACTION;
14358 if (CAN_MOVE(element) && GET_MAX_MOVE_DELAY(element) == 0 &&
14359 ((move_direction & MV_VERTICAL &&
14360 ((element_info[element].move_pattern & MV_LEFT &&
14361 IN_LEV_FIELD(x - 1, y) && IS_FREE(x - 1, y)) ||
14362 (element_info[element].move_pattern & MV_RIGHT &&
14363 IN_LEV_FIELD(x + 1, y) && IS_FREE(x + 1, y)))) ||
14364 (move_direction & MV_HORIZONTAL &&
14365 ((element_info[element].move_pattern & MV_UP &&
14366 IN_LEV_FIELD(x, y - 1) && IS_FREE(x, y - 1)) ||
14367 (element_info[element].move_pattern & MV_DOWN &&
14368 IN_LEV_FIELD(x, y + 1) && IS_FREE(x, y + 1))))))
14369 return MP_NO_ACTION;
14371 // do not push elements already moving away faster than player
14372 if (CAN_MOVE(element) && MovDir[x][y] == move_direction &&
14373 ABS(getElementMoveStepsize(x, y)) > MOVE_STEPSIZE_NORMAL)
14374 return MP_NO_ACTION;
14376 if (game.engine_version >= VERSION_IDENT(3,1,0,0))
14378 if (player->push_delay_value == -1 || !player_was_pushing)
14379 player->push_delay_value = GET_NEW_PUSH_DELAY(element);
14381 else if (game.engine_version >= VERSION_IDENT(3,0,7,1))
14383 if (player->push_delay_value == -1)
14384 player->push_delay_value = GET_NEW_PUSH_DELAY(element);
14386 else if (game.engine_version >= VERSION_IDENT(2,2,0,7))
14388 if (!player->is_pushing)
14389 player->push_delay_value = GET_NEW_PUSH_DELAY(element);
14392 player->is_pushing = TRUE;
14393 player->is_active = TRUE;
14395 if (!(IN_LEV_FIELD(nextx, nexty) &&
14396 (IS_FREE(nextx, nexty) ||
14397 (IS_SB_ELEMENT(element) &&
14398 Tile[nextx][nexty] == EL_SOKOBAN_FIELD_EMPTY) ||
14399 (IS_CUSTOM_ELEMENT(element) &&
14400 CUSTOM_ELEMENT_CAN_ENTER_FIELD(element, nextx, nexty)))))
14401 return MP_NO_ACTION;
14403 if (!checkDiagonalPushing(player, x, y, real_dx, real_dy))
14404 return MP_NO_ACTION;
14406 if (player->push_delay == -1) // new pushing; restart delay
14407 player->push_delay = 0;
14409 if (player->push_delay < player->push_delay_value &&
14410 !(tape.playing && tape.file_version < FILE_VERSION_2_0) &&
14411 element != EL_SPRING && element != EL_BALLOON)
14413 // make sure that there is no move delay before next try to push
14414 if (game.engine_version >= VERSION_IDENT(3,0,7,1))
14415 player->move_delay = 0;
14417 return MP_NO_ACTION;
14420 if (IS_CUSTOM_ELEMENT(element) &&
14421 CUSTOM_ELEMENT_CAN_ENTER_FIELD(element, nextx, nexty))
14423 if (!DigFieldByCE(nextx, nexty, element))
14424 return MP_NO_ACTION;
14427 if (IS_SB_ELEMENT(element))
14429 boolean sokoban_task_solved = FALSE;
14431 if (element == EL_SOKOBAN_FIELD_FULL)
14433 Back[x][y] = EL_SOKOBAN_FIELD_EMPTY;
14435 IncrementSokobanFieldsNeeded();
14436 IncrementSokobanObjectsNeeded();
14439 if (Tile[nextx][nexty] == EL_SOKOBAN_FIELD_EMPTY)
14441 Back[nextx][nexty] = EL_SOKOBAN_FIELD_EMPTY;
14443 DecrementSokobanFieldsNeeded();
14444 DecrementSokobanObjectsNeeded();
14446 // sokoban object was pushed from empty field to sokoban field
14447 if (Back[x][y] == EL_EMPTY)
14448 sokoban_task_solved = TRUE;
14451 Tile[x][y] = EL_SOKOBAN_OBJECT;
14453 if (Back[x][y] == Back[nextx][nexty])
14454 PlayLevelSoundAction(x, y, ACTION_PUSHING);
14455 else if (Back[x][y] != 0)
14456 PlayLevelSoundElementAction(x, y, EL_SOKOBAN_FIELD_FULL,
14459 PlayLevelSoundElementAction(nextx, nexty, EL_SOKOBAN_FIELD_EMPTY,
14462 if (sokoban_task_solved &&
14463 game.sokoban_fields_still_needed == 0 &&
14464 game.sokoban_objects_still_needed == 0 &&
14465 (game.emulation == EMU_SOKOBAN || level.auto_exit_sokoban))
14467 game.players_still_needed = 0;
14471 PlayLevelSound(x, y, SND_GAME_SOKOBAN_SOLVING);
14475 PlayLevelSoundElementAction(x, y, element, ACTION_PUSHING);
14477 InitMovingField(x, y, move_direction);
14478 GfxAction[x][y] = ACTION_PUSHING;
14480 if (mode == DF_SNAP)
14481 ContinueMoving(x, y);
14483 MovPos[x][y] = (dx != 0 ? dx : dy);
14485 Pushed[x][y] = TRUE;
14486 Pushed[nextx][nexty] = TRUE;
14488 if (game.engine_version < VERSION_IDENT(2,2,0,7))
14489 player->push_delay_value = GET_NEW_PUSH_DELAY(element);
14491 player->push_delay_value = -1; // get new value later
14493 // check for element change _after_ element has been pushed
14494 if (game.use_change_when_pushing_bug)
14496 CheckElementChangeByPlayer(x, y, element, CE_PUSHED_BY_PLAYER,
14497 player->index_bit, dig_side);
14498 CheckTriggeredElementChangeByPlayer(x, y, element, CE_PLAYER_PUSHES_X,
14499 player->index_bit, dig_side);
14502 else if (IS_SWITCHABLE(element))
14504 if (PLAYER_SWITCHING(player, x, y))
14506 CheckTriggeredElementChangeByPlayer(x, y, element, CE_PLAYER_PRESSES_X,
14507 player->index_bit, dig_side);
14512 player->is_switching = TRUE;
14513 player->switch_x = x;
14514 player->switch_y = y;
14516 PlayLevelSoundElementAction(x, y, element, ACTION_ACTIVATING);
14518 if (element == EL_ROBOT_WHEEL)
14520 Tile[x][y] = EL_ROBOT_WHEEL_ACTIVE;
14522 game.robot_wheel_x = x;
14523 game.robot_wheel_y = y;
14524 game.robot_wheel_active = TRUE;
14526 TEST_DrawLevelField(x, y);
14528 else if (element == EL_SP_TERMINAL)
14532 SCAN_PLAYFIELD(xx, yy)
14534 if (Tile[xx][yy] == EL_SP_DISK_YELLOW)
14538 else if (Tile[xx][yy] == EL_SP_TERMINAL)
14540 Tile[xx][yy] = EL_SP_TERMINAL_ACTIVE;
14542 ResetGfxAnimation(xx, yy);
14543 TEST_DrawLevelField(xx, yy);
14547 else if (IS_BELT_SWITCH(element))
14549 ToggleBeltSwitch(x, y);
14551 else if (element == EL_SWITCHGATE_SWITCH_UP ||
14552 element == EL_SWITCHGATE_SWITCH_DOWN ||
14553 element == EL_DC_SWITCHGATE_SWITCH_UP ||
14554 element == EL_DC_SWITCHGATE_SWITCH_DOWN)
14556 ToggleSwitchgateSwitch(x, y);
14558 else if (element == EL_LIGHT_SWITCH ||
14559 element == EL_LIGHT_SWITCH_ACTIVE)
14561 ToggleLightSwitch(x, y);
14563 else if (element == EL_TIMEGATE_SWITCH ||
14564 element == EL_DC_TIMEGATE_SWITCH)
14566 ActivateTimegateSwitch(x, y);
14568 else if (element == EL_BALLOON_SWITCH_LEFT ||
14569 element == EL_BALLOON_SWITCH_RIGHT ||
14570 element == EL_BALLOON_SWITCH_UP ||
14571 element == EL_BALLOON_SWITCH_DOWN ||
14572 element == EL_BALLOON_SWITCH_NONE ||
14573 element == EL_BALLOON_SWITCH_ANY)
14575 game.wind_direction = (element == EL_BALLOON_SWITCH_LEFT ? MV_LEFT :
14576 element == EL_BALLOON_SWITCH_RIGHT ? MV_RIGHT :
14577 element == EL_BALLOON_SWITCH_UP ? MV_UP :
14578 element == EL_BALLOON_SWITCH_DOWN ? MV_DOWN :
14579 element == EL_BALLOON_SWITCH_NONE ? MV_NONE :
14582 else if (element == EL_LAMP)
14584 Tile[x][y] = EL_LAMP_ACTIVE;
14585 game.lights_still_needed--;
14587 ResetGfxAnimation(x, y);
14588 TEST_DrawLevelField(x, y);
14590 else if (element == EL_TIME_ORB_FULL)
14592 Tile[x][y] = EL_TIME_ORB_EMPTY;
14594 if (level.time > 0 || level.use_time_orb_bug)
14596 TimeLeft += level.time_orb_time;
14597 game.no_time_limit = FALSE;
14599 game_panel_controls[GAME_PANEL_TIME].value = TimeLeft;
14601 DisplayGameControlValues();
14604 ResetGfxAnimation(x, y);
14605 TEST_DrawLevelField(x, y);
14607 else if (element == EL_EMC_MAGIC_BALL_SWITCH ||
14608 element == EL_EMC_MAGIC_BALL_SWITCH_ACTIVE)
14612 game.ball_active = !game.ball_active;
14614 SCAN_PLAYFIELD(xx, yy)
14616 int e = Tile[xx][yy];
14618 if (game.ball_active)
14620 if (e == EL_EMC_MAGIC_BALL)
14621 CreateField(xx, yy, EL_EMC_MAGIC_BALL_ACTIVE);
14622 else if (e == EL_EMC_MAGIC_BALL_SWITCH)
14623 CreateField(xx, yy, EL_EMC_MAGIC_BALL_SWITCH_ACTIVE);
14627 if (e == EL_EMC_MAGIC_BALL_ACTIVE)
14628 CreateField(xx, yy, EL_EMC_MAGIC_BALL);
14629 else if (e == EL_EMC_MAGIC_BALL_SWITCH_ACTIVE)
14630 CreateField(xx, yy, EL_EMC_MAGIC_BALL_SWITCH);
14635 CheckTriggeredElementChangeByPlayer(x, y, element, CE_SWITCH_OF_X,
14636 player->index_bit, dig_side);
14638 CheckTriggeredElementChangeByPlayer(x, y, element, CE_PLAYER_SWITCHES_X,
14639 player->index_bit, dig_side);
14641 CheckTriggeredElementChangeByPlayer(x, y, element, CE_PLAYER_PRESSES_X,
14642 player->index_bit, dig_side);
14648 if (!PLAYER_SWITCHING(player, x, y))
14650 player->is_switching = TRUE;
14651 player->switch_x = x;
14652 player->switch_y = y;
14654 CheckElementChangeByPlayer(x, y, element, CE_SWITCHED,
14655 player->index_bit, dig_side);
14656 CheckTriggeredElementChangeByPlayer(x, y, element, CE_SWITCH_OF_X,
14657 player->index_bit, dig_side);
14659 CheckElementChangeByPlayer(x, y, element, CE_SWITCHED_BY_PLAYER,
14660 player->index_bit, dig_side);
14661 CheckTriggeredElementChangeByPlayer(x, y, element, CE_PLAYER_SWITCHES_X,
14662 player->index_bit, dig_side);
14665 CheckElementChangeByPlayer(x, y, element, CE_PRESSED_BY_PLAYER,
14666 player->index_bit, dig_side);
14667 CheckTriggeredElementChangeByPlayer(x, y, element, CE_PLAYER_PRESSES_X,
14668 player->index_bit, dig_side);
14670 return MP_NO_ACTION;
14673 player->push_delay = -1;
14675 if (is_player) // function can also be called by EL_PENGUIN
14677 if (Tile[x][y] != element) // really digged/collected something
14679 player->is_collecting = !player->is_digging;
14680 player->is_active = TRUE;
14682 player->last_removed_element = element;
14689 static boolean DigFieldByCE(int x, int y, int digging_element)
14691 int element = Tile[x][y];
14693 if (!IS_FREE(x, y))
14695 int action = (IS_DIGGABLE(element) ? ACTION_DIGGING :
14696 IS_COLLECTIBLE(element) ? ACTION_COLLECTING :
14699 // no element can dig solid indestructible elements
14700 if (IS_INDESTRUCTIBLE(element) &&
14701 !IS_DIGGABLE(element) &&
14702 !IS_COLLECTIBLE(element))
14705 if (AmoebaNr[x][y] &&
14706 (element == EL_AMOEBA_FULL ||
14707 element == EL_BD_AMOEBA ||
14708 element == EL_AMOEBA_GROWING))
14710 AmoebaCnt[AmoebaNr[x][y]]--;
14711 AmoebaCnt2[AmoebaNr[x][y]]--;
14714 if (IS_MOVING(x, y))
14715 RemoveMovingField(x, y);
14719 TEST_DrawLevelField(x, y);
14722 // if digged element was about to explode, prevent the explosion
14723 ExplodeField[x][y] = EX_TYPE_NONE;
14725 PlayLevelSoundAction(x, y, action);
14728 Store[x][y] = EL_EMPTY;
14730 // this makes it possible to leave the removed element again
14731 if (IS_EQUAL_OR_IN_GROUP(element, MOVE_ENTER_EL(digging_element)))
14732 Store[x][y] = element;
14737 static boolean SnapField(struct PlayerInfo *player, int dx, int dy)
14739 int jx = player->jx, jy = player->jy;
14740 int x = jx + dx, y = jy + dy;
14741 int snap_direction = (dx == -1 ? MV_LEFT :
14742 dx == +1 ? MV_RIGHT :
14744 dy == +1 ? MV_DOWN : MV_NONE);
14745 boolean can_continue_snapping = (level.continuous_snapping &&
14746 WasJustFalling[x][y] < CHECK_DELAY_FALLING);
14748 if (player->MovPos != 0 && game.engine_version >= VERSION_IDENT(2,2,0,0))
14751 if (!player->active || !IN_LEV_FIELD(x, y))
14759 if (player->MovPos == 0)
14760 player->is_pushing = FALSE;
14762 player->is_snapping = FALSE;
14764 if (player->MovPos == 0)
14766 player->is_moving = FALSE;
14767 player->is_digging = FALSE;
14768 player->is_collecting = FALSE;
14774 // prevent snapping with already pressed snap key when not allowed
14775 if (player->is_snapping && !can_continue_snapping)
14778 player->MovDir = snap_direction;
14780 if (player->MovPos == 0)
14782 player->is_moving = FALSE;
14783 player->is_digging = FALSE;
14784 player->is_collecting = FALSE;
14787 player->is_dropping = FALSE;
14788 player->is_dropping_pressed = FALSE;
14789 player->drop_pressed_delay = 0;
14791 if (DigField(player, jx, jy, x, y, 0, 0, DF_SNAP) == MP_NO_ACTION)
14794 player->is_snapping = TRUE;
14795 player->is_active = TRUE;
14797 if (player->MovPos == 0)
14799 player->is_moving = FALSE;
14800 player->is_digging = FALSE;
14801 player->is_collecting = FALSE;
14804 if (player->MovPos != 0) // prevent graphic bugs in versions < 2.2.0
14805 TEST_DrawLevelField(player->last_jx, player->last_jy);
14807 TEST_DrawLevelField(x, y);
14812 static boolean DropElement(struct PlayerInfo *player)
14814 int old_element, new_element;
14815 int dropx = player->jx, dropy = player->jy;
14816 int drop_direction = player->MovDir;
14817 int drop_side = drop_direction;
14818 int drop_element = get_next_dropped_element(player);
14820 /* do not drop an element on top of another element; when holding drop key
14821 pressed without moving, dropped element must move away before the next
14822 element can be dropped (this is especially important if the next element
14823 is dynamite, which can be placed on background for historical reasons) */
14824 if (PLAYER_DROPPING(player, dropx, dropy) && Tile[dropx][dropy] != EL_EMPTY)
14827 if (IS_THROWABLE(drop_element))
14829 dropx += GET_DX_FROM_DIR(drop_direction);
14830 dropy += GET_DY_FROM_DIR(drop_direction);
14832 if (!IN_LEV_FIELD(dropx, dropy))
14836 old_element = Tile[dropx][dropy]; // old element at dropping position
14837 new_element = drop_element; // default: no change when dropping
14839 // check if player is active, not moving and ready to drop
14840 if (!player->active || player->MovPos || player->drop_delay > 0)
14843 // check if player has anything that can be dropped
14844 if (new_element == EL_UNDEFINED)
14847 // only set if player has anything that can be dropped
14848 player->is_dropping_pressed = TRUE;
14850 // check if drop key was pressed long enough for EM style dynamite
14851 if (new_element == EL_EM_DYNAMITE && player->drop_pressed_delay < 40)
14854 // check if anything can be dropped at the current position
14855 if (IS_ACTIVE_BOMB(old_element) || old_element == EL_EXPLOSION)
14858 // collected custom elements can only be dropped on empty fields
14859 if (IS_CUSTOM_ELEMENT(new_element) && old_element != EL_EMPTY)
14862 if (old_element != EL_EMPTY)
14863 Back[dropx][dropy] = old_element; // store old element on this field
14865 ResetGfxAnimation(dropx, dropy);
14866 ResetRandomAnimationValue(dropx, dropy);
14868 if (player->inventory_size > 0 ||
14869 player->inventory_infinite_element != EL_UNDEFINED)
14871 if (player->inventory_size > 0)
14873 player->inventory_size--;
14875 DrawGameDoorValues();
14877 if (new_element == EL_DYNAMITE)
14878 new_element = EL_DYNAMITE_ACTIVE;
14879 else if (new_element == EL_EM_DYNAMITE)
14880 new_element = EL_EM_DYNAMITE_ACTIVE;
14881 else if (new_element == EL_SP_DISK_RED)
14882 new_element = EL_SP_DISK_RED_ACTIVE;
14885 Tile[dropx][dropy] = new_element;
14887 if (IN_SCR_FIELD(SCREENX(dropx), SCREENY(dropy)))
14888 DrawGraphicThruMask(SCREENX(dropx), SCREENY(dropy),
14889 el2img(Tile[dropx][dropy]), 0);
14891 PlayLevelSoundAction(dropx, dropy, ACTION_DROPPING);
14893 // needed if previous element just changed to "empty" in the last frame
14894 ChangeCount[dropx][dropy] = 0; // allow at least one more change
14896 CheckElementChangeByPlayer(dropx, dropy, new_element, CE_DROPPED_BY_PLAYER,
14897 player->index_bit, drop_side);
14898 CheckTriggeredElementChangeByPlayer(dropx, dropy, new_element,
14900 player->index_bit, drop_side);
14902 TestIfElementTouchesCustomElement(dropx, dropy);
14904 else // player is dropping a dyna bomb
14906 player->dynabombs_left--;
14908 Tile[dropx][dropy] = new_element;
14910 if (IN_SCR_FIELD(SCREENX(dropx), SCREENY(dropy)))
14911 DrawGraphicThruMask(SCREENX(dropx), SCREENY(dropy),
14912 el2img(Tile[dropx][dropy]), 0);
14914 PlayLevelSoundAction(dropx, dropy, ACTION_DROPPING);
14917 if (Tile[dropx][dropy] == new_element) // uninitialized unless CE change
14918 InitField_WithBug1(dropx, dropy, FALSE);
14920 new_element = Tile[dropx][dropy]; // element might have changed
14922 if (IS_CUSTOM_ELEMENT(new_element) && CAN_MOVE(new_element) &&
14923 element_info[new_element].move_pattern == MV_WHEN_DROPPED)
14925 if (element_info[new_element].move_direction_initial == MV_START_AUTOMATIC)
14926 MovDir[dropx][dropy] = drop_direction;
14928 ChangeCount[dropx][dropy] = 0; // allow at least one more change
14930 // do not cause impact style collision by dropping elements that can fall
14931 CheckCollision[dropx][dropy] = CHECK_DELAY_COLLISION;
14934 player->drop_delay = GET_NEW_DROP_DELAY(drop_element);
14935 player->is_dropping = TRUE;
14937 player->drop_pressed_delay = 0;
14938 player->is_dropping_pressed = FALSE;
14940 player->drop_x = dropx;
14941 player->drop_y = dropy;
14946 // ----------------------------------------------------------------------------
14947 // game sound playing functions
14948 // ----------------------------------------------------------------------------
14950 static int *loop_sound_frame = NULL;
14951 static int *loop_sound_volume = NULL;
14953 void InitPlayLevelSound(void)
14955 int num_sounds = getSoundListSize();
14957 checked_free(loop_sound_frame);
14958 checked_free(loop_sound_volume);
14960 loop_sound_frame = checked_calloc(num_sounds * sizeof(int));
14961 loop_sound_volume = checked_calloc(num_sounds * sizeof(int));
14964 static void PlayLevelSound(int x, int y, int nr)
14966 int sx = SCREENX(x), sy = SCREENY(y);
14967 int volume, stereo_position;
14968 int max_distance = 8;
14969 int type = (IS_LOOP_SOUND(nr) ? SND_CTRL_PLAY_LOOP : SND_CTRL_PLAY_SOUND);
14971 if ((!setup.sound_simple && !IS_LOOP_SOUND(nr)) ||
14972 (!setup.sound_loops && IS_LOOP_SOUND(nr)))
14975 if (!IN_LEV_FIELD(x, y) ||
14976 sx < -max_distance || sx >= SCR_FIELDX + max_distance ||
14977 sy < -max_distance || sy >= SCR_FIELDY + max_distance)
14980 volume = SOUND_MAX_VOLUME;
14982 if (!IN_SCR_FIELD(sx, sy))
14984 int dx = ABS(sx - SCR_FIELDX / 2) - SCR_FIELDX / 2;
14985 int dy = ABS(sy - SCR_FIELDY / 2) - SCR_FIELDY / 2;
14987 volume -= volume * (dx > dy ? dx : dy) / max_distance;
14990 stereo_position = (SOUND_MAX_LEFT +
14991 (sx + max_distance) * SOUND_MAX_LEFT2RIGHT /
14992 (SCR_FIELDX + 2 * max_distance));
14994 if (IS_LOOP_SOUND(nr))
14996 /* This assures that quieter loop sounds do not overwrite louder ones,
14997 while restarting sound volume comparison with each new game frame. */
14999 if (loop_sound_volume[nr] > volume && loop_sound_frame[nr] == FrameCounter)
15002 loop_sound_volume[nr] = volume;
15003 loop_sound_frame[nr] = FrameCounter;
15006 PlaySoundExt(nr, volume, stereo_position, type);
15009 static void PlayLevelSoundNearest(int x, int y, int sound_action)
15011 PlayLevelSound(x < LEVELX(BX1) ? LEVELX(BX1) :
15012 x > LEVELX(BX2) ? LEVELX(BX2) : x,
15013 y < LEVELY(BY1) ? LEVELY(BY1) :
15014 y > LEVELY(BY2) ? LEVELY(BY2) : y,
15018 static void PlayLevelSoundAction(int x, int y, int action)
15020 PlayLevelSoundElementAction(x, y, Tile[x][y], action);
15023 static void PlayLevelSoundElementAction(int x, int y, int element, int action)
15025 int sound_effect = element_info[SND_ELEMENT(element)].sound[action];
15027 if (sound_effect != SND_UNDEFINED)
15028 PlayLevelSound(x, y, sound_effect);
15031 static void PlayLevelSoundElementActionIfLoop(int x, int y, int element,
15034 int sound_effect = element_info[SND_ELEMENT(element)].sound[action];
15036 if (sound_effect != SND_UNDEFINED && IS_LOOP_SOUND(sound_effect))
15037 PlayLevelSound(x, y, sound_effect);
15040 static void PlayLevelSoundActionIfLoop(int x, int y, int action)
15042 int sound_effect = element_info[SND_ELEMENT(Tile[x][y])].sound[action];
15044 if (sound_effect != SND_UNDEFINED && IS_LOOP_SOUND(sound_effect))
15045 PlayLevelSound(x, y, sound_effect);
15048 static void StopLevelSoundActionIfLoop(int x, int y, int action)
15050 int sound_effect = element_info[SND_ELEMENT(Tile[x][y])].sound[action];
15052 if (sound_effect != SND_UNDEFINED && IS_LOOP_SOUND(sound_effect))
15053 StopSound(sound_effect);
15056 static int getLevelMusicNr(void)
15058 if (levelset.music[level_nr] != MUS_UNDEFINED)
15059 return levelset.music[level_nr]; // from config file
15061 return MAP_NOCONF_MUSIC(level_nr); // from music dir
15064 static void FadeLevelSounds(void)
15069 static void FadeLevelMusic(void)
15071 int music_nr = getLevelMusicNr();
15072 char *curr_music = getCurrentlyPlayingMusicFilename();
15073 char *next_music = getMusicInfoEntryFilename(music_nr);
15075 if (!strEqual(curr_music, next_music))
15079 void FadeLevelSoundsAndMusic(void)
15085 static void PlayLevelMusic(void)
15087 int music_nr = getLevelMusicNr();
15088 char *curr_music = getCurrentlyPlayingMusicFilename();
15089 char *next_music = getMusicInfoEntryFilename(music_nr);
15091 if (!strEqual(curr_music, next_music))
15092 PlayMusicLoop(music_nr);
15095 void PlayLevelSound_EM(int xx, int yy, int element_em, int sample)
15097 int element = (element_em > -1 ? map_element_EM_to_RND_game(element_em) : 0);
15099 int x = xx - offset;
15100 int y = yy - offset;
15105 PlayLevelSoundElementAction(x, y, element, ACTION_WALKING);
15109 PlayLevelSoundElementAction(x, y, element, ACTION_PUSHING);
15113 PlayLevelSoundElementAction(x, y, element, ACTION_IMPACT);
15117 PlayLevelSoundElementAction(x, y, element, ACTION_IMPACT);
15121 PlayLevelSoundElementAction(x, y, element, ACTION_BREAKING);
15125 PlayLevelSoundElementAction(x, y, element, ACTION_MOVING);
15129 PlayLevelSoundElementAction(x, y, element, ACTION_MOVING);
15132 case SOUND_android_clone:
15133 PlayLevelSoundElementAction(x, y, element, ACTION_DROPPING);
15136 case SOUND_android_move:
15137 PlayLevelSoundElementAction(x, y, element, ACTION_MOVING);
15141 PlayLevelSoundElementAction(x, y, element, ACTION_IMPACT);
15145 PlayLevelSoundElementAction(x, y, element, ACTION_EATING);
15149 PlayLevelSoundElementAction(x, y, element, ACTION_WAITING);
15152 case SOUND_eater_eat:
15153 PlayLevelSoundElementAction(x, y, element, ACTION_DIGGING);
15157 PlayLevelSoundElementAction(x, y, element, ACTION_MOVING);
15160 case SOUND_collect:
15161 PlayLevelSoundElementAction(x, y, element, ACTION_COLLECTING);
15164 case SOUND_diamond:
15165 PlayLevelSoundElementAction(x, y, element, ACTION_IMPACT);
15169 // !!! CHECK THIS !!!
15171 PlayLevelSoundElementAction(x, y, element, ACTION_BREAKING);
15173 PlayLevelSoundElementAction(x, y, element, ACTION_SMASHED_BY_ROCK);
15177 case SOUND_wonderfall:
15178 PlayLevelSoundElementAction(x, y, element, ACTION_FILLING);
15182 PlayLevelSoundElementAction(x, y, element, ACTION_IMPACT);
15186 PlayLevelSoundElementAction(x, y, element, ACTION_PUSHING);
15190 PlayLevelSoundElementAction(x, y, element, ACTION_DIGGING);
15194 PlayLevelSoundElementAction(x, y, element, ACTION_SPLASHING);
15198 PlayLevelSoundElementAction(x, y, element, ACTION_DROPPING);
15202 PlayLevelSoundElementAction(x, y, element, ACTION_GROWING);
15206 PlayLevelSoundElementAction(x, y, element, ACTION_ACTIVE);
15210 PlayLevelSoundElementAction(x, y, element, ACTION_PASSING);
15213 case SOUND_exit_open:
15214 PlayLevelSoundElementAction(x, y, element, ACTION_OPENING);
15217 case SOUND_exit_leave:
15218 PlayLevelSoundElementAction(x, y, element, ACTION_PASSING);
15221 case SOUND_dynamite:
15222 PlayLevelSoundElementAction(x, y, element, ACTION_DROPPING);
15226 PlayLevelSoundElementAction(x, y, element, ACTION_ACTIVE);
15230 PlayLevelSoundElementAction(x, y, element, ACTION_ACTIVATING);
15234 PlayLevelSoundElementAction(x, y, element, ACTION_ACTIVE);
15238 PlayLevelSoundElementAction(x, y, element, ACTION_EXPLODING);
15242 PlayLevelSoundElementAction(x, y, element, ACTION_DYING);
15246 PlaySound(SND_GAME_RUNNING_OUT_OF_TIME);
15250 PlayLevelSoundElementAction(x, y, element, ACTION_DEFAULT);
15255 void PlayLevelSound_SP(int xx, int yy, int element_sp, int action_sp)
15257 int element = map_element_SP_to_RND(element_sp);
15258 int action = map_action_SP_to_RND(action_sp);
15259 int offset = (setup.sp_show_border_elements ? 0 : 1);
15260 int x = xx - offset;
15261 int y = yy - offset;
15263 PlayLevelSoundElementAction(x, y, element, action);
15266 void PlayLevelSound_MM(int xx, int yy, int element_mm, int action_mm)
15268 int element = map_element_MM_to_RND(element_mm);
15269 int action = map_action_MM_to_RND(action_mm);
15271 int x = xx - offset;
15272 int y = yy - offset;
15274 if (!IS_MM_ELEMENT(element))
15275 element = EL_MM_DEFAULT;
15277 PlayLevelSoundElementAction(x, y, element, action);
15280 void PlaySound_MM(int sound_mm)
15282 int sound = map_sound_MM_to_RND(sound_mm);
15284 if (sound == SND_UNDEFINED)
15290 void PlaySoundLoop_MM(int sound_mm)
15292 int sound = map_sound_MM_to_RND(sound_mm);
15294 if (sound == SND_UNDEFINED)
15297 PlaySoundLoop(sound);
15300 void StopSound_MM(int sound_mm)
15302 int sound = map_sound_MM_to_RND(sound_mm);
15304 if (sound == SND_UNDEFINED)
15310 void RaiseScore(int value)
15312 game.score += value;
15314 game_panel_controls[GAME_PANEL_SCORE].value = game.score;
15316 DisplayGameControlValues();
15319 void RaiseScoreElement(int element)
15324 case EL_BD_DIAMOND:
15325 case EL_EMERALD_YELLOW:
15326 case EL_EMERALD_RED:
15327 case EL_EMERALD_PURPLE:
15328 case EL_SP_INFOTRON:
15329 RaiseScore(level.score[SC_EMERALD]);
15332 RaiseScore(level.score[SC_DIAMOND]);
15335 RaiseScore(level.score[SC_CRYSTAL]);
15338 RaiseScore(level.score[SC_PEARL]);
15341 case EL_BD_BUTTERFLY:
15342 case EL_SP_ELECTRON:
15343 RaiseScore(level.score[SC_BUG]);
15346 case EL_BD_FIREFLY:
15347 case EL_SP_SNIKSNAK:
15348 RaiseScore(level.score[SC_SPACESHIP]);
15351 case EL_DARK_YAMYAM:
15352 RaiseScore(level.score[SC_YAMYAM]);
15355 RaiseScore(level.score[SC_ROBOT]);
15358 RaiseScore(level.score[SC_PACMAN]);
15361 RaiseScore(level.score[SC_NUT]);
15364 case EL_EM_DYNAMITE:
15365 case EL_SP_DISK_RED:
15366 case EL_DYNABOMB_INCREASE_NUMBER:
15367 case EL_DYNABOMB_INCREASE_SIZE:
15368 case EL_DYNABOMB_INCREASE_POWER:
15369 RaiseScore(level.score[SC_DYNAMITE]);
15371 case EL_SHIELD_NORMAL:
15372 case EL_SHIELD_DEADLY:
15373 RaiseScore(level.score[SC_SHIELD]);
15375 case EL_EXTRA_TIME:
15376 RaiseScore(level.extra_time_score);
15390 case EL_DC_KEY_WHITE:
15391 RaiseScore(level.score[SC_KEY]);
15394 RaiseScore(element_info[element].collect_score);
15399 void RequestQuitGameExt(boolean skip_request, boolean quick_quit, char *message)
15401 if (skip_request || Request(message, REQ_ASK | REQ_STAY_CLOSED))
15405 // prevent short reactivation of overlay buttons while closing door
15406 SetOverlayActive(FALSE);
15408 // door may still be open due to skipped or envelope style request
15409 CloseDoor(DOOR_CLOSE_1);
15412 if (network.enabled)
15413 SendToServer_StopPlaying(NETWORK_STOP_BY_PLAYER);
15417 FadeSkipNextFadeIn();
15419 SetGameStatus(GAME_MODE_MAIN);
15424 else // continue playing the game
15426 if (tape.playing && tape.deactivate_display)
15427 TapeDeactivateDisplayOff(TRUE);
15429 OpenDoor(DOOR_OPEN_1 | DOOR_COPY_BACK);
15431 if (tape.playing && tape.deactivate_display)
15432 TapeDeactivateDisplayOn();
15436 void RequestQuitGame(boolean escape_key_pressed)
15438 boolean ask_on_escape = (setup.ask_on_escape && setup.ask_on_quit_game);
15439 boolean quick_quit = ((escape_key_pressed && !ask_on_escape) ||
15440 level_editor_test_game);
15441 boolean skip_request = (game.all_players_gone || !setup.ask_on_quit_game ||
15444 RequestQuitGameExt(skip_request, quick_quit,
15445 "Do you really want to quit the game?");
15448 void RequestRestartGame(char *message)
15450 game.restart_game_message = NULL;
15452 boolean has_started_game = hasStartedNetworkGame();
15453 int request_mode = (has_started_game ? REQ_ASK : REQ_CONFIRM);
15455 if (Request(message, request_mode | REQ_STAY_CLOSED) && has_started_game)
15457 StartGameActions(network.enabled, setup.autorecord, level.random_seed);
15461 // needed in case of envelope request to close game panel
15462 CloseDoor(DOOR_CLOSE_1);
15464 SetGameStatus(GAME_MODE_MAIN);
15470 void CheckGameOver(void)
15472 static boolean last_game_over = FALSE;
15473 static int game_over_delay = 0;
15474 int game_over_delay_value = 50;
15475 boolean game_over = checkGameFailed();
15477 // do not handle game over if request dialog is already active
15478 if (game.request_active)
15481 // do not ask to play again if game was never actually played
15482 if (!game.GamePlayed)
15487 last_game_over = FALSE;
15488 game_over_delay = game_over_delay_value;
15493 if (game_over_delay > 0)
15500 if (last_game_over != game_over)
15501 game.restart_game_message = (hasStartedNetworkGame() ?
15502 "Game over! Play it again?" :
15505 last_game_over = game_over;
15508 boolean checkGameSolved(void)
15510 // set for all game engines if level was solved
15511 return game.LevelSolved_GameEnd;
15514 boolean checkGameFailed(void)
15516 if (level.game_engine_type == GAME_ENGINE_TYPE_EM)
15517 return (game_em.game_over && !game_em.level_solved);
15518 else if (level.game_engine_type == GAME_ENGINE_TYPE_SP)
15519 return (game_sp.game_over && !game_sp.level_solved);
15520 else if (level.game_engine_type == GAME_ENGINE_TYPE_MM)
15521 return (game_mm.game_over && !game_mm.level_solved);
15522 else // GAME_ENGINE_TYPE_RND
15523 return (game.GameOver && !game.LevelSolved);
15526 boolean checkGameEnded(void)
15528 return (checkGameSolved() || checkGameFailed());
15532 // ----------------------------------------------------------------------------
15533 // random generator functions
15534 // ----------------------------------------------------------------------------
15536 unsigned int InitEngineRandom_RND(int seed)
15538 game.num_random_calls = 0;
15540 return InitEngineRandom(seed);
15543 unsigned int RND(int max)
15547 game.num_random_calls++;
15549 return GetEngineRandom(max);
15556 // ----------------------------------------------------------------------------
15557 // game engine snapshot handling functions
15558 // ----------------------------------------------------------------------------
15560 struct EngineSnapshotInfo
15562 // runtime values for custom element collect score
15563 int collect_score[NUM_CUSTOM_ELEMENTS];
15565 // runtime values for group element choice position
15566 int choice_pos[NUM_GROUP_ELEMENTS];
15568 // runtime values for belt position animations
15569 int belt_graphic[4][NUM_BELT_PARTS];
15570 int belt_anim_mode[4][NUM_BELT_PARTS];
15573 static struct EngineSnapshotInfo engine_snapshot_rnd;
15574 static char *snapshot_level_identifier = NULL;
15575 static int snapshot_level_nr = -1;
15577 static void SaveEngineSnapshotValues_RND(void)
15579 static int belt_base_active_element[4] =
15581 EL_CONVEYOR_BELT_1_LEFT_ACTIVE,
15582 EL_CONVEYOR_BELT_2_LEFT_ACTIVE,
15583 EL_CONVEYOR_BELT_3_LEFT_ACTIVE,
15584 EL_CONVEYOR_BELT_4_LEFT_ACTIVE
15588 for (i = 0; i < NUM_CUSTOM_ELEMENTS; i++)
15590 int element = EL_CUSTOM_START + i;
15592 engine_snapshot_rnd.collect_score[i] = element_info[element].collect_score;
15595 for (i = 0; i < NUM_GROUP_ELEMENTS; i++)
15597 int element = EL_GROUP_START + i;
15599 engine_snapshot_rnd.choice_pos[i] = element_info[element].group->choice_pos;
15602 for (i = 0; i < 4; i++)
15604 for (j = 0; j < NUM_BELT_PARTS; j++)
15606 int element = belt_base_active_element[i] + j;
15607 int graphic = el2img(element);
15608 int anim_mode = graphic_info[graphic].anim_mode;
15610 engine_snapshot_rnd.belt_graphic[i][j] = graphic;
15611 engine_snapshot_rnd.belt_anim_mode[i][j] = anim_mode;
15616 static void LoadEngineSnapshotValues_RND(void)
15618 unsigned int num_random_calls = game.num_random_calls;
15621 for (i = 0; i < NUM_CUSTOM_ELEMENTS; i++)
15623 int element = EL_CUSTOM_START + i;
15625 element_info[element].collect_score = engine_snapshot_rnd.collect_score[i];
15628 for (i = 0; i < NUM_GROUP_ELEMENTS; i++)
15630 int element = EL_GROUP_START + i;
15632 element_info[element].group->choice_pos = engine_snapshot_rnd.choice_pos[i];
15635 for (i = 0; i < 4; i++)
15637 for (j = 0; j < NUM_BELT_PARTS; j++)
15639 int graphic = engine_snapshot_rnd.belt_graphic[i][j];
15640 int anim_mode = engine_snapshot_rnd.belt_anim_mode[i][j];
15642 graphic_info[graphic].anim_mode = anim_mode;
15646 if (level.game_engine_type == GAME_ENGINE_TYPE_RND)
15648 InitRND(tape.random_seed);
15649 for (i = 0; i < num_random_calls; i++)
15653 if (game.num_random_calls != num_random_calls)
15655 Error("number of random calls out of sync");
15656 Error("number of random calls should be %d", num_random_calls);
15657 Error("number of random calls is %d", game.num_random_calls);
15659 Fail("this should not happen -- please debug");
15663 void FreeEngineSnapshotSingle(void)
15665 FreeSnapshotSingle();
15667 setString(&snapshot_level_identifier, NULL);
15668 snapshot_level_nr = -1;
15671 void FreeEngineSnapshotList(void)
15673 FreeSnapshotList();
15676 static ListNode *SaveEngineSnapshotBuffers(void)
15678 ListNode *buffers = NULL;
15680 // copy some special values to a structure better suited for the snapshot
15682 if (level.game_engine_type == GAME_ENGINE_TYPE_RND)
15683 SaveEngineSnapshotValues_RND();
15684 if (level.game_engine_type == GAME_ENGINE_TYPE_EM)
15685 SaveEngineSnapshotValues_EM();
15686 if (level.game_engine_type == GAME_ENGINE_TYPE_SP)
15687 SaveEngineSnapshotValues_SP(&buffers);
15688 if (level.game_engine_type == GAME_ENGINE_TYPE_MM)
15689 SaveEngineSnapshotValues_MM(&buffers);
15691 // save values stored in special snapshot structure
15693 if (level.game_engine_type == GAME_ENGINE_TYPE_RND)
15694 SaveSnapshotBuffer(&buffers, ARGS_ADDRESS_AND_SIZEOF(engine_snapshot_rnd));
15695 if (level.game_engine_type == GAME_ENGINE_TYPE_EM)
15696 SaveSnapshotBuffer(&buffers, ARGS_ADDRESS_AND_SIZEOF(engine_snapshot_em));
15697 if (level.game_engine_type == GAME_ENGINE_TYPE_SP)
15698 SaveSnapshotBuffer(&buffers, ARGS_ADDRESS_AND_SIZEOF(engine_snapshot_sp));
15699 if (level.game_engine_type == GAME_ENGINE_TYPE_MM)
15700 SaveSnapshotBuffer(&buffers, ARGS_ADDRESS_AND_SIZEOF(engine_snapshot_mm));
15702 // save further RND engine values
15704 SaveSnapshotBuffer(&buffers, ARGS_ADDRESS_AND_SIZEOF(stored_player));
15705 SaveSnapshotBuffer(&buffers, ARGS_ADDRESS_AND_SIZEOF(game));
15706 SaveSnapshotBuffer(&buffers, ARGS_ADDRESS_AND_SIZEOF(tape));
15708 SaveSnapshotBuffer(&buffers, ARGS_ADDRESS_AND_SIZEOF(FrameCounter));
15709 SaveSnapshotBuffer(&buffers, ARGS_ADDRESS_AND_SIZEOF(TimeFrames));
15710 SaveSnapshotBuffer(&buffers, ARGS_ADDRESS_AND_SIZEOF(TimePlayed));
15711 SaveSnapshotBuffer(&buffers, ARGS_ADDRESS_AND_SIZEOF(TimeLeft));
15712 SaveSnapshotBuffer(&buffers, ARGS_ADDRESS_AND_SIZEOF(TapeTime));
15714 SaveSnapshotBuffer(&buffers, ARGS_ADDRESS_AND_SIZEOF(ScreenMovDir));
15715 SaveSnapshotBuffer(&buffers, ARGS_ADDRESS_AND_SIZEOF(ScreenMovPos));
15716 SaveSnapshotBuffer(&buffers, ARGS_ADDRESS_AND_SIZEOF(ScreenGfxPos));
15718 SaveSnapshotBuffer(&buffers, ARGS_ADDRESS_AND_SIZEOF(ScrollStepSize));
15720 SaveSnapshotBuffer(&buffers, ARGS_ADDRESS_AND_SIZEOF(AmoebaCnt));
15721 SaveSnapshotBuffer(&buffers, ARGS_ADDRESS_AND_SIZEOF(AmoebaCnt2));
15723 SaveSnapshotBuffer(&buffers, ARGS_ADDRESS_AND_SIZEOF(Tile));
15724 SaveSnapshotBuffer(&buffers, ARGS_ADDRESS_AND_SIZEOF(MovPos));
15725 SaveSnapshotBuffer(&buffers, ARGS_ADDRESS_AND_SIZEOF(MovDir));
15726 SaveSnapshotBuffer(&buffers, ARGS_ADDRESS_AND_SIZEOF(MovDelay));
15727 SaveSnapshotBuffer(&buffers, ARGS_ADDRESS_AND_SIZEOF(ChangeDelay));
15728 SaveSnapshotBuffer(&buffers, ARGS_ADDRESS_AND_SIZEOF(ChangePage));
15729 SaveSnapshotBuffer(&buffers, ARGS_ADDRESS_AND_SIZEOF(CustomValue));
15730 SaveSnapshotBuffer(&buffers, ARGS_ADDRESS_AND_SIZEOF(Store));
15731 SaveSnapshotBuffer(&buffers, ARGS_ADDRESS_AND_SIZEOF(Store2));
15732 SaveSnapshotBuffer(&buffers, ARGS_ADDRESS_AND_SIZEOF(StorePlayer));
15733 SaveSnapshotBuffer(&buffers, ARGS_ADDRESS_AND_SIZEOF(Back));
15734 SaveSnapshotBuffer(&buffers, ARGS_ADDRESS_AND_SIZEOF(AmoebaNr));
15735 SaveSnapshotBuffer(&buffers, ARGS_ADDRESS_AND_SIZEOF(WasJustMoving));
15736 SaveSnapshotBuffer(&buffers, ARGS_ADDRESS_AND_SIZEOF(WasJustFalling));
15737 SaveSnapshotBuffer(&buffers, ARGS_ADDRESS_AND_SIZEOF(CheckCollision));
15738 SaveSnapshotBuffer(&buffers, ARGS_ADDRESS_AND_SIZEOF(CheckImpact));
15739 SaveSnapshotBuffer(&buffers, ARGS_ADDRESS_AND_SIZEOF(Stop));
15740 SaveSnapshotBuffer(&buffers, ARGS_ADDRESS_AND_SIZEOF(Pushed));
15742 SaveSnapshotBuffer(&buffers, ARGS_ADDRESS_AND_SIZEOF(ChangeCount));
15743 SaveSnapshotBuffer(&buffers, ARGS_ADDRESS_AND_SIZEOF(ChangeEvent));
15745 SaveSnapshotBuffer(&buffers, ARGS_ADDRESS_AND_SIZEOF(ExplodePhase));
15746 SaveSnapshotBuffer(&buffers, ARGS_ADDRESS_AND_SIZEOF(ExplodeDelay));
15747 SaveSnapshotBuffer(&buffers, ARGS_ADDRESS_AND_SIZEOF(ExplodeField));
15749 SaveSnapshotBuffer(&buffers, ARGS_ADDRESS_AND_SIZEOF(RunnerVisit));
15750 SaveSnapshotBuffer(&buffers, ARGS_ADDRESS_AND_SIZEOF(PlayerVisit));
15752 SaveSnapshotBuffer(&buffers, ARGS_ADDRESS_AND_SIZEOF(GfxFrame));
15753 SaveSnapshotBuffer(&buffers, ARGS_ADDRESS_AND_SIZEOF(GfxRandom));
15754 SaveSnapshotBuffer(&buffers, ARGS_ADDRESS_AND_SIZEOF(GfxElement));
15755 SaveSnapshotBuffer(&buffers, ARGS_ADDRESS_AND_SIZEOF(GfxAction));
15756 SaveSnapshotBuffer(&buffers, ARGS_ADDRESS_AND_SIZEOF(GfxDir));
15758 SaveSnapshotBuffer(&buffers, ARGS_ADDRESS_AND_SIZEOF(scroll_x));
15759 SaveSnapshotBuffer(&buffers, ARGS_ADDRESS_AND_SIZEOF(scroll_y));
15762 ListNode *node = engine_snapshot_list_rnd;
15765 while (node != NULL)
15767 num_bytes += ((struct EngineSnapshotNodeInfo *)node->content)->size;
15772 Debug("game:playing:SaveEngineSnapshotBuffers",
15773 "size of engine snapshot: %d bytes", num_bytes);
15779 void SaveEngineSnapshotSingle(void)
15781 ListNode *buffers = SaveEngineSnapshotBuffers();
15783 // finally save all snapshot buffers to single snapshot
15784 SaveSnapshotSingle(buffers);
15786 // save level identification information
15787 setString(&snapshot_level_identifier, leveldir_current->identifier);
15788 snapshot_level_nr = level_nr;
15791 boolean CheckSaveEngineSnapshotToList(void)
15793 boolean save_snapshot =
15794 ((game.snapshot.mode == SNAPSHOT_MODE_EVERY_STEP) ||
15795 (game.snapshot.mode == SNAPSHOT_MODE_EVERY_MOVE &&
15796 game.snapshot.changed_action) ||
15797 (game.snapshot.mode == SNAPSHOT_MODE_EVERY_COLLECT &&
15798 game.snapshot.collected_item));
15800 game.snapshot.changed_action = FALSE;
15801 game.snapshot.collected_item = FALSE;
15802 game.snapshot.save_snapshot = save_snapshot;
15804 return save_snapshot;
15807 void SaveEngineSnapshotToList(void)
15809 if (game.snapshot.mode == SNAPSHOT_MODE_OFF ||
15813 ListNode *buffers = SaveEngineSnapshotBuffers();
15815 // finally save all snapshot buffers to snapshot list
15816 SaveSnapshotToList(buffers);
15819 void SaveEngineSnapshotToListInitial(void)
15821 FreeEngineSnapshotList();
15823 SaveEngineSnapshotToList();
15826 static void LoadEngineSnapshotValues(void)
15828 // restore special values from snapshot structure
15830 if (level.game_engine_type == GAME_ENGINE_TYPE_RND)
15831 LoadEngineSnapshotValues_RND();
15832 if (level.game_engine_type == GAME_ENGINE_TYPE_EM)
15833 LoadEngineSnapshotValues_EM();
15834 if (level.game_engine_type == GAME_ENGINE_TYPE_SP)
15835 LoadEngineSnapshotValues_SP();
15836 if (level.game_engine_type == GAME_ENGINE_TYPE_MM)
15837 LoadEngineSnapshotValues_MM();
15840 void LoadEngineSnapshotSingle(void)
15842 LoadSnapshotSingle();
15844 LoadEngineSnapshotValues();
15847 static void LoadEngineSnapshot_Undo(int steps)
15849 LoadSnapshotFromList_Older(steps);
15851 LoadEngineSnapshotValues();
15854 static void LoadEngineSnapshot_Redo(int steps)
15856 LoadSnapshotFromList_Newer(steps);
15858 LoadEngineSnapshotValues();
15861 boolean CheckEngineSnapshotSingle(void)
15863 return (strEqual(snapshot_level_identifier, leveldir_current->identifier) &&
15864 snapshot_level_nr == level_nr);
15867 boolean CheckEngineSnapshotList(void)
15869 return CheckSnapshotList();
15873 // ---------- new game button stuff -------------------------------------------
15880 boolean *setup_value;
15881 boolean allowed_on_tape;
15882 boolean is_touch_button;
15884 } gamebutton_info[NUM_GAME_BUTTONS] =
15887 IMG_GFX_GAME_BUTTON_STOP, &game.button.stop,
15888 GAME_CTRL_ID_STOP, NULL,
15889 TRUE, FALSE, "stop game"
15892 IMG_GFX_GAME_BUTTON_PAUSE, &game.button.pause,
15893 GAME_CTRL_ID_PAUSE, NULL,
15894 TRUE, FALSE, "pause game"
15897 IMG_GFX_GAME_BUTTON_PLAY, &game.button.play,
15898 GAME_CTRL_ID_PLAY, NULL,
15899 TRUE, FALSE, "play game"
15902 IMG_GFX_GAME_BUTTON_UNDO, &game.button.undo,
15903 GAME_CTRL_ID_UNDO, NULL,
15904 TRUE, FALSE, "undo step"
15907 IMG_GFX_GAME_BUTTON_REDO, &game.button.redo,
15908 GAME_CTRL_ID_REDO, NULL,
15909 TRUE, FALSE, "redo step"
15912 IMG_GFX_GAME_BUTTON_SAVE, &game.button.save,
15913 GAME_CTRL_ID_SAVE, NULL,
15914 TRUE, FALSE, "save game"
15917 IMG_GFX_GAME_BUTTON_PAUSE2, &game.button.pause2,
15918 GAME_CTRL_ID_PAUSE2, NULL,
15919 TRUE, FALSE, "pause game"
15922 IMG_GFX_GAME_BUTTON_LOAD, &game.button.load,
15923 GAME_CTRL_ID_LOAD, NULL,
15924 TRUE, FALSE, "load game"
15927 IMG_GFX_GAME_BUTTON_PANEL_STOP, &game.button.panel_stop,
15928 GAME_CTRL_ID_PANEL_STOP, NULL,
15929 FALSE, FALSE, "stop game"
15932 IMG_GFX_GAME_BUTTON_PANEL_PAUSE, &game.button.panel_pause,
15933 GAME_CTRL_ID_PANEL_PAUSE, NULL,
15934 FALSE, FALSE, "pause game"
15937 IMG_GFX_GAME_BUTTON_PANEL_PLAY, &game.button.panel_play,
15938 GAME_CTRL_ID_PANEL_PLAY, NULL,
15939 FALSE, FALSE, "play game"
15942 IMG_GFX_GAME_BUTTON_TOUCH_STOP, &game.button.touch_stop,
15943 GAME_CTRL_ID_TOUCH_STOP, NULL,
15944 FALSE, TRUE, "stop game"
15947 IMG_GFX_GAME_BUTTON_TOUCH_PAUSE, &game.button.touch_pause,
15948 GAME_CTRL_ID_TOUCH_PAUSE, NULL,
15949 FALSE, TRUE, "pause game"
15952 IMG_GFX_GAME_BUTTON_SOUND_MUSIC, &game.button.sound_music,
15953 SOUND_CTRL_ID_MUSIC, &setup.sound_music,
15954 TRUE, FALSE, "background music on/off"
15957 IMG_GFX_GAME_BUTTON_SOUND_LOOPS, &game.button.sound_loops,
15958 SOUND_CTRL_ID_LOOPS, &setup.sound_loops,
15959 TRUE, FALSE, "sound loops on/off"
15962 IMG_GFX_GAME_BUTTON_SOUND_SIMPLE, &game.button.sound_simple,
15963 SOUND_CTRL_ID_SIMPLE, &setup.sound_simple,
15964 TRUE, FALSE, "normal sounds on/off"
15967 IMG_GFX_GAME_BUTTON_PANEL_SOUND_MUSIC, &game.button.panel_sound_music,
15968 SOUND_CTRL_ID_PANEL_MUSIC, &setup.sound_music,
15969 FALSE, FALSE, "background music on/off"
15972 IMG_GFX_GAME_BUTTON_PANEL_SOUND_LOOPS, &game.button.panel_sound_loops,
15973 SOUND_CTRL_ID_PANEL_LOOPS, &setup.sound_loops,
15974 FALSE, FALSE, "sound loops on/off"
15977 IMG_GFX_GAME_BUTTON_PANEL_SOUND_SIMPLE, &game.button.panel_sound_simple,
15978 SOUND_CTRL_ID_PANEL_SIMPLE, &setup.sound_simple,
15979 FALSE, FALSE, "normal sounds on/off"
15983 void CreateGameButtons(void)
15987 for (i = 0; i < NUM_GAME_BUTTONS; i++)
15989 int graphic = gamebutton_info[i].graphic;
15990 struct GraphicInfo *gfx = &graphic_info[graphic];
15991 struct XY *pos = gamebutton_info[i].pos;
15992 struct GadgetInfo *gi;
15995 unsigned int event_mask;
15996 boolean is_touch_button = gamebutton_info[i].is_touch_button;
15997 boolean allowed_on_tape = gamebutton_info[i].allowed_on_tape;
15998 boolean on_tape = (tape.show_game_buttons && allowed_on_tape);
15999 int base_x = (is_touch_button ? 0 : on_tape ? VX : DX);
16000 int base_y = (is_touch_button ? 0 : on_tape ? VY : DY);
16001 int gd_x = gfx->src_x;
16002 int gd_y = gfx->src_y;
16003 int gd_xp = gfx->src_x + gfx->pressed_xoffset;
16004 int gd_yp = gfx->src_y + gfx->pressed_yoffset;
16005 int gd_xa = gfx->src_x + gfx->active_xoffset;
16006 int gd_ya = gfx->src_y + gfx->active_yoffset;
16007 int gd_xap = gfx->src_x + gfx->active_xoffset + gfx->pressed_xoffset;
16008 int gd_yap = gfx->src_y + gfx->active_yoffset + gfx->pressed_yoffset;
16009 int x = (is_touch_button ? pos->x : GDI_ACTIVE_POS(pos->x));
16010 int y = (is_touch_button ? pos->y : GDI_ACTIVE_POS(pos->y));
16013 if (gfx->bitmap == NULL)
16015 game_gadget[id] = NULL;
16020 if (id == GAME_CTRL_ID_STOP ||
16021 id == GAME_CTRL_ID_PANEL_STOP ||
16022 id == GAME_CTRL_ID_TOUCH_STOP ||
16023 id == GAME_CTRL_ID_PLAY ||
16024 id == GAME_CTRL_ID_PANEL_PLAY ||
16025 id == GAME_CTRL_ID_SAVE ||
16026 id == GAME_CTRL_ID_LOAD)
16028 button_type = GD_TYPE_NORMAL_BUTTON;
16030 event_mask = GD_EVENT_RELEASED;
16032 else if (id == GAME_CTRL_ID_UNDO ||
16033 id == GAME_CTRL_ID_REDO)
16035 button_type = GD_TYPE_NORMAL_BUTTON;
16037 event_mask = GD_EVENT_PRESSED | GD_EVENT_REPEATED;
16041 button_type = GD_TYPE_CHECK_BUTTON;
16042 checked = (gamebutton_info[i].setup_value != NULL ?
16043 *gamebutton_info[i].setup_value : FALSE);
16044 event_mask = GD_EVENT_PRESSED;
16047 gi = CreateGadget(GDI_CUSTOM_ID, id,
16048 GDI_IMAGE_ID, graphic,
16049 GDI_INFO_TEXT, gamebutton_info[i].infotext,
16052 GDI_WIDTH, gfx->width,
16053 GDI_HEIGHT, gfx->height,
16054 GDI_TYPE, button_type,
16055 GDI_STATE, GD_BUTTON_UNPRESSED,
16056 GDI_CHECKED, checked,
16057 GDI_DESIGN_UNPRESSED, gfx->bitmap, gd_x, gd_y,
16058 GDI_DESIGN_PRESSED, gfx->bitmap, gd_xp, gd_yp,
16059 GDI_ALT_DESIGN_UNPRESSED, gfx->bitmap, gd_xa, gd_ya,
16060 GDI_ALT_DESIGN_PRESSED, gfx->bitmap, gd_xap, gd_yap,
16061 GDI_DIRECT_DRAW, FALSE,
16062 GDI_OVERLAY_TOUCH_BUTTON, is_touch_button,
16063 GDI_EVENT_MASK, event_mask,
16064 GDI_CALLBACK_ACTION, HandleGameButtons,
16068 Fail("cannot create gadget");
16070 game_gadget[id] = gi;
16074 void FreeGameButtons(void)
16078 for (i = 0; i < NUM_GAME_BUTTONS; i++)
16079 FreeGadget(game_gadget[i]);
16082 static void UnmapGameButtonsAtSamePosition(int id)
16086 for (i = 0; i < NUM_GAME_BUTTONS; i++)
16088 gamebutton_info[i].pos->x == gamebutton_info[id].pos->x &&
16089 gamebutton_info[i].pos->y == gamebutton_info[id].pos->y)
16090 UnmapGadget(game_gadget[i]);
16093 static void UnmapGameButtonsAtSamePosition_All(void)
16095 if (setup.show_snapshot_buttons)
16097 UnmapGameButtonsAtSamePosition(GAME_CTRL_ID_SAVE);
16098 UnmapGameButtonsAtSamePosition(GAME_CTRL_ID_PAUSE2);
16099 UnmapGameButtonsAtSamePosition(GAME_CTRL_ID_LOAD);
16103 UnmapGameButtonsAtSamePosition(GAME_CTRL_ID_STOP);
16104 UnmapGameButtonsAtSamePosition(GAME_CTRL_ID_PAUSE);
16105 UnmapGameButtonsAtSamePosition(GAME_CTRL_ID_PLAY);
16107 UnmapGameButtonsAtSamePosition(GAME_CTRL_ID_PANEL_STOP);
16108 UnmapGameButtonsAtSamePosition(GAME_CTRL_ID_PANEL_PAUSE);
16109 UnmapGameButtonsAtSamePosition(GAME_CTRL_ID_PANEL_PLAY);
16113 static void MapGameButtonsAtSamePosition(int id)
16117 for (i = 0; i < NUM_GAME_BUTTONS; i++)
16119 gamebutton_info[i].pos->x == gamebutton_info[id].pos->x &&
16120 gamebutton_info[i].pos->y == gamebutton_info[id].pos->y)
16121 MapGadget(game_gadget[i]);
16123 UnmapGameButtonsAtSamePosition_All();
16126 void MapUndoRedoButtons(void)
16128 UnmapGameButtonsAtSamePosition(GAME_CTRL_ID_UNDO);
16129 UnmapGameButtonsAtSamePosition(GAME_CTRL_ID_REDO);
16131 MapGadget(game_gadget[GAME_CTRL_ID_UNDO]);
16132 MapGadget(game_gadget[GAME_CTRL_ID_REDO]);
16135 void UnmapUndoRedoButtons(void)
16137 UnmapGadget(game_gadget[GAME_CTRL_ID_UNDO]);
16138 UnmapGadget(game_gadget[GAME_CTRL_ID_REDO]);
16140 MapGameButtonsAtSamePosition(GAME_CTRL_ID_UNDO);
16141 MapGameButtonsAtSamePosition(GAME_CTRL_ID_REDO);
16144 void ModifyPauseButtons(void)
16148 GAME_CTRL_ID_PAUSE,
16149 GAME_CTRL_ID_PAUSE2,
16150 GAME_CTRL_ID_PANEL_PAUSE,
16151 GAME_CTRL_ID_TOUCH_PAUSE,
16156 for (i = 0; ids[i] > -1; i++)
16157 ModifyGadget(game_gadget[ids[i]], GDI_CHECKED, tape.pausing, GDI_END);
16160 static void MapGameButtonsExt(boolean on_tape)
16164 for (i = 0; i < NUM_GAME_BUTTONS; i++)
16165 if ((!on_tape || gamebutton_info[i].allowed_on_tape) &&
16166 i != GAME_CTRL_ID_UNDO &&
16167 i != GAME_CTRL_ID_REDO)
16168 MapGadget(game_gadget[i]);
16170 UnmapGameButtonsAtSamePosition_All();
16172 RedrawGameButtons();
16175 static void UnmapGameButtonsExt(boolean on_tape)
16179 for (i = 0; i < NUM_GAME_BUTTONS; i++)
16180 if (!on_tape || gamebutton_info[i].allowed_on_tape)
16181 UnmapGadget(game_gadget[i]);
16184 static void RedrawGameButtonsExt(boolean on_tape)
16188 for (i = 0; i < NUM_GAME_BUTTONS; i++)
16189 if (!on_tape || gamebutton_info[i].allowed_on_tape)
16190 RedrawGadget(game_gadget[i]);
16193 static void SetGadgetState(struct GadgetInfo *gi, boolean state)
16198 gi->checked = state;
16201 static void RedrawSoundButtonGadget(int id)
16203 int id2 = (id == SOUND_CTRL_ID_MUSIC ? SOUND_CTRL_ID_PANEL_MUSIC :
16204 id == SOUND_CTRL_ID_LOOPS ? SOUND_CTRL_ID_PANEL_LOOPS :
16205 id == SOUND_CTRL_ID_SIMPLE ? SOUND_CTRL_ID_PANEL_SIMPLE :
16206 id == SOUND_CTRL_ID_PANEL_MUSIC ? SOUND_CTRL_ID_MUSIC :
16207 id == SOUND_CTRL_ID_PANEL_LOOPS ? SOUND_CTRL_ID_LOOPS :
16208 id == SOUND_CTRL_ID_PANEL_SIMPLE ? SOUND_CTRL_ID_SIMPLE :
16211 SetGadgetState(game_gadget[id2], *gamebutton_info[id2].setup_value);
16212 RedrawGadget(game_gadget[id2]);
16215 void MapGameButtons(void)
16217 MapGameButtonsExt(FALSE);
16220 void UnmapGameButtons(void)
16222 UnmapGameButtonsExt(FALSE);
16225 void RedrawGameButtons(void)
16227 RedrawGameButtonsExt(FALSE);
16230 void MapGameButtonsOnTape(void)
16232 MapGameButtonsExt(TRUE);
16235 void UnmapGameButtonsOnTape(void)
16237 UnmapGameButtonsExt(TRUE);
16240 void RedrawGameButtonsOnTape(void)
16242 RedrawGameButtonsExt(TRUE);
16245 static void GameUndoRedoExt(void)
16247 ClearPlayerAction();
16249 tape.pausing = TRUE;
16252 UpdateAndDisplayGameControlValues();
16254 DrawCompleteVideoDisplay();
16255 DrawVideoDisplay(VIDEO_STATE_TIME_ON, TapeTime);
16256 DrawVideoDisplay(VIDEO_STATE_FRAME_ON, FrameCounter);
16257 DrawVideoDisplay(VIDEO_STATE_1STEP(tape.single_step), 0);
16262 static void GameUndo(int steps)
16264 if (!CheckEngineSnapshotList())
16267 LoadEngineSnapshot_Undo(steps);
16272 static void GameRedo(int steps)
16274 if (!CheckEngineSnapshotList())
16277 LoadEngineSnapshot_Redo(steps);
16282 static void HandleGameButtonsExt(int id, int button)
16284 static boolean game_undo_executed = FALSE;
16285 int steps = BUTTON_STEPSIZE(button);
16286 boolean handle_game_buttons =
16287 (game_status == GAME_MODE_PLAYING ||
16288 (game_status == GAME_MODE_MAIN && tape.show_game_buttons));
16290 if (!handle_game_buttons)
16295 case GAME_CTRL_ID_STOP:
16296 case GAME_CTRL_ID_PANEL_STOP:
16297 case GAME_CTRL_ID_TOUCH_STOP:
16298 if (game_status == GAME_MODE_MAIN)
16304 RequestQuitGame(FALSE);
16308 case GAME_CTRL_ID_PAUSE:
16309 case GAME_CTRL_ID_PAUSE2:
16310 case GAME_CTRL_ID_PANEL_PAUSE:
16311 case GAME_CTRL_ID_TOUCH_PAUSE:
16312 if (network.enabled && game_status == GAME_MODE_PLAYING)
16315 SendToServer_ContinuePlaying();
16317 SendToServer_PausePlaying();
16320 TapeTogglePause(TAPE_TOGGLE_MANUAL);
16322 game_undo_executed = FALSE;
16326 case GAME_CTRL_ID_PLAY:
16327 case GAME_CTRL_ID_PANEL_PLAY:
16328 if (game_status == GAME_MODE_MAIN)
16330 StartGameActions(network.enabled, setup.autorecord, level.random_seed);
16332 else if (tape.pausing)
16334 if (network.enabled)
16335 SendToServer_ContinuePlaying();
16337 TapeTogglePause(TAPE_TOGGLE_MANUAL | TAPE_TOGGLE_PLAY_PAUSE);
16341 case GAME_CTRL_ID_UNDO:
16342 // Important: When using "save snapshot when collecting an item" mode,
16343 // load last (current) snapshot for first "undo" after pressing "pause"
16344 // (else the last-but-one snapshot would be loaded, because the snapshot
16345 // pointer already points to the last snapshot when pressing "pause",
16346 // which is fine for "every step/move" mode, but not for "every collect")
16347 if (game.snapshot.mode == SNAPSHOT_MODE_EVERY_COLLECT &&
16348 !game_undo_executed)
16351 game_undo_executed = TRUE;
16356 case GAME_CTRL_ID_REDO:
16360 case GAME_CTRL_ID_SAVE:
16364 case GAME_CTRL_ID_LOAD:
16368 case SOUND_CTRL_ID_MUSIC:
16369 case SOUND_CTRL_ID_PANEL_MUSIC:
16370 if (setup.sound_music)
16372 setup.sound_music = FALSE;
16376 else if (audio.music_available)
16378 setup.sound = setup.sound_music = TRUE;
16380 SetAudioMode(setup.sound);
16382 if (game_status == GAME_MODE_PLAYING)
16386 RedrawSoundButtonGadget(id);
16390 case SOUND_CTRL_ID_LOOPS:
16391 case SOUND_CTRL_ID_PANEL_LOOPS:
16392 if (setup.sound_loops)
16393 setup.sound_loops = FALSE;
16394 else if (audio.loops_available)
16396 setup.sound = setup.sound_loops = TRUE;
16398 SetAudioMode(setup.sound);
16401 RedrawSoundButtonGadget(id);
16405 case SOUND_CTRL_ID_SIMPLE:
16406 case SOUND_CTRL_ID_PANEL_SIMPLE:
16407 if (setup.sound_simple)
16408 setup.sound_simple = FALSE;
16409 else if (audio.sound_available)
16411 setup.sound = setup.sound_simple = TRUE;
16413 SetAudioMode(setup.sound);
16416 RedrawSoundButtonGadget(id);
16425 static void HandleGameButtons(struct GadgetInfo *gi)
16427 HandleGameButtonsExt(gi->custom_id, gi->event.button);
16430 void HandleSoundButtonKeys(Key key)
16432 if (key == setup.shortcut.sound_simple)
16433 ClickOnGadget(game_gadget[SOUND_CTRL_ID_SIMPLE], MB_LEFTBUTTON);
16434 else if (key == setup.shortcut.sound_loops)
16435 ClickOnGadget(game_gadget[SOUND_CTRL_ID_LOOPS], MB_LEFTBUTTON);
16436 else if (key == setup.shortcut.sound_music)
16437 ClickOnGadget(game_gadget[SOUND_CTRL_ID_MUSIC], MB_LEFTBUTTON);