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 CheckNextToConditions(int, int);
1062 static void TestIfPlayerNextToCustomElement(int, int);
1063 static void TestIfPlayerTouchesCustomElement(int, int);
1064 static void TestIfElementNextToCustomElement(int, int);
1065 static void TestIfElementTouchesCustomElement(int, int);
1066 static void TestIfElementHitsCustomElement(int, int, int);
1068 static void HandleElementChange(int, int, int);
1069 static void ExecuteCustomElementAction(int, int, int, int);
1070 static boolean ChangeElement(int, int, int, int);
1072 static boolean CheckTriggeredElementChangeExt(int, int, int, int, int,int,int);
1073 #define CheckTriggeredElementChange(x, y, e, ev) \
1074 CheckTriggeredElementChangeExt(x,y,e,ev, CH_PLAYER_ANY,CH_SIDE_ANY, -1)
1075 #define CheckTriggeredElementChangeByPlayer(x, y, e, ev, p, s) \
1076 CheckTriggeredElementChangeExt(x, y, e, ev, p, s, -1)
1077 #define CheckTriggeredElementChangeBySide(x, y, e, ev, s) \
1078 CheckTriggeredElementChangeExt(x, y, e, ev, CH_PLAYER_ANY, s, -1)
1079 #define CheckTriggeredElementChangeByPage(x, y, e, ev, p) \
1080 CheckTriggeredElementChangeExt(x,y,e,ev, CH_PLAYER_ANY, CH_SIDE_ANY, p)
1081 #define CheckTriggeredElementChangeByMouse(x, y, e, ev, s) \
1082 CheckTriggeredElementChangeExt(x, y, e, ev, CH_PLAYER_ANY, s, -1)
1084 static boolean CheckElementChangeExt(int, int, int, int, int, int, int);
1085 #define CheckElementChange(x, y, e, te, ev) \
1086 CheckElementChangeExt(x, y, e, te, ev, CH_PLAYER_ANY, CH_SIDE_ANY)
1087 #define CheckElementChangeByPlayer(x, y, e, ev, p, s) \
1088 CheckElementChangeExt(x, y, e, EL_EMPTY, ev, p, s)
1089 #define CheckElementChangeBySide(x, y, e, te, ev, s) \
1090 CheckElementChangeExt(x, y, e, te, ev, CH_PLAYER_ANY, s)
1091 #define CheckElementChangeByMouse(x, y, e, ev, s) \
1092 CheckElementChangeExt(x, y, e, EL_UNDEFINED, ev, CH_PLAYER_ANY, s)
1094 static void PlayLevelSound(int, int, int);
1095 static void PlayLevelSoundNearest(int, int, int);
1096 static void PlayLevelSoundAction(int, int, int);
1097 static void PlayLevelSoundElementAction(int, int, int, int);
1098 static void PlayLevelSoundElementActionIfLoop(int, int, int, int);
1099 static void PlayLevelSoundActionIfLoop(int, int, int);
1100 static void StopLevelSoundActionIfLoop(int, int, int);
1101 static void PlayLevelMusic(void);
1102 static void FadeLevelSoundsAndMusic(void);
1104 static void HandleGameButtons(struct GadgetInfo *);
1106 int AmoebaNeighbourNr(int, int);
1107 void AmoebaToDiamond(int, int);
1108 void ContinueMoving(int, int);
1109 void Bang(int, int);
1110 void InitMovDir(int, int);
1111 void InitAmoebaNr(int, int);
1112 void NewHighScore(int, boolean);
1114 void TestIfGoodThingHitsBadThing(int, int, int);
1115 void TestIfBadThingHitsGoodThing(int, int, int);
1116 void TestIfPlayerTouchesBadThing(int, int);
1117 void TestIfPlayerRunsIntoBadThing(int, int, int);
1118 void TestIfBadThingTouchesPlayer(int, int);
1119 void TestIfBadThingRunsIntoPlayer(int, int, int);
1120 void TestIfFriendTouchesBadThing(int, int);
1121 void TestIfBadThingTouchesFriend(int, int);
1122 void TestIfBadThingTouchesOtherBadThing(int, int);
1123 void TestIfGoodThingGetsHitByBadThing(int, int, int);
1125 void KillPlayer(struct PlayerInfo *);
1126 void BuryPlayer(struct PlayerInfo *);
1127 void RemovePlayer(struct PlayerInfo *);
1128 void ExitPlayer(struct PlayerInfo *);
1130 static int getInvisibleActiveFromInvisibleElement(int);
1131 static int getInvisibleFromInvisibleActiveElement(int);
1133 static void TestFieldAfterSnapping(int, int, int, int, int);
1135 static struct GadgetInfo *game_gadget[NUM_GAME_BUTTONS];
1137 // for detection of endless loops, caused by custom element programming
1138 // (using maximal playfield width x 10 is just a rough approximation)
1139 #define MAX_ELEMENT_CHANGE_RECURSION_DEPTH (MAX_PLAYFIELD_WIDTH * 10)
1141 #define RECURSION_LOOP_DETECTION_START(e, rc) \
1143 if (recursion_loop_detected) \
1146 if (recursion_loop_depth > MAX_ELEMENT_CHANGE_RECURSION_DEPTH) \
1148 recursion_loop_detected = TRUE; \
1149 recursion_loop_element = (e); \
1152 recursion_loop_depth++; \
1155 #define RECURSION_LOOP_DETECTION_END() \
1157 recursion_loop_depth--; \
1160 static int recursion_loop_depth;
1161 static boolean recursion_loop_detected;
1162 static boolean recursion_loop_element;
1164 static int map_player_action[MAX_PLAYERS];
1167 // ----------------------------------------------------------------------------
1168 // definition of elements that automatically change to other elements after
1169 // a specified time, eventually calling a function when changing
1170 // ----------------------------------------------------------------------------
1172 // forward declaration for changer functions
1173 static void InitBuggyBase(int, int);
1174 static void WarnBuggyBase(int, int);
1176 static void InitTrap(int, int);
1177 static void ActivateTrap(int, int);
1178 static void ChangeActiveTrap(int, int);
1180 static void InitRobotWheel(int, int);
1181 static void RunRobotWheel(int, int);
1182 static void StopRobotWheel(int, int);
1184 static void InitTimegateWheel(int, int);
1185 static void RunTimegateWheel(int, int);
1187 static void InitMagicBallDelay(int, int);
1188 static void ActivateMagicBall(int, int);
1190 struct ChangingElementInfo
1195 void (*pre_change_function)(int x, int y);
1196 void (*change_function)(int x, int y);
1197 void (*post_change_function)(int x, int y);
1200 static struct ChangingElementInfo change_delay_list[] =
1235 EL_STEEL_EXIT_OPENING,
1243 EL_STEEL_EXIT_CLOSING,
1244 EL_STEEL_EXIT_CLOSED,
1267 EL_EM_STEEL_EXIT_OPENING,
1268 EL_EM_STEEL_EXIT_OPEN,
1275 EL_EM_STEEL_EXIT_CLOSING,
1299 EL_SWITCHGATE_OPENING,
1307 EL_SWITCHGATE_CLOSING,
1308 EL_SWITCHGATE_CLOSED,
1315 EL_TIMEGATE_OPENING,
1323 EL_TIMEGATE_CLOSING,
1332 EL_ACID_SPLASH_LEFT,
1340 EL_ACID_SPLASH_RIGHT,
1349 EL_SP_BUGGY_BASE_ACTIVATING,
1356 EL_SP_BUGGY_BASE_ACTIVATING,
1357 EL_SP_BUGGY_BASE_ACTIVE,
1364 EL_SP_BUGGY_BASE_ACTIVE,
1388 EL_ROBOT_WHEEL_ACTIVE,
1396 EL_TIMEGATE_SWITCH_ACTIVE,
1404 EL_DC_TIMEGATE_SWITCH_ACTIVE,
1405 EL_DC_TIMEGATE_SWITCH,
1412 EL_EMC_MAGIC_BALL_ACTIVE,
1413 EL_EMC_MAGIC_BALL_ACTIVE,
1420 EL_EMC_SPRING_BUMPER_ACTIVE,
1421 EL_EMC_SPRING_BUMPER,
1428 EL_DIAGONAL_SHRINKING,
1436 EL_DIAGONAL_GROWING,
1457 int push_delay_fixed, push_delay_random;
1461 { EL_SPRING, 0, 0 },
1462 { EL_BALLOON, 0, 0 },
1464 { EL_SOKOBAN_OBJECT, 2, 0 },
1465 { EL_SOKOBAN_FIELD_FULL, 2, 0 },
1466 { EL_SATELLITE, 2, 0 },
1467 { EL_SP_DISK_YELLOW, 2, 0 },
1469 { EL_UNDEFINED, 0, 0 },
1477 move_stepsize_list[] =
1479 { EL_AMOEBA_DROP, 2 },
1480 { EL_AMOEBA_DROPPING, 2 },
1481 { EL_QUICKSAND_FILLING, 1 },
1482 { EL_QUICKSAND_EMPTYING, 1 },
1483 { EL_QUICKSAND_FAST_FILLING, 2 },
1484 { EL_QUICKSAND_FAST_EMPTYING, 2 },
1485 { EL_MAGIC_WALL_FILLING, 2 },
1486 { EL_MAGIC_WALL_EMPTYING, 2 },
1487 { EL_BD_MAGIC_WALL_FILLING, 2 },
1488 { EL_BD_MAGIC_WALL_EMPTYING, 2 },
1489 { EL_DC_MAGIC_WALL_FILLING, 2 },
1490 { EL_DC_MAGIC_WALL_EMPTYING, 2 },
1492 { EL_UNDEFINED, 0 },
1500 collect_count_list[] =
1503 { EL_BD_DIAMOND, 1 },
1504 { EL_EMERALD_YELLOW, 1 },
1505 { EL_EMERALD_RED, 1 },
1506 { EL_EMERALD_PURPLE, 1 },
1508 { EL_SP_INFOTRON, 1 },
1512 { EL_UNDEFINED, 0 },
1520 access_direction_list[] =
1522 { EL_TUBE_ANY, MV_LEFT | MV_RIGHT | MV_UP | MV_DOWN },
1523 { EL_TUBE_VERTICAL, MV_UP | MV_DOWN },
1524 { EL_TUBE_HORIZONTAL, MV_LEFT | MV_RIGHT },
1525 { EL_TUBE_VERTICAL_LEFT, MV_LEFT | MV_UP | MV_DOWN },
1526 { EL_TUBE_VERTICAL_RIGHT, MV_RIGHT | MV_UP | MV_DOWN },
1527 { EL_TUBE_HORIZONTAL_UP, MV_LEFT | MV_RIGHT | MV_UP },
1528 { EL_TUBE_HORIZONTAL_DOWN, MV_LEFT | MV_RIGHT | MV_DOWN },
1529 { EL_TUBE_LEFT_UP, MV_LEFT | MV_UP },
1530 { EL_TUBE_LEFT_DOWN, MV_LEFT | MV_DOWN },
1531 { EL_TUBE_RIGHT_UP, MV_RIGHT | MV_UP },
1532 { EL_TUBE_RIGHT_DOWN, MV_RIGHT | MV_DOWN },
1534 { EL_SP_PORT_LEFT, MV_RIGHT },
1535 { EL_SP_PORT_RIGHT, MV_LEFT },
1536 { EL_SP_PORT_UP, MV_DOWN },
1537 { EL_SP_PORT_DOWN, MV_UP },
1538 { EL_SP_PORT_HORIZONTAL, MV_LEFT | MV_RIGHT },
1539 { EL_SP_PORT_VERTICAL, MV_UP | MV_DOWN },
1540 { EL_SP_PORT_ANY, MV_LEFT | MV_RIGHT | MV_UP | MV_DOWN },
1541 { EL_SP_GRAVITY_PORT_LEFT, MV_RIGHT },
1542 { EL_SP_GRAVITY_PORT_RIGHT, MV_LEFT },
1543 { EL_SP_GRAVITY_PORT_UP, MV_DOWN },
1544 { EL_SP_GRAVITY_PORT_DOWN, MV_UP },
1545 { EL_SP_GRAVITY_ON_PORT_LEFT, MV_RIGHT },
1546 { EL_SP_GRAVITY_ON_PORT_RIGHT, MV_LEFT },
1547 { EL_SP_GRAVITY_ON_PORT_UP, MV_DOWN },
1548 { EL_SP_GRAVITY_ON_PORT_DOWN, MV_UP },
1549 { EL_SP_GRAVITY_OFF_PORT_LEFT, MV_RIGHT },
1550 { EL_SP_GRAVITY_OFF_PORT_RIGHT, MV_LEFT },
1551 { EL_SP_GRAVITY_OFF_PORT_UP, MV_DOWN },
1552 { EL_SP_GRAVITY_OFF_PORT_DOWN, MV_UP },
1554 { EL_UNDEFINED, MV_NONE }
1557 static boolean trigger_events[MAX_NUM_ELEMENTS][NUM_CHANGE_EVENTS];
1559 #define IS_AUTO_CHANGING(e) (element_info[e].has_change_event[CE_DELAY])
1560 #define IS_JUST_CHANGING(x, y) (ChangeDelay[x][y] != 0)
1561 #define IS_CHANGING(x, y) (IS_AUTO_CHANGING(Tile[x][y]) || \
1562 IS_JUST_CHANGING(x, y))
1564 #define CE_PAGE(e, ce) (element_info[e].event_page[ce])
1566 // static variables for playfield scan mode (scanning forward or backward)
1567 static int playfield_scan_start_x = 0;
1568 static int playfield_scan_start_y = 0;
1569 static int playfield_scan_delta_x = 1;
1570 static int playfield_scan_delta_y = 1;
1572 #define SCAN_PLAYFIELD(x, y) for ((y) = playfield_scan_start_y; \
1573 (y) >= 0 && (y) <= lev_fieldy - 1; \
1574 (y) += playfield_scan_delta_y) \
1575 for ((x) = playfield_scan_start_x; \
1576 (x) >= 0 && (x) <= lev_fieldx - 1; \
1577 (x) += playfield_scan_delta_x)
1580 void DEBUG_SetMaximumDynamite(void)
1584 for (i = 0; i < MAX_INVENTORY_SIZE; i++)
1585 if (local_player->inventory_size < MAX_INVENTORY_SIZE)
1586 local_player->inventory_element[local_player->inventory_size++] =
1591 static void InitPlayfieldScanModeVars(void)
1593 if (game.use_reverse_scan_direction)
1595 playfield_scan_start_x = lev_fieldx - 1;
1596 playfield_scan_start_y = lev_fieldy - 1;
1598 playfield_scan_delta_x = -1;
1599 playfield_scan_delta_y = -1;
1603 playfield_scan_start_x = 0;
1604 playfield_scan_start_y = 0;
1606 playfield_scan_delta_x = 1;
1607 playfield_scan_delta_y = 1;
1611 static void InitPlayfieldScanMode(int mode)
1613 game.use_reverse_scan_direction =
1614 (mode == CA_ARG_SCAN_MODE_REVERSE ? TRUE : FALSE);
1616 InitPlayfieldScanModeVars();
1619 static int get_move_delay_from_stepsize(int move_stepsize)
1622 MIN(MAX(MOVE_STEPSIZE_MIN, move_stepsize), MOVE_STEPSIZE_MAX);
1624 // make sure that stepsize value is always a power of 2
1625 move_stepsize = (1 << log_2(move_stepsize));
1627 return TILEX / move_stepsize;
1630 static void SetPlayerMoveSpeed(struct PlayerInfo *player, int move_stepsize,
1633 int player_nr = player->index_nr;
1634 int move_delay = get_move_delay_from_stepsize(move_stepsize);
1635 boolean cannot_move = (move_stepsize == STEPSIZE_NOT_MOVING ? TRUE : FALSE);
1637 // do no immediately change move delay -- the player might just be moving
1638 player->move_delay_value_next = move_delay;
1640 // information if player can move must be set separately
1641 player->cannot_move = cannot_move;
1645 player->move_delay = game.initial_move_delay[player_nr];
1646 player->move_delay_value = game.initial_move_delay_value[player_nr];
1648 player->move_delay_value_next = -1;
1650 player->move_delay_reset_counter = 0;
1654 void GetPlayerConfig(void)
1656 GameFrameDelay = setup.game_frame_delay;
1658 if (!audio.sound_available)
1659 setup.sound_simple = FALSE;
1661 if (!audio.loops_available)
1662 setup.sound_loops = FALSE;
1664 if (!audio.music_available)
1665 setup.sound_music = FALSE;
1667 if (!video.fullscreen_available)
1668 setup.fullscreen = FALSE;
1670 setup.sound = (setup.sound_simple || setup.sound_loops || setup.sound_music);
1672 SetAudioMode(setup.sound);
1675 int GetElementFromGroupElement(int element)
1677 if (IS_GROUP_ELEMENT(element))
1679 struct ElementGroupInfo *group = element_info[element].group;
1680 int last_anim_random_frame = gfx.anim_random_frame;
1683 if (group->choice_mode == ANIM_RANDOM)
1684 gfx.anim_random_frame = RND(group->num_elements_resolved);
1686 element_pos = getAnimationFrame(group->num_elements_resolved, 1,
1687 group->choice_mode, 0,
1690 if (group->choice_mode == ANIM_RANDOM)
1691 gfx.anim_random_frame = last_anim_random_frame;
1693 group->choice_pos++;
1695 element = group->element_resolved[element_pos];
1701 static void IncrementSokobanFieldsNeeded(void)
1703 if (level.sb_fields_needed)
1704 game.sokoban_fields_still_needed++;
1707 static void IncrementSokobanObjectsNeeded(void)
1709 if (level.sb_objects_needed)
1710 game.sokoban_objects_still_needed++;
1713 static void DecrementSokobanFieldsNeeded(void)
1715 if (game.sokoban_fields_still_needed > 0)
1716 game.sokoban_fields_still_needed--;
1719 static void DecrementSokobanObjectsNeeded(void)
1721 if (game.sokoban_objects_still_needed > 0)
1722 game.sokoban_objects_still_needed--;
1725 static void InitPlayerField(int x, int y, int element, boolean init_game)
1727 if (element == EL_SP_MURPHY)
1731 if (stored_player[0].present)
1733 Tile[x][y] = EL_SP_MURPHY_CLONE;
1739 stored_player[0].initial_element = element;
1740 stored_player[0].use_murphy = TRUE;
1742 if (!level.use_artwork_element[0])
1743 stored_player[0].artwork_element = EL_SP_MURPHY;
1746 Tile[x][y] = EL_PLAYER_1;
1752 struct PlayerInfo *player = &stored_player[Tile[x][y] - EL_PLAYER_1];
1753 int jx = player->jx, jy = player->jy;
1755 player->present = TRUE;
1757 player->block_last_field = (element == EL_SP_MURPHY ?
1758 level.sp_block_last_field :
1759 level.block_last_field);
1761 // ---------- initialize player's last field block delay ------------------
1763 // always start with reliable default value (no adjustment needed)
1764 player->block_delay_adjustment = 0;
1766 // special case 1: in Supaplex, Murphy blocks last field one more frame
1767 if (player->block_last_field && element == EL_SP_MURPHY)
1768 player->block_delay_adjustment = 1;
1770 // special case 2: in game engines before 3.1.1, blocking was different
1771 if (game.use_block_last_field_bug)
1772 player->block_delay_adjustment = (player->block_last_field ? -1 : 1);
1774 if (!network.enabled || player->connected_network)
1776 player->active = TRUE;
1778 // remove potentially duplicate players
1779 if (StorePlayer[jx][jy] == Tile[x][y])
1780 StorePlayer[jx][jy] = 0;
1782 StorePlayer[x][y] = Tile[x][y];
1784 #if DEBUG_INIT_PLAYER
1785 Debug("game:init:player", "- player element %d activated",
1786 player->element_nr);
1787 Debug("game:init:player", " (local player is %d and currently %s)",
1788 local_player->element_nr,
1789 local_player->active ? "active" : "not active");
1793 Tile[x][y] = EL_EMPTY;
1795 player->jx = player->last_jx = x;
1796 player->jy = player->last_jy = y;
1799 // always check if player was just killed and should be reanimated
1801 int player_nr = GET_PLAYER_NR(element);
1802 struct PlayerInfo *player = &stored_player[player_nr];
1804 if (player->active && player->killed)
1805 player->reanimated = TRUE; // if player was just killed, reanimate him
1809 static void InitField(int x, int y, boolean init_game)
1811 int element = Tile[x][y];
1820 InitPlayerField(x, y, element, init_game);
1823 case EL_SOKOBAN_FIELD_PLAYER:
1824 element = Tile[x][y] = EL_PLAYER_1;
1825 InitField(x, y, init_game);
1827 element = Tile[x][y] = EL_SOKOBAN_FIELD_EMPTY;
1828 InitField(x, y, init_game);
1831 case EL_SOKOBAN_FIELD_EMPTY:
1832 IncrementSokobanFieldsNeeded();
1835 case EL_SOKOBAN_OBJECT:
1836 IncrementSokobanObjectsNeeded();
1840 if (x < lev_fieldx-1 && Tile[x+1][y] == EL_ACID)
1841 Tile[x][y] = EL_ACID_POOL_TOPLEFT;
1842 else if (x > 0 && Tile[x-1][y] == EL_ACID)
1843 Tile[x][y] = EL_ACID_POOL_TOPRIGHT;
1844 else if (y > 0 && Tile[x][y-1] == EL_ACID_POOL_TOPLEFT)
1845 Tile[x][y] = EL_ACID_POOL_BOTTOMLEFT;
1846 else if (y > 0 && Tile[x][y-1] == EL_ACID)
1847 Tile[x][y] = EL_ACID_POOL_BOTTOM;
1848 else if (y > 0 && Tile[x][y-1] == EL_ACID_POOL_TOPRIGHT)
1849 Tile[x][y] = EL_ACID_POOL_BOTTOMRIGHT;
1858 case EL_SPACESHIP_RIGHT:
1859 case EL_SPACESHIP_UP:
1860 case EL_SPACESHIP_LEFT:
1861 case EL_SPACESHIP_DOWN:
1862 case EL_BD_BUTTERFLY:
1863 case EL_BD_BUTTERFLY_RIGHT:
1864 case EL_BD_BUTTERFLY_UP:
1865 case EL_BD_BUTTERFLY_LEFT:
1866 case EL_BD_BUTTERFLY_DOWN:
1868 case EL_BD_FIREFLY_RIGHT:
1869 case EL_BD_FIREFLY_UP:
1870 case EL_BD_FIREFLY_LEFT:
1871 case EL_BD_FIREFLY_DOWN:
1872 case EL_PACMAN_RIGHT:
1874 case EL_PACMAN_LEFT:
1875 case EL_PACMAN_DOWN:
1877 case EL_YAMYAM_LEFT:
1878 case EL_YAMYAM_RIGHT:
1880 case EL_YAMYAM_DOWN:
1881 case EL_DARK_YAMYAM:
1884 case EL_SP_SNIKSNAK:
1885 case EL_SP_ELECTRON:
1891 case EL_SPRING_LEFT:
1892 case EL_SPRING_RIGHT:
1896 case EL_AMOEBA_FULL:
1901 case EL_AMOEBA_DROP:
1902 if (y == lev_fieldy - 1)
1904 Tile[x][y] = EL_AMOEBA_GROWING;
1905 Store[x][y] = EL_AMOEBA_WET;
1909 case EL_DYNAMITE_ACTIVE:
1910 case EL_SP_DISK_RED_ACTIVE:
1911 case EL_DYNABOMB_PLAYER_1_ACTIVE:
1912 case EL_DYNABOMB_PLAYER_2_ACTIVE:
1913 case EL_DYNABOMB_PLAYER_3_ACTIVE:
1914 case EL_DYNABOMB_PLAYER_4_ACTIVE:
1915 MovDelay[x][y] = 96;
1918 case EL_EM_DYNAMITE_ACTIVE:
1919 MovDelay[x][y] = 32;
1923 game.lights_still_needed++;
1927 game.friends_still_needed++;
1932 GfxDir[x][y] = MovDir[x][y] = 1 << RND(4);
1935 case EL_CONVEYOR_BELT_1_SWITCH_LEFT:
1936 case EL_CONVEYOR_BELT_1_SWITCH_MIDDLE:
1937 case EL_CONVEYOR_BELT_1_SWITCH_RIGHT:
1938 case EL_CONVEYOR_BELT_2_SWITCH_LEFT:
1939 case EL_CONVEYOR_BELT_2_SWITCH_MIDDLE:
1940 case EL_CONVEYOR_BELT_2_SWITCH_RIGHT:
1941 case EL_CONVEYOR_BELT_3_SWITCH_LEFT:
1942 case EL_CONVEYOR_BELT_3_SWITCH_MIDDLE:
1943 case EL_CONVEYOR_BELT_3_SWITCH_RIGHT:
1944 case EL_CONVEYOR_BELT_4_SWITCH_LEFT:
1945 case EL_CONVEYOR_BELT_4_SWITCH_MIDDLE:
1946 case EL_CONVEYOR_BELT_4_SWITCH_RIGHT:
1949 int belt_nr = getBeltNrFromBeltSwitchElement(Tile[x][y]);
1950 int belt_dir = getBeltDirFromBeltSwitchElement(Tile[x][y]);
1951 int belt_dir_nr = getBeltDirNrFromBeltSwitchElement(Tile[x][y]);
1953 if (game.belt_dir_nr[belt_nr] == 3) // initial value
1955 game.belt_dir[belt_nr] = belt_dir;
1956 game.belt_dir_nr[belt_nr] = belt_dir_nr;
1958 else // more than one switch -- set it like the first switch
1960 Tile[x][y] = Tile[x][y] - belt_dir_nr + game.belt_dir_nr[belt_nr];
1965 case EL_LIGHT_SWITCH_ACTIVE:
1967 game.light_time_left = level.time_light * FRAMES_PER_SECOND;
1970 case EL_INVISIBLE_STEELWALL:
1971 case EL_INVISIBLE_WALL:
1972 case EL_INVISIBLE_SAND:
1973 if (game.light_time_left > 0 ||
1974 game.lenses_time_left > 0)
1975 Tile[x][y] = getInvisibleActiveFromInvisibleElement(element);
1978 case EL_EMC_MAGIC_BALL:
1979 if (game.ball_active)
1980 Tile[x][y] = EL_EMC_MAGIC_BALL_ACTIVE;
1983 case EL_EMC_MAGIC_BALL_SWITCH:
1984 if (game.ball_active)
1985 Tile[x][y] = EL_EMC_MAGIC_BALL_SWITCH_ACTIVE;
1988 case EL_TRIGGER_PLAYER:
1989 case EL_TRIGGER_ELEMENT:
1990 case EL_TRIGGER_CE_VALUE:
1991 case EL_TRIGGER_CE_SCORE:
1993 case EL_ANY_ELEMENT:
1994 case EL_CURRENT_CE_VALUE:
1995 case EL_CURRENT_CE_SCORE:
2012 // reference elements should not be used on the playfield
2013 Tile[x][y] = EL_EMPTY;
2017 if (IS_CUSTOM_ELEMENT(element))
2019 if (CAN_MOVE(element))
2022 if (!element_info[element].use_last_ce_value || init_game)
2023 CustomValue[x][y] = GET_NEW_CE_VALUE(Tile[x][y]);
2025 else if (IS_GROUP_ELEMENT(element))
2027 Tile[x][y] = GetElementFromGroupElement(element);
2029 InitField(x, y, init_game);
2031 else if (IS_EMPTY_ELEMENT(element))
2033 GfxElementEmpty[x][y] = element;
2034 Tile[x][y] = EL_EMPTY;
2036 if (element_info[element].use_gfx_element)
2037 game.use_masked_elements = TRUE;
2044 CheckTriggeredElementChange(x, y, element, CE_CREATION_OF_X);
2047 static void InitField_WithBug1(int x, int y, boolean init_game)
2049 InitField(x, y, init_game);
2051 // not needed to call InitMovDir() -- already done by InitField()!
2052 if (game.engine_version < VERSION_IDENT(3,1,0,0) &&
2053 CAN_MOVE(Tile[x][y]))
2057 static void InitField_WithBug2(int x, int y, boolean init_game)
2059 int old_element = Tile[x][y];
2061 InitField(x, y, init_game);
2063 // not needed to call InitMovDir() -- already done by InitField()!
2064 if (game.engine_version < VERSION_IDENT(3,1,0,0) &&
2065 CAN_MOVE(old_element) &&
2066 (old_element < EL_MOLE_LEFT || old_element > EL_MOLE_DOWN))
2069 /* this case is in fact a combination of not less than three bugs:
2070 first, it calls InitMovDir() for elements that can move, although this is
2071 already done by InitField(); then, it checks the element that was at this
2072 field _before_ the call to InitField() (which can change it); lastly, it
2073 was not called for "mole with direction" elements, which were treated as
2074 "cannot move" due to (fixed) wrong element initialization in "src/init.c"
2078 static int get_key_element_from_nr(int key_nr)
2080 int key_base_element = (key_nr >= STD_NUM_KEYS ? EL_EMC_KEY_5 - STD_NUM_KEYS :
2081 level.game_engine_type == GAME_ENGINE_TYPE_EM ?
2082 EL_EM_KEY_1 : EL_KEY_1);
2084 return key_base_element + key_nr;
2087 static int get_next_dropped_element(struct PlayerInfo *player)
2089 return (player->inventory_size > 0 ?
2090 player->inventory_element[player->inventory_size - 1] :
2091 player->inventory_infinite_element != EL_UNDEFINED ?
2092 player->inventory_infinite_element :
2093 player->dynabombs_left > 0 ?
2094 EL_DYNABOMB_PLAYER_1_ACTIVE + player->index_nr :
2098 static int get_inventory_element_from_pos(struct PlayerInfo *player, int pos)
2100 // pos >= 0: get element from bottom of the stack;
2101 // pos < 0: get element from top of the stack
2105 int min_inventory_size = -pos;
2106 int inventory_pos = player->inventory_size - min_inventory_size;
2107 int min_dynabombs_left = min_inventory_size - player->inventory_size;
2109 return (player->inventory_size >= min_inventory_size ?
2110 player->inventory_element[inventory_pos] :
2111 player->inventory_infinite_element != EL_UNDEFINED ?
2112 player->inventory_infinite_element :
2113 player->dynabombs_left >= min_dynabombs_left ?
2114 EL_DYNABOMB_PLAYER_1 + player->index_nr :
2119 int min_dynabombs_left = pos + 1;
2120 int min_inventory_size = pos + 1 - player->dynabombs_left;
2121 int inventory_pos = pos - player->dynabombs_left;
2123 return (player->inventory_infinite_element != EL_UNDEFINED ?
2124 player->inventory_infinite_element :
2125 player->dynabombs_left >= min_dynabombs_left ?
2126 EL_DYNABOMB_PLAYER_1 + player->index_nr :
2127 player->inventory_size >= min_inventory_size ?
2128 player->inventory_element[inventory_pos] :
2133 static int compareGamePanelOrderInfo(const void *object1, const void *object2)
2135 const struct GamePanelOrderInfo *gpo1 = (struct GamePanelOrderInfo *)object1;
2136 const struct GamePanelOrderInfo *gpo2 = (struct GamePanelOrderInfo *)object2;
2139 if (gpo1->sort_priority != gpo2->sort_priority)
2140 compare_result = gpo1->sort_priority - gpo2->sort_priority;
2142 compare_result = gpo1->nr - gpo2->nr;
2144 return compare_result;
2147 int getPlayerInventorySize(int player_nr)
2149 if (level.game_engine_type == GAME_ENGINE_TYPE_EM)
2150 return game_em.ply[player_nr]->dynamite;
2151 else if (level.game_engine_type == GAME_ENGINE_TYPE_SP)
2152 return game_sp.red_disk_count;
2154 return stored_player[player_nr].inventory_size;
2157 static void InitGameControlValues(void)
2161 for (i = 0; game_panel_controls[i].nr != -1; i++)
2163 struct GamePanelControlInfo *gpc = &game_panel_controls[i];
2164 struct GamePanelOrderInfo *gpo = &game_panel_order[i];
2165 struct TextPosInfo *pos = gpc->pos;
2167 int type = gpc->type;
2171 Error("'game_panel_controls' structure corrupted at %d", i);
2173 Fail("this should not happen -- please debug");
2176 // force update of game controls after initialization
2177 gpc->value = gpc->last_value = -1;
2178 gpc->frame = gpc->last_frame = -1;
2179 gpc->gfx_frame = -1;
2181 // determine panel value width for later calculation of alignment
2182 if (type == TYPE_INTEGER || type == TYPE_STRING)
2184 pos->width = pos->size * getFontWidth(pos->font);
2185 pos->height = getFontHeight(pos->font);
2187 else if (type == TYPE_ELEMENT)
2189 pos->width = pos->size;
2190 pos->height = pos->size;
2193 // fill structure for game panel draw order
2195 gpo->sort_priority = pos->sort_priority;
2198 // sort game panel controls according to sort_priority and control number
2199 qsort(game_panel_order, NUM_GAME_PANEL_CONTROLS,
2200 sizeof(struct GamePanelOrderInfo), compareGamePanelOrderInfo);
2203 static void UpdatePlayfieldElementCount(void)
2205 boolean use_element_count = FALSE;
2208 // first check if it is needed at all to calculate playfield element count
2209 for (i = GAME_PANEL_ELEMENT_COUNT_1; i <= GAME_PANEL_ELEMENT_COUNT_8; i++)
2210 if (!PANEL_DEACTIVATED(game_panel_controls[i].pos))
2211 use_element_count = TRUE;
2213 if (!use_element_count)
2216 for (i = 0; i < MAX_NUM_ELEMENTS; i++)
2217 element_info[i].element_count = 0;
2219 SCAN_PLAYFIELD(x, y)
2221 element_info[Tile[x][y]].element_count++;
2224 for (i = 0; i < NUM_GROUP_ELEMENTS; i++)
2225 for (j = 0; j < MAX_NUM_ELEMENTS; j++)
2226 if (IS_IN_GROUP(j, i))
2227 element_info[EL_GROUP_START + i].element_count +=
2228 element_info[j].element_count;
2231 static void UpdateGameControlValues(void)
2234 int time = (game.LevelSolved ?
2235 game.LevelSolved_CountingTime :
2236 level.game_engine_type == GAME_ENGINE_TYPE_EM ?
2238 level.game_engine_type == GAME_ENGINE_TYPE_SP ?
2239 game_sp.time_played :
2240 level.game_engine_type == GAME_ENGINE_TYPE_MM ?
2241 game_mm.energy_left :
2242 game.no_time_limit ? TimePlayed : TimeLeft);
2243 int score = (game.LevelSolved ?
2244 game.LevelSolved_CountingScore :
2245 level.game_engine_type == GAME_ENGINE_TYPE_EM ?
2246 game_em.lev->score :
2247 level.game_engine_type == GAME_ENGINE_TYPE_SP ?
2249 level.game_engine_type == GAME_ENGINE_TYPE_MM ?
2252 int gems = (level.game_engine_type == GAME_ENGINE_TYPE_EM ?
2253 game_em.lev->gems_needed :
2254 level.game_engine_type == GAME_ENGINE_TYPE_SP ?
2255 game_sp.infotrons_still_needed :
2256 level.game_engine_type == GAME_ENGINE_TYPE_MM ?
2257 game_mm.kettles_still_needed :
2258 game.gems_still_needed);
2259 int exit_closed = (level.game_engine_type == GAME_ENGINE_TYPE_EM ?
2260 game_em.lev->gems_needed > 0 :
2261 level.game_engine_type == GAME_ENGINE_TYPE_SP ?
2262 game_sp.infotrons_still_needed > 0 :
2263 level.game_engine_type == GAME_ENGINE_TYPE_MM ?
2264 game_mm.kettles_still_needed > 0 ||
2265 game_mm.lights_still_needed > 0 :
2266 game.gems_still_needed > 0 ||
2267 game.sokoban_fields_still_needed > 0 ||
2268 game.sokoban_objects_still_needed > 0 ||
2269 game.lights_still_needed > 0);
2270 int health = (game.LevelSolved ?
2271 game.LevelSolved_CountingHealth :
2272 level.game_engine_type == GAME_ENGINE_TYPE_MM ?
2273 MM_HEALTH(game_mm.laser_overload_value) :
2275 int sync_random_frame = INIT_GFX_RANDOM(); // random, but synchronized
2277 UpdatePlayfieldElementCount();
2279 // update game panel control values
2281 // used instead of "level_nr" (for network games)
2282 game_panel_controls[GAME_PANEL_LEVEL_NUMBER].value = levelset.level_nr;
2283 game_panel_controls[GAME_PANEL_GEMS].value = gems;
2285 game_panel_controls[GAME_PANEL_INVENTORY_COUNT].value = 0;
2286 for (i = 0; i < MAX_NUM_KEYS; i++)
2287 game_panel_controls[GAME_PANEL_KEY_1 + i].value = EL_EMPTY;
2288 game_panel_controls[GAME_PANEL_KEY_WHITE].value = EL_EMPTY;
2289 game_panel_controls[GAME_PANEL_KEY_WHITE_COUNT].value = 0;
2291 if (game.centered_player_nr == -1)
2293 for (i = 0; i < MAX_PLAYERS; i++)
2295 // only one player in Supaplex game engine
2296 if (level.game_engine_type == GAME_ENGINE_TYPE_SP && i > 0)
2299 for (k = 0; k < MAX_NUM_KEYS; k++)
2301 if (level.game_engine_type == GAME_ENGINE_TYPE_EM)
2303 if (game_em.ply[i]->keys & (1 << k))
2304 game_panel_controls[GAME_PANEL_KEY_1 + k].value =
2305 get_key_element_from_nr(k);
2307 else if (stored_player[i].key[k])
2308 game_panel_controls[GAME_PANEL_KEY_1 + k].value =
2309 get_key_element_from_nr(k);
2312 game_panel_controls[GAME_PANEL_INVENTORY_COUNT].value +=
2313 getPlayerInventorySize(i);
2315 if (stored_player[i].num_white_keys > 0)
2316 game_panel_controls[GAME_PANEL_KEY_WHITE].value =
2319 game_panel_controls[GAME_PANEL_KEY_WHITE_COUNT].value +=
2320 stored_player[i].num_white_keys;
2325 int player_nr = game.centered_player_nr;
2327 for (k = 0; k < MAX_NUM_KEYS; k++)
2329 if (level.game_engine_type == GAME_ENGINE_TYPE_EM)
2331 if (game_em.ply[player_nr]->keys & (1 << k))
2332 game_panel_controls[GAME_PANEL_KEY_1 + k].value =
2333 get_key_element_from_nr(k);
2335 else if (stored_player[player_nr].key[k])
2336 game_panel_controls[GAME_PANEL_KEY_1 + k].value =
2337 get_key_element_from_nr(k);
2340 game_panel_controls[GAME_PANEL_INVENTORY_COUNT].value +=
2341 getPlayerInventorySize(player_nr);
2343 if (stored_player[player_nr].num_white_keys > 0)
2344 game_panel_controls[GAME_PANEL_KEY_WHITE].value = EL_DC_KEY_WHITE;
2346 game_panel_controls[GAME_PANEL_KEY_WHITE_COUNT].value +=
2347 stored_player[player_nr].num_white_keys;
2350 // re-arrange keys on game panel, if needed or if defined by style settings
2351 for (i = 0; i < MAX_NUM_KEYS + 1; i++) // all normal keys + white key
2353 int nr = GAME_PANEL_KEY_1 + i;
2354 struct GamePanelControlInfo *gpc = &game_panel_controls[nr];
2355 struct TextPosInfo *pos = gpc->pos;
2357 // skip check if key is not in the player's inventory
2358 if (gpc->value == EL_EMPTY)
2361 // check if keys should be arranged on panel from left to right
2362 if (pos->style == STYLE_LEFTMOST_POSITION)
2364 // check previous key positions (left from current key)
2365 for (k = 0; k < i; k++)
2367 int nr_new = GAME_PANEL_KEY_1 + k;
2369 if (game_panel_controls[nr_new].value == EL_EMPTY)
2371 game_panel_controls[nr_new].value = gpc->value;
2372 gpc->value = EL_EMPTY;
2379 // check if "undefined" keys can be placed at some other position
2380 if (pos->x == -1 && pos->y == -1)
2382 int nr_new = GAME_PANEL_KEY_1 + i % STD_NUM_KEYS;
2384 // 1st try: display key at the same position as normal or EM keys
2385 if (game_panel_controls[nr_new].value == EL_EMPTY)
2387 game_panel_controls[nr_new].value = gpc->value;
2391 // 2nd try: display key at the next free position in the key panel
2392 for (k = 0; k < STD_NUM_KEYS; k++)
2394 nr_new = GAME_PANEL_KEY_1 + k;
2396 if (game_panel_controls[nr_new].value == EL_EMPTY)
2398 game_panel_controls[nr_new].value = gpc->value;
2407 for (i = 0; i < NUM_PANEL_INVENTORY; i++)
2409 game_panel_controls[GAME_PANEL_INVENTORY_FIRST_1 + i].value =
2410 get_inventory_element_from_pos(local_player, i);
2411 game_panel_controls[GAME_PANEL_INVENTORY_LAST_1 + i].value =
2412 get_inventory_element_from_pos(local_player, -i - 1);
2415 game_panel_controls[GAME_PANEL_SCORE].value = score;
2416 game_panel_controls[GAME_PANEL_HIGHSCORE].value = scores.entry[0].score;
2418 game_panel_controls[GAME_PANEL_TIME].value = time;
2420 game_panel_controls[GAME_PANEL_TIME_HH].value = time / 3600;
2421 game_panel_controls[GAME_PANEL_TIME_MM].value = (time / 60) % 60;
2422 game_panel_controls[GAME_PANEL_TIME_SS].value = time % 60;
2424 if (level.time == 0)
2425 game_panel_controls[GAME_PANEL_TIME_ANIM].value = 100;
2427 game_panel_controls[GAME_PANEL_TIME_ANIM].value = time * 100 / level.time;
2429 game_panel_controls[GAME_PANEL_HEALTH].value = health;
2430 game_panel_controls[GAME_PANEL_HEALTH_ANIM].value = health;
2432 game_panel_controls[GAME_PANEL_FRAME].value = FrameCounter;
2434 game_panel_controls[GAME_PANEL_SHIELD_NORMAL].value =
2435 (local_player->shield_normal_time_left > 0 ? EL_SHIELD_NORMAL_ACTIVE :
2437 game_panel_controls[GAME_PANEL_SHIELD_NORMAL_TIME].value =
2438 local_player->shield_normal_time_left;
2439 game_panel_controls[GAME_PANEL_SHIELD_DEADLY].value =
2440 (local_player->shield_deadly_time_left > 0 ? EL_SHIELD_DEADLY_ACTIVE :
2442 game_panel_controls[GAME_PANEL_SHIELD_DEADLY_TIME].value =
2443 local_player->shield_deadly_time_left;
2445 game_panel_controls[GAME_PANEL_EXIT].value =
2446 (exit_closed ? EL_EXIT_CLOSED : EL_EXIT_OPEN);
2448 game_panel_controls[GAME_PANEL_EMC_MAGIC_BALL].value =
2449 (game.ball_active ? EL_EMC_MAGIC_BALL_ACTIVE : EL_EMC_MAGIC_BALL);
2450 game_panel_controls[GAME_PANEL_EMC_MAGIC_BALL_SWITCH].value =
2451 (game.ball_active ? EL_EMC_MAGIC_BALL_SWITCH_ACTIVE :
2452 EL_EMC_MAGIC_BALL_SWITCH);
2454 game_panel_controls[GAME_PANEL_LIGHT_SWITCH].value =
2455 (game.light_time_left > 0 ? EL_LIGHT_SWITCH_ACTIVE : EL_LIGHT_SWITCH);
2456 game_panel_controls[GAME_PANEL_LIGHT_SWITCH_TIME].value =
2457 game.light_time_left;
2459 game_panel_controls[GAME_PANEL_TIMEGATE_SWITCH].value =
2460 (game.timegate_time_left > 0 ? EL_TIMEGATE_OPEN : EL_TIMEGATE_CLOSED);
2461 game_panel_controls[GAME_PANEL_TIMEGATE_SWITCH_TIME].value =
2462 game.timegate_time_left;
2464 game_panel_controls[GAME_PANEL_SWITCHGATE_SWITCH].value =
2465 EL_SWITCHGATE_SWITCH_UP + game.switchgate_pos;
2467 game_panel_controls[GAME_PANEL_EMC_LENSES].value =
2468 (game.lenses_time_left > 0 ? EL_EMC_LENSES : EL_EMPTY);
2469 game_panel_controls[GAME_PANEL_EMC_LENSES_TIME].value =
2470 game.lenses_time_left;
2472 game_panel_controls[GAME_PANEL_EMC_MAGNIFIER].value =
2473 (game.magnify_time_left > 0 ? EL_EMC_MAGNIFIER : EL_EMPTY);
2474 game_panel_controls[GAME_PANEL_EMC_MAGNIFIER_TIME].value =
2475 game.magnify_time_left;
2477 game_panel_controls[GAME_PANEL_BALLOON_SWITCH].value =
2478 (game.wind_direction == MV_LEFT ? EL_BALLOON_SWITCH_LEFT :
2479 game.wind_direction == MV_RIGHT ? EL_BALLOON_SWITCH_RIGHT :
2480 game.wind_direction == MV_UP ? EL_BALLOON_SWITCH_UP :
2481 game.wind_direction == MV_DOWN ? EL_BALLOON_SWITCH_DOWN :
2482 EL_BALLOON_SWITCH_NONE);
2484 game_panel_controls[GAME_PANEL_DYNABOMB_NUMBER].value =
2485 local_player->dynabomb_count;
2486 game_panel_controls[GAME_PANEL_DYNABOMB_SIZE].value =
2487 local_player->dynabomb_size;
2488 game_panel_controls[GAME_PANEL_DYNABOMB_POWER].value =
2489 (local_player->dynabomb_xl ? EL_DYNABOMB_INCREASE_POWER : EL_EMPTY);
2491 game_panel_controls[GAME_PANEL_PENGUINS].value =
2492 game.friends_still_needed;
2494 game_panel_controls[GAME_PANEL_SOKOBAN_OBJECTS].value =
2495 game.sokoban_objects_still_needed;
2496 game_panel_controls[GAME_PANEL_SOKOBAN_FIELDS].value =
2497 game.sokoban_fields_still_needed;
2499 game_panel_controls[GAME_PANEL_ROBOT_WHEEL].value =
2500 (game.robot_wheel_active ? EL_ROBOT_WHEEL_ACTIVE : EL_ROBOT_WHEEL);
2502 for (i = 0; i < NUM_BELTS; i++)
2504 game_panel_controls[GAME_PANEL_CONVEYOR_BELT_1 + i].value =
2505 (game.belt_dir[i] != MV_NONE ? EL_CONVEYOR_BELT_1_MIDDLE_ACTIVE :
2506 EL_CONVEYOR_BELT_1_MIDDLE) + i;
2507 game_panel_controls[GAME_PANEL_CONVEYOR_BELT_1_SWITCH + i].value =
2508 getBeltSwitchElementFromBeltNrAndBeltDir(i, game.belt_dir[i]);
2511 game_panel_controls[GAME_PANEL_MAGIC_WALL].value =
2512 (game.magic_wall_active ? EL_MAGIC_WALL_ACTIVE : EL_MAGIC_WALL);
2513 game_panel_controls[GAME_PANEL_MAGIC_WALL_TIME].value =
2514 game.magic_wall_time_left;
2516 game_panel_controls[GAME_PANEL_GRAVITY_STATE].value =
2517 local_player->gravity;
2519 for (i = 0; i < NUM_PANEL_GRAPHICS; i++)
2520 game_panel_controls[GAME_PANEL_GRAPHIC_1 + i].value = EL_GRAPHIC_1 + i;
2522 for (i = 0; i < NUM_PANEL_ELEMENTS; i++)
2523 game_panel_controls[GAME_PANEL_ELEMENT_1 + i].value =
2524 (IS_DRAWABLE_ELEMENT(game.panel.element[i].id) ?
2525 game.panel.element[i].id : EL_UNDEFINED);
2527 for (i = 0; i < NUM_PANEL_ELEMENTS; i++)
2528 game_panel_controls[GAME_PANEL_ELEMENT_COUNT_1 + i].value =
2529 (IS_VALID_ELEMENT(game.panel.element_count[i].id) ?
2530 element_info[game.panel.element_count[i].id].element_count : 0);
2532 for (i = 0; i < NUM_PANEL_CE_SCORE; i++)
2533 game_panel_controls[GAME_PANEL_CE_SCORE_1 + i].value =
2534 (IS_CUSTOM_ELEMENT(game.panel.ce_score[i].id) ?
2535 element_info[game.panel.ce_score[i].id].collect_score : 0);
2537 for (i = 0; i < NUM_PANEL_CE_SCORE; i++)
2538 game_panel_controls[GAME_PANEL_CE_SCORE_1_ELEMENT + i].value =
2539 (IS_CUSTOM_ELEMENT(game.panel.ce_score_element[i].id) ?
2540 element_info[game.panel.ce_score_element[i].id].collect_score :
2543 game_panel_controls[GAME_PANEL_PLAYER_NAME].value = 0;
2544 game_panel_controls[GAME_PANEL_LEVEL_NAME].value = 0;
2545 game_panel_controls[GAME_PANEL_LEVEL_AUTHOR].value = 0;
2547 // update game panel control frames
2549 for (i = 0; game_panel_controls[i].nr != -1; i++)
2551 struct GamePanelControlInfo *gpc = &game_panel_controls[i];
2553 if (gpc->type == TYPE_ELEMENT)
2555 if (gpc->value != EL_UNDEFINED && gpc->value != EL_EMPTY)
2557 int last_anim_random_frame = gfx.anim_random_frame;
2558 int element = gpc->value;
2559 int graphic = el2panelimg(element);
2560 int init_gfx_random = (graphic_info[graphic].anim_global_sync ?
2561 sync_random_frame : INIT_GFX_RANDOM());
2563 if (gpc->value != gpc->last_value)
2566 gpc->gfx_random = init_gfx_random;
2572 if (ANIM_MODE(graphic) == ANIM_RANDOM &&
2573 IS_NEXT_FRAME(gpc->gfx_frame, graphic))
2574 gpc->gfx_random = init_gfx_random;
2577 if (ANIM_MODE(graphic) == ANIM_RANDOM)
2578 gfx.anim_random_frame = gpc->gfx_random;
2580 if (ANIM_MODE(graphic) == ANIM_CE_SCORE)
2581 gpc->gfx_frame = element_info[element].collect_score;
2583 gpc->frame = getGraphicAnimationFrame(graphic, gpc->gfx_frame);
2585 if (ANIM_MODE(graphic) == ANIM_RANDOM)
2586 gfx.anim_random_frame = last_anim_random_frame;
2589 else if (gpc->type == TYPE_GRAPHIC)
2591 if (gpc->graphic != IMG_UNDEFINED)
2593 int last_anim_random_frame = gfx.anim_random_frame;
2594 int graphic = gpc->graphic;
2595 int init_gfx_random = (graphic_info[graphic].anim_global_sync ?
2596 sync_random_frame : INIT_GFX_RANDOM());
2598 if (gpc->value != gpc->last_value)
2601 gpc->gfx_random = init_gfx_random;
2607 if (ANIM_MODE(graphic) == ANIM_RANDOM &&
2608 IS_NEXT_FRAME(gpc->gfx_frame, graphic))
2609 gpc->gfx_random = init_gfx_random;
2612 if (ANIM_MODE(graphic) == ANIM_RANDOM)
2613 gfx.anim_random_frame = gpc->gfx_random;
2615 gpc->frame = getGraphicAnimationFrame(graphic, gpc->gfx_frame);
2617 if (ANIM_MODE(graphic) == ANIM_RANDOM)
2618 gfx.anim_random_frame = last_anim_random_frame;
2624 static void DisplayGameControlValues(void)
2626 boolean redraw_panel = FALSE;
2629 for (i = 0; game_panel_controls[i].nr != -1; i++)
2631 struct GamePanelControlInfo *gpc = &game_panel_controls[i];
2633 if (PANEL_DEACTIVATED(gpc->pos))
2636 if (gpc->value == gpc->last_value &&
2637 gpc->frame == gpc->last_frame)
2640 redraw_panel = TRUE;
2646 // copy default game door content to main double buffer
2648 // !!! CHECK AGAIN !!!
2649 SetPanelBackground();
2650 // SetDoorBackgroundImage(IMG_BACKGROUND_PANEL);
2651 DrawBackground(DX, DY, DXSIZE, DYSIZE);
2653 // redraw game control buttons
2654 RedrawGameButtons();
2656 SetGameStatus(GAME_MODE_PSEUDO_PANEL);
2658 for (i = 0; i < NUM_GAME_PANEL_CONTROLS; i++)
2660 int nr = game_panel_order[i].nr;
2661 struct GamePanelControlInfo *gpc = &game_panel_controls[nr];
2662 struct TextPosInfo *pos = gpc->pos;
2663 int type = gpc->type;
2664 int value = gpc->value;
2665 int frame = gpc->frame;
2666 int size = pos->size;
2667 int font = pos->font;
2668 boolean draw_masked = pos->draw_masked;
2669 int mask_mode = (draw_masked ? BLIT_MASKED : BLIT_OPAQUE);
2671 if (PANEL_DEACTIVATED(pos))
2674 if (pos->class == get_hash_from_key("extra_panel_items") &&
2675 !setup.prefer_extra_panel_items)
2678 gpc->last_value = value;
2679 gpc->last_frame = frame;
2681 if (type == TYPE_INTEGER)
2683 if (nr == GAME_PANEL_LEVEL_NUMBER ||
2684 nr == GAME_PANEL_TIME)
2686 boolean use_dynamic_size = (size == -1 ? TRUE : FALSE);
2688 if (use_dynamic_size) // use dynamic number of digits
2690 int value_change = (nr == GAME_PANEL_LEVEL_NUMBER ? 100 : 1000);
2691 int size1 = (nr == GAME_PANEL_LEVEL_NUMBER ? 2 : 3);
2692 int size2 = size1 + 1;
2693 int font1 = pos->font;
2694 int font2 = pos->font_alt;
2696 size = (value < value_change ? size1 : size2);
2697 font = (value < value_change ? font1 : font2);
2701 // correct text size if "digits" is zero or less
2703 size = strlen(int2str(value, size));
2705 // dynamically correct text alignment
2706 pos->width = size * getFontWidth(font);
2708 DrawTextExt(drawto, PANEL_XPOS(pos), PANEL_YPOS(pos),
2709 int2str(value, size), font, mask_mode);
2711 else if (type == TYPE_ELEMENT)
2713 int element, graphic;
2717 int dst_x = PANEL_XPOS(pos);
2718 int dst_y = PANEL_YPOS(pos);
2720 if (value != EL_UNDEFINED && value != EL_EMPTY)
2723 graphic = el2panelimg(value);
2726 Debug("game:DisplayGameControlValues", "%d, '%s' [%d]",
2727 element, EL_NAME(element), size);
2730 if (element >= EL_GRAPHIC_1 && element <= EL_GRAPHIC_8 && size == 0)
2733 getSizedGraphicSource(graphic, frame, size, &src_bitmap,
2736 width = graphic_info[graphic].width * size / TILESIZE;
2737 height = graphic_info[graphic].height * size / TILESIZE;
2740 BlitBitmapMasked(src_bitmap, drawto, src_x, src_y, width, height,
2743 BlitBitmap(src_bitmap, drawto, src_x, src_y, width, height,
2747 else if (type == TYPE_GRAPHIC)
2749 int graphic = gpc->graphic;
2750 int graphic_active = gpc->graphic_active;
2754 int dst_x = PANEL_XPOS(pos);
2755 int dst_y = PANEL_YPOS(pos);
2756 boolean skip = (pos->class == get_hash_from_key("mm_engine_only") &&
2757 level.game_engine_type != GAME_ENGINE_TYPE_MM);
2759 if (graphic != IMG_UNDEFINED && !skip)
2761 if (pos->style == STYLE_REVERSE)
2762 value = 100 - value;
2764 getGraphicSource(graphic_active, frame, &src_bitmap, &src_x, &src_y);
2766 if (pos->direction & MV_HORIZONTAL)
2768 width = graphic_info[graphic_active].width * value / 100;
2769 height = graphic_info[graphic_active].height;
2771 if (pos->direction == MV_LEFT)
2773 src_x += graphic_info[graphic_active].width - width;
2774 dst_x += graphic_info[graphic_active].width - width;
2779 width = graphic_info[graphic_active].width;
2780 height = graphic_info[graphic_active].height * value / 100;
2782 if (pos->direction == MV_UP)
2784 src_y += graphic_info[graphic_active].height - height;
2785 dst_y += graphic_info[graphic_active].height - height;
2790 BlitBitmapMasked(src_bitmap, drawto, src_x, src_y, width, height,
2793 BlitBitmap(src_bitmap, drawto, src_x, src_y, width, height,
2796 getGraphicSource(graphic, frame, &src_bitmap, &src_x, &src_y);
2798 if (pos->direction & MV_HORIZONTAL)
2800 if (pos->direction == MV_RIGHT)
2807 dst_x = PANEL_XPOS(pos);
2810 width = graphic_info[graphic].width - width;
2814 if (pos->direction == MV_DOWN)
2821 dst_y = PANEL_YPOS(pos);
2824 height = graphic_info[graphic].height - height;
2828 BlitBitmapMasked(src_bitmap, drawto, src_x, src_y, width, height,
2831 BlitBitmap(src_bitmap, drawto, src_x, src_y, width, height,
2835 else if (type == TYPE_STRING)
2837 boolean active = (value != 0);
2838 char *state_normal = "off";
2839 char *state_active = "on";
2840 char *state = (active ? state_active : state_normal);
2841 char *s = (nr == GAME_PANEL_GRAVITY_STATE ? state :
2842 nr == GAME_PANEL_PLAYER_NAME ? setup.player_name :
2843 nr == GAME_PANEL_LEVEL_NAME ? level.name :
2844 nr == GAME_PANEL_LEVEL_AUTHOR ? level.author : NULL);
2846 if (nr == GAME_PANEL_GRAVITY_STATE)
2848 int font1 = pos->font; // (used for normal state)
2849 int font2 = pos->font_alt; // (used for active state)
2851 font = (active ? font2 : font1);
2860 // don't truncate output if "chars" is zero or less
2863 // dynamically correct text alignment
2864 pos->width = size * getFontWidth(font);
2867 s_cut = getStringCopyN(s, size);
2869 DrawTextExt(drawto, PANEL_XPOS(pos), PANEL_YPOS(pos),
2870 s_cut, font, mask_mode);
2876 redraw_mask |= REDRAW_DOOR_1;
2879 SetGameStatus(GAME_MODE_PLAYING);
2882 void UpdateAndDisplayGameControlValues(void)
2884 if (tape.deactivate_display)
2887 UpdateGameControlValues();
2888 DisplayGameControlValues();
2891 void UpdateGameDoorValues(void)
2893 UpdateGameControlValues();
2896 void DrawGameDoorValues(void)
2898 DisplayGameControlValues();
2902 // ============================================================================
2904 // ----------------------------------------------------------------------------
2905 // initialize game engine due to level / tape version number
2906 // ============================================================================
2908 static void InitGameEngine(void)
2910 int i, j, k, l, x, y;
2912 // set game engine from tape file when re-playing, else from level file
2913 game.engine_version = (tape.playing ? tape.engine_version :
2914 level.game_version);
2916 // set single or multi-player game mode (needed for re-playing tapes)
2917 game.team_mode = setup.team_mode;
2921 int num_players = 0;
2923 for (i = 0; i < MAX_PLAYERS; i++)
2924 if (tape.player_participates[i])
2927 // multi-player tapes contain input data for more than one player
2928 game.team_mode = (num_players > 1);
2932 Debug("game:init:level", "level %d: level.game_version == %06d", level_nr,
2933 level.game_version);
2934 Debug("game:init:level", " tape.file_version == %06d",
2936 Debug("game:init:level", " tape.game_version == %06d",
2938 Debug("game:init:level", " tape.engine_version == %06d",
2939 tape.engine_version);
2940 Debug("game:init:level", " => game.engine_version == %06d [tape mode: %s]",
2941 game.engine_version, (tape.playing ? "PLAYING" : "RECORDING"));
2944 // --------------------------------------------------------------------------
2945 // set flags for bugs and changes according to active game engine version
2946 // --------------------------------------------------------------------------
2950 Fixed property "can fall" for run-time element "EL_AMOEBA_DROPPING"
2952 Bug was introduced in version:
2955 Bug was fixed in version:
2959 In version 2.0.1, a new run-time element "EL_AMOEBA_DROPPING" was added,
2960 but the property "can fall" was missing, which caused some levels to be
2961 unsolvable. This was fixed in version 4.2.0.0.
2963 Affected levels/tapes:
2964 An example for a tape that was fixed by this bugfix is tape 029 from the
2965 level set "rnd_sam_bateman".
2966 The wrong behaviour will still be used for all levels or tapes that were
2967 created/recorded with it. An example for this is tape 023 from the level
2968 set "rnd_gerhard_haeusler", which was recorded with a buggy game engine.
2971 boolean use_amoeba_dropping_cannot_fall_bug =
2972 ((game.engine_version >= VERSION_IDENT(2,0,1,0) &&
2973 game.engine_version < VERSION_IDENT(4,2,0,0)) ||
2975 tape.game_version >= VERSION_IDENT(2,0,1,0) &&
2976 tape.game_version < VERSION_IDENT(4,2,0,0)));
2979 Summary of bugfix/change:
2980 Fixed move speed of elements entering or leaving magic wall.
2982 Fixed/changed in version:
2986 Before 2.0.1, move speed of elements entering or leaving magic wall was
2987 twice as fast as it is now.
2988 Since 2.0.1, this is set to a lower value by using move_stepsize_list[].
2990 Affected levels/tapes:
2991 The first condition is generally needed for all levels/tapes before version
2992 2.0.1, which might use the old behaviour before it was changed; known tapes
2993 that are affected: Tape 014 from the level set "rnd_conor_mancone".
2994 The second condition is an exception from the above case and is needed for
2995 the special case of tapes recorded with game (not engine!) version 2.0.1 or
2996 above, but before it was known that this change would break tapes like the
2997 above and was fixed in 4.2.0.0, so that the changed behaviour was active
2998 although the engine version while recording maybe was before 2.0.1. There
2999 are a lot of tapes that are affected by this exception, like tape 006 from
3000 the level set "rnd_conor_mancone".
3003 boolean use_old_move_stepsize_for_magic_wall =
3004 (game.engine_version < VERSION_IDENT(2,0,1,0) &&
3006 tape.game_version >= VERSION_IDENT(2,0,1,0) &&
3007 tape.game_version < VERSION_IDENT(4,2,0,0)));
3010 Summary of bugfix/change:
3011 Fixed handling for custom elements that change when pushed by the player.
3013 Fixed/changed in version:
3017 Before 3.1.0, custom elements that "change when pushing" changed directly
3018 after the player started pushing them (until then handled in "DigField()").
3019 Since 3.1.0, these custom elements are not changed until the "pushing"
3020 move of the element is finished (now handled in "ContinueMoving()").
3022 Affected levels/tapes:
3023 The first condition is generally needed for all levels/tapes before version
3024 3.1.0, which might use the old behaviour before it was changed; known tapes
3025 that are affected are some tapes from the level set "Walpurgis Gardens" by
3027 The second condition is an exception from the above case and is needed for
3028 the special case of tapes recorded with game (not engine!) version 3.1.0 or
3029 above (including some development versions of 3.1.0), but before it was
3030 known that this change would break tapes like the above and was fixed in
3031 3.1.1, so that the changed behaviour was active although the engine version
3032 while recording maybe was before 3.1.0. There is at least one tape that is
3033 affected by this exception, which is the tape for the one-level set "Bug
3034 Machine" by Juergen Bonhagen.
3037 game.use_change_when_pushing_bug =
3038 (game.engine_version < VERSION_IDENT(3,1,0,0) &&
3040 tape.game_version >= VERSION_IDENT(3,1,0,0) &&
3041 tape.game_version < VERSION_IDENT(3,1,1,0)));
3044 Summary of bugfix/change:
3045 Fixed handling for blocking the field the player leaves when moving.
3047 Fixed/changed in version:
3051 Before 3.1.1, when "block last field when moving" was enabled, the field
3052 the player is leaving when moving was blocked for the time of the move,
3053 and was directly unblocked afterwards. This resulted in the last field
3054 being blocked for exactly one less than the number of frames of one player
3055 move. Additionally, even when blocking was disabled, the last field was
3056 blocked for exactly one frame.
3057 Since 3.1.1, due to changes in player movement handling, the last field
3058 is not blocked at all when blocking is disabled. When blocking is enabled,
3059 the last field is blocked for exactly the number of frames of one player
3060 move. Additionally, if the player is Murphy, the hero of Supaplex, the
3061 last field is blocked for exactly one more than the number of frames of
3064 Affected levels/tapes:
3065 (!!! yet to be determined -- probably many !!!)
3068 game.use_block_last_field_bug =
3069 (game.engine_version < VERSION_IDENT(3,1,1,0));
3071 /* various special flags and settings for native Emerald Mine game engine */
3073 game_em.use_single_button =
3074 (game.engine_version > VERSION_IDENT(4,0,0,2));
3076 game_em.use_snap_key_bug =
3077 (game.engine_version < VERSION_IDENT(4,0,1,0));
3079 game_em.use_random_bug =
3080 (tape.property_bits & TAPE_PROPERTY_EM_RANDOM_BUG);
3082 boolean use_old_em_engine = (game.engine_version < VERSION_IDENT(4,2,0,0));
3084 game_em.use_old_explosions = use_old_em_engine;
3085 game_em.use_old_android = use_old_em_engine;
3086 game_em.use_old_push_elements = use_old_em_engine;
3087 game_em.use_old_push_into_acid = use_old_em_engine;
3089 game_em.use_wrap_around = !use_old_em_engine;
3091 // --------------------------------------------------------------------------
3093 // set maximal allowed number of custom element changes per game frame
3094 game.max_num_changes_per_frame = 1;
3096 // default scan direction: scan playfield from top/left to bottom/right
3097 InitPlayfieldScanMode(CA_ARG_SCAN_MODE_NORMAL);
3099 // dynamically adjust element properties according to game engine version
3100 InitElementPropertiesEngine(game.engine_version);
3102 // ---------- initialize special element properties -------------------------
3104 // "EL_AMOEBA_DROPPING" missed property "can fall" in older game versions
3105 if (use_amoeba_dropping_cannot_fall_bug)
3106 SET_PROPERTY(EL_AMOEBA_DROPPING, EP_CAN_FALL, FALSE);
3108 // ---------- initialize player's initial move delay ------------------------
3110 // dynamically adjust player properties according to level information
3111 for (i = 0; i < MAX_PLAYERS; i++)
3112 game.initial_move_delay_value[i] =
3113 get_move_delay_from_stepsize(level.initial_player_stepsize[i]);
3115 // dynamically adjust player properties according to game engine version
3116 for (i = 0; i < MAX_PLAYERS; i++)
3117 game.initial_move_delay[i] =
3118 (game.engine_version <= VERSION_IDENT(2,0,1,0) ?
3119 game.initial_move_delay_value[i] : 0);
3121 // ---------- initialize player's initial push delay ------------------------
3123 // dynamically adjust player properties according to game engine version
3124 game.initial_push_delay_value =
3125 (game.engine_version < VERSION_IDENT(3,0,7,1) ? 5 : -1);
3127 // ---------- initialize changing elements ----------------------------------
3129 // initialize changing elements information
3130 for (i = 0; i < MAX_NUM_ELEMENTS; i++)
3132 struct ElementInfo *ei = &element_info[i];
3134 // this pointer might have been changed in the level editor
3135 ei->change = &ei->change_page[0];
3137 if (!IS_CUSTOM_ELEMENT(i))
3139 ei->change->target_element = EL_EMPTY_SPACE;
3140 ei->change->delay_fixed = 0;
3141 ei->change->delay_random = 0;
3142 ei->change->delay_frames = 1;
3145 for (j = 0; j < NUM_CHANGE_EVENTS; j++)
3147 ei->has_change_event[j] = FALSE;
3149 ei->event_page_nr[j] = 0;
3150 ei->event_page[j] = &ei->change_page[0];
3154 // add changing elements from pre-defined list
3155 for (i = 0; change_delay_list[i].element != EL_UNDEFINED; i++)
3157 struct ChangingElementInfo *ch_delay = &change_delay_list[i];
3158 struct ElementInfo *ei = &element_info[ch_delay->element];
3160 ei->change->target_element = ch_delay->target_element;
3161 ei->change->delay_fixed = ch_delay->change_delay;
3163 ei->change->pre_change_function = ch_delay->pre_change_function;
3164 ei->change->change_function = ch_delay->change_function;
3165 ei->change->post_change_function = ch_delay->post_change_function;
3167 ei->change->can_change = TRUE;
3168 ei->change->can_change_or_has_action = TRUE;
3170 ei->has_change_event[CE_DELAY] = TRUE;
3172 SET_PROPERTY(ch_delay->element, EP_CAN_CHANGE, TRUE);
3173 SET_PROPERTY(ch_delay->element, EP_CAN_CHANGE_OR_HAS_ACTION, TRUE);
3176 // ---------- initialize internal run-time variables ------------------------
3178 for (i = 0; i < NUM_CUSTOM_ELEMENTS; i++)
3180 struct ElementInfo *ei = &element_info[EL_CUSTOM_START + i];
3182 for (j = 0; j < ei->num_change_pages; j++)
3184 ei->change_page[j].can_change_or_has_action =
3185 (ei->change_page[j].can_change |
3186 ei->change_page[j].has_action);
3190 // add change events from custom element configuration
3191 for (i = 0; i < NUM_CUSTOM_ELEMENTS; i++)
3193 struct ElementInfo *ei = &element_info[EL_CUSTOM_START + i];
3195 for (j = 0; j < ei->num_change_pages; j++)
3197 if (!ei->change_page[j].can_change_or_has_action)
3200 for (k = 0; k < NUM_CHANGE_EVENTS; k++)
3202 // only add event page for the first page found with this event
3203 if (ei->change_page[j].has_event[k] && !(ei->has_change_event[k]))
3205 ei->has_change_event[k] = TRUE;
3207 ei->event_page_nr[k] = j;
3208 ei->event_page[k] = &ei->change_page[j];
3214 // ---------- initialize reference elements in change conditions ------------
3216 for (i = 0; i < NUM_CUSTOM_ELEMENTS; i++)
3218 int element = EL_CUSTOM_START + i;
3219 struct ElementInfo *ei = &element_info[element];
3221 for (j = 0; j < ei->num_change_pages; j++)
3223 int trigger_element = ei->change_page[j].initial_trigger_element;
3225 if (trigger_element >= EL_PREV_CE_8 &&
3226 trigger_element <= EL_NEXT_CE_8)
3227 trigger_element = RESOLVED_REFERENCE_ELEMENT(element, trigger_element);
3229 ei->change_page[j].trigger_element = trigger_element;
3233 // ---------- initialize run-time trigger player and element ----------------
3235 for (i = 0; i < NUM_CUSTOM_ELEMENTS; i++)
3237 struct ElementInfo *ei = &element_info[EL_CUSTOM_START + i];
3239 for (j = 0; j < ei->num_change_pages; j++)
3241 ei->change_page[j].actual_trigger_element = EL_EMPTY;
3242 ei->change_page[j].actual_trigger_player = EL_EMPTY;
3243 ei->change_page[j].actual_trigger_player_bits = CH_PLAYER_NONE;
3244 ei->change_page[j].actual_trigger_side = CH_SIDE_NONE;
3245 ei->change_page[j].actual_trigger_ce_value = 0;
3246 ei->change_page[j].actual_trigger_ce_score = 0;
3250 // ---------- initialize trigger events -------------------------------------
3252 // initialize trigger events information
3253 for (i = 0; i < MAX_NUM_ELEMENTS; i++)
3254 for (j = 0; j < NUM_CHANGE_EVENTS; j++)
3255 trigger_events[i][j] = FALSE;
3257 // add trigger events from element change event properties
3258 for (i = 0; i < MAX_NUM_ELEMENTS; i++)
3260 struct ElementInfo *ei = &element_info[i];
3262 for (j = 0; j < ei->num_change_pages; j++)
3264 if (!ei->change_page[j].can_change_or_has_action)
3267 if (ei->change_page[j].has_event[CE_BY_OTHER_ACTION])
3269 int trigger_element = ei->change_page[j].trigger_element;
3271 for (k = 0; k < NUM_CHANGE_EVENTS; k++)
3273 if (ei->change_page[j].has_event[k])
3275 if (IS_GROUP_ELEMENT(trigger_element))
3277 struct ElementGroupInfo *group =
3278 element_info[trigger_element].group;
3280 for (l = 0; l < group->num_elements_resolved; l++)
3281 trigger_events[group->element_resolved[l]][k] = TRUE;
3283 else if (trigger_element == EL_ANY_ELEMENT)
3284 for (l = 0; l < MAX_NUM_ELEMENTS; l++)
3285 trigger_events[l][k] = TRUE;
3287 trigger_events[trigger_element][k] = TRUE;
3294 // ---------- initialize push delay -----------------------------------------
3296 // initialize push delay values to default
3297 for (i = 0; i < MAX_NUM_ELEMENTS; i++)
3299 if (!IS_CUSTOM_ELEMENT(i))
3301 // set default push delay values (corrected since version 3.0.7-1)
3302 if (game.engine_version < VERSION_IDENT(3,0,7,1))
3304 element_info[i].push_delay_fixed = 2;
3305 element_info[i].push_delay_random = 8;
3309 element_info[i].push_delay_fixed = 8;
3310 element_info[i].push_delay_random = 8;
3315 // set push delay value for certain elements from pre-defined list
3316 for (i = 0; push_delay_list[i].element != EL_UNDEFINED; i++)
3318 int e = push_delay_list[i].element;
3320 element_info[e].push_delay_fixed = push_delay_list[i].push_delay_fixed;
3321 element_info[e].push_delay_random = push_delay_list[i].push_delay_random;
3324 // set push delay value for Supaplex elements for newer engine versions
3325 if (game.engine_version >= VERSION_IDENT(3,1,0,0))
3327 for (i = 0; i < MAX_NUM_ELEMENTS; i++)
3329 if (IS_SP_ELEMENT(i))
3331 // set SP push delay to just enough to push under a falling zonk
3332 int delay = (game.engine_version >= VERSION_IDENT(3,1,1,0) ? 8 : 6);
3334 element_info[i].push_delay_fixed = delay;
3335 element_info[i].push_delay_random = 0;
3340 // ---------- initialize move stepsize --------------------------------------
3342 // initialize move stepsize values to default
3343 for (i = 0; i < MAX_NUM_ELEMENTS; i++)
3344 if (!IS_CUSTOM_ELEMENT(i))
3345 element_info[i].move_stepsize = MOVE_STEPSIZE_NORMAL;
3347 // set move stepsize value for certain elements from pre-defined list
3348 for (i = 0; move_stepsize_list[i].element != EL_UNDEFINED; i++)
3350 int e = move_stepsize_list[i].element;
3352 element_info[e].move_stepsize = move_stepsize_list[i].move_stepsize;
3354 // set move stepsize value for certain elements for older engine versions
3355 if (use_old_move_stepsize_for_magic_wall)
3357 if (e == EL_MAGIC_WALL_FILLING ||
3358 e == EL_MAGIC_WALL_EMPTYING ||
3359 e == EL_BD_MAGIC_WALL_FILLING ||
3360 e == EL_BD_MAGIC_WALL_EMPTYING)
3361 element_info[e].move_stepsize *= 2;
3365 // ---------- initialize collect score --------------------------------------
3367 // initialize collect score values for custom elements from initial value
3368 for (i = 0; i < MAX_NUM_ELEMENTS; i++)
3369 if (IS_CUSTOM_ELEMENT(i))
3370 element_info[i].collect_score = element_info[i].collect_score_initial;
3372 // ---------- initialize collect count --------------------------------------
3374 // initialize collect count values for non-custom elements
3375 for (i = 0; i < MAX_NUM_ELEMENTS; i++)
3376 if (!IS_CUSTOM_ELEMENT(i))
3377 element_info[i].collect_count_initial = 0;
3379 // add collect count values for all elements from pre-defined list
3380 for (i = 0; collect_count_list[i].element != EL_UNDEFINED; i++)
3381 element_info[collect_count_list[i].element].collect_count_initial =
3382 collect_count_list[i].count;
3384 // ---------- initialize access direction -----------------------------------
3386 // initialize access direction values to default (access from every side)
3387 for (i = 0; i < MAX_NUM_ELEMENTS; i++)
3388 if (!IS_CUSTOM_ELEMENT(i))
3389 element_info[i].access_direction = MV_ALL_DIRECTIONS;
3391 // set access direction value for certain elements from pre-defined list
3392 for (i = 0; access_direction_list[i].element != EL_UNDEFINED; i++)
3393 element_info[access_direction_list[i].element].access_direction =
3394 access_direction_list[i].direction;
3396 // ---------- initialize explosion content ----------------------------------
3397 for (i = 0; i < MAX_NUM_ELEMENTS; i++)
3399 if (IS_CUSTOM_ELEMENT(i))
3402 for (y = 0; y < 3; y++) for (x = 0; x < 3; x++)
3404 // (content for EL_YAMYAM set at run-time with game.yamyam_content_nr)
3406 element_info[i].content.e[x][y] =
3407 (i == EL_PLAYER_1 ? EL_EMERALD_YELLOW :
3408 i == EL_PLAYER_2 ? EL_EMERALD_RED :
3409 i == EL_PLAYER_3 ? EL_EMERALD :
3410 i == EL_PLAYER_4 ? EL_EMERALD_PURPLE :
3411 i == EL_MOLE ? EL_EMERALD_RED :
3412 i == EL_PENGUIN ? EL_EMERALD_PURPLE :
3413 i == EL_BUG ? (x == 1 && y == 1 ? EL_DIAMOND : EL_EMERALD) :
3414 i == EL_BD_BUTTERFLY ? EL_BD_DIAMOND :
3415 i == EL_SP_ELECTRON ? EL_SP_INFOTRON :
3416 i == EL_AMOEBA_TO_DIAMOND ? level.amoeba_content :
3417 i == EL_WALL_EMERALD ? EL_EMERALD :
3418 i == EL_WALL_DIAMOND ? EL_DIAMOND :
3419 i == EL_WALL_BD_DIAMOND ? EL_BD_DIAMOND :
3420 i == EL_WALL_EMERALD_YELLOW ? EL_EMERALD_YELLOW :
3421 i == EL_WALL_EMERALD_RED ? EL_EMERALD_RED :
3422 i == EL_WALL_EMERALD_PURPLE ? EL_EMERALD_PURPLE :
3423 i == EL_WALL_PEARL ? EL_PEARL :
3424 i == EL_WALL_CRYSTAL ? EL_CRYSTAL :
3429 // ---------- initialize recursion detection --------------------------------
3430 recursion_loop_depth = 0;
3431 recursion_loop_detected = FALSE;
3432 recursion_loop_element = EL_UNDEFINED;
3434 // ---------- initialize graphics engine ------------------------------------
3435 game.scroll_delay_value =
3436 (game.forced_scroll_delay_value != -1 ? game.forced_scroll_delay_value :
3437 level.game_engine_type == GAME_ENGINE_TYPE_EM &&
3438 !setup.forced_scroll_delay ? 0 :
3439 setup.scroll_delay ? setup.scroll_delay_value : 0);
3440 game.scroll_delay_value =
3441 MIN(MAX(MIN_SCROLL_DELAY, game.scroll_delay_value), MAX_SCROLL_DELAY);
3443 // ---------- initialize game engine snapshots ------------------------------
3444 for (i = 0; i < MAX_PLAYERS; i++)
3445 game.snapshot.last_action[i] = 0;
3446 game.snapshot.changed_action = FALSE;
3447 game.snapshot.collected_item = FALSE;
3448 game.snapshot.mode =
3449 (strEqual(setup.engine_snapshot_mode, STR_SNAPSHOT_MODE_EVERY_STEP) ?
3450 SNAPSHOT_MODE_EVERY_STEP :
3451 strEqual(setup.engine_snapshot_mode, STR_SNAPSHOT_MODE_EVERY_MOVE) ?
3452 SNAPSHOT_MODE_EVERY_MOVE :
3453 strEqual(setup.engine_snapshot_mode, STR_SNAPSHOT_MODE_EVERY_COLLECT) ?
3454 SNAPSHOT_MODE_EVERY_COLLECT : SNAPSHOT_MODE_OFF);
3455 game.snapshot.save_snapshot = FALSE;
3457 // ---------- initialize level time for Supaplex engine ---------------------
3458 // Supaplex levels with time limit currently unsupported -- should be added
3459 if (level.game_engine_type == GAME_ENGINE_TYPE_SP)
3462 // ---------- initialize flags for handling game actions --------------------
3464 // set flags for game actions to default values
3465 game.use_key_actions = TRUE;
3466 game.use_mouse_actions = FALSE;
3468 // when using Mirror Magic game engine, handle mouse events only
3469 if (level.game_engine_type == GAME_ENGINE_TYPE_MM)
3471 game.use_key_actions = FALSE;
3472 game.use_mouse_actions = TRUE;
3475 // check for custom elements with mouse click events
3476 if (level.game_engine_type == GAME_ENGINE_TYPE_RND)
3478 for (i = 0; i < NUM_CUSTOM_ELEMENTS; i++)
3480 int element = EL_CUSTOM_START + i;
3482 if (HAS_CHANGE_EVENT(element, CE_CLICKED_BY_MOUSE) ||
3483 HAS_CHANGE_EVENT(element, CE_PRESSED_BY_MOUSE) ||
3484 HAS_CHANGE_EVENT(element, CE_MOUSE_CLICKED_ON_X) ||
3485 HAS_CHANGE_EVENT(element, CE_MOUSE_PRESSED_ON_X))
3486 game.use_mouse_actions = TRUE;
3491 static int get_num_special_action(int element, int action_first,
3494 int num_special_action = 0;
3497 for (i = action_first; i <= action_last; i++)
3499 boolean found = FALSE;
3501 for (j = 0; j < NUM_DIRECTIONS; j++)
3502 if (el_act_dir2img(element, i, j) !=
3503 el_act_dir2img(element, ACTION_DEFAULT, j))
3507 num_special_action++;
3512 return num_special_action;
3516 // ============================================================================
3518 // ----------------------------------------------------------------------------
3519 // initialize and start new game
3520 // ============================================================================
3522 #if DEBUG_INIT_PLAYER
3523 static void DebugPrintPlayerStatus(char *message)
3530 Debug("game:init:player", "%s:", message);
3532 for (i = 0; i < MAX_PLAYERS; i++)
3534 struct PlayerInfo *player = &stored_player[i];
3536 Debug("game:init:player",
3537 "- player %d: present == %d, connected == %d [%d/%d], active == %d%s",
3541 player->connected_locally,
3542 player->connected_network,
3544 (local_player == player ? " (local player)" : ""));
3551 int full_lev_fieldx = lev_fieldx + (BorderElement != EL_EMPTY ? 2 : 0);
3552 int full_lev_fieldy = lev_fieldy + (BorderElement != EL_EMPTY ? 2 : 0);
3553 int fade_mask = REDRAW_FIELD;
3555 boolean emulate_bd = TRUE; // unless non-BOULDERDASH elements found
3556 boolean emulate_sp = TRUE; // unless non-SUPAPLEX elements found
3557 int initial_move_dir = MV_DOWN;
3560 // required here to update video display before fading (FIX THIS)
3561 DrawMaskedBorder(REDRAW_DOOR_2);
3563 if (!game.restart_level)
3564 CloseDoor(DOOR_CLOSE_1);
3566 SetGameStatus(GAME_MODE_PLAYING);
3568 if (level_editor_test_game)
3569 FadeSkipNextFadeOut();
3571 FadeSetEnterScreen();
3574 fade_mask = REDRAW_ALL;
3576 FadeLevelSoundsAndMusic();
3578 ExpireSoundLoops(TRUE);
3582 if (level_editor_test_game)
3583 FadeSkipNextFadeIn();
3585 // needed if different viewport properties defined for playing
3586 ChangeViewportPropertiesIfNeeded();
3590 DrawCompleteVideoDisplay();
3592 OpenDoor(GetDoorState() | DOOR_NO_DELAY | DOOR_FORCE_REDRAW);
3595 InitGameControlValues();
3599 // initialize tape actions from game when recording tape
3600 tape.use_key_actions = game.use_key_actions;
3601 tape.use_mouse_actions = game.use_mouse_actions;
3603 // initialize visible playfield size when recording tape (for team mode)
3604 tape.scr_fieldx = SCR_FIELDX;
3605 tape.scr_fieldy = SCR_FIELDY;
3608 // don't play tapes over network
3609 network_playing = (network.enabled && !tape.playing);
3611 for (i = 0; i < MAX_PLAYERS; i++)
3613 struct PlayerInfo *player = &stored_player[i];
3615 player->index_nr = i;
3616 player->index_bit = (1 << i);
3617 player->element_nr = EL_PLAYER_1 + i;
3619 player->present = FALSE;
3620 player->active = FALSE;
3621 player->mapped = FALSE;
3623 player->killed = FALSE;
3624 player->reanimated = FALSE;
3625 player->buried = FALSE;
3628 player->effective_action = 0;
3629 player->programmed_action = 0;
3630 player->snap_action = 0;
3632 player->mouse_action.lx = 0;
3633 player->mouse_action.ly = 0;
3634 player->mouse_action.button = 0;
3635 player->mouse_action.button_hint = 0;
3637 player->effective_mouse_action.lx = 0;
3638 player->effective_mouse_action.ly = 0;
3639 player->effective_mouse_action.button = 0;
3640 player->effective_mouse_action.button_hint = 0;
3642 for (j = 0; j < MAX_NUM_KEYS; j++)
3643 player->key[j] = FALSE;
3645 player->num_white_keys = 0;
3647 player->dynabomb_count = 0;
3648 player->dynabomb_size = 1;
3649 player->dynabombs_left = 0;
3650 player->dynabomb_xl = FALSE;
3652 player->MovDir = initial_move_dir;
3655 player->GfxDir = initial_move_dir;
3656 player->GfxAction = ACTION_DEFAULT;
3658 player->StepFrame = 0;
3660 player->initial_element = player->element_nr;
3661 player->artwork_element =
3662 (level.use_artwork_element[i] ? level.artwork_element[i] :
3663 player->element_nr);
3664 player->use_murphy = FALSE;
3666 player->block_last_field = FALSE; // initialized in InitPlayerField()
3667 player->block_delay_adjustment = 0; // initialized in InitPlayerField()
3669 player->gravity = level.initial_player_gravity[i];
3671 player->can_fall_into_acid = CAN_MOVE_INTO_ACID(player->element_nr);
3673 player->actual_frame_counter = 0;
3675 player->step_counter = 0;
3677 player->last_move_dir = initial_move_dir;
3679 player->is_active = FALSE;
3681 player->is_waiting = FALSE;
3682 player->is_moving = FALSE;
3683 player->is_auto_moving = FALSE;
3684 player->is_digging = FALSE;
3685 player->is_snapping = FALSE;
3686 player->is_collecting = FALSE;
3687 player->is_pushing = FALSE;
3688 player->is_switching = FALSE;
3689 player->is_dropping = FALSE;
3690 player->is_dropping_pressed = FALSE;
3692 player->is_bored = FALSE;
3693 player->is_sleeping = FALSE;
3695 player->was_waiting = TRUE;
3696 player->was_moving = FALSE;
3697 player->was_snapping = FALSE;
3698 player->was_dropping = FALSE;
3700 player->force_dropping = FALSE;
3702 player->frame_counter_bored = -1;
3703 player->frame_counter_sleeping = -1;
3705 player->anim_delay_counter = 0;
3706 player->post_delay_counter = 0;
3708 player->dir_waiting = initial_move_dir;
3709 player->action_waiting = ACTION_DEFAULT;
3710 player->last_action_waiting = ACTION_DEFAULT;
3711 player->special_action_bored = ACTION_DEFAULT;
3712 player->special_action_sleeping = ACTION_DEFAULT;
3714 player->switch_x = -1;
3715 player->switch_y = -1;
3717 player->drop_x = -1;
3718 player->drop_y = -1;
3720 player->show_envelope = 0;
3722 SetPlayerMoveSpeed(player, level.initial_player_stepsize[i], TRUE);
3724 player->push_delay = -1; // initialized when pushing starts
3725 player->push_delay_value = game.initial_push_delay_value;
3727 player->drop_delay = 0;
3728 player->drop_pressed_delay = 0;
3730 player->last_jx = -1;
3731 player->last_jy = -1;
3735 player->shield_normal_time_left = 0;
3736 player->shield_deadly_time_left = 0;
3738 player->last_removed_element = EL_UNDEFINED;
3740 player->inventory_infinite_element = EL_UNDEFINED;
3741 player->inventory_size = 0;
3743 if (level.use_initial_inventory[i])
3745 for (j = 0; j < level.initial_inventory_size[i]; j++)
3747 int element = level.initial_inventory_content[i][j];
3748 int collect_count = element_info[element].collect_count_initial;
3751 if (!IS_CUSTOM_ELEMENT(element))
3754 if (collect_count == 0)
3755 player->inventory_infinite_element = element;
3757 for (k = 0; k < collect_count; k++)
3758 if (player->inventory_size < MAX_INVENTORY_SIZE)
3759 player->inventory_element[player->inventory_size++] = element;
3763 DigField(player, 0, 0, 0, 0, 0, 0, DF_NO_PUSH);
3764 SnapField(player, 0, 0);
3766 map_player_action[i] = i;
3769 network_player_action_received = FALSE;
3771 // initial null action
3772 if (network_playing)
3773 SendToServer_MovePlayer(MV_NONE);
3778 TimeLeft = level.time;
3781 ScreenMovDir = MV_NONE;
3785 ScrollStepSize = 0; // will be correctly initialized by ScrollScreen()
3787 game.robot_wheel_x = -1;
3788 game.robot_wheel_y = -1;
3793 game.all_players_gone = FALSE;
3795 game.LevelSolved = FALSE;
3796 game.GameOver = FALSE;
3798 game.GamePlayed = !tape.playing;
3800 game.LevelSolved_GameWon = FALSE;
3801 game.LevelSolved_GameEnd = FALSE;
3802 game.LevelSolved_SaveTape = FALSE;
3803 game.LevelSolved_SaveScore = FALSE;
3805 game.LevelSolved_CountingTime = 0;
3806 game.LevelSolved_CountingScore = 0;
3807 game.LevelSolved_CountingHealth = 0;
3809 game.panel.active = TRUE;
3811 game.no_time_limit = (level.time == 0);
3813 game.yamyam_content_nr = 0;
3814 game.robot_wheel_active = FALSE;
3815 game.magic_wall_active = FALSE;
3816 game.magic_wall_time_left = 0;
3817 game.light_time_left = 0;
3818 game.timegate_time_left = 0;
3819 game.switchgate_pos = 0;
3820 game.wind_direction = level.wind_direction_initial;
3822 game.time_final = 0;
3823 game.score_time_final = 0;
3826 game.score_final = 0;
3828 game.health = MAX_HEALTH;
3829 game.health_final = MAX_HEALTH;
3831 game.gems_still_needed = level.gems_needed;
3832 game.sokoban_fields_still_needed = 0;
3833 game.sokoban_objects_still_needed = 0;
3834 game.lights_still_needed = 0;
3835 game.players_still_needed = 0;
3836 game.friends_still_needed = 0;
3838 game.lenses_time_left = 0;
3839 game.magnify_time_left = 0;
3841 game.ball_active = level.ball_active_initial;
3842 game.ball_content_nr = 0;
3844 game.explosions_delayed = TRUE;
3846 game.envelope_active = FALSE;
3848 // special case: set custom artwork setting to initial value
3849 game.use_masked_elements = game.use_masked_elements_initial;
3851 for (i = 0; i < NUM_BELTS; i++)
3853 game.belt_dir[i] = MV_NONE;
3854 game.belt_dir_nr[i] = 3; // not moving, next moving left
3857 for (i = 0; i < MAX_NUM_AMOEBA; i++)
3858 AmoebaCnt[i] = AmoebaCnt2[i] = 0;
3860 #if DEBUG_INIT_PLAYER
3861 DebugPrintPlayerStatus("Player status at level initialization");
3864 SCAN_PLAYFIELD(x, y)
3866 Tile[x][y] = Last[x][y] = level.field[x][y];
3867 MovPos[x][y] = MovDir[x][y] = MovDelay[x][y] = 0;
3868 ChangeDelay[x][y] = 0;
3869 ChangePage[x][y] = -1;
3870 CustomValue[x][y] = 0; // initialized in InitField()
3871 Store[x][y] = Store2[x][y] = StorePlayer[x][y] = Back[x][y] = 0;
3873 WasJustMoving[x][y] = 0;
3874 WasJustFalling[x][y] = 0;
3875 CheckCollision[x][y] = 0;
3876 CheckImpact[x][y] = 0;
3878 Pushed[x][y] = FALSE;
3880 ChangeCount[x][y] = 0;
3881 ChangeEvent[x][y] = -1;
3883 ExplodePhase[x][y] = 0;
3884 ExplodeDelay[x][y] = 0;
3885 ExplodeField[x][y] = EX_TYPE_NONE;
3887 RunnerVisit[x][y] = 0;
3888 PlayerVisit[x][y] = 0;
3891 GfxRandom[x][y] = INIT_GFX_RANDOM();
3892 GfxRandomStatic[x][y] = INIT_GFX_RANDOM();
3893 GfxElement[x][y] = EL_UNDEFINED;
3894 GfxElementEmpty[x][y] = EL_EMPTY;
3895 GfxAction[x][y] = ACTION_DEFAULT;
3896 GfxDir[x][y] = MV_NONE;
3897 GfxRedraw[x][y] = GFX_REDRAW_NONE;
3900 SCAN_PLAYFIELD(x, y)
3902 if (emulate_bd && !IS_BD_ELEMENT(Tile[x][y]))
3904 if (emulate_sp && !IS_SP_ELEMENT(Tile[x][y]))
3907 InitField(x, y, TRUE);
3909 ResetGfxAnimation(x, y);
3914 for (i = 0; i < MAX_PLAYERS; i++)
3916 struct PlayerInfo *player = &stored_player[i];
3918 // set number of special actions for bored and sleeping animation
3919 player->num_special_action_bored =
3920 get_num_special_action(player->artwork_element,
3921 ACTION_BORING_1, ACTION_BORING_LAST);
3922 player->num_special_action_sleeping =
3923 get_num_special_action(player->artwork_element,
3924 ACTION_SLEEPING_1, ACTION_SLEEPING_LAST);
3927 game.emulation = (emulate_bd ? EMU_BOULDERDASH :
3928 emulate_sp ? EMU_SUPAPLEX : EMU_NONE);
3930 // initialize type of slippery elements
3931 for (i = 0; i < MAX_NUM_ELEMENTS; i++)
3933 if (!IS_CUSTOM_ELEMENT(i))
3935 // default: elements slip down either to the left or right randomly
3936 element_info[i].slippery_type = SLIPPERY_ANY_RANDOM;
3938 // SP style elements prefer to slip down on the left side
3939 if (game.engine_version >= VERSION_IDENT(3,1,1,0) && IS_SP_ELEMENT(i))
3940 element_info[i].slippery_type = SLIPPERY_ANY_LEFT_RIGHT;
3942 // BD style elements prefer to slip down on the left side
3943 if (game.emulation == EMU_BOULDERDASH)
3944 element_info[i].slippery_type = SLIPPERY_ANY_LEFT_RIGHT;
3948 // initialize explosion and ignition delay
3949 for (i = 0; i < MAX_NUM_ELEMENTS; i++)
3951 if (!IS_CUSTOM_ELEMENT(i))
3954 int delay = (((IS_SP_ELEMENT(i) && i != EL_EMPTY_SPACE) &&
3955 game.engine_version >= VERSION_IDENT(3,1,0,0)) ||
3956 game.emulation == EMU_SUPAPLEX ? 3 : 2);
3957 int last_phase = (num_phase + 1) * delay;
3958 int half_phase = (num_phase / 2) * delay;
3960 element_info[i].explosion_delay = last_phase - 1;
3961 element_info[i].ignition_delay = half_phase;
3963 if (i == EL_BLACK_ORB)
3964 element_info[i].ignition_delay = 1;
3968 // correct non-moving belts to start moving left
3969 for (i = 0; i < NUM_BELTS; i++)
3970 if (game.belt_dir[i] == MV_NONE)
3971 game.belt_dir_nr[i] = 3; // not moving, next moving left
3973 #if USE_NEW_PLAYER_ASSIGNMENTS
3974 // use preferred player also in local single-player mode
3975 if (!network.enabled && !game.team_mode)
3977 int new_index_nr = setup.network_player_nr;
3979 if (new_index_nr >= 0 && new_index_nr < MAX_PLAYERS)
3981 for (i = 0; i < MAX_PLAYERS; i++)
3982 stored_player[i].connected_locally = FALSE;
3984 stored_player[new_index_nr].connected_locally = TRUE;
3988 for (i = 0; i < MAX_PLAYERS; i++)
3990 stored_player[i].connected = FALSE;
3992 // in network game mode, the local player might not be the first player
3993 if (stored_player[i].connected_locally)
3994 local_player = &stored_player[i];
3997 if (!network.enabled)
3998 local_player->connected = TRUE;
4002 for (i = 0; i < MAX_PLAYERS; i++)
4003 stored_player[i].connected = tape.player_participates[i];
4005 else if (network.enabled)
4007 // add team mode players connected over the network (needed for correct
4008 // assignment of player figures from level to locally playing players)
4010 for (i = 0; i < MAX_PLAYERS; i++)
4011 if (stored_player[i].connected_network)
4012 stored_player[i].connected = TRUE;
4014 else if (game.team_mode)
4016 // try to guess locally connected team mode players (needed for correct
4017 // assignment of player figures from level to locally playing players)
4019 for (i = 0; i < MAX_PLAYERS; i++)
4020 if (setup.input[i].use_joystick ||
4021 setup.input[i].key.left != KSYM_UNDEFINED)
4022 stored_player[i].connected = TRUE;
4025 #if DEBUG_INIT_PLAYER
4026 DebugPrintPlayerStatus("Player status after level initialization");
4029 #if DEBUG_INIT_PLAYER
4030 Debug("game:init:player", "Reassigning players ...");
4033 // check if any connected player was not found in playfield
4034 for (i = 0; i < MAX_PLAYERS; i++)
4036 struct PlayerInfo *player = &stored_player[i];
4038 if (player->connected && !player->present)
4040 struct PlayerInfo *field_player = NULL;
4042 #if DEBUG_INIT_PLAYER
4043 Debug("game:init:player",
4044 "- looking for field player for player %d ...", i + 1);
4047 // assign first free player found that is present in the playfield
4049 // first try: look for unmapped playfield player that is not connected
4050 for (j = 0; j < MAX_PLAYERS; j++)
4051 if (field_player == NULL &&
4052 stored_player[j].present &&
4053 !stored_player[j].mapped &&
4054 !stored_player[j].connected)
4055 field_player = &stored_player[j];
4057 // second try: look for *any* unmapped playfield player
4058 for (j = 0; j < MAX_PLAYERS; j++)
4059 if (field_player == NULL &&
4060 stored_player[j].present &&
4061 !stored_player[j].mapped)
4062 field_player = &stored_player[j];
4064 if (field_player != NULL)
4066 int jx = field_player->jx, jy = field_player->jy;
4068 #if DEBUG_INIT_PLAYER
4069 Debug("game:init:player", "- found player %d",
4070 field_player->index_nr + 1);
4073 player->present = FALSE;
4074 player->active = FALSE;
4076 field_player->present = TRUE;
4077 field_player->active = TRUE;
4080 player->initial_element = field_player->initial_element;
4081 player->artwork_element = field_player->artwork_element;
4083 player->block_last_field = field_player->block_last_field;
4084 player->block_delay_adjustment = field_player->block_delay_adjustment;
4087 StorePlayer[jx][jy] = field_player->element_nr;
4089 field_player->jx = field_player->last_jx = jx;
4090 field_player->jy = field_player->last_jy = jy;
4092 if (local_player == player)
4093 local_player = field_player;
4095 map_player_action[field_player->index_nr] = i;
4097 field_player->mapped = TRUE;
4099 #if DEBUG_INIT_PLAYER
4100 Debug("game:init:player", "- map_player_action[%d] == %d",
4101 field_player->index_nr + 1, i + 1);
4106 if (player->connected && player->present)
4107 player->mapped = TRUE;
4110 #if DEBUG_INIT_PLAYER
4111 DebugPrintPlayerStatus("Player status after player assignment (first stage)");
4116 // check if any connected player was not found in playfield
4117 for (i = 0; i < MAX_PLAYERS; i++)
4119 struct PlayerInfo *player = &stored_player[i];
4121 if (player->connected && !player->present)
4123 for (j = 0; j < MAX_PLAYERS; j++)
4125 struct PlayerInfo *field_player = &stored_player[j];
4126 int jx = field_player->jx, jy = field_player->jy;
4128 // assign first free player found that is present in the playfield
4129 if (field_player->present && !field_player->connected)
4131 player->present = TRUE;
4132 player->active = TRUE;
4134 field_player->present = FALSE;
4135 field_player->active = FALSE;
4137 player->initial_element = field_player->initial_element;
4138 player->artwork_element = field_player->artwork_element;
4140 player->block_last_field = field_player->block_last_field;
4141 player->block_delay_adjustment = field_player->block_delay_adjustment;
4143 StorePlayer[jx][jy] = player->element_nr;
4145 player->jx = player->last_jx = jx;
4146 player->jy = player->last_jy = jy;
4156 Debug("game:init:player", "local_player->present == %d",
4157 local_player->present);
4160 // set focus to local player for network games, else to all players
4161 game.centered_player_nr = (network_playing ? local_player->index_nr : -1);
4162 game.centered_player_nr_next = game.centered_player_nr;
4163 game.set_centered_player = FALSE;
4164 game.set_centered_player_wrap = FALSE;
4166 if (network_playing && tape.recording)
4168 // store client dependent player focus when recording network games
4169 tape.centered_player_nr_next = game.centered_player_nr_next;
4170 tape.set_centered_player = TRUE;
4175 // when playing a tape, eliminate all players who do not participate
4177 #if USE_NEW_PLAYER_ASSIGNMENTS
4179 if (!game.team_mode)
4181 for (i = 0; i < MAX_PLAYERS; i++)
4183 if (stored_player[i].active &&
4184 !tape.player_participates[map_player_action[i]])
4186 struct PlayerInfo *player = &stored_player[i];
4187 int jx = player->jx, jy = player->jy;
4189 #if DEBUG_INIT_PLAYER
4190 Debug("game:init:player", "Removing player %d at (%d, %d)",
4194 player->active = FALSE;
4195 StorePlayer[jx][jy] = 0;
4196 Tile[jx][jy] = EL_EMPTY;
4203 for (i = 0; i < MAX_PLAYERS; i++)
4205 if (stored_player[i].active &&
4206 !tape.player_participates[i])
4208 struct PlayerInfo *player = &stored_player[i];
4209 int jx = player->jx, jy = player->jy;
4211 player->active = FALSE;
4212 StorePlayer[jx][jy] = 0;
4213 Tile[jx][jy] = EL_EMPTY;
4218 else if (!network.enabled && !game.team_mode) // && !tape.playing
4220 // when in single player mode, eliminate all but the local player
4222 for (i = 0; i < MAX_PLAYERS; i++)
4224 struct PlayerInfo *player = &stored_player[i];
4226 if (player->active && player != local_player)
4228 int jx = player->jx, jy = player->jy;
4230 player->active = FALSE;
4231 player->present = FALSE;
4233 StorePlayer[jx][jy] = 0;
4234 Tile[jx][jy] = EL_EMPTY;
4239 for (i = 0; i < MAX_PLAYERS; i++)
4240 if (stored_player[i].active)
4241 game.players_still_needed++;
4243 if (level.solved_by_one_player)
4244 game.players_still_needed = 1;
4246 // when recording the game, store which players take part in the game
4249 #if USE_NEW_PLAYER_ASSIGNMENTS
4250 for (i = 0; i < MAX_PLAYERS; i++)
4251 if (stored_player[i].connected)
4252 tape.player_participates[i] = TRUE;
4254 for (i = 0; i < MAX_PLAYERS; i++)
4255 if (stored_player[i].active)
4256 tape.player_participates[i] = TRUE;
4260 #if DEBUG_INIT_PLAYER
4261 DebugPrintPlayerStatus("Player status after player assignment (final stage)");
4264 if (BorderElement == EL_EMPTY)
4267 SBX_Right = lev_fieldx - SCR_FIELDX;
4269 SBY_Lower = lev_fieldy - SCR_FIELDY;
4274 SBX_Right = lev_fieldx - SCR_FIELDX + 1;
4276 SBY_Lower = lev_fieldy - SCR_FIELDY + 1;
4279 if (full_lev_fieldx <= SCR_FIELDX)
4280 SBX_Left = SBX_Right = -1 * (SCR_FIELDX - lev_fieldx) / 2;
4281 if (full_lev_fieldy <= SCR_FIELDY)
4282 SBY_Upper = SBY_Lower = -1 * (SCR_FIELDY - lev_fieldy) / 2;
4284 if (EVEN(SCR_FIELDX) && full_lev_fieldx > SCR_FIELDX)
4286 if (EVEN(SCR_FIELDY) && full_lev_fieldy > SCR_FIELDY)
4289 // if local player not found, look for custom element that might create
4290 // the player (make some assumptions about the right custom element)
4291 if (!local_player->present)
4293 int start_x = 0, start_y = 0;
4294 int found_rating = 0;
4295 int found_element = EL_UNDEFINED;
4296 int player_nr = local_player->index_nr;
4298 SCAN_PLAYFIELD(x, y)
4300 int element = Tile[x][y];
4305 if (level.use_start_element[player_nr] &&
4306 level.start_element[player_nr] == element &&
4313 found_element = element;
4316 if (!IS_CUSTOM_ELEMENT(element))
4319 if (CAN_CHANGE(element))
4321 for (i = 0; i < element_info[element].num_change_pages; i++)
4323 // check for player created from custom element as single target
4324 content = element_info[element].change_page[i].target_element;
4325 is_player = IS_PLAYER_ELEMENT(content);
4327 if (is_player && (found_rating < 3 ||
4328 (found_rating == 3 && element < found_element)))
4334 found_element = element;
4339 for (yy = 0; yy < 3; yy++) for (xx = 0; xx < 3; xx++)
4341 // check for player created from custom element as explosion content
4342 content = element_info[element].content.e[xx][yy];
4343 is_player = IS_PLAYER_ELEMENT(content);
4345 if (is_player && (found_rating < 2 ||
4346 (found_rating == 2 && element < found_element)))
4348 start_x = x + xx - 1;
4349 start_y = y + yy - 1;
4352 found_element = element;
4355 if (!CAN_CHANGE(element))
4358 for (i = 0; i < element_info[element].num_change_pages; i++)
4360 // check for player created from custom element as extended target
4362 element_info[element].change_page[i].target_content.e[xx][yy];
4364 is_player = IS_PLAYER_ELEMENT(content);
4366 if (is_player && (found_rating < 1 ||
4367 (found_rating == 1 && element < found_element)))
4369 start_x = x + xx - 1;
4370 start_y = y + yy - 1;
4373 found_element = element;
4379 scroll_x = SCROLL_POSITION_X(start_x);
4380 scroll_y = SCROLL_POSITION_Y(start_y);
4384 scroll_x = SCROLL_POSITION_X(local_player->jx);
4385 scroll_y = SCROLL_POSITION_Y(local_player->jy);
4388 // !!! FIX THIS (START) !!!
4389 if (level.game_engine_type == GAME_ENGINE_TYPE_EM)
4391 InitGameEngine_EM();
4393 else if (level.game_engine_type == GAME_ENGINE_TYPE_SP)
4395 InitGameEngine_SP();
4397 else if (level.game_engine_type == GAME_ENGINE_TYPE_MM)
4399 InitGameEngine_MM();
4403 DrawLevel(REDRAW_FIELD);
4406 // after drawing the level, correct some elements
4407 if (game.timegate_time_left == 0)
4408 CloseAllOpenTimegates();
4411 // blit playfield from scroll buffer to normal back buffer for fading in
4412 BlitScreenToBitmap(backbuffer);
4413 // !!! FIX THIS (END) !!!
4415 DrawMaskedBorder(fade_mask);
4420 // full screen redraw is required at this point in the following cases:
4421 // - special editor door undrawn when game was started from level editor
4422 // - drawing area (playfield) was changed and has to be removed completely
4423 redraw_mask = REDRAW_ALL;
4427 if (!game.restart_level)
4429 // copy default game door content to main double buffer
4431 // !!! CHECK AGAIN !!!
4432 SetPanelBackground();
4433 // SetDoorBackgroundImage(IMG_BACKGROUND_PANEL);
4434 DrawBackground(DX, DY, DXSIZE, DYSIZE);
4437 SetPanelBackground();
4438 SetDrawBackgroundMask(REDRAW_DOOR_1);
4440 UpdateAndDisplayGameControlValues();
4442 if (!game.restart_level)
4448 CreateGameButtons();
4453 // copy actual game door content to door double buffer for OpenDoor()
4454 BlitBitmap(drawto, bitmap_db_door_1, DX, DY, DXSIZE, DYSIZE, 0, 0);
4456 OpenDoor(DOOR_OPEN_ALL);
4458 KeyboardAutoRepeatOffUnlessAutoplay();
4460 #if DEBUG_INIT_PLAYER
4461 DebugPrintPlayerStatus("Player status (final)");
4470 if (!game.restart_level && !tape.playing)
4472 LevelStats_incPlayed(level_nr);
4474 SaveLevelSetup_SeriesInfo();
4477 game.restart_level = FALSE;
4478 game.restart_game_message = NULL;
4480 game.request_active = FALSE;
4481 game.request_active_or_moving = FALSE;
4483 if (level.game_engine_type == GAME_ENGINE_TYPE_MM)
4484 InitGameActions_MM();
4486 SaveEngineSnapshotToListInitial();
4488 if (!game.restart_level)
4490 PlaySound(SND_GAME_STARTING);
4492 if (setup.sound_music)
4496 SetPlayfieldMouseCursorEnabled(!game.use_mouse_actions);
4499 void UpdateEngineValues(int actual_scroll_x, int actual_scroll_y,
4500 int actual_player_x, int actual_player_y)
4502 // this is used for non-R'n'D game engines to update certain engine values
4504 // needed to determine if sounds are played within the visible screen area
4505 scroll_x = actual_scroll_x;
4506 scroll_y = actual_scroll_y;
4508 // needed to get player position for "follow finger" playing input method
4509 local_player->jx = actual_player_x;
4510 local_player->jy = actual_player_y;
4513 void InitMovDir(int x, int y)
4515 int i, element = Tile[x][y];
4516 static int xy[4][2] =
4523 static int direction[3][4] =
4525 { MV_RIGHT, MV_UP, MV_LEFT, MV_DOWN },
4526 { MV_LEFT, MV_DOWN, MV_RIGHT, MV_UP },
4527 { MV_LEFT, MV_RIGHT, MV_UP, MV_DOWN }
4536 Tile[x][y] = EL_BUG;
4537 MovDir[x][y] = direction[0][element - EL_BUG_RIGHT];
4540 case EL_SPACESHIP_RIGHT:
4541 case EL_SPACESHIP_UP:
4542 case EL_SPACESHIP_LEFT:
4543 case EL_SPACESHIP_DOWN:
4544 Tile[x][y] = EL_SPACESHIP;
4545 MovDir[x][y] = direction[0][element - EL_SPACESHIP_RIGHT];
4548 case EL_BD_BUTTERFLY_RIGHT:
4549 case EL_BD_BUTTERFLY_UP:
4550 case EL_BD_BUTTERFLY_LEFT:
4551 case EL_BD_BUTTERFLY_DOWN:
4552 Tile[x][y] = EL_BD_BUTTERFLY;
4553 MovDir[x][y] = direction[0][element - EL_BD_BUTTERFLY_RIGHT];
4556 case EL_BD_FIREFLY_RIGHT:
4557 case EL_BD_FIREFLY_UP:
4558 case EL_BD_FIREFLY_LEFT:
4559 case EL_BD_FIREFLY_DOWN:
4560 Tile[x][y] = EL_BD_FIREFLY;
4561 MovDir[x][y] = direction[0][element - EL_BD_FIREFLY_RIGHT];
4564 case EL_PACMAN_RIGHT:
4566 case EL_PACMAN_LEFT:
4567 case EL_PACMAN_DOWN:
4568 Tile[x][y] = EL_PACMAN;
4569 MovDir[x][y] = direction[0][element - EL_PACMAN_RIGHT];
4572 case EL_YAMYAM_LEFT:
4573 case EL_YAMYAM_RIGHT:
4575 case EL_YAMYAM_DOWN:
4576 Tile[x][y] = EL_YAMYAM;
4577 MovDir[x][y] = direction[2][element - EL_YAMYAM_LEFT];
4580 case EL_SP_SNIKSNAK:
4581 MovDir[x][y] = MV_UP;
4584 case EL_SP_ELECTRON:
4585 MovDir[x][y] = MV_LEFT;
4592 Tile[x][y] = EL_MOLE;
4593 MovDir[x][y] = direction[2][element - EL_MOLE_LEFT];
4596 case EL_SPRING_LEFT:
4597 case EL_SPRING_RIGHT:
4598 Tile[x][y] = EL_SPRING;
4599 MovDir[x][y] = direction[2][element - EL_SPRING_LEFT];
4603 if (IS_CUSTOM_ELEMENT(element))
4605 struct ElementInfo *ei = &element_info[element];
4606 int move_direction_initial = ei->move_direction_initial;
4607 int move_pattern = ei->move_pattern;
4609 if (move_direction_initial == MV_START_PREVIOUS)
4611 if (MovDir[x][y] != MV_NONE)
4614 move_direction_initial = MV_START_AUTOMATIC;
4617 if (move_direction_initial == MV_START_RANDOM)
4618 MovDir[x][y] = 1 << RND(4);
4619 else if (move_direction_initial & MV_ANY_DIRECTION)
4620 MovDir[x][y] = move_direction_initial;
4621 else if (move_pattern == MV_ALL_DIRECTIONS ||
4622 move_pattern == MV_TURNING_LEFT ||
4623 move_pattern == MV_TURNING_RIGHT ||
4624 move_pattern == MV_TURNING_LEFT_RIGHT ||
4625 move_pattern == MV_TURNING_RIGHT_LEFT ||
4626 move_pattern == MV_TURNING_RANDOM)
4627 MovDir[x][y] = 1 << RND(4);
4628 else if (move_pattern == MV_HORIZONTAL)
4629 MovDir[x][y] = (RND(2) ? MV_LEFT : MV_RIGHT);
4630 else if (move_pattern == MV_VERTICAL)
4631 MovDir[x][y] = (RND(2) ? MV_UP : MV_DOWN);
4632 else if (move_pattern & MV_ANY_DIRECTION)
4633 MovDir[x][y] = element_info[element].move_pattern;
4634 else if (move_pattern == MV_ALONG_LEFT_SIDE ||
4635 move_pattern == MV_ALONG_RIGHT_SIDE)
4637 // use random direction as default start direction
4638 if (game.engine_version >= VERSION_IDENT(3,1,0,0))
4639 MovDir[x][y] = 1 << RND(4);
4641 for (i = 0; i < NUM_DIRECTIONS; i++)
4643 int x1 = x + xy[i][0];
4644 int y1 = y + xy[i][1];
4646 if (!IN_LEV_FIELD(x1, y1) || !IS_FREE(x1, y1))
4648 if (move_pattern == MV_ALONG_RIGHT_SIDE)
4649 MovDir[x][y] = direction[0][i];
4651 MovDir[x][y] = direction[1][i];
4660 MovDir[x][y] = 1 << RND(4);
4662 if (element != EL_BUG &&
4663 element != EL_SPACESHIP &&
4664 element != EL_BD_BUTTERFLY &&
4665 element != EL_BD_FIREFLY)
4668 for (i = 0; i < NUM_DIRECTIONS; i++)
4670 int x1 = x + xy[i][0];
4671 int y1 = y + xy[i][1];
4673 if (!IN_LEV_FIELD(x1, y1) || !IS_FREE(x1, y1))
4675 if (element == EL_BUG || element == EL_BD_BUTTERFLY)
4677 MovDir[x][y] = direction[0][i];
4680 else if (element == EL_SPACESHIP || element == EL_BD_FIREFLY ||
4681 element == EL_SP_SNIKSNAK || element == EL_SP_ELECTRON)
4683 MovDir[x][y] = direction[1][i];
4692 GfxDir[x][y] = MovDir[x][y];
4695 void InitAmoebaNr(int x, int y)
4698 int group_nr = AmoebaNeighbourNr(x, y);
4702 for (i = 1; i < MAX_NUM_AMOEBA; i++)
4704 if (AmoebaCnt[i] == 0)
4712 AmoebaNr[x][y] = group_nr;
4713 AmoebaCnt[group_nr]++;
4714 AmoebaCnt2[group_nr]++;
4717 static void LevelSolved_SetFinalGameValues(void)
4719 game.time_final = (game.no_time_limit ? TimePlayed : TimeLeft);
4720 game.score_time_final = (level.use_step_counter ? TimePlayed :
4721 TimePlayed * FRAMES_PER_SECOND + TimeFrames);
4723 game.score_final = (level.game_engine_type == GAME_ENGINE_TYPE_EM ?
4724 game_em.lev->score :
4725 level.game_engine_type == GAME_ENGINE_TYPE_MM ?
4729 game.health_final = (level.game_engine_type == GAME_ENGINE_TYPE_MM ?
4730 MM_HEALTH(game_mm.laser_overload_value) :
4733 game.LevelSolved_CountingTime = game.time_final;
4734 game.LevelSolved_CountingScore = game.score_final;
4735 game.LevelSolved_CountingHealth = game.health_final;
4738 static void LevelSolved_DisplayFinalGameValues(int time, int score, int health)
4740 game.LevelSolved_CountingTime = time;
4741 game.LevelSolved_CountingScore = score;
4742 game.LevelSolved_CountingHealth = health;
4744 game_panel_controls[GAME_PANEL_TIME].value = time;
4745 game_panel_controls[GAME_PANEL_SCORE].value = score;
4746 game_panel_controls[GAME_PANEL_HEALTH].value = health;
4748 DisplayGameControlValues();
4751 static void LevelSolved(void)
4753 if (level.game_engine_type == GAME_ENGINE_TYPE_RND &&
4754 game.players_still_needed > 0)
4757 game.LevelSolved = TRUE;
4758 game.GameOver = TRUE;
4760 // needed here to display correct panel values while player walks into exit
4761 LevelSolved_SetFinalGameValues();
4766 static int time_count_steps;
4767 static int time, time_final;
4768 static float score, score_final; // needed for time score < 10 for 10 seconds
4769 static int health, health_final;
4770 static int game_over_delay_1 = 0;
4771 static int game_over_delay_2 = 0;
4772 static int game_over_delay_3 = 0;
4773 int time_score_base = MIN(MAX(1, level.time_score_base), 10);
4774 float time_score = (float)level.score[SC_TIME_BONUS] / time_score_base;
4776 if (!game.LevelSolved_GameWon)
4780 // do not start end game actions before the player stops moving (to exit)
4781 if (local_player->active && local_player->MovPos)
4784 // calculate final game values after player finished walking into exit
4785 LevelSolved_SetFinalGameValues();
4787 game.LevelSolved_GameWon = TRUE;
4788 game.LevelSolved_SaveTape = tape.recording;
4789 game.LevelSolved_SaveScore = !tape.playing;
4793 LevelStats_incSolved(level_nr);
4795 SaveLevelSetup_SeriesInfo();
4798 if (tape.auto_play) // tape might already be stopped here
4799 tape.auto_play_level_solved = TRUE;
4803 game_over_delay_1 = FRAMES_PER_SECOND; // delay before counting time
4804 game_over_delay_2 = FRAMES_PER_SECOND / 2; // delay before counting health
4805 game_over_delay_3 = FRAMES_PER_SECOND; // delay before ending the game
4807 time = time_final = game.time_final;
4808 score = score_final = game.score_final;
4809 health = health_final = game.health_final;
4811 // update game panel values before (delayed) counting of score (if any)
4812 LevelSolved_DisplayFinalGameValues(time, score, health);
4814 // if level has time score defined, calculate new final game values
4817 int time_final_max = 999;
4818 int time_frames_final_max = time_final_max * FRAMES_PER_SECOND;
4819 int time_frames = 0;
4820 int time_frames_left = TimeLeft * FRAMES_PER_SECOND - TimeFrames;
4821 int time_frames_played = TimePlayed * FRAMES_PER_SECOND + TimeFrames;
4826 time_frames = time_frames_left;
4828 else if (game.no_time_limit && TimePlayed < time_final_max)
4830 time_final = time_final_max;
4831 time_frames = time_frames_final_max - time_frames_played;
4834 score_final += time_score * time_frames / FRAMES_PER_SECOND + 0.5;
4836 time_count_steps = MAX(1, ABS(time_final - time) / 100);
4838 if (level.game_engine_type == GAME_ENGINE_TYPE_MM)
4841 score_final += health * time_score;
4844 game.score_final = score_final;
4845 game.health_final = health_final;
4848 // if not counting score after game, immediately update game panel values
4849 if (level_editor_test_game || !setup.count_score_after_game)
4852 score = score_final;
4854 LevelSolved_DisplayFinalGameValues(time, score, health);
4857 if (level.game_engine_type == GAME_ENGINE_TYPE_RND)
4859 // check if last player has left the level
4860 if (game.exit_x >= 0 &&
4863 int x = game.exit_x;
4864 int y = game.exit_y;
4865 int element = Tile[x][y];
4867 // close exit door after last player
4868 if ((game.all_players_gone &&
4869 (element == EL_EXIT_OPEN ||
4870 element == EL_SP_EXIT_OPEN ||
4871 element == EL_STEEL_EXIT_OPEN)) ||
4872 element == EL_EM_EXIT_OPEN ||
4873 element == EL_EM_STEEL_EXIT_OPEN)
4877 (element == EL_EXIT_OPEN ? EL_EXIT_CLOSING :
4878 element == EL_EM_EXIT_OPEN ? EL_EM_EXIT_CLOSING :
4879 element == EL_SP_EXIT_OPEN ? EL_SP_EXIT_CLOSING:
4880 element == EL_STEEL_EXIT_OPEN ? EL_STEEL_EXIT_CLOSING:
4881 EL_EM_STEEL_EXIT_CLOSING);
4883 PlayLevelSoundElementAction(x, y, element, ACTION_CLOSING);
4886 // player disappears
4887 DrawLevelField(x, y);
4890 for (i = 0; i < MAX_PLAYERS; i++)
4892 struct PlayerInfo *player = &stored_player[i];
4894 if (player->present)
4896 RemovePlayer(player);
4898 // player disappears
4899 DrawLevelField(player->jx, player->jy);
4904 PlaySound(SND_GAME_WINNING);
4907 if (setup.count_score_after_game)
4909 if (time != time_final)
4911 if (game_over_delay_1 > 0)
4913 game_over_delay_1--;
4918 int time_to_go = ABS(time_final - time);
4919 int time_count_dir = (time < time_final ? +1 : -1);
4921 if (time_to_go < time_count_steps)
4922 time_count_steps = 1;
4924 time += time_count_steps * time_count_dir;
4925 score += time_count_steps * time_score;
4927 // set final score to correct rounding differences after counting score
4928 if (time == time_final)
4929 score = score_final;
4931 LevelSolved_DisplayFinalGameValues(time, score, health);
4933 if (time == time_final)
4934 StopSound(SND_GAME_LEVELTIME_BONUS);
4935 else if (setup.sound_loops)
4936 PlaySoundLoop(SND_GAME_LEVELTIME_BONUS);
4938 PlaySound(SND_GAME_LEVELTIME_BONUS);
4943 if (health != health_final)
4945 if (game_over_delay_2 > 0)
4947 game_over_delay_2--;
4952 int health_count_dir = (health < health_final ? +1 : -1);
4954 health += health_count_dir;
4955 score += time_score;
4957 LevelSolved_DisplayFinalGameValues(time, score, health);
4959 if (health == health_final)
4960 StopSound(SND_GAME_LEVELTIME_BONUS);
4961 else if (setup.sound_loops)
4962 PlaySoundLoop(SND_GAME_LEVELTIME_BONUS);
4964 PlaySound(SND_GAME_LEVELTIME_BONUS);
4970 game.panel.active = FALSE;
4972 if (game_over_delay_3 > 0)
4974 game_over_delay_3--;
4984 // used instead of "level_nr" (needed for network games)
4985 int last_level_nr = levelset.level_nr;
4986 boolean tape_saved = FALSE;
4988 game.LevelSolved_GameEnd = TRUE;
4990 if (game.LevelSolved_SaveTape)
4992 // make sure that request dialog to save tape does not open door again
4993 if (!global.use_envelope_request)
4994 CloseDoor(DOOR_CLOSE_1);
4997 tape_saved = SaveTapeChecked_LevelSolved(tape.level_nr);
4999 // set unique basename for score tape (also saved in high score table)
5000 strcpy(tape.score_tape_basename, getScoreTapeBasename(setup.player_name));
5003 // if no tape is to be saved, close both doors simultaneously
5004 CloseDoor(DOOR_CLOSE_ALL);
5006 if (level_editor_test_game)
5008 SetGameStatus(GAME_MODE_MAIN);
5015 if (!game.LevelSolved_SaveScore)
5017 SetGameStatus(GAME_MODE_MAIN);
5024 if (level_nr == leveldir_current->handicap_level)
5026 leveldir_current->handicap_level++;
5028 SaveLevelSetup_SeriesInfo();
5031 // save score and score tape before potentially erasing tape below
5032 NewHighScore(last_level_nr, tape_saved);
5034 if (setup.increment_levels &&
5035 level_nr < leveldir_current->last_level &&
5038 level_nr++; // advance to next level
5039 TapeErase(); // start with empty tape
5041 if (setup.auto_play_next_level)
5043 LoadLevel(level_nr);
5045 SaveLevelSetup_SeriesInfo();
5049 if (scores.last_added >= 0 && setup.show_scores_after_game)
5051 SetGameStatus(GAME_MODE_SCORES);
5053 DrawHallOfFame(last_level_nr);
5055 else if (setup.auto_play_next_level && setup.increment_levels &&
5056 last_level_nr < leveldir_current->last_level &&
5059 StartGameActions(network.enabled, setup.autorecord, level.random_seed);
5063 SetGameStatus(GAME_MODE_MAIN);
5069 static int addScoreEntry(struct ScoreInfo *list, struct ScoreEntry *new_entry,
5070 boolean one_score_entry_per_name)
5074 if (strEqual(new_entry->name, EMPTY_PLAYER_NAME))
5077 for (i = 0; i < MAX_SCORE_ENTRIES; i++)
5079 struct ScoreEntry *entry = &list->entry[i];
5080 boolean score_is_better = (new_entry->score > entry->score);
5081 boolean score_is_equal = (new_entry->score == entry->score);
5082 boolean time_is_better = (new_entry->time < entry->time);
5083 boolean time_is_equal = (new_entry->time == entry->time);
5084 boolean better_by_score = (score_is_better ||
5085 (score_is_equal && time_is_better));
5086 boolean better_by_time = (time_is_better ||
5087 (time_is_equal && score_is_better));
5088 boolean is_better = (level.rate_time_over_score ? better_by_time :
5090 boolean entry_is_empty = (entry->score == 0 &&
5093 // prevent adding server score entries if also existing in local score file
5094 // (special case: historic score entries have an empty tape basename entry)
5095 if (strEqual(new_entry->tape_basename, entry->tape_basename) &&
5096 !strEqual(new_entry->tape_basename, UNDEFINED_FILENAME))
5098 // special case: use server score instead of local score value if higher
5099 // (historic scores might have been truncated to 16-bit values locally)
5100 if (score_is_better)
5101 entry->score = new_entry->score;
5106 if (is_better || entry_is_empty)
5108 // player has made it to the hall of fame
5110 if (i < MAX_SCORE_ENTRIES - 1)
5112 int m = MAX_SCORE_ENTRIES - 1;
5115 if (one_score_entry_per_name)
5117 for (l = i; l < MAX_SCORE_ENTRIES; l++)
5118 if (strEqual(list->entry[l].name, new_entry->name))
5121 if (m == i) // player's new highscore overwrites his old one
5125 for (l = m; l > i; l--)
5126 list->entry[l] = list->entry[l - 1];
5131 *entry = *new_entry;
5135 else if (one_score_entry_per_name &&
5136 strEqual(entry->name, new_entry->name))
5138 // player already in high score list with better score or time
5147 void NewHighScore(int level_nr, boolean tape_saved)
5149 struct ScoreEntry new_entry = {{ 0 }}; // (prevent warning from GCC bug 53119)
5150 boolean one_per_name = FALSE;
5152 strncpy(new_entry.tape_basename, tape.score_tape_basename, MAX_FILENAME_LEN);
5153 strncpy(new_entry.name, setup.player_name, MAX_PLAYER_NAME_LEN);
5155 new_entry.score = game.score_final;
5156 new_entry.time = game.score_time_final;
5158 LoadScore(level_nr);
5160 scores.last_added = addScoreEntry(&scores, &new_entry, one_per_name);
5162 if (scores.last_added < 0)
5165 SaveScore(level_nr);
5167 // store last added local score entry (before merging server scores)
5168 scores.last_added_local = scores.last_added;
5170 if (!game.LevelSolved_SaveTape)
5173 SaveScoreTape(level_nr);
5175 if (setup.ask_for_using_api_server)
5177 setup.use_api_server =
5178 Request("Upload your score and tape to the high score server?", REQ_ASK);
5180 if (!setup.use_api_server)
5181 Request("Not using high score server! Use setup menu to enable again!",
5184 runtime.use_api_server = setup.use_api_server;
5186 // after asking for using API server once, do not ask again
5187 setup.ask_for_using_api_server = FALSE;
5189 SaveSetup_ServerSetup();
5192 SaveServerScore(level_nr, tape_saved);
5195 void MergeServerScore(void)
5197 struct ScoreEntry last_added_entry;
5198 boolean one_per_name = FALSE;
5201 if (scores.last_added >= 0)
5202 last_added_entry = scores.entry[scores.last_added];
5204 for (i = 0; i < server_scores.num_entries; i++)
5206 int pos = addScoreEntry(&scores, &server_scores.entry[i], one_per_name);
5208 if (pos >= 0 && pos <= scores.last_added)
5209 scores.last_added++;
5212 if (scores.last_added >= MAX_SCORE_ENTRIES)
5214 scores.last_added = MAX_SCORE_ENTRIES - 1;
5215 scores.force_last_added = TRUE;
5217 scores.entry[scores.last_added] = last_added_entry;
5221 static int getElementMoveStepsizeExt(int x, int y, int direction)
5223 int element = Tile[x][y];
5224 int dx = (direction == MV_LEFT ? -1 : direction == MV_RIGHT ? +1 : 0);
5225 int dy = (direction == MV_UP ? -1 : direction == MV_DOWN ? +1 : 0);
5226 int horiz_move = (dx != 0);
5227 int sign = (horiz_move ? dx : dy);
5228 int step = sign * element_info[element].move_stepsize;
5230 // special values for move stepsize for spring and things on conveyor belt
5233 if (CAN_FALL(element) &&
5234 y < lev_fieldy - 1 && IS_BELT_ACTIVE(Tile[x][y + 1]))
5235 step = sign * MOVE_STEPSIZE_NORMAL / 2;
5236 else if (element == EL_SPRING)
5237 step = sign * MOVE_STEPSIZE_NORMAL * 2;
5243 static int getElementMoveStepsize(int x, int y)
5245 return getElementMoveStepsizeExt(x, y, MovDir[x][y]);
5248 void InitPlayerGfxAnimation(struct PlayerInfo *player, int action, int dir)
5250 if (player->GfxAction != action || player->GfxDir != dir)
5252 player->GfxAction = action;
5253 player->GfxDir = dir;
5255 player->StepFrame = 0;
5259 static void ResetGfxFrame(int x, int y)
5261 // profiling showed that "autotest" spends 10~20% of its time in this function
5262 if (DrawingDeactivatedField())
5265 int element = Tile[x][y];
5266 int graphic = el_act_dir2img(element, GfxAction[x][y], GfxDir[x][y]);
5268 if (graphic_info[graphic].anim_global_sync)
5269 GfxFrame[x][y] = FrameCounter;
5270 else if (ANIM_MODE(graphic) == ANIM_CE_VALUE)
5271 GfxFrame[x][y] = CustomValue[x][y];
5272 else if (ANIM_MODE(graphic) == ANIM_CE_SCORE)
5273 GfxFrame[x][y] = element_info[element].collect_score;
5274 else if (ANIM_MODE(graphic) == ANIM_CE_DELAY)
5275 GfxFrame[x][y] = ChangeDelay[x][y];
5278 static void ResetGfxAnimation(int x, int y)
5280 GfxAction[x][y] = ACTION_DEFAULT;
5281 GfxDir[x][y] = MovDir[x][y];
5284 ResetGfxFrame(x, y);
5287 static void ResetRandomAnimationValue(int x, int y)
5289 GfxRandom[x][y] = INIT_GFX_RANDOM();
5292 static void InitMovingField(int x, int y, int direction)
5294 int element = Tile[x][y];
5295 int dx = (direction == MV_LEFT ? -1 : direction == MV_RIGHT ? +1 : 0);
5296 int dy = (direction == MV_UP ? -1 : direction == MV_DOWN ? +1 : 0);
5299 boolean is_moving_before, is_moving_after;
5301 // check if element was/is moving or being moved before/after mode change
5302 is_moving_before = (WasJustMoving[x][y] != 0);
5303 is_moving_after = (getElementMoveStepsizeExt(x, y, direction) != 0);
5305 // reset animation only for moving elements which change direction of moving
5306 // or which just started or stopped moving
5307 // (else CEs with property "can move" / "not moving" are reset each frame)
5308 if (is_moving_before != is_moving_after ||
5309 direction != MovDir[x][y])
5310 ResetGfxAnimation(x, y);
5312 MovDir[x][y] = direction;
5313 GfxDir[x][y] = direction;
5315 GfxAction[x][y] = (!is_moving_after ? ACTION_WAITING :
5316 direction == MV_DOWN && CAN_FALL(element) ?
5317 ACTION_FALLING : ACTION_MOVING);
5319 // this is needed for CEs with property "can move" / "not moving"
5321 if (is_moving_after)
5323 if (Tile[newx][newy] == EL_EMPTY)
5324 Tile[newx][newy] = EL_BLOCKED;
5326 MovDir[newx][newy] = MovDir[x][y];
5328 CustomValue[newx][newy] = CustomValue[x][y];
5330 GfxFrame[newx][newy] = GfxFrame[x][y];
5331 GfxRandom[newx][newy] = GfxRandom[x][y];
5332 GfxAction[newx][newy] = GfxAction[x][y];
5333 GfxDir[newx][newy] = GfxDir[x][y];
5337 void Moving2Blocked(int x, int y, int *goes_to_x, int *goes_to_y)
5339 int direction = MovDir[x][y];
5340 int newx = x + (direction & MV_LEFT ? -1 : direction & MV_RIGHT ? +1 : 0);
5341 int newy = y + (direction & MV_UP ? -1 : direction & MV_DOWN ? +1 : 0);
5347 void Blocked2Moving(int x, int y, int *comes_from_x, int *comes_from_y)
5349 int oldx = x, oldy = y;
5350 int direction = MovDir[x][y];
5352 if (direction == MV_LEFT)
5354 else if (direction == MV_RIGHT)
5356 else if (direction == MV_UP)
5358 else if (direction == MV_DOWN)
5361 *comes_from_x = oldx;
5362 *comes_from_y = oldy;
5365 static int MovingOrBlocked2Element(int x, int y)
5367 int element = Tile[x][y];
5369 if (element == EL_BLOCKED)
5373 Blocked2Moving(x, y, &oldx, &oldy);
5374 return Tile[oldx][oldy];
5380 static int MovingOrBlocked2ElementIfNotLeaving(int x, int y)
5382 // like MovingOrBlocked2Element(), but if element is moving
5383 // and (x,y) is the field the moving element is just leaving,
5384 // return EL_BLOCKED instead of the element value
5385 int element = Tile[x][y];
5387 if (IS_MOVING(x, y))
5389 if (element == EL_BLOCKED)
5393 Blocked2Moving(x, y, &oldx, &oldy);
5394 return Tile[oldx][oldy];
5403 static void RemoveField(int x, int y)
5405 Tile[x][y] = EL_EMPTY;
5411 CustomValue[x][y] = 0;
5414 ChangeDelay[x][y] = 0;
5415 ChangePage[x][y] = -1;
5416 Pushed[x][y] = FALSE;
5418 GfxElement[x][y] = EL_UNDEFINED;
5419 GfxAction[x][y] = ACTION_DEFAULT;
5420 GfxDir[x][y] = MV_NONE;
5423 static void RemoveMovingField(int x, int y)
5425 int oldx = x, oldy = y, newx = x, newy = y;
5426 int element = Tile[x][y];
5427 int next_element = EL_UNDEFINED;
5429 if (element != EL_BLOCKED && !IS_MOVING(x, y))
5432 if (IS_MOVING(x, y))
5434 Moving2Blocked(x, y, &newx, &newy);
5436 if (Tile[newx][newy] != EL_BLOCKED)
5438 // element is moving, but target field is not free (blocked), but
5439 // already occupied by something different (example: acid pool);
5440 // in this case, only remove the moving field, but not the target
5442 RemoveField(oldx, oldy);
5444 Store[oldx][oldy] = Store2[oldx][oldy] = 0;
5446 TEST_DrawLevelField(oldx, oldy);
5451 else if (element == EL_BLOCKED)
5453 Blocked2Moving(x, y, &oldx, &oldy);
5454 if (!IS_MOVING(oldx, oldy))
5458 if (element == EL_BLOCKED &&
5459 (Tile[oldx][oldy] == EL_QUICKSAND_EMPTYING ||
5460 Tile[oldx][oldy] == EL_QUICKSAND_FAST_EMPTYING ||
5461 Tile[oldx][oldy] == EL_MAGIC_WALL_EMPTYING ||
5462 Tile[oldx][oldy] == EL_BD_MAGIC_WALL_EMPTYING ||
5463 Tile[oldx][oldy] == EL_DC_MAGIC_WALL_EMPTYING ||
5464 Tile[oldx][oldy] == EL_AMOEBA_DROPPING))
5465 next_element = get_next_element(Tile[oldx][oldy]);
5467 RemoveField(oldx, oldy);
5468 RemoveField(newx, newy);
5470 Store[oldx][oldy] = Store2[oldx][oldy] = 0;
5472 if (next_element != EL_UNDEFINED)
5473 Tile[oldx][oldy] = next_element;
5475 TEST_DrawLevelField(oldx, oldy);
5476 TEST_DrawLevelField(newx, newy);
5479 void DrawDynamite(int x, int y)
5481 int sx = SCREENX(x), sy = SCREENY(y);
5482 int graphic = el2img(Tile[x][y]);
5485 if (!IN_SCR_FIELD(sx, sy) || IS_PLAYER(x, y))
5488 if (IS_WALKABLE_INSIDE(Back[x][y]))
5492 DrawLevelElement(x, y, Back[x][y]);
5493 else if (Store[x][y])
5494 DrawLevelElement(x, y, Store[x][y]);
5495 else if (game.use_masked_elements)
5496 DrawLevelElement(x, y, EL_EMPTY);
5498 frame = getGraphicAnimationFrameXY(graphic, x, y);
5500 if (Back[x][y] || Store[x][y] || game.use_masked_elements)
5501 DrawGraphicThruMask(sx, sy, graphic, frame);
5503 DrawGraphic(sx, sy, graphic, frame);
5506 static void CheckDynamite(int x, int y)
5508 if (MovDelay[x][y] != 0) // dynamite is still waiting to explode
5512 if (MovDelay[x][y] != 0)
5515 PlayLevelSoundActionIfLoop(x, y, ACTION_ACTIVE);
5521 StopLevelSoundActionIfLoop(x, y, ACTION_ACTIVE);
5526 static void setMinimalPlayerBoundaries(int *sx1, int *sy1, int *sx2, int *sy2)
5528 boolean num_checked_players = 0;
5531 for (i = 0; i < MAX_PLAYERS; i++)
5533 if (stored_player[i].active)
5535 int sx = stored_player[i].jx;
5536 int sy = stored_player[i].jy;
5538 if (num_checked_players == 0)
5545 *sx1 = MIN(*sx1, sx);
5546 *sy1 = MIN(*sy1, sy);
5547 *sx2 = MAX(*sx2, sx);
5548 *sy2 = MAX(*sy2, sy);
5551 num_checked_players++;
5556 static boolean checkIfAllPlayersFitToScreen_RND(void)
5558 int sx1 = 0, sy1 = 0, sx2 = 0, sy2 = 0;
5560 setMinimalPlayerBoundaries(&sx1, &sy1, &sx2, &sy2);
5562 return (sx2 - sx1 < SCR_FIELDX &&
5563 sy2 - sy1 < SCR_FIELDY);
5566 static void setScreenCenteredToAllPlayers(int *sx, int *sy)
5568 int sx1 = scroll_x, sy1 = scroll_y, sx2 = scroll_x, sy2 = scroll_y;
5570 setMinimalPlayerBoundaries(&sx1, &sy1, &sx2, &sy2);
5572 *sx = (sx1 + sx2) / 2;
5573 *sy = (sy1 + sy2) / 2;
5576 static void DrawRelocateScreen(int old_x, int old_y, int x, int y, int move_dir,
5577 boolean center_screen, boolean quick_relocation)
5579 unsigned int frame_delay_value_old = GetVideoFrameDelay();
5580 boolean ffwd_delay = (tape.playing && tape.fast_forward);
5581 boolean no_delay = (tape.warp_forward);
5582 int frame_delay_value = (ffwd_delay ? FfwdFrameDelay : GameFrameDelay);
5583 int wait_delay_value = (no_delay ? 0 : frame_delay_value);
5584 int new_scroll_x, new_scroll_y;
5586 if (level.lazy_relocation && IN_VIS_FIELD(SCREENX(x), SCREENY(y)))
5588 // case 1: quick relocation inside visible screen (without scrolling)
5595 if (!level.shifted_relocation || center_screen)
5597 // relocation _with_ centering of screen
5599 new_scroll_x = SCROLL_POSITION_X(x);
5600 new_scroll_y = SCROLL_POSITION_Y(y);
5604 // relocation _without_ centering of screen
5606 int center_scroll_x = SCROLL_POSITION_X(old_x);
5607 int center_scroll_y = SCROLL_POSITION_Y(old_y);
5608 int offset_x = x + (scroll_x - center_scroll_x);
5609 int offset_y = y + (scroll_y - center_scroll_y);
5611 // for new screen position, apply previous offset to center position
5612 new_scroll_x = SCROLL_POSITION_X(offset_x);
5613 new_scroll_y = SCROLL_POSITION_Y(offset_y);
5616 if (quick_relocation)
5618 // case 2: quick relocation (redraw without visible scrolling)
5620 scroll_x = new_scroll_x;
5621 scroll_y = new_scroll_y;
5628 // case 3: visible relocation (with scrolling to new position)
5630 ScrollScreen(NULL, SCROLL_GO_ON); // scroll last frame to full tile
5632 SetVideoFrameDelay(wait_delay_value);
5634 while (scroll_x != new_scroll_x || scroll_y != new_scroll_y)
5636 int dx = (new_scroll_x < scroll_x ? +1 : new_scroll_x > scroll_x ? -1 : 0);
5637 int dy = (new_scroll_y < scroll_y ? +1 : new_scroll_y > scroll_y ? -1 : 0);
5639 if (dx == 0 && dy == 0) // no scrolling needed at all
5645 // set values for horizontal/vertical screen scrolling (half tile size)
5646 int dir_x = (dx != 0 ? MV_HORIZONTAL : 0);
5647 int dir_y = (dy != 0 ? MV_VERTICAL : 0);
5648 int pos_x = dx * TILEX / 2;
5649 int pos_y = dy * TILEY / 2;
5650 int fx = getFieldbufferOffsetX_RND(dir_x, pos_x);
5651 int fy = getFieldbufferOffsetY_RND(dir_y, pos_y);
5653 ScrollLevel(dx, dy);
5656 // scroll in two steps of half tile size to make things smoother
5657 BlitScreenToBitmapExt_RND(window, fx, fy);
5659 // scroll second step to align at full tile size
5660 BlitScreenToBitmap(window);
5666 SetVideoFrameDelay(frame_delay_value_old);
5669 static void RelocatePlayer(int jx, int jy, int el_player_raw)
5671 int el_player = GET_PLAYER_ELEMENT(el_player_raw);
5672 int player_nr = GET_PLAYER_NR(el_player);
5673 struct PlayerInfo *player = &stored_player[player_nr];
5674 boolean ffwd_delay = (tape.playing && tape.fast_forward);
5675 boolean no_delay = (tape.warp_forward);
5676 int frame_delay_value = (ffwd_delay ? FfwdFrameDelay : GameFrameDelay);
5677 int wait_delay_value = (no_delay ? 0 : frame_delay_value);
5678 int old_jx = player->jx;
5679 int old_jy = player->jy;
5680 int old_element = Tile[old_jx][old_jy];
5681 int element = Tile[jx][jy];
5682 boolean player_relocated = (old_jx != jx || old_jy != jy);
5684 int move_dir_horiz = (jx < old_jx ? MV_LEFT : jx > old_jx ? MV_RIGHT : 0);
5685 int move_dir_vert = (jy < old_jy ? MV_UP : jy > old_jy ? MV_DOWN : 0);
5686 int enter_side_horiz = MV_DIR_OPPOSITE(move_dir_horiz);
5687 int enter_side_vert = MV_DIR_OPPOSITE(move_dir_vert);
5688 int leave_side_horiz = move_dir_horiz;
5689 int leave_side_vert = move_dir_vert;
5690 int enter_side = enter_side_horiz | enter_side_vert;
5691 int leave_side = leave_side_horiz | leave_side_vert;
5693 if (player->buried) // do not reanimate dead player
5696 if (!player_relocated) // no need to relocate the player
5699 if (IS_PLAYER(jx, jy)) // player already placed at new position
5701 RemoveField(jx, jy); // temporarily remove newly placed player
5702 DrawLevelField(jx, jy);
5705 if (player->present)
5707 while (player->MovPos)
5709 ScrollPlayer(player, SCROLL_GO_ON);
5710 ScrollScreen(NULL, SCROLL_GO_ON);
5712 AdvanceFrameAndPlayerCounters(player->index_nr);
5716 BackToFront_WithFrameDelay(wait_delay_value);
5719 DrawPlayer(player); // needed here only to cleanup last field
5720 DrawLevelField(player->jx, player->jy); // remove player graphic
5722 player->is_moving = FALSE;
5725 if (IS_CUSTOM_ELEMENT(old_element))
5726 CheckElementChangeByPlayer(old_jx, old_jy, old_element,
5728 player->index_bit, leave_side);
5730 CheckTriggeredElementChangeByPlayer(old_jx, old_jy, old_element,
5732 player->index_bit, leave_side);
5734 Tile[jx][jy] = el_player;
5735 InitPlayerField(jx, jy, el_player, TRUE);
5737 /* "InitPlayerField()" above sets Tile[jx][jy] to EL_EMPTY, but it may be
5738 possible that the relocation target field did not contain a player element,
5739 but a walkable element, to which the new player was relocated -- in this
5740 case, restore that (already initialized!) element on the player field */
5741 if (!IS_PLAYER_ELEMENT(element)) // player may be set on walkable element
5743 Tile[jx][jy] = element; // restore previously existing element
5746 // only visually relocate centered player
5747 DrawRelocateScreen(old_jx, old_jy, player->jx, player->jy, player->MovDir,
5748 FALSE, level.instant_relocation);
5750 TestIfPlayerTouchesBadThing(jx, jy);
5751 TestIfPlayerTouchesCustomElement(jx, jy);
5753 if (IS_CUSTOM_ELEMENT(element))
5754 CheckElementChangeByPlayer(jx, jy, element, CE_ENTERED_BY_PLAYER,
5755 player->index_bit, enter_side);
5757 CheckTriggeredElementChangeByPlayer(jx, jy, element, CE_PLAYER_ENTERS_X,
5758 player->index_bit, enter_side);
5760 if (player->is_switching)
5762 /* ensure that relocation while still switching an element does not cause
5763 a new element to be treated as also switched directly after relocation
5764 (this is important for teleporter switches that teleport the player to
5765 a place where another teleporter switch is in the same direction, which
5766 would then incorrectly be treated as immediately switched before the
5767 direction key that caused the switch was released) */
5769 player->switch_x += jx - old_jx;
5770 player->switch_y += jy - old_jy;
5774 static void Explode(int ex, int ey, int phase, int mode)
5780 // !!! eliminate this variable !!!
5781 int delay = (game.emulation == EMU_SUPAPLEX ? 3 : 2);
5783 if (game.explosions_delayed)
5785 ExplodeField[ex][ey] = mode;
5789 if (phase == EX_PHASE_START) // initialize 'Store[][]' field
5791 int center_element = Tile[ex][ey];
5792 int artwork_element, explosion_element; // set these values later
5794 // remove things displayed in background while burning dynamite
5795 if (Back[ex][ey] != EL_EMPTY && !IS_INDESTRUCTIBLE(Back[ex][ey]))
5798 if (IS_MOVING(ex, ey) || IS_BLOCKED(ex, ey))
5800 // put moving element to center field (and let it explode there)
5801 center_element = MovingOrBlocked2Element(ex, ey);
5802 RemoveMovingField(ex, ey);
5803 Tile[ex][ey] = center_element;
5806 // now "center_element" is finally determined -- set related values now
5807 artwork_element = center_element; // for custom player artwork
5808 explosion_element = center_element; // for custom player artwork
5810 if (IS_PLAYER(ex, ey))
5812 int player_nr = GET_PLAYER_NR(StorePlayer[ex][ey]);
5814 artwork_element = stored_player[player_nr].artwork_element;
5816 if (level.use_explosion_element[player_nr])
5818 explosion_element = level.explosion_element[player_nr];
5819 artwork_element = explosion_element;
5823 if (mode == EX_TYPE_NORMAL ||
5824 mode == EX_TYPE_CENTER ||
5825 mode == EX_TYPE_CROSS)
5826 PlayLevelSoundElementAction(ex, ey, artwork_element, ACTION_EXPLODING);
5828 last_phase = element_info[explosion_element].explosion_delay + 1;
5830 for (y = ey - 1; y <= ey + 1; y++) for (x = ex - 1; x <= ex + 1; x++)
5832 int xx = x - ex + 1;
5833 int yy = y - ey + 1;
5836 if (!IN_LEV_FIELD(x, y) ||
5837 (mode & EX_TYPE_SINGLE_TILE && (x != ex || y != ey)) ||
5838 (mode == EX_TYPE_CROSS && (x != ex && y != ey)))
5841 element = Tile[x][y];
5843 if (IS_MOVING(x, y) || IS_BLOCKED(x, y))
5845 element = MovingOrBlocked2Element(x, y);
5847 if (!IS_EXPLOSION_PROOF(element))
5848 RemoveMovingField(x, y);
5851 // indestructible elements can only explode in center (but not flames)
5852 if ((IS_EXPLOSION_PROOF(element) && (x != ex || y != ey ||
5853 mode == EX_TYPE_BORDER)) ||
5854 element == EL_FLAMES)
5857 /* no idea why this was changed from 3.0.8 to 3.1.0 -- this causes buggy
5858 behaviour, for example when touching a yamyam that explodes to rocks
5859 with active deadly shield, a rock is created under the player !!! */
5860 // (case 1 (surely buggy): >= 3.1.0, case 2 (maybe buggy): <= 3.0.8)
5862 if (IS_PLAYER(x, y) && SHIELD_ON(PLAYERINFO(x, y)) &&
5863 (game.engine_version < VERSION_IDENT(3,1,0,0) ||
5864 (x == ex && y == ey && mode != EX_TYPE_BORDER)))
5866 if (IS_PLAYER(x, y) && SHIELD_ON(PLAYERINFO(x, y)))
5869 if (IS_ACTIVE_BOMB(element))
5871 // re-activate things under the bomb like gate or penguin
5872 Tile[x][y] = (Back[x][y] ? Back[x][y] : EL_EMPTY);
5879 // save walkable background elements while explosion on same tile
5880 if (IS_WALKABLE(element) && IS_INDESTRUCTIBLE(element) &&
5881 (x != ex || y != ey || mode == EX_TYPE_BORDER))
5882 Back[x][y] = element;
5884 // ignite explodable elements reached by other explosion
5885 if (element == EL_EXPLOSION)
5886 element = Store2[x][y];
5888 if (AmoebaNr[x][y] &&
5889 (element == EL_AMOEBA_FULL ||
5890 element == EL_BD_AMOEBA ||
5891 element == EL_AMOEBA_GROWING))
5893 AmoebaCnt[AmoebaNr[x][y]]--;
5894 AmoebaCnt2[AmoebaNr[x][y]]--;
5899 if (IS_PLAYER(ex, ey) && !PLAYER_EXPLOSION_PROTECTED(ex, ey))
5901 int player_nr = StorePlayer[ex][ey] - EL_PLAYER_1;
5903 Store[x][y] = EL_PLAYER_IS_EXPLODING_1 + player_nr;
5905 if (PLAYERINFO(ex, ey)->use_murphy)
5906 Store[x][y] = EL_EMPTY;
5909 // !!! check this case -- currently needed for rnd_rado_negundo_v,
5910 // !!! levels 015 018 019 020 021 022 023 026 027 028 !!!
5911 else if (IS_PLAYER_ELEMENT(center_element))
5912 Store[x][y] = EL_EMPTY;
5913 else if (center_element == EL_YAMYAM)
5914 Store[x][y] = level.yamyam_content[game.yamyam_content_nr].e[xx][yy];
5915 else if (element_info[center_element].content.e[xx][yy] != EL_EMPTY)
5916 Store[x][y] = element_info[center_element].content.e[xx][yy];
5918 // needed because EL_BD_BUTTERFLY is not defined as "CAN_EXPLODE"
5919 // (killing EL_BD_BUTTERFLY with dynamite would result in BD diamond
5920 // otherwise) -- FIX THIS !!!
5921 else if (!CAN_EXPLODE(element) && element != EL_BD_BUTTERFLY)
5922 Store[x][y] = element_info[element].content.e[1][1];
5924 else if (!CAN_EXPLODE(element))
5925 Store[x][y] = element_info[element].content.e[1][1];
5928 Store[x][y] = EL_EMPTY;
5930 if (x != ex || y != ey || mode == EX_TYPE_BORDER ||
5931 center_element == EL_AMOEBA_TO_DIAMOND)
5932 Store2[x][y] = element;
5934 Tile[x][y] = EL_EXPLOSION;
5935 GfxElement[x][y] = artwork_element;
5937 ExplodePhase[x][y] = 1;
5938 ExplodeDelay[x][y] = last_phase;
5943 if (center_element == EL_YAMYAM)
5944 game.yamyam_content_nr =
5945 (game.yamyam_content_nr + 1) % level.num_yamyam_contents;
5957 GfxFrame[x][y] = 0; // restart explosion animation
5959 last_phase = ExplodeDelay[x][y];
5961 ExplodePhase[x][y] = (phase < last_phase ? phase + 1 : 0);
5963 // this can happen if the player leaves an explosion just in time
5964 if (GfxElement[x][y] == EL_UNDEFINED)
5965 GfxElement[x][y] = EL_EMPTY;
5967 border_element = Store2[x][y];
5968 if (IS_PLAYER(x, y) && !PLAYER_EXPLOSION_PROTECTED(x, y))
5969 border_element = StorePlayer[x][y];
5971 if (phase == element_info[border_element].ignition_delay ||
5972 phase == last_phase)
5974 boolean border_explosion = FALSE;
5976 if (IS_PLAYER(x, y) && PLAYERINFO(x, y)->present &&
5977 !PLAYER_EXPLOSION_PROTECTED(x, y))
5979 KillPlayerUnlessExplosionProtected(x, y);
5980 border_explosion = TRUE;
5982 else if (CAN_EXPLODE_BY_EXPLOSION(border_element))
5984 Tile[x][y] = Store2[x][y];
5987 border_explosion = TRUE;
5989 else if (border_element == EL_AMOEBA_TO_DIAMOND)
5991 AmoebaToDiamond(x, y);
5993 border_explosion = TRUE;
5996 // if an element just explodes due to another explosion (chain-reaction),
5997 // do not immediately end the new explosion when it was the last frame of
5998 // the explosion (as it would be done in the following "if"-statement!)
5999 if (border_explosion && phase == last_phase)
6003 // this can happen if the player was just killed by an explosion
6004 if (GfxElement[x][y] == EL_UNDEFINED)
6005 GfxElement[x][y] = EL_EMPTY;
6007 if (phase == last_phase)
6011 element = Tile[x][y] = Store[x][y];
6012 Store[x][y] = Store2[x][y] = 0;
6013 GfxElement[x][y] = EL_UNDEFINED;
6015 // player can escape from explosions and might therefore be still alive
6016 if (element >= EL_PLAYER_IS_EXPLODING_1 &&
6017 element <= EL_PLAYER_IS_EXPLODING_4)
6019 int player_nr = element - EL_PLAYER_IS_EXPLODING_1;
6020 int explosion_element = EL_PLAYER_1 + player_nr;
6021 int xx = MIN(MAX(0, x - stored_player[player_nr].jx + 1), 2);
6022 int yy = MIN(MAX(0, y - stored_player[player_nr].jy + 1), 2);
6024 if (level.use_explosion_element[player_nr])
6025 explosion_element = level.explosion_element[player_nr];
6027 Tile[x][y] = (stored_player[player_nr].active ? EL_EMPTY :
6028 element_info[explosion_element].content.e[xx][yy]);
6031 // restore probably existing indestructible background element
6032 if (Back[x][y] && IS_INDESTRUCTIBLE(Back[x][y]))
6033 element = Tile[x][y] = Back[x][y];
6036 MovDir[x][y] = MovPos[x][y] = MovDelay[x][y] = 0;
6037 GfxDir[x][y] = MV_NONE;
6038 ChangeDelay[x][y] = 0;
6039 ChangePage[x][y] = -1;
6041 CustomValue[x][y] = 0;
6043 InitField_WithBug2(x, y, FALSE);
6045 TEST_DrawLevelField(x, y);
6047 TestIfElementTouchesCustomElement(x, y);
6049 if (GFX_CRUMBLED(element))
6050 TEST_DrawLevelFieldCrumbledNeighbours(x, y);
6052 if (IS_PLAYER(x, y) && !PLAYERINFO(x, y)->present)
6053 StorePlayer[x][y] = 0;
6055 if (IS_PLAYER_ELEMENT(element))
6056 RelocatePlayer(x, y, element);
6058 else if (IN_SCR_FIELD(SCREENX(x), SCREENY(y)))
6060 int graphic = el_act2img(GfxElement[x][y], ACTION_EXPLODING);
6061 int frame = getGraphicAnimationFrameXY(graphic, x, y);
6064 TEST_DrawLevelFieldCrumbled(x, y);
6066 if (IS_WALKABLE_OVER(Back[x][y]) && Back[x][y] != EL_EMPTY)
6068 DrawLevelElement(x, y, Back[x][y]);
6069 DrawGraphicThruMask(SCREENX(x), SCREENY(y), graphic, frame);
6071 else if (IS_WALKABLE_UNDER(Back[x][y]))
6073 DrawGraphic(SCREENX(x), SCREENY(y), graphic, frame);
6074 DrawLevelElementThruMask(x, y, Back[x][y]);
6076 else if (!IS_WALKABLE_INSIDE(Back[x][y]))
6077 DrawScreenGraphic(SCREENX(x), SCREENY(y), graphic, frame);
6081 static void DynaExplode(int ex, int ey)
6084 int dynabomb_element = Tile[ex][ey];
6085 int dynabomb_size = 1;
6086 boolean dynabomb_xl = FALSE;
6087 struct PlayerInfo *player;
6088 static int xy[4][2] =
6096 if (IS_ACTIVE_BOMB(dynabomb_element))
6098 player = &stored_player[dynabomb_element - EL_DYNABOMB_PLAYER_1_ACTIVE];
6099 dynabomb_size = player->dynabomb_size;
6100 dynabomb_xl = player->dynabomb_xl;
6101 player->dynabombs_left++;
6104 Explode(ex, ey, EX_PHASE_START, EX_TYPE_CENTER);
6106 for (i = 0; i < NUM_DIRECTIONS; i++)
6108 for (j = 1; j <= dynabomb_size; j++)
6110 int x = ex + j * xy[i][0];
6111 int y = ey + j * xy[i][1];
6114 if (!IN_LEV_FIELD(x, y) || IS_INDESTRUCTIBLE(Tile[x][y]))
6117 element = Tile[x][y];
6119 // do not restart explosions of fields with active bombs
6120 if (element == EL_EXPLOSION && IS_ACTIVE_BOMB(Store2[x][y]))
6123 Explode(x, y, EX_PHASE_START, EX_TYPE_BORDER);
6125 if (element != EL_EMPTY && element != EL_EXPLOSION &&
6126 !IS_DIGGABLE(element) && !dynabomb_xl)
6132 void Bang(int x, int y)
6134 int element = MovingOrBlocked2Element(x, y);
6135 int explosion_type = EX_TYPE_NORMAL;
6137 if (IS_PLAYER(x, y) && !PLAYER_EXPLOSION_PROTECTED(x, y))
6139 struct PlayerInfo *player = PLAYERINFO(x, y);
6141 element = Tile[x][y] = player->initial_element;
6143 if (level.use_explosion_element[player->index_nr])
6145 int explosion_element = level.explosion_element[player->index_nr];
6147 if (element_info[explosion_element].explosion_type == EXPLODES_CROSS)
6148 explosion_type = EX_TYPE_CROSS;
6149 else if (element_info[explosion_element].explosion_type == EXPLODES_1X1)
6150 explosion_type = EX_TYPE_CENTER;
6158 case EL_BD_BUTTERFLY:
6161 case EL_DARK_YAMYAM:
6165 RaiseScoreElement(element);
6168 case EL_DYNABOMB_PLAYER_1_ACTIVE:
6169 case EL_DYNABOMB_PLAYER_2_ACTIVE:
6170 case EL_DYNABOMB_PLAYER_3_ACTIVE:
6171 case EL_DYNABOMB_PLAYER_4_ACTIVE:
6172 case EL_DYNABOMB_INCREASE_NUMBER:
6173 case EL_DYNABOMB_INCREASE_SIZE:
6174 case EL_DYNABOMB_INCREASE_POWER:
6175 explosion_type = EX_TYPE_DYNA;
6178 case EL_DC_LANDMINE:
6179 explosion_type = EX_TYPE_CENTER;
6184 case EL_LAMP_ACTIVE:
6185 case EL_AMOEBA_TO_DIAMOND:
6186 if (!IS_PLAYER(x, y)) // penguin and player may be at same field
6187 explosion_type = EX_TYPE_CENTER;
6191 if (element_info[element].explosion_type == EXPLODES_CROSS)
6192 explosion_type = EX_TYPE_CROSS;
6193 else if (element_info[element].explosion_type == EXPLODES_1X1)
6194 explosion_type = EX_TYPE_CENTER;
6198 if (explosion_type == EX_TYPE_DYNA)
6201 Explode(x, y, EX_PHASE_START, explosion_type);
6203 CheckTriggeredElementChange(x, y, element, CE_EXPLOSION_OF_X);
6206 static void SplashAcid(int x, int y)
6208 if (IN_LEV_FIELD(x - 1, y - 1) && IS_FREE(x - 1, y - 1) &&
6209 (!IN_LEV_FIELD(x - 1, y - 2) ||
6210 !CAN_FALL(MovingOrBlocked2Element(x - 1, y - 2))))
6211 Tile[x - 1][y - 1] = EL_ACID_SPLASH_LEFT;
6213 if (IN_LEV_FIELD(x + 1, y - 1) && IS_FREE(x + 1, y - 1) &&
6214 (!IN_LEV_FIELD(x + 1, y - 2) ||
6215 !CAN_FALL(MovingOrBlocked2Element(x + 1, y - 2))))
6216 Tile[x + 1][y - 1] = EL_ACID_SPLASH_RIGHT;
6218 PlayLevelSound(x, y, SND_ACID_SPLASHING);
6221 static void InitBeltMovement(void)
6223 static int belt_base_element[4] =
6225 EL_CONVEYOR_BELT_1_LEFT,
6226 EL_CONVEYOR_BELT_2_LEFT,
6227 EL_CONVEYOR_BELT_3_LEFT,
6228 EL_CONVEYOR_BELT_4_LEFT
6230 static int belt_base_active_element[4] =
6232 EL_CONVEYOR_BELT_1_LEFT_ACTIVE,
6233 EL_CONVEYOR_BELT_2_LEFT_ACTIVE,
6234 EL_CONVEYOR_BELT_3_LEFT_ACTIVE,
6235 EL_CONVEYOR_BELT_4_LEFT_ACTIVE
6240 // set frame order for belt animation graphic according to belt direction
6241 for (i = 0; i < NUM_BELTS; i++)
6245 for (j = 0; j < NUM_BELT_PARTS; j++)
6247 int element = belt_base_active_element[belt_nr] + j;
6248 int graphic_1 = el2img(element);
6249 int graphic_2 = el2panelimg(element);
6251 if (game.belt_dir[i] == MV_LEFT)
6253 graphic_info[graphic_1].anim_mode &= ~ANIM_REVERSE;
6254 graphic_info[graphic_2].anim_mode &= ~ANIM_REVERSE;
6258 graphic_info[graphic_1].anim_mode |= ANIM_REVERSE;
6259 graphic_info[graphic_2].anim_mode |= ANIM_REVERSE;
6264 SCAN_PLAYFIELD(x, y)
6266 int element = Tile[x][y];
6268 for (i = 0; i < NUM_BELTS; i++)
6270 if (IS_BELT(element) && game.belt_dir[i] != MV_NONE)
6272 int e_belt_nr = getBeltNrFromBeltElement(element);
6275 if (e_belt_nr == belt_nr)
6277 int belt_part = Tile[x][y] - belt_base_element[belt_nr];
6279 Tile[x][y] = belt_base_active_element[belt_nr] + belt_part;
6286 static void ToggleBeltSwitch(int x, int y)
6288 static int belt_base_element[4] =
6290 EL_CONVEYOR_BELT_1_LEFT,
6291 EL_CONVEYOR_BELT_2_LEFT,
6292 EL_CONVEYOR_BELT_3_LEFT,
6293 EL_CONVEYOR_BELT_4_LEFT
6295 static int belt_base_active_element[4] =
6297 EL_CONVEYOR_BELT_1_LEFT_ACTIVE,
6298 EL_CONVEYOR_BELT_2_LEFT_ACTIVE,
6299 EL_CONVEYOR_BELT_3_LEFT_ACTIVE,
6300 EL_CONVEYOR_BELT_4_LEFT_ACTIVE
6302 static int belt_base_switch_element[4] =
6304 EL_CONVEYOR_BELT_1_SWITCH_LEFT,
6305 EL_CONVEYOR_BELT_2_SWITCH_LEFT,
6306 EL_CONVEYOR_BELT_3_SWITCH_LEFT,
6307 EL_CONVEYOR_BELT_4_SWITCH_LEFT
6309 static int belt_move_dir[4] =
6317 int element = Tile[x][y];
6318 int belt_nr = getBeltNrFromBeltSwitchElement(element);
6319 int belt_dir_nr = (game.belt_dir_nr[belt_nr] + 1) % 4;
6320 int belt_dir = belt_move_dir[belt_dir_nr];
6323 if (!IS_BELT_SWITCH(element))
6326 game.belt_dir_nr[belt_nr] = belt_dir_nr;
6327 game.belt_dir[belt_nr] = belt_dir;
6329 if (belt_dir_nr == 3)
6332 // set frame order for belt animation graphic according to belt direction
6333 for (i = 0; i < NUM_BELT_PARTS; i++)
6335 int element = belt_base_active_element[belt_nr] + i;
6336 int graphic_1 = el2img(element);
6337 int graphic_2 = el2panelimg(element);
6339 if (belt_dir == MV_LEFT)
6341 graphic_info[graphic_1].anim_mode &= ~ANIM_REVERSE;
6342 graphic_info[graphic_2].anim_mode &= ~ANIM_REVERSE;
6346 graphic_info[graphic_1].anim_mode |= ANIM_REVERSE;
6347 graphic_info[graphic_2].anim_mode |= ANIM_REVERSE;
6351 SCAN_PLAYFIELD(xx, yy)
6353 int element = Tile[xx][yy];
6355 if (IS_BELT_SWITCH(element))
6357 int e_belt_nr = getBeltNrFromBeltSwitchElement(element);
6359 if (e_belt_nr == belt_nr)
6361 Tile[xx][yy] = belt_base_switch_element[belt_nr] + belt_dir_nr;
6362 TEST_DrawLevelField(xx, yy);
6365 else if (IS_BELT(element) && belt_dir != MV_NONE)
6367 int e_belt_nr = getBeltNrFromBeltElement(element);
6369 if (e_belt_nr == belt_nr)
6371 int belt_part = Tile[xx][yy] - belt_base_element[belt_nr];
6373 Tile[xx][yy] = belt_base_active_element[belt_nr] + belt_part;
6374 TEST_DrawLevelField(xx, yy);
6377 else if (IS_BELT_ACTIVE(element) && belt_dir == MV_NONE)
6379 int e_belt_nr = getBeltNrFromBeltActiveElement(element);
6381 if (e_belt_nr == belt_nr)
6383 int belt_part = Tile[xx][yy] - belt_base_active_element[belt_nr];
6385 Tile[xx][yy] = belt_base_element[belt_nr] + belt_part;
6386 TEST_DrawLevelField(xx, yy);
6392 static void ToggleSwitchgateSwitch(int x, int y)
6396 game.switchgate_pos = !game.switchgate_pos;
6398 SCAN_PLAYFIELD(xx, yy)
6400 int element = Tile[xx][yy];
6402 if (element == EL_SWITCHGATE_SWITCH_UP)
6404 Tile[xx][yy] = EL_SWITCHGATE_SWITCH_DOWN;
6405 TEST_DrawLevelField(xx, yy);
6407 else if (element == EL_SWITCHGATE_SWITCH_DOWN)
6409 Tile[xx][yy] = EL_SWITCHGATE_SWITCH_UP;
6410 TEST_DrawLevelField(xx, yy);
6412 else if (element == EL_DC_SWITCHGATE_SWITCH_UP)
6414 Tile[xx][yy] = EL_DC_SWITCHGATE_SWITCH_DOWN;
6415 TEST_DrawLevelField(xx, yy);
6417 else if (element == EL_DC_SWITCHGATE_SWITCH_DOWN)
6419 Tile[xx][yy] = EL_DC_SWITCHGATE_SWITCH_UP;
6420 TEST_DrawLevelField(xx, yy);
6422 else if (element == EL_SWITCHGATE_OPEN ||
6423 element == EL_SWITCHGATE_OPENING)
6425 Tile[xx][yy] = EL_SWITCHGATE_CLOSING;
6427 PlayLevelSoundAction(xx, yy, ACTION_CLOSING);
6429 else if (element == EL_SWITCHGATE_CLOSED ||
6430 element == EL_SWITCHGATE_CLOSING)
6432 Tile[xx][yy] = EL_SWITCHGATE_OPENING;
6434 PlayLevelSoundAction(xx, yy, ACTION_OPENING);
6439 static int getInvisibleActiveFromInvisibleElement(int element)
6441 return (element == EL_INVISIBLE_STEELWALL ? EL_INVISIBLE_STEELWALL_ACTIVE :
6442 element == EL_INVISIBLE_WALL ? EL_INVISIBLE_WALL_ACTIVE :
6443 element == EL_INVISIBLE_SAND ? EL_INVISIBLE_SAND_ACTIVE :
6447 static int getInvisibleFromInvisibleActiveElement(int element)
6449 return (element == EL_INVISIBLE_STEELWALL_ACTIVE ? EL_INVISIBLE_STEELWALL :
6450 element == EL_INVISIBLE_WALL_ACTIVE ? EL_INVISIBLE_WALL :
6451 element == EL_INVISIBLE_SAND_ACTIVE ? EL_INVISIBLE_SAND :
6455 static void RedrawAllLightSwitchesAndInvisibleElements(void)
6459 SCAN_PLAYFIELD(x, y)
6461 int element = Tile[x][y];
6463 if (element == EL_LIGHT_SWITCH &&
6464 game.light_time_left > 0)
6466 Tile[x][y] = EL_LIGHT_SWITCH_ACTIVE;
6467 TEST_DrawLevelField(x, y);
6469 else if (element == EL_LIGHT_SWITCH_ACTIVE &&
6470 game.light_time_left == 0)
6472 Tile[x][y] = EL_LIGHT_SWITCH;
6473 TEST_DrawLevelField(x, y);
6475 else if (element == EL_EMC_DRIPPER &&
6476 game.light_time_left > 0)
6478 Tile[x][y] = EL_EMC_DRIPPER_ACTIVE;
6479 TEST_DrawLevelField(x, y);
6481 else if (element == EL_EMC_DRIPPER_ACTIVE &&
6482 game.light_time_left == 0)
6484 Tile[x][y] = EL_EMC_DRIPPER;
6485 TEST_DrawLevelField(x, y);
6487 else if (element == EL_INVISIBLE_STEELWALL ||
6488 element == EL_INVISIBLE_WALL ||
6489 element == EL_INVISIBLE_SAND)
6491 if (game.light_time_left > 0)
6492 Tile[x][y] = getInvisibleActiveFromInvisibleElement(element);
6494 TEST_DrawLevelField(x, y);
6496 // uncrumble neighbour fields, if needed
6497 if (element == EL_INVISIBLE_SAND)
6498 TEST_DrawLevelFieldCrumbledNeighbours(x, y);
6500 else if (element == EL_INVISIBLE_STEELWALL_ACTIVE ||
6501 element == EL_INVISIBLE_WALL_ACTIVE ||
6502 element == EL_INVISIBLE_SAND_ACTIVE)
6504 if (game.light_time_left == 0)
6505 Tile[x][y] = getInvisibleFromInvisibleActiveElement(element);
6507 TEST_DrawLevelField(x, y);
6509 // re-crumble neighbour fields, if needed
6510 if (element == EL_INVISIBLE_SAND)
6511 TEST_DrawLevelFieldCrumbledNeighbours(x, y);
6516 static void RedrawAllInvisibleElementsForLenses(void)
6520 SCAN_PLAYFIELD(x, y)
6522 int element = Tile[x][y];
6524 if (element == EL_EMC_DRIPPER &&
6525 game.lenses_time_left > 0)
6527 Tile[x][y] = EL_EMC_DRIPPER_ACTIVE;
6528 TEST_DrawLevelField(x, y);
6530 else if (element == EL_EMC_DRIPPER_ACTIVE &&
6531 game.lenses_time_left == 0)
6533 Tile[x][y] = EL_EMC_DRIPPER;
6534 TEST_DrawLevelField(x, y);
6536 else if (element == EL_INVISIBLE_STEELWALL ||
6537 element == EL_INVISIBLE_WALL ||
6538 element == EL_INVISIBLE_SAND)
6540 if (game.lenses_time_left > 0)
6541 Tile[x][y] = getInvisibleActiveFromInvisibleElement(element);
6543 TEST_DrawLevelField(x, y);
6545 // uncrumble neighbour fields, if needed
6546 if (element == EL_INVISIBLE_SAND)
6547 TEST_DrawLevelFieldCrumbledNeighbours(x, y);
6549 else if (element == EL_INVISIBLE_STEELWALL_ACTIVE ||
6550 element == EL_INVISIBLE_WALL_ACTIVE ||
6551 element == EL_INVISIBLE_SAND_ACTIVE)
6553 if (game.lenses_time_left == 0)
6554 Tile[x][y] = getInvisibleFromInvisibleActiveElement(element);
6556 TEST_DrawLevelField(x, y);
6558 // re-crumble neighbour fields, if needed
6559 if (element == EL_INVISIBLE_SAND)
6560 TEST_DrawLevelFieldCrumbledNeighbours(x, y);
6565 static void RedrawAllInvisibleElementsForMagnifier(void)
6569 SCAN_PLAYFIELD(x, y)
6571 int element = Tile[x][y];
6573 if (element == EL_EMC_FAKE_GRASS &&
6574 game.magnify_time_left > 0)
6576 Tile[x][y] = EL_EMC_FAKE_GRASS_ACTIVE;
6577 TEST_DrawLevelField(x, y);
6579 else if (element == EL_EMC_FAKE_GRASS_ACTIVE &&
6580 game.magnify_time_left == 0)
6582 Tile[x][y] = EL_EMC_FAKE_GRASS;
6583 TEST_DrawLevelField(x, y);
6585 else if (IS_GATE_GRAY(element) &&
6586 game.magnify_time_left > 0)
6588 Tile[x][y] = (IS_RND_GATE_GRAY(element) ?
6589 element - EL_GATE_1_GRAY + EL_GATE_1_GRAY_ACTIVE :
6590 IS_EM_GATE_GRAY(element) ?
6591 element - EL_EM_GATE_1_GRAY + EL_EM_GATE_1_GRAY_ACTIVE :
6592 IS_EMC_GATE_GRAY(element) ?
6593 element - EL_EMC_GATE_5_GRAY + EL_EMC_GATE_5_GRAY_ACTIVE :
6594 IS_DC_GATE_GRAY(element) ?
6595 EL_DC_GATE_WHITE_GRAY_ACTIVE :
6597 TEST_DrawLevelField(x, y);
6599 else if (IS_GATE_GRAY_ACTIVE(element) &&
6600 game.magnify_time_left == 0)
6602 Tile[x][y] = (IS_RND_GATE_GRAY_ACTIVE(element) ?
6603 element - EL_GATE_1_GRAY_ACTIVE + EL_GATE_1_GRAY :
6604 IS_EM_GATE_GRAY_ACTIVE(element) ?
6605 element - EL_EM_GATE_1_GRAY_ACTIVE + EL_EM_GATE_1_GRAY :
6606 IS_EMC_GATE_GRAY_ACTIVE(element) ?
6607 element - EL_EMC_GATE_5_GRAY_ACTIVE + EL_EMC_GATE_5_GRAY :
6608 IS_DC_GATE_GRAY_ACTIVE(element) ?
6609 EL_DC_GATE_WHITE_GRAY :
6611 TEST_DrawLevelField(x, y);
6616 static void ToggleLightSwitch(int x, int y)
6618 int element = Tile[x][y];
6620 game.light_time_left =
6621 (element == EL_LIGHT_SWITCH ?
6622 level.time_light * FRAMES_PER_SECOND : 0);
6624 RedrawAllLightSwitchesAndInvisibleElements();
6627 static void ActivateTimegateSwitch(int x, int y)
6631 game.timegate_time_left = level.time_timegate * FRAMES_PER_SECOND;
6633 SCAN_PLAYFIELD(xx, yy)
6635 int element = Tile[xx][yy];
6637 if (element == EL_TIMEGATE_CLOSED ||
6638 element == EL_TIMEGATE_CLOSING)
6640 Tile[xx][yy] = EL_TIMEGATE_OPENING;
6641 PlayLevelSound(xx, yy, SND_CLASS_TIMEGATE_OPENING);
6645 else if (element == EL_TIMEGATE_SWITCH_ACTIVE)
6647 Tile[xx][yy] = EL_TIMEGATE_SWITCH;
6648 TEST_DrawLevelField(xx, yy);
6654 Tile[x][y] = (Tile[x][y] == EL_TIMEGATE_SWITCH ? EL_TIMEGATE_SWITCH_ACTIVE :
6655 EL_DC_TIMEGATE_SWITCH_ACTIVE);
6658 static void Impact(int x, int y)
6660 boolean last_line = (y == lev_fieldy - 1);
6661 boolean object_hit = FALSE;
6662 boolean impact = (last_line || object_hit);
6663 int element = Tile[x][y];
6664 int smashed = EL_STEELWALL;
6666 if (!last_line) // check if element below was hit
6668 if (Tile[x][y + 1] == EL_PLAYER_IS_LEAVING)
6671 object_hit = (!IS_FREE(x, y + 1) && (!IS_MOVING(x, y + 1) ||
6672 MovDir[x][y + 1] != MV_DOWN ||
6673 MovPos[x][y + 1] <= TILEY / 2));
6675 // do not smash moving elements that left the smashed field in time
6676 if (game.engine_version >= VERSION_IDENT(2,2,0,7) && IS_MOVING(x, y + 1) &&
6677 ABS(MovPos[x][y + 1] + getElementMoveStepsize(x, y + 1)) >= TILEX)
6680 #if USE_QUICKSAND_IMPACT_BUGFIX
6681 if (Tile[x][y + 1] == EL_QUICKSAND_EMPTYING && object_hit == FALSE)
6683 RemoveMovingField(x, y + 1);
6684 Tile[x][y + 1] = EL_QUICKSAND_EMPTY;
6685 Tile[x][y + 2] = EL_ROCK;
6686 TEST_DrawLevelField(x, y + 2);
6691 if (Tile[x][y + 1] == EL_QUICKSAND_FAST_EMPTYING && object_hit == FALSE)
6693 RemoveMovingField(x, y + 1);
6694 Tile[x][y + 1] = EL_QUICKSAND_FAST_EMPTY;
6695 Tile[x][y + 2] = EL_ROCK;
6696 TEST_DrawLevelField(x, y + 2);
6703 smashed = MovingOrBlocked2Element(x, y + 1);
6705 impact = (last_line || object_hit);
6708 if (!last_line && smashed == EL_ACID) // element falls into acid
6710 SplashAcid(x, y + 1);
6714 // !!! not sufficient for all cases -- see EL_PEARL below !!!
6715 // only reset graphic animation if graphic really changes after impact
6717 el_act_dir2img(element, GfxAction[x][y], MV_DOWN) != el2img(element))
6719 ResetGfxAnimation(x, y);
6720 TEST_DrawLevelField(x, y);
6723 if (impact && CAN_EXPLODE_IMPACT(element))
6728 else if (impact && element == EL_PEARL &&
6729 smashed != EL_DC_MAGIC_WALL && smashed != EL_DC_MAGIC_WALL_ACTIVE)
6731 ResetGfxAnimation(x, y);
6733 Tile[x][y] = EL_PEARL_BREAKING;
6734 PlayLevelSound(x, y, SND_PEARL_BREAKING);
6737 else if (impact && CheckElementChange(x, y, element, smashed, CE_IMPACT))
6739 PlayLevelSoundElementAction(x, y, element, ACTION_IMPACT);
6744 if (impact && element == EL_AMOEBA_DROP)
6746 if (object_hit && IS_PLAYER(x, y + 1))
6747 KillPlayerUnlessEnemyProtected(x, y + 1);
6748 else if (object_hit && smashed == EL_PENGUIN)
6752 Tile[x][y] = EL_AMOEBA_GROWING;
6753 Store[x][y] = EL_AMOEBA_WET;
6755 ResetRandomAnimationValue(x, y);
6760 if (object_hit) // check which object was hit
6762 if ((CAN_PASS_MAGIC_WALL(element) &&
6763 (smashed == EL_MAGIC_WALL ||
6764 smashed == EL_BD_MAGIC_WALL)) ||
6765 (CAN_PASS_DC_MAGIC_WALL(element) &&
6766 smashed == EL_DC_MAGIC_WALL))
6769 int activated_magic_wall =
6770 (smashed == EL_MAGIC_WALL ? EL_MAGIC_WALL_ACTIVE :
6771 smashed == EL_BD_MAGIC_WALL ? EL_BD_MAGIC_WALL_ACTIVE :
6772 EL_DC_MAGIC_WALL_ACTIVE);
6774 // activate magic wall / mill
6775 SCAN_PLAYFIELD(xx, yy)
6777 if (Tile[xx][yy] == smashed)
6778 Tile[xx][yy] = activated_magic_wall;
6781 game.magic_wall_time_left = level.time_magic_wall * FRAMES_PER_SECOND;
6782 game.magic_wall_active = TRUE;
6784 PlayLevelSound(x, y, (smashed == EL_MAGIC_WALL ?
6785 SND_MAGIC_WALL_ACTIVATING :
6786 smashed == EL_BD_MAGIC_WALL ?
6787 SND_BD_MAGIC_WALL_ACTIVATING :
6788 SND_DC_MAGIC_WALL_ACTIVATING));
6791 if (IS_PLAYER(x, y + 1))
6793 if (CAN_SMASH_PLAYER(element))
6795 KillPlayerUnlessEnemyProtected(x, y + 1);
6799 else if (smashed == EL_PENGUIN)
6801 if (CAN_SMASH_PLAYER(element))
6807 else if (element == EL_BD_DIAMOND)
6809 if (IS_CLASSIC_ENEMY(smashed) && IS_BD_ELEMENT(smashed))
6815 else if (((element == EL_SP_INFOTRON ||
6816 element == EL_SP_ZONK) &&
6817 (smashed == EL_SP_SNIKSNAK ||
6818 smashed == EL_SP_ELECTRON ||
6819 smashed == EL_SP_DISK_ORANGE)) ||
6820 (element == EL_SP_INFOTRON &&
6821 smashed == EL_SP_DISK_YELLOW))
6826 else if (CAN_SMASH_EVERYTHING(element))
6828 if (IS_CLASSIC_ENEMY(smashed) ||
6829 CAN_EXPLODE_SMASHED(smashed))
6834 else if (!IS_MOVING(x, y + 1) && !IS_BLOCKED(x, y + 1))
6836 if (smashed == EL_LAMP ||
6837 smashed == EL_LAMP_ACTIVE)
6842 else if (smashed == EL_NUT)
6844 Tile[x][y + 1] = EL_NUT_BREAKING;
6845 PlayLevelSound(x, y, SND_NUT_BREAKING);
6846 RaiseScoreElement(EL_NUT);
6849 else if (smashed == EL_PEARL)
6851 ResetGfxAnimation(x, y);
6853 Tile[x][y + 1] = EL_PEARL_BREAKING;
6854 PlayLevelSound(x, y, SND_PEARL_BREAKING);
6857 else if (smashed == EL_DIAMOND)
6859 Tile[x][y + 1] = EL_DIAMOND_BREAKING;
6860 PlayLevelSound(x, y, SND_DIAMOND_BREAKING);
6863 else if (IS_BELT_SWITCH(smashed))
6865 ToggleBeltSwitch(x, y + 1);
6867 else if (smashed == EL_SWITCHGATE_SWITCH_UP ||
6868 smashed == EL_SWITCHGATE_SWITCH_DOWN ||
6869 smashed == EL_DC_SWITCHGATE_SWITCH_UP ||
6870 smashed == EL_DC_SWITCHGATE_SWITCH_DOWN)
6872 ToggleSwitchgateSwitch(x, y + 1);
6874 else if (smashed == EL_LIGHT_SWITCH ||
6875 smashed == EL_LIGHT_SWITCH_ACTIVE)
6877 ToggleLightSwitch(x, y + 1);
6881 CheckElementChange(x, y + 1, smashed, element, CE_SMASHED);
6883 CheckElementChangeBySide(x, y + 1, smashed, element,
6884 CE_SWITCHED, CH_SIDE_TOP);
6885 CheckTriggeredElementChangeBySide(x, y + 1, smashed, CE_SWITCH_OF_X,
6891 CheckElementChange(x, y + 1, smashed, element, CE_SMASHED);
6896 // play sound of magic wall / mill
6898 (Tile[x][y + 1] == EL_MAGIC_WALL_ACTIVE ||
6899 Tile[x][y + 1] == EL_BD_MAGIC_WALL_ACTIVE ||
6900 Tile[x][y + 1] == EL_DC_MAGIC_WALL_ACTIVE))
6902 if (Tile[x][y + 1] == EL_MAGIC_WALL_ACTIVE)
6903 PlayLevelSound(x, y, SND_MAGIC_WALL_FILLING);
6904 else if (Tile[x][y + 1] == EL_BD_MAGIC_WALL_ACTIVE)
6905 PlayLevelSound(x, y, SND_BD_MAGIC_WALL_FILLING);
6906 else if (Tile[x][y + 1] == EL_DC_MAGIC_WALL_ACTIVE)
6907 PlayLevelSound(x, y, SND_DC_MAGIC_WALL_FILLING);
6912 // play sound of object that hits the ground
6913 if (last_line || object_hit)
6914 PlayLevelSoundElementAction(x, y, element, ACTION_IMPACT);
6917 static void TurnRoundExt(int x, int y)
6929 { 0, 0 }, { 0, 0 }, { 0, 0 },
6934 int left, right, back;
6938 { MV_DOWN, MV_UP, MV_RIGHT },
6939 { MV_UP, MV_DOWN, MV_LEFT },
6941 { MV_LEFT, MV_RIGHT, MV_DOWN },
6945 { MV_RIGHT, MV_LEFT, MV_UP }
6948 int element = Tile[x][y];
6949 int move_pattern = element_info[element].move_pattern;
6951 int old_move_dir = MovDir[x][y];
6952 int left_dir = turn[old_move_dir].left;
6953 int right_dir = turn[old_move_dir].right;
6954 int back_dir = turn[old_move_dir].back;
6956 int left_dx = move_xy[left_dir].dx, left_dy = move_xy[left_dir].dy;
6957 int right_dx = move_xy[right_dir].dx, right_dy = move_xy[right_dir].dy;
6958 int move_dx = move_xy[old_move_dir].dx, move_dy = move_xy[old_move_dir].dy;
6959 int back_dx = move_xy[back_dir].dx, back_dy = move_xy[back_dir].dy;
6961 int left_x = x + left_dx, left_y = y + left_dy;
6962 int right_x = x + right_dx, right_y = y + right_dy;
6963 int move_x = x + move_dx, move_y = y + move_dy;
6967 if (element == EL_BUG || element == EL_BD_BUTTERFLY)
6969 TestIfBadThingTouchesOtherBadThing(x, y);
6971 if (ENEMY_CAN_ENTER_FIELD(element, right_x, right_y))
6972 MovDir[x][y] = right_dir;
6973 else if (!ENEMY_CAN_ENTER_FIELD(element, move_x, move_y))
6974 MovDir[x][y] = left_dir;
6976 if (element == EL_BUG && MovDir[x][y] != old_move_dir)
6978 else if (element == EL_BD_BUTTERFLY) // && MovDir[x][y] == left_dir)
6981 else if (element == EL_SPACESHIP || element == EL_BD_FIREFLY)
6983 TestIfBadThingTouchesOtherBadThing(x, y);
6985 if (ENEMY_CAN_ENTER_FIELD(element, left_x, left_y))
6986 MovDir[x][y] = left_dir;
6987 else if (!ENEMY_CAN_ENTER_FIELD(element, move_x, move_y))
6988 MovDir[x][y] = right_dir;
6990 if (element == EL_SPACESHIP && MovDir[x][y] != old_move_dir)
6992 else if (element == EL_BD_FIREFLY) // && MovDir[x][y] == right_dir)
6995 else if (element == EL_SP_SNIKSNAK || element == EL_SP_ELECTRON)
6997 TestIfBadThingTouchesOtherBadThing(x, y);
6999 if (ELEMENT_CAN_ENTER_FIELD_BASE_4(element, left_x, left_y, 0))
7000 MovDir[x][y] = left_dir;
7001 else if (!ELEMENT_CAN_ENTER_FIELD_BASE_4(element, move_x, move_y, 0))
7002 MovDir[x][y] = right_dir;
7004 if (MovDir[x][y] != old_move_dir)
7007 else if (element == EL_YAMYAM)
7009 boolean can_turn_left = YAMYAM_CAN_ENTER_FIELD(element, left_x, left_y);
7010 boolean can_turn_right = YAMYAM_CAN_ENTER_FIELD(element, right_x, right_y);
7012 if (can_turn_left && can_turn_right)
7013 MovDir[x][y] = (RND(3) ? (RND(2) ? left_dir : right_dir) : back_dir);
7014 else if (can_turn_left)
7015 MovDir[x][y] = (RND(2) ? left_dir : back_dir);
7016 else if (can_turn_right)
7017 MovDir[x][y] = (RND(2) ? right_dir : back_dir);
7019 MovDir[x][y] = back_dir;
7021 MovDelay[x][y] = 16 + 16 * RND(3);
7023 else if (element == EL_DARK_YAMYAM)
7025 boolean can_turn_left = DARK_YAMYAM_CAN_ENTER_FIELD(element,
7027 boolean can_turn_right = DARK_YAMYAM_CAN_ENTER_FIELD(element,
7030 if (can_turn_left && can_turn_right)
7031 MovDir[x][y] = (RND(3) ? (RND(2) ? left_dir : right_dir) : back_dir);
7032 else if (can_turn_left)
7033 MovDir[x][y] = (RND(2) ? left_dir : back_dir);
7034 else if (can_turn_right)
7035 MovDir[x][y] = (RND(2) ? right_dir : back_dir);
7037 MovDir[x][y] = back_dir;
7039 MovDelay[x][y] = 16 + 16 * RND(3);
7041 else if (element == EL_PACMAN)
7043 boolean can_turn_left = PACMAN_CAN_ENTER_FIELD(element, left_x, left_y);
7044 boolean can_turn_right = PACMAN_CAN_ENTER_FIELD(element, right_x, right_y);
7046 if (can_turn_left && can_turn_right)
7047 MovDir[x][y] = (RND(3) ? (RND(2) ? left_dir : right_dir) : back_dir);
7048 else if (can_turn_left)
7049 MovDir[x][y] = (RND(2) ? left_dir : back_dir);
7050 else if (can_turn_right)
7051 MovDir[x][y] = (RND(2) ? right_dir : back_dir);
7053 MovDir[x][y] = back_dir;
7055 MovDelay[x][y] = 6 + RND(40);
7057 else if (element == EL_PIG)
7059 boolean can_turn_left = PIG_CAN_ENTER_FIELD(element, left_x, left_y);
7060 boolean can_turn_right = PIG_CAN_ENTER_FIELD(element, right_x, right_y);
7061 boolean can_move_on = PIG_CAN_ENTER_FIELD(element, move_x, move_y);
7062 boolean should_turn_left, should_turn_right, should_move_on;
7064 int rnd = RND(rnd_value);
7066 should_turn_left = (can_turn_left &&
7068 IN_LEV_FIELD_AND_NOT_FREE(x + back_dx + left_dx,
7069 y + back_dy + left_dy)));
7070 should_turn_right = (can_turn_right &&
7072 IN_LEV_FIELD_AND_NOT_FREE(x + back_dx + right_dx,
7073 y + back_dy + right_dy)));
7074 should_move_on = (can_move_on &&
7077 IN_LEV_FIELD_AND_NOT_FREE(x + move_dx + left_dx,
7078 y + move_dy + left_dy) ||
7079 IN_LEV_FIELD_AND_NOT_FREE(x + move_dx + right_dx,
7080 y + move_dy + right_dy)));
7082 if (should_turn_left || should_turn_right || should_move_on)
7084 if (should_turn_left && should_turn_right && should_move_on)
7085 MovDir[x][y] = (rnd < rnd_value / 3 ? left_dir :
7086 rnd < 2 * rnd_value / 3 ? right_dir :
7088 else if (should_turn_left && should_turn_right)
7089 MovDir[x][y] = (rnd < rnd_value / 2 ? left_dir : right_dir);
7090 else if (should_turn_left && should_move_on)
7091 MovDir[x][y] = (rnd < rnd_value / 2 ? left_dir : old_move_dir);
7092 else if (should_turn_right && should_move_on)
7093 MovDir[x][y] = (rnd < rnd_value / 2 ? right_dir : old_move_dir);
7094 else if (should_turn_left)
7095 MovDir[x][y] = left_dir;
7096 else if (should_turn_right)
7097 MovDir[x][y] = right_dir;
7098 else if (should_move_on)
7099 MovDir[x][y] = old_move_dir;
7101 else if (can_move_on && rnd > rnd_value / 8)
7102 MovDir[x][y] = old_move_dir;
7103 else if (can_turn_left && can_turn_right)
7104 MovDir[x][y] = (rnd < rnd_value / 2 ? left_dir : right_dir);
7105 else if (can_turn_left && rnd > rnd_value / 8)
7106 MovDir[x][y] = left_dir;
7107 else if (can_turn_right && rnd > rnd_value/8)
7108 MovDir[x][y] = right_dir;
7110 MovDir[x][y] = back_dir;
7112 xx = x + move_xy[MovDir[x][y]].dx;
7113 yy = y + move_xy[MovDir[x][y]].dy;
7115 if (!IN_LEV_FIELD(xx, yy) ||
7116 (!IS_FREE(xx, yy) && !IS_FOOD_PIG(Tile[xx][yy])))
7117 MovDir[x][y] = old_move_dir;
7121 else if (element == EL_DRAGON)
7123 boolean can_turn_left = DRAGON_CAN_ENTER_FIELD(element, left_x, left_y);
7124 boolean can_turn_right = DRAGON_CAN_ENTER_FIELD(element, right_x, right_y);
7125 boolean can_move_on = DRAGON_CAN_ENTER_FIELD(element, move_x, move_y);
7127 int rnd = RND(rnd_value);
7129 if (can_move_on && rnd > rnd_value / 8)
7130 MovDir[x][y] = old_move_dir;
7131 else if (can_turn_left && can_turn_right)
7132 MovDir[x][y] = (rnd < rnd_value / 2 ? left_dir : right_dir);
7133 else if (can_turn_left && rnd > rnd_value / 8)
7134 MovDir[x][y] = left_dir;
7135 else if (can_turn_right && rnd > rnd_value / 8)
7136 MovDir[x][y] = right_dir;
7138 MovDir[x][y] = back_dir;
7140 xx = x + move_xy[MovDir[x][y]].dx;
7141 yy = y + move_xy[MovDir[x][y]].dy;
7143 if (!IN_LEV_FIELD_AND_IS_FREE(xx, yy))
7144 MovDir[x][y] = old_move_dir;
7148 else if (element == EL_MOLE)
7150 boolean can_move_on =
7151 (MOLE_CAN_ENTER_FIELD(element, move_x, move_y,
7152 IS_AMOEBOID(Tile[move_x][move_y]) ||
7153 Tile[move_x][move_y] == EL_AMOEBA_SHRINKING));
7156 boolean can_turn_left =
7157 (MOLE_CAN_ENTER_FIELD(element, left_x, left_y,
7158 IS_AMOEBOID(Tile[left_x][left_y])));
7160 boolean can_turn_right =
7161 (MOLE_CAN_ENTER_FIELD(element, right_x, right_y,
7162 IS_AMOEBOID(Tile[right_x][right_y])));
7164 if (can_turn_left && can_turn_right)
7165 MovDir[x][y] = (RND(2) ? left_dir : right_dir);
7166 else if (can_turn_left)
7167 MovDir[x][y] = left_dir;
7169 MovDir[x][y] = right_dir;
7172 if (MovDir[x][y] != old_move_dir)
7175 else if (element == EL_BALLOON)
7177 MovDir[x][y] = game.wind_direction;
7180 else if (element == EL_SPRING)
7182 if (MovDir[x][y] & MV_HORIZONTAL)
7184 if (SPRING_CAN_BUMP_FROM_FIELD(move_x, move_y) &&
7185 !SPRING_CAN_ENTER_FIELD(element, x, y + 1))
7187 Tile[move_x][move_y] = EL_EMC_SPRING_BUMPER_ACTIVE;
7188 ResetGfxAnimation(move_x, move_y);
7189 TEST_DrawLevelField(move_x, move_y);
7191 MovDir[x][y] = back_dir;
7193 else if (!SPRING_CAN_ENTER_FIELD(element, move_x, move_y) ||
7194 SPRING_CAN_ENTER_FIELD(element, x, y + 1))
7195 MovDir[x][y] = MV_NONE;
7200 else if (element == EL_ROBOT ||
7201 element == EL_SATELLITE ||
7202 element == EL_PENGUIN ||
7203 element == EL_EMC_ANDROID)
7205 int attr_x = -1, attr_y = -1;
7207 if (game.all_players_gone)
7209 attr_x = game.exit_x;
7210 attr_y = game.exit_y;
7216 for (i = 0; i < MAX_PLAYERS; i++)
7218 struct PlayerInfo *player = &stored_player[i];
7219 int jx = player->jx, jy = player->jy;
7221 if (!player->active)
7225 ABS(jx - x) + ABS(jy - y) < ABS(attr_x - x) + ABS(attr_y - y))
7233 if (element == EL_ROBOT &&
7234 game.robot_wheel_x >= 0 &&
7235 game.robot_wheel_y >= 0 &&
7236 (Tile[game.robot_wheel_x][game.robot_wheel_y] == EL_ROBOT_WHEEL_ACTIVE ||
7237 game.engine_version < VERSION_IDENT(3,1,0,0)))
7239 attr_x = game.robot_wheel_x;
7240 attr_y = game.robot_wheel_y;
7243 if (element == EL_PENGUIN)
7246 static int xy[4][2] =
7254 for (i = 0; i < NUM_DIRECTIONS; i++)
7256 int ex = x + xy[i][0];
7257 int ey = y + xy[i][1];
7259 if (IN_LEV_FIELD(ex, ey) && (Tile[ex][ey] == EL_EXIT_OPEN ||
7260 Tile[ex][ey] == EL_EM_EXIT_OPEN ||
7261 Tile[ex][ey] == EL_STEEL_EXIT_OPEN ||
7262 Tile[ex][ey] == EL_EM_STEEL_EXIT_OPEN))
7271 MovDir[x][y] = MV_NONE;
7273 MovDir[x][y] |= (game.all_players_gone ? MV_RIGHT : MV_LEFT);
7274 else if (attr_x > x)
7275 MovDir[x][y] |= (game.all_players_gone ? MV_LEFT : MV_RIGHT);
7277 MovDir[x][y] |= (game.all_players_gone ? MV_DOWN : MV_UP);
7278 else if (attr_y > y)
7279 MovDir[x][y] |= (game.all_players_gone ? MV_UP : MV_DOWN);
7281 if (element == EL_ROBOT)
7285 if (MovDir[x][y] & MV_HORIZONTAL && MovDir[x][y] & MV_VERTICAL)
7286 MovDir[x][y] &= (RND(2) ? MV_HORIZONTAL : MV_VERTICAL);
7287 Moving2Blocked(x, y, &newx, &newy);
7289 if (IN_LEV_FIELD(newx, newy) && IS_FREE_OR_PLAYER(newx, newy))
7290 MovDelay[x][y] = 8 + 8 * !RND(3);
7292 MovDelay[x][y] = 16;
7294 else if (element == EL_PENGUIN)
7300 if (MovDir[x][y] & MV_HORIZONTAL && MovDir[x][y] & MV_VERTICAL)
7302 boolean first_horiz = RND(2);
7303 int new_move_dir = MovDir[x][y];
7306 new_move_dir & (first_horiz ? MV_HORIZONTAL : MV_VERTICAL);
7307 Moving2Blocked(x, y, &newx, &newy);
7309 if (PENGUIN_CAN_ENTER_FIELD(element, newx, newy))
7313 new_move_dir & (!first_horiz ? MV_HORIZONTAL : MV_VERTICAL);
7314 Moving2Blocked(x, y, &newx, &newy);
7316 if (PENGUIN_CAN_ENTER_FIELD(element, newx, newy))
7319 MovDir[x][y] = old_move_dir;
7323 else if (element == EL_SATELLITE)
7329 if (MovDir[x][y] & MV_HORIZONTAL && MovDir[x][y] & MV_VERTICAL)
7331 boolean first_horiz = RND(2);
7332 int new_move_dir = MovDir[x][y];
7335 new_move_dir & (first_horiz ? MV_HORIZONTAL : MV_VERTICAL);
7336 Moving2Blocked(x, y, &newx, &newy);
7338 if (SATELLITE_CAN_ENTER_FIELD(newx, newy))
7342 new_move_dir & (!first_horiz ? MV_HORIZONTAL : MV_VERTICAL);
7343 Moving2Blocked(x, y, &newx, &newy);
7345 if (SATELLITE_CAN_ENTER_FIELD(newx, newy))
7348 MovDir[x][y] = old_move_dir;
7352 else if (element == EL_EMC_ANDROID)
7354 static int check_pos[16] =
7356 -1, // 0 => (invalid)
7359 -1, // 3 => (invalid)
7361 0, // 5 => MV_LEFT | MV_UP
7362 2, // 6 => MV_RIGHT | MV_UP
7363 -1, // 7 => (invalid)
7365 6, // 9 => MV_LEFT | MV_DOWN
7366 4, // 10 => MV_RIGHT | MV_DOWN
7367 -1, // 11 => (invalid)
7368 -1, // 12 => (invalid)
7369 -1, // 13 => (invalid)
7370 -1, // 14 => (invalid)
7371 -1, // 15 => (invalid)
7379 { -1, -1, MV_LEFT | MV_UP },
7381 { +1, -1, MV_RIGHT | MV_UP },
7382 { +1, 0, MV_RIGHT },
7383 { +1, +1, MV_RIGHT | MV_DOWN },
7385 { -1, +1, MV_LEFT | MV_DOWN },
7388 int start_pos, check_order;
7389 boolean can_clone = FALSE;
7392 // check if there is any free field around current position
7393 for (i = 0; i < 8; i++)
7395 int newx = x + check_xy[i].dx;
7396 int newy = y + check_xy[i].dy;
7398 if (IN_LEV_FIELD_AND_IS_FREE(newx, newy))
7406 if (can_clone) // randomly find an element to clone
7410 start_pos = check_pos[RND(8)];
7411 check_order = (RND(2) ? -1 : +1);
7413 for (i = 0; i < 8; i++)
7415 int pos_raw = start_pos + i * check_order;
7416 int pos = (pos_raw + 8) % 8;
7417 int newx = x + check_xy[pos].dx;
7418 int newy = y + check_xy[pos].dy;
7420 if (ANDROID_CAN_CLONE_FIELD(newx, newy))
7422 element_info[element].move_leave_type = LEAVE_TYPE_LIMITED;
7423 element_info[element].move_leave_element = EL_TRIGGER_ELEMENT;
7425 Store[x][y] = Tile[newx][newy];
7434 if (can_clone) // randomly find a direction to move
7438 start_pos = check_pos[RND(8)];
7439 check_order = (RND(2) ? -1 : +1);
7441 for (i = 0; i < 8; i++)
7443 int pos_raw = start_pos + i * check_order;
7444 int pos = (pos_raw + 8) % 8;
7445 int newx = x + check_xy[pos].dx;
7446 int newy = y + check_xy[pos].dy;
7447 int new_move_dir = check_xy[pos].dir;
7449 if (IN_LEV_FIELD_AND_IS_FREE(newx, newy))
7451 MovDir[x][y] = new_move_dir;
7452 MovDelay[x][y] = level.android_clone_time * 8 + 1;
7461 if (can_clone) // cloning and moving successful
7464 // cannot clone -- try to move towards player
7466 start_pos = check_pos[MovDir[x][y] & 0x0f];
7467 check_order = (RND(2) ? -1 : +1);
7469 for (i = 0; i < 3; i++)
7471 // first check start_pos, then previous/next or (next/previous) pos
7472 int pos_raw = start_pos + (i < 2 ? i : -1) * check_order;
7473 int pos = (pos_raw + 8) % 8;
7474 int newx = x + check_xy[pos].dx;
7475 int newy = y + check_xy[pos].dy;
7476 int new_move_dir = check_xy[pos].dir;
7478 if (IS_PLAYER(newx, newy))
7481 if (ANDROID_CAN_ENTER_FIELD(element, newx, newy))
7483 MovDir[x][y] = new_move_dir;
7484 MovDelay[x][y] = level.android_move_time * 8 + 1;
7491 else if (move_pattern == MV_TURNING_LEFT ||
7492 move_pattern == MV_TURNING_RIGHT ||
7493 move_pattern == MV_TURNING_LEFT_RIGHT ||
7494 move_pattern == MV_TURNING_RIGHT_LEFT ||
7495 move_pattern == MV_TURNING_RANDOM ||
7496 move_pattern == MV_ALL_DIRECTIONS)
7498 boolean can_turn_left =
7499 CUSTOM_ELEMENT_CAN_ENTER_FIELD(element, left_x, left_y);
7500 boolean can_turn_right =
7501 CUSTOM_ELEMENT_CAN_ENTER_FIELD(element, right_x,right_y);
7503 if (element_info[element].move_stepsize == 0) // "not moving"
7506 if (move_pattern == MV_TURNING_LEFT)
7507 MovDir[x][y] = left_dir;
7508 else if (move_pattern == MV_TURNING_RIGHT)
7509 MovDir[x][y] = right_dir;
7510 else if (move_pattern == MV_TURNING_LEFT_RIGHT)
7511 MovDir[x][y] = (can_turn_left || !can_turn_right ? left_dir : right_dir);
7512 else if (move_pattern == MV_TURNING_RIGHT_LEFT)
7513 MovDir[x][y] = (can_turn_right || !can_turn_left ? right_dir : left_dir);
7514 else if (move_pattern == MV_TURNING_RANDOM)
7515 MovDir[x][y] = (can_turn_left && !can_turn_right ? left_dir :
7516 can_turn_right && !can_turn_left ? right_dir :
7517 RND(2) ? left_dir : right_dir);
7518 else if (can_turn_left && can_turn_right)
7519 MovDir[x][y] = (RND(3) ? (RND(2) ? left_dir : right_dir) : back_dir);
7520 else if (can_turn_left)
7521 MovDir[x][y] = (RND(2) ? left_dir : back_dir);
7522 else if (can_turn_right)
7523 MovDir[x][y] = (RND(2) ? right_dir : back_dir);
7525 MovDir[x][y] = back_dir;
7527 MovDelay[x][y] = GET_NEW_MOVE_DELAY(element);
7529 else if (move_pattern == MV_HORIZONTAL ||
7530 move_pattern == MV_VERTICAL)
7532 if (move_pattern & old_move_dir)
7533 MovDir[x][y] = back_dir;
7534 else if (move_pattern == MV_HORIZONTAL)
7535 MovDir[x][y] = (RND(2) ? MV_LEFT : MV_RIGHT);
7536 else if (move_pattern == MV_VERTICAL)
7537 MovDir[x][y] = (RND(2) ? MV_UP : MV_DOWN);
7539 MovDelay[x][y] = GET_NEW_MOVE_DELAY(element);
7541 else if (move_pattern & MV_ANY_DIRECTION)
7543 MovDir[x][y] = move_pattern;
7544 MovDelay[x][y] = GET_NEW_MOVE_DELAY(element);
7546 else if (move_pattern & MV_WIND_DIRECTION)
7548 MovDir[x][y] = game.wind_direction;
7549 MovDelay[x][y] = GET_NEW_MOVE_DELAY(element);
7551 else if (move_pattern == MV_ALONG_LEFT_SIDE)
7553 if (CUSTOM_ELEMENT_CAN_ENTER_FIELD(element, left_x, left_y))
7554 MovDir[x][y] = left_dir;
7555 else if (!CUSTOM_ELEMENT_CAN_ENTER_FIELD(element, move_x, move_y))
7556 MovDir[x][y] = right_dir;
7558 if (MovDir[x][y] != old_move_dir)
7559 MovDelay[x][y] = GET_NEW_MOVE_DELAY(element);
7561 else if (move_pattern == MV_ALONG_RIGHT_SIDE)
7563 if (CUSTOM_ELEMENT_CAN_ENTER_FIELD(element, right_x, right_y))
7564 MovDir[x][y] = right_dir;
7565 else if (!CUSTOM_ELEMENT_CAN_ENTER_FIELD(element, move_x, move_y))
7566 MovDir[x][y] = left_dir;
7568 if (MovDir[x][y] != old_move_dir)
7569 MovDelay[x][y] = GET_NEW_MOVE_DELAY(element);
7571 else if (move_pattern == MV_TOWARDS_PLAYER ||
7572 move_pattern == MV_AWAY_FROM_PLAYER)
7574 int attr_x = -1, attr_y = -1;
7576 boolean move_away = (move_pattern == MV_AWAY_FROM_PLAYER);
7578 if (game.all_players_gone)
7580 attr_x = game.exit_x;
7581 attr_y = game.exit_y;
7587 for (i = 0; i < MAX_PLAYERS; i++)
7589 struct PlayerInfo *player = &stored_player[i];
7590 int jx = player->jx, jy = player->jy;
7592 if (!player->active)
7596 ABS(jx - x) + ABS(jy - y) < ABS(attr_x - x) + ABS(attr_y - y))
7604 MovDir[x][y] = MV_NONE;
7606 MovDir[x][y] |= (move_away ? MV_RIGHT : MV_LEFT);
7607 else if (attr_x > x)
7608 MovDir[x][y] |= (move_away ? MV_LEFT : MV_RIGHT);
7610 MovDir[x][y] |= (move_away ? MV_DOWN : MV_UP);
7611 else if (attr_y > y)
7612 MovDir[x][y] |= (move_away ? MV_UP : MV_DOWN);
7614 MovDelay[x][y] = GET_NEW_MOVE_DELAY(element);
7616 if (MovDir[x][y] & MV_HORIZONTAL && MovDir[x][y] & MV_VERTICAL)
7618 boolean first_horiz = RND(2);
7619 int new_move_dir = MovDir[x][y];
7621 if (element_info[element].move_stepsize == 0) // "not moving"
7623 first_horiz = (ABS(attr_x - x) >= ABS(attr_y - y));
7624 MovDir[x][y] &= (first_horiz ? MV_HORIZONTAL : MV_VERTICAL);
7630 new_move_dir & (first_horiz ? MV_HORIZONTAL : MV_VERTICAL);
7631 Moving2Blocked(x, y, &newx, &newy);
7633 if (CUSTOM_ELEMENT_CAN_ENTER_FIELD(element, newx, newy))
7637 new_move_dir & (!first_horiz ? MV_HORIZONTAL : MV_VERTICAL);
7638 Moving2Blocked(x, y, &newx, &newy);
7640 if (CUSTOM_ELEMENT_CAN_ENTER_FIELD(element, newx, newy))
7643 MovDir[x][y] = old_move_dir;
7646 else if (move_pattern == MV_WHEN_PUSHED ||
7647 move_pattern == MV_WHEN_DROPPED)
7649 if (!CUSTOM_ELEMENT_CAN_ENTER_FIELD(element, move_x, move_y))
7650 MovDir[x][y] = MV_NONE;
7654 else if (move_pattern & MV_MAZE_RUNNER_STYLE)
7656 static int test_xy[7][2] =
7666 static int test_dir[7] =
7676 boolean hunter_mode = (move_pattern == MV_MAZE_HUNTER);
7677 int move_preference = -1000000; // start with very low preference
7678 int new_move_dir = MV_NONE;
7679 int start_test = RND(4);
7682 for (i = 0; i < NUM_DIRECTIONS; i++)
7684 int move_dir = test_dir[start_test + i];
7685 int move_dir_preference;
7687 xx = x + test_xy[start_test + i][0];
7688 yy = y + test_xy[start_test + i][1];
7690 if (hunter_mode && IN_LEV_FIELD(xx, yy) &&
7691 (IS_PLAYER(xx, yy) || Tile[xx][yy] == EL_PLAYER_IS_LEAVING))
7693 new_move_dir = move_dir;
7698 if (!CUSTOM_ELEMENT_CAN_ENTER_FIELD(element, xx, yy))
7701 move_dir_preference = -1 * RunnerVisit[xx][yy];
7702 if (hunter_mode && PlayerVisit[xx][yy] > 0)
7703 move_dir_preference = PlayerVisit[xx][yy];
7705 if (move_dir_preference > move_preference)
7707 // prefer field that has not been visited for the longest time
7708 move_preference = move_dir_preference;
7709 new_move_dir = move_dir;
7711 else if (move_dir_preference == move_preference &&
7712 move_dir == old_move_dir)
7714 // prefer last direction when all directions are preferred equally
7715 move_preference = move_dir_preference;
7716 new_move_dir = move_dir;
7720 MovDir[x][y] = new_move_dir;
7721 if (old_move_dir != new_move_dir)
7722 MovDelay[x][y] = GET_NEW_MOVE_DELAY(element);
7726 static void TurnRound(int x, int y)
7728 int direction = MovDir[x][y];
7732 GfxDir[x][y] = MovDir[x][y];
7734 if (direction != MovDir[x][y])
7738 GfxAction[x][y] = ACTION_TURNING_FROM_LEFT + MV_DIR_TO_BIT(direction);
7740 ResetGfxFrame(x, y);
7743 static boolean JustBeingPushed(int x, int y)
7747 for (i = 0; i < MAX_PLAYERS; i++)
7749 struct PlayerInfo *player = &stored_player[i];
7751 if (player->active && player->is_pushing && player->MovPos)
7753 int next_jx = player->jx + (player->jx - player->last_jx);
7754 int next_jy = player->jy + (player->jy - player->last_jy);
7756 if (x == next_jx && y == next_jy)
7764 static void StartMoving(int x, int y)
7766 boolean started_moving = FALSE; // some elements can fall _and_ move
7767 int element = Tile[x][y];
7772 if (MovDelay[x][y] == 0)
7773 GfxAction[x][y] = ACTION_DEFAULT;
7775 if (CAN_FALL(element) && y < lev_fieldy - 1)
7777 if ((x > 0 && IS_PLAYER(x - 1, y)) ||
7778 (x < lev_fieldx - 1 && IS_PLAYER(x + 1, y)))
7779 if (JustBeingPushed(x, y))
7782 if (element == EL_QUICKSAND_FULL)
7784 if (IS_FREE(x, y + 1))
7786 InitMovingField(x, y, MV_DOWN);
7787 started_moving = TRUE;
7789 Tile[x][y] = EL_QUICKSAND_EMPTYING;
7790 #if USE_QUICKSAND_BD_ROCK_BUGFIX
7791 if (Store[x][y] != EL_ROCK && Store[x][y] != EL_BD_ROCK)
7792 Store[x][y] = EL_ROCK;
7794 Store[x][y] = EL_ROCK;
7797 PlayLevelSoundAction(x, y, ACTION_EMPTYING);
7799 else if (Tile[x][y + 1] == EL_QUICKSAND_EMPTY)
7801 if (!MovDelay[x][y])
7803 MovDelay[x][y] = TILEY + 1;
7805 ResetGfxAnimation(x, y);
7806 ResetGfxAnimation(x, y + 1);
7811 DrawLevelElement(x, y, EL_QUICKSAND_EMPTYING);
7812 DrawLevelElement(x, y + 1, EL_QUICKSAND_FILLING);
7819 Tile[x][y] = EL_QUICKSAND_EMPTY;
7820 Tile[x][y + 1] = EL_QUICKSAND_FULL;
7821 Store[x][y + 1] = Store[x][y];
7824 PlayLevelSoundAction(x, y, ACTION_FILLING);
7826 else if (Tile[x][y + 1] == EL_QUICKSAND_FAST_EMPTY)
7828 if (!MovDelay[x][y])
7830 MovDelay[x][y] = TILEY + 1;
7832 ResetGfxAnimation(x, y);
7833 ResetGfxAnimation(x, y + 1);
7838 DrawLevelElement(x, y, EL_QUICKSAND_EMPTYING);
7839 DrawLevelElement(x, y + 1, EL_QUICKSAND_FAST_FILLING);
7846 Tile[x][y] = EL_QUICKSAND_EMPTY;
7847 Tile[x][y + 1] = EL_QUICKSAND_FAST_FULL;
7848 Store[x][y + 1] = Store[x][y];
7851 PlayLevelSoundAction(x, y, ACTION_FILLING);
7854 else if (element == EL_QUICKSAND_FAST_FULL)
7856 if (IS_FREE(x, y + 1))
7858 InitMovingField(x, y, MV_DOWN);
7859 started_moving = TRUE;
7861 Tile[x][y] = EL_QUICKSAND_FAST_EMPTYING;
7862 #if USE_QUICKSAND_BD_ROCK_BUGFIX
7863 if (Store[x][y] != EL_ROCK && Store[x][y] != EL_BD_ROCK)
7864 Store[x][y] = EL_ROCK;
7866 Store[x][y] = EL_ROCK;
7869 PlayLevelSoundAction(x, y, ACTION_EMPTYING);
7871 else if (Tile[x][y + 1] == EL_QUICKSAND_FAST_EMPTY)
7873 if (!MovDelay[x][y])
7875 MovDelay[x][y] = TILEY + 1;
7877 ResetGfxAnimation(x, y);
7878 ResetGfxAnimation(x, y + 1);
7883 DrawLevelElement(x, y, EL_QUICKSAND_FAST_EMPTYING);
7884 DrawLevelElement(x, y + 1, EL_QUICKSAND_FAST_FILLING);
7891 Tile[x][y] = EL_QUICKSAND_FAST_EMPTY;
7892 Tile[x][y + 1] = EL_QUICKSAND_FAST_FULL;
7893 Store[x][y + 1] = Store[x][y];
7896 PlayLevelSoundAction(x, y, ACTION_FILLING);
7898 else if (Tile[x][y + 1] == EL_QUICKSAND_EMPTY)
7900 if (!MovDelay[x][y])
7902 MovDelay[x][y] = TILEY + 1;
7904 ResetGfxAnimation(x, y);
7905 ResetGfxAnimation(x, y + 1);
7910 DrawLevelElement(x, y, EL_QUICKSAND_FAST_EMPTYING);
7911 DrawLevelElement(x, y + 1, EL_QUICKSAND_FILLING);
7918 Tile[x][y] = EL_QUICKSAND_FAST_EMPTY;
7919 Tile[x][y + 1] = EL_QUICKSAND_FULL;
7920 Store[x][y + 1] = Store[x][y];
7923 PlayLevelSoundAction(x, y, ACTION_FILLING);
7926 else if ((element == EL_ROCK || element == EL_BD_ROCK) &&
7927 Tile[x][y + 1] == EL_QUICKSAND_EMPTY)
7929 InitMovingField(x, y, MV_DOWN);
7930 started_moving = TRUE;
7932 Tile[x][y] = EL_QUICKSAND_FILLING;
7933 Store[x][y] = element;
7935 PlayLevelSoundAction(x, y, ACTION_FILLING);
7937 else if ((element == EL_ROCK || element == EL_BD_ROCK) &&
7938 Tile[x][y + 1] == EL_QUICKSAND_FAST_EMPTY)
7940 InitMovingField(x, y, MV_DOWN);
7941 started_moving = TRUE;
7943 Tile[x][y] = EL_QUICKSAND_FAST_FILLING;
7944 Store[x][y] = element;
7946 PlayLevelSoundAction(x, y, ACTION_FILLING);
7948 else if (element == EL_MAGIC_WALL_FULL)
7950 if (IS_FREE(x, y + 1))
7952 InitMovingField(x, y, MV_DOWN);
7953 started_moving = TRUE;
7955 Tile[x][y] = EL_MAGIC_WALL_EMPTYING;
7956 Store[x][y] = EL_CHANGED(Store[x][y]);
7958 else if (Tile[x][y + 1] == EL_MAGIC_WALL_ACTIVE)
7960 if (!MovDelay[x][y])
7961 MovDelay[x][y] = TILEY / 4 + 1;
7970 Tile[x][y] = EL_MAGIC_WALL_ACTIVE;
7971 Tile[x][y + 1] = EL_MAGIC_WALL_FULL;
7972 Store[x][y + 1] = EL_CHANGED(Store[x][y]);
7976 else if (element == EL_BD_MAGIC_WALL_FULL)
7978 if (IS_FREE(x, y + 1))
7980 InitMovingField(x, y, MV_DOWN);
7981 started_moving = TRUE;
7983 Tile[x][y] = EL_BD_MAGIC_WALL_EMPTYING;
7984 Store[x][y] = EL_CHANGED_BD(Store[x][y]);
7986 else if (Tile[x][y + 1] == EL_BD_MAGIC_WALL_ACTIVE)
7988 if (!MovDelay[x][y])
7989 MovDelay[x][y] = TILEY / 4 + 1;
7998 Tile[x][y] = EL_BD_MAGIC_WALL_ACTIVE;
7999 Tile[x][y + 1] = EL_BD_MAGIC_WALL_FULL;
8000 Store[x][y + 1] = EL_CHANGED_BD(Store[x][y]);
8004 else if (element == EL_DC_MAGIC_WALL_FULL)
8006 if (IS_FREE(x, y + 1))
8008 InitMovingField(x, y, MV_DOWN);
8009 started_moving = TRUE;
8011 Tile[x][y] = EL_DC_MAGIC_WALL_EMPTYING;
8012 Store[x][y] = EL_CHANGED_DC(Store[x][y]);
8014 else if (Tile[x][y + 1] == EL_DC_MAGIC_WALL_ACTIVE)
8016 if (!MovDelay[x][y])
8017 MovDelay[x][y] = TILEY / 4 + 1;
8026 Tile[x][y] = EL_DC_MAGIC_WALL_ACTIVE;
8027 Tile[x][y + 1] = EL_DC_MAGIC_WALL_FULL;
8028 Store[x][y + 1] = EL_CHANGED_DC(Store[x][y]);
8032 else if ((CAN_PASS_MAGIC_WALL(element) &&
8033 (Tile[x][y + 1] == EL_MAGIC_WALL_ACTIVE ||
8034 Tile[x][y + 1] == EL_BD_MAGIC_WALL_ACTIVE)) ||
8035 (CAN_PASS_DC_MAGIC_WALL(element) &&
8036 (Tile[x][y + 1] == EL_DC_MAGIC_WALL_ACTIVE)))
8039 InitMovingField(x, y, MV_DOWN);
8040 started_moving = TRUE;
8043 (Tile[x][y + 1] == EL_MAGIC_WALL_ACTIVE ? EL_MAGIC_WALL_FILLING :
8044 Tile[x][y + 1] == EL_BD_MAGIC_WALL_ACTIVE ? EL_BD_MAGIC_WALL_FILLING :
8045 EL_DC_MAGIC_WALL_FILLING);
8046 Store[x][y] = element;
8048 else if (CAN_FALL(element) && Tile[x][y + 1] == EL_ACID)
8050 SplashAcid(x, y + 1);
8052 InitMovingField(x, y, MV_DOWN);
8053 started_moving = TRUE;
8055 Store[x][y] = EL_ACID;
8058 (game.engine_version >= VERSION_IDENT(3,1,0,0) &&
8059 CheckImpact[x][y] && !IS_FREE(x, y + 1)) ||
8060 (game.engine_version >= VERSION_IDENT(3,0,7,0) &&
8061 CAN_FALL(element) && WasJustFalling[x][y] &&
8062 (Tile[x][y + 1] == EL_BLOCKED || IS_PLAYER(x, y + 1))) ||
8064 (game.engine_version < VERSION_IDENT(2,2,0,7) &&
8065 CAN_FALL(element) && WasJustMoving[x][y] && !Pushed[x][y + 1] &&
8066 (Tile[x][y + 1] == EL_BLOCKED)))
8068 /* this is needed for a special case not covered by calling "Impact()"
8069 from "ContinueMoving()": if an element moves to a tile directly below
8070 another element which was just falling on that tile (which was empty
8071 in the previous frame), the falling element above would just stop
8072 instead of smashing the element below (in previous version, the above
8073 element was just checked for "moving" instead of "falling", resulting
8074 in incorrect smashes caused by horizontal movement of the above
8075 element; also, the case of the player being the element to smash was
8076 simply not covered here... :-/ ) */
8078 CheckCollision[x][y] = 0;
8079 CheckImpact[x][y] = 0;
8083 else if (IS_FREE(x, y + 1) && element == EL_SPRING && level.use_spring_bug)
8085 if (MovDir[x][y] == MV_NONE)
8087 InitMovingField(x, y, MV_DOWN);
8088 started_moving = TRUE;
8091 else if (IS_FREE(x, y + 1) || Tile[x][y + 1] == EL_DIAMOND_BREAKING)
8093 if (WasJustFalling[x][y]) // prevent animation from being restarted
8094 MovDir[x][y] = MV_DOWN;
8096 InitMovingField(x, y, MV_DOWN);
8097 started_moving = TRUE;
8099 else if (element == EL_AMOEBA_DROP)
8101 Tile[x][y] = EL_AMOEBA_GROWING;
8102 Store[x][y] = EL_AMOEBA_WET;
8104 else if (((IS_SLIPPERY(Tile[x][y + 1]) && !IS_PLAYER(x, y + 1)) ||
8105 (IS_EM_SLIPPERY_WALL(Tile[x][y + 1]) && IS_GEM(element))) &&
8106 !IS_FALLING(x, y + 1) && !WasJustMoving[x][y + 1] &&
8107 element != EL_DX_SUPABOMB && element != EL_SP_DISK_ORANGE)
8109 boolean can_fall_left = (x > 0 && IS_FREE(x - 1, y) &&
8110 (IS_FREE(x - 1, y + 1) ||
8111 Tile[x - 1][y + 1] == EL_ACID));
8112 boolean can_fall_right = (x < lev_fieldx - 1 && IS_FREE(x + 1, y) &&
8113 (IS_FREE(x + 1, y + 1) ||
8114 Tile[x + 1][y + 1] == EL_ACID));
8115 boolean can_fall_any = (can_fall_left || can_fall_right);
8116 boolean can_fall_both = (can_fall_left && can_fall_right);
8117 int slippery_type = element_info[Tile[x][y + 1]].slippery_type;
8119 if (can_fall_any && slippery_type != SLIPPERY_ANY_RANDOM)
8121 if (slippery_type == SLIPPERY_ANY_LEFT_RIGHT && can_fall_both)
8122 can_fall_right = FALSE;
8123 else if (slippery_type == SLIPPERY_ANY_RIGHT_LEFT && can_fall_both)
8124 can_fall_left = FALSE;
8125 else if (slippery_type == SLIPPERY_ONLY_LEFT)
8126 can_fall_right = FALSE;
8127 else if (slippery_type == SLIPPERY_ONLY_RIGHT)
8128 can_fall_left = FALSE;
8130 can_fall_any = (can_fall_left || can_fall_right);
8131 can_fall_both = FALSE;
8136 if (element == EL_BD_ROCK || element == EL_BD_DIAMOND)
8137 can_fall_right = FALSE; // slip down on left side
8139 can_fall_left = !(can_fall_right = RND(2));
8141 can_fall_both = FALSE;
8146 // if not determined otherwise, prefer left side for slipping down
8147 InitMovingField(x, y, can_fall_left ? MV_LEFT : MV_RIGHT);
8148 started_moving = TRUE;
8151 else if (IS_BELT_ACTIVE(Tile[x][y + 1]))
8153 boolean left_is_free = (x > 0 && IS_FREE(x - 1, y));
8154 boolean right_is_free = (x < lev_fieldx - 1 && IS_FREE(x + 1, y));
8155 int belt_nr = getBeltNrFromBeltActiveElement(Tile[x][y + 1]);
8156 int belt_dir = game.belt_dir[belt_nr];
8158 if ((belt_dir == MV_LEFT && left_is_free) ||
8159 (belt_dir == MV_RIGHT && right_is_free))
8161 int nextx = (belt_dir == MV_LEFT ? x - 1 : x + 1);
8163 InitMovingField(x, y, belt_dir);
8164 started_moving = TRUE;
8166 Pushed[x][y] = TRUE;
8167 Pushed[nextx][y] = TRUE;
8169 GfxAction[x][y] = ACTION_DEFAULT;
8173 MovDir[x][y] = 0; // if element was moving, stop it
8178 // not "else if" because of elements that can fall and move (EL_SPRING)
8179 if (CAN_MOVE(element) && !started_moving)
8181 int move_pattern = element_info[element].move_pattern;
8184 Moving2Blocked(x, y, &newx, &newy);
8186 if (IS_PUSHABLE(element) && JustBeingPushed(x, y))
8189 if (game.engine_version >= VERSION_IDENT(3,1,0,0) &&
8190 CheckCollision[x][y] && !IN_LEV_FIELD_AND_IS_FREE(newx, newy))
8192 WasJustMoving[x][y] = 0;
8193 CheckCollision[x][y] = 0;
8195 TestIfElementHitsCustomElement(x, y, MovDir[x][y]);
8197 if (Tile[x][y] != element) // element has changed
8201 if (!MovDelay[x][y]) // start new movement phase
8203 // all objects that can change their move direction after each step
8204 // (YAMYAM, DARK_YAMYAM and PACMAN go straight until they hit a wall
8206 if (element != EL_YAMYAM &&
8207 element != EL_DARK_YAMYAM &&
8208 element != EL_PACMAN &&
8209 !(move_pattern & MV_ANY_DIRECTION) &&
8210 move_pattern != MV_TURNING_LEFT &&
8211 move_pattern != MV_TURNING_RIGHT &&
8212 move_pattern != MV_TURNING_LEFT_RIGHT &&
8213 move_pattern != MV_TURNING_RIGHT_LEFT &&
8214 move_pattern != MV_TURNING_RANDOM)
8218 if (MovDelay[x][y] && (element == EL_BUG ||
8219 element == EL_SPACESHIP ||
8220 element == EL_SP_SNIKSNAK ||
8221 element == EL_SP_ELECTRON ||
8222 element == EL_MOLE))
8223 TEST_DrawLevelField(x, y);
8227 if (MovDelay[x][y]) // wait some time before next movement
8231 if (element == EL_ROBOT ||
8232 element == EL_YAMYAM ||
8233 element == EL_DARK_YAMYAM)
8235 DrawLevelElementAnimationIfNeeded(x, y, element);
8236 PlayLevelSoundAction(x, y, ACTION_WAITING);
8238 else if (element == EL_SP_ELECTRON)
8239 DrawLevelElementAnimationIfNeeded(x, y, element);
8240 else if (element == EL_DRAGON)
8243 int dir = MovDir[x][y];
8244 int dx = (dir == MV_LEFT ? -1 : dir == MV_RIGHT ? +1 : 0);
8245 int dy = (dir == MV_UP ? -1 : dir == MV_DOWN ? +1 : 0);
8246 int graphic = (dir == MV_LEFT ? IMG_FLAMES_1_LEFT :
8247 dir == MV_RIGHT ? IMG_FLAMES_1_RIGHT :
8248 dir == MV_UP ? IMG_FLAMES_1_UP :
8249 dir == MV_DOWN ? IMG_FLAMES_1_DOWN : IMG_EMPTY);
8250 int frame = getGraphicAnimationFrameXY(graphic, x, y);
8252 GfxAction[x][y] = ACTION_ATTACKING;
8254 if (IS_PLAYER(x, y))
8255 DrawPlayerField(x, y);
8257 TEST_DrawLevelField(x, y);
8259 PlayLevelSoundActionIfLoop(x, y, ACTION_ATTACKING);
8261 for (i = 1; i <= 3; i++)
8263 int xx = x + i * dx;
8264 int yy = y + i * dy;
8265 int sx = SCREENX(xx);
8266 int sy = SCREENY(yy);
8267 int flame_graphic = graphic + (i - 1);
8269 if (!IN_LEV_FIELD(xx, yy) || IS_DRAGONFIRE_PROOF(Tile[xx][yy]))
8274 int flamed = MovingOrBlocked2Element(xx, yy);
8276 if (IS_CLASSIC_ENEMY(flamed) || CAN_EXPLODE_BY_DRAGONFIRE(flamed))
8279 RemoveMovingField(xx, yy);
8281 ChangeDelay[xx][yy] = 0;
8283 Tile[xx][yy] = EL_FLAMES;
8285 if (IN_SCR_FIELD(sx, sy))
8287 TEST_DrawLevelFieldCrumbled(xx, yy);
8288 DrawGraphic(sx, sy, flame_graphic, frame);
8293 if (Tile[xx][yy] == EL_FLAMES)
8294 Tile[xx][yy] = EL_EMPTY;
8295 TEST_DrawLevelField(xx, yy);
8300 if (MovDelay[x][y]) // element still has to wait some time
8302 PlayLevelSoundAction(x, y, ACTION_WAITING);
8308 // now make next step
8310 Moving2Blocked(x, y, &newx, &newy); // get next screen position
8312 if (DONT_COLLIDE_WITH(element) &&
8313 IN_LEV_FIELD(newx, newy) && IS_PLAYER(newx, newy) &&
8314 !PLAYER_ENEMY_PROTECTED(newx, newy))
8316 TestIfBadThingRunsIntoPlayer(x, y, MovDir[x][y]);
8321 else if (CAN_MOVE_INTO_ACID(element) &&
8322 IN_LEV_FIELD(newx, newy) && Tile[newx][newy] == EL_ACID &&
8323 !IS_MV_DIAGONAL(MovDir[x][y]) &&
8324 (MovDir[x][y] == MV_DOWN ||
8325 game.engine_version >= VERSION_IDENT(3,1,0,0)))
8327 SplashAcid(newx, newy);
8328 Store[x][y] = EL_ACID;
8330 else if (element == EL_PENGUIN && IN_LEV_FIELD(newx, newy))
8332 if (Tile[newx][newy] == EL_EXIT_OPEN ||
8333 Tile[newx][newy] == EL_EM_EXIT_OPEN ||
8334 Tile[newx][newy] == EL_STEEL_EXIT_OPEN ||
8335 Tile[newx][newy] == EL_EM_STEEL_EXIT_OPEN)
8338 TEST_DrawLevelField(x, y);
8340 PlayLevelSound(newx, newy, SND_PENGUIN_PASSING);
8341 if (IN_SCR_FIELD(SCREENX(newx), SCREENY(newy)))
8342 DrawGraphicThruMask(SCREENX(newx),SCREENY(newy), el2img(element), 0);
8344 game.friends_still_needed--;
8345 if (!game.friends_still_needed &&
8347 game.all_players_gone)
8352 else if (IS_FOOD_PENGUIN(Tile[newx][newy]))
8354 if (DigField(local_player, x, y, newx, newy, 0,0, DF_DIG) == MP_MOVING)
8355 TEST_DrawLevelField(newx, newy);
8357 GfxDir[x][y] = MovDir[x][y] = MV_NONE;
8359 else if (!IS_FREE(newx, newy))
8361 GfxAction[x][y] = ACTION_WAITING;
8363 if (IS_PLAYER(x, y))
8364 DrawPlayerField(x, y);
8366 TEST_DrawLevelField(x, y);
8371 else if (element == EL_PIG && IN_LEV_FIELD(newx, newy))
8373 if (IS_FOOD_PIG(Tile[newx][newy]))
8375 if (IS_MOVING(newx, newy))
8376 RemoveMovingField(newx, newy);
8379 Tile[newx][newy] = EL_EMPTY;
8380 TEST_DrawLevelField(newx, newy);
8383 PlayLevelSound(x, y, SND_PIG_DIGGING);
8385 else if (!IS_FREE(newx, newy))
8387 if (IS_PLAYER(x, y))
8388 DrawPlayerField(x, y);
8390 TEST_DrawLevelField(x, y);
8395 else if (element == EL_EMC_ANDROID && IN_LEV_FIELD(newx, newy))
8397 if (Store[x][y] != EL_EMPTY)
8399 boolean can_clone = FALSE;
8402 // check if element to clone is still there
8403 for (yy = y - 1; yy <= y + 1; yy++) for (xx = x - 1; xx <= x + 1; xx++)
8405 if (IN_LEV_FIELD(xx, yy) && Tile[xx][yy] == Store[x][y])
8413 // cannot clone or target field not free anymore -- do not clone
8414 if (!can_clone || !ANDROID_CAN_ENTER_FIELD(element, newx, newy))
8415 Store[x][y] = EL_EMPTY;
8418 if (ANDROID_CAN_ENTER_FIELD(element, newx, newy))
8420 if (IS_MV_DIAGONAL(MovDir[x][y]))
8422 int diagonal_move_dir = MovDir[x][y];
8423 int stored = Store[x][y];
8424 int change_delay = 8;
8427 // android is moving diagonally
8429 CreateField(x, y, EL_DIAGONAL_SHRINKING);
8431 Store[x][y] = (stored == EL_ACID ? EL_EMPTY : stored);
8432 GfxElement[x][y] = EL_EMC_ANDROID;
8433 GfxAction[x][y] = ACTION_SHRINKING;
8434 GfxDir[x][y] = diagonal_move_dir;
8435 ChangeDelay[x][y] = change_delay;
8437 if (Store[x][y] == EL_EMPTY)
8438 Store[x][y] = GfxElementEmpty[x][y];
8440 graphic = el_act_dir2img(GfxElement[x][y], GfxAction[x][y],
8443 DrawLevelGraphicAnimation(x, y, graphic);
8444 PlayLevelSoundAction(x, y, ACTION_SHRINKING);
8446 if (Tile[newx][newy] == EL_ACID)
8448 SplashAcid(newx, newy);
8453 CreateField(newx, newy, EL_DIAGONAL_GROWING);
8455 Store[newx][newy] = EL_EMC_ANDROID;
8456 GfxElement[newx][newy] = EL_EMC_ANDROID;
8457 GfxAction[newx][newy] = ACTION_GROWING;
8458 GfxDir[newx][newy] = diagonal_move_dir;
8459 ChangeDelay[newx][newy] = change_delay;
8461 graphic = el_act_dir2img(GfxElement[newx][newy],
8462 GfxAction[newx][newy], GfxDir[newx][newy]);
8464 DrawLevelGraphicAnimation(newx, newy, graphic);
8465 PlayLevelSoundAction(newx, newy, ACTION_GROWING);
8471 Tile[newx][newy] = EL_EMPTY;
8472 TEST_DrawLevelField(newx, newy);
8474 PlayLevelSoundAction(x, y, ACTION_DIGGING);
8477 else if (!IS_FREE(newx, newy))
8482 else if (IS_CUSTOM_ELEMENT(element) &&
8483 CUSTOM_ELEMENT_CAN_ENTER_FIELD(element, newx, newy))
8485 if (!DigFieldByCE(newx, newy, element))
8488 if (move_pattern & MV_MAZE_RUNNER_STYLE)
8490 RunnerVisit[x][y] = FrameCounter;
8491 PlayerVisit[x][y] /= 8; // expire player visit path
8494 else if (element == EL_DRAGON && IN_LEV_FIELD(newx, newy))
8496 if (!IS_FREE(newx, newy))
8498 if (IS_PLAYER(x, y))
8499 DrawPlayerField(x, y);
8501 TEST_DrawLevelField(x, y);
8507 boolean wanna_flame = !RND(10);
8508 int dx = newx - x, dy = newy - y;
8509 int newx1 = newx + 1 * dx, newy1 = newy + 1 * dy;
8510 int newx2 = newx + 2 * dx, newy2 = newy + 2 * dy;
8511 int element1 = (IN_LEV_FIELD(newx1, newy1) ?
8512 MovingOrBlocked2Element(newx1, newy1) : EL_STEELWALL);
8513 int element2 = (IN_LEV_FIELD(newx2, newy2) ?
8514 MovingOrBlocked2Element(newx2, newy2) : EL_STEELWALL);
8517 IS_CLASSIC_ENEMY(element1) ||
8518 IS_CLASSIC_ENEMY(element2)) &&
8519 element1 != EL_DRAGON && element2 != EL_DRAGON &&
8520 element1 != EL_FLAMES && element2 != EL_FLAMES)
8522 ResetGfxAnimation(x, y);
8523 GfxAction[x][y] = ACTION_ATTACKING;
8525 if (IS_PLAYER(x, y))
8526 DrawPlayerField(x, y);
8528 TEST_DrawLevelField(x, y);
8530 PlayLevelSound(x, y, SND_DRAGON_ATTACKING);
8532 MovDelay[x][y] = 50;
8534 Tile[newx][newy] = EL_FLAMES;
8535 if (IN_LEV_FIELD(newx1, newy1) && Tile[newx1][newy1] == EL_EMPTY)
8536 Tile[newx1][newy1] = EL_FLAMES;
8537 if (IN_LEV_FIELD(newx2, newy2) && Tile[newx2][newy2] == EL_EMPTY)
8538 Tile[newx2][newy2] = EL_FLAMES;
8544 else if (element == EL_YAMYAM && IN_LEV_FIELD(newx, newy) &&
8545 Tile[newx][newy] == EL_DIAMOND)
8547 if (IS_MOVING(newx, newy))
8548 RemoveMovingField(newx, newy);
8551 Tile[newx][newy] = EL_EMPTY;
8552 TEST_DrawLevelField(newx, newy);
8555 PlayLevelSound(x, y, SND_YAMYAM_DIGGING);
8557 else if (element == EL_DARK_YAMYAM && IN_LEV_FIELD(newx, newy) &&
8558 IS_FOOD_DARK_YAMYAM(Tile[newx][newy]))
8560 if (AmoebaNr[newx][newy])
8562 AmoebaCnt2[AmoebaNr[newx][newy]]--;
8563 if (Tile[newx][newy] == EL_AMOEBA_FULL ||
8564 Tile[newx][newy] == EL_BD_AMOEBA)
8565 AmoebaCnt[AmoebaNr[newx][newy]]--;
8568 if (IS_MOVING(newx, newy))
8570 RemoveMovingField(newx, newy);
8574 Tile[newx][newy] = EL_EMPTY;
8575 TEST_DrawLevelField(newx, newy);
8578 PlayLevelSound(x, y, SND_DARK_YAMYAM_DIGGING);
8580 else if ((element == EL_PACMAN || element == EL_MOLE)
8581 && IN_LEV_FIELD(newx, newy) && IS_AMOEBOID(Tile[newx][newy]))
8583 if (AmoebaNr[newx][newy])
8585 AmoebaCnt2[AmoebaNr[newx][newy]]--;
8586 if (Tile[newx][newy] == EL_AMOEBA_FULL ||
8587 Tile[newx][newy] == EL_BD_AMOEBA)
8588 AmoebaCnt[AmoebaNr[newx][newy]]--;
8591 if (element == EL_MOLE)
8593 Tile[newx][newy] = EL_AMOEBA_SHRINKING;
8594 PlayLevelSound(x, y, SND_MOLE_DIGGING);
8596 ResetGfxAnimation(x, y);
8597 GfxAction[x][y] = ACTION_DIGGING;
8598 TEST_DrawLevelField(x, y);
8600 MovDelay[newx][newy] = 0; // start amoeba shrinking delay
8602 return; // wait for shrinking amoeba
8604 else // element == EL_PACMAN
8606 Tile[newx][newy] = EL_EMPTY;
8607 TEST_DrawLevelField(newx, newy);
8608 PlayLevelSound(x, y, SND_PACMAN_DIGGING);
8611 else if (element == EL_MOLE && IN_LEV_FIELD(newx, newy) &&
8612 (Tile[newx][newy] == EL_AMOEBA_SHRINKING ||
8613 (Tile[newx][newy] == EL_EMPTY && Stop[newx][newy])))
8615 // wait for shrinking amoeba to completely disappear
8618 else if (!IN_LEV_FIELD(newx, newy) || !IS_FREE(newx, newy))
8620 // object was running against a wall
8624 if (GFX_ELEMENT(element) != EL_SAND) // !!! FIX THIS (crumble) !!!
8625 DrawLevelElementAnimation(x, y, element);
8627 if (DONT_TOUCH(element))
8628 TestIfBadThingTouchesPlayer(x, y);
8633 InitMovingField(x, y, MovDir[x][y]);
8635 PlayLevelSoundAction(x, y, ACTION_MOVING);
8639 ContinueMoving(x, y);
8642 void ContinueMoving(int x, int y)
8644 int element = Tile[x][y];
8645 struct ElementInfo *ei = &element_info[element];
8646 int direction = MovDir[x][y];
8647 int dx = (direction == MV_LEFT ? -1 : direction == MV_RIGHT ? +1 : 0);
8648 int dy = (direction == MV_UP ? -1 : direction == MV_DOWN ? +1 : 0);
8649 int newx = x + dx, newy = y + dy;
8650 int stored = Store[x][y];
8651 int stored_new = Store[newx][newy];
8652 boolean pushed_by_player = (Pushed[x][y] && IS_PLAYER(x, y));
8653 boolean pushed_by_conveyor = (Pushed[x][y] && !IS_PLAYER(x, y));
8654 boolean last_line = (newy == lev_fieldy - 1);
8655 boolean use_step_delay = (GET_MAX_STEP_DELAY(element) != 0);
8657 if (pushed_by_player) // special case: moving object pushed by player
8659 MovPos[x][y] = SIGN(MovPos[x][y]) * (TILEX - ABS(PLAYERINFO(x,y)->MovPos));
8661 else if (use_step_delay) // special case: moving object has step delay
8663 if (!MovDelay[x][y])
8664 MovPos[x][y] += getElementMoveStepsize(x, y);
8669 MovDelay[x][y] = GET_NEW_STEP_DELAY(element);
8673 TEST_DrawLevelField(x, y);
8675 return; // element is still waiting
8678 else // normal case: generically moving object
8680 MovPos[x][y] += getElementMoveStepsize(x, y);
8683 if (ABS(MovPos[x][y]) < TILEX)
8685 TEST_DrawLevelField(x, y);
8687 return; // element is still moving
8690 // element reached destination field
8692 Tile[x][y] = EL_EMPTY;
8693 Tile[newx][newy] = element;
8694 MovPos[x][y] = 0; // force "not moving" for "crumbled sand"
8696 if (Store[x][y] == EL_ACID) // element is moving into acid pool
8698 element = Tile[newx][newy] = EL_ACID;
8700 else if (element == EL_MOLE)
8702 Tile[x][y] = EL_SAND;
8704 TEST_DrawLevelFieldCrumbledNeighbours(x, y);
8706 else if (element == EL_QUICKSAND_FILLING)
8708 element = Tile[newx][newy] = get_next_element(element);
8709 Store[newx][newy] = Store[x][y];
8711 else if (element == EL_QUICKSAND_EMPTYING)
8713 Tile[x][y] = get_next_element(element);
8714 element = Tile[newx][newy] = Store[x][y];
8716 else if (element == EL_QUICKSAND_FAST_FILLING)
8718 element = Tile[newx][newy] = get_next_element(element);
8719 Store[newx][newy] = Store[x][y];
8721 else if (element == EL_QUICKSAND_FAST_EMPTYING)
8723 Tile[x][y] = get_next_element(element);
8724 element = Tile[newx][newy] = Store[x][y];
8726 else if (element == EL_MAGIC_WALL_FILLING)
8728 element = Tile[newx][newy] = get_next_element(element);
8729 if (!game.magic_wall_active)
8730 element = Tile[newx][newy] = EL_MAGIC_WALL_DEAD;
8731 Store[newx][newy] = Store[x][y];
8733 else if (element == EL_MAGIC_WALL_EMPTYING)
8735 Tile[x][y] = get_next_element(element);
8736 if (!game.magic_wall_active)
8737 Tile[x][y] = EL_MAGIC_WALL_DEAD;
8738 element = Tile[newx][newy] = Store[x][y];
8740 InitField(newx, newy, FALSE);
8742 else if (element == EL_BD_MAGIC_WALL_FILLING)
8744 element = Tile[newx][newy] = get_next_element(element);
8745 if (!game.magic_wall_active)
8746 element = Tile[newx][newy] = EL_BD_MAGIC_WALL_DEAD;
8747 Store[newx][newy] = Store[x][y];
8749 else if (element == EL_BD_MAGIC_WALL_EMPTYING)
8751 Tile[x][y] = get_next_element(element);
8752 if (!game.magic_wall_active)
8753 Tile[x][y] = EL_BD_MAGIC_WALL_DEAD;
8754 element = Tile[newx][newy] = Store[x][y];
8756 InitField(newx, newy, FALSE);
8758 else if (element == EL_DC_MAGIC_WALL_FILLING)
8760 element = Tile[newx][newy] = get_next_element(element);
8761 if (!game.magic_wall_active)
8762 element = Tile[newx][newy] = EL_DC_MAGIC_WALL_DEAD;
8763 Store[newx][newy] = Store[x][y];
8765 else if (element == EL_DC_MAGIC_WALL_EMPTYING)
8767 Tile[x][y] = get_next_element(element);
8768 if (!game.magic_wall_active)
8769 Tile[x][y] = EL_DC_MAGIC_WALL_DEAD;
8770 element = Tile[newx][newy] = Store[x][y];
8772 InitField(newx, newy, FALSE);
8774 else if (element == EL_AMOEBA_DROPPING)
8776 Tile[x][y] = get_next_element(element);
8777 element = Tile[newx][newy] = Store[x][y];
8779 else if (element == EL_SOKOBAN_OBJECT)
8782 Tile[x][y] = Back[x][y];
8784 if (Back[newx][newy])
8785 Tile[newx][newy] = EL_SOKOBAN_FIELD_FULL;
8787 Back[x][y] = Back[newx][newy] = 0;
8790 Store[x][y] = EL_EMPTY;
8795 MovDelay[newx][newy] = 0;
8797 if (CAN_CHANGE_OR_HAS_ACTION(element))
8799 // copy element change control values to new field
8800 ChangeDelay[newx][newy] = ChangeDelay[x][y];
8801 ChangePage[newx][newy] = ChangePage[x][y];
8802 ChangeCount[newx][newy] = ChangeCount[x][y];
8803 ChangeEvent[newx][newy] = ChangeEvent[x][y];
8806 CustomValue[newx][newy] = CustomValue[x][y];
8808 ChangeDelay[x][y] = 0;
8809 ChangePage[x][y] = -1;
8810 ChangeCount[x][y] = 0;
8811 ChangeEvent[x][y] = -1;
8813 CustomValue[x][y] = 0;
8815 // copy animation control values to new field
8816 GfxFrame[newx][newy] = GfxFrame[x][y];
8817 GfxRandom[newx][newy] = GfxRandom[x][y]; // keep same random value
8818 GfxAction[newx][newy] = GfxAction[x][y]; // keep action one frame
8819 GfxDir[newx][newy] = GfxDir[x][y]; // keep element direction
8821 Pushed[x][y] = Pushed[newx][newy] = FALSE;
8823 // some elements can leave other elements behind after moving
8824 if (ei->move_leave_element != EL_EMPTY &&
8825 (ei->move_leave_type == LEAVE_TYPE_UNLIMITED || stored != EL_EMPTY) &&
8826 (!IS_PLAYER(x, y) || IS_WALKABLE(ei->move_leave_element)))
8828 int move_leave_element = ei->move_leave_element;
8830 // this makes it possible to leave the removed element again
8831 if (ei->move_leave_element == EL_TRIGGER_ELEMENT)
8832 move_leave_element = (stored == EL_ACID ? EL_EMPTY : stored);
8834 Tile[x][y] = move_leave_element;
8836 if (element_info[Tile[x][y]].move_direction_initial == MV_START_PREVIOUS)
8837 MovDir[x][y] = direction;
8839 InitField(x, y, FALSE);
8841 if (GFX_CRUMBLED(Tile[x][y]))
8842 TEST_DrawLevelFieldCrumbledNeighbours(x, y);
8844 if (IS_PLAYER_ELEMENT(move_leave_element))
8845 RelocatePlayer(x, y, move_leave_element);
8848 // do this after checking for left-behind element
8849 ResetGfxAnimation(x, y); // reset animation values for old field
8851 if (!CAN_MOVE(element) ||
8852 (CAN_FALL(element) && direction == MV_DOWN &&
8853 (element == EL_SPRING ||
8854 element_info[element].move_pattern == MV_WHEN_PUSHED ||
8855 element_info[element].move_pattern == MV_WHEN_DROPPED)))
8856 GfxDir[x][y] = MovDir[newx][newy] = 0;
8858 TEST_DrawLevelField(x, y);
8859 TEST_DrawLevelField(newx, newy);
8861 Stop[newx][newy] = TRUE; // ignore this element until the next frame
8863 // prevent pushed element from moving on in pushed direction
8864 if (pushed_by_player && CAN_MOVE(element) &&
8865 element_info[element].move_pattern & MV_ANY_DIRECTION &&
8866 !(element_info[element].move_pattern & direction))
8867 TurnRound(newx, newy);
8869 // prevent elements on conveyor belt from moving on in last direction
8870 if (pushed_by_conveyor && CAN_FALL(element) &&
8871 direction & MV_HORIZONTAL)
8872 MovDir[newx][newy] = 0;
8874 if (!pushed_by_player)
8876 int nextx = newx + dx, nexty = newy + dy;
8877 boolean check_collision_again = IN_LEV_FIELD_AND_IS_FREE(nextx, nexty);
8879 WasJustMoving[newx][newy] = CHECK_DELAY_MOVING;
8881 if (CAN_FALL(element) && direction == MV_DOWN)
8882 WasJustFalling[newx][newy] = CHECK_DELAY_FALLING;
8884 if ((!CAN_FALL(element) || direction == MV_DOWN) && check_collision_again)
8885 CheckCollision[newx][newy] = CHECK_DELAY_COLLISION;
8887 if (CAN_FALL(element) && direction == MV_DOWN && check_collision_again)
8888 CheckImpact[newx][newy] = CHECK_DELAY_IMPACT;
8891 if (DONT_TOUCH(element)) // object may be nasty to player or others
8893 TestIfBadThingTouchesPlayer(newx, newy);
8894 TestIfBadThingTouchesFriend(newx, newy);
8896 if (!IS_CUSTOM_ELEMENT(element))
8897 TestIfBadThingTouchesOtherBadThing(newx, newy);
8899 else if (element == EL_PENGUIN)
8900 TestIfFriendTouchesBadThing(newx, newy);
8902 if (DONT_GET_HIT_BY(element))
8904 TestIfGoodThingGetsHitByBadThing(newx, newy, direction);
8907 // give the player one last chance (one more frame) to move away
8908 if (CAN_FALL(element) && direction == MV_DOWN &&
8909 (last_line || (!IS_FREE(x, newy + 1) &&
8910 (!IS_PLAYER(x, newy + 1) ||
8911 game.engine_version < VERSION_IDENT(3,1,1,0)))))
8914 if (pushed_by_player && !game.use_change_when_pushing_bug)
8916 int push_side = MV_DIR_OPPOSITE(direction);
8917 struct PlayerInfo *player = PLAYERINFO(x, y);
8919 CheckElementChangeByPlayer(newx, newy, element, CE_PUSHED_BY_PLAYER,
8920 player->index_bit, push_side);
8921 CheckTriggeredElementChangeByPlayer(newx,newy, element, CE_PLAYER_PUSHES_X,
8922 player->index_bit, push_side);
8925 if (element == EL_EMC_ANDROID && pushed_by_player) // make another move
8926 MovDelay[newx][newy] = 1;
8928 CheckTriggeredElementChangeBySide(x, y, element, CE_MOVE_OF_X, direction);
8930 TestIfElementTouchesCustomElement(x, y); // empty or new element
8931 TestIfElementHitsCustomElement(newx, newy, direction);
8932 TestIfPlayerTouchesCustomElement(newx, newy);
8933 TestIfElementTouchesCustomElement(newx, newy);
8935 if (IS_CUSTOM_ELEMENT(element) && ei->move_enter_element != EL_EMPTY &&
8936 IS_EQUAL_OR_IN_GROUP(stored_new, ei->move_enter_element))
8937 CheckElementChangeBySide(newx, newy, element, stored_new, CE_DIGGING_X,
8938 MV_DIR_OPPOSITE(direction));
8941 int AmoebaNeighbourNr(int ax, int ay)
8944 int element = Tile[ax][ay];
8946 static int xy[4][2] =
8954 for (i = 0; i < NUM_DIRECTIONS; i++)
8956 int x = ax + xy[i][0];
8957 int y = ay + xy[i][1];
8959 if (!IN_LEV_FIELD(x, y))
8962 if (Tile[x][y] == element && AmoebaNr[x][y] > 0)
8963 group_nr = AmoebaNr[x][y];
8969 static void AmoebaMerge(int ax, int ay)
8971 int i, x, y, xx, yy;
8972 int new_group_nr = AmoebaNr[ax][ay];
8973 static int xy[4][2] =
8981 if (new_group_nr == 0)
8984 for (i = 0; i < NUM_DIRECTIONS; i++)
8989 if (!IN_LEV_FIELD(x, y))
8992 if ((Tile[x][y] == EL_AMOEBA_FULL ||
8993 Tile[x][y] == EL_BD_AMOEBA ||
8994 Tile[x][y] == EL_AMOEBA_DEAD) &&
8995 AmoebaNr[x][y] != new_group_nr)
8997 int old_group_nr = AmoebaNr[x][y];
8999 if (old_group_nr == 0)
9002 AmoebaCnt[new_group_nr] += AmoebaCnt[old_group_nr];
9003 AmoebaCnt[old_group_nr] = 0;
9004 AmoebaCnt2[new_group_nr] += AmoebaCnt2[old_group_nr];
9005 AmoebaCnt2[old_group_nr] = 0;
9007 SCAN_PLAYFIELD(xx, yy)
9009 if (AmoebaNr[xx][yy] == old_group_nr)
9010 AmoebaNr[xx][yy] = new_group_nr;
9016 void AmoebaToDiamond(int ax, int ay)
9020 if (Tile[ax][ay] == EL_AMOEBA_DEAD)
9022 int group_nr = AmoebaNr[ax][ay];
9027 Debug("game:playing:AmoebaToDiamond", "ax = %d, ay = %d", ax, ay);
9028 Debug("game:playing:AmoebaToDiamond", "This should never happen!");
9034 SCAN_PLAYFIELD(x, y)
9036 if (Tile[x][y] == EL_AMOEBA_DEAD && AmoebaNr[x][y] == group_nr)
9039 Tile[x][y] = EL_AMOEBA_TO_DIAMOND;
9043 PlayLevelSound(ax, ay, (IS_GEM(level.amoeba_content) ?
9044 SND_AMOEBA_TURNING_TO_GEM :
9045 SND_AMOEBA_TURNING_TO_ROCK));
9050 static int xy[4][2] =
9058 for (i = 0; i < NUM_DIRECTIONS; i++)
9063 if (!IN_LEV_FIELD(x, y))
9066 if (Tile[x][y] == EL_AMOEBA_TO_DIAMOND)
9068 PlayLevelSound(x, y, (IS_GEM(level.amoeba_content) ?
9069 SND_AMOEBA_TURNING_TO_GEM :
9070 SND_AMOEBA_TURNING_TO_ROCK));
9077 static void AmoebaToDiamondBD(int ax, int ay, int new_element)
9080 int group_nr = AmoebaNr[ax][ay];
9081 boolean done = FALSE;
9086 Debug("game:playing:AmoebaToDiamondBD", "ax = %d, ay = %d", ax, ay);
9087 Debug("game:playing:AmoebaToDiamondBD", "This should never happen!");
9093 SCAN_PLAYFIELD(x, y)
9095 if (AmoebaNr[x][y] == group_nr &&
9096 (Tile[x][y] == EL_AMOEBA_DEAD ||
9097 Tile[x][y] == EL_BD_AMOEBA ||
9098 Tile[x][y] == EL_AMOEBA_GROWING))
9101 Tile[x][y] = new_element;
9102 InitField(x, y, FALSE);
9103 TEST_DrawLevelField(x, y);
9109 PlayLevelSound(ax, ay, (new_element == EL_BD_ROCK ?
9110 SND_BD_AMOEBA_TURNING_TO_ROCK :
9111 SND_BD_AMOEBA_TURNING_TO_GEM));
9114 static void AmoebaGrowing(int x, int y)
9116 static unsigned int sound_delay = 0;
9117 static unsigned int sound_delay_value = 0;
9119 if (!MovDelay[x][y]) // start new growing cycle
9123 if (DelayReached(&sound_delay, sound_delay_value))
9125 PlayLevelSoundElementAction(x, y, Store[x][y], ACTION_GROWING);
9126 sound_delay_value = 30;
9130 if (MovDelay[x][y]) // wait some time before growing bigger
9133 if (MovDelay[x][y]/2 && IN_SCR_FIELD(SCREENX(x), SCREENY(y)))
9135 int frame = getGraphicAnimationFrame(IMG_AMOEBA_GROWING,
9136 6 - MovDelay[x][y]);
9138 DrawGraphic(SCREENX(x), SCREENY(y), IMG_AMOEBA_GROWING, frame);
9141 if (!MovDelay[x][y])
9143 Tile[x][y] = Store[x][y];
9145 TEST_DrawLevelField(x, y);
9150 static void AmoebaShrinking(int x, int y)
9152 static unsigned int sound_delay = 0;
9153 static unsigned int sound_delay_value = 0;
9155 if (!MovDelay[x][y]) // start new shrinking cycle
9159 if (DelayReached(&sound_delay, sound_delay_value))
9160 sound_delay_value = 30;
9163 if (MovDelay[x][y]) // wait some time before shrinking
9166 if (MovDelay[x][y]/2 && IN_SCR_FIELD(SCREENX(x), SCREENY(y)))
9168 int frame = getGraphicAnimationFrame(IMG_AMOEBA_SHRINKING,
9169 6 - MovDelay[x][y]);
9171 DrawGraphic(SCREENX(x), SCREENY(y), IMG_AMOEBA_SHRINKING, frame);
9174 if (!MovDelay[x][y])
9176 Tile[x][y] = EL_EMPTY;
9177 TEST_DrawLevelField(x, y);
9179 // don't let mole enter this field in this cycle;
9180 // (give priority to objects falling to this field from above)
9186 static void AmoebaReproduce(int ax, int ay)
9189 int element = Tile[ax][ay];
9190 int graphic = el2img(element);
9191 int newax = ax, neway = ay;
9192 boolean can_drop = (element == EL_AMOEBA_WET || element == EL_EMC_DRIPPER);
9193 static int xy[4][2] =
9201 if (!level.amoeba_speed && element != EL_EMC_DRIPPER)
9203 Tile[ax][ay] = EL_AMOEBA_DEAD;
9204 TEST_DrawLevelField(ax, ay);
9208 if (IS_ANIMATED(graphic))
9209 DrawLevelGraphicAnimationIfNeeded(ax, ay, graphic);
9211 if (!MovDelay[ax][ay]) // start making new amoeba field
9212 MovDelay[ax][ay] = RND(FRAMES_PER_SECOND * 25 / (1 + level.amoeba_speed));
9214 if (MovDelay[ax][ay]) // wait some time before making new amoeba
9217 if (MovDelay[ax][ay])
9221 if (can_drop) // EL_AMOEBA_WET or EL_EMC_DRIPPER
9224 int x = ax + xy[start][0];
9225 int y = ay + xy[start][1];
9227 if (!IN_LEV_FIELD(x, y))
9230 if (IS_FREE(x, y) ||
9231 CAN_GROW_INTO(Tile[x][y]) ||
9232 Tile[x][y] == EL_QUICKSAND_EMPTY ||
9233 Tile[x][y] == EL_QUICKSAND_FAST_EMPTY)
9239 if (newax == ax && neway == ay)
9242 else // normal or "filled" (BD style) amoeba
9245 boolean waiting_for_player = FALSE;
9247 for (i = 0; i < NUM_DIRECTIONS; i++)
9249 int j = (start + i) % 4;
9250 int x = ax + xy[j][0];
9251 int y = ay + xy[j][1];
9253 if (!IN_LEV_FIELD(x, y))
9256 if (IS_FREE(x, y) ||
9257 CAN_GROW_INTO(Tile[x][y]) ||
9258 Tile[x][y] == EL_QUICKSAND_EMPTY ||
9259 Tile[x][y] == EL_QUICKSAND_FAST_EMPTY)
9265 else if (IS_PLAYER(x, y))
9266 waiting_for_player = TRUE;
9269 if (newax == ax && neway == ay) // amoeba cannot grow
9271 if (i == 4 && (!waiting_for_player || element == EL_BD_AMOEBA))
9273 Tile[ax][ay] = EL_AMOEBA_DEAD;
9274 TEST_DrawLevelField(ax, ay);
9275 AmoebaCnt[AmoebaNr[ax][ay]]--;
9277 if (AmoebaCnt[AmoebaNr[ax][ay]] <= 0) // amoeba is completely dead
9279 if (element == EL_AMOEBA_FULL)
9280 AmoebaToDiamond(ax, ay);
9281 else if (element == EL_BD_AMOEBA)
9282 AmoebaToDiamondBD(ax, ay, level.amoeba_content);
9287 else if (element == EL_AMOEBA_FULL || element == EL_BD_AMOEBA)
9289 // amoeba gets larger by growing in some direction
9291 int new_group_nr = AmoebaNr[ax][ay];
9294 if (new_group_nr == 0)
9296 Debug("game:playing:AmoebaReproduce", "newax = %d, neway = %d",
9298 Debug("game:playing:AmoebaReproduce", "This should never happen!");
9304 AmoebaNr[newax][neway] = new_group_nr;
9305 AmoebaCnt[new_group_nr]++;
9306 AmoebaCnt2[new_group_nr]++;
9308 // if amoeba touches other amoeba(s) after growing, unify them
9309 AmoebaMerge(newax, neway);
9311 if (element == EL_BD_AMOEBA && AmoebaCnt2[new_group_nr] >= 200)
9313 AmoebaToDiamondBD(newax, neway, EL_BD_ROCK);
9319 if (!can_drop || neway < ay || !IS_FREE(newax, neway) ||
9320 (neway == lev_fieldy - 1 && newax != ax))
9322 Tile[newax][neway] = EL_AMOEBA_GROWING; // creation of new amoeba
9323 Store[newax][neway] = element;
9325 else if (neway == ay || element == EL_EMC_DRIPPER)
9327 Tile[newax][neway] = EL_AMOEBA_DROP; // drop left/right of amoeba
9329 PlayLevelSoundAction(newax, neway, ACTION_GROWING);
9333 InitMovingField(ax, ay, MV_DOWN); // drop dripping from amoeba
9334 Tile[ax][ay] = EL_AMOEBA_DROPPING;
9335 Store[ax][ay] = EL_AMOEBA_DROP;
9336 ContinueMoving(ax, ay);
9340 TEST_DrawLevelField(newax, neway);
9343 static void Life(int ax, int ay)
9347 int element = Tile[ax][ay];
9348 int graphic = el2img(element);
9349 int *life_parameter = (element == EL_GAME_OF_LIFE ? level.game_of_life :
9351 boolean changed = FALSE;
9353 if (IS_ANIMATED(graphic))
9354 DrawLevelGraphicAnimationIfNeeded(ax, ay, graphic);
9359 if (!MovDelay[ax][ay]) // start new "game of life" cycle
9360 MovDelay[ax][ay] = life_time;
9362 if (MovDelay[ax][ay]) // wait some time before next cycle
9365 if (MovDelay[ax][ay])
9369 for (y1 = -1; y1 < 2; y1++) for (x1 = -1; x1 < 2; x1++)
9371 int xx = ax+x1, yy = ay+y1;
9372 int old_element = Tile[xx][yy];
9373 int num_neighbours = 0;
9375 if (!IN_LEV_FIELD(xx, yy))
9378 for (y2 = -1; y2 < 2; y2++) for (x2 = -1; x2 < 2; x2++)
9380 int x = xx+x2, y = yy+y2;
9382 if (!IN_LEV_FIELD(x, y) || (x == xx && y == yy))
9385 boolean is_player_cell = (element == EL_GAME_OF_LIFE && IS_PLAYER(x, y));
9386 boolean is_neighbour = FALSE;
9388 if (level.use_life_bugs)
9390 (((Tile[x][y] == element || is_player_cell) && !Stop[x][y]) ||
9391 (IS_FREE(x, y) && Stop[x][y]));
9394 (Last[x][y] == element || is_player_cell);
9400 boolean is_free = FALSE;
9402 if (level.use_life_bugs)
9403 is_free = (IS_FREE(xx, yy));
9405 is_free = (IS_FREE(xx, yy) && Last[xx][yy] == EL_EMPTY);
9407 if (xx == ax && yy == ay) // field in the middle
9409 if (num_neighbours < life_parameter[0] ||
9410 num_neighbours > life_parameter[1])
9412 Tile[xx][yy] = EL_EMPTY;
9413 if (Tile[xx][yy] != old_element)
9414 TEST_DrawLevelField(xx, yy);
9415 Stop[xx][yy] = TRUE;
9419 else if (is_free || CAN_GROW_INTO(Tile[xx][yy]))
9420 { // free border field
9421 if (num_neighbours >= life_parameter[2] &&
9422 num_neighbours <= life_parameter[3])
9424 Tile[xx][yy] = element;
9425 MovDelay[xx][yy] = (element == EL_GAME_OF_LIFE ? 0 : life_time-1);
9426 if (Tile[xx][yy] != old_element)
9427 TEST_DrawLevelField(xx, yy);
9428 Stop[xx][yy] = TRUE;
9435 PlayLevelSound(ax, ay, element == EL_BIOMAZE ? SND_BIOMAZE_GROWING :
9436 SND_GAME_OF_LIFE_GROWING);
9439 static void InitRobotWheel(int x, int y)
9441 ChangeDelay[x][y] = level.time_wheel * FRAMES_PER_SECOND;
9444 static void RunRobotWheel(int x, int y)
9446 PlayLevelSound(x, y, SND_ROBOT_WHEEL_ACTIVE);
9449 static void StopRobotWheel(int x, int y)
9451 if (game.robot_wheel_x == x &&
9452 game.robot_wheel_y == y)
9454 game.robot_wheel_x = -1;
9455 game.robot_wheel_y = -1;
9456 game.robot_wheel_active = FALSE;
9460 static void InitTimegateWheel(int x, int y)
9462 ChangeDelay[x][y] = level.time_timegate * FRAMES_PER_SECOND;
9465 static void RunTimegateWheel(int x, int y)
9467 PlayLevelSound(x, y, SND_CLASS_TIMEGATE_SWITCH_ACTIVE);
9470 static void InitMagicBallDelay(int x, int y)
9472 ChangeDelay[x][y] = (level.ball_time + 1) * 8 + 1;
9475 static void ActivateMagicBall(int bx, int by)
9479 if (level.ball_random)
9481 int pos_border = RND(8); // select one of the eight border elements
9482 int pos_content = (pos_border > 3 ? pos_border + 1 : pos_border);
9483 int xx = pos_content % 3;
9484 int yy = pos_content / 3;
9489 if (IN_LEV_FIELD(x, y) && Tile[x][y] == EL_EMPTY)
9490 CreateField(x, y, level.ball_content[game.ball_content_nr].e[xx][yy]);
9494 for (y = by - 1; y <= by + 1; y++) for (x = bx - 1; x <= bx + 1; x++)
9496 int xx = x - bx + 1;
9497 int yy = y - by + 1;
9499 if (IN_LEV_FIELD(x, y) && Tile[x][y] == EL_EMPTY)
9500 CreateField(x, y, level.ball_content[game.ball_content_nr].e[xx][yy]);
9504 game.ball_content_nr = (game.ball_content_nr + 1) % level.num_ball_contents;
9507 static void CheckExit(int x, int y)
9509 if (game.gems_still_needed > 0 ||
9510 game.sokoban_fields_still_needed > 0 ||
9511 game.sokoban_objects_still_needed > 0 ||
9512 game.lights_still_needed > 0)
9514 int element = Tile[x][y];
9515 int graphic = el2img(element);
9517 if (IS_ANIMATED(graphic))
9518 DrawLevelGraphicAnimationIfNeeded(x, y, graphic);
9523 // do not re-open exit door closed after last player
9524 if (game.all_players_gone)
9527 Tile[x][y] = EL_EXIT_OPENING;
9529 PlayLevelSoundNearest(x, y, SND_CLASS_EXIT_OPENING);
9532 static void CheckExitEM(int x, int y)
9534 if (game.gems_still_needed > 0 ||
9535 game.sokoban_fields_still_needed > 0 ||
9536 game.sokoban_objects_still_needed > 0 ||
9537 game.lights_still_needed > 0)
9539 int element = Tile[x][y];
9540 int graphic = el2img(element);
9542 if (IS_ANIMATED(graphic))
9543 DrawLevelGraphicAnimationIfNeeded(x, y, graphic);
9548 // do not re-open exit door closed after last player
9549 if (game.all_players_gone)
9552 Tile[x][y] = EL_EM_EXIT_OPENING;
9554 PlayLevelSoundNearest(x, y, SND_CLASS_EM_EXIT_OPENING);
9557 static void CheckExitSteel(int x, int y)
9559 if (game.gems_still_needed > 0 ||
9560 game.sokoban_fields_still_needed > 0 ||
9561 game.sokoban_objects_still_needed > 0 ||
9562 game.lights_still_needed > 0)
9564 int element = Tile[x][y];
9565 int graphic = el2img(element);
9567 if (IS_ANIMATED(graphic))
9568 DrawLevelGraphicAnimationIfNeeded(x, y, graphic);
9573 // do not re-open exit door closed after last player
9574 if (game.all_players_gone)
9577 Tile[x][y] = EL_STEEL_EXIT_OPENING;
9579 PlayLevelSoundNearest(x, y, SND_CLASS_STEEL_EXIT_OPENING);
9582 static void CheckExitSteelEM(int x, int y)
9584 if (game.gems_still_needed > 0 ||
9585 game.sokoban_fields_still_needed > 0 ||
9586 game.sokoban_objects_still_needed > 0 ||
9587 game.lights_still_needed > 0)
9589 int element = Tile[x][y];
9590 int graphic = el2img(element);
9592 if (IS_ANIMATED(graphic))
9593 DrawLevelGraphicAnimationIfNeeded(x, y, graphic);
9598 // do not re-open exit door closed after last player
9599 if (game.all_players_gone)
9602 Tile[x][y] = EL_EM_STEEL_EXIT_OPENING;
9604 PlayLevelSoundNearest(x, y, SND_CLASS_EM_STEEL_EXIT_OPENING);
9607 static void CheckExitSP(int x, int y)
9609 if (game.gems_still_needed > 0)
9611 int element = Tile[x][y];
9612 int graphic = el2img(element);
9614 if (IS_ANIMATED(graphic))
9615 DrawLevelGraphicAnimationIfNeeded(x, y, graphic);
9620 // do not re-open exit door closed after last player
9621 if (game.all_players_gone)
9624 Tile[x][y] = EL_SP_EXIT_OPENING;
9626 PlayLevelSoundNearest(x, y, SND_CLASS_SP_EXIT_OPENING);
9629 static void CloseAllOpenTimegates(void)
9633 SCAN_PLAYFIELD(x, y)
9635 int element = Tile[x][y];
9637 if (element == EL_TIMEGATE_OPEN || element == EL_TIMEGATE_OPENING)
9639 Tile[x][y] = EL_TIMEGATE_CLOSING;
9641 PlayLevelSoundAction(x, y, ACTION_CLOSING);
9646 static void DrawTwinkleOnField(int x, int y)
9648 if (!IN_SCR_FIELD(SCREENX(x), SCREENY(y)) || IS_MOVING(x, y))
9651 if (Tile[x][y] == EL_BD_DIAMOND)
9654 if (MovDelay[x][y] == 0) // next animation frame
9655 MovDelay[x][y] = 11 * !GetSimpleRandom(500);
9657 if (MovDelay[x][y] != 0) // wait some time before next frame
9661 DrawLevelElementAnimation(x, y, Tile[x][y]);
9663 if (MovDelay[x][y] != 0)
9665 int frame = getGraphicAnimationFrame(IMG_TWINKLE_WHITE,
9666 10 - MovDelay[x][y]);
9668 DrawGraphicThruMask(SCREENX(x), SCREENY(y), IMG_TWINKLE_WHITE, frame);
9673 static void MauerWaechst(int x, int y)
9677 if (!MovDelay[x][y]) // next animation frame
9678 MovDelay[x][y] = 3 * delay;
9680 if (MovDelay[x][y]) // wait some time before next frame
9684 if (IN_SCR_FIELD(SCREENX(x), SCREENY(y)))
9686 int graphic = el_dir2img(Tile[x][y], GfxDir[x][y]);
9687 int frame = getGraphicAnimationFrame(graphic, 17 - MovDelay[x][y]);
9689 DrawGraphic(SCREENX(x), SCREENY(y), graphic, frame);
9692 if (!MovDelay[x][y])
9694 if (MovDir[x][y] == MV_LEFT)
9696 if (IN_LEV_FIELD(x - 1, y) && IS_WALL(Tile[x - 1][y]))
9697 TEST_DrawLevelField(x - 1, y);
9699 else if (MovDir[x][y] == MV_RIGHT)
9701 if (IN_LEV_FIELD(x + 1, y) && IS_WALL(Tile[x + 1][y]))
9702 TEST_DrawLevelField(x + 1, y);
9704 else if (MovDir[x][y] == MV_UP)
9706 if (IN_LEV_FIELD(x, y - 1) && IS_WALL(Tile[x][y - 1]))
9707 TEST_DrawLevelField(x, y - 1);
9711 if (IN_LEV_FIELD(x, y + 1) && IS_WALL(Tile[x][y + 1]))
9712 TEST_DrawLevelField(x, y + 1);
9715 Tile[x][y] = Store[x][y];
9717 GfxDir[x][y] = MovDir[x][y] = MV_NONE;
9718 TEST_DrawLevelField(x, y);
9723 static void MauerAbleger(int ax, int ay)
9725 int element = Tile[ax][ay];
9726 int graphic = el2img(element);
9727 boolean oben_frei = FALSE, unten_frei = FALSE;
9728 boolean links_frei = FALSE, rechts_frei = FALSE;
9729 boolean oben_massiv = FALSE, unten_massiv = FALSE;
9730 boolean links_massiv = FALSE, rechts_massiv = FALSE;
9731 boolean new_wall = FALSE;
9733 if (IS_ANIMATED(graphic))
9734 DrawLevelGraphicAnimationIfNeeded(ax, ay, graphic);
9736 if (!MovDelay[ax][ay]) // start building new wall
9737 MovDelay[ax][ay] = 6;
9739 if (MovDelay[ax][ay]) // wait some time before building new wall
9742 if (MovDelay[ax][ay])
9746 if (IN_LEV_FIELD(ax, ay-1) && IS_FREE(ax, ay-1))
9748 if (IN_LEV_FIELD(ax, ay+1) && IS_FREE(ax, ay+1))
9750 if (IN_LEV_FIELD(ax-1, ay) && IS_FREE(ax-1, ay))
9752 if (IN_LEV_FIELD(ax+1, ay) && IS_FREE(ax+1, ay))
9755 if (element == EL_EXPANDABLE_WALL_VERTICAL ||
9756 element == EL_EXPANDABLE_WALL_ANY)
9760 Tile[ax][ay-1] = EL_EXPANDABLE_WALL_GROWING;
9761 Store[ax][ay-1] = element;
9762 GfxDir[ax][ay-1] = MovDir[ax][ay-1] = MV_UP;
9763 if (IN_SCR_FIELD(SCREENX(ax), SCREENY(ay-1)))
9764 DrawGraphic(SCREENX(ax), SCREENY(ay - 1),
9765 IMG_EXPANDABLE_WALL_GROWING_UP, 0);
9770 Tile[ax][ay+1] = EL_EXPANDABLE_WALL_GROWING;
9771 Store[ax][ay+1] = element;
9772 GfxDir[ax][ay+1] = MovDir[ax][ay+1] = MV_DOWN;
9773 if (IN_SCR_FIELD(SCREENX(ax), SCREENY(ay+1)))
9774 DrawGraphic(SCREENX(ax), SCREENY(ay + 1),
9775 IMG_EXPANDABLE_WALL_GROWING_DOWN, 0);
9780 if (element == EL_EXPANDABLE_WALL_HORIZONTAL ||
9781 element == EL_EXPANDABLE_WALL_ANY ||
9782 element == EL_EXPANDABLE_WALL ||
9783 element == EL_BD_EXPANDABLE_WALL)
9787 Tile[ax-1][ay] = EL_EXPANDABLE_WALL_GROWING;
9788 Store[ax-1][ay] = element;
9789 GfxDir[ax-1][ay] = MovDir[ax-1][ay] = MV_LEFT;
9790 if (IN_SCR_FIELD(SCREENX(ax-1), SCREENY(ay)))
9791 DrawGraphic(SCREENX(ax - 1), SCREENY(ay),
9792 IMG_EXPANDABLE_WALL_GROWING_LEFT, 0);
9798 Tile[ax+1][ay] = EL_EXPANDABLE_WALL_GROWING;
9799 Store[ax+1][ay] = element;
9800 GfxDir[ax+1][ay] = MovDir[ax+1][ay] = MV_RIGHT;
9801 if (IN_SCR_FIELD(SCREENX(ax+1), SCREENY(ay)))
9802 DrawGraphic(SCREENX(ax + 1), SCREENY(ay),
9803 IMG_EXPANDABLE_WALL_GROWING_RIGHT, 0);
9808 if (element == EL_EXPANDABLE_WALL && (links_frei || rechts_frei))
9809 TEST_DrawLevelField(ax, ay);
9811 if (!IN_LEV_FIELD(ax, ay-1) || IS_WALL(Tile[ax][ay-1]))
9813 if (!IN_LEV_FIELD(ax, ay+1) || IS_WALL(Tile[ax][ay+1]))
9814 unten_massiv = TRUE;
9815 if (!IN_LEV_FIELD(ax-1, ay) || IS_WALL(Tile[ax-1][ay]))
9816 links_massiv = TRUE;
9817 if (!IN_LEV_FIELD(ax+1, ay) || IS_WALL(Tile[ax+1][ay]))
9818 rechts_massiv = TRUE;
9820 if (((oben_massiv && unten_massiv) ||
9821 element == EL_EXPANDABLE_WALL_HORIZONTAL ||
9822 element == EL_EXPANDABLE_WALL) &&
9823 ((links_massiv && rechts_massiv) ||
9824 element == EL_EXPANDABLE_WALL_VERTICAL))
9825 Tile[ax][ay] = EL_WALL;
9828 PlayLevelSoundAction(ax, ay, ACTION_GROWING);
9831 static void MauerAblegerStahl(int ax, int ay)
9833 int element = Tile[ax][ay];
9834 int graphic = el2img(element);
9835 boolean oben_frei = FALSE, unten_frei = FALSE;
9836 boolean links_frei = FALSE, rechts_frei = FALSE;
9837 boolean oben_massiv = FALSE, unten_massiv = FALSE;
9838 boolean links_massiv = FALSE, rechts_massiv = FALSE;
9839 boolean new_wall = FALSE;
9841 if (IS_ANIMATED(graphic))
9842 DrawLevelGraphicAnimationIfNeeded(ax, ay, graphic);
9844 if (!MovDelay[ax][ay]) // start building new wall
9845 MovDelay[ax][ay] = 6;
9847 if (MovDelay[ax][ay]) // wait some time before building new wall
9850 if (MovDelay[ax][ay])
9854 if (IN_LEV_FIELD(ax, ay-1) && IS_FREE(ax, ay-1))
9856 if (IN_LEV_FIELD(ax, ay+1) && IS_FREE(ax, ay+1))
9858 if (IN_LEV_FIELD(ax-1, ay) && IS_FREE(ax-1, ay))
9860 if (IN_LEV_FIELD(ax+1, ay) && IS_FREE(ax+1, ay))
9863 if (element == EL_EXPANDABLE_STEELWALL_VERTICAL ||
9864 element == EL_EXPANDABLE_STEELWALL_ANY)
9868 Tile[ax][ay-1] = EL_EXPANDABLE_STEELWALL_GROWING;
9869 Store[ax][ay-1] = element;
9870 GfxDir[ax][ay-1] = MovDir[ax][ay-1] = MV_UP;
9871 if (IN_SCR_FIELD(SCREENX(ax), SCREENY(ay-1)))
9872 DrawGraphic(SCREENX(ax), SCREENY(ay - 1),
9873 IMG_EXPANDABLE_STEELWALL_GROWING_UP, 0);
9878 Tile[ax][ay+1] = EL_EXPANDABLE_STEELWALL_GROWING;
9879 Store[ax][ay+1] = element;
9880 GfxDir[ax][ay+1] = MovDir[ax][ay+1] = MV_DOWN;
9881 if (IN_SCR_FIELD(SCREENX(ax), SCREENY(ay+1)))
9882 DrawGraphic(SCREENX(ax), SCREENY(ay + 1),
9883 IMG_EXPANDABLE_STEELWALL_GROWING_DOWN, 0);
9888 if (element == EL_EXPANDABLE_STEELWALL_HORIZONTAL ||
9889 element == EL_EXPANDABLE_STEELWALL_ANY)
9893 Tile[ax-1][ay] = EL_EXPANDABLE_STEELWALL_GROWING;
9894 Store[ax-1][ay] = element;
9895 GfxDir[ax-1][ay] = MovDir[ax-1][ay] = MV_LEFT;
9896 if (IN_SCR_FIELD(SCREENX(ax-1), SCREENY(ay)))
9897 DrawGraphic(SCREENX(ax - 1), SCREENY(ay),
9898 IMG_EXPANDABLE_STEELWALL_GROWING_LEFT, 0);
9904 Tile[ax+1][ay] = EL_EXPANDABLE_STEELWALL_GROWING;
9905 Store[ax+1][ay] = element;
9906 GfxDir[ax+1][ay] = MovDir[ax+1][ay] = MV_RIGHT;
9907 if (IN_SCR_FIELD(SCREENX(ax+1), SCREENY(ay)))
9908 DrawGraphic(SCREENX(ax + 1), SCREENY(ay),
9909 IMG_EXPANDABLE_STEELWALL_GROWING_RIGHT, 0);
9914 if (!IN_LEV_FIELD(ax, ay-1) || IS_WALL(Tile[ax][ay-1]))
9916 if (!IN_LEV_FIELD(ax, ay+1) || IS_WALL(Tile[ax][ay+1]))
9917 unten_massiv = TRUE;
9918 if (!IN_LEV_FIELD(ax-1, ay) || IS_WALL(Tile[ax-1][ay]))
9919 links_massiv = TRUE;
9920 if (!IN_LEV_FIELD(ax+1, ay) || IS_WALL(Tile[ax+1][ay]))
9921 rechts_massiv = TRUE;
9923 if (((oben_massiv && unten_massiv) ||
9924 element == EL_EXPANDABLE_STEELWALL_HORIZONTAL) &&
9925 ((links_massiv && rechts_massiv) ||
9926 element == EL_EXPANDABLE_STEELWALL_VERTICAL))
9927 Tile[ax][ay] = EL_STEELWALL;
9930 PlayLevelSoundAction(ax, ay, ACTION_GROWING);
9933 static void CheckForDragon(int x, int y)
9936 boolean dragon_found = FALSE;
9937 static int xy[4][2] =
9945 for (i = 0; i < NUM_DIRECTIONS; i++)
9947 for (j = 0; j < 4; j++)
9949 int xx = x + j * xy[i][0], yy = y + j * xy[i][1];
9951 if (IN_LEV_FIELD(xx, yy) &&
9952 (Tile[xx][yy] == EL_FLAMES || Tile[xx][yy] == EL_DRAGON))
9954 if (Tile[xx][yy] == EL_DRAGON)
9955 dragon_found = TRUE;
9964 for (i = 0; i < NUM_DIRECTIONS; i++)
9966 for (j = 0; j < 3; j++)
9968 int xx = x + j * xy[i][0], yy = y + j * xy[i][1];
9970 if (IN_LEV_FIELD(xx, yy) && Tile[xx][yy] == EL_FLAMES)
9972 Tile[xx][yy] = EL_EMPTY;
9973 TEST_DrawLevelField(xx, yy);
9982 static void InitBuggyBase(int x, int y)
9984 int element = Tile[x][y];
9985 int activating_delay = FRAMES_PER_SECOND / 4;
9988 (element == EL_SP_BUGGY_BASE ?
9989 2 * FRAMES_PER_SECOND + RND(5 * FRAMES_PER_SECOND) - activating_delay :
9990 element == EL_SP_BUGGY_BASE_ACTIVATING ?
9992 element == EL_SP_BUGGY_BASE_ACTIVE ?
9993 1 * FRAMES_PER_SECOND + RND(1 * FRAMES_PER_SECOND) : 1);
9996 static void WarnBuggyBase(int x, int y)
9999 static int xy[4][2] =
10007 for (i = 0; i < NUM_DIRECTIONS; i++)
10009 int xx = x + xy[i][0];
10010 int yy = y + xy[i][1];
10012 if (IN_LEV_FIELD(xx, yy) && IS_PLAYER(xx, yy))
10014 PlayLevelSound(x, y, SND_SP_BUGGY_BASE_ACTIVE);
10021 static void InitTrap(int x, int y)
10023 ChangeDelay[x][y] = 2 * FRAMES_PER_SECOND + RND(5 * FRAMES_PER_SECOND);
10026 static void ActivateTrap(int x, int y)
10028 PlayLevelSound(x, y, SND_TRAP_ACTIVATING);
10031 static void ChangeActiveTrap(int x, int y)
10033 int graphic = IMG_TRAP_ACTIVE;
10035 // if new animation frame was drawn, correct crumbled sand border
10036 if (IS_NEW_FRAME(GfxFrame[x][y], graphic))
10037 TEST_DrawLevelFieldCrumbled(x, y);
10040 static int getSpecialActionElement(int element, int number, int base_element)
10042 return (element != EL_EMPTY ? element :
10043 number != -1 ? base_element + number - 1 :
10047 static int getModifiedActionNumber(int value_old, int operator, int operand,
10048 int value_min, int value_max)
10050 int value_new = (operator == CA_MODE_SET ? operand :
10051 operator == CA_MODE_ADD ? value_old + operand :
10052 operator == CA_MODE_SUBTRACT ? value_old - operand :
10053 operator == CA_MODE_MULTIPLY ? value_old * operand :
10054 operator == CA_MODE_DIVIDE ? value_old / MAX(1, operand) :
10055 operator == CA_MODE_MODULO ? value_old % MAX(1, operand) :
10058 return (value_new < value_min ? value_min :
10059 value_new > value_max ? value_max :
10063 static void ExecuteCustomElementAction(int x, int y, int element, int page)
10065 struct ElementInfo *ei = &element_info[element];
10066 struct ElementChangeInfo *change = &ei->change_page[page];
10067 int target_element = change->target_element;
10068 int action_type = change->action_type;
10069 int action_mode = change->action_mode;
10070 int action_arg = change->action_arg;
10071 int action_element = change->action_element;
10074 if (!change->has_action)
10077 // ---------- determine action paramater values -----------------------------
10079 int level_time_value =
10080 (level.time > 0 ? TimeLeft :
10083 int action_arg_element_raw =
10084 (action_arg == CA_ARG_PLAYER_TRIGGER ? change->actual_trigger_player :
10085 action_arg == CA_ARG_ELEMENT_TRIGGER ? change->actual_trigger_element :
10086 action_arg == CA_ARG_ELEMENT_TARGET ? change->target_element :
10087 action_arg == CA_ARG_ELEMENT_ACTION ? change->action_element :
10088 action_arg == CA_ARG_INVENTORY_RM_TRIGGER ? change->actual_trigger_element:
10089 action_arg == CA_ARG_INVENTORY_RM_TARGET ? change->target_element :
10090 action_arg == CA_ARG_INVENTORY_RM_ACTION ? change->action_element :
10092 int action_arg_element = GetElementFromGroupElement(action_arg_element_raw);
10094 int action_arg_direction =
10095 (action_arg >= CA_ARG_DIRECTION_LEFT &&
10096 action_arg <= CA_ARG_DIRECTION_DOWN ? action_arg - CA_ARG_DIRECTION :
10097 action_arg == CA_ARG_DIRECTION_TRIGGER ?
10098 change->actual_trigger_side :
10099 action_arg == CA_ARG_DIRECTION_TRIGGER_BACK ?
10100 MV_DIR_OPPOSITE(change->actual_trigger_side) :
10103 int action_arg_number_min =
10104 (action_type == CA_SET_PLAYER_SPEED ? STEPSIZE_NOT_MOVING :
10107 int action_arg_number_max =
10108 (action_type == CA_SET_PLAYER_SPEED ? STEPSIZE_EVEN_FASTER :
10109 action_type == CA_SET_LEVEL_GEMS ? 999 :
10110 action_type == CA_SET_LEVEL_TIME ? 9999 :
10111 action_type == CA_SET_LEVEL_SCORE ? 99999 :
10112 action_type == CA_SET_CE_VALUE ? 9999 :
10113 action_type == CA_SET_CE_SCORE ? 9999 :
10116 int action_arg_number_reset =
10117 (action_type == CA_SET_PLAYER_SPEED ? level.initial_player_stepsize[0] :
10118 action_type == CA_SET_LEVEL_GEMS ? level.gems_needed :
10119 action_type == CA_SET_LEVEL_TIME ? level.time :
10120 action_type == CA_SET_LEVEL_SCORE ? 0 :
10121 action_type == CA_SET_CE_VALUE ? GET_NEW_CE_VALUE(element) :
10122 action_type == CA_SET_CE_SCORE ? 0 :
10125 int action_arg_number =
10126 (action_arg <= CA_ARG_MAX ? action_arg :
10127 action_arg >= CA_ARG_SPEED_NOT_MOVING &&
10128 action_arg <= CA_ARG_SPEED_EVEN_FASTER ? (action_arg - CA_ARG_SPEED) :
10129 action_arg == CA_ARG_SPEED_RESET ? action_arg_number_reset :
10130 action_arg == CA_ARG_NUMBER_MIN ? action_arg_number_min :
10131 action_arg == CA_ARG_NUMBER_MAX ? action_arg_number_max :
10132 action_arg == CA_ARG_NUMBER_RESET ? action_arg_number_reset :
10133 action_arg == CA_ARG_NUMBER_CE_VALUE ? CustomValue[x][y] :
10134 action_arg == CA_ARG_NUMBER_CE_SCORE ? ei->collect_score :
10135 action_arg == CA_ARG_NUMBER_CE_DELAY ? GET_CE_DELAY_VALUE(change) :
10136 action_arg == CA_ARG_NUMBER_LEVEL_TIME ? level_time_value :
10137 action_arg == CA_ARG_NUMBER_LEVEL_GEMS ? game.gems_still_needed :
10138 action_arg == CA_ARG_NUMBER_LEVEL_SCORE ? game.score :
10139 action_arg == CA_ARG_ELEMENT_CV_TARGET ? GET_NEW_CE_VALUE(target_element):
10140 action_arg == CA_ARG_ELEMENT_CV_TRIGGER ? change->actual_trigger_ce_value:
10141 action_arg == CA_ARG_ELEMENT_CV_ACTION ? GET_NEW_CE_VALUE(action_element):
10142 action_arg == CA_ARG_ELEMENT_CS_TARGET ? GET_CE_SCORE(target_element) :
10143 action_arg == CA_ARG_ELEMENT_CS_TRIGGER ? change->actual_trigger_ce_score:
10144 action_arg == CA_ARG_ELEMENT_CS_ACTION ? GET_CE_SCORE(action_element) :
10145 action_arg == CA_ARG_ELEMENT_NR_TARGET ? change->target_element :
10146 action_arg == CA_ARG_ELEMENT_NR_TRIGGER ? change->actual_trigger_element :
10147 action_arg == CA_ARG_ELEMENT_NR_ACTION ? change->action_element :
10150 int action_arg_number_old =
10151 (action_type == CA_SET_LEVEL_GEMS ? game.gems_still_needed :
10152 action_type == CA_SET_LEVEL_TIME ? TimeLeft :
10153 action_type == CA_SET_LEVEL_SCORE ? game.score :
10154 action_type == CA_SET_CE_VALUE ? CustomValue[x][y] :
10155 action_type == CA_SET_CE_SCORE ? ei->collect_score :
10158 int action_arg_number_new =
10159 getModifiedActionNumber(action_arg_number_old,
10160 action_mode, action_arg_number,
10161 action_arg_number_min, action_arg_number_max);
10163 int trigger_player_bits =
10164 (change->actual_trigger_player_bits != CH_PLAYER_NONE ?
10165 change->actual_trigger_player_bits : change->trigger_player);
10167 int action_arg_player_bits =
10168 (action_arg >= CA_ARG_PLAYER_1 &&
10169 action_arg <= CA_ARG_PLAYER_4 ? action_arg - CA_ARG_PLAYER :
10170 action_arg == CA_ARG_PLAYER_TRIGGER ? trigger_player_bits :
10171 action_arg == CA_ARG_PLAYER_ACTION ? 1 << GET_PLAYER_NR(action_element) :
10174 // ---------- execute action -----------------------------------------------
10176 switch (action_type)
10183 // ---------- level actions ----------------------------------------------
10185 case CA_RESTART_LEVEL:
10187 game.restart_level = TRUE;
10192 case CA_SHOW_ENVELOPE:
10194 int element = getSpecialActionElement(action_arg_element,
10195 action_arg_number, EL_ENVELOPE_1);
10197 if (IS_ENVELOPE(element))
10198 local_player->show_envelope = element;
10203 case CA_SET_LEVEL_TIME:
10205 if (level.time > 0) // only modify limited time value
10207 TimeLeft = action_arg_number_new;
10209 game_panel_controls[GAME_PANEL_TIME].value = TimeLeft;
10211 DisplayGameControlValues();
10213 if (!TimeLeft && setup.time_limit)
10214 for (i = 0; i < MAX_PLAYERS; i++)
10215 KillPlayer(&stored_player[i]);
10221 case CA_SET_LEVEL_SCORE:
10223 game.score = action_arg_number_new;
10225 game_panel_controls[GAME_PANEL_SCORE].value = game.score;
10227 DisplayGameControlValues();
10232 case CA_SET_LEVEL_GEMS:
10234 game.gems_still_needed = action_arg_number_new;
10236 game.snapshot.collected_item = TRUE;
10238 game_panel_controls[GAME_PANEL_GEMS].value = game.gems_still_needed;
10240 DisplayGameControlValues();
10245 case CA_SET_LEVEL_WIND:
10247 game.wind_direction = action_arg_direction;
10252 case CA_SET_LEVEL_RANDOM_SEED:
10254 // ensure that setting a new random seed while playing is predictable
10255 InitRND(action_arg_number_new ? action_arg_number_new : RND(1000000) + 1);
10260 // ---------- player actions ---------------------------------------------
10262 case CA_MOVE_PLAYER:
10263 case CA_MOVE_PLAYER_NEW:
10265 // automatically move to the next field in specified direction
10266 for (i = 0; i < MAX_PLAYERS; i++)
10267 if (trigger_player_bits & (1 << i))
10268 if (action_type == CA_MOVE_PLAYER ||
10269 stored_player[i].MovPos == 0)
10270 stored_player[i].programmed_action = action_arg_direction;
10275 case CA_EXIT_PLAYER:
10277 for (i = 0; i < MAX_PLAYERS; i++)
10278 if (action_arg_player_bits & (1 << i))
10279 ExitPlayer(&stored_player[i]);
10281 if (game.players_still_needed == 0)
10287 case CA_KILL_PLAYER:
10289 for (i = 0; i < MAX_PLAYERS; i++)
10290 if (action_arg_player_bits & (1 << i))
10291 KillPlayer(&stored_player[i]);
10296 case CA_SET_PLAYER_KEYS:
10298 int key_state = (action_mode == CA_MODE_ADD ? TRUE : FALSE);
10299 int element = getSpecialActionElement(action_arg_element,
10300 action_arg_number, EL_KEY_1);
10302 if (IS_KEY(element))
10304 for (i = 0; i < MAX_PLAYERS; i++)
10306 if (trigger_player_bits & (1 << i))
10308 stored_player[i].key[KEY_NR(element)] = key_state;
10310 DrawGameDoorValues();
10318 case CA_SET_PLAYER_SPEED:
10320 for (i = 0; i < MAX_PLAYERS; i++)
10322 if (trigger_player_bits & (1 << i))
10324 int move_stepsize = TILEX / stored_player[i].move_delay_value;
10326 if (action_arg == CA_ARG_SPEED_FASTER &&
10327 stored_player[i].cannot_move)
10329 action_arg_number = STEPSIZE_VERY_SLOW;
10331 else if (action_arg == CA_ARG_SPEED_SLOWER ||
10332 action_arg == CA_ARG_SPEED_FASTER)
10334 action_arg_number = 2;
10335 action_mode = (action_arg == CA_ARG_SPEED_SLOWER ? CA_MODE_DIVIDE :
10338 else if (action_arg == CA_ARG_NUMBER_RESET)
10340 action_arg_number = level.initial_player_stepsize[i];
10344 getModifiedActionNumber(move_stepsize,
10347 action_arg_number_min,
10348 action_arg_number_max);
10350 SetPlayerMoveSpeed(&stored_player[i], move_stepsize, FALSE);
10357 case CA_SET_PLAYER_SHIELD:
10359 for (i = 0; i < MAX_PLAYERS; i++)
10361 if (trigger_player_bits & (1 << i))
10363 if (action_arg == CA_ARG_SHIELD_OFF)
10365 stored_player[i].shield_normal_time_left = 0;
10366 stored_player[i].shield_deadly_time_left = 0;
10368 else if (action_arg == CA_ARG_SHIELD_NORMAL)
10370 stored_player[i].shield_normal_time_left = 999999;
10372 else if (action_arg == CA_ARG_SHIELD_DEADLY)
10374 stored_player[i].shield_normal_time_left = 999999;
10375 stored_player[i].shield_deadly_time_left = 999999;
10383 case CA_SET_PLAYER_GRAVITY:
10385 for (i = 0; i < MAX_PLAYERS; i++)
10387 if (trigger_player_bits & (1 << i))
10389 stored_player[i].gravity =
10390 (action_arg == CA_ARG_GRAVITY_OFF ? FALSE :
10391 action_arg == CA_ARG_GRAVITY_ON ? TRUE :
10392 action_arg == CA_ARG_GRAVITY_TOGGLE ? !stored_player[i].gravity :
10393 stored_player[i].gravity);
10400 case CA_SET_PLAYER_ARTWORK:
10402 for (i = 0; i < MAX_PLAYERS; i++)
10404 if (trigger_player_bits & (1 << i))
10406 int artwork_element = action_arg_element;
10408 if (action_arg == CA_ARG_ELEMENT_RESET)
10410 (level.use_artwork_element[i] ? level.artwork_element[i] :
10411 stored_player[i].element_nr);
10413 if (stored_player[i].artwork_element != artwork_element)
10414 stored_player[i].Frame = 0;
10416 stored_player[i].artwork_element = artwork_element;
10418 SetPlayerWaiting(&stored_player[i], FALSE);
10420 // set number of special actions for bored and sleeping animation
10421 stored_player[i].num_special_action_bored =
10422 get_num_special_action(artwork_element,
10423 ACTION_BORING_1, ACTION_BORING_LAST);
10424 stored_player[i].num_special_action_sleeping =
10425 get_num_special_action(artwork_element,
10426 ACTION_SLEEPING_1, ACTION_SLEEPING_LAST);
10433 case CA_SET_PLAYER_INVENTORY:
10435 for (i = 0; i < MAX_PLAYERS; i++)
10437 struct PlayerInfo *player = &stored_player[i];
10440 if (trigger_player_bits & (1 << i))
10442 int inventory_element = action_arg_element;
10444 if (action_arg == CA_ARG_ELEMENT_TARGET ||
10445 action_arg == CA_ARG_ELEMENT_TRIGGER ||
10446 action_arg == CA_ARG_ELEMENT_ACTION)
10448 int element = inventory_element;
10449 int collect_count = element_info[element].collect_count_initial;
10451 if (!IS_CUSTOM_ELEMENT(element))
10454 if (collect_count == 0)
10455 player->inventory_infinite_element = element;
10457 for (k = 0; k < collect_count; k++)
10458 if (player->inventory_size < MAX_INVENTORY_SIZE)
10459 player->inventory_element[player->inventory_size++] =
10462 else if (action_arg == CA_ARG_INVENTORY_RM_TARGET ||
10463 action_arg == CA_ARG_INVENTORY_RM_TRIGGER ||
10464 action_arg == CA_ARG_INVENTORY_RM_ACTION)
10466 if (player->inventory_infinite_element != EL_UNDEFINED &&
10467 IS_EQUAL_OR_IN_GROUP(player->inventory_infinite_element,
10468 action_arg_element_raw))
10469 player->inventory_infinite_element = EL_UNDEFINED;
10471 for (k = 0, j = 0; j < player->inventory_size; j++)
10473 if (!IS_EQUAL_OR_IN_GROUP(player->inventory_element[j],
10474 action_arg_element_raw))
10475 player->inventory_element[k++] = player->inventory_element[j];
10478 player->inventory_size = k;
10480 else if (action_arg == CA_ARG_INVENTORY_RM_FIRST)
10482 if (player->inventory_size > 0)
10484 for (j = 0; j < player->inventory_size - 1; j++)
10485 player->inventory_element[j] = player->inventory_element[j + 1];
10487 player->inventory_size--;
10490 else if (action_arg == CA_ARG_INVENTORY_RM_LAST)
10492 if (player->inventory_size > 0)
10493 player->inventory_size--;
10495 else if (action_arg == CA_ARG_INVENTORY_RM_ALL)
10497 player->inventory_infinite_element = EL_UNDEFINED;
10498 player->inventory_size = 0;
10500 else if (action_arg == CA_ARG_INVENTORY_RESET)
10502 player->inventory_infinite_element = EL_UNDEFINED;
10503 player->inventory_size = 0;
10505 if (level.use_initial_inventory[i])
10507 for (j = 0; j < level.initial_inventory_size[i]; j++)
10509 int element = level.initial_inventory_content[i][j];
10510 int collect_count = element_info[element].collect_count_initial;
10512 if (!IS_CUSTOM_ELEMENT(element))
10515 if (collect_count == 0)
10516 player->inventory_infinite_element = element;
10518 for (k = 0; k < collect_count; k++)
10519 if (player->inventory_size < MAX_INVENTORY_SIZE)
10520 player->inventory_element[player->inventory_size++] =
10531 // ---------- CE actions -------------------------------------------------
10533 case CA_SET_CE_VALUE:
10535 int last_ce_value = CustomValue[x][y];
10537 CustomValue[x][y] = action_arg_number_new;
10539 if (CustomValue[x][y] != last_ce_value)
10541 CheckElementChange(x, y, element, EL_UNDEFINED, CE_VALUE_CHANGES);
10542 CheckTriggeredElementChange(x, y, element, CE_VALUE_CHANGES_OF_X);
10544 if (CustomValue[x][y] == 0)
10546 // reset change counter (else CE_VALUE_GETS_ZERO would not work)
10547 ChangeCount[x][y] = 0; // allow at least one more change
10549 CheckElementChange(x, y, element, EL_UNDEFINED, CE_VALUE_GETS_ZERO);
10550 CheckTriggeredElementChange(x, y, element, CE_VALUE_GETS_ZERO_OF_X);
10557 case CA_SET_CE_SCORE:
10559 int last_ce_score = ei->collect_score;
10561 ei->collect_score = action_arg_number_new;
10563 if (ei->collect_score != last_ce_score)
10565 CheckElementChange(x, y, element, EL_UNDEFINED, CE_SCORE_CHANGES);
10566 CheckTriggeredElementChange(x, y, element, CE_SCORE_CHANGES_OF_X);
10568 if (ei->collect_score == 0)
10572 // reset change counter (else CE_SCORE_GETS_ZERO would not work)
10573 ChangeCount[x][y] = 0; // allow at least one more change
10575 CheckElementChange(x, y, element, EL_UNDEFINED, CE_SCORE_GETS_ZERO);
10576 CheckTriggeredElementChange(x, y, element, CE_SCORE_GETS_ZERO_OF_X);
10579 This is a very special case that seems to be a mixture between
10580 CheckElementChange() and CheckTriggeredElementChange(): while
10581 the first one only affects single elements that are triggered
10582 directly, the second one affects multiple elements in the playfield
10583 that are triggered indirectly by another element. This is a third
10584 case: Changing the CE score always affects multiple identical CEs,
10585 so every affected CE must be checked, not only the single CE for
10586 which the CE score was changed in the first place (as every instance
10587 of that CE shares the same CE score, and therefore also can change)!
10589 SCAN_PLAYFIELD(xx, yy)
10591 if (Tile[xx][yy] == element)
10592 CheckElementChange(xx, yy, element, EL_UNDEFINED,
10593 CE_SCORE_GETS_ZERO);
10601 case CA_SET_CE_ARTWORK:
10603 int artwork_element = action_arg_element;
10604 boolean reset_frame = FALSE;
10607 if (action_arg == CA_ARG_ELEMENT_RESET)
10608 artwork_element = (ei->use_gfx_element ? ei->gfx_element_initial :
10611 if (ei->gfx_element != artwork_element)
10612 reset_frame = TRUE;
10614 ei->gfx_element = artwork_element;
10616 SCAN_PLAYFIELD(xx, yy)
10618 if (Tile[xx][yy] == element)
10622 ResetGfxAnimation(xx, yy);
10623 ResetRandomAnimationValue(xx, yy);
10626 TEST_DrawLevelField(xx, yy);
10633 // ---------- engine actions ---------------------------------------------
10635 case CA_SET_ENGINE_SCAN_MODE:
10637 InitPlayfieldScanMode(action_arg);
10647 static void CreateFieldExt(int x, int y, int element, boolean is_change)
10649 int old_element = Tile[x][y];
10650 int new_element = GetElementFromGroupElement(element);
10651 int previous_move_direction = MovDir[x][y];
10652 int last_ce_value = CustomValue[x][y];
10653 boolean player_explosion_protected = PLAYER_EXPLOSION_PROTECTED(x, y);
10654 boolean new_element_is_player = IS_PLAYER_ELEMENT(new_element);
10655 boolean add_player_onto_element = (new_element_is_player &&
10656 new_element != EL_SOKOBAN_FIELD_PLAYER &&
10657 IS_WALKABLE(old_element));
10659 if (!add_player_onto_element)
10661 if (IS_MOVING(x, y) || IS_BLOCKED(x, y))
10662 RemoveMovingField(x, y);
10666 Tile[x][y] = new_element;
10668 if (element_info[new_element].move_direction_initial == MV_START_PREVIOUS)
10669 MovDir[x][y] = previous_move_direction;
10671 if (element_info[new_element].use_last_ce_value)
10672 CustomValue[x][y] = last_ce_value;
10674 InitField_WithBug1(x, y, FALSE);
10676 new_element = Tile[x][y]; // element may have changed
10678 ResetGfxAnimation(x, y);
10679 ResetRandomAnimationValue(x, y);
10681 TEST_DrawLevelField(x, y);
10683 if (GFX_CRUMBLED(new_element))
10684 TEST_DrawLevelFieldCrumbledNeighbours(x, y);
10687 // check if element under the player changes from accessible to unaccessible
10688 // (needed for special case of dropping element which then changes)
10689 // (must be checked after creating new element for walkable group elements)
10690 if (IS_PLAYER(x, y) && !player_explosion_protected &&
10691 IS_ACCESSIBLE(old_element) && !IS_ACCESSIBLE(new_element))
10698 // "ChangeCount" not set yet to allow "entered by player" change one time
10699 if (new_element_is_player)
10700 RelocatePlayer(x, y, new_element);
10703 ChangeCount[x][y]++; // count number of changes in the same frame
10705 TestIfBadThingTouchesPlayer(x, y);
10706 TestIfPlayerTouchesCustomElement(x, y);
10707 TestIfElementTouchesCustomElement(x, y);
10710 static void CreateField(int x, int y, int element)
10712 CreateFieldExt(x, y, element, FALSE);
10715 static void CreateElementFromChange(int x, int y, int element)
10717 element = GET_VALID_RUNTIME_ELEMENT(element);
10719 if (game.engine_version >= VERSION_IDENT(3,2,0,7))
10721 int old_element = Tile[x][y];
10723 // prevent changed element from moving in same engine frame
10724 // unless both old and new element can either fall or move
10725 if ((!CAN_FALL(old_element) || !CAN_FALL(element)) &&
10726 (!CAN_MOVE(old_element) || !CAN_MOVE(element)))
10730 CreateFieldExt(x, y, element, TRUE);
10733 static boolean ChangeElement(int x, int y, int element, int page)
10735 struct ElementInfo *ei = &element_info[element];
10736 struct ElementChangeInfo *change = &ei->change_page[page];
10737 int ce_value = CustomValue[x][y];
10738 int ce_score = ei->collect_score;
10739 int target_element;
10740 int old_element = Tile[x][y];
10742 // always use default change event to prevent running into a loop
10743 if (ChangeEvent[x][y] == -1)
10744 ChangeEvent[x][y] = CE_DELAY;
10746 if (ChangeEvent[x][y] == CE_DELAY)
10748 // reset actual trigger element, trigger player and action element
10749 change->actual_trigger_element = EL_EMPTY;
10750 change->actual_trigger_player = EL_EMPTY;
10751 change->actual_trigger_player_bits = CH_PLAYER_NONE;
10752 change->actual_trigger_side = CH_SIDE_NONE;
10753 change->actual_trigger_ce_value = 0;
10754 change->actual_trigger_ce_score = 0;
10757 // do not change elements more than a specified maximum number of changes
10758 if (ChangeCount[x][y] >= game.max_num_changes_per_frame)
10761 ChangeCount[x][y]++; // count number of changes in the same frame
10763 if (change->explode)
10770 if (change->use_target_content)
10772 boolean complete_replace = TRUE;
10773 boolean can_replace[3][3];
10776 for (yy = 0; yy < 3; yy++) for (xx = 0; xx < 3 ; xx++)
10779 boolean is_walkable;
10780 boolean is_diggable;
10781 boolean is_collectible;
10782 boolean is_removable;
10783 boolean is_destructible;
10784 int ex = x + xx - 1;
10785 int ey = y + yy - 1;
10786 int content_element = change->target_content.e[xx][yy];
10789 can_replace[xx][yy] = TRUE;
10791 if (ex == x && ey == y) // do not check changing element itself
10794 if (content_element == EL_EMPTY_SPACE)
10796 can_replace[xx][yy] = FALSE; // do not replace border with space
10801 if (!IN_LEV_FIELD(ex, ey))
10803 can_replace[xx][yy] = FALSE;
10804 complete_replace = FALSE;
10811 if (IS_MOVING(ex, ey) || IS_BLOCKED(ex, ey))
10812 e = MovingOrBlocked2Element(ex, ey);
10814 is_empty = (IS_FREE(ex, ey) ||
10815 (IS_FREE_OR_PLAYER(ex, ey) && IS_WALKABLE(content_element)));
10817 is_walkable = (is_empty || IS_WALKABLE(e));
10818 is_diggable = (is_empty || IS_DIGGABLE(e));
10819 is_collectible = (is_empty || IS_COLLECTIBLE(e));
10820 is_destructible = (is_empty || !IS_INDESTRUCTIBLE(e));
10821 is_removable = (is_diggable || is_collectible);
10823 can_replace[xx][yy] =
10824 (((change->replace_when == CP_WHEN_EMPTY && is_empty) ||
10825 (change->replace_when == CP_WHEN_WALKABLE && is_walkable) ||
10826 (change->replace_when == CP_WHEN_DIGGABLE && is_diggable) ||
10827 (change->replace_when == CP_WHEN_COLLECTIBLE && is_collectible) ||
10828 (change->replace_when == CP_WHEN_REMOVABLE && is_removable) ||
10829 (change->replace_when == CP_WHEN_DESTRUCTIBLE && is_destructible)) &&
10830 !(IS_PLAYER(ex, ey) && IS_PLAYER_ELEMENT(content_element)));
10832 if (!can_replace[xx][yy])
10833 complete_replace = FALSE;
10836 if (!change->only_if_complete || complete_replace)
10838 boolean something_has_changed = FALSE;
10840 if (change->only_if_complete && change->use_random_replace &&
10841 RND(100) < change->random_percentage)
10844 for (yy = 0; yy < 3; yy++) for (xx = 0; xx < 3 ; xx++)
10846 int ex = x + xx - 1;
10847 int ey = y + yy - 1;
10848 int content_element;
10850 if (can_replace[xx][yy] && (!change->use_random_replace ||
10851 RND(100) < change->random_percentage))
10853 if (IS_MOVING(ex, ey) || IS_BLOCKED(ex, ey))
10854 RemoveMovingField(ex, ey);
10856 ChangeEvent[ex][ey] = ChangeEvent[x][y];
10858 content_element = change->target_content.e[xx][yy];
10859 target_element = GET_TARGET_ELEMENT(element, content_element, change,
10860 ce_value, ce_score);
10862 CreateElementFromChange(ex, ey, target_element);
10864 something_has_changed = TRUE;
10866 // for symmetry reasons, freeze newly created border elements
10867 if (ex != x || ey != y)
10868 Stop[ex][ey] = TRUE; // no more moving in this frame
10872 if (something_has_changed)
10874 PlayLevelSoundElementAction(x, y, element, ACTION_CHANGING);
10875 PlayLevelSoundElementAction(x, y, element, ACTION_PAGE_1 + page);
10881 target_element = GET_TARGET_ELEMENT(element, change->target_element, change,
10882 ce_value, ce_score);
10884 if (element == EL_DIAGONAL_GROWING ||
10885 element == EL_DIAGONAL_SHRINKING)
10887 target_element = Store[x][y];
10889 Store[x][y] = EL_EMPTY;
10892 // special case: element changes to player (and may be kept if walkable)
10893 if (IS_PLAYER_ELEMENT(target_element) && !level.keep_walkable_ce)
10894 CreateElementFromChange(x, y, EL_EMPTY);
10896 CreateElementFromChange(x, y, target_element);
10898 PlayLevelSoundElementAction(x, y, element, ACTION_CHANGING);
10899 PlayLevelSoundElementAction(x, y, element, ACTION_PAGE_1 + page);
10902 // this uses direct change before indirect change
10903 CheckTriggeredElementChangeByPage(x, y, old_element, CE_CHANGE_OF_X, page);
10908 static void HandleElementChange(int x, int y, int page)
10910 int element = MovingOrBlocked2Element(x, y);
10911 struct ElementInfo *ei = &element_info[element];
10912 struct ElementChangeInfo *change = &ei->change_page[page];
10913 boolean handle_action_before_change = FALSE;
10916 if (!CAN_CHANGE_OR_HAS_ACTION(element) &&
10917 !CAN_CHANGE_OR_HAS_ACTION(Back[x][y]))
10919 Debug("game:playing:HandleElementChange", "%d,%d: element = %d ('%s')",
10920 x, y, element, element_info[element].token_name);
10921 Debug("game:playing:HandleElementChange", "This should never happen!");
10925 // this can happen with classic bombs on walkable, changing elements
10926 if (!CAN_CHANGE_OR_HAS_ACTION(element))
10931 if (ChangeDelay[x][y] == 0) // initialize element change
10933 ChangeDelay[x][y] = GET_CHANGE_DELAY(change) + 1;
10935 if (change->can_change)
10937 // !!! not clear why graphic animation should be reset at all here !!!
10938 // !!! UPDATE: but is needed for correct Snake Bite tail animation !!!
10939 // !!! SOLUTION: do not reset if graphics engine set to 4 or above !!!
10942 GRAPHICAL BUG ADDRESSED BY CHECKING GRAPHICS ENGINE VERSION:
10944 When using an animation frame delay of 1 (this only happens with
10945 "sp_zonk.moving.left/right" in the classic graphics), the default
10946 (non-moving) animation shows wrong animation frames (while the
10947 moving animation, like "sp_zonk.moving.left/right", is correct,
10948 so this graphical bug never shows up with the classic graphics).
10949 For an animation with 4 frames, this causes wrong frames 0,0,1,2
10950 be drawn instead of the correct frames 0,1,2,3. This is caused by
10951 "GfxFrame[][]" being reset *twice* (in two successive frames) after
10952 an element change: First when the change delay ("ChangeDelay[][]")
10953 counter has reached zero after decrementing, then a second time in
10954 the next frame (after "GfxFrame[][]" was already incremented) when
10955 "ChangeDelay[][]" is reset to the initial delay value again.
10957 This causes frame 0 to be drawn twice, while the last frame won't
10958 be drawn anymore, resulting in the wrong frame sequence 0,0,1,2.
10960 As some animations may already be cleverly designed around this bug
10961 (at least the "Snake Bite" snake tail animation does this), it cannot
10962 simply be fixed here without breaking such existing animations.
10963 Unfortunately, it cannot easily be detected if a graphics set was
10964 designed "before" or "after" the bug was fixed. As a workaround,
10965 a new graphics set option "game.graphics_engine_version" was added
10966 to be able to specify the game's major release version for which the
10967 graphics set was designed, which can then be used to decide if the
10968 bugfix should be used (version 4 and above) or not (version 3 or
10969 below, or if no version was specified at all, as with old sets).
10971 (The wrong/fixed animation frames can be tested with the test level set
10972 "test_gfxframe" and level "000", which contains a specially prepared
10973 custom element at level position (x/y) == (11/9) which uses the zonk
10974 animation mentioned above. Using "game.graphics_engine_version: 4"
10975 fixes the wrong animation frames, showing the correct frames 0,1,2,3.
10976 This can also be seen from the debug output for this test element.)
10979 // when a custom element is about to change (for example by change delay),
10980 // do not reset graphic animation when the custom element is moving
10981 if (game.graphics_engine_version < 4 &&
10984 ResetGfxAnimation(x, y);
10985 ResetRandomAnimationValue(x, y);
10988 if (change->pre_change_function)
10989 change->pre_change_function(x, y);
10993 ChangeDelay[x][y]--;
10995 if (ChangeDelay[x][y] != 0) // continue element change
10997 if (change->can_change)
10999 int graphic = el_act_dir2img(element, GfxAction[x][y], GfxDir[x][y]);
11001 if (IS_ANIMATED(graphic))
11002 DrawLevelGraphicAnimationIfNeeded(x, y, graphic);
11004 if (change->change_function)
11005 change->change_function(x, y);
11008 else // finish element change
11010 if (ChangePage[x][y] != -1) // remember page from delayed change
11012 page = ChangePage[x][y];
11013 ChangePage[x][y] = -1;
11015 change = &ei->change_page[page];
11018 if (IS_MOVING(x, y)) // never change a running system ;-)
11020 ChangeDelay[x][y] = 1; // try change after next move step
11021 ChangePage[x][y] = page; // remember page to use for change
11026 // special case: set new level random seed before changing element
11027 if (change->has_action && change->action_type == CA_SET_LEVEL_RANDOM_SEED)
11028 handle_action_before_change = TRUE;
11030 if (change->has_action && handle_action_before_change)
11031 ExecuteCustomElementAction(x, y, element, page);
11033 if (change->can_change)
11035 if (ChangeElement(x, y, element, page))
11037 if (change->post_change_function)
11038 change->post_change_function(x, y);
11042 if (change->has_action && !handle_action_before_change)
11043 ExecuteCustomElementAction(x, y, element, page);
11047 static boolean CheckTriggeredElementChangeExt(int trigger_x, int trigger_y,
11048 int trigger_element,
11050 int trigger_player,
11054 boolean change_done_any = FALSE;
11055 int trigger_page_bits = (trigger_page < 0 ? CH_PAGE_ANY : 1 << trigger_page);
11058 if (!(trigger_events[trigger_element][trigger_event]))
11061 RECURSION_LOOP_DETECTION_START(trigger_element, FALSE);
11063 for (i = 0; i < NUM_CUSTOM_ELEMENTS; i++)
11065 int element = EL_CUSTOM_START + i;
11066 boolean change_done = FALSE;
11069 if (!CAN_CHANGE_OR_HAS_ACTION(element) ||
11070 !HAS_ANY_CHANGE_EVENT(element, trigger_event))
11073 for (p = 0; p < element_info[element].num_change_pages; p++)
11075 struct ElementChangeInfo *change = &element_info[element].change_page[p];
11077 if (change->can_change_or_has_action &&
11078 change->has_event[trigger_event] &&
11079 change->trigger_side & trigger_side &&
11080 change->trigger_player & trigger_player &&
11081 change->trigger_page & trigger_page_bits &&
11082 IS_EQUAL_OR_IN_GROUP(trigger_element, change->trigger_element))
11084 change->actual_trigger_element = trigger_element;
11085 change->actual_trigger_player = GET_PLAYER_FROM_BITS(trigger_player);
11086 change->actual_trigger_player_bits = trigger_player;
11087 change->actual_trigger_side = trigger_side;
11088 change->actual_trigger_ce_value = CustomValue[trigger_x][trigger_y];
11089 change->actual_trigger_ce_score = GET_CE_SCORE(trigger_element);
11091 if ((change->can_change && !change_done) || change->has_action)
11095 SCAN_PLAYFIELD(x, y)
11097 if (Tile[x][y] == element)
11099 if (change->can_change && !change_done)
11101 // if element already changed in this frame, not only prevent
11102 // another element change (checked in ChangeElement()), but
11103 // also prevent additional element actions for this element
11105 if (ChangeCount[x][y] >= game.max_num_changes_per_frame &&
11106 !level.use_action_after_change_bug)
11109 ChangeDelay[x][y] = 1;
11110 ChangeEvent[x][y] = trigger_event;
11112 HandleElementChange(x, y, p);
11114 else if (change->has_action)
11116 // if element already changed in this frame, not only prevent
11117 // another element change (checked in ChangeElement()), but
11118 // also prevent additional element actions for this element
11120 if (ChangeCount[x][y] >= game.max_num_changes_per_frame &&
11121 !level.use_action_after_change_bug)
11124 ExecuteCustomElementAction(x, y, element, p);
11125 PlayLevelSoundElementAction(x, y, element, ACTION_PAGE_1 + p);
11130 if (change->can_change)
11132 change_done = TRUE;
11133 change_done_any = TRUE;
11140 RECURSION_LOOP_DETECTION_END();
11142 return change_done_any;
11145 static boolean CheckElementChangeExt(int x, int y,
11147 int trigger_element,
11149 int trigger_player,
11152 boolean change_done = FALSE;
11155 if (!CAN_CHANGE_OR_HAS_ACTION(element) ||
11156 !HAS_ANY_CHANGE_EVENT(element, trigger_event))
11159 if (Tile[x][y] == EL_BLOCKED)
11161 Blocked2Moving(x, y, &x, &y);
11162 element = Tile[x][y];
11165 // check if element has already changed or is about to change after moving
11166 if ((game.engine_version < VERSION_IDENT(3,2,0,7) &&
11167 Tile[x][y] != element) ||
11169 (game.engine_version >= VERSION_IDENT(3,2,0,7) &&
11170 (ChangeCount[x][y] >= game.max_num_changes_per_frame ||
11171 ChangePage[x][y] != -1)))
11174 RECURSION_LOOP_DETECTION_START(trigger_element, FALSE);
11176 for (p = 0; p < element_info[element].num_change_pages; p++)
11178 struct ElementChangeInfo *change = &element_info[element].change_page[p];
11180 /* check trigger element for all events where the element that is checked
11181 for changing interacts with a directly adjacent element -- this is
11182 different to element changes that affect other elements to change on the
11183 whole playfield (which is handeld by CheckTriggeredElementChangeExt()) */
11184 boolean check_trigger_element =
11185 (trigger_event == CE_NEXT_TO_X ||
11186 trigger_event == CE_TOUCHING_X ||
11187 trigger_event == CE_HITTING_X ||
11188 trigger_event == CE_HIT_BY_X ||
11189 trigger_event == CE_DIGGING_X); // this one was forgotten until 3.2.3
11191 if (change->can_change_or_has_action &&
11192 change->has_event[trigger_event] &&
11193 change->trigger_side & trigger_side &&
11194 change->trigger_player & trigger_player &&
11195 (!check_trigger_element ||
11196 IS_EQUAL_OR_IN_GROUP(trigger_element, change->trigger_element)))
11198 change->actual_trigger_element = trigger_element;
11199 change->actual_trigger_player = GET_PLAYER_FROM_BITS(trigger_player);
11200 change->actual_trigger_player_bits = trigger_player;
11201 change->actual_trigger_side = trigger_side;
11202 change->actual_trigger_ce_value = CustomValue[x][y];
11203 change->actual_trigger_ce_score = GET_CE_SCORE(trigger_element);
11205 // special case: trigger element not at (x,y) position for some events
11206 if (check_trigger_element)
11218 { 0, 0 }, { 0, 0 }, { 0, 0 },
11222 int xx = x + move_xy[MV_DIR_OPPOSITE(trigger_side)].dx;
11223 int yy = y + move_xy[MV_DIR_OPPOSITE(trigger_side)].dy;
11225 change->actual_trigger_ce_value = CustomValue[xx][yy];
11226 change->actual_trigger_ce_score = GET_CE_SCORE(trigger_element);
11229 if (change->can_change && !change_done)
11231 ChangeDelay[x][y] = 1;
11232 ChangeEvent[x][y] = trigger_event;
11234 HandleElementChange(x, y, p);
11236 change_done = TRUE;
11238 else if (change->has_action)
11240 ExecuteCustomElementAction(x, y, element, p);
11241 PlayLevelSoundElementAction(x, y, element, ACTION_PAGE_1 + p);
11246 RECURSION_LOOP_DETECTION_END();
11248 return change_done;
11251 static void PlayPlayerSound(struct PlayerInfo *player)
11253 int jx = player->jx, jy = player->jy;
11254 int sound_element = player->artwork_element;
11255 int last_action = player->last_action_waiting;
11256 int action = player->action_waiting;
11258 if (player->is_waiting)
11260 if (action != last_action)
11261 PlayLevelSoundElementAction(jx, jy, sound_element, action);
11263 PlayLevelSoundElementActionIfLoop(jx, jy, sound_element, action);
11267 if (action != last_action)
11268 StopSound(element_info[sound_element].sound[last_action]);
11270 if (last_action == ACTION_SLEEPING)
11271 PlayLevelSoundElementAction(jx, jy, sound_element, ACTION_AWAKENING);
11275 static void PlayAllPlayersSound(void)
11279 for (i = 0; i < MAX_PLAYERS; i++)
11280 if (stored_player[i].active)
11281 PlayPlayerSound(&stored_player[i]);
11284 static void SetPlayerWaiting(struct PlayerInfo *player, boolean is_waiting)
11286 boolean last_waiting = player->is_waiting;
11287 int move_dir = player->MovDir;
11289 player->dir_waiting = move_dir;
11290 player->last_action_waiting = player->action_waiting;
11294 if (!last_waiting) // not waiting -> waiting
11296 player->is_waiting = TRUE;
11298 player->frame_counter_bored =
11300 game.player_boring_delay_fixed +
11301 GetSimpleRandom(game.player_boring_delay_random);
11302 player->frame_counter_sleeping =
11304 game.player_sleeping_delay_fixed +
11305 GetSimpleRandom(game.player_sleeping_delay_random);
11307 InitPlayerGfxAnimation(player, ACTION_WAITING, move_dir);
11310 if (game.player_sleeping_delay_fixed +
11311 game.player_sleeping_delay_random > 0 &&
11312 player->anim_delay_counter == 0 &&
11313 player->post_delay_counter == 0 &&
11314 FrameCounter >= player->frame_counter_sleeping)
11315 player->is_sleeping = TRUE;
11316 else if (game.player_boring_delay_fixed +
11317 game.player_boring_delay_random > 0 &&
11318 FrameCounter >= player->frame_counter_bored)
11319 player->is_bored = TRUE;
11321 player->action_waiting = (player->is_sleeping ? ACTION_SLEEPING :
11322 player->is_bored ? ACTION_BORING :
11325 if (player->is_sleeping && player->use_murphy)
11327 // special case for sleeping Murphy when leaning against non-free tile
11329 if (!IN_LEV_FIELD(player->jx - 1, player->jy) ||
11330 (Tile[player->jx - 1][player->jy] != EL_EMPTY &&
11331 !IS_MOVING(player->jx - 1, player->jy)))
11332 move_dir = MV_LEFT;
11333 else if (!IN_LEV_FIELD(player->jx + 1, player->jy) ||
11334 (Tile[player->jx + 1][player->jy] != EL_EMPTY &&
11335 !IS_MOVING(player->jx + 1, player->jy)))
11336 move_dir = MV_RIGHT;
11338 player->is_sleeping = FALSE;
11340 player->dir_waiting = move_dir;
11343 if (player->is_sleeping)
11345 if (player->num_special_action_sleeping > 0)
11347 if (player->anim_delay_counter == 0 && player->post_delay_counter == 0)
11349 int last_special_action = player->special_action_sleeping;
11350 int num_special_action = player->num_special_action_sleeping;
11351 int special_action =
11352 (last_special_action == ACTION_DEFAULT ? ACTION_SLEEPING_1 :
11353 last_special_action == ACTION_SLEEPING ? ACTION_SLEEPING :
11354 last_special_action < ACTION_SLEEPING_1 + num_special_action - 1 ?
11355 last_special_action + 1 : ACTION_SLEEPING);
11356 int special_graphic =
11357 el_act_dir2img(player->artwork_element, special_action, move_dir);
11359 player->anim_delay_counter =
11360 graphic_info[special_graphic].anim_delay_fixed +
11361 GetSimpleRandom(graphic_info[special_graphic].anim_delay_random);
11362 player->post_delay_counter =
11363 graphic_info[special_graphic].post_delay_fixed +
11364 GetSimpleRandom(graphic_info[special_graphic].post_delay_random);
11366 player->special_action_sleeping = special_action;
11369 if (player->anim_delay_counter > 0)
11371 player->action_waiting = player->special_action_sleeping;
11372 player->anim_delay_counter--;
11374 else if (player->post_delay_counter > 0)
11376 player->post_delay_counter--;
11380 else if (player->is_bored)
11382 if (player->num_special_action_bored > 0)
11384 if (player->anim_delay_counter == 0 && player->post_delay_counter == 0)
11386 int special_action =
11387 ACTION_BORING_1 + GetSimpleRandom(player->num_special_action_bored);
11388 int special_graphic =
11389 el_act_dir2img(player->artwork_element, special_action, move_dir);
11391 player->anim_delay_counter =
11392 graphic_info[special_graphic].anim_delay_fixed +
11393 GetSimpleRandom(graphic_info[special_graphic].anim_delay_random);
11394 player->post_delay_counter =
11395 graphic_info[special_graphic].post_delay_fixed +
11396 GetSimpleRandom(graphic_info[special_graphic].post_delay_random);
11398 player->special_action_bored = special_action;
11401 if (player->anim_delay_counter > 0)
11403 player->action_waiting = player->special_action_bored;
11404 player->anim_delay_counter--;
11406 else if (player->post_delay_counter > 0)
11408 player->post_delay_counter--;
11413 else if (last_waiting) // waiting -> not waiting
11415 player->is_waiting = FALSE;
11416 player->is_bored = FALSE;
11417 player->is_sleeping = FALSE;
11419 player->frame_counter_bored = -1;
11420 player->frame_counter_sleeping = -1;
11422 player->anim_delay_counter = 0;
11423 player->post_delay_counter = 0;
11425 player->dir_waiting = player->MovDir;
11426 player->action_waiting = ACTION_DEFAULT;
11428 player->special_action_bored = ACTION_DEFAULT;
11429 player->special_action_sleeping = ACTION_DEFAULT;
11433 static void CheckSaveEngineSnapshot(struct PlayerInfo *player)
11435 if ((!player->is_moving && player->was_moving) ||
11436 (player->MovPos == 0 && player->was_moving) ||
11437 (player->is_snapping && !player->was_snapping) ||
11438 (player->is_dropping && !player->was_dropping))
11440 if (!CheckSaveEngineSnapshotToList())
11443 player->was_moving = FALSE;
11444 player->was_snapping = TRUE;
11445 player->was_dropping = TRUE;
11449 if (player->is_moving)
11450 player->was_moving = TRUE;
11452 if (!player->is_snapping)
11453 player->was_snapping = FALSE;
11455 if (!player->is_dropping)
11456 player->was_dropping = FALSE;
11459 static struct MouseActionInfo mouse_action_last = { 0 };
11460 struct MouseActionInfo mouse_action = player->effective_mouse_action;
11461 boolean new_released = (!mouse_action.button && mouse_action_last.button);
11464 CheckSaveEngineSnapshotToList();
11466 mouse_action_last = mouse_action;
11469 static void CheckSingleStepMode(struct PlayerInfo *player)
11471 if (tape.single_step && tape.recording && !tape.pausing)
11473 // as it is called "single step mode", just return to pause mode when the
11474 // player stopped moving after one tile (or never starts moving at all)
11475 // (reverse logic needed here in case single step mode used in team mode)
11476 if (player->is_moving ||
11477 player->is_pushing ||
11478 player->is_dropping_pressed ||
11479 player->effective_mouse_action.button)
11480 game.enter_single_step_mode = FALSE;
11483 CheckSaveEngineSnapshot(player);
11486 static byte PlayerActions(struct PlayerInfo *player, byte player_action)
11488 int left = player_action & JOY_LEFT;
11489 int right = player_action & JOY_RIGHT;
11490 int up = player_action & JOY_UP;
11491 int down = player_action & JOY_DOWN;
11492 int button1 = player_action & JOY_BUTTON_1;
11493 int button2 = player_action & JOY_BUTTON_2;
11494 int dx = (left ? -1 : right ? 1 : 0);
11495 int dy = (up ? -1 : down ? 1 : 0);
11497 if (!player->active || tape.pausing)
11503 SnapField(player, dx, dy);
11507 DropElement(player);
11509 MovePlayer(player, dx, dy);
11512 CheckSingleStepMode(player);
11514 SetPlayerWaiting(player, FALSE);
11516 return player_action;
11520 // no actions for this player (no input at player's configured device)
11522 DigField(player, 0, 0, 0, 0, 0, 0, DF_NO_PUSH);
11523 SnapField(player, 0, 0);
11524 CheckGravityMovementWhenNotMoving(player);
11526 if (player->MovPos == 0)
11527 SetPlayerWaiting(player, TRUE);
11529 if (player->MovPos == 0) // needed for tape.playing
11530 player->is_moving = FALSE;
11532 player->is_dropping = FALSE;
11533 player->is_dropping_pressed = FALSE;
11534 player->drop_pressed_delay = 0;
11536 CheckSingleStepMode(player);
11542 static void SetMouseActionFromTapeAction(struct MouseActionInfo *mouse_action,
11545 if (!tape.use_mouse_actions)
11548 mouse_action->lx = tape_action[TAPE_ACTION_LX];
11549 mouse_action->ly = tape_action[TAPE_ACTION_LY];
11550 mouse_action->button = tape_action[TAPE_ACTION_BUTTON];
11553 static void SetTapeActionFromMouseAction(byte *tape_action,
11554 struct MouseActionInfo *mouse_action)
11556 if (!tape.use_mouse_actions)
11559 tape_action[TAPE_ACTION_LX] = mouse_action->lx;
11560 tape_action[TAPE_ACTION_LY] = mouse_action->ly;
11561 tape_action[TAPE_ACTION_BUTTON] = mouse_action->button;
11564 static void CheckLevelSolved(void)
11566 if (level.game_engine_type == GAME_ENGINE_TYPE_EM)
11568 if (game_em.level_solved &&
11569 !game_em.game_over) // game won
11573 game_em.game_over = TRUE;
11575 game.all_players_gone = TRUE;
11578 if (game_em.game_over) // game lost
11579 game.all_players_gone = TRUE;
11581 else if (level.game_engine_type == GAME_ENGINE_TYPE_SP)
11583 if (game_sp.level_solved &&
11584 !game_sp.game_over) // game won
11588 game_sp.game_over = TRUE;
11590 game.all_players_gone = TRUE;
11593 if (game_sp.game_over) // game lost
11594 game.all_players_gone = TRUE;
11596 else if (level.game_engine_type == GAME_ENGINE_TYPE_MM)
11598 if (game_mm.level_solved &&
11599 !game_mm.game_over) // game won
11603 game_mm.game_over = TRUE;
11605 game.all_players_gone = TRUE;
11608 if (game_mm.game_over) // game lost
11609 game.all_players_gone = TRUE;
11613 static void CheckLevelTime_StepCounter(void)
11623 if (TimeLeft <= 10 && setup.time_limit && !game.LevelSolved)
11624 PlaySound(SND_GAME_RUNNING_OUT_OF_TIME);
11626 game_panel_controls[GAME_PANEL_TIME].value = TimeLeft;
11628 DisplayGameControlValues();
11630 if (!TimeLeft && setup.time_limit && !game.LevelSolved)
11631 for (i = 0; i < MAX_PLAYERS; i++)
11632 KillPlayer(&stored_player[i]);
11634 else if (game.no_time_limit && !game.all_players_gone)
11636 game_panel_controls[GAME_PANEL_TIME].value = TimePlayed;
11638 DisplayGameControlValues();
11642 static void CheckLevelTime(void)
11646 if (TimeFrames >= FRAMES_PER_SECOND)
11651 for (i = 0; i < MAX_PLAYERS; i++)
11653 struct PlayerInfo *player = &stored_player[i];
11655 if (SHIELD_ON(player))
11657 player->shield_normal_time_left--;
11659 if (player->shield_deadly_time_left > 0)
11660 player->shield_deadly_time_left--;
11664 if (!game.LevelSolved && !level.use_step_counter)
11672 if (TimeLeft <= 10 && setup.time_limit)
11673 PlaySound(SND_GAME_RUNNING_OUT_OF_TIME);
11675 /* this does not make sense: game_panel_controls[GAME_PANEL_TIME].value
11676 is reset from other values in UpdateGameDoorValues() -- FIX THIS */
11678 game_panel_controls[GAME_PANEL_TIME].value = TimeLeft;
11680 if (!TimeLeft && setup.time_limit)
11682 if (level.game_engine_type == GAME_ENGINE_TYPE_EM)
11683 game_em.lev->killed_out_of_time = TRUE;
11685 for (i = 0; i < MAX_PLAYERS; i++)
11686 KillPlayer(&stored_player[i]);
11689 else if (game.no_time_limit && !game.all_players_gone)
11691 game_panel_controls[GAME_PANEL_TIME].value = TimePlayed;
11694 game_em.lev->time = (game.no_time_limit ? TimePlayed : TimeLeft);
11697 if (tape.recording || tape.playing)
11698 DrawVideoDisplay(VIDEO_STATE_TIME_ON, TapeTime);
11701 if (tape.recording || tape.playing)
11702 DrawVideoDisplay(VIDEO_STATE_FRAME_ON, FrameCounter);
11704 UpdateAndDisplayGameControlValues();
11707 void AdvanceFrameAndPlayerCounters(int player_nr)
11711 // advance frame counters (global frame counter and time frame counter)
11715 // advance player counters (counters for move delay, move animation etc.)
11716 for (i = 0; i < MAX_PLAYERS; i++)
11718 boolean advance_player_counters = (player_nr == -1 || player_nr == i);
11719 int move_delay_value = stored_player[i].move_delay_value;
11720 int move_frames = MOVE_DELAY_NORMAL_SPEED / move_delay_value;
11722 if (!advance_player_counters) // not all players may be affected
11725 if (move_frames == 0) // less than one move per game frame
11727 int stepsize = TILEX / move_delay_value;
11728 int delay = move_delay_value / MOVE_DELAY_NORMAL_SPEED;
11729 int count = (stored_player[i].is_moving ?
11730 ABS(stored_player[i].MovPos) / stepsize : FrameCounter);
11732 if (count % delay == 0)
11736 stored_player[i].Frame += move_frames;
11738 if (stored_player[i].MovPos != 0)
11739 stored_player[i].StepFrame += move_frames;
11741 if (stored_player[i].move_delay > 0)
11742 stored_player[i].move_delay--;
11744 // due to bugs in previous versions, counter must count up, not down
11745 if (stored_player[i].push_delay != -1)
11746 stored_player[i].push_delay++;
11748 if (stored_player[i].drop_delay > 0)
11749 stored_player[i].drop_delay--;
11751 if (stored_player[i].is_dropping_pressed)
11752 stored_player[i].drop_pressed_delay++;
11756 void StartGameActions(boolean init_network_game, boolean record_tape,
11759 unsigned int new_random_seed = InitRND(random_seed);
11762 TapeStartRecording(new_random_seed);
11764 if (init_network_game)
11766 SendToServer_LevelFile();
11767 SendToServer_StartPlaying();
11775 static void GameActionsExt(void)
11778 static unsigned int game_frame_delay = 0;
11780 unsigned int game_frame_delay_value;
11781 byte *recorded_player_action;
11782 byte summarized_player_action = 0;
11783 byte tape_action[MAX_TAPE_ACTIONS] = { 0 };
11786 // detect endless loops, caused by custom element programming
11787 if (recursion_loop_detected && recursion_loop_depth == 0)
11789 char *message = getStringCat3("Internal Error! Element ",
11790 EL_NAME(recursion_loop_element),
11791 " caused endless loop! Quit the game?");
11793 Warn("element '%s' caused endless loop in game engine",
11794 EL_NAME(recursion_loop_element));
11796 RequestQuitGameExt(program.headless, level_editor_test_game, message);
11798 recursion_loop_detected = FALSE; // if game should be continued
11805 if (game.restart_level)
11806 StartGameActions(network.enabled, setup.autorecord, level.random_seed);
11808 CheckLevelSolved();
11810 if (game.LevelSolved && !game.LevelSolved_GameEnd)
11813 if (game.all_players_gone && !TAPE_IS_STOPPED(tape))
11816 if (game_status != GAME_MODE_PLAYING) // status might have changed
11819 game_frame_delay_value =
11820 (tape.playing && tape.fast_forward ? FfwdFrameDelay : GameFrameDelay);
11822 if (tape.playing && tape.warp_forward && !tape.pausing)
11823 game_frame_delay_value = 0;
11825 SetVideoFrameDelay(game_frame_delay_value);
11827 // (de)activate virtual buttons depending on current game status
11828 if (strEqual(setup.touch.control_type, TOUCH_CONTROL_VIRTUAL_BUTTONS))
11830 if (game.all_players_gone) // if no players there to be controlled anymore
11831 SetOverlayActive(FALSE);
11832 else if (!tape.playing) // if game continues after tape stopped playing
11833 SetOverlayActive(TRUE);
11838 // ---------- main game synchronization point ----------
11840 int skip = WaitUntilDelayReached(&game_frame_delay, game_frame_delay_value);
11842 Debug("game:playing:skip", "skip == %d", skip);
11845 // ---------- main game synchronization point ----------
11847 WaitUntilDelayReached(&game_frame_delay, game_frame_delay_value);
11851 if (network_playing && !network_player_action_received)
11853 // try to get network player actions in time
11855 // last chance to get network player actions without main loop delay
11856 HandleNetworking();
11858 // game was quit by network peer
11859 if (game_status != GAME_MODE_PLAYING)
11862 // check if network player actions still missing and game still running
11863 if (!network_player_action_received && !checkGameEnded())
11864 return; // failed to get network player actions in time
11866 // do not yet reset "network_player_action_received" (for tape.pausing)
11872 // at this point we know that we really continue executing the game
11874 network_player_action_received = FALSE;
11876 // when playing tape, read previously recorded player input from tape data
11877 recorded_player_action = (tape.playing ? TapePlayAction() : NULL);
11879 local_player->effective_mouse_action = local_player->mouse_action;
11881 if (recorded_player_action != NULL)
11882 SetMouseActionFromTapeAction(&local_player->effective_mouse_action,
11883 recorded_player_action);
11885 // TapePlayAction() may return NULL when toggling to "pause before death"
11889 if (tape.set_centered_player)
11891 game.centered_player_nr_next = tape.centered_player_nr_next;
11892 game.set_centered_player = TRUE;
11895 for (i = 0; i < MAX_PLAYERS; i++)
11897 summarized_player_action |= stored_player[i].action;
11899 if (!network_playing && (game.team_mode || tape.playing))
11900 stored_player[i].effective_action = stored_player[i].action;
11903 if (network_playing && !checkGameEnded())
11904 SendToServer_MovePlayer(summarized_player_action);
11906 // summarize all actions at local players mapped input device position
11907 // (this allows using different input devices in single player mode)
11908 if (!network.enabled && !game.team_mode)
11909 stored_player[map_player_action[local_player->index_nr]].effective_action =
11910 summarized_player_action;
11912 // summarize all actions at centered player in local team mode
11913 if (tape.recording &&
11914 setup.team_mode && !network.enabled &&
11915 setup.input_on_focus &&
11916 game.centered_player_nr != -1)
11918 for (i = 0; i < MAX_PLAYERS; i++)
11919 stored_player[map_player_action[i]].effective_action =
11920 (i == game.centered_player_nr ? summarized_player_action : 0);
11923 if (recorded_player_action != NULL)
11924 for (i = 0; i < MAX_PLAYERS; i++)
11925 stored_player[i].effective_action = recorded_player_action[i];
11927 for (i = 0; i < MAX_PLAYERS; i++)
11929 tape_action[i] = stored_player[i].effective_action;
11931 /* (this may happen in the RND game engine if a player was not present on
11932 the playfield on level start, but appeared later from a custom element */
11933 if (setup.team_mode &&
11936 !tape.player_participates[i])
11937 tape.player_participates[i] = TRUE;
11940 SetTapeActionFromMouseAction(tape_action,
11941 &local_player->effective_mouse_action);
11943 // only record actions from input devices, but not programmed actions
11944 if (tape.recording)
11945 TapeRecordAction(tape_action);
11947 // remember if game was played (especially after tape stopped playing)
11948 if (!tape.playing && summarized_player_action)
11949 game.GamePlayed = TRUE;
11951 #if USE_NEW_PLAYER_ASSIGNMENTS
11952 // !!! also map player actions in single player mode !!!
11953 // if (game.team_mode)
11956 byte mapped_action[MAX_PLAYERS];
11958 #if DEBUG_PLAYER_ACTIONS
11959 for (i = 0; i < MAX_PLAYERS; i++)
11960 DebugContinued("", "%d, ", stored_player[i].effective_action);
11963 for (i = 0; i < MAX_PLAYERS; i++)
11964 mapped_action[i] = stored_player[map_player_action[i]].effective_action;
11966 for (i = 0; i < MAX_PLAYERS; i++)
11967 stored_player[i].effective_action = mapped_action[i];
11969 #if DEBUG_PLAYER_ACTIONS
11970 DebugContinued("", "=> ");
11971 for (i = 0; i < MAX_PLAYERS; i++)
11972 DebugContinued("", "%d, ", stored_player[i].effective_action);
11973 DebugContinued("game:playing:player", "\n");
11976 #if DEBUG_PLAYER_ACTIONS
11979 for (i = 0; i < MAX_PLAYERS; i++)
11980 DebugContinued("", "%d, ", stored_player[i].effective_action);
11981 DebugContinued("game:playing:player", "\n");
11986 for (i = 0; i < MAX_PLAYERS; i++)
11988 // allow engine snapshot in case of changed movement attempt
11989 if ((game.snapshot.last_action[i] & KEY_MOTION) !=
11990 (stored_player[i].effective_action & KEY_MOTION))
11991 game.snapshot.changed_action = TRUE;
11993 // allow engine snapshot in case of snapping/dropping attempt
11994 if ((game.snapshot.last_action[i] & KEY_BUTTON) == 0 &&
11995 (stored_player[i].effective_action & KEY_BUTTON) != 0)
11996 game.snapshot.changed_action = TRUE;
11998 game.snapshot.last_action[i] = stored_player[i].effective_action;
12001 if (level.game_engine_type == GAME_ENGINE_TYPE_EM)
12003 GameActions_EM_Main();
12005 else if (level.game_engine_type == GAME_ENGINE_TYPE_SP)
12007 GameActions_SP_Main();
12009 else if (level.game_engine_type == GAME_ENGINE_TYPE_MM)
12011 GameActions_MM_Main();
12015 GameActions_RND_Main();
12018 BlitScreenToBitmap(backbuffer);
12020 CheckLevelSolved();
12023 AdvanceFrameAndPlayerCounters(-1); // advance counters for all players
12025 if (global.show_frames_per_second)
12027 static unsigned int fps_counter = 0;
12028 static int fps_frames = 0;
12029 unsigned int fps_delay_ms = Counter() - fps_counter;
12033 if (fps_delay_ms >= 500) // calculate FPS every 0.5 seconds
12035 global.frames_per_second = 1000 * (float)fps_frames / fps_delay_ms;
12038 fps_counter = Counter();
12040 // always draw FPS to screen after FPS value was updated
12041 redraw_mask |= REDRAW_FPS;
12044 // only draw FPS if no screen areas are deactivated (invisible warp mode)
12045 if (GetDrawDeactivationMask() == REDRAW_NONE)
12046 redraw_mask |= REDRAW_FPS;
12050 static void GameActions_CheckSaveEngineSnapshot(void)
12052 if (!game.snapshot.save_snapshot)
12055 // clear flag for saving snapshot _before_ saving snapshot
12056 game.snapshot.save_snapshot = FALSE;
12058 SaveEngineSnapshotToList();
12061 void GameActions(void)
12065 GameActions_CheckSaveEngineSnapshot();
12068 void GameActions_EM_Main(void)
12070 byte effective_action[MAX_PLAYERS];
12071 boolean warp_mode = (tape.playing && tape.warp_forward && !tape.pausing);
12074 for (i = 0; i < MAX_PLAYERS; i++)
12075 effective_action[i] = stored_player[i].effective_action;
12077 GameActions_EM(effective_action, warp_mode);
12080 void GameActions_SP_Main(void)
12082 byte effective_action[MAX_PLAYERS];
12083 boolean warp_mode = (tape.playing && tape.warp_forward && !tape.pausing);
12086 for (i = 0; i < MAX_PLAYERS; i++)
12087 effective_action[i] = stored_player[i].effective_action;
12089 GameActions_SP(effective_action, warp_mode);
12091 for (i = 0; i < MAX_PLAYERS; i++)
12093 if (stored_player[i].force_dropping)
12094 stored_player[i].action |= KEY_BUTTON_DROP;
12096 stored_player[i].force_dropping = FALSE;
12100 void GameActions_MM_Main(void)
12102 boolean warp_mode = (tape.playing && tape.warp_forward && !tape.pausing);
12104 GameActions_MM(local_player->effective_mouse_action, warp_mode);
12107 void GameActions_RND_Main(void)
12112 void GameActions_RND(void)
12114 static struct MouseActionInfo mouse_action_last = { 0 };
12115 struct MouseActionInfo mouse_action = local_player->effective_mouse_action;
12116 int magic_wall_x = 0, magic_wall_y = 0;
12117 int i, x, y, element, graphic, last_gfx_frame;
12119 InitPlayfieldScanModeVars();
12121 if (game.engine_version >= VERSION_IDENT(3,2,0,7))
12123 SCAN_PLAYFIELD(x, y)
12125 ChangeCount[x][y] = 0;
12126 ChangeEvent[x][y] = -1;
12130 if (game.set_centered_player)
12132 boolean all_players_fit_to_screen = checkIfAllPlayersFitToScreen_RND();
12134 // switching to "all players" only possible if all players fit to screen
12135 if (game.centered_player_nr_next == -1 && !all_players_fit_to_screen)
12137 game.centered_player_nr_next = game.centered_player_nr;
12138 game.set_centered_player = FALSE;
12141 // do not switch focus to non-existing (or non-active) player
12142 if (game.centered_player_nr_next >= 0 &&
12143 !stored_player[game.centered_player_nr_next].active)
12145 game.centered_player_nr_next = game.centered_player_nr;
12146 game.set_centered_player = FALSE;
12150 if (game.set_centered_player &&
12151 ScreenMovPos == 0) // screen currently aligned at tile position
12155 if (game.centered_player_nr_next == -1)
12157 setScreenCenteredToAllPlayers(&sx, &sy);
12161 sx = stored_player[game.centered_player_nr_next].jx;
12162 sy = stored_player[game.centered_player_nr_next].jy;
12165 game.centered_player_nr = game.centered_player_nr_next;
12166 game.set_centered_player = FALSE;
12168 DrawRelocateScreen(0, 0, sx, sy, MV_NONE, TRUE, setup.quick_switch);
12169 DrawGameDoorValues();
12172 // check single step mode (set flag and clear again if any player is active)
12173 game.enter_single_step_mode =
12174 (tape.single_step && tape.recording && !tape.pausing);
12176 for (i = 0; i < MAX_PLAYERS; i++)
12178 int actual_player_action = stored_player[i].effective_action;
12181 /* !!! THIS BREAKS THE FOLLOWING TAPES: !!!
12182 - rnd_equinox_tetrachloride 048
12183 - rnd_equinox_tetrachloride_ii 096
12184 - rnd_emanuel_schmieg 002
12185 - doctor_sloan_ww 001, 020
12187 if (stored_player[i].MovPos == 0)
12188 CheckGravityMovement(&stored_player[i]);
12191 // overwrite programmed action with tape action
12192 if (stored_player[i].programmed_action)
12193 actual_player_action = stored_player[i].programmed_action;
12195 PlayerActions(&stored_player[i], actual_player_action);
12197 ScrollPlayer(&stored_player[i], SCROLL_GO_ON);
12200 // single step pause mode may already have been toggled by "ScrollPlayer()"
12201 if (game.enter_single_step_mode && !tape.pausing)
12202 TapeTogglePause(TAPE_TOGGLE_AUTOMATIC);
12204 ScrollScreen(NULL, SCROLL_GO_ON);
12206 /* for backwards compatibility, the following code emulates a fixed bug that
12207 occured when pushing elements (causing elements that just made their last
12208 pushing step to already (if possible) make their first falling step in the
12209 same game frame, which is bad); this code is also needed to use the famous
12210 "spring push bug" which is used in older levels and might be wanted to be
12211 used also in newer levels, but in this case the buggy pushing code is only
12212 affecting the "spring" element and no other elements */
12214 if (game.engine_version < VERSION_IDENT(2,2,0,7) || level.use_spring_bug)
12216 for (i = 0; i < MAX_PLAYERS; i++)
12218 struct PlayerInfo *player = &stored_player[i];
12219 int x = player->jx;
12220 int y = player->jy;
12222 if (player->active && player->is_pushing && player->is_moving &&
12224 (game.engine_version < VERSION_IDENT(2,2,0,7) ||
12225 Tile[x][y] == EL_SPRING))
12227 ContinueMoving(x, y);
12229 // continue moving after pushing (this is actually a bug)
12230 if (!IS_MOVING(x, y))
12231 Stop[x][y] = FALSE;
12236 SCAN_PLAYFIELD(x, y)
12238 Last[x][y] = Tile[x][y];
12240 ChangeCount[x][y] = 0;
12241 ChangeEvent[x][y] = -1;
12243 // this must be handled before main playfield loop
12244 if (Tile[x][y] == EL_PLAYER_IS_LEAVING)
12247 if (MovDelay[x][y] <= 0)
12251 if (Tile[x][y] == EL_ELEMENT_SNAPPING)
12254 if (MovDelay[x][y] <= 0)
12256 int element = Store[x][y];
12257 int move_direction = MovDir[x][y];
12258 int player_index_bit = Store2[x][y];
12264 TEST_DrawLevelField(x, y);
12266 TestFieldAfterSnapping(x, y, element, move_direction, player_index_bit);
12268 if (IS_ENVELOPE(element))
12269 local_player->show_envelope = element;
12274 if (ChangePage[x][y] != -1 && ChangeDelay[x][y] != 1)
12276 Debug("game:playing:GameActions_RND", "x = %d, y = %d: ChangePage != -1",
12278 Debug("game:playing:GameActions_RND", "This should never happen!");
12280 ChangePage[x][y] = -1;
12284 Stop[x][y] = FALSE;
12285 if (WasJustMoving[x][y] > 0)
12286 WasJustMoving[x][y]--;
12287 if (WasJustFalling[x][y] > 0)
12288 WasJustFalling[x][y]--;
12289 if (CheckCollision[x][y] > 0)
12290 CheckCollision[x][y]--;
12291 if (CheckImpact[x][y] > 0)
12292 CheckImpact[x][y]--;
12296 /* reset finished pushing action (not done in ContinueMoving() to allow
12297 continuous pushing animation for elements with zero push delay) */
12298 if (GfxAction[x][y] == ACTION_PUSHING && !IS_MOVING(x, y))
12300 ResetGfxAnimation(x, y);
12301 TEST_DrawLevelField(x, y);
12305 if (IS_BLOCKED(x, y))
12309 Blocked2Moving(x, y, &oldx, &oldy);
12310 if (!IS_MOVING(oldx, oldy))
12312 Debug("game:playing:GameActions_RND", "(BLOCKED => MOVING) context corrupted!");
12313 Debug("game:playing:GameActions_RND", "BLOCKED: x = %d, y = %d", x, y);
12314 Debug("game:playing:GameActions_RND", "!MOVING: oldx = %d, oldy = %d", oldx, oldy);
12315 Debug("game:playing:GameActions_RND", "This should never happen!");
12321 if (mouse_action.button)
12323 int new_button = (mouse_action.button && mouse_action_last.button == 0);
12324 int ch_button = CH_SIDE_FROM_BUTTON(mouse_action.button);
12326 x = mouse_action.lx;
12327 y = mouse_action.ly;
12328 element = Tile[x][y];
12332 CheckElementChangeByMouse(x, y, element, CE_CLICKED_BY_MOUSE, ch_button);
12333 CheckTriggeredElementChangeByMouse(x, y, element, CE_MOUSE_CLICKED_ON_X,
12337 CheckElementChangeByMouse(x, y, element, CE_PRESSED_BY_MOUSE, ch_button);
12338 CheckTriggeredElementChangeByMouse(x, y, element, CE_MOUSE_PRESSED_ON_X,
12341 if (level.use_step_counter)
12343 boolean counted_click = FALSE;
12345 // element clicked that can change when clicked/pressed
12346 if (CAN_CHANGE_OR_HAS_ACTION(element) &&
12347 (HAS_ANY_CHANGE_EVENT(element, CE_CLICKED_BY_MOUSE) ||
12348 HAS_ANY_CHANGE_EVENT(element, CE_PRESSED_BY_MOUSE)))
12349 counted_click = TRUE;
12351 // element clicked that can trigger change when clicked/pressed
12352 if (trigger_events[element][CE_MOUSE_CLICKED_ON_X] ||
12353 trigger_events[element][CE_MOUSE_PRESSED_ON_X])
12354 counted_click = TRUE;
12356 if (new_button && counted_click)
12357 CheckLevelTime_StepCounter();
12361 SCAN_PLAYFIELD(x, y)
12363 element = Tile[x][y];
12364 graphic = el_act_dir2img(element, GfxAction[x][y], GfxDir[x][y]);
12365 last_gfx_frame = GfxFrame[x][y];
12367 if (element == EL_EMPTY)
12368 graphic = el2img(GfxElementEmpty[x][y]);
12370 ResetGfxFrame(x, y);
12372 if (GfxFrame[x][y] != last_gfx_frame && !Stop[x][y])
12373 DrawLevelGraphicAnimation(x, y, graphic);
12375 if (ANIM_MODE(graphic) == ANIM_RANDOM &&
12376 IS_NEXT_FRAME(GfxFrame[x][y], graphic))
12377 ResetRandomAnimationValue(x, y);
12379 SetRandomAnimationValue(x, y);
12381 PlayLevelSoundActionIfLoop(x, y, GfxAction[x][y]);
12383 if (IS_INACTIVE(element))
12385 if (IS_ANIMATED(graphic))
12386 DrawLevelGraphicAnimationIfNeeded(x, y, graphic);
12391 // this may take place after moving, so 'element' may have changed
12392 if (IS_CHANGING(x, y) &&
12393 (game.engine_version < VERSION_IDENT(3,0,7,1) || !Stop[x][y]))
12395 int page = element_info[element].event_page_nr[CE_DELAY];
12397 HandleElementChange(x, y, page);
12399 element = Tile[x][y];
12400 graphic = el_act_dir2img(element, GfxAction[x][y], GfxDir[x][y]);
12403 CheckNextToConditions(x, y);
12405 if (!IS_MOVING(x, y) && (CAN_FALL(element) || CAN_MOVE(element)))
12409 element = Tile[x][y];
12410 graphic = el_act_dir2img(element, GfxAction[x][y], GfxDir[x][y]);
12412 if (IS_ANIMATED(graphic) &&
12413 !IS_MOVING(x, y) &&
12415 DrawLevelGraphicAnimationIfNeeded(x, y, graphic);
12417 if (IS_GEM(element) || element == EL_SP_INFOTRON)
12418 TEST_DrawTwinkleOnField(x, y);
12420 else if (element == EL_ACID)
12423 DrawLevelGraphicAnimationIfNeeded(x, y, graphic);
12425 else if ((element == EL_EXIT_OPEN ||
12426 element == EL_EM_EXIT_OPEN ||
12427 element == EL_SP_EXIT_OPEN ||
12428 element == EL_STEEL_EXIT_OPEN ||
12429 element == EL_EM_STEEL_EXIT_OPEN ||
12430 element == EL_SP_TERMINAL ||
12431 element == EL_SP_TERMINAL_ACTIVE ||
12432 element == EL_EXTRA_TIME ||
12433 element == EL_SHIELD_NORMAL ||
12434 element == EL_SHIELD_DEADLY) &&
12435 IS_ANIMATED(graphic))
12436 DrawLevelGraphicAnimationIfNeeded(x, y, graphic);
12437 else if (IS_MOVING(x, y))
12438 ContinueMoving(x, y);
12439 else if (IS_ACTIVE_BOMB(element))
12440 CheckDynamite(x, y);
12441 else if (element == EL_AMOEBA_GROWING)
12442 AmoebaGrowing(x, y);
12443 else if (element == EL_AMOEBA_SHRINKING)
12444 AmoebaShrinking(x, y);
12446 #if !USE_NEW_AMOEBA_CODE
12447 else if (IS_AMOEBALIVE(element))
12448 AmoebaReproduce(x, y);
12451 else if (element == EL_GAME_OF_LIFE || element == EL_BIOMAZE)
12453 else if (element == EL_EXIT_CLOSED)
12455 else if (element == EL_EM_EXIT_CLOSED)
12457 else if (element == EL_STEEL_EXIT_CLOSED)
12458 CheckExitSteel(x, y);
12459 else if (element == EL_EM_STEEL_EXIT_CLOSED)
12460 CheckExitSteelEM(x, y);
12461 else if (element == EL_SP_EXIT_CLOSED)
12463 else if (element == EL_EXPANDABLE_WALL_GROWING ||
12464 element == EL_EXPANDABLE_STEELWALL_GROWING)
12465 MauerWaechst(x, y);
12466 else if (element == EL_EXPANDABLE_WALL ||
12467 element == EL_EXPANDABLE_WALL_HORIZONTAL ||
12468 element == EL_EXPANDABLE_WALL_VERTICAL ||
12469 element == EL_EXPANDABLE_WALL_ANY ||
12470 element == EL_BD_EXPANDABLE_WALL)
12471 MauerAbleger(x, y);
12472 else if (element == EL_EXPANDABLE_STEELWALL_HORIZONTAL ||
12473 element == EL_EXPANDABLE_STEELWALL_VERTICAL ||
12474 element == EL_EXPANDABLE_STEELWALL_ANY)
12475 MauerAblegerStahl(x, y);
12476 else if (element == EL_FLAMES)
12477 CheckForDragon(x, y);
12478 else if (element == EL_EXPLOSION)
12479 ; // drawing of correct explosion animation is handled separately
12480 else if (element == EL_ELEMENT_SNAPPING ||
12481 element == EL_DIAGONAL_SHRINKING ||
12482 element == EL_DIAGONAL_GROWING)
12484 graphic = el_act_dir2img(GfxElement[x][y], GfxAction[x][y],GfxDir[x][y]);
12486 DrawLevelGraphicAnimationIfNeeded(x, y, graphic);
12488 else if (IS_ANIMATED(graphic) && !IS_CHANGING(x, y))
12489 DrawLevelGraphicAnimationIfNeeded(x, y, graphic);
12491 if (IS_BELT_ACTIVE(element))
12492 PlayLevelSoundAction(x, y, ACTION_ACTIVE);
12494 if (game.magic_wall_active)
12496 int jx = local_player->jx, jy = local_player->jy;
12498 // play the element sound at the position nearest to the player
12499 if ((element == EL_MAGIC_WALL_FULL ||
12500 element == EL_MAGIC_WALL_ACTIVE ||
12501 element == EL_MAGIC_WALL_EMPTYING ||
12502 element == EL_BD_MAGIC_WALL_FULL ||
12503 element == EL_BD_MAGIC_WALL_ACTIVE ||
12504 element == EL_BD_MAGIC_WALL_EMPTYING ||
12505 element == EL_DC_MAGIC_WALL_FULL ||
12506 element == EL_DC_MAGIC_WALL_ACTIVE ||
12507 element == EL_DC_MAGIC_WALL_EMPTYING) &&
12508 ABS(x - jx) + ABS(y - jy) <
12509 ABS(magic_wall_x - jx) + ABS(magic_wall_y - jy))
12517 #if USE_NEW_AMOEBA_CODE
12518 // new experimental amoeba growth stuff
12519 if (!(FrameCounter % 8))
12521 static unsigned int random = 1684108901;
12523 for (i = 0; i < level.amoeba_speed * 28 / 8; i++)
12525 x = RND(lev_fieldx);
12526 y = RND(lev_fieldy);
12527 element = Tile[x][y];
12529 if (!IS_PLAYER(x,y) &&
12530 (element == EL_EMPTY ||
12531 CAN_GROW_INTO(element) ||
12532 element == EL_QUICKSAND_EMPTY ||
12533 element == EL_QUICKSAND_FAST_EMPTY ||
12534 element == EL_ACID_SPLASH_LEFT ||
12535 element == EL_ACID_SPLASH_RIGHT))
12537 if ((IN_LEV_FIELD(x, y-1) && Tile[x][y-1] == EL_AMOEBA_WET) ||
12538 (IN_LEV_FIELD(x-1, y) && Tile[x-1][y] == EL_AMOEBA_WET) ||
12539 (IN_LEV_FIELD(x+1, y) && Tile[x+1][y] == EL_AMOEBA_WET) ||
12540 (IN_LEV_FIELD(x, y+1) && Tile[x][y+1] == EL_AMOEBA_WET))
12541 Tile[x][y] = EL_AMOEBA_DROP;
12544 random = random * 129 + 1;
12549 game.explosions_delayed = FALSE;
12551 SCAN_PLAYFIELD(x, y)
12553 element = Tile[x][y];
12555 if (ExplodeField[x][y])
12556 Explode(x, y, EX_PHASE_START, ExplodeField[x][y]);
12557 else if (element == EL_EXPLOSION)
12558 Explode(x, y, ExplodePhase[x][y], EX_TYPE_NORMAL);
12560 ExplodeField[x][y] = EX_TYPE_NONE;
12563 game.explosions_delayed = TRUE;
12565 if (game.magic_wall_active)
12567 if (!(game.magic_wall_time_left % 4))
12569 int element = Tile[magic_wall_x][magic_wall_y];
12571 if (element == EL_BD_MAGIC_WALL_FULL ||
12572 element == EL_BD_MAGIC_WALL_ACTIVE ||
12573 element == EL_BD_MAGIC_WALL_EMPTYING)
12574 PlayLevelSound(magic_wall_x, magic_wall_y, SND_BD_MAGIC_WALL_ACTIVE);
12575 else if (element == EL_DC_MAGIC_WALL_FULL ||
12576 element == EL_DC_MAGIC_WALL_ACTIVE ||
12577 element == EL_DC_MAGIC_WALL_EMPTYING)
12578 PlayLevelSound(magic_wall_x, magic_wall_y, SND_DC_MAGIC_WALL_ACTIVE);
12580 PlayLevelSound(magic_wall_x, magic_wall_y, SND_MAGIC_WALL_ACTIVE);
12583 if (game.magic_wall_time_left > 0)
12585 game.magic_wall_time_left--;
12587 if (!game.magic_wall_time_left)
12589 SCAN_PLAYFIELD(x, y)
12591 element = Tile[x][y];
12593 if (element == EL_MAGIC_WALL_ACTIVE ||
12594 element == EL_MAGIC_WALL_FULL)
12596 Tile[x][y] = EL_MAGIC_WALL_DEAD;
12597 TEST_DrawLevelField(x, y);
12599 else if (element == EL_BD_MAGIC_WALL_ACTIVE ||
12600 element == EL_BD_MAGIC_WALL_FULL)
12602 Tile[x][y] = EL_BD_MAGIC_WALL_DEAD;
12603 TEST_DrawLevelField(x, y);
12605 else if (element == EL_DC_MAGIC_WALL_ACTIVE ||
12606 element == EL_DC_MAGIC_WALL_FULL)
12608 Tile[x][y] = EL_DC_MAGIC_WALL_DEAD;
12609 TEST_DrawLevelField(x, y);
12613 game.magic_wall_active = FALSE;
12618 if (game.light_time_left > 0)
12620 game.light_time_left--;
12622 if (game.light_time_left == 0)
12623 RedrawAllLightSwitchesAndInvisibleElements();
12626 if (game.timegate_time_left > 0)
12628 game.timegate_time_left--;
12630 if (game.timegate_time_left == 0)
12631 CloseAllOpenTimegates();
12634 if (game.lenses_time_left > 0)
12636 game.lenses_time_left--;
12638 if (game.lenses_time_left == 0)
12639 RedrawAllInvisibleElementsForLenses();
12642 if (game.magnify_time_left > 0)
12644 game.magnify_time_left--;
12646 if (game.magnify_time_left == 0)
12647 RedrawAllInvisibleElementsForMagnifier();
12650 for (i = 0; i < MAX_PLAYERS; i++)
12652 struct PlayerInfo *player = &stored_player[i];
12654 if (SHIELD_ON(player))
12656 if (player->shield_deadly_time_left)
12657 PlayLevelSound(player->jx, player->jy, SND_SHIELD_DEADLY_ACTIVE);
12658 else if (player->shield_normal_time_left)
12659 PlayLevelSound(player->jx, player->jy, SND_SHIELD_NORMAL_ACTIVE);
12663 #if USE_DELAYED_GFX_REDRAW
12664 SCAN_PLAYFIELD(x, y)
12666 if (GfxRedraw[x][y] != GFX_REDRAW_NONE)
12668 /* !!! PROBLEM: THIS REDRAWS THE PLAYFIELD _AFTER_ THE SCAN, BUT TILES
12669 !!! MAY HAVE CHANGED AFTER BEING DRAWN DURING PLAYFIELD SCAN !!! */
12671 if (GfxRedraw[x][y] & GFX_REDRAW_TILE)
12672 DrawLevelField(x, y);
12674 if (GfxRedraw[x][y] & GFX_REDRAW_TILE_CRUMBLED)
12675 DrawLevelFieldCrumbled(x, y);
12677 if (GfxRedraw[x][y] & GFX_REDRAW_TILE_CRUMBLED_NEIGHBOURS)
12678 DrawLevelFieldCrumbledNeighbours(x, y);
12680 if (GfxRedraw[x][y] & GFX_REDRAW_TILE_TWINKLED)
12681 DrawTwinkleOnField(x, y);
12684 GfxRedraw[x][y] = GFX_REDRAW_NONE;
12689 PlayAllPlayersSound();
12691 for (i = 0; i < MAX_PLAYERS; i++)
12693 struct PlayerInfo *player = &stored_player[i];
12695 if (player->show_envelope != 0 && (!player->active ||
12696 player->MovPos == 0))
12698 ShowEnvelope(player->show_envelope - EL_ENVELOPE_1);
12700 player->show_envelope = 0;
12704 // use random number generator in every frame to make it less predictable
12705 if (game.engine_version >= VERSION_IDENT(3,1,1,0))
12708 mouse_action_last = mouse_action;
12711 static boolean AllPlayersInSight(struct PlayerInfo *player, int x, int y)
12713 int min_x = x, min_y = y, max_x = x, max_y = y;
12714 int scr_fieldx = getScreenFieldSizeX();
12715 int scr_fieldy = getScreenFieldSizeY();
12718 for (i = 0; i < MAX_PLAYERS; i++)
12720 int jx = stored_player[i].jx, jy = stored_player[i].jy;
12722 if (!stored_player[i].active || &stored_player[i] == player)
12725 min_x = MIN(min_x, jx);
12726 min_y = MIN(min_y, jy);
12727 max_x = MAX(max_x, jx);
12728 max_y = MAX(max_y, jy);
12731 return (max_x - min_x < scr_fieldx && max_y - min_y < scr_fieldy);
12734 static boolean AllPlayersInVisibleScreen(void)
12738 for (i = 0; i < MAX_PLAYERS; i++)
12740 int jx = stored_player[i].jx, jy = stored_player[i].jy;
12742 if (!stored_player[i].active)
12745 if (!IN_VIS_FIELD(SCREENX(jx), SCREENY(jy)))
12752 void ScrollLevel(int dx, int dy)
12754 int scroll_offset = 2 * TILEX_VAR;
12757 BlitBitmap(drawto_field, drawto_field,
12758 FX + TILEX_VAR * (dx == -1) - scroll_offset,
12759 FY + TILEY_VAR * (dy == -1) - scroll_offset,
12760 SXSIZE - TILEX_VAR * (dx != 0) + 2 * scroll_offset,
12761 SYSIZE - TILEY_VAR * (dy != 0) + 2 * scroll_offset,
12762 FX + TILEX_VAR * (dx == 1) - scroll_offset,
12763 FY + TILEY_VAR * (dy == 1) - scroll_offset);
12767 x = (dx == 1 ? BX1 : BX2);
12768 for (y = BY1; y <= BY2; y++)
12769 DrawScreenField(x, y);
12774 y = (dy == 1 ? BY1 : BY2);
12775 for (x = BX1; x <= BX2; x++)
12776 DrawScreenField(x, y);
12779 redraw_mask |= REDRAW_FIELD;
12782 static boolean canFallDown(struct PlayerInfo *player)
12784 int jx = player->jx, jy = player->jy;
12786 return (IN_LEV_FIELD(jx, jy + 1) &&
12787 (IS_FREE(jx, jy + 1) ||
12788 (Tile[jx][jy + 1] == EL_ACID && player->can_fall_into_acid)) &&
12789 IS_WALKABLE_FROM(Tile[jx][jy], MV_DOWN) &&
12790 !IS_WALKABLE_INSIDE(Tile[jx][jy]));
12793 static boolean canPassField(int x, int y, int move_dir)
12795 int opposite_dir = MV_DIR_OPPOSITE(move_dir);
12796 int dx = (move_dir & MV_LEFT ? -1 : move_dir & MV_RIGHT ? +1 : 0);
12797 int dy = (move_dir & MV_UP ? -1 : move_dir & MV_DOWN ? +1 : 0);
12798 int nextx = x + dx;
12799 int nexty = y + dy;
12800 int element = Tile[x][y];
12802 return (IS_PASSABLE_FROM(element, opposite_dir) &&
12803 !CAN_MOVE(element) &&
12804 IN_LEV_FIELD(nextx, nexty) && !IS_PLAYER(nextx, nexty) &&
12805 IS_WALKABLE_FROM(Tile[nextx][nexty], move_dir) &&
12806 (level.can_pass_to_walkable || IS_FREE(nextx, nexty)));
12809 static boolean canMoveToValidFieldWithGravity(int x, int y, int move_dir)
12811 int opposite_dir = MV_DIR_OPPOSITE(move_dir);
12812 int dx = (move_dir & MV_LEFT ? -1 : move_dir & MV_RIGHT ? +1 : 0);
12813 int dy = (move_dir & MV_UP ? -1 : move_dir & MV_DOWN ? +1 : 0);
12817 return (IN_LEV_FIELD(newx, newy) && !IS_FREE_OR_PLAYER(newx, newy) &&
12818 IS_GRAVITY_REACHABLE(Tile[newx][newy]) &&
12819 (IS_DIGGABLE(Tile[newx][newy]) ||
12820 IS_WALKABLE_FROM(Tile[newx][newy], opposite_dir) ||
12821 canPassField(newx, newy, move_dir)));
12824 static void CheckGravityMovement(struct PlayerInfo *player)
12826 if (player->gravity && !player->programmed_action)
12828 int move_dir_horizontal = player->effective_action & MV_HORIZONTAL;
12829 int move_dir_vertical = player->effective_action & MV_VERTICAL;
12830 boolean player_is_snapping = (player->effective_action & JOY_BUTTON_1);
12831 int jx = player->jx, jy = player->jy;
12832 boolean player_is_moving_to_valid_field =
12833 (!player_is_snapping &&
12834 (canMoveToValidFieldWithGravity(jx, jy, move_dir_horizontal) ||
12835 canMoveToValidFieldWithGravity(jx, jy, move_dir_vertical)));
12836 boolean player_can_fall_down = canFallDown(player);
12838 if (player_can_fall_down &&
12839 !player_is_moving_to_valid_field)
12840 player->programmed_action = MV_DOWN;
12844 static void CheckGravityMovementWhenNotMoving(struct PlayerInfo *player)
12846 return CheckGravityMovement(player);
12848 if (player->gravity && !player->programmed_action)
12850 int jx = player->jx, jy = player->jy;
12851 boolean field_under_player_is_free =
12852 (IN_LEV_FIELD(jx, jy + 1) && IS_FREE(jx, jy + 1));
12853 boolean player_is_standing_on_valid_field =
12854 (IS_WALKABLE_INSIDE(Tile[jx][jy]) ||
12855 (IS_WALKABLE(Tile[jx][jy]) &&
12856 !(element_info[Tile[jx][jy]].access_direction & MV_DOWN)));
12858 if (field_under_player_is_free && !player_is_standing_on_valid_field)
12859 player->programmed_action = MV_DOWN;
12864 MovePlayerOneStep()
12865 -----------------------------------------------------------------------------
12866 dx, dy: direction (non-diagonal) to try to move the player to
12867 real_dx, real_dy: direction as read from input device (can be diagonal)
12870 boolean MovePlayerOneStep(struct PlayerInfo *player,
12871 int dx, int dy, int real_dx, int real_dy)
12873 int jx = player->jx, jy = player->jy;
12874 int new_jx = jx + dx, new_jy = jy + dy;
12876 boolean player_can_move = !player->cannot_move;
12878 if (!player->active || (!dx && !dy))
12879 return MP_NO_ACTION;
12881 player->MovDir = (dx < 0 ? MV_LEFT :
12882 dx > 0 ? MV_RIGHT :
12884 dy > 0 ? MV_DOWN : MV_NONE);
12886 if (!IN_LEV_FIELD(new_jx, new_jy))
12887 return MP_NO_ACTION;
12889 if (!player_can_move)
12891 if (player->MovPos == 0)
12893 player->is_moving = FALSE;
12894 player->is_digging = FALSE;
12895 player->is_collecting = FALSE;
12896 player->is_snapping = FALSE;
12897 player->is_pushing = FALSE;
12901 if (!network.enabled && game.centered_player_nr == -1 &&
12902 !AllPlayersInSight(player, new_jx, new_jy))
12903 return MP_NO_ACTION;
12905 can_move = DigField(player, jx, jy, new_jx, new_jy, real_dx,real_dy, DF_DIG);
12906 if (can_move != MP_MOVING)
12909 // check if DigField() has caused relocation of the player
12910 if (player->jx != jx || player->jy != jy)
12911 return MP_NO_ACTION; // <-- !!! CHECK THIS [-> MP_ACTION ?] !!!
12913 StorePlayer[jx][jy] = 0;
12914 player->last_jx = jx;
12915 player->last_jy = jy;
12916 player->jx = new_jx;
12917 player->jy = new_jy;
12918 StorePlayer[new_jx][new_jy] = player->element_nr;
12920 if (player->move_delay_value_next != -1)
12922 player->move_delay_value = player->move_delay_value_next;
12923 player->move_delay_value_next = -1;
12927 (dx > 0 || dy > 0 ? -1 : 1) * (TILEX - TILEX / player->move_delay_value);
12929 player->step_counter++;
12931 PlayerVisit[jx][jy] = FrameCounter;
12933 player->is_moving = TRUE;
12936 // should better be called in MovePlayer(), but this breaks some tapes
12937 ScrollPlayer(player, SCROLL_INIT);
12943 boolean MovePlayer(struct PlayerInfo *player, int dx, int dy)
12945 int jx = player->jx, jy = player->jy;
12946 int old_jx = jx, old_jy = jy;
12947 int moved = MP_NO_ACTION;
12949 if (!player->active)
12954 if (player->MovPos == 0)
12956 player->is_moving = FALSE;
12957 player->is_digging = FALSE;
12958 player->is_collecting = FALSE;
12959 player->is_snapping = FALSE;
12960 player->is_pushing = FALSE;
12966 if (player->move_delay > 0)
12969 player->move_delay = -1; // set to "uninitialized" value
12971 // store if player is automatically moved to next field
12972 player->is_auto_moving = (player->programmed_action != MV_NONE);
12974 // remove the last programmed player action
12975 player->programmed_action = 0;
12977 if (player->MovPos)
12979 // should only happen if pre-1.2 tape recordings are played
12980 // this is only for backward compatibility
12982 int original_move_delay_value = player->move_delay_value;
12985 Debug("game:playing:MovePlayer",
12986 "THIS SHOULD ONLY HAPPEN WITH PRE-1.2 LEVEL TAPES. [%d]",
12990 // scroll remaining steps with finest movement resolution
12991 player->move_delay_value = MOVE_DELAY_NORMAL_SPEED;
12993 while (player->MovPos)
12995 ScrollPlayer(player, SCROLL_GO_ON);
12996 ScrollScreen(NULL, SCROLL_GO_ON);
12998 AdvanceFrameAndPlayerCounters(player->index_nr);
13001 BackToFront_WithFrameDelay(0);
13004 player->move_delay_value = original_move_delay_value;
13007 player->is_active = FALSE;
13009 if (player->last_move_dir & MV_HORIZONTAL)
13011 if (!(moved |= MovePlayerOneStep(player, 0, dy, dx, dy)))
13012 moved |= MovePlayerOneStep(player, dx, 0, dx, dy);
13016 if (!(moved |= MovePlayerOneStep(player, dx, 0, dx, dy)))
13017 moved |= MovePlayerOneStep(player, 0, dy, dx, dy);
13020 if (!moved && !player->is_active)
13022 player->is_moving = FALSE;
13023 player->is_digging = FALSE;
13024 player->is_collecting = FALSE;
13025 player->is_snapping = FALSE;
13026 player->is_pushing = FALSE;
13032 if (moved & MP_MOVING && !ScreenMovPos &&
13033 (player->index_nr == game.centered_player_nr ||
13034 game.centered_player_nr == -1))
13036 int old_scroll_x = scroll_x, old_scroll_y = scroll_y;
13038 if (!IN_VIS_FIELD(SCREENX(jx), SCREENY(jy)))
13040 // actual player has left the screen -- scroll in that direction
13041 if (jx != old_jx) // player has moved horizontally
13042 scroll_x += (jx - old_jx);
13043 else // player has moved vertically
13044 scroll_y += (jy - old_jy);
13048 int offset_raw = game.scroll_delay_value;
13050 if (jx != old_jx) // player has moved horizontally
13052 int offset = MIN(offset_raw, (SCR_FIELDX - 2) / 2);
13053 int offset_x = offset * (player->MovDir == MV_LEFT ? +1 : -1);
13054 int new_scroll_x = jx - MIDPOSX + offset_x;
13056 if ((player->MovDir == MV_LEFT && scroll_x > new_scroll_x) ||
13057 (player->MovDir == MV_RIGHT && scroll_x < new_scroll_x))
13058 scroll_x = new_scroll_x;
13060 // don't scroll over playfield boundaries
13061 scroll_x = MIN(MAX(SBX_Left, scroll_x), SBX_Right);
13063 // don't scroll more than one field at a time
13064 scroll_x = old_scroll_x + SIGN(scroll_x - old_scroll_x);
13066 // don't scroll against the player's moving direction
13067 if ((player->MovDir == MV_LEFT && scroll_x > old_scroll_x) ||
13068 (player->MovDir == MV_RIGHT && scroll_x < old_scroll_x))
13069 scroll_x = old_scroll_x;
13071 else // player has moved vertically
13073 int offset = MIN(offset_raw, (SCR_FIELDY - 2) / 2);
13074 int offset_y = offset * (player->MovDir == MV_UP ? +1 : -1);
13075 int new_scroll_y = jy - MIDPOSY + offset_y;
13077 if ((player->MovDir == MV_UP && scroll_y > new_scroll_y) ||
13078 (player->MovDir == MV_DOWN && scroll_y < new_scroll_y))
13079 scroll_y = new_scroll_y;
13081 // don't scroll over playfield boundaries
13082 scroll_y = MIN(MAX(SBY_Upper, scroll_y), SBY_Lower);
13084 // don't scroll more than one field at a time
13085 scroll_y = old_scroll_y + SIGN(scroll_y - old_scroll_y);
13087 // don't scroll against the player's moving direction
13088 if ((player->MovDir == MV_UP && scroll_y > old_scroll_y) ||
13089 (player->MovDir == MV_DOWN && scroll_y < old_scroll_y))
13090 scroll_y = old_scroll_y;
13094 if (scroll_x != old_scroll_x || scroll_y != old_scroll_y)
13096 if (!network.enabled && game.centered_player_nr == -1 &&
13097 !AllPlayersInVisibleScreen())
13099 scroll_x = old_scroll_x;
13100 scroll_y = old_scroll_y;
13104 ScrollScreen(player, SCROLL_INIT);
13105 ScrollLevel(old_scroll_x - scroll_x, old_scroll_y - scroll_y);
13110 player->StepFrame = 0;
13112 if (moved & MP_MOVING)
13114 if (old_jx != jx && old_jy == jy)
13115 player->MovDir = (old_jx < jx ? MV_RIGHT : MV_LEFT);
13116 else if (old_jx == jx && old_jy != jy)
13117 player->MovDir = (old_jy < jy ? MV_DOWN : MV_UP);
13119 TEST_DrawLevelField(jx, jy); // for "crumbled sand"
13121 player->last_move_dir = player->MovDir;
13122 player->is_moving = TRUE;
13123 player->is_snapping = FALSE;
13124 player->is_switching = FALSE;
13125 player->is_dropping = FALSE;
13126 player->is_dropping_pressed = FALSE;
13127 player->drop_pressed_delay = 0;
13130 // should better be called here than above, but this breaks some tapes
13131 ScrollPlayer(player, SCROLL_INIT);
13136 CheckGravityMovementWhenNotMoving(player);
13138 player->is_moving = FALSE;
13140 /* at this point, the player is allowed to move, but cannot move right now
13141 (e.g. because of something blocking the way) -- ensure that the player
13142 is also allowed to move in the next frame (in old versions before 3.1.1,
13143 the player was forced to wait again for eight frames before next try) */
13145 if (game.engine_version >= VERSION_IDENT(3,1,1,0))
13146 player->move_delay = 0; // allow direct movement in the next frame
13149 if (player->move_delay == -1) // not yet initialized by DigField()
13150 player->move_delay = player->move_delay_value;
13152 if (game.engine_version < VERSION_IDENT(3,0,7,0))
13154 TestIfPlayerTouchesBadThing(jx, jy);
13155 TestIfPlayerTouchesCustomElement(jx, jy);
13158 if (!player->active)
13159 RemovePlayer(player);
13164 void ScrollPlayer(struct PlayerInfo *player, int mode)
13166 int jx = player->jx, jy = player->jy;
13167 int last_jx = player->last_jx, last_jy = player->last_jy;
13168 int move_stepsize = TILEX / player->move_delay_value;
13170 if (!player->active)
13173 if (player->MovPos == 0 && mode == SCROLL_GO_ON) // player not moving
13176 if (mode == SCROLL_INIT)
13178 player->actual_frame_counter = FrameCounter;
13179 player->GfxPos = move_stepsize * (player->MovPos / move_stepsize);
13181 if ((player->block_last_field || player->block_delay_adjustment > 0) &&
13182 Tile[last_jx][last_jy] == EL_EMPTY)
13184 int last_field_block_delay = 0; // start with no blocking at all
13185 int block_delay_adjustment = player->block_delay_adjustment;
13187 // if player blocks last field, add delay for exactly one move
13188 if (player->block_last_field)
13190 last_field_block_delay += player->move_delay_value;
13192 // when blocking enabled, prevent moving up despite gravity
13193 if (player->gravity && player->MovDir == MV_UP)
13194 block_delay_adjustment = -1;
13197 // add block delay adjustment (also possible when not blocking)
13198 last_field_block_delay += block_delay_adjustment;
13200 Tile[last_jx][last_jy] = EL_PLAYER_IS_LEAVING;
13201 MovDelay[last_jx][last_jy] = last_field_block_delay + 1;
13204 if (player->MovPos != 0) // player has not yet reached destination
13207 else if (!FrameReached(&player->actual_frame_counter, 1))
13210 if (player->MovPos != 0)
13212 player->MovPos += (player->MovPos > 0 ? -1 : 1) * move_stepsize;
13213 player->GfxPos = move_stepsize * (player->MovPos / move_stepsize);
13215 // before DrawPlayer() to draw correct player graphic for this case
13216 if (player->MovPos == 0)
13217 CheckGravityMovement(player);
13220 if (player->MovPos == 0) // player reached destination field
13222 if (player->move_delay_reset_counter > 0)
13224 player->move_delay_reset_counter--;
13226 if (player->move_delay_reset_counter == 0)
13228 // continue with normal speed after quickly moving through gate
13229 HALVE_PLAYER_SPEED(player);
13231 // be able to make the next move without delay
13232 player->move_delay = 0;
13236 player->last_jx = jx;
13237 player->last_jy = jy;
13239 if (Tile[jx][jy] == EL_EXIT_OPEN ||
13240 Tile[jx][jy] == EL_EM_EXIT_OPEN ||
13241 Tile[jx][jy] == EL_EM_EXIT_OPENING ||
13242 Tile[jx][jy] == EL_STEEL_EXIT_OPEN ||
13243 Tile[jx][jy] == EL_EM_STEEL_EXIT_OPEN ||
13244 Tile[jx][jy] == EL_EM_STEEL_EXIT_OPENING ||
13245 Tile[jx][jy] == EL_SP_EXIT_OPEN ||
13246 Tile[jx][jy] == EL_SP_EXIT_OPENING) // <-- special case
13248 ExitPlayer(player);
13250 if (game.players_still_needed == 0 &&
13251 (game.friends_still_needed == 0 ||
13252 IS_SP_ELEMENT(Tile[jx][jy])))
13256 // this breaks one level: "machine", level 000
13258 int move_direction = player->MovDir;
13259 int enter_side = MV_DIR_OPPOSITE(move_direction);
13260 int leave_side = move_direction;
13261 int old_jx = last_jx;
13262 int old_jy = last_jy;
13263 int old_element = Tile[old_jx][old_jy];
13264 int new_element = Tile[jx][jy];
13266 if (IS_CUSTOM_ELEMENT(old_element))
13267 CheckElementChangeByPlayer(old_jx, old_jy, old_element,
13269 player->index_bit, leave_side);
13271 CheckTriggeredElementChangeByPlayer(old_jx, old_jy, old_element,
13272 CE_PLAYER_LEAVES_X,
13273 player->index_bit, leave_side);
13275 if (IS_CUSTOM_ELEMENT(new_element))
13276 CheckElementChangeByPlayer(jx, jy, new_element, CE_ENTERED_BY_PLAYER,
13277 player->index_bit, enter_side);
13279 CheckTriggeredElementChangeByPlayer(jx, jy, new_element,
13280 CE_PLAYER_ENTERS_X,
13281 player->index_bit, enter_side);
13283 CheckTriggeredElementChangeBySide(jx, jy, player->initial_element,
13284 CE_MOVE_OF_X, move_direction);
13287 if (game.engine_version >= VERSION_IDENT(3,0,7,0))
13289 TestIfPlayerTouchesBadThing(jx, jy);
13290 TestIfPlayerTouchesCustomElement(jx, jy);
13292 /* needed because pushed element has not yet reached its destination,
13293 so it would trigger a change event at its previous field location */
13294 if (!player->is_pushing)
13295 TestIfElementTouchesCustomElement(jx, jy); // for empty space
13297 if (level.finish_dig_collect &&
13298 (player->is_digging || player->is_collecting))
13300 int last_element = player->last_removed_element;
13301 int move_direction = player->MovDir;
13302 int enter_side = MV_DIR_OPPOSITE(move_direction);
13303 int change_event = (player->is_digging ? CE_PLAYER_DIGS_X :
13304 CE_PLAYER_COLLECTS_X);
13306 CheckTriggeredElementChangeByPlayer(jx, jy, last_element, change_event,
13307 player->index_bit, enter_side);
13309 player->last_removed_element = EL_UNDEFINED;
13312 if (!player->active)
13313 RemovePlayer(player);
13316 if (level.use_step_counter)
13317 CheckLevelTime_StepCounter();
13319 if (tape.single_step && tape.recording && !tape.pausing &&
13320 !player->programmed_action)
13321 TapeTogglePause(TAPE_TOGGLE_AUTOMATIC);
13323 if (!player->programmed_action)
13324 CheckSaveEngineSnapshot(player);
13328 void ScrollScreen(struct PlayerInfo *player, int mode)
13330 static unsigned int screen_frame_counter = 0;
13332 if (mode == SCROLL_INIT)
13334 // set scrolling step size according to actual player's moving speed
13335 ScrollStepSize = TILEX / player->move_delay_value;
13337 screen_frame_counter = FrameCounter;
13338 ScreenMovDir = player->MovDir;
13339 ScreenMovPos = player->MovPos;
13340 ScreenGfxPos = ScrollStepSize * (ScreenMovPos / ScrollStepSize);
13343 else if (!FrameReached(&screen_frame_counter, 1))
13348 ScreenMovPos += (ScreenMovPos > 0 ? -1 : 1) * ScrollStepSize;
13349 ScreenGfxPos = ScrollStepSize * (ScreenMovPos / ScrollStepSize);
13350 redraw_mask |= REDRAW_FIELD;
13353 ScreenMovDir = MV_NONE;
13356 void CheckNextToConditions(int x, int y)
13358 int element = Tile[x][y];
13360 if (IS_PLAYER(x, y))
13361 TestIfPlayerNextToCustomElement(x, y);
13363 if (CAN_CHANGE_OR_HAS_ACTION(element) &&
13364 HAS_ANY_CHANGE_EVENT(element, CE_NEXT_TO_X))
13365 TestIfElementNextToCustomElement(x, y);
13368 void TestIfPlayerNextToCustomElement(int x, int y)
13370 static int xy[4][2] =
13377 static int trigger_sides[4][2] =
13379 // center side border side
13380 { CH_SIDE_TOP, CH_SIDE_BOTTOM }, // check top
13381 { CH_SIDE_LEFT, CH_SIDE_RIGHT }, // check left
13382 { CH_SIDE_RIGHT, CH_SIDE_LEFT }, // check right
13383 { CH_SIDE_BOTTOM, CH_SIDE_TOP } // check bottom
13387 if (!IS_PLAYER(x, y))
13390 struct PlayerInfo *player = PLAYERINFO(x, y);
13392 if (player->is_moving)
13395 for (i = 0; i < NUM_DIRECTIONS; i++)
13397 int xx = x + xy[i][0];
13398 int yy = y + xy[i][1];
13399 int border_side = trigger_sides[i][1];
13400 int border_element;
13402 if (!IN_LEV_FIELD(xx, yy))
13405 if (IS_MOVING(xx, yy) || IS_BLOCKED(xx, yy))
13406 continue; // center and border element not connected
13408 border_element = Tile[xx][yy];
13410 CheckElementChangeByPlayer(xx, yy, border_element, CE_NEXT_TO_PLAYER,
13411 player->index_bit, border_side);
13412 CheckTriggeredElementChangeByPlayer(xx, yy, border_element,
13413 CE_PLAYER_NEXT_TO_X,
13414 player->index_bit, border_side);
13416 /* use player element that is initially defined in the level playfield,
13417 not the player element that corresponds to the runtime player number
13418 (example: a level that contains EL_PLAYER_3 as the only player would
13419 incorrectly give EL_PLAYER_1 for "player->element_nr") */
13421 CheckElementChangeBySide(xx, yy, border_element, player->initial_element,
13422 CE_NEXT_TO_X, border_side);
13426 void TestIfPlayerTouchesCustomElement(int x, int y)
13428 static int xy[4][2] =
13435 static int trigger_sides[4][2] =
13437 // center side border side
13438 { CH_SIDE_TOP, CH_SIDE_BOTTOM }, // check top
13439 { CH_SIDE_LEFT, CH_SIDE_RIGHT }, // check left
13440 { CH_SIDE_RIGHT, CH_SIDE_LEFT }, // check right
13441 { CH_SIDE_BOTTOM, CH_SIDE_TOP } // check bottom
13443 static int touch_dir[4] =
13445 MV_LEFT | MV_RIGHT,
13450 int center_element = Tile[x][y]; // should always be non-moving!
13453 for (i = 0; i < NUM_DIRECTIONS; i++)
13455 int xx = x + xy[i][0];
13456 int yy = y + xy[i][1];
13457 int center_side = trigger_sides[i][0];
13458 int border_side = trigger_sides[i][1];
13459 int border_element;
13461 if (!IN_LEV_FIELD(xx, yy))
13464 if (IS_PLAYER(x, y)) // player found at center element
13466 struct PlayerInfo *player = PLAYERINFO(x, y);
13468 if (game.engine_version < VERSION_IDENT(3,0,7,0))
13469 border_element = Tile[xx][yy]; // may be moving!
13470 else if (!IS_MOVING(xx, yy) && !IS_BLOCKED(xx, yy))
13471 border_element = Tile[xx][yy];
13472 else if (MovDir[xx][yy] & touch_dir[i]) // elements are touching
13473 border_element = MovingOrBlocked2Element(xx, yy);
13475 continue; // center and border element do not touch
13477 CheckElementChangeByPlayer(xx, yy, border_element, CE_TOUCHED_BY_PLAYER,
13478 player->index_bit, border_side);
13479 CheckTriggeredElementChangeByPlayer(xx, yy, border_element,
13480 CE_PLAYER_TOUCHES_X,
13481 player->index_bit, border_side);
13484 /* use player element that is initially defined in the level playfield,
13485 not the player element that corresponds to the runtime player number
13486 (example: a level that contains EL_PLAYER_3 as the only player would
13487 incorrectly give EL_PLAYER_1 for "player->element_nr") */
13488 int player_element = PLAYERINFO(x, y)->initial_element;
13490 CheckElementChangeBySide(xx, yy, border_element, player_element,
13491 CE_TOUCHING_X, border_side);
13494 else if (IS_PLAYER(xx, yy)) // player found at border element
13496 struct PlayerInfo *player = PLAYERINFO(xx, yy);
13498 if (game.engine_version >= VERSION_IDENT(3,0,7,0))
13500 if (player->MovPos != 0 && !(player->MovDir & touch_dir[i]))
13501 continue; // center and border element do not touch
13504 CheckElementChangeByPlayer(x, y, center_element, CE_TOUCHED_BY_PLAYER,
13505 player->index_bit, center_side);
13506 CheckTriggeredElementChangeByPlayer(x, y, center_element,
13507 CE_PLAYER_TOUCHES_X,
13508 player->index_bit, center_side);
13511 /* use player element that is initially defined in the level playfield,
13512 not the player element that corresponds to the runtime player number
13513 (example: a level that contains EL_PLAYER_3 as the only player would
13514 incorrectly give EL_PLAYER_1 for "player->element_nr") */
13515 int player_element = PLAYERINFO(xx, yy)->initial_element;
13517 CheckElementChangeBySide(x, y, center_element, player_element,
13518 CE_TOUCHING_X, center_side);
13526 void TestIfElementNextToCustomElement(int x, int y)
13528 static int xy[4][2] =
13535 static int trigger_sides[4][2] =
13537 // center side border side
13538 { CH_SIDE_TOP, CH_SIDE_BOTTOM }, // check top
13539 { CH_SIDE_LEFT, CH_SIDE_RIGHT }, // check left
13540 { CH_SIDE_RIGHT, CH_SIDE_LEFT }, // check right
13541 { CH_SIDE_BOTTOM, CH_SIDE_TOP } // check bottom
13543 int center_element = Tile[x][y]; // should always be non-moving!
13546 if (IS_MOVING(x, y) || IS_BLOCKED(x, y))
13549 for (i = 0; i < NUM_DIRECTIONS; i++)
13551 int xx = x + xy[i][0];
13552 int yy = y + xy[i][1];
13553 int border_side = trigger_sides[i][1];
13554 int border_element;
13556 if (!IN_LEV_FIELD(xx, yy))
13559 if (IS_MOVING(xx, yy) || IS_BLOCKED(xx, yy))
13560 continue; // center and border element not connected
13562 border_element = Tile[xx][yy];
13564 // check for change of center element (but change it only once)
13565 if (CheckElementChangeBySide(x, y, center_element, border_element,
13566 CE_NEXT_TO_X, border_side))
13571 void TestIfElementTouchesCustomElement(int x, int y)
13573 static int xy[4][2] =
13580 static int trigger_sides[4][2] =
13582 // center side border side
13583 { CH_SIDE_TOP, CH_SIDE_BOTTOM }, // check top
13584 { CH_SIDE_LEFT, CH_SIDE_RIGHT }, // check left
13585 { CH_SIDE_RIGHT, CH_SIDE_LEFT }, // check right
13586 { CH_SIDE_BOTTOM, CH_SIDE_TOP } // check bottom
13588 static int touch_dir[4] =
13590 MV_LEFT | MV_RIGHT,
13595 boolean change_center_element = FALSE;
13596 int center_element = Tile[x][y]; // should always be non-moving!
13597 int border_element_old[NUM_DIRECTIONS];
13600 for (i = 0; i < NUM_DIRECTIONS; i++)
13602 int xx = x + xy[i][0];
13603 int yy = y + xy[i][1];
13604 int border_element;
13606 border_element_old[i] = -1;
13608 if (!IN_LEV_FIELD(xx, yy))
13611 if (game.engine_version < VERSION_IDENT(3,0,7,0))
13612 border_element = Tile[xx][yy]; // may be moving!
13613 else if (!IS_MOVING(xx, yy) && !IS_BLOCKED(xx, yy))
13614 border_element = Tile[xx][yy];
13615 else if (MovDir[xx][yy] & touch_dir[i]) // elements are touching
13616 border_element = MovingOrBlocked2Element(xx, yy);
13618 continue; // center and border element do not touch
13620 border_element_old[i] = border_element;
13623 for (i = 0; i < NUM_DIRECTIONS; i++)
13625 int xx = x + xy[i][0];
13626 int yy = y + xy[i][1];
13627 int center_side = trigger_sides[i][0];
13628 int border_element = border_element_old[i];
13630 if (border_element == -1)
13633 // check for change of border element
13634 CheckElementChangeBySide(xx, yy, border_element, center_element,
13635 CE_TOUCHING_X, center_side);
13637 // (center element cannot be player, so we dont have to check this here)
13640 for (i = 0; i < NUM_DIRECTIONS; i++)
13642 int xx = x + xy[i][0];
13643 int yy = y + xy[i][1];
13644 int border_side = trigger_sides[i][1];
13645 int border_element = border_element_old[i];
13647 if (border_element == -1)
13650 // check for change of center element (but change it only once)
13651 if (!change_center_element)
13652 change_center_element =
13653 CheckElementChangeBySide(x, y, center_element, border_element,
13654 CE_TOUCHING_X, border_side);
13656 if (IS_PLAYER(xx, yy))
13658 /* use player element that is initially defined in the level playfield,
13659 not the player element that corresponds to the runtime player number
13660 (example: a level that contains EL_PLAYER_3 as the only player would
13661 incorrectly give EL_PLAYER_1 for "player->element_nr") */
13662 int player_element = PLAYERINFO(xx, yy)->initial_element;
13664 CheckElementChangeBySide(x, y, center_element, player_element,
13665 CE_TOUCHING_X, border_side);
13670 void TestIfElementHitsCustomElement(int x, int y, int direction)
13672 int dx = (direction == MV_LEFT ? -1 : direction == MV_RIGHT ? +1 : 0);
13673 int dy = (direction == MV_UP ? -1 : direction == MV_DOWN ? +1 : 0);
13674 int hitx = x + dx, hity = y + dy;
13675 int hitting_element = Tile[x][y];
13676 int touched_element;
13678 if (IN_LEV_FIELD(hitx, hity) && IS_FREE(hitx, hity))
13681 touched_element = (IN_LEV_FIELD(hitx, hity) ?
13682 MovingOrBlocked2Element(hitx, hity) : EL_STEELWALL);
13684 if (IN_LEV_FIELD(hitx, hity))
13686 int opposite_direction = MV_DIR_OPPOSITE(direction);
13687 int hitting_side = direction;
13688 int touched_side = opposite_direction;
13689 boolean object_hit = (!IS_MOVING(hitx, hity) ||
13690 MovDir[hitx][hity] != direction ||
13691 ABS(MovPos[hitx][hity]) <= TILEY / 2);
13697 CheckElementChangeBySide(x, y, hitting_element, touched_element,
13698 CE_HITTING_X, touched_side);
13700 CheckElementChangeBySide(hitx, hity, touched_element, hitting_element,
13701 CE_HIT_BY_X, hitting_side);
13703 CheckElementChangeBySide(hitx, hity, touched_element, hitting_element,
13704 CE_HIT_BY_SOMETHING, opposite_direction);
13706 if (IS_PLAYER(hitx, hity))
13708 /* use player element that is initially defined in the level playfield,
13709 not the player element that corresponds to the runtime player number
13710 (example: a level that contains EL_PLAYER_3 as the only player would
13711 incorrectly give EL_PLAYER_1 for "player->element_nr") */
13712 int player_element = PLAYERINFO(hitx, hity)->initial_element;
13714 CheckElementChangeBySide(x, y, hitting_element, player_element,
13715 CE_HITTING_X, touched_side);
13720 // "hitting something" is also true when hitting the playfield border
13721 CheckElementChangeBySide(x, y, hitting_element, touched_element,
13722 CE_HITTING_SOMETHING, direction);
13725 void TestIfGoodThingHitsBadThing(int good_x, int good_y, int good_move_dir)
13727 int i, kill_x = -1, kill_y = -1;
13729 int bad_element = -1;
13730 static int test_xy[4][2] =
13737 static int test_dir[4] =
13745 for (i = 0; i < NUM_DIRECTIONS; i++)
13747 int test_x, test_y, test_move_dir, test_element;
13749 test_x = good_x + test_xy[i][0];
13750 test_y = good_y + test_xy[i][1];
13752 if (!IN_LEV_FIELD(test_x, test_y))
13756 (IS_MOVING(test_x, test_y) ? MovDir[test_x][test_y] : MV_NONE);
13758 test_element = MovingOrBlocked2ElementIfNotLeaving(test_x, test_y);
13760 /* 1st case: good thing is moving towards DONT_RUN_INTO style bad thing;
13761 2nd case: DONT_TOUCH style bad thing does not move away from good thing
13763 if ((DONT_RUN_INTO(test_element) && good_move_dir == test_dir[i]) ||
13764 (DONT_TOUCH(test_element) && test_move_dir != test_dir[i]))
13768 bad_element = test_element;
13774 if (kill_x != -1 || kill_y != -1)
13776 if (IS_PLAYER(good_x, good_y))
13778 struct PlayerInfo *player = PLAYERINFO(good_x, good_y);
13780 if (player->shield_deadly_time_left > 0 &&
13781 !IS_INDESTRUCTIBLE(bad_element))
13782 Bang(kill_x, kill_y);
13783 else if (!PLAYER_ENEMY_PROTECTED(good_x, good_y))
13784 KillPlayer(player);
13787 Bang(good_x, good_y);
13791 void TestIfBadThingHitsGoodThing(int bad_x, int bad_y, int bad_move_dir)
13793 int i, kill_x = -1, kill_y = -1;
13794 int bad_element = Tile[bad_x][bad_y];
13795 static int test_xy[4][2] =
13802 static int touch_dir[4] =
13804 MV_LEFT | MV_RIGHT,
13809 static int test_dir[4] =
13817 if (bad_element == EL_EXPLOSION) // skip just exploding bad things
13820 for (i = 0; i < NUM_DIRECTIONS; i++)
13822 int test_x, test_y, test_move_dir, test_element;
13824 test_x = bad_x + test_xy[i][0];
13825 test_y = bad_y + test_xy[i][1];
13827 if (!IN_LEV_FIELD(test_x, test_y))
13831 (IS_MOVING(test_x, test_y) ? MovDir[test_x][test_y] : MV_NONE);
13833 test_element = Tile[test_x][test_y];
13835 /* 1st case: good thing is moving towards DONT_RUN_INTO style bad thing;
13836 2nd case: DONT_TOUCH style bad thing does not move away from good thing
13838 if ((DONT_RUN_INTO(bad_element) && bad_move_dir == test_dir[i]) ||
13839 (DONT_TOUCH(bad_element) && test_move_dir != test_dir[i]))
13841 // good thing is player or penguin that does not move away
13842 if (IS_PLAYER(test_x, test_y))
13844 struct PlayerInfo *player = PLAYERINFO(test_x, test_y);
13846 if (bad_element == EL_ROBOT && player->is_moving)
13847 continue; // robot does not kill player if he is moving
13849 if (game.engine_version >= VERSION_IDENT(3,0,7,0))
13851 if (player->MovPos != 0 && !(player->MovDir & touch_dir[i]))
13852 continue; // center and border element do not touch
13860 else if (test_element == EL_PENGUIN)
13870 if (kill_x != -1 || kill_y != -1)
13872 if (IS_PLAYER(kill_x, kill_y))
13874 struct PlayerInfo *player = PLAYERINFO(kill_x, kill_y);
13876 if (player->shield_deadly_time_left > 0 &&
13877 !IS_INDESTRUCTIBLE(bad_element))
13878 Bang(bad_x, bad_y);
13879 else if (!PLAYER_ENEMY_PROTECTED(kill_x, kill_y))
13880 KillPlayer(player);
13883 Bang(kill_x, kill_y);
13887 void TestIfGoodThingGetsHitByBadThing(int bad_x, int bad_y, int bad_move_dir)
13889 int bad_element = Tile[bad_x][bad_y];
13890 int dx = (bad_move_dir == MV_LEFT ? -1 : bad_move_dir == MV_RIGHT ? +1 : 0);
13891 int dy = (bad_move_dir == MV_UP ? -1 : bad_move_dir == MV_DOWN ? +1 : 0);
13892 int test_x = bad_x + dx, test_y = bad_y + dy;
13893 int test_move_dir, test_element;
13894 int kill_x = -1, kill_y = -1;
13896 if (!IN_LEV_FIELD(test_x, test_y))
13900 (IS_MOVING(test_x, test_y) ? MovDir[test_x][test_y] : MV_NONE);
13902 test_element = Tile[test_x][test_y];
13904 if (test_move_dir != bad_move_dir)
13906 // good thing can be player or penguin that does not move away
13907 if (IS_PLAYER(test_x, test_y))
13909 struct PlayerInfo *player = PLAYERINFO(test_x, test_y);
13911 /* (note: in comparison to DONT_RUN_TO and DONT_TOUCH, also handle the
13912 player as being hit when he is moving towards the bad thing, because
13913 the "get hit by" condition would be lost after the player stops) */
13914 if (player->MovPos != 0 && player->MovDir == bad_move_dir)
13915 return; // player moves away from bad thing
13920 else if (test_element == EL_PENGUIN)
13927 if (kill_x != -1 || kill_y != -1)
13929 if (IS_PLAYER(kill_x, kill_y))
13931 struct PlayerInfo *player = PLAYERINFO(kill_x, kill_y);
13933 if (player->shield_deadly_time_left > 0 &&
13934 !IS_INDESTRUCTIBLE(bad_element))
13935 Bang(bad_x, bad_y);
13936 else if (!PLAYER_ENEMY_PROTECTED(kill_x, kill_y))
13937 KillPlayer(player);
13940 Bang(kill_x, kill_y);
13944 void TestIfPlayerTouchesBadThing(int x, int y)
13946 TestIfGoodThingHitsBadThing(x, y, MV_NONE);
13949 void TestIfPlayerRunsIntoBadThing(int x, int y, int move_dir)
13951 TestIfGoodThingHitsBadThing(x, y, move_dir);
13954 void TestIfBadThingTouchesPlayer(int x, int y)
13956 TestIfBadThingHitsGoodThing(x, y, MV_NONE);
13959 void TestIfBadThingRunsIntoPlayer(int x, int y, int move_dir)
13961 TestIfBadThingHitsGoodThing(x, y, move_dir);
13964 void TestIfFriendTouchesBadThing(int x, int y)
13966 TestIfGoodThingHitsBadThing(x, y, MV_NONE);
13969 void TestIfBadThingTouchesFriend(int x, int y)
13971 TestIfBadThingHitsGoodThing(x, y, MV_NONE);
13974 void TestIfBadThingTouchesOtherBadThing(int bad_x, int bad_y)
13976 int i, kill_x = bad_x, kill_y = bad_y;
13977 static int xy[4][2] =
13985 for (i = 0; i < NUM_DIRECTIONS; i++)
13989 x = bad_x + xy[i][0];
13990 y = bad_y + xy[i][1];
13991 if (!IN_LEV_FIELD(x, y))
13994 element = Tile[x][y];
13995 if (IS_AMOEBOID(element) || element == EL_GAME_OF_LIFE ||
13996 element == EL_AMOEBA_GROWING || element == EL_AMOEBA_DROP)
14004 if (kill_x != bad_x || kill_y != bad_y)
14005 Bang(bad_x, bad_y);
14008 void KillPlayer(struct PlayerInfo *player)
14010 int jx = player->jx, jy = player->jy;
14012 if (!player->active)
14016 Debug("game:playing:KillPlayer",
14017 "0: killed == %d, active == %d, reanimated == %d",
14018 player->killed, player->active, player->reanimated);
14021 /* the following code was introduced to prevent an infinite loop when calling
14023 -> CheckTriggeredElementChangeExt()
14024 -> ExecuteCustomElementAction()
14026 -> (infinitely repeating the above sequence of function calls)
14027 which occurs when killing the player while having a CE with the setting
14028 "kill player X when explosion of <player X>"; the solution using a new
14029 field "player->killed" was chosen for backwards compatibility, although
14030 clever use of the fields "player->active" etc. would probably also work */
14032 if (player->killed)
14036 player->killed = TRUE;
14038 // remove accessible field at the player's position
14039 Tile[jx][jy] = EL_EMPTY;
14041 // deactivate shield (else Bang()/Explode() would not work right)
14042 player->shield_normal_time_left = 0;
14043 player->shield_deadly_time_left = 0;
14046 Debug("game:playing:KillPlayer",
14047 "1: killed == %d, active == %d, reanimated == %d",
14048 player->killed, player->active, player->reanimated);
14054 Debug("game:playing:KillPlayer",
14055 "2: killed == %d, active == %d, reanimated == %d",
14056 player->killed, player->active, player->reanimated);
14059 if (player->reanimated) // killed player may have been reanimated
14060 player->killed = player->reanimated = FALSE;
14062 BuryPlayer(player);
14065 static void KillPlayerUnlessEnemyProtected(int x, int y)
14067 if (!PLAYER_ENEMY_PROTECTED(x, y))
14068 KillPlayer(PLAYERINFO(x, y));
14071 static void KillPlayerUnlessExplosionProtected(int x, int y)
14073 if (!PLAYER_EXPLOSION_PROTECTED(x, y))
14074 KillPlayer(PLAYERINFO(x, y));
14077 void BuryPlayer(struct PlayerInfo *player)
14079 int jx = player->jx, jy = player->jy;
14081 if (!player->active)
14084 PlayLevelSoundElementAction(jx, jy, player->artwork_element, ACTION_DYING);
14085 PlayLevelSound(jx, jy, SND_GAME_LOSING);
14087 RemovePlayer(player);
14089 player->buried = TRUE;
14091 if (game.all_players_gone)
14092 game.GameOver = TRUE;
14095 void RemovePlayer(struct PlayerInfo *player)
14097 int jx = player->jx, jy = player->jy;
14098 int i, found = FALSE;
14100 player->present = FALSE;
14101 player->active = FALSE;
14103 // required for some CE actions (even if the player is not active anymore)
14104 player->MovPos = 0;
14106 if (!ExplodeField[jx][jy])
14107 StorePlayer[jx][jy] = 0;
14109 if (player->is_moving)
14110 TEST_DrawLevelField(player->last_jx, player->last_jy);
14112 for (i = 0; i < MAX_PLAYERS; i++)
14113 if (stored_player[i].active)
14118 game.all_players_gone = TRUE;
14119 game.GameOver = TRUE;
14122 game.exit_x = game.robot_wheel_x = jx;
14123 game.exit_y = game.robot_wheel_y = jy;
14126 void ExitPlayer(struct PlayerInfo *player)
14128 DrawPlayer(player); // needed here only to cleanup last field
14129 RemovePlayer(player);
14131 if (game.players_still_needed > 0)
14132 game.players_still_needed--;
14135 static void SetFieldForSnapping(int x, int y, int element, int direction,
14136 int player_index_bit)
14138 struct ElementInfo *ei = &element_info[element];
14139 int direction_bit = MV_DIR_TO_BIT(direction);
14140 int graphic_snapping = ei->direction_graphic[ACTION_SNAPPING][direction_bit];
14141 int action = (graphic_snapping != IMG_EMPTY_SPACE ? ACTION_SNAPPING :
14142 IS_DIGGABLE(element) ? ACTION_DIGGING : ACTION_COLLECTING);
14144 Tile[x][y] = EL_ELEMENT_SNAPPING;
14145 MovDelay[x][y] = MOVE_DELAY_NORMAL_SPEED + 1 - 1;
14146 MovDir[x][y] = direction;
14147 Store[x][y] = element;
14148 Store2[x][y] = player_index_bit;
14150 ResetGfxAnimation(x, y);
14152 GfxElement[x][y] = element;
14153 GfxAction[x][y] = action;
14154 GfxDir[x][y] = direction;
14155 GfxFrame[x][y] = -1;
14158 static void TestFieldAfterSnapping(int x, int y, int element, int direction,
14159 int player_index_bit)
14161 TestIfElementTouchesCustomElement(x, y); // for empty space
14163 if (level.finish_dig_collect)
14165 int dig_side = MV_DIR_OPPOSITE(direction);
14166 int change_event = (IS_DIGGABLE(element) ? CE_PLAYER_DIGS_X :
14167 CE_PLAYER_COLLECTS_X);
14169 CheckTriggeredElementChangeByPlayer(x, y, element, change_event,
14170 player_index_bit, dig_side);
14171 CheckTriggeredElementChangeByPlayer(x, y, element, CE_PLAYER_SNAPS_X,
14172 player_index_bit, dig_side);
14177 =============================================================================
14178 checkDiagonalPushing()
14179 -----------------------------------------------------------------------------
14180 check if diagonal input device direction results in pushing of object
14181 (by checking if the alternative direction is walkable, diggable, ...)
14182 =============================================================================
14185 static boolean checkDiagonalPushing(struct PlayerInfo *player,
14186 int x, int y, int real_dx, int real_dy)
14188 int jx, jy, dx, dy, xx, yy;
14190 if (real_dx == 0 || real_dy == 0) // no diagonal direction => push
14193 // diagonal direction: check alternative direction
14198 xx = jx + (dx == 0 ? real_dx : 0);
14199 yy = jy + (dy == 0 ? real_dy : 0);
14201 return (!IN_LEV_FIELD(xx, yy) || IS_SOLID_FOR_PUSHING(Tile[xx][yy]));
14205 =============================================================================
14207 -----------------------------------------------------------------------------
14208 x, y: field next to player (non-diagonal) to try to dig to
14209 real_dx, real_dy: direction as read from input device (can be diagonal)
14210 =============================================================================
14213 static int DigField(struct PlayerInfo *player,
14214 int oldx, int oldy, int x, int y,
14215 int real_dx, int real_dy, int mode)
14217 boolean is_player = (IS_PLAYER(oldx, oldy) || mode != DF_DIG);
14218 boolean player_was_pushing = player->is_pushing;
14219 boolean player_can_move = (!player->cannot_move && mode != DF_SNAP);
14220 boolean player_can_move_or_snap = (!player->cannot_move || mode == DF_SNAP);
14221 int jx = oldx, jy = oldy;
14222 int dx = x - jx, dy = y - jy;
14223 int nextx = x + dx, nexty = y + dy;
14224 int move_direction = (dx == -1 ? MV_LEFT :
14225 dx == +1 ? MV_RIGHT :
14227 dy == +1 ? MV_DOWN : MV_NONE);
14228 int opposite_direction = MV_DIR_OPPOSITE(move_direction);
14229 int dig_side = MV_DIR_OPPOSITE(move_direction);
14230 int old_element = Tile[jx][jy];
14231 int element = MovingOrBlocked2ElementIfNotLeaving(x, y);
14234 if (is_player) // function can also be called by EL_PENGUIN
14236 if (player->MovPos == 0)
14238 player->is_digging = FALSE;
14239 player->is_collecting = FALSE;
14242 if (player->MovPos == 0) // last pushing move finished
14243 player->is_pushing = FALSE;
14245 if (mode == DF_NO_PUSH) // player just stopped pushing
14247 player->is_switching = FALSE;
14248 player->push_delay = -1;
14250 return MP_NO_ACTION;
14253 if (IS_TUBE(Back[jx][jy]) && game.engine_version >= VERSION_IDENT(2,2,0,0))
14254 old_element = Back[jx][jy];
14256 // in case of element dropped at player position, check background
14257 else if (Back[jx][jy] != EL_EMPTY &&
14258 game.engine_version >= VERSION_IDENT(2,2,0,0))
14259 old_element = Back[jx][jy];
14261 if (IS_WALKABLE(old_element) && !ACCESS_FROM(old_element, move_direction))
14262 return MP_NO_ACTION; // field has no opening in this direction
14264 if (IS_PASSABLE(old_element) && !ACCESS_FROM(old_element,opposite_direction))
14265 return MP_NO_ACTION; // field has no opening in this direction
14267 if (player_can_move && element == EL_ACID && move_direction == MV_DOWN)
14271 Tile[jx][jy] = player->artwork_element;
14272 InitMovingField(jx, jy, MV_DOWN);
14273 Store[jx][jy] = EL_ACID;
14274 ContinueMoving(jx, jy);
14275 BuryPlayer(player);
14277 return MP_DONT_RUN_INTO;
14280 if (player_can_move && DONT_RUN_INTO(element))
14282 TestIfPlayerRunsIntoBadThing(jx, jy, player->MovDir);
14284 return MP_DONT_RUN_INTO;
14287 if (IS_MOVING(x, y) || IS_PLAYER(x, y))
14288 return MP_NO_ACTION;
14290 collect_count = element_info[element].collect_count_initial;
14292 if (!is_player && !IS_COLLECTIBLE(element)) // penguin cannot collect it
14293 return MP_NO_ACTION;
14295 if (game.engine_version < VERSION_IDENT(2,2,0,0))
14296 player_can_move = player_can_move_or_snap;
14298 if (mode == DF_SNAP && !IS_SNAPPABLE(element) &&
14299 game.engine_version >= VERSION_IDENT(2,2,0,0))
14301 CheckElementChangeByPlayer(x, y, element, CE_SNAPPED_BY_PLAYER,
14302 player->index_bit, dig_side);
14303 CheckTriggeredElementChangeByPlayer(x, y, element, CE_PLAYER_SNAPS_X,
14304 player->index_bit, dig_side);
14306 if (element == EL_DC_LANDMINE)
14309 if (Tile[x][y] != element) // field changed by snapping
14312 return MP_NO_ACTION;
14315 if (player->gravity && is_player && !player->is_auto_moving &&
14316 canFallDown(player) && move_direction != MV_DOWN &&
14317 !canMoveToValidFieldWithGravity(jx, jy, move_direction))
14318 return MP_NO_ACTION; // player cannot walk here due to gravity
14320 if (player_can_move &&
14321 IS_WALKABLE(element) && ACCESS_FROM(element, opposite_direction))
14323 int sound_element = SND_ELEMENT(element);
14324 int sound_action = ACTION_WALKING;
14326 if (IS_RND_GATE(element))
14328 if (!player->key[RND_GATE_NR(element)])
14329 return MP_NO_ACTION;
14331 else if (IS_RND_GATE_GRAY(element))
14333 if (!player->key[RND_GATE_GRAY_NR(element)])
14334 return MP_NO_ACTION;
14336 else if (IS_RND_GATE_GRAY_ACTIVE(element))
14338 if (!player->key[RND_GATE_GRAY_ACTIVE_NR(element)])
14339 return MP_NO_ACTION;
14341 else if (element == EL_EXIT_OPEN ||
14342 element == EL_EM_EXIT_OPEN ||
14343 element == EL_EM_EXIT_OPENING ||
14344 element == EL_STEEL_EXIT_OPEN ||
14345 element == EL_EM_STEEL_EXIT_OPEN ||
14346 element == EL_EM_STEEL_EXIT_OPENING ||
14347 element == EL_SP_EXIT_OPEN ||
14348 element == EL_SP_EXIT_OPENING)
14350 sound_action = ACTION_PASSING; // player is passing exit
14352 else if (element == EL_EMPTY)
14354 sound_action = ACTION_MOVING; // nothing to walk on
14357 // play sound from background or player, whatever is available
14358 if (element_info[sound_element].sound[sound_action] != SND_UNDEFINED)
14359 PlayLevelSoundElementAction(x, y, sound_element, sound_action);
14361 PlayLevelSoundElementAction(x, y, player->artwork_element, sound_action);
14363 else if (player_can_move &&
14364 IS_PASSABLE(element) && canPassField(x, y, move_direction))
14366 if (!ACCESS_FROM(element, opposite_direction))
14367 return MP_NO_ACTION; // field not accessible from this direction
14369 if (CAN_MOVE(element)) // only fixed elements can be passed!
14370 return MP_NO_ACTION;
14372 if (IS_EM_GATE(element))
14374 if (!player->key[EM_GATE_NR(element)])
14375 return MP_NO_ACTION;
14377 else if (IS_EM_GATE_GRAY(element))
14379 if (!player->key[EM_GATE_GRAY_NR(element)])
14380 return MP_NO_ACTION;
14382 else if (IS_EM_GATE_GRAY_ACTIVE(element))
14384 if (!player->key[EM_GATE_GRAY_ACTIVE_NR(element)])
14385 return MP_NO_ACTION;
14387 else if (IS_EMC_GATE(element))
14389 if (!player->key[EMC_GATE_NR(element)])
14390 return MP_NO_ACTION;
14392 else if (IS_EMC_GATE_GRAY(element))
14394 if (!player->key[EMC_GATE_GRAY_NR(element)])
14395 return MP_NO_ACTION;
14397 else if (IS_EMC_GATE_GRAY_ACTIVE(element))
14399 if (!player->key[EMC_GATE_GRAY_ACTIVE_NR(element)])
14400 return MP_NO_ACTION;
14402 else if (element == EL_DC_GATE_WHITE ||
14403 element == EL_DC_GATE_WHITE_GRAY ||
14404 element == EL_DC_GATE_WHITE_GRAY_ACTIVE)
14406 if (player->num_white_keys == 0)
14407 return MP_NO_ACTION;
14409 player->num_white_keys--;
14411 else if (IS_SP_PORT(element))
14413 if (element == EL_SP_GRAVITY_PORT_LEFT ||
14414 element == EL_SP_GRAVITY_PORT_RIGHT ||
14415 element == EL_SP_GRAVITY_PORT_UP ||
14416 element == EL_SP_GRAVITY_PORT_DOWN)
14417 player->gravity = !player->gravity;
14418 else if (element == EL_SP_GRAVITY_ON_PORT_LEFT ||
14419 element == EL_SP_GRAVITY_ON_PORT_RIGHT ||
14420 element == EL_SP_GRAVITY_ON_PORT_UP ||
14421 element == EL_SP_GRAVITY_ON_PORT_DOWN)
14422 player->gravity = TRUE;
14423 else if (element == EL_SP_GRAVITY_OFF_PORT_LEFT ||
14424 element == EL_SP_GRAVITY_OFF_PORT_RIGHT ||
14425 element == EL_SP_GRAVITY_OFF_PORT_UP ||
14426 element == EL_SP_GRAVITY_OFF_PORT_DOWN)
14427 player->gravity = FALSE;
14430 // automatically move to the next field with double speed
14431 player->programmed_action = move_direction;
14433 if (player->move_delay_reset_counter == 0)
14435 player->move_delay_reset_counter = 2; // two double speed steps
14437 DOUBLE_PLAYER_SPEED(player);
14440 PlayLevelSoundAction(x, y, ACTION_PASSING);
14442 else if (player_can_move_or_snap && IS_DIGGABLE(element))
14446 if (mode != DF_SNAP)
14448 GfxElement[x][y] = GFX_ELEMENT(element);
14449 player->is_digging = TRUE;
14452 PlayLevelSoundElementAction(x, y, element, ACTION_DIGGING);
14454 // use old behaviour for old levels (digging)
14455 if (!level.finish_dig_collect)
14457 CheckTriggeredElementChangeByPlayer(x, y, element, CE_PLAYER_DIGS_X,
14458 player->index_bit, dig_side);
14460 // if digging triggered player relocation, finish digging tile
14461 if (mode == DF_DIG && (player->jx != jx || player->jy != jy))
14462 SetFieldForSnapping(x, y, element, move_direction, player->index_bit);
14465 if (mode == DF_SNAP)
14467 if (level.block_snap_field)
14468 SetFieldForSnapping(x, y, element, move_direction, player->index_bit);
14470 TestFieldAfterSnapping(x, y, element, move_direction, player->index_bit);
14472 // use old behaviour for old levels (snapping)
14473 if (!level.finish_dig_collect)
14474 CheckTriggeredElementChangeByPlayer(x, y, element, CE_PLAYER_SNAPS_X,
14475 player->index_bit, dig_side);
14478 else if (player_can_move_or_snap && IS_COLLECTIBLE(element))
14482 if (is_player && mode != DF_SNAP)
14484 GfxElement[x][y] = element;
14485 player->is_collecting = TRUE;
14488 if (element == EL_SPEED_PILL)
14490 player->move_delay_value = MOVE_DELAY_HIGH_SPEED;
14492 else if (element == EL_EXTRA_TIME && level.time > 0)
14494 TimeLeft += level.extra_time;
14496 game_panel_controls[GAME_PANEL_TIME].value = TimeLeft;
14498 DisplayGameControlValues();
14500 else if (element == EL_SHIELD_NORMAL || element == EL_SHIELD_DEADLY)
14502 player->shield_normal_time_left += level.shield_normal_time;
14503 if (element == EL_SHIELD_DEADLY)
14504 player->shield_deadly_time_left += level.shield_deadly_time;
14506 else if (element == EL_DYNAMITE ||
14507 element == EL_EM_DYNAMITE ||
14508 element == EL_SP_DISK_RED)
14510 if (player->inventory_size < MAX_INVENTORY_SIZE)
14511 player->inventory_element[player->inventory_size++] = element;
14513 DrawGameDoorValues();
14515 else if (element == EL_DYNABOMB_INCREASE_NUMBER)
14517 player->dynabomb_count++;
14518 player->dynabombs_left++;
14520 else if (element == EL_DYNABOMB_INCREASE_SIZE)
14522 player->dynabomb_size++;
14524 else if (element == EL_DYNABOMB_INCREASE_POWER)
14526 player->dynabomb_xl = TRUE;
14528 else if (IS_KEY(element))
14530 player->key[KEY_NR(element)] = TRUE;
14532 DrawGameDoorValues();
14534 else if (element == EL_DC_KEY_WHITE)
14536 player->num_white_keys++;
14538 // display white keys?
14539 // DrawGameDoorValues();
14541 else if (IS_ENVELOPE(element))
14543 boolean wait_for_snapping = (mode == DF_SNAP && level.block_snap_field);
14545 if (!wait_for_snapping)
14546 player->show_envelope = element;
14548 else if (element == EL_EMC_LENSES)
14550 game.lenses_time_left = level.lenses_time * FRAMES_PER_SECOND;
14552 RedrawAllInvisibleElementsForLenses();
14554 else if (element == EL_EMC_MAGNIFIER)
14556 game.magnify_time_left = level.magnify_time * FRAMES_PER_SECOND;
14558 RedrawAllInvisibleElementsForMagnifier();
14560 else if (IS_DROPPABLE(element) ||
14561 IS_THROWABLE(element)) // can be collected and dropped
14565 if (collect_count == 0)
14566 player->inventory_infinite_element = element;
14568 for (i = 0; i < collect_count; i++)
14569 if (player->inventory_size < MAX_INVENTORY_SIZE)
14570 player->inventory_element[player->inventory_size++] = element;
14572 DrawGameDoorValues();
14574 else if (collect_count > 0)
14576 game.gems_still_needed -= collect_count;
14577 if (game.gems_still_needed < 0)
14578 game.gems_still_needed = 0;
14580 game.snapshot.collected_item = TRUE;
14582 game_panel_controls[GAME_PANEL_GEMS].value = game.gems_still_needed;
14584 DisplayGameControlValues();
14587 RaiseScoreElement(element);
14588 PlayLevelSoundElementAction(x, y, element, ACTION_COLLECTING);
14590 // use old behaviour for old levels (collecting)
14591 if (!level.finish_dig_collect && is_player)
14593 CheckTriggeredElementChangeByPlayer(x, y, element, CE_PLAYER_COLLECTS_X,
14594 player->index_bit, dig_side);
14596 // if collecting triggered player relocation, finish collecting tile
14597 if (mode == DF_DIG && (player->jx != jx || player->jy != jy))
14598 SetFieldForSnapping(x, y, element, move_direction, player->index_bit);
14601 if (mode == DF_SNAP)
14603 if (level.block_snap_field)
14604 SetFieldForSnapping(x, y, element, move_direction, player->index_bit);
14606 TestFieldAfterSnapping(x, y, element, move_direction, player->index_bit);
14608 // use old behaviour for old levels (snapping)
14609 if (!level.finish_dig_collect)
14610 CheckTriggeredElementChangeByPlayer(x, y, element, CE_PLAYER_SNAPS_X,
14611 player->index_bit, dig_side);
14614 else if (player_can_move_or_snap && IS_PUSHABLE(element))
14616 if (mode == DF_SNAP && element != EL_BD_ROCK)
14617 return MP_NO_ACTION;
14619 if (CAN_FALL(element) && dy)
14620 return MP_NO_ACTION;
14622 if (CAN_FALL(element) && IN_LEV_FIELD(x, y + 1) && IS_FREE(x, y + 1) &&
14623 !(element == EL_SPRING && level.use_spring_bug))
14624 return MP_NO_ACTION;
14626 if (CAN_MOVE(element) && GET_MAX_MOVE_DELAY(element) == 0 &&
14627 ((move_direction & MV_VERTICAL &&
14628 ((element_info[element].move_pattern & MV_LEFT &&
14629 IN_LEV_FIELD(x - 1, y) && IS_FREE(x - 1, y)) ||
14630 (element_info[element].move_pattern & MV_RIGHT &&
14631 IN_LEV_FIELD(x + 1, y) && IS_FREE(x + 1, y)))) ||
14632 (move_direction & MV_HORIZONTAL &&
14633 ((element_info[element].move_pattern & MV_UP &&
14634 IN_LEV_FIELD(x, y - 1) && IS_FREE(x, y - 1)) ||
14635 (element_info[element].move_pattern & MV_DOWN &&
14636 IN_LEV_FIELD(x, y + 1) && IS_FREE(x, y + 1))))))
14637 return MP_NO_ACTION;
14639 // do not push elements already moving away faster than player
14640 if (CAN_MOVE(element) && MovDir[x][y] == move_direction &&
14641 ABS(getElementMoveStepsize(x, y)) > MOVE_STEPSIZE_NORMAL)
14642 return MP_NO_ACTION;
14644 if (game.engine_version >= VERSION_IDENT(3,1,0,0))
14646 if (player->push_delay_value == -1 || !player_was_pushing)
14647 player->push_delay_value = GET_NEW_PUSH_DELAY(element);
14649 else if (game.engine_version >= VERSION_IDENT(3,0,7,1))
14651 if (player->push_delay_value == -1)
14652 player->push_delay_value = GET_NEW_PUSH_DELAY(element);
14654 else if (game.engine_version >= VERSION_IDENT(2,2,0,7))
14656 if (!player->is_pushing)
14657 player->push_delay_value = GET_NEW_PUSH_DELAY(element);
14660 player->is_pushing = TRUE;
14661 player->is_active = TRUE;
14663 if (!(IN_LEV_FIELD(nextx, nexty) &&
14664 (IS_FREE(nextx, nexty) ||
14665 (IS_SB_ELEMENT(element) &&
14666 Tile[nextx][nexty] == EL_SOKOBAN_FIELD_EMPTY) ||
14667 (IS_CUSTOM_ELEMENT(element) &&
14668 CUSTOM_ELEMENT_CAN_ENTER_FIELD(element, nextx, nexty)))))
14669 return MP_NO_ACTION;
14671 if (!checkDiagonalPushing(player, x, y, real_dx, real_dy))
14672 return MP_NO_ACTION;
14674 if (player->push_delay == -1) // new pushing; restart delay
14675 player->push_delay = 0;
14677 if (player->push_delay < player->push_delay_value &&
14678 !(tape.playing && tape.file_version < FILE_VERSION_2_0) &&
14679 element != EL_SPRING && element != EL_BALLOON)
14681 // make sure that there is no move delay before next try to push
14682 if (game.engine_version >= VERSION_IDENT(3,0,7,1))
14683 player->move_delay = 0;
14685 return MP_NO_ACTION;
14688 if (IS_CUSTOM_ELEMENT(element) &&
14689 CUSTOM_ELEMENT_CAN_ENTER_FIELD(element, nextx, nexty))
14691 if (!DigFieldByCE(nextx, nexty, element))
14692 return MP_NO_ACTION;
14695 if (IS_SB_ELEMENT(element))
14697 boolean sokoban_task_solved = FALSE;
14699 if (element == EL_SOKOBAN_FIELD_FULL)
14701 Back[x][y] = EL_SOKOBAN_FIELD_EMPTY;
14703 IncrementSokobanFieldsNeeded();
14704 IncrementSokobanObjectsNeeded();
14707 if (Tile[nextx][nexty] == EL_SOKOBAN_FIELD_EMPTY)
14709 Back[nextx][nexty] = EL_SOKOBAN_FIELD_EMPTY;
14711 DecrementSokobanFieldsNeeded();
14712 DecrementSokobanObjectsNeeded();
14714 // sokoban object was pushed from empty field to sokoban field
14715 if (Back[x][y] == EL_EMPTY)
14716 sokoban_task_solved = TRUE;
14719 Tile[x][y] = EL_SOKOBAN_OBJECT;
14721 if (Back[x][y] == Back[nextx][nexty])
14722 PlayLevelSoundAction(x, y, ACTION_PUSHING);
14723 else if (Back[x][y] != 0)
14724 PlayLevelSoundElementAction(x, y, EL_SOKOBAN_FIELD_FULL,
14727 PlayLevelSoundElementAction(nextx, nexty, EL_SOKOBAN_FIELD_EMPTY,
14730 if (sokoban_task_solved &&
14731 game.sokoban_fields_still_needed == 0 &&
14732 game.sokoban_objects_still_needed == 0 &&
14733 level.auto_exit_sokoban)
14735 game.players_still_needed = 0;
14739 PlayLevelSound(x, y, SND_GAME_SOKOBAN_SOLVING);
14743 PlayLevelSoundElementAction(x, y, element, ACTION_PUSHING);
14745 InitMovingField(x, y, move_direction);
14746 GfxAction[x][y] = ACTION_PUSHING;
14748 if (mode == DF_SNAP)
14749 ContinueMoving(x, y);
14751 MovPos[x][y] = (dx != 0 ? dx : dy);
14753 Pushed[x][y] = TRUE;
14754 Pushed[nextx][nexty] = TRUE;
14756 if (game.engine_version < VERSION_IDENT(2,2,0,7))
14757 player->push_delay_value = GET_NEW_PUSH_DELAY(element);
14759 player->push_delay_value = -1; // get new value later
14761 // check for element change _after_ element has been pushed
14762 if (game.use_change_when_pushing_bug)
14764 CheckElementChangeByPlayer(x, y, element, CE_PUSHED_BY_PLAYER,
14765 player->index_bit, dig_side);
14766 CheckTriggeredElementChangeByPlayer(x, y, element, CE_PLAYER_PUSHES_X,
14767 player->index_bit, dig_side);
14770 else if (IS_SWITCHABLE(element))
14772 if (PLAYER_SWITCHING(player, x, y))
14774 CheckTriggeredElementChangeByPlayer(x, y, element, CE_PLAYER_PRESSES_X,
14775 player->index_bit, dig_side);
14780 player->is_switching = TRUE;
14781 player->switch_x = x;
14782 player->switch_y = y;
14784 PlayLevelSoundElementAction(x, y, element, ACTION_ACTIVATING);
14786 if (element == EL_ROBOT_WHEEL)
14788 Tile[x][y] = EL_ROBOT_WHEEL_ACTIVE;
14790 game.robot_wheel_x = x;
14791 game.robot_wheel_y = y;
14792 game.robot_wheel_active = TRUE;
14794 TEST_DrawLevelField(x, y);
14796 else if (element == EL_SP_TERMINAL)
14800 SCAN_PLAYFIELD(xx, yy)
14802 if (Tile[xx][yy] == EL_SP_DISK_YELLOW)
14806 else if (Tile[xx][yy] == EL_SP_TERMINAL)
14808 Tile[xx][yy] = EL_SP_TERMINAL_ACTIVE;
14810 ResetGfxAnimation(xx, yy);
14811 TEST_DrawLevelField(xx, yy);
14815 else if (IS_BELT_SWITCH(element))
14817 ToggleBeltSwitch(x, y);
14819 else if (element == EL_SWITCHGATE_SWITCH_UP ||
14820 element == EL_SWITCHGATE_SWITCH_DOWN ||
14821 element == EL_DC_SWITCHGATE_SWITCH_UP ||
14822 element == EL_DC_SWITCHGATE_SWITCH_DOWN)
14824 ToggleSwitchgateSwitch(x, y);
14826 else if (element == EL_LIGHT_SWITCH ||
14827 element == EL_LIGHT_SWITCH_ACTIVE)
14829 ToggleLightSwitch(x, y);
14831 else if (element == EL_TIMEGATE_SWITCH ||
14832 element == EL_DC_TIMEGATE_SWITCH)
14834 ActivateTimegateSwitch(x, y);
14836 else if (element == EL_BALLOON_SWITCH_LEFT ||
14837 element == EL_BALLOON_SWITCH_RIGHT ||
14838 element == EL_BALLOON_SWITCH_UP ||
14839 element == EL_BALLOON_SWITCH_DOWN ||
14840 element == EL_BALLOON_SWITCH_NONE ||
14841 element == EL_BALLOON_SWITCH_ANY)
14843 game.wind_direction = (element == EL_BALLOON_SWITCH_LEFT ? MV_LEFT :
14844 element == EL_BALLOON_SWITCH_RIGHT ? MV_RIGHT :
14845 element == EL_BALLOON_SWITCH_UP ? MV_UP :
14846 element == EL_BALLOON_SWITCH_DOWN ? MV_DOWN :
14847 element == EL_BALLOON_SWITCH_NONE ? MV_NONE :
14850 else if (element == EL_LAMP)
14852 Tile[x][y] = EL_LAMP_ACTIVE;
14853 game.lights_still_needed--;
14855 ResetGfxAnimation(x, y);
14856 TEST_DrawLevelField(x, y);
14858 else if (element == EL_TIME_ORB_FULL)
14860 Tile[x][y] = EL_TIME_ORB_EMPTY;
14862 if (level.time > 0 || level.use_time_orb_bug)
14864 TimeLeft += level.time_orb_time;
14865 game.no_time_limit = FALSE;
14867 game_panel_controls[GAME_PANEL_TIME].value = TimeLeft;
14869 DisplayGameControlValues();
14872 ResetGfxAnimation(x, y);
14873 TEST_DrawLevelField(x, y);
14875 else if (element == EL_EMC_MAGIC_BALL_SWITCH ||
14876 element == EL_EMC_MAGIC_BALL_SWITCH_ACTIVE)
14880 game.ball_active = !game.ball_active;
14882 SCAN_PLAYFIELD(xx, yy)
14884 int e = Tile[xx][yy];
14886 if (game.ball_active)
14888 if (e == EL_EMC_MAGIC_BALL)
14889 CreateField(xx, yy, EL_EMC_MAGIC_BALL_ACTIVE);
14890 else if (e == EL_EMC_MAGIC_BALL_SWITCH)
14891 CreateField(xx, yy, EL_EMC_MAGIC_BALL_SWITCH_ACTIVE);
14895 if (e == EL_EMC_MAGIC_BALL_ACTIVE)
14896 CreateField(xx, yy, EL_EMC_MAGIC_BALL);
14897 else if (e == EL_EMC_MAGIC_BALL_SWITCH_ACTIVE)
14898 CreateField(xx, yy, EL_EMC_MAGIC_BALL_SWITCH);
14903 CheckTriggeredElementChangeByPlayer(x, y, element, CE_SWITCH_OF_X,
14904 player->index_bit, dig_side);
14906 CheckTriggeredElementChangeByPlayer(x, y, element, CE_PLAYER_SWITCHES_X,
14907 player->index_bit, dig_side);
14909 CheckTriggeredElementChangeByPlayer(x, y, element, CE_PLAYER_PRESSES_X,
14910 player->index_bit, dig_side);
14916 if (!PLAYER_SWITCHING(player, x, y))
14918 player->is_switching = TRUE;
14919 player->switch_x = x;
14920 player->switch_y = y;
14922 CheckElementChangeByPlayer(x, y, element, CE_SWITCHED,
14923 player->index_bit, dig_side);
14924 CheckTriggeredElementChangeByPlayer(x, y, element, CE_SWITCH_OF_X,
14925 player->index_bit, dig_side);
14927 CheckElementChangeByPlayer(x, y, element, CE_SWITCHED_BY_PLAYER,
14928 player->index_bit, dig_side);
14929 CheckTriggeredElementChangeByPlayer(x, y, element, CE_PLAYER_SWITCHES_X,
14930 player->index_bit, dig_side);
14933 CheckElementChangeByPlayer(x, y, element, CE_PRESSED_BY_PLAYER,
14934 player->index_bit, dig_side);
14935 CheckTriggeredElementChangeByPlayer(x, y, element, CE_PLAYER_PRESSES_X,
14936 player->index_bit, dig_side);
14938 return MP_NO_ACTION;
14941 player->push_delay = -1;
14943 if (is_player) // function can also be called by EL_PENGUIN
14945 if (Tile[x][y] != element) // really digged/collected something
14947 player->is_collecting = !player->is_digging;
14948 player->is_active = TRUE;
14950 player->last_removed_element = element;
14957 static boolean DigFieldByCE(int x, int y, int digging_element)
14959 int element = Tile[x][y];
14961 if (!IS_FREE(x, y))
14963 int action = (IS_DIGGABLE(element) ? ACTION_DIGGING :
14964 IS_COLLECTIBLE(element) ? ACTION_COLLECTING :
14967 // no element can dig solid indestructible elements
14968 if (IS_INDESTRUCTIBLE(element) &&
14969 !IS_DIGGABLE(element) &&
14970 !IS_COLLECTIBLE(element))
14973 if (AmoebaNr[x][y] &&
14974 (element == EL_AMOEBA_FULL ||
14975 element == EL_BD_AMOEBA ||
14976 element == EL_AMOEBA_GROWING))
14978 AmoebaCnt[AmoebaNr[x][y]]--;
14979 AmoebaCnt2[AmoebaNr[x][y]]--;
14982 if (IS_MOVING(x, y))
14983 RemoveMovingField(x, y);
14987 TEST_DrawLevelField(x, y);
14990 // if digged element was about to explode, prevent the explosion
14991 ExplodeField[x][y] = EX_TYPE_NONE;
14993 PlayLevelSoundAction(x, y, action);
14996 Store[x][y] = EL_EMPTY;
14998 // this makes it possible to leave the removed element again
14999 if (IS_EQUAL_OR_IN_GROUP(element, MOVE_ENTER_EL(digging_element)))
15000 Store[x][y] = element;
15005 static boolean SnapField(struct PlayerInfo *player, int dx, int dy)
15007 int jx = player->jx, jy = player->jy;
15008 int x = jx + dx, y = jy + dy;
15009 int snap_direction = (dx == -1 ? MV_LEFT :
15010 dx == +1 ? MV_RIGHT :
15012 dy == +1 ? MV_DOWN : MV_NONE);
15013 boolean can_continue_snapping = (level.continuous_snapping &&
15014 WasJustFalling[x][y] < CHECK_DELAY_FALLING);
15016 if (player->MovPos != 0 && game.engine_version >= VERSION_IDENT(2,2,0,0))
15019 if (!player->active || !IN_LEV_FIELD(x, y))
15027 if (player->MovPos == 0)
15028 player->is_pushing = FALSE;
15030 player->is_snapping = FALSE;
15032 if (player->MovPos == 0)
15034 player->is_moving = FALSE;
15035 player->is_digging = FALSE;
15036 player->is_collecting = FALSE;
15042 // prevent snapping with already pressed snap key when not allowed
15043 if (player->is_snapping && !can_continue_snapping)
15046 player->MovDir = snap_direction;
15048 if (player->MovPos == 0)
15050 player->is_moving = FALSE;
15051 player->is_digging = FALSE;
15052 player->is_collecting = FALSE;
15055 player->is_dropping = FALSE;
15056 player->is_dropping_pressed = FALSE;
15057 player->drop_pressed_delay = 0;
15059 if (DigField(player, jx, jy, x, y, 0, 0, DF_SNAP) == MP_NO_ACTION)
15062 player->is_snapping = TRUE;
15063 player->is_active = TRUE;
15065 if (player->MovPos == 0)
15067 player->is_moving = FALSE;
15068 player->is_digging = FALSE;
15069 player->is_collecting = FALSE;
15072 if (player->MovPos != 0) // prevent graphic bugs in versions < 2.2.0
15073 TEST_DrawLevelField(player->last_jx, player->last_jy);
15075 TEST_DrawLevelField(x, y);
15080 static boolean DropElement(struct PlayerInfo *player)
15082 int old_element, new_element;
15083 int dropx = player->jx, dropy = player->jy;
15084 int drop_direction = player->MovDir;
15085 int drop_side = drop_direction;
15086 int drop_element = get_next_dropped_element(player);
15088 /* do not drop an element on top of another element; when holding drop key
15089 pressed without moving, dropped element must move away before the next
15090 element can be dropped (this is especially important if the next element
15091 is dynamite, which can be placed on background for historical reasons) */
15092 if (PLAYER_DROPPING(player, dropx, dropy) && Tile[dropx][dropy] != EL_EMPTY)
15095 if (IS_THROWABLE(drop_element))
15097 dropx += GET_DX_FROM_DIR(drop_direction);
15098 dropy += GET_DY_FROM_DIR(drop_direction);
15100 if (!IN_LEV_FIELD(dropx, dropy))
15104 old_element = Tile[dropx][dropy]; // old element at dropping position
15105 new_element = drop_element; // default: no change when dropping
15107 // check if player is active, not moving and ready to drop
15108 if (!player->active || player->MovPos || player->drop_delay > 0)
15111 // check if player has anything that can be dropped
15112 if (new_element == EL_UNDEFINED)
15115 // only set if player has anything that can be dropped
15116 player->is_dropping_pressed = TRUE;
15118 // check if drop key was pressed long enough for EM style dynamite
15119 if (new_element == EL_EM_DYNAMITE && player->drop_pressed_delay < 40)
15122 // check if anything can be dropped at the current position
15123 if (IS_ACTIVE_BOMB(old_element) || old_element == EL_EXPLOSION)
15126 // collected custom elements can only be dropped on empty fields
15127 if (IS_CUSTOM_ELEMENT(new_element) && old_element != EL_EMPTY)
15130 if (old_element != EL_EMPTY)
15131 Back[dropx][dropy] = old_element; // store old element on this field
15133 ResetGfxAnimation(dropx, dropy);
15134 ResetRandomAnimationValue(dropx, dropy);
15136 if (player->inventory_size > 0 ||
15137 player->inventory_infinite_element != EL_UNDEFINED)
15139 if (player->inventory_size > 0)
15141 player->inventory_size--;
15143 DrawGameDoorValues();
15145 if (new_element == EL_DYNAMITE)
15146 new_element = EL_DYNAMITE_ACTIVE;
15147 else if (new_element == EL_EM_DYNAMITE)
15148 new_element = EL_EM_DYNAMITE_ACTIVE;
15149 else if (new_element == EL_SP_DISK_RED)
15150 new_element = EL_SP_DISK_RED_ACTIVE;
15153 Tile[dropx][dropy] = new_element;
15155 if (IN_SCR_FIELD(SCREENX(dropx), SCREENY(dropy)))
15156 DrawGraphicThruMask(SCREENX(dropx), SCREENY(dropy),
15157 el2img(Tile[dropx][dropy]), 0);
15159 PlayLevelSoundAction(dropx, dropy, ACTION_DROPPING);
15161 // needed if previous element just changed to "empty" in the last frame
15162 ChangeCount[dropx][dropy] = 0; // allow at least one more change
15164 CheckElementChangeByPlayer(dropx, dropy, new_element, CE_DROPPED_BY_PLAYER,
15165 player->index_bit, drop_side);
15166 CheckTriggeredElementChangeByPlayer(dropx, dropy, new_element,
15168 player->index_bit, drop_side);
15170 TestIfElementTouchesCustomElement(dropx, dropy);
15172 else // player is dropping a dyna bomb
15174 player->dynabombs_left--;
15176 Tile[dropx][dropy] = new_element;
15178 if (IN_SCR_FIELD(SCREENX(dropx), SCREENY(dropy)))
15179 DrawGraphicThruMask(SCREENX(dropx), SCREENY(dropy),
15180 el2img(Tile[dropx][dropy]), 0);
15182 PlayLevelSoundAction(dropx, dropy, ACTION_DROPPING);
15185 if (Tile[dropx][dropy] == new_element) // uninitialized unless CE change
15186 InitField_WithBug1(dropx, dropy, FALSE);
15188 new_element = Tile[dropx][dropy]; // element might have changed
15190 if (IS_CUSTOM_ELEMENT(new_element) && CAN_MOVE(new_element) &&
15191 element_info[new_element].move_pattern == MV_WHEN_DROPPED)
15193 if (element_info[new_element].move_direction_initial == MV_START_AUTOMATIC)
15194 MovDir[dropx][dropy] = drop_direction;
15196 ChangeCount[dropx][dropy] = 0; // allow at least one more change
15198 // do not cause impact style collision by dropping elements that can fall
15199 CheckCollision[dropx][dropy] = CHECK_DELAY_COLLISION;
15202 player->drop_delay = GET_NEW_DROP_DELAY(drop_element);
15203 player->is_dropping = TRUE;
15205 player->drop_pressed_delay = 0;
15206 player->is_dropping_pressed = FALSE;
15208 player->drop_x = dropx;
15209 player->drop_y = dropy;
15214 // ----------------------------------------------------------------------------
15215 // game sound playing functions
15216 // ----------------------------------------------------------------------------
15218 static int *loop_sound_frame = NULL;
15219 static int *loop_sound_volume = NULL;
15221 void InitPlayLevelSound(void)
15223 int num_sounds = getSoundListSize();
15225 checked_free(loop_sound_frame);
15226 checked_free(loop_sound_volume);
15228 loop_sound_frame = checked_calloc(num_sounds * sizeof(int));
15229 loop_sound_volume = checked_calloc(num_sounds * sizeof(int));
15232 static void PlayLevelSound(int x, int y, int nr)
15234 int sx = SCREENX(x), sy = SCREENY(y);
15235 int volume, stereo_position;
15236 int max_distance = 8;
15237 int type = (IS_LOOP_SOUND(nr) ? SND_CTRL_PLAY_LOOP : SND_CTRL_PLAY_SOUND);
15239 if ((!setup.sound_simple && !IS_LOOP_SOUND(nr)) ||
15240 (!setup.sound_loops && IS_LOOP_SOUND(nr)))
15243 if (!IN_LEV_FIELD(x, y) ||
15244 sx < -max_distance || sx >= SCR_FIELDX + max_distance ||
15245 sy < -max_distance || sy >= SCR_FIELDY + max_distance)
15248 volume = SOUND_MAX_VOLUME;
15250 if (!IN_SCR_FIELD(sx, sy))
15252 int dx = ABS(sx - SCR_FIELDX / 2) - SCR_FIELDX / 2;
15253 int dy = ABS(sy - SCR_FIELDY / 2) - SCR_FIELDY / 2;
15255 volume -= volume * (dx > dy ? dx : dy) / max_distance;
15258 stereo_position = (SOUND_MAX_LEFT +
15259 (sx + max_distance) * SOUND_MAX_LEFT2RIGHT /
15260 (SCR_FIELDX + 2 * max_distance));
15262 if (IS_LOOP_SOUND(nr))
15264 /* This assures that quieter loop sounds do not overwrite louder ones,
15265 while restarting sound volume comparison with each new game frame. */
15267 if (loop_sound_volume[nr] > volume && loop_sound_frame[nr] == FrameCounter)
15270 loop_sound_volume[nr] = volume;
15271 loop_sound_frame[nr] = FrameCounter;
15274 PlaySoundExt(nr, volume, stereo_position, type);
15277 static void PlayLevelSoundNearest(int x, int y, int sound_action)
15279 PlayLevelSound(x < LEVELX(BX1) ? LEVELX(BX1) :
15280 x > LEVELX(BX2) ? LEVELX(BX2) : x,
15281 y < LEVELY(BY1) ? LEVELY(BY1) :
15282 y > LEVELY(BY2) ? LEVELY(BY2) : y,
15286 static void PlayLevelSoundAction(int x, int y, int action)
15288 PlayLevelSoundElementAction(x, y, Tile[x][y], action);
15291 static void PlayLevelSoundElementAction(int x, int y, int element, int action)
15293 int sound_effect = element_info[SND_ELEMENT(element)].sound[action];
15295 if (sound_effect != SND_UNDEFINED)
15296 PlayLevelSound(x, y, sound_effect);
15299 static void PlayLevelSoundElementActionIfLoop(int x, int y, int element,
15302 int sound_effect = element_info[SND_ELEMENT(element)].sound[action];
15304 if (sound_effect != SND_UNDEFINED && IS_LOOP_SOUND(sound_effect))
15305 PlayLevelSound(x, y, sound_effect);
15308 static void PlayLevelSoundActionIfLoop(int x, int y, int action)
15310 int sound_effect = element_info[SND_ELEMENT(Tile[x][y])].sound[action];
15312 if (sound_effect != SND_UNDEFINED && IS_LOOP_SOUND(sound_effect))
15313 PlayLevelSound(x, y, sound_effect);
15316 static void StopLevelSoundActionIfLoop(int x, int y, int action)
15318 int sound_effect = element_info[SND_ELEMENT(Tile[x][y])].sound[action];
15320 if (sound_effect != SND_UNDEFINED && IS_LOOP_SOUND(sound_effect))
15321 StopSound(sound_effect);
15324 static int getLevelMusicNr(void)
15326 if (levelset.music[level_nr] != MUS_UNDEFINED)
15327 return levelset.music[level_nr]; // from config file
15329 return MAP_NOCONF_MUSIC(level_nr); // from music dir
15332 static void FadeLevelSounds(void)
15337 static void FadeLevelMusic(void)
15339 int music_nr = getLevelMusicNr();
15340 char *curr_music = getCurrentlyPlayingMusicFilename();
15341 char *next_music = getMusicInfoEntryFilename(music_nr);
15343 if (!strEqual(curr_music, next_music))
15347 void FadeLevelSoundsAndMusic(void)
15353 static void PlayLevelMusic(void)
15355 int music_nr = getLevelMusicNr();
15356 char *curr_music = getCurrentlyPlayingMusicFilename();
15357 char *next_music = getMusicInfoEntryFilename(music_nr);
15359 if (!strEqual(curr_music, next_music))
15360 PlayMusicLoop(music_nr);
15363 void PlayLevelSound_EM(int xx, int yy, int element_em, int sample)
15365 int element = (element_em > -1 ? map_element_EM_to_RND_game(element_em) : 0);
15367 int x = xx - offset;
15368 int y = yy - offset;
15373 PlayLevelSoundElementAction(x, y, element, ACTION_WALKING);
15377 PlayLevelSoundElementAction(x, y, element, ACTION_PUSHING);
15381 PlayLevelSoundElementAction(x, y, element, ACTION_IMPACT);
15385 PlayLevelSoundElementAction(x, y, element, ACTION_IMPACT);
15389 PlayLevelSoundElementAction(x, y, element, ACTION_BREAKING);
15393 PlayLevelSoundElementAction(x, y, element, ACTION_MOVING);
15397 PlayLevelSoundElementAction(x, y, element, ACTION_MOVING);
15400 case SOUND_android_clone:
15401 PlayLevelSoundElementAction(x, y, element, ACTION_DROPPING);
15404 case SOUND_android_move:
15405 PlayLevelSoundElementAction(x, y, element, ACTION_MOVING);
15409 PlayLevelSoundElementAction(x, y, element, ACTION_IMPACT);
15413 PlayLevelSoundElementAction(x, y, element, ACTION_EATING);
15417 PlayLevelSoundElementAction(x, y, element, ACTION_WAITING);
15420 case SOUND_eater_eat:
15421 PlayLevelSoundElementAction(x, y, element, ACTION_DIGGING);
15425 PlayLevelSoundElementAction(x, y, element, ACTION_MOVING);
15428 case SOUND_collect:
15429 PlayLevelSoundElementAction(x, y, element, ACTION_COLLECTING);
15432 case SOUND_diamond:
15433 PlayLevelSoundElementAction(x, y, element, ACTION_IMPACT);
15437 // !!! CHECK THIS !!!
15439 PlayLevelSoundElementAction(x, y, element, ACTION_BREAKING);
15441 PlayLevelSoundElementAction(x, y, element, ACTION_SMASHED_BY_ROCK);
15445 case SOUND_wonderfall:
15446 PlayLevelSoundElementAction(x, y, element, ACTION_FILLING);
15450 PlayLevelSoundElementAction(x, y, element, ACTION_IMPACT);
15454 PlayLevelSoundElementAction(x, y, element, ACTION_PUSHING);
15458 PlayLevelSoundElementAction(x, y, element, ACTION_DIGGING);
15462 PlayLevelSoundElementAction(x, y, element, ACTION_SPLASHING);
15466 PlayLevelSoundElementAction(x, y, element, ACTION_DROPPING);
15470 PlayLevelSoundElementAction(x, y, element, ACTION_GROWING);
15474 PlayLevelSoundElementAction(x, y, element, ACTION_ACTIVE);
15478 PlayLevelSoundElementAction(x, y, element, ACTION_PASSING);
15481 case SOUND_exit_open:
15482 PlayLevelSoundElementAction(x, y, element, ACTION_OPENING);
15485 case SOUND_exit_leave:
15486 PlayLevelSoundElementAction(x, y, element, ACTION_PASSING);
15489 case SOUND_dynamite:
15490 PlayLevelSoundElementAction(x, y, element, ACTION_DROPPING);
15494 PlayLevelSoundElementAction(x, y, element, ACTION_ACTIVE);
15498 PlayLevelSoundElementAction(x, y, element, ACTION_ACTIVATING);
15502 PlayLevelSoundElementAction(x, y, element, ACTION_ACTIVE);
15506 PlayLevelSoundElementAction(x, y, element, ACTION_EXPLODING);
15510 PlayLevelSoundElementAction(x, y, element, ACTION_DYING);
15514 PlaySound(SND_GAME_RUNNING_OUT_OF_TIME);
15518 PlayLevelSoundElementAction(x, y, element, ACTION_DEFAULT);
15523 void PlayLevelSound_SP(int xx, int yy, int element_sp, int action_sp)
15525 int element = map_element_SP_to_RND(element_sp);
15526 int action = map_action_SP_to_RND(action_sp);
15527 int offset = (setup.sp_show_border_elements ? 0 : 1);
15528 int x = xx - offset;
15529 int y = yy - offset;
15531 PlayLevelSoundElementAction(x, y, element, action);
15534 void PlayLevelSound_MM(int xx, int yy, int element_mm, int action_mm)
15536 int element = map_element_MM_to_RND(element_mm);
15537 int action = map_action_MM_to_RND(action_mm);
15539 int x = xx - offset;
15540 int y = yy - offset;
15542 if (!IS_MM_ELEMENT(element))
15543 element = EL_MM_DEFAULT;
15545 PlayLevelSoundElementAction(x, y, element, action);
15548 void PlaySound_MM(int sound_mm)
15550 int sound = map_sound_MM_to_RND(sound_mm);
15552 if (sound == SND_UNDEFINED)
15558 void PlaySoundLoop_MM(int sound_mm)
15560 int sound = map_sound_MM_to_RND(sound_mm);
15562 if (sound == SND_UNDEFINED)
15565 PlaySoundLoop(sound);
15568 void StopSound_MM(int sound_mm)
15570 int sound = map_sound_MM_to_RND(sound_mm);
15572 if (sound == SND_UNDEFINED)
15578 void RaiseScore(int value)
15580 game.score += value;
15582 game_panel_controls[GAME_PANEL_SCORE].value = game.score;
15584 DisplayGameControlValues();
15587 void RaiseScoreElement(int element)
15592 case EL_BD_DIAMOND:
15593 case EL_EMERALD_YELLOW:
15594 case EL_EMERALD_RED:
15595 case EL_EMERALD_PURPLE:
15596 case EL_SP_INFOTRON:
15597 RaiseScore(level.score[SC_EMERALD]);
15600 RaiseScore(level.score[SC_DIAMOND]);
15603 RaiseScore(level.score[SC_CRYSTAL]);
15606 RaiseScore(level.score[SC_PEARL]);
15609 case EL_BD_BUTTERFLY:
15610 case EL_SP_ELECTRON:
15611 RaiseScore(level.score[SC_BUG]);
15614 case EL_BD_FIREFLY:
15615 case EL_SP_SNIKSNAK:
15616 RaiseScore(level.score[SC_SPACESHIP]);
15619 case EL_DARK_YAMYAM:
15620 RaiseScore(level.score[SC_YAMYAM]);
15623 RaiseScore(level.score[SC_ROBOT]);
15626 RaiseScore(level.score[SC_PACMAN]);
15629 RaiseScore(level.score[SC_NUT]);
15632 case EL_EM_DYNAMITE:
15633 case EL_SP_DISK_RED:
15634 case EL_DYNABOMB_INCREASE_NUMBER:
15635 case EL_DYNABOMB_INCREASE_SIZE:
15636 case EL_DYNABOMB_INCREASE_POWER:
15637 RaiseScore(level.score[SC_DYNAMITE]);
15639 case EL_SHIELD_NORMAL:
15640 case EL_SHIELD_DEADLY:
15641 RaiseScore(level.score[SC_SHIELD]);
15643 case EL_EXTRA_TIME:
15644 RaiseScore(level.extra_time_score);
15658 case EL_DC_KEY_WHITE:
15659 RaiseScore(level.score[SC_KEY]);
15662 RaiseScore(element_info[element].collect_score);
15667 void RequestQuitGameExt(boolean skip_request, boolean quick_quit, char *message)
15669 if (skip_request || Request(message, REQ_ASK | REQ_STAY_CLOSED))
15673 // prevent short reactivation of overlay buttons while closing door
15674 SetOverlayActive(FALSE);
15676 // door may still be open due to skipped or envelope style request
15677 CloseDoor(DOOR_CLOSE_1);
15680 if (network.enabled)
15681 SendToServer_StopPlaying(NETWORK_STOP_BY_PLAYER);
15685 FadeSkipNextFadeIn();
15687 SetGameStatus(GAME_MODE_MAIN);
15692 else // continue playing the game
15694 if (tape.playing && tape.deactivate_display)
15695 TapeDeactivateDisplayOff(TRUE);
15697 OpenDoor(DOOR_OPEN_1 | DOOR_COPY_BACK);
15699 if (tape.playing && tape.deactivate_display)
15700 TapeDeactivateDisplayOn();
15704 void RequestQuitGame(boolean escape_key_pressed)
15706 boolean ask_on_escape = (setup.ask_on_escape && setup.ask_on_quit_game);
15707 boolean quick_quit = ((escape_key_pressed && !ask_on_escape) ||
15708 level_editor_test_game);
15709 boolean skip_request = (game.all_players_gone || !setup.ask_on_quit_game ||
15712 RequestQuitGameExt(skip_request, quick_quit,
15713 "Do you really want to quit the game?");
15716 void RequestRestartGame(char *message)
15718 game.restart_game_message = NULL;
15720 boolean has_started_game = hasStartedNetworkGame();
15721 int request_mode = (has_started_game ? REQ_ASK : REQ_CONFIRM);
15723 if (Request(message, request_mode | REQ_STAY_CLOSED) && has_started_game)
15725 StartGameActions(network.enabled, setup.autorecord, level.random_seed);
15729 // needed in case of envelope request to close game panel
15730 CloseDoor(DOOR_CLOSE_1);
15732 SetGameStatus(GAME_MODE_MAIN);
15738 void CheckGameOver(void)
15740 static boolean last_game_over = FALSE;
15741 static int game_over_delay = 0;
15742 int game_over_delay_value = 50;
15743 boolean game_over = checkGameFailed();
15745 // do not handle game over if request dialog is already active
15746 if (game.request_active)
15749 // do not ask to play again if game was never actually played
15750 if (!game.GamePlayed)
15755 last_game_over = FALSE;
15756 game_over_delay = game_over_delay_value;
15761 if (game_over_delay > 0)
15768 if (last_game_over != game_over)
15769 game.restart_game_message = (hasStartedNetworkGame() ?
15770 "Game over! Play it again?" :
15773 last_game_over = game_over;
15776 boolean checkGameSolved(void)
15778 // set for all game engines if level was solved
15779 return game.LevelSolved_GameEnd;
15782 boolean checkGameFailed(void)
15784 if (level.game_engine_type == GAME_ENGINE_TYPE_EM)
15785 return (game_em.game_over && !game_em.level_solved);
15786 else if (level.game_engine_type == GAME_ENGINE_TYPE_SP)
15787 return (game_sp.game_over && !game_sp.level_solved);
15788 else if (level.game_engine_type == GAME_ENGINE_TYPE_MM)
15789 return (game_mm.game_over && !game_mm.level_solved);
15790 else // GAME_ENGINE_TYPE_RND
15791 return (game.GameOver && !game.LevelSolved);
15794 boolean checkGameEnded(void)
15796 return (checkGameSolved() || checkGameFailed());
15800 // ----------------------------------------------------------------------------
15801 // random generator functions
15802 // ----------------------------------------------------------------------------
15804 unsigned int InitEngineRandom_RND(int seed)
15806 game.num_random_calls = 0;
15808 return InitEngineRandom(seed);
15811 unsigned int RND(int max)
15815 game.num_random_calls++;
15817 return GetEngineRandom(max);
15824 // ----------------------------------------------------------------------------
15825 // game engine snapshot handling functions
15826 // ----------------------------------------------------------------------------
15828 struct EngineSnapshotInfo
15830 // runtime values for custom element collect score
15831 int collect_score[NUM_CUSTOM_ELEMENTS];
15833 // runtime values for group element choice position
15834 int choice_pos[NUM_GROUP_ELEMENTS];
15836 // runtime values for belt position animations
15837 int belt_graphic[4][NUM_BELT_PARTS];
15838 int belt_anim_mode[4][NUM_BELT_PARTS];
15841 static struct EngineSnapshotInfo engine_snapshot_rnd;
15842 static char *snapshot_level_identifier = NULL;
15843 static int snapshot_level_nr = -1;
15845 static void SaveEngineSnapshotValues_RND(void)
15847 static int belt_base_active_element[4] =
15849 EL_CONVEYOR_BELT_1_LEFT_ACTIVE,
15850 EL_CONVEYOR_BELT_2_LEFT_ACTIVE,
15851 EL_CONVEYOR_BELT_3_LEFT_ACTIVE,
15852 EL_CONVEYOR_BELT_4_LEFT_ACTIVE
15856 for (i = 0; i < NUM_CUSTOM_ELEMENTS; i++)
15858 int element = EL_CUSTOM_START + i;
15860 engine_snapshot_rnd.collect_score[i] = element_info[element].collect_score;
15863 for (i = 0; i < NUM_GROUP_ELEMENTS; i++)
15865 int element = EL_GROUP_START + i;
15867 engine_snapshot_rnd.choice_pos[i] = element_info[element].group->choice_pos;
15870 for (i = 0; i < 4; i++)
15872 for (j = 0; j < NUM_BELT_PARTS; j++)
15874 int element = belt_base_active_element[i] + j;
15875 int graphic = el2img(element);
15876 int anim_mode = graphic_info[graphic].anim_mode;
15878 engine_snapshot_rnd.belt_graphic[i][j] = graphic;
15879 engine_snapshot_rnd.belt_anim_mode[i][j] = anim_mode;
15884 static void LoadEngineSnapshotValues_RND(void)
15886 unsigned int num_random_calls = game.num_random_calls;
15889 for (i = 0; i < NUM_CUSTOM_ELEMENTS; i++)
15891 int element = EL_CUSTOM_START + i;
15893 element_info[element].collect_score = engine_snapshot_rnd.collect_score[i];
15896 for (i = 0; i < NUM_GROUP_ELEMENTS; i++)
15898 int element = EL_GROUP_START + i;
15900 element_info[element].group->choice_pos = engine_snapshot_rnd.choice_pos[i];
15903 for (i = 0; i < 4; i++)
15905 for (j = 0; j < NUM_BELT_PARTS; j++)
15907 int graphic = engine_snapshot_rnd.belt_graphic[i][j];
15908 int anim_mode = engine_snapshot_rnd.belt_anim_mode[i][j];
15910 graphic_info[graphic].anim_mode = anim_mode;
15914 if (level.game_engine_type == GAME_ENGINE_TYPE_RND)
15916 InitRND(tape.random_seed);
15917 for (i = 0; i < num_random_calls; i++)
15921 if (game.num_random_calls != num_random_calls)
15923 Error("number of random calls out of sync");
15924 Error("number of random calls should be %d", num_random_calls);
15925 Error("number of random calls is %d", game.num_random_calls);
15927 Fail("this should not happen -- please debug");
15931 void FreeEngineSnapshotSingle(void)
15933 FreeSnapshotSingle();
15935 setString(&snapshot_level_identifier, NULL);
15936 snapshot_level_nr = -1;
15939 void FreeEngineSnapshotList(void)
15941 FreeSnapshotList();
15944 static ListNode *SaveEngineSnapshotBuffers(void)
15946 ListNode *buffers = NULL;
15948 // copy some special values to a structure better suited for the snapshot
15950 if (level.game_engine_type == GAME_ENGINE_TYPE_RND)
15951 SaveEngineSnapshotValues_RND();
15952 if (level.game_engine_type == GAME_ENGINE_TYPE_EM)
15953 SaveEngineSnapshotValues_EM();
15954 if (level.game_engine_type == GAME_ENGINE_TYPE_SP)
15955 SaveEngineSnapshotValues_SP(&buffers);
15956 if (level.game_engine_type == GAME_ENGINE_TYPE_MM)
15957 SaveEngineSnapshotValues_MM(&buffers);
15959 // save values stored in special snapshot structure
15961 if (level.game_engine_type == GAME_ENGINE_TYPE_RND)
15962 SaveSnapshotBuffer(&buffers, ARGS_ADDRESS_AND_SIZEOF(engine_snapshot_rnd));
15963 if (level.game_engine_type == GAME_ENGINE_TYPE_EM)
15964 SaveSnapshotBuffer(&buffers, ARGS_ADDRESS_AND_SIZEOF(engine_snapshot_em));
15965 if (level.game_engine_type == GAME_ENGINE_TYPE_SP)
15966 SaveSnapshotBuffer(&buffers, ARGS_ADDRESS_AND_SIZEOF(engine_snapshot_sp));
15967 if (level.game_engine_type == GAME_ENGINE_TYPE_MM)
15968 SaveSnapshotBuffer(&buffers, ARGS_ADDRESS_AND_SIZEOF(engine_snapshot_mm));
15970 // save further RND engine values
15972 SaveSnapshotBuffer(&buffers, ARGS_ADDRESS_AND_SIZEOF(stored_player));
15973 SaveSnapshotBuffer(&buffers, ARGS_ADDRESS_AND_SIZEOF(game));
15974 SaveSnapshotBuffer(&buffers, ARGS_ADDRESS_AND_SIZEOF(tape));
15976 SaveSnapshotBuffer(&buffers, ARGS_ADDRESS_AND_SIZEOF(FrameCounter));
15977 SaveSnapshotBuffer(&buffers, ARGS_ADDRESS_AND_SIZEOF(TimeFrames));
15978 SaveSnapshotBuffer(&buffers, ARGS_ADDRESS_AND_SIZEOF(TimePlayed));
15979 SaveSnapshotBuffer(&buffers, ARGS_ADDRESS_AND_SIZEOF(TimeLeft));
15980 SaveSnapshotBuffer(&buffers, ARGS_ADDRESS_AND_SIZEOF(TapeTime));
15982 SaveSnapshotBuffer(&buffers, ARGS_ADDRESS_AND_SIZEOF(ScreenMovDir));
15983 SaveSnapshotBuffer(&buffers, ARGS_ADDRESS_AND_SIZEOF(ScreenMovPos));
15984 SaveSnapshotBuffer(&buffers, ARGS_ADDRESS_AND_SIZEOF(ScreenGfxPos));
15986 SaveSnapshotBuffer(&buffers, ARGS_ADDRESS_AND_SIZEOF(ScrollStepSize));
15988 SaveSnapshotBuffer(&buffers, ARGS_ADDRESS_AND_SIZEOF(AmoebaCnt));
15989 SaveSnapshotBuffer(&buffers, ARGS_ADDRESS_AND_SIZEOF(AmoebaCnt2));
15991 SaveSnapshotBuffer(&buffers, ARGS_ADDRESS_AND_SIZEOF(Tile));
15992 SaveSnapshotBuffer(&buffers, ARGS_ADDRESS_AND_SIZEOF(MovPos));
15993 SaveSnapshotBuffer(&buffers, ARGS_ADDRESS_AND_SIZEOF(MovDir));
15994 SaveSnapshotBuffer(&buffers, ARGS_ADDRESS_AND_SIZEOF(MovDelay));
15995 SaveSnapshotBuffer(&buffers, ARGS_ADDRESS_AND_SIZEOF(ChangeDelay));
15996 SaveSnapshotBuffer(&buffers, ARGS_ADDRESS_AND_SIZEOF(ChangePage));
15997 SaveSnapshotBuffer(&buffers, ARGS_ADDRESS_AND_SIZEOF(CustomValue));
15998 SaveSnapshotBuffer(&buffers, ARGS_ADDRESS_AND_SIZEOF(Store));
15999 SaveSnapshotBuffer(&buffers, ARGS_ADDRESS_AND_SIZEOF(Store2));
16000 SaveSnapshotBuffer(&buffers, ARGS_ADDRESS_AND_SIZEOF(StorePlayer));
16001 SaveSnapshotBuffer(&buffers, ARGS_ADDRESS_AND_SIZEOF(Back));
16002 SaveSnapshotBuffer(&buffers, ARGS_ADDRESS_AND_SIZEOF(AmoebaNr));
16003 SaveSnapshotBuffer(&buffers, ARGS_ADDRESS_AND_SIZEOF(WasJustMoving));
16004 SaveSnapshotBuffer(&buffers, ARGS_ADDRESS_AND_SIZEOF(WasJustFalling));
16005 SaveSnapshotBuffer(&buffers, ARGS_ADDRESS_AND_SIZEOF(CheckCollision));
16006 SaveSnapshotBuffer(&buffers, ARGS_ADDRESS_AND_SIZEOF(CheckImpact));
16007 SaveSnapshotBuffer(&buffers, ARGS_ADDRESS_AND_SIZEOF(Stop));
16008 SaveSnapshotBuffer(&buffers, ARGS_ADDRESS_AND_SIZEOF(Pushed));
16010 SaveSnapshotBuffer(&buffers, ARGS_ADDRESS_AND_SIZEOF(ChangeCount));
16011 SaveSnapshotBuffer(&buffers, ARGS_ADDRESS_AND_SIZEOF(ChangeEvent));
16013 SaveSnapshotBuffer(&buffers, ARGS_ADDRESS_AND_SIZEOF(ExplodePhase));
16014 SaveSnapshotBuffer(&buffers, ARGS_ADDRESS_AND_SIZEOF(ExplodeDelay));
16015 SaveSnapshotBuffer(&buffers, ARGS_ADDRESS_AND_SIZEOF(ExplodeField));
16017 SaveSnapshotBuffer(&buffers, ARGS_ADDRESS_AND_SIZEOF(RunnerVisit));
16018 SaveSnapshotBuffer(&buffers, ARGS_ADDRESS_AND_SIZEOF(PlayerVisit));
16020 SaveSnapshotBuffer(&buffers, ARGS_ADDRESS_AND_SIZEOF(GfxFrame));
16021 SaveSnapshotBuffer(&buffers, ARGS_ADDRESS_AND_SIZEOF(GfxRandom));
16022 SaveSnapshotBuffer(&buffers, ARGS_ADDRESS_AND_SIZEOF(GfxRandomStatic));
16023 SaveSnapshotBuffer(&buffers, ARGS_ADDRESS_AND_SIZEOF(GfxElement));
16024 SaveSnapshotBuffer(&buffers, ARGS_ADDRESS_AND_SIZEOF(GfxAction));
16025 SaveSnapshotBuffer(&buffers, ARGS_ADDRESS_AND_SIZEOF(GfxDir));
16027 SaveSnapshotBuffer(&buffers, ARGS_ADDRESS_AND_SIZEOF(scroll_x));
16028 SaveSnapshotBuffer(&buffers, ARGS_ADDRESS_AND_SIZEOF(scroll_y));
16031 ListNode *node = engine_snapshot_list_rnd;
16034 while (node != NULL)
16036 num_bytes += ((struct EngineSnapshotNodeInfo *)node->content)->size;
16041 Debug("game:playing:SaveEngineSnapshotBuffers",
16042 "size of engine snapshot: %d bytes", num_bytes);
16048 void SaveEngineSnapshotSingle(void)
16050 ListNode *buffers = SaveEngineSnapshotBuffers();
16052 // finally save all snapshot buffers to single snapshot
16053 SaveSnapshotSingle(buffers);
16055 // save level identification information
16056 setString(&snapshot_level_identifier, leveldir_current->identifier);
16057 snapshot_level_nr = level_nr;
16060 boolean CheckSaveEngineSnapshotToList(void)
16062 boolean save_snapshot =
16063 ((game.snapshot.mode == SNAPSHOT_MODE_EVERY_STEP) ||
16064 (game.snapshot.mode == SNAPSHOT_MODE_EVERY_MOVE &&
16065 game.snapshot.changed_action) ||
16066 (game.snapshot.mode == SNAPSHOT_MODE_EVERY_COLLECT &&
16067 game.snapshot.collected_item));
16069 game.snapshot.changed_action = FALSE;
16070 game.snapshot.collected_item = FALSE;
16071 game.snapshot.save_snapshot = save_snapshot;
16073 return save_snapshot;
16076 void SaveEngineSnapshotToList(void)
16078 if (game.snapshot.mode == SNAPSHOT_MODE_OFF ||
16082 ListNode *buffers = SaveEngineSnapshotBuffers();
16084 // finally save all snapshot buffers to snapshot list
16085 SaveSnapshotToList(buffers);
16088 void SaveEngineSnapshotToListInitial(void)
16090 FreeEngineSnapshotList();
16092 SaveEngineSnapshotToList();
16095 static void LoadEngineSnapshotValues(void)
16097 // restore special values from snapshot structure
16099 if (level.game_engine_type == GAME_ENGINE_TYPE_RND)
16100 LoadEngineSnapshotValues_RND();
16101 if (level.game_engine_type == GAME_ENGINE_TYPE_EM)
16102 LoadEngineSnapshotValues_EM();
16103 if (level.game_engine_type == GAME_ENGINE_TYPE_SP)
16104 LoadEngineSnapshotValues_SP();
16105 if (level.game_engine_type == GAME_ENGINE_TYPE_MM)
16106 LoadEngineSnapshotValues_MM();
16109 void LoadEngineSnapshotSingle(void)
16111 LoadSnapshotSingle();
16113 LoadEngineSnapshotValues();
16116 static void LoadEngineSnapshot_Undo(int steps)
16118 LoadSnapshotFromList_Older(steps);
16120 LoadEngineSnapshotValues();
16123 static void LoadEngineSnapshot_Redo(int steps)
16125 LoadSnapshotFromList_Newer(steps);
16127 LoadEngineSnapshotValues();
16130 boolean CheckEngineSnapshotSingle(void)
16132 return (strEqual(snapshot_level_identifier, leveldir_current->identifier) &&
16133 snapshot_level_nr == level_nr);
16136 boolean CheckEngineSnapshotList(void)
16138 return CheckSnapshotList();
16142 // ---------- new game button stuff -------------------------------------------
16149 boolean *setup_value;
16150 boolean allowed_on_tape;
16151 boolean is_touch_button;
16153 } gamebutton_info[NUM_GAME_BUTTONS] =
16156 IMG_GFX_GAME_BUTTON_STOP, &game.button.stop,
16157 GAME_CTRL_ID_STOP, NULL,
16158 TRUE, FALSE, "stop game"
16161 IMG_GFX_GAME_BUTTON_PAUSE, &game.button.pause,
16162 GAME_CTRL_ID_PAUSE, NULL,
16163 TRUE, FALSE, "pause game"
16166 IMG_GFX_GAME_BUTTON_PLAY, &game.button.play,
16167 GAME_CTRL_ID_PLAY, NULL,
16168 TRUE, FALSE, "play game"
16171 IMG_GFX_GAME_BUTTON_UNDO, &game.button.undo,
16172 GAME_CTRL_ID_UNDO, NULL,
16173 TRUE, FALSE, "undo step"
16176 IMG_GFX_GAME_BUTTON_REDO, &game.button.redo,
16177 GAME_CTRL_ID_REDO, NULL,
16178 TRUE, FALSE, "redo step"
16181 IMG_GFX_GAME_BUTTON_SAVE, &game.button.save,
16182 GAME_CTRL_ID_SAVE, NULL,
16183 TRUE, FALSE, "save game"
16186 IMG_GFX_GAME_BUTTON_PAUSE2, &game.button.pause2,
16187 GAME_CTRL_ID_PAUSE2, NULL,
16188 TRUE, FALSE, "pause game"
16191 IMG_GFX_GAME_BUTTON_LOAD, &game.button.load,
16192 GAME_CTRL_ID_LOAD, NULL,
16193 TRUE, FALSE, "load game"
16196 IMG_GFX_GAME_BUTTON_PANEL_STOP, &game.button.panel_stop,
16197 GAME_CTRL_ID_PANEL_STOP, NULL,
16198 FALSE, FALSE, "stop game"
16201 IMG_GFX_GAME_BUTTON_PANEL_PAUSE, &game.button.panel_pause,
16202 GAME_CTRL_ID_PANEL_PAUSE, NULL,
16203 FALSE, FALSE, "pause game"
16206 IMG_GFX_GAME_BUTTON_PANEL_PLAY, &game.button.panel_play,
16207 GAME_CTRL_ID_PANEL_PLAY, NULL,
16208 FALSE, FALSE, "play game"
16211 IMG_GFX_GAME_BUTTON_TOUCH_STOP, &game.button.touch_stop,
16212 GAME_CTRL_ID_TOUCH_STOP, NULL,
16213 FALSE, TRUE, "stop game"
16216 IMG_GFX_GAME_BUTTON_TOUCH_PAUSE, &game.button.touch_pause,
16217 GAME_CTRL_ID_TOUCH_PAUSE, NULL,
16218 FALSE, TRUE, "pause game"
16221 IMG_GFX_GAME_BUTTON_SOUND_MUSIC, &game.button.sound_music,
16222 SOUND_CTRL_ID_MUSIC, &setup.sound_music,
16223 TRUE, FALSE, "background music on/off"
16226 IMG_GFX_GAME_BUTTON_SOUND_LOOPS, &game.button.sound_loops,
16227 SOUND_CTRL_ID_LOOPS, &setup.sound_loops,
16228 TRUE, FALSE, "sound loops on/off"
16231 IMG_GFX_GAME_BUTTON_SOUND_SIMPLE, &game.button.sound_simple,
16232 SOUND_CTRL_ID_SIMPLE, &setup.sound_simple,
16233 TRUE, FALSE, "normal sounds on/off"
16236 IMG_GFX_GAME_BUTTON_PANEL_SOUND_MUSIC, &game.button.panel_sound_music,
16237 SOUND_CTRL_ID_PANEL_MUSIC, &setup.sound_music,
16238 FALSE, FALSE, "background music on/off"
16241 IMG_GFX_GAME_BUTTON_PANEL_SOUND_LOOPS, &game.button.panel_sound_loops,
16242 SOUND_CTRL_ID_PANEL_LOOPS, &setup.sound_loops,
16243 FALSE, FALSE, "sound loops on/off"
16246 IMG_GFX_GAME_BUTTON_PANEL_SOUND_SIMPLE, &game.button.panel_sound_simple,
16247 SOUND_CTRL_ID_PANEL_SIMPLE, &setup.sound_simple,
16248 FALSE, FALSE, "normal sounds on/off"
16252 void CreateGameButtons(void)
16256 for (i = 0; i < NUM_GAME_BUTTONS; i++)
16258 int graphic = gamebutton_info[i].graphic;
16259 struct GraphicInfo *gfx = &graphic_info[graphic];
16260 struct XY *pos = gamebutton_info[i].pos;
16261 struct GadgetInfo *gi;
16264 unsigned int event_mask;
16265 boolean is_touch_button = gamebutton_info[i].is_touch_button;
16266 boolean allowed_on_tape = gamebutton_info[i].allowed_on_tape;
16267 boolean on_tape = (tape.show_game_buttons && allowed_on_tape);
16268 int base_x = (is_touch_button ? 0 : on_tape ? VX : DX);
16269 int base_y = (is_touch_button ? 0 : on_tape ? VY : DY);
16270 int gd_x = gfx->src_x;
16271 int gd_y = gfx->src_y;
16272 int gd_xp = gfx->src_x + gfx->pressed_xoffset;
16273 int gd_yp = gfx->src_y + gfx->pressed_yoffset;
16274 int gd_xa = gfx->src_x + gfx->active_xoffset;
16275 int gd_ya = gfx->src_y + gfx->active_yoffset;
16276 int gd_xap = gfx->src_x + gfx->active_xoffset + gfx->pressed_xoffset;
16277 int gd_yap = gfx->src_y + gfx->active_yoffset + gfx->pressed_yoffset;
16278 int x = (is_touch_button ? pos->x : GDI_ACTIVE_POS(pos->x));
16279 int y = (is_touch_button ? pos->y : GDI_ACTIVE_POS(pos->y));
16282 if (gfx->bitmap == NULL)
16284 game_gadget[id] = NULL;
16289 if (id == GAME_CTRL_ID_STOP ||
16290 id == GAME_CTRL_ID_PANEL_STOP ||
16291 id == GAME_CTRL_ID_TOUCH_STOP ||
16292 id == GAME_CTRL_ID_PLAY ||
16293 id == GAME_CTRL_ID_PANEL_PLAY ||
16294 id == GAME_CTRL_ID_SAVE ||
16295 id == GAME_CTRL_ID_LOAD)
16297 button_type = GD_TYPE_NORMAL_BUTTON;
16299 event_mask = GD_EVENT_RELEASED;
16301 else if (id == GAME_CTRL_ID_UNDO ||
16302 id == GAME_CTRL_ID_REDO)
16304 button_type = GD_TYPE_NORMAL_BUTTON;
16306 event_mask = GD_EVENT_PRESSED | GD_EVENT_REPEATED;
16310 button_type = GD_TYPE_CHECK_BUTTON;
16311 checked = (gamebutton_info[i].setup_value != NULL ?
16312 *gamebutton_info[i].setup_value : FALSE);
16313 event_mask = GD_EVENT_PRESSED;
16316 gi = CreateGadget(GDI_CUSTOM_ID, id,
16317 GDI_IMAGE_ID, graphic,
16318 GDI_INFO_TEXT, gamebutton_info[i].infotext,
16321 GDI_WIDTH, gfx->width,
16322 GDI_HEIGHT, gfx->height,
16323 GDI_TYPE, button_type,
16324 GDI_STATE, GD_BUTTON_UNPRESSED,
16325 GDI_CHECKED, checked,
16326 GDI_DESIGN_UNPRESSED, gfx->bitmap, gd_x, gd_y,
16327 GDI_DESIGN_PRESSED, gfx->bitmap, gd_xp, gd_yp,
16328 GDI_ALT_DESIGN_UNPRESSED, gfx->bitmap, gd_xa, gd_ya,
16329 GDI_ALT_DESIGN_PRESSED, gfx->bitmap, gd_xap, gd_yap,
16330 GDI_DIRECT_DRAW, FALSE,
16331 GDI_OVERLAY_TOUCH_BUTTON, is_touch_button,
16332 GDI_EVENT_MASK, event_mask,
16333 GDI_CALLBACK_ACTION, HandleGameButtons,
16337 Fail("cannot create gadget");
16339 game_gadget[id] = gi;
16343 void FreeGameButtons(void)
16347 for (i = 0; i < NUM_GAME_BUTTONS; i++)
16348 FreeGadget(game_gadget[i]);
16351 static void UnmapGameButtonsAtSamePosition(int id)
16355 for (i = 0; i < NUM_GAME_BUTTONS; i++)
16357 gamebutton_info[i].pos->x == gamebutton_info[id].pos->x &&
16358 gamebutton_info[i].pos->y == gamebutton_info[id].pos->y)
16359 UnmapGadget(game_gadget[i]);
16362 static void UnmapGameButtonsAtSamePosition_All(void)
16364 if (setup.show_load_save_buttons)
16366 UnmapGameButtonsAtSamePosition(GAME_CTRL_ID_SAVE);
16367 UnmapGameButtonsAtSamePosition(GAME_CTRL_ID_PAUSE2);
16368 UnmapGameButtonsAtSamePosition(GAME_CTRL_ID_LOAD);
16370 else if (setup.show_undo_redo_buttons)
16372 UnmapGameButtonsAtSamePosition(GAME_CTRL_ID_UNDO);
16373 UnmapGameButtonsAtSamePosition(GAME_CTRL_ID_PAUSE2);
16374 UnmapGameButtonsAtSamePosition(GAME_CTRL_ID_REDO);
16378 UnmapGameButtonsAtSamePosition(GAME_CTRL_ID_STOP);
16379 UnmapGameButtonsAtSamePosition(GAME_CTRL_ID_PAUSE);
16380 UnmapGameButtonsAtSamePosition(GAME_CTRL_ID_PLAY);
16382 UnmapGameButtonsAtSamePosition(GAME_CTRL_ID_PANEL_STOP);
16383 UnmapGameButtonsAtSamePosition(GAME_CTRL_ID_PANEL_PAUSE);
16384 UnmapGameButtonsAtSamePosition(GAME_CTRL_ID_PANEL_PLAY);
16388 void MapLoadSaveButtons(void)
16390 UnmapGameButtonsAtSamePosition(GAME_CTRL_ID_LOAD);
16391 UnmapGameButtonsAtSamePosition(GAME_CTRL_ID_SAVE);
16393 MapGadget(game_gadget[GAME_CTRL_ID_LOAD]);
16394 MapGadget(game_gadget[GAME_CTRL_ID_SAVE]);
16397 void MapUndoRedoButtons(void)
16399 UnmapGameButtonsAtSamePosition(GAME_CTRL_ID_UNDO);
16400 UnmapGameButtonsAtSamePosition(GAME_CTRL_ID_REDO);
16402 MapGadget(game_gadget[GAME_CTRL_ID_UNDO]);
16403 MapGadget(game_gadget[GAME_CTRL_ID_REDO]);
16406 void ModifyPauseButtons(void)
16410 GAME_CTRL_ID_PAUSE,
16411 GAME_CTRL_ID_PAUSE2,
16412 GAME_CTRL_ID_PANEL_PAUSE,
16413 GAME_CTRL_ID_TOUCH_PAUSE,
16418 for (i = 0; ids[i] > -1; i++)
16419 ModifyGadget(game_gadget[ids[i]], GDI_CHECKED, tape.pausing, GDI_END);
16422 static void MapGameButtonsExt(boolean on_tape)
16426 for (i = 0; i < NUM_GAME_BUTTONS; i++)
16427 if (!on_tape || gamebutton_info[i].allowed_on_tape)
16428 MapGadget(game_gadget[i]);
16430 UnmapGameButtonsAtSamePosition_All();
16432 RedrawGameButtons();
16435 static void UnmapGameButtonsExt(boolean on_tape)
16439 for (i = 0; i < NUM_GAME_BUTTONS; i++)
16440 if (!on_tape || gamebutton_info[i].allowed_on_tape)
16441 UnmapGadget(game_gadget[i]);
16444 static void RedrawGameButtonsExt(boolean on_tape)
16448 for (i = 0; i < NUM_GAME_BUTTONS; i++)
16449 if (!on_tape || gamebutton_info[i].allowed_on_tape)
16450 RedrawGadget(game_gadget[i]);
16453 static void SetGadgetState(struct GadgetInfo *gi, boolean state)
16458 gi->checked = state;
16461 static void RedrawSoundButtonGadget(int id)
16463 int id2 = (id == SOUND_CTRL_ID_MUSIC ? SOUND_CTRL_ID_PANEL_MUSIC :
16464 id == SOUND_CTRL_ID_LOOPS ? SOUND_CTRL_ID_PANEL_LOOPS :
16465 id == SOUND_CTRL_ID_SIMPLE ? SOUND_CTRL_ID_PANEL_SIMPLE :
16466 id == SOUND_CTRL_ID_PANEL_MUSIC ? SOUND_CTRL_ID_MUSIC :
16467 id == SOUND_CTRL_ID_PANEL_LOOPS ? SOUND_CTRL_ID_LOOPS :
16468 id == SOUND_CTRL_ID_PANEL_SIMPLE ? SOUND_CTRL_ID_SIMPLE :
16471 SetGadgetState(game_gadget[id2], *gamebutton_info[id2].setup_value);
16472 RedrawGadget(game_gadget[id2]);
16475 void MapGameButtons(void)
16477 MapGameButtonsExt(FALSE);
16480 void UnmapGameButtons(void)
16482 UnmapGameButtonsExt(FALSE);
16485 void RedrawGameButtons(void)
16487 RedrawGameButtonsExt(FALSE);
16490 void MapGameButtonsOnTape(void)
16492 MapGameButtonsExt(TRUE);
16495 void UnmapGameButtonsOnTape(void)
16497 UnmapGameButtonsExt(TRUE);
16500 void RedrawGameButtonsOnTape(void)
16502 RedrawGameButtonsExt(TRUE);
16505 static void GameUndoRedoExt(void)
16507 ClearPlayerAction();
16509 tape.pausing = TRUE;
16512 UpdateAndDisplayGameControlValues();
16514 DrawCompleteVideoDisplay();
16515 DrawVideoDisplay(VIDEO_STATE_TIME_ON, TapeTime);
16516 DrawVideoDisplay(VIDEO_STATE_FRAME_ON, FrameCounter);
16517 DrawVideoDisplay(VIDEO_STATE_1STEP(tape.single_step), 0);
16519 ModifyPauseButtons();
16524 static void GameUndo(int steps)
16526 if (!CheckEngineSnapshotList())
16529 int tape_property_bits = tape.property_bits;
16531 LoadEngineSnapshot_Undo(steps);
16533 tape.property_bits |= tape_property_bits | TAPE_PROPERTY_SNAPSHOT;
16538 static void GameRedo(int steps)
16540 if (!CheckEngineSnapshotList())
16543 int tape_property_bits = tape.property_bits;
16545 LoadEngineSnapshot_Redo(steps);
16547 tape.property_bits |= tape_property_bits | TAPE_PROPERTY_SNAPSHOT;
16552 static void HandleGameButtonsExt(int id, int button)
16554 static boolean game_undo_executed = FALSE;
16555 int steps = BUTTON_STEPSIZE(button);
16556 boolean handle_game_buttons =
16557 (game_status == GAME_MODE_PLAYING ||
16558 (game_status == GAME_MODE_MAIN && tape.show_game_buttons));
16560 if (!handle_game_buttons)
16565 case GAME_CTRL_ID_STOP:
16566 case GAME_CTRL_ID_PANEL_STOP:
16567 case GAME_CTRL_ID_TOUCH_STOP:
16568 if (game_status == GAME_MODE_MAIN)
16574 RequestQuitGame(FALSE);
16578 case GAME_CTRL_ID_PAUSE:
16579 case GAME_CTRL_ID_PAUSE2:
16580 case GAME_CTRL_ID_PANEL_PAUSE:
16581 case GAME_CTRL_ID_TOUCH_PAUSE:
16582 if (network.enabled && game_status == GAME_MODE_PLAYING)
16585 SendToServer_ContinuePlaying();
16587 SendToServer_PausePlaying();
16590 TapeTogglePause(TAPE_TOGGLE_MANUAL);
16592 game_undo_executed = FALSE;
16596 case GAME_CTRL_ID_PLAY:
16597 case GAME_CTRL_ID_PANEL_PLAY:
16598 if (game_status == GAME_MODE_MAIN)
16600 StartGameActions(network.enabled, setup.autorecord, level.random_seed);
16602 else if (tape.pausing)
16604 if (network.enabled)
16605 SendToServer_ContinuePlaying();
16607 TapeTogglePause(TAPE_TOGGLE_MANUAL | TAPE_TOGGLE_PLAY_PAUSE);
16611 case GAME_CTRL_ID_UNDO:
16612 // Important: When using "save snapshot when collecting an item" mode,
16613 // load last (current) snapshot for first "undo" after pressing "pause"
16614 // (else the last-but-one snapshot would be loaded, because the snapshot
16615 // pointer already points to the last snapshot when pressing "pause",
16616 // which is fine for "every step/move" mode, but not for "every collect")
16617 if (game.snapshot.mode == SNAPSHOT_MODE_EVERY_COLLECT &&
16618 !game_undo_executed)
16621 game_undo_executed = TRUE;
16626 case GAME_CTRL_ID_REDO:
16630 case GAME_CTRL_ID_SAVE:
16634 case GAME_CTRL_ID_LOAD:
16638 case SOUND_CTRL_ID_MUSIC:
16639 case SOUND_CTRL_ID_PANEL_MUSIC:
16640 if (setup.sound_music)
16642 setup.sound_music = FALSE;
16646 else if (audio.music_available)
16648 setup.sound = setup.sound_music = TRUE;
16650 SetAudioMode(setup.sound);
16652 if (game_status == GAME_MODE_PLAYING)
16656 RedrawSoundButtonGadget(id);
16660 case SOUND_CTRL_ID_LOOPS:
16661 case SOUND_CTRL_ID_PANEL_LOOPS:
16662 if (setup.sound_loops)
16663 setup.sound_loops = FALSE;
16664 else if (audio.loops_available)
16666 setup.sound = setup.sound_loops = TRUE;
16668 SetAudioMode(setup.sound);
16671 RedrawSoundButtonGadget(id);
16675 case SOUND_CTRL_ID_SIMPLE:
16676 case SOUND_CTRL_ID_PANEL_SIMPLE:
16677 if (setup.sound_simple)
16678 setup.sound_simple = FALSE;
16679 else if (audio.sound_available)
16681 setup.sound = setup.sound_simple = TRUE;
16683 SetAudioMode(setup.sound);
16686 RedrawSoundButtonGadget(id);
16695 static void HandleGameButtons(struct GadgetInfo *gi)
16697 HandleGameButtonsExt(gi->custom_id, gi->event.button);
16700 void HandleSoundButtonKeys(Key key)
16702 if (key == setup.shortcut.sound_simple)
16703 ClickOnGadget(game_gadget[SOUND_CTRL_ID_SIMPLE], MB_LEFTBUTTON);
16704 else if (key == setup.shortcut.sound_loops)
16705 ClickOnGadget(game_gadget[SOUND_CTRL_ID_LOOPS], MB_LEFTBUTTON);
16706 else if (key == setup.shortcut.sound_music)
16707 ClickOnGadget(game_gadget[SOUND_CTRL_ID_MUSIC], MB_LEFTBUTTON);