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))
5099 if (is_better || entry_is_empty)
5101 // player has made it to the hall of fame
5103 if (i < MAX_SCORE_ENTRIES - 1)
5105 int m = MAX_SCORE_ENTRIES - 1;
5108 if (one_score_entry_per_name)
5110 for (l = i; l < MAX_SCORE_ENTRIES; l++)
5111 if (strEqual(list->entry[l].name, new_entry->name))
5114 if (m == i) // player's new highscore overwrites his old one
5118 for (l = m; l > i; l--)
5119 list->entry[l] = list->entry[l - 1];
5124 *entry = *new_entry;
5128 else if (one_score_entry_per_name &&
5129 strEqual(entry->name, new_entry->name))
5131 // player already in high score list with better score or time
5140 void NewHighScore(int level_nr, boolean tape_saved)
5142 struct ScoreEntry new_entry = {{ 0 }}; // (prevent warning from GCC bug 53119)
5143 boolean one_per_name = FALSE;
5145 strncpy(new_entry.tape_basename, tape.score_tape_basename, MAX_FILENAME_LEN);
5146 strncpy(new_entry.name, setup.player_name, MAX_PLAYER_NAME_LEN);
5148 new_entry.score = game.score_final;
5149 new_entry.time = game.score_time_final;
5151 LoadScore(level_nr);
5153 scores.last_added = addScoreEntry(&scores, &new_entry, one_per_name);
5155 if (scores.last_added < 0)
5158 SaveScore(level_nr);
5160 // store last added local score entry (before merging server scores)
5161 scores.last_added_local = scores.last_added;
5163 if (!game.LevelSolved_SaveTape)
5166 SaveScoreTape(level_nr);
5168 if (setup.ask_for_using_api_server)
5170 setup.use_api_server =
5171 Request("Upload your score and tape to the high score server?", REQ_ASK);
5173 if (!setup.use_api_server)
5174 Request("Not using high score server! Use setup menu to enable again!",
5177 runtime.use_api_server = setup.use_api_server;
5179 // after asking for using API server once, do not ask again
5180 setup.ask_for_using_api_server = FALSE;
5182 SaveSetup_ServerSetup();
5185 SaveServerScore(level_nr, tape_saved);
5188 void MergeServerScore(void)
5190 struct ScoreEntry last_added_entry;
5191 boolean one_per_name = FALSE;
5194 if (scores.last_added >= 0)
5195 last_added_entry = scores.entry[scores.last_added];
5197 for (i = 0; i < server_scores.num_entries; i++)
5199 int pos = addScoreEntry(&scores, &server_scores.entry[i], one_per_name);
5201 if (pos >= 0 && pos <= scores.last_added)
5202 scores.last_added++;
5205 if (scores.last_added >= MAX_SCORE_ENTRIES)
5207 scores.last_added = MAX_SCORE_ENTRIES - 1;
5208 scores.force_last_added = TRUE;
5210 scores.entry[scores.last_added] = last_added_entry;
5214 static int getElementMoveStepsizeExt(int x, int y, int direction)
5216 int element = Tile[x][y];
5217 int dx = (direction == MV_LEFT ? -1 : direction == MV_RIGHT ? +1 : 0);
5218 int dy = (direction == MV_UP ? -1 : direction == MV_DOWN ? +1 : 0);
5219 int horiz_move = (dx != 0);
5220 int sign = (horiz_move ? dx : dy);
5221 int step = sign * element_info[element].move_stepsize;
5223 // special values for move stepsize for spring and things on conveyor belt
5226 if (CAN_FALL(element) &&
5227 y < lev_fieldy - 1 && IS_BELT_ACTIVE(Tile[x][y + 1]))
5228 step = sign * MOVE_STEPSIZE_NORMAL / 2;
5229 else if (element == EL_SPRING)
5230 step = sign * MOVE_STEPSIZE_NORMAL * 2;
5236 static int getElementMoveStepsize(int x, int y)
5238 return getElementMoveStepsizeExt(x, y, MovDir[x][y]);
5241 void InitPlayerGfxAnimation(struct PlayerInfo *player, int action, int dir)
5243 if (player->GfxAction != action || player->GfxDir != dir)
5245 player->GfxAction = action;
5246 player->GfxDir = dir;
5248 player->StepFrame = 0;
5252 static void ResetGfxFrame(int x, int y)
5254 // profiling showed that "autotest" spends 10~20% of its time in this function
5255 if (DrawingDeactivatedField())
5258 int element = Tile[x][y];
5259 int graphic = el_act_dir2img(element, GfxAction[x][y], GfxDir[x][y]);
5261 if (graphic_info[graphic].anim_global_sync)
5262 GfxFrame[x][y] = FrameCounter;
5263 else if (ANIM_MODE(graphic) == ANIM_CE_VALUE)
5264 GfxFrame[x][y] = CustomValue[x][y];
5265 else if (ANIM_MODE(graphic) == ANIM_CE_SCORE)
5266 GfxFrame[x][y] = element_info[element].collect_score;
5267 else if (ANIM_MODE(graphic) == ANIM_CE_DELAY)
5268 GfxFrame[x][y] = ChangeDelay[x][y];
5271 static void ResetGfxAnimation(int x, int y)
5273 GfxAction[x][y] = ACTION_DEFAULT;
5274 GfxDir[x][y] = MovDir[x][y];
5277 ResetGfxFrame(x, y);
5280 static void ResetRandomAnimationValue(int x, int y)
5282 GfxRandom[x][y] = INIT_GFX_RANDOM();
5285 static void InitMovingField(int x, int y, int direction)
5287 int element = Tile[x][y];
5288 int dx = (direction == MV_LEFT ? -1 : direction == MV_RIGHT ? +1 : 0);
5289 int dy = (direction == MV_UP ? -1 : direction == MV_DOWN ? +1 : 0);
5292 boolean is_moving_before, is_moving_after;
5294 // check if element was/is moving or being moved before/after mode change
5295 is_moving_before = (WasJustMoving[x][y] != 0);
5296 is_moving_after = (getElementMoveStepsizeExt(x, y, direction) != 0);
5298 // reset animation only for moving elements which change direction of moving
5299 // or which just started or stopped moving
5300 // (else CEs with property "can move" / "not moving" are reset each frame)
5301 if (is_moving_before != is_moving_after ||
5302 direction != MovDir[x][y])
5303 ResetGfxAnimation(x, y);
5305 MovDir[x][y] = direction;
5306 GfxDir[x][y] = direction;
5308 GfxAction[x][y] = (!is_moving_after ? ACTION_WAITING :
5309 direction == MV_DOWN && CAN_FALL(element) ?
5310 ACTION_FALLING : ACTION_MOVING);
5312 // this is needed for CEs with property "can move" / "not moving"
5314 if (is_moving_after)
5316 if (Tile[newx][newy] == EL_EMPTY)
5317 Tile[newx][newy] = EL_BLOCKED;
5319 MovDir[newx][newy] = MovDir[x][y];
5321 CustomValue[newx][newy] = CustomValue[x][y];
5323 GfxFrame[newx][newy] = GfxFrame[x][y];
5324 GfxRandom[newx][newy] = GfxRandom[x][y];
5325 GfxAction[newx][newy] = GfxAction[x][y];
5326 GfxDir[newx][newy] = GfxDir[x][y];
5330 void Moving2Blocked(int x, int y, int *goes_to_x, int *goes_to_y)
5332 int direction = MovDir[x][y];
5333 int newx = x + (direction & MV_LEFT ? -1 : direction & MV_RIGHT ? +1 : 0);
5334 int newy = y + (direction & MV_UP ? -1 : direction & MV_DOWN ? +1 : 0);
5340 void Blocked2Moving(int x, int y, int *comes_from_x, int *comes_from_y)
5342 int oldx = x, oldy = y;
5343 int direction = MovDir[x][y];
5345 if (direction == MV_LEFT)
5347 else if (direction == MV_RIGHT)
5349 else if (direction == MV_UP)
5351 else if (direction == MV_DOWN)
5354 *comes_from_x = oldx;
5355 *comes_from_y = oldy;
5358 static int MovingOrBlocked2Element(int x, int y)
5360 int element = Tile[x][y];
5362 if (element == EL_BLOCKED)
5366 Blocked2Moving(x, y, &oldx, &oldy);
5367 return Tile[oldx][oldy];
5373 static int MovingOrBlocked2ElementIfNotLeaving(int x, int y)
5375 // like MovingOrBlocked2Element(), but if element is moving
5376 // and (x,y) is the field the moving element is just leaving,
5377 // return EL_BLOCKED instead of the element value
5378 int element = Tile[x][y];
5380 if (IS_MOVING(x, y))
5382 if (element == EL_BLOCKED)
5386 Blocked2Moving(x, y, &oldx, &oldy);
5387 return Tile[oldx][oldy];
5396 static void RemoveField(int x, int y)
5398 Tile[x][y] = EL_EMPTY;
5404 CustomValue[x][y] = 0;
5407 ChangeDelay[x][y] = 0;
5408 ChangePage[x][y] = -1;
5409 Pushed[x][y] = FALSE;
5411 GfxElement[x][y] = EL_UNDEFINED;
5412 GfxAction[x][y] = ACTION_DEFAULT;
5413 GfxDir[x][y] = MV_NONE;
5416 static void RemoveMovingField(int x, int y)
5418 int oldx = x, oldy = y, newx = x, newy = y;
5419 int element = Tile[x][y];
5420 int next_element = EL_UNDEFINED;
5422 if (element != EL_BLOCKED && !IS_MOVING(x, y))
5425 if (IS_MOVING(x, y))
5427 Moving2Blocked(x, y, &newx, &newy);
5429 if (Tile[newx][newy] != EL_BLOCKED)
5431 // element is moving, but target field is not free (blocked), but
5432 // already occupied by something different (example: acid pool);
5433 // in this case, only remove the moving field, but not the target
5435 RemoveField(oldx, oldy);
5437 Store[oldx][oldy] = Store2[oldx][oldy] = 0;
5439 TEST_DrawLevelField(oldx, oldy);
5444 else if (element == EL_BLOCKED)
5446 Blocked2Moving(x, y, &oldx, &oldy);
5447 if (!IS_MOVING(oldx, oldy))
5451 if (element == EL_BLOCKED &&
5452 (Tile[oldx][oldy] == EL_QUICKSAND_EMPTYING ||
5453 Tile[oldx][oldy] == EL_QUICKSAND_FAST_EMPTYING ||
5454 Tile[oldx][oldy] == EL_MAGIC_WALL_EMPTYING ||
5455 Tile[oldx][oldy] == EL_BD_MAGIC_WALL_EMPTYING ||
5456 Tile[oldx][oldy] == EL_DC_MAGIC_WALL_EMPTYING ||
5457 Tile[oldx][oldy] == EL_AMOEBA_DROPPING))
5458 next_element = get_next_element(Tile[oldx][oldy]);
5460 RemoveField(oldx, oldy);
5461 RemoveField(newx, newy);
5463 Store[oldx][oldy] = Store2[oldx][oldy] = 0;
5465 if (next_element != EL_UNDEFINED)
5466 Tile[oldx][oldy] = next_element;
5468 TEST_DrawLevelField(oldx, oldy);
5469 TEST_DrawLevelField(newx, newy);
5472 void DrawDynamite(int x, int y)
5474 int sx = SCREENX(x), sy = SCREENY(y);
5475 int graphic = el2img(Tile[x][y]);
5478 if (!IN_SCR_FIELD(sx, sy) || IS_PLAYER(x, y))
5481 if (IS_WALKABLE_INSIDE(Back[x][y]))
5485 DrawLevelElement(x, y, Back[x][y]);
5486 else if (Store[x][y])
5487 DrawLevelElement(x, y, Store[x][y]);
5488 else if (game.use_masked_elements)
5489 DrawLevelElement(x, y, EL_EMPTY);
5491 frame = getGraphicAnimationFrameXY(graphic, x, y);
5493 if (Back[x][y] || Store[x][y] || game.use_masked_elements)
5494 DrawGraphicThruMask(sx, sy, graphic, frame);
5496 DrawGraphic(sx, sy, graphic, frame);
5499 static void CheckDynamite(int x, int y)
5501 if (MovDelay[x][y] != 0) // dynamite is still waiting to explode
5505 if (MovDelay[x][y] != 0)
5508 PlayLevelSoundActionIfLoop(x, y, ACTION_ACTIVE);
5514 StopLevelSoundActionIfLoop(x, y, ACTION_ACTIVE);
5519 static void setMinimalPlayerBoundaries(int *sx1, int *sy1, int *sx2, int *sy2)
5521 boolean num_checked_players = 0;
5524 for (i = 0; i < MAX_PLAYERS; i++)
5526 if (stored_player[i].active)
5528 int sx = stored_player[i].jx;
5529 int sy = stored_player[i].jy;
5531 if (num_checked_players == 0)
5538 *sx1 = MIN(*sx1, sx);
5539 *sy1 = MIN(*sy1, sy);
5540 *sx2 = MAX(*sx2, sx);
5541 *sy2 = MAX(*sy2, sy);
5544 num_checked_players++;
5549 static boolean checkIfAllPlayersFitToScreen_RND(void)
5551 int sx1 = 0, sy1 = 0, sx2 = 0, sy2 = 0;
5553 setMinimalPlayerBoundaries(&sx1, &sy1, &sx2, &sy2);
5555 return (sx2 - sx1 < SCR_FIELDX &&
5556 sy2 - sy1 < SCR_FIELDY);
5559 static void setScreenCenteredToAllPlayers(int *sx, int *sy)
5561 int sx1 = scroll_x, sy1 = scroll_y, sx2 = scroll_x, sy2 = scroll_y;
5563 setMinimalPlayerBoundaries(&sx1, &sy1, &sx2, &sy2);
5565 *sx = (sx1 + sx2) / 2;
5566 *sy = (sy1 + sy2) / 2;
5569 static void DrawRelocateScreen(int old_x, int old_y, int x, int y, int move_dir,
5570 boolean center_screen, boolean quick_relocation)
5572 unsigned int frame_delay_value_old = GetVideoFrameDelay();
5573 boolean ffwd_delay = (tape.playing && tape.fast_forward);
5574 boolean no_delay = (tape.warp_forward);
5575 int frame_delay_value = (ffwd_delay ? FfwdFrameDelay : GameFrameDelay);
5576 int wait_delay_value = (no_delay ? 0 : frame_delay_value);
5577 int new_scroll_x, new_scroll_y;
5579 if (level.lazy_relocation && IN_VIS_FIELD(SCREENX(x), SCREENY(y)))
5581 // case 1: quick relocation inside visible screen (without scrolling)
5588 if (!level.shifted_relocation || center_screen)
5590 // relocation _with_ centering of screen
5592 new_scroll_x = SCROLL_POSITION_X(x);
5593 new_scroll_y = SCROLL_POSITION_Y(y);
5597 // relocation _without_ centering of screen
5599 int center_scroll_x = SCROLL_POSITION_X(old_x);
5600 int center_scroll_y = SCROLL_POSITION_Y(old_y);
5601 int offset_x = x + (scroll_x - center_scroll_x);
5602 int offset_y = y + (scroll_y - center_scroll_y);
5604 // for new screen position, apply previous offset to center position
5605 new_scroll_x = SCROLL_POSITION_X(offset_x);
5606 new_scroll_y = SCROLL_POSITION_Y(offset_y);
5609 if (quick_relocation)
5611 // case 2: quick relocation (redraw without visible scrolling)
5613 scroll_x = new_scroll_x;
5614 scroll_y = new_scroll_y;
5621 // case 3: visible relocation (with scrolling to new position)
5623 ScrollScreen(NULL, SCROLL_GO_ON); // scroll last frame to full tile
5625 SetVideoFrameDelay(wait_delay_value);
5627 while (scroll_x != new_scroll_x || scroll_y != new_scroll_y)
5629 int dx = (new_scroll_x < scroll_x ? +1 : new_scroll_x > scroll_x ? -1 : 0);
5630 int dy = (new_scroll_y < scroll_y ? +1 : new_scroll_y > scroll_y ? -1 : 0);
5632 if (dx == 0 && dy == 0) // no scrolling needed at all
5638 // set values for horizontal/vertical screen scrolling (half tile size)
5639 int dir_x = (dx != 0 ? MV_HORIZONTAL : 0);
5640 int dir_y = (dy != 0 ? MV_VERTICAL : 0);
5641 int pos_x = dx * TILEX / 2;
5642 int pos_y = dy * TILEY / 2;
5643 int fx = getFieldbufferOffsetX_RND(dir_x, pos_x);
5644 int fy = getFieldbufferOffsetY_RND(dir_y, pos_y);
5646 ScrollLevel(dx, dy);
5649 // scroll in two steps of half tile size to make things smoother
5650 BlitScreenToBitmapExt_RND(window, fx, fy);
5652 // scroll second step to align at full tile size
5653 BlitScreenToBitmap(window);
5659 SetVideoFrameDelay(frame_delay_value_old);
5662 static void RelocatePlayer(int jx, int jy, int el_player_raw)
5664 int el_player = GET_PLAYER_ELEMENT(el_player_raw);
5665 int player_nr = GET_PLAYER_NR(el_player);
5666 struct PlayerInfo *player = &stored_player[player_nr];
5667 boolean ffwd_delay = (tape.playing && tape.fast_forward);
5668 boolean no_delay = (tape.warp_forward);
5669 int frame_delay_value = (ffwd_delay ? FfwdFrameDelay : GameFrameDelay);
5670 int wait_delay_value = (no_delay ? 0 : frame_delay_value);
5671 int old_jx = player->jx;
5672 int old_jy = player->jy;
5673 int old_element = Tile[old_jx][old_jy];
5674 int element = Tile[jx][jy];
5675 boolean player_relocated = (old_jx != jx || old_jy != jy);
5677 int move_dir_horiz = (jx < old_jx ? MV_LEFT : jx > old_jx ? MV_RIGHT : 0);
5678 int move_dir_vert = (jy < old_jy ? MV_UP : jy > old_jy ? MV_DOWN : 0);
5679 int enter_side_horiz = MV_DIR_OPPOSITE(move_dir_horiz);
5680 int enter_side_vert = MV_DIR_OPPOSITE(move_dir_vert);
5681 int leave_side_horiz = move_dir_horiz;
5682 int leave_side_vert = move_dir_vert;
5683 int enter_side = enter_side_horiz | enter_side_vert;
5684 int leave_side = leave_side_horiz | leave_side_vert;
5686 if (player->buried) // do not reanimate dead player
5689 if (!player_relocated) // no need to relocate the player
5692 if (IS_PLAYER(jx, jy)) // player already placed at new position
5694 RemoveField(jx, jy); // temporarily remove newly placed player
5695 DrawLevelField(jx, jy);
5698 if (player->present)
5700 while (player->MovPos)
5702 ScrollPlayer(player, SCROLL_GO_ON);
5703 ScrollScreen(NULL, SCROLL_GO_ON);
5705 AdvanceFrameAndPlayerCounters(player->index_nr);
5709 BackToFront_WithFrameDelay(wait_delay_value);
5712 DrawPlayer(player); // needed here only to cleanup last field
5713 DrawLevelField(player->jx, player->jy); // remove player graphic
5715 player->is_moving = FALSE;
5718 if (IS_CUSTOM_ELEMENT(old_element))
5719 CheckElementChangeByPlayer(old_jx, old_jy, old_element,
5721 player->index_bit, leave_side);
5723 CheckTriggeredElementChangeByPlayer(old_jx, old_jy, old_element,
5725 player->index_bit, leave_side);
5727 Tile[jx][jy] = el_player;
5728 InitPlayerField(jx, jy, el_player, TRUE);
5730 /* "InitPlayerField()" above sets Tile[jx][jy] to EL_EMPTY, but it may be
5731 possible that the relocation target field did not contain a player element,
5732 but a walkable element, to which the new player was relocated -- in this
5733 case, restore that (already initialized!) element on the player field */
5734 if (!IS_PLAYER_ELEMENT(element)) // player may be set on walkable element
5736 Tile[jx][jy] = element; // restore previously existing element
5739 // only visually relocate centered player
5740 DrawRelocateScreen(old_jx, old_jy, player->jx, player->jy, player->MovDir,
5741 FALSE, level.instant_relocation);
5743 TestIfPlayerTouchesBadThing(jx, jy);
5744 TestIfPlayerTouchesCustomElement(jx, jy);
5746 if (IS_CUSTOM_ELEMENT(element))
5747 CheckElementChangeByPlayer(jx, jy, element, CE_ENTERED_BY_PLAYER,
5748 player->index_bit, enter_side);
5750 CheckTriggeredElementChangeByPlayer(jx, jy, element, CE_PLAYER_ENTERS_X,
5751 player->index_bit, enter_side);
5753 if (player->is_switching)
5755 /* ensure that relocation while still switching an element does not cause
5756 a new element to be treated as also switched directly after relocation
5757 (this is important for teleporter switches that teleport the player to
5758 a place where another teleporter switch is in the same direction, which
5759 would then incorrectly be treated as immediately switched before the
5760 direction key that caused the switch was released) */
5762 player->switch_x += jx - old_jx;
5763 player->switch_y += jy - old_jy;
5767 static void Explode(int ex, int ey, int phase, int mode)
5773 // !!! eliminate this variable !!!
5774 int delay = (game.emulation == EMU_SUPAPLEX ? 3 : 2);
5776 if (game.explosions_delayed)
5778 ExplodeField[ex][ey] = mode;
5782 if (phase == EX_PHASE_START) // initialize 'Store[][]' field
5784 int center_element = Tile[ex][ey];
5785 int artwork_element, explosion_element; // set these values later
5787 // remove things displayed in background while burning dynamite
5788 if (Back[ex][ey] != EL_EMPTY && !IS_INDESTRUCTIBLE(Back[ex][ey]))
5791 if (IS_MOVING(ex, ey) || IS_BLOCKED(ex, ey))
5793 // put moving element to center field (and let it explode there)
5794 center_element = MovingOrBlocked2Element(ex, ey);
5795 RemoveMovingField(ex, ey);
5796 Tile[ex][ey] = center_element;
5799 // now "center_element" is finally determined -- set related values now
5800 artwork_element = center_element; // for custom player artwork
5801 explosion_element = center_element; // for custom player artwork
5803 if (IS_PLAYER(ex, ey))
5805 int player_nr = GET_PLAYER_NR(StorePlayer[ex][ey]);
5807 artwork_element = stored_player[player_nr].artwork_element;
5809 if (level.use_explosion_element[player_nr])
5811 explosion_element = level.explosion_element[player_nr];
5812 artwork_element = explosion_element;
5816 if (mode == EX_TYPE_NORMAL ||
5817 mode == EX_TYPE_CENTER ||
5818 mode == EX_TYPE_CROSS)
5819 PlayLevelSoundElementAction(ex, ey, artwork_element, ACTION_EXPLODING);
5821 last_phase = element_info[explosion_element].explosion_delay + 1;
5823 for (y = ey - 1; y <= ey + 1; y++) for (x = ex - 1; x <= ex + 1; x++)
5825 int xx = x - ex + 1;
5826 int yy = y - ey + 1;
5829 if (!IN_LEV_FIELD(x, y) ||
5830 (mode & EX_TYPE_SINGLE_TILE && (x != ex || y != ey)) ||
5831 (mode == EX_TYPE_CROSS && (x != ex && y != ey)))
5834 element = Tile[x][y];
5836 if (IS_MOVING(x, y) || IS_BLOCKED(x, y))
5838 element = MovingOrBlocked2Element(x, y);
5840 if (!IS_EXPLOSION_PROOF(element))
5841 RemoveMovingField(x, y);
5844 // indestructible elements can only explode in center (but not flames)
5845 if ((IS_EXPLOSION_PROOF(element) && (x != ex || y != ey ||
5846 mode == EX_TYPE_BORDER)) ||
5847 element == EL_FLAMES)
5850 /* no idea why this was changed from 3.0.8 to 3.1.0 -- this causes buggy
5851 behaviour, for example when touching a yamyam that explodes to rocks
5852 with active deadly shield, a rock is created under the player !!! */
5853 // (case 1 (surely buggy): >= 3.1.0, case 2 (maybe buggy): <= 3.0.8)
5855 if (IS_PLAYER(x, y) && SHIELD_ON(PLAYERINFO(x, y)) &&
5856 (game.engine_version < VERSION_IDENT(3,1,0,0) ||
5857 (x == ex && y == ey && mode != EX_TYPE_BORDER)))
5859 if (IS_PLAYER(x, y) && SHIELD_ON(PLAYERINFO(x, y)))
5862 if (IS_ACTIVE_BOMB(element))
5864 // re-activate things under the bomb like gate or penguin
5865 Tile[x][y] = (Back[x][y] ? Back[x][y] : EL_EMPTY);
5872 // save walkable background elements while explosion on same tile
5873 if (IS_WALKABLE(element) && IS_INDESTRUCTIBLE(element) &&
5874 (x != ex || y != ey || mode == EX_TYPE_BORDER))
5875 Back[x][y] = element;
5877 // ignite explodable elements reached by other explosion
5878 if (element == EL_EXPLOSION)
5879 element = Store2[x][y];
5881 if (AmoebaNr[x][y] &&
5882 (element == EL_AMOEBA_FULL ||
5883 element == EL_BD_AMOEBA ||
5884 element == EL_AMOEBA_GROWING))
5886 AmoebaCnt[AmoebaNr[x][y]]--;
5887 AmoebaCnt2[AmoebaNr[x][y]]--;
5892 if (IS_PLAYER(ex, ey) && !PLAYER_EXPLOSION_PROTECTED(ex, ey))
5894 int player_nr = StorePlayer[ex][ey] - EL_PLAYER_1;
5896 Store[x][y] = EL_PLAYER_IS_EXPLODING_1 + player_nr;
5898 if (PLAYERINFO(ex, ey)->use_murphy)
5899 Store[x][y] = EL_EMPTY;
5902 // !!! check this case -- currently needed for rnd_rado_negundo_v,
5903 // !!! levels 015 018 019 020 021 022 023 026 027 028 !!!
5904 else if (IS_PLAYER_ELEMENT(center_element))
5905 Store[x][y] = EL_EMPTY;
5906 else if (center_element == EL_YAMYAM)
5907 Store[x][y] = level.yamyam_content[game.yamyam_content_nr].e[xx][yy];
5908 else if (element_info[center_element].content.e[xx][yy] != EL_EMPTY)
5909 Store[x][y] = element_info[center_element].content.e[xx][yy];
5911 // needed because EL_BD_BUTTERFLY is not defined as "CAN_EXPLODE"
5912 // (killing EL_BD_BUTTERFLY with dynamite would result in BD diamond
5913 // otherwise) -- FIX THIS !!!
5914 else if (!CAN_EXPLODE(element) && element != EL_BD_BUTTERFLY)
5915 Store[x][y] = element_info[element].content.e[1][1];
5917 else if (!CAN_EXPLODE(element))
5918 Store[x][y] = element_info[element].content.e[1][1];
5921 Store[x][y] = EL_EMPTY;
5923 if (x != ex || y != ey || mode == EX_TYPE_BORDER ||
5924 center_element == EL_AMOEBA_TO_DIAMOND)
5925 Store2[x][y] = element;
5927 Tile[x][y] = EL_EXPLOSION;
5928 GfxElement[x][y] = artwork_element;
5930 ExplodePhase[x][y] = 1;
5931 ExplodeDelay[x][y] = last_phase;
5936 if (center_element == EL_YAMYAM)
5937 game.yamyam_content_nr =
5938 (game.yamyam_content_nr + 1) % level.num_yamyam_contents;
5950 GfxFrame[x][y] = 0; // restart explosion animation
5952 last_phase = ExplodeDelay[x][y];
5954 ExplodePhase[x][y] = (phase < last_phase ? phase + 1 : 0);
5956 // this can happen if the player leaves an explosion just in time
5957 if (GfxElement[x][y] == EL_UNDEFINED)
5958 GfxElement[x][y] = EL_EMPTY;
5960 border_element = Store2[x][y];
5961 if (IS_PLAYER(x, y) && !PLAYER_EXPLOSION_PROTECTED(x, y))
5962 border_element = StorePlayer[x][y];
5964 if (phase == element_info[border_element].ignition_delay ||
5965 phase == last_phase)
5967 boolean border_explosion = FALSE;
5969 if (IS_PLAYER(x, y) && PLAYERINFO(x, y)->present &&
5970 !PLAYER_EXPLOSION_PROTECTED(x, y))
5972 KillPlayerUnlessExplosionProtected(x, y);
5973 border_explosion = TRUE;
5975 else if (CAN_EXPLODE_BY_EXPLOSION(border_element))
5977 Tile[x][y] = Store2[x][y];
5980 border_explosion = TRUE;
5982 else if (border_element == EL_AMOEBA_TO_DIAMOND)
5984 AmoebaToDiamond(x, y);
5986 border_explosion = TRUE;
5989 // if an element just explodes due to another explosion (chain-reaction),
5990 // do not immediately end the new explosion when it was the last frame of
5991 // the explosion (as it would be done in the following "if"-statement!)
5992 if (border_explosion && phase == last_phase)
5996 // this can happen if the player was just killed by an explosion
5997 if (GfxElement[x][y] == EL_UNDEFINED)
5998 GfxElement[x][y] = EL_EMPTY;
6000 if (phase == last_phase)
6004 element = Tile[x][y] = Store[x][y];
6005 Store[x][y] = Store2[x][y] = 0;
6006 GfxElement[x][y] = EL_UNDEFINED;
6008 // player can escape from explosions and might therefore be still alive
6009 if (element >= EL_PLAYER_IS_EXPLODING_1 &&
6010 element <= EL_PLAYER_IS_EXPLODING_4)
6012 int player_nr = element - EL_PLAYER_IS_EXPLODING_1;
6013 int explosion_element = EL_PLAYER_1 + player_nr;
6014 int xx = MIN(MAX(0, x - stored_player[player_nr].jx + 1), 2);
6015 int yy = MIN(MAX(0, y - stored_player[player_nr].jy + 1), 2);
6017 if (level.use_explosion_element[player_nr])
6018 explosion_element = level.explosion_element[player_nr];
6020 Tile[x][y] = (stored_player[player_nr].active ? EL_EMPTY :
6021 element_info[explosion_element].content.e[xx][yy]);
6024 // restore probably existing indestructible background element
6025 if (Back[x][y] && IS_INDESTRUCTIBLE(Back[x][y]))
6026 element = Tile[x][y] = Back[x][y];
6029 MovDir[x][y] = MovPos[x][y] = MovDelay[x][y] = 0;
6030 GfxDir[x][y] = MV_NONE;
6031 ChangeDelay[x][y] = 0;
6032 ChangePage[x][y] = -1;
6034 CustomValue[x][y] = 0;
6036 InitField_WithBug2(x, y, FALSE);
6038 TEST_DrawLevelField(x, y);
6040 TestIfElementTouchesCustomElement(x, y);
6042 if (GFX_CRUMBLED(element))
6043 TEST_DrawLevelFieldCrumbledNeighbours(x, y);
6045 if (IS_PLAYER(x, y) && !PLAYERINFO(x, y)->present)
6046 StorePlayer[x][y] = 0;
6048 if (IS_PLAYER_ELEMENT(element))
6049 RelocatePlayer(x, y, element);
6051 else if (IN_SCR_FIELD(SCREENX(x), SCREENY(y)))
6053 int graphic = el_act2img(GfxElement[x][y], ACTION_EXPLODING);
6054 int frame = getGraphicAnimationFrameXY(graphic, x, y);
6057 TEST_DrawLevelFieldCrumbled(x, y);
6059 if (IS_WALKABLE_OVER(Back[x][y]) && Back[x][y] != EL_EMPTY)
6061 DrawLevelElement(x, y, Back[x][y]);
6062 DrawGraphicThruMask(SCREENX(x), SCREENY(y), graphic, frame);
6064 else if (IS_WALKABLE_UNDER(Back[x][y]))
6066 DrawGraphic(SCREENX(x), SCREENY(y), graphic, frame);
6067 DrawLevelElementThruMask(x, y, Back[x][y]);
6069 else if (!IS_WALKABLE_INSIDE(Back[x][y]))
6070 DrawScreenGraphic(SCREENX(x), SCREENY(y), graphic, frame);
6074 static void DynaExplode(int ex, int ey)
6077 int dynabomb_element = Tile[ex][ey];
6078 int dynabomb_size = 1;
6079 boolean dynabomb_xl = FALSE;
6080 struct PlayerInfo *player;
6081 static int xy[4][2] =
6089 if (IS_ACTIVE_BOMB(dynabomb_element))
6091 player = &stored_player[dynabomb_element - EL_DYNABOMB_PLAYER_1_ACTIVE];
6092 dynabomb_size = player->dynabomb_size;
6093 dynabomb_xl = player->dynabomb_xl;
6094 player->dynabombs_left++;
6097 Explode(ex, ey, EX_PHASE_START, EX_TYPE_CENTER);
6099 for (i = 0; i < NUM_DIRECTIONS; i++)
6101 for (j = 1; j <= dynabomb_size; j++)
6103 int x = ex + j * xy[i][0];
6104 int y = ey + j * xy[i][1];
6107 if (!IN_LEV_FIELD(x, y) || IS_INDESTRUCTIBLE(Tile[x][y]))
6110 element = Tile[x][y];
6112 // do not restart explosions of fields with active bombs
6113 if (element == EL_EXPLOSION && IS_ACTIVE_BOMB(Store2[x][y]))
6116 Explode(x, y, EX_PHASE_START, EX_TYPE_BORDER);
6118 if (element != EL_EMPTY && element != EL_EXPLOSION &&
6119 !IS_DIGGABLE(element) && !dynabomb_xl)
6125 void Bang(int x, int y)
6127 int element = MovingOrBlocked2Element(x, y);
6128 int explosion_type = EX_TYPE_NORMAL;
6130 if (IS_PLAYER(x, y) && !PLAYER_EXPLOSION_PROTECTED(x, y))
6132 struct PlayerInfo *player = PLAYERINFO(x, y);
6134 element = Tile[x][y] = player->initial_element;
6136 if (level.use_explosion_element[player->index_nr])
6138 int explosion_element = level.explosion_element[player->index_nr];
6140 if (element_info[explosion_element].explosion_type == EXPLODES_CROSS)
6141 explosion_type = EX_TYPE_CROSS;
6142 else if (element_info[explosion_element].explosion_type == EXPLODES_1X1)
6143 explosion_type = EX_TYPE_CENTER;
6151 case EL_BD_BUTTERFLY:
6154 case EL_DARK_YAMYAM:
6158 RaiseScoreElement(element);
6161 case EL_DYNABOMB_PLAYER_1_ACTIVE:
6162 case EL_DYNABOMB_PLAYER_2_ACTIVE:
6163 case EL_DYNABOMB_PLAYER_3_ACTIVE:
6164 case EL_DYNABOMB_PLAYER_4_ACTIVE:
6165 case EL_DYNABOMB_INCREASE_NUMBER:
6166 case EL_DYNABOMB_INCREASE_SIZE:
6167 case EL_DYNABOMB_INCREASE_POWER:
6168 explosion_type = EX_TYPE_DYNA;
6171 case EL_DC_LANDMINE:
6172 explosion_type = EX_TYPE_CENTER;
6177 case EL_LAMP_ACTIVE:
6178 case EL_AMOEBA_TO_DIAMOND:
6179 if (!IS_PLAYER(x, y)) // penguin and player may be at same field
6180 explosion_type = EX_TYPE_CENTER;
6184 if (element_info[element].explosion_type == EXPLODES_CROSS)
6185 explosion_type = EX_TYPE_CROSS;
6186 else if (element_info[element].explosion_type == EXPLODES_1X1)
6187 explosion_type = EX_TYPE_CENTER;
6191 if (explosion_type == EX_TYPE_DYNA)
6194 Explode(x, y, EX_PHASE_START, explosion_type);
6196 CheckTriggeredElementChange(x, y, element, CE_EXPLOSION_OF_X);
6199 static void SplashAcid(int x, int y)
6201 if (IN_LEV_FIELD(x - 1, y - 1) && IS_FREE(x - 1, y - 1) &&
6202 (!IN_LEV_FIELD(x - 1, y - 2) ||
6203 !CAN_FALL(MovingOrBlocked2Element(x - 1, y - 2))))
6204 Tile[x - 1][y - 1] = EL_ACID_SPLASH_LEFT;
6206 if (IN_LEV_FIELD(x + 1, y - 1) && IS_FREE(x + 1, y - 1) &&
6207 (!IN_LEV_FIELD(x + 1, y - 2) ||
6208 !CAN_FALL(MovingOrBlocked2Element(x + 1, y - 2))))
6209 Tile[x + 1][y - 1] = EL_ACID_SPLASH_RIGHT;
6211 PlayLevelSound(x, y, SND_ACID_SPLASHING);
6214 static void InitBeltMovement(void)
6216 static int belt_base_element[4] =
6218 EL_CONVEYOR_BELT_1_LEFT,
6219 EL_CONVEYOR_BELT_2_LEFT,
6220 EL_CONVEYOR_BELT_3_LEFT,
6221 EL_CONVEYOR_BELT_4_LEFT
6223 static int belt_base_active_element[4] =
6225 EL_CONVEYOR_BELT_1_LEFT_ACTIVE,
6226 EL_CONVEYOR_BELT_2_LEFT_ACTIVE,
6227 EL_CONVEYOR_BELT_3_LEFT_ACTIVE,
6228 EL_CONVEYOR_BELT_4_LEFT_ACTIVE
6233 // set frame order for belt animation graphic according to belt direction
6234 for (i = 0; i < NUM_BELTS; i++)
6238 for (j = 0; j < NUM_BELT_PARTS; j++)
6240 int element = belt_base_active_element[belt_nr] + j;
6241 int graphic_1 = el2img(element);
6242 int graphic_2 = el2panelimg(element);
6244 if (game.belt_dir[i] == MV_LEFT)
6246 graphic_info[graphic_1].anim_mode &= ~ANIM_REVERSE;
6247 graphic_info[graphic_2].anim_mode &= ~ANIM_REVERSE;
6251 graphic_info[graphic_1].anim_mode |= ANIM_REVERSE;
6252 graphic_info[graphic_2].anim_mode |= ANIM_REVERSE;
6257 SCAN_PLAYFIELD(x, y)
6259 int element = Tile[x][y];
6261 for (i = 0; i < NUM_BELTS; i++)
6263 if (IS_BELT(element) && game.belt_dir[i] != MV_NONE)
6265 int e_belt_nr = getBeltNrFromBeltElement(element);
6268 if (e_belt_nr == belt_nr)
6270 int belt_part = Tile[x][y] - belt_base_element[belt_nr];
6272 Tile[x][y] = belt_base_active_element[belt_nr] + belt_part;
6279 static void ToggleBeltSwitch(int x, int y)
6281 static int belt_base_element[4] =
6283 EL_CONVEYOR_BELT_1_LEFT,
6284 EL_CONVEYOR_BELT_2_LEFT,
6285 EL_CONVEYOR_BELT_3_LEFT,
6286 EL_CONVEYOR_BELT_4_LEFT
6288 static int belt_base_active_element[4] =
6290 EL_CONVEYOR_BELT_1_LEFT_ACTIVE,
6291 EL_CONVEYOR_BELT_2_LEFT_ACTIVE,
6292 EL_CONVEYOR_BELT_3_LEFT_ACTIVE,
6293 EL_CONVEYOR_BELT_4_LEFT_ACTIVE
6295 static int belt_base_switch_element[4] =
6297 EL_CONVEYOR_BELT_1_SWITCH_LEFT,
6298 EL_CONVEYOR_BELT_2_SWITCH_LEFT,
6299 EL_CONVEYOR_BELT_3_SWITCH_LEFT,
6300 EL_CONVEYOR_BELT_4_SWITCH_LEFT
6302 static int belt_move_dir[4] =
6310 int element = Tile[x][y];
6311 int belt_nr = getBeltNrFromBeltSwitchElement(element);
6312 int belt_dir_nr = (game.belt_dir_nr[belt_nr] + 1) % 4;
6313 int belt_dir = belt_move_dir[belt_dir_nr];
6316 if (!IS_BELT_SWITCH(element))
6319 game.belt_dir_nr[belt_nr] = belt_dir_nr;
6320 game.belt_dir[belt_nr] = belt_dir;
6322 if (belt_dir_nr == 3)
6325 // set frame order for belt animation graphic according to belt direction
6326 for (i = 0; i < NUM_BELT_PARTS; i++)
6328 int element = belt_base_active_element[belt_nr] + i;
6329 int graphic_1 = el2img(element);
6330 int graphic_2 = el2panelimg(element);
6332 if (belt_dir == MV_LEFT)
6334 graphic_info[graphic_1].anim_mode &= ~ANIM_REVERSE;
6335 graphic_info[graphic_2].anim_mode &= ~ANIM_REVERSE;
6339 graphic_info[graphic_1].anim_mode |= ANIM_REVERSE;
6340 graphic_info[graphic_2].anim_mode |= ANIM_REVERSE;
6344 SCAN_PLAYFIELD(xx, yy)
6346 int element = Tile[xx][yy];
6348 if (IS_BELT_SWITCH(element))
6350 int e_belt_nr = getBeltNrFromBeltSwitchElement(element);
6352 if (e_belt_nr == belt_nr)
6354 Tile[xx][yy] = belt_base_switch_element[belt_nr] + belt_dir_nr;
6355 TEST_DrawLevelField(xx, yy);
6358 else if (IS_BELT(element) && belt_dir != MV_NONE)
6360 int e_belt_nr = getBeltNrFromBeltElement(element);
6362 if (e_belt_nr == belt_nr)
6364 int belt_part = Tile[xx][yy] - belt_base_element[belt_nr];
6366 Tile[xx][yy] = belt_base_active_element[belt_nr] + belt_part;
6367 TEST_DrawLevelField(xx, yy);
6370 else if (IS_BELT_ACTIVE(element) && belt_dir == MV_NONE)
6372 int e_belt_nr = getBeltNrFromBeltActiveElement(element);
6374 if (e_belt_nr == belt_nr)
6376 int belt_part = Tile[xx][yy] - belt_base_active_element[belt_nr];
6378 Tile[xx][yy] = belt_base_element[belt_nr] + belt_part;
6379 TEST_DrawLevelField(xx, yy);
6385 static void ToggleSwitchgateSwitch(int x, int y)
6389 game.switchgate_pos = !game.switchgate_pos;
6391 SCAN_PLAYFIELD(xx, yy)
6393 int element = Tile[xx][yy];
6395 if (element == EL_SWITCHGATE_SWITCH_UP)
6397 Tile[xx][yy] = EL_SWITCHGATE_SWITCH_DOWN;
6398 TEST_DrawLevelField(xx, yy);
6400 else if (element == EL_SWITCHGATE_SWITCH_DOWN)
6402 Tile[xx][yy] = EL_SWITCHGATE_SWITCH_UP;
6403 TEST_DrawLevelField(xx, yy);
6405 else if (element == EL_DC_SWITCHGATE_SWITCH_UP)
6407 Tile[xx][yy] = EL_DC_SWITCHGATE_SWITCH_DOWN;
6408 TEST_DrawLevelField(xx, yy);
6410 else if (element == EL_DC_SWITCHGATE_SWITCH_DOWN)
6412 Tile[xx][yy] = EL_DC_SWITCHGATE_SWITCH_UP;
6413 TEST_DrawLevelField(xx, yy);
6415 else if (element == EL_SWITCHGATE_OPEN ||
6416 element == EL_SWITCHGATE_OPENING)
6418 Tile[xx][yy] = EL_SWITCHGATE_CLOSING;
6420 PlayLevelSoundAction(xx, yy, ACTION_CLOSING);
6422 else if (element == EL_SWITCHGATE_CLOSED ||
6423 element == EL_SWITCHGATE_CLOSING)
6425 Tile[xx][yy] = EL_SWITCHGATE_OPENING;
6427 PlayLevelSoundAction(xx, yy, ACTION_OPENING);
6432 static int getInvisibleActiveFromInvisibleElement(int element)
6434 return (element == EL_INVISIBLE_STEELWALL ? EL_INVISIBLE_STEELWALL_ACTIVE :
6435 element == EL_INVISIBLE_WALL ? EL_INVISIBLE_WALL_ACTIVE :
6436 element == EL_INVISIBLE_SAND ? EL_INVISIBLE_SAND_ACTIVE :
6440 static int getInvisibleFromInvisibleActiveElement(int element)
6442 return (element == EL_INVISIBLE_STEELWALL_ACTIVE ? EL_INVISIBLE_STEELWALL :
6443 element == EL_INVISIBLE_WALL_ACTIVE ? EL_INVISIBLE_WALL :
6444 element == EL_INVISIBLE_SAND_ACTIVE ? EL_INVISIBLE_SAND :
6448 static void RedrawAllLightSwitchesAndInvisibleElements(void)
6452 SCAN_PLAYFIELD(x, y)
6454 int element = Tile[x][y];
6456 if (element == EL_LIGHT_SWITCH &&
6457 game.light_time_left > 0)
6459 Tile[x][y] = EL_LIGHT_SWITCH_ACTIVE;
6460 TEST_DrawLevelField(x, y);
6462 else if (element == EL_LIGHT_SWITCH_ACTIVE &&
6463 game.light_time_left == 0)
6465 Tile[x][y] = EL_LIGHT_SWITCH;
6466 TEST_DrawLevelField(x, y);
6468 else if (element == EL_EMC_DRIPPER &&
6469 game.light_time_left > 0)
6471 Tile[x][y] = EL_EMC_DRIPPER_ACTIVE;
6472 TEST_DrawLevelField(x, y);
6474 else if (element == EL_EMC_DRIPPER_ACTIVE &&
6475 game.light_time_left == 0)
6477 Tile[x][y] = EL_EMC_DRIPPER;
6478 TEST_DrawLevelField(x, y);
6480 else if (element == EL_INVISIBLE_STEELWALL ||
6481 element == EL_INVISIBLE_WALL ||
6482 element == EL_INVISIBLE_SAND)
6484 if (game.light_time_left > 0)
6485 Tile[x][y] = getInvisibleActiveFromInvisibleElement(element);
6487 TEST_DrawLevelField(x, y);
6489 // uncrumble neighbour fields, if needed
6490 if (element == EL_INVISIBLE_SAND)
6491 TEST_DrawLevelFieldCrumbledNeighbours(x, y);
6493 else if (element == EL_INVISIBLE_STEELWALL_ACTIVE ||
6494 element == EL_INVISIBLE_WALL_ACTIVE ||
6495 element == EL_INVISIBLE_SAND_ACTIVE)
6497 if (game.light_time_left == 0)
6498 Tile[x][y] = getInvisibleFromInvisibleActiveElement(element);
6500 TEST_DrawLevelField(x, y);
6502 // re-crumble neighbour fields, if needed
6503 if (element == EL_INVISIBLE_SAND)
6504 TEST_DrawLevelFieldCrumbledNeighbours(x, y);
6509 static void RedrawAllInvisibleElementsForLenses(void)
6513 SCAN_PLAYFIELD(x, y)
6515 int element = Tile[x][y];
6517 if (element == EL_EMC_DRIPPER &&
6518 game.lenses_time_left > 0)
6520 Tile[x][y] = EL_EMC_DRIPPER_ACTIVE;
6521 TEST_DrawLevelField(x, y);
6523 else if (element == EL_EMC_DRIPPER_ACTIVE &&
6524 game.lenses_time_left == 0)
6526 Tile[x][y] = EL_EMC_DRIPPER;
6527 TEST_DrawLevelField(x, y);
6529 else if (element == EL_INVISIBLE_STEELWALL ||
6530 element == EL_INVISIBLE_WALL ||
6531 element == EL_INVISIBLE_SAND)
6533 if (game.lenses_time_left > 0)
6534 Tile[x][y] = getInvisibleActiveFromInvisibleElement(element);
6536 TEST_DrawLevelField(x, y);
6538 // uncrumble neighbour fields, if needed
6539 if (element == EL_INVISIBLE_SAND)
6540 TEST_DrawLevelFieldCrumbledNeighbours(x, y);
6542 else if (element == EL_INVISIBLE_STEELWALL_ACTIVE ||
6543 element == EL_INVISIBLE_WALL_ACTIVE ||
6544 element == EL_INVISIBLE_SAND_ACTIVE)
6546 if (game.lenses_time_left == 0)
6547 Tile[x][y] = getInvisibleFromInvisibleActiveElement(element);
6549 TEST_DrawLevelField(x, y);
6551 // re-crumble neighbour fields, if needed
6552 if (element == EL_INVISIBLE_SAND)
6553 TEST_DrawLevelFieldCrumbledNeighbours(x, y);
6558 static void RedrawAllInvisibleElementsForMagnifier(void)
6562 SCAN_PLAYFIELD(x, y)
6564 int element = Tile[x][y];
6566 if (element == EL_EMC_FAKE_GRASS &&
6567 game.magnify_time_left > 0)
6569 Tile[x][y] = EL_EMC_FAKE_GRASS_ACTIVE;
6570 TEST_DrawLevelField(x, y);
6572 else if (element == EL_EMC_FAKE_GRASS_ACTIVE &&
6573 game.magnify_time_left == 0)
6575 Tile[x][y] = EL_EMC_FAKE_GRASS;
6576 TEST_DrawLevelField(x, y);
6578 else if (IS_GATE_GRAY(element) &&
6579 game.magnify_time_left > 0)
6581 Tile[x][y] = (IS_RND_GATE_GRAY(element) ?
6582 element - EL_GATE_1_GRAY + EL_GATE_1_GRAY_ACTIVE :
6583 IS_EM_GATE_GRAY(element) ?
6584 element - EL_EM_GATE_1_GRAY + EL_EM_GATE_1_GRAY_ACTIVE :
6585 IS_EMC_GATE_GRAY(element) ?
6586 element - EL_EMC_GATE_5_GRAY + EL_EMC_GATE_5_GRAY_ACTIVE :
6587 IS_DC_GATE_GRAY(element) ?
6588 EL_DC_GATE_WHITE_GRAY_ACTIVE :
6590 TEST_DrawLevelField(x, y);
6592 else if (IS_GATE_GRAY_ACTIVE(element) &&
6593 game.magnify_time_left == 0)
6595 Tile[x][y] = (IS_RND_GATE_GRAY_ACTIVE(element) ?
6596 element - EL_GATE_1_GRAY_ACTIVE + EL_GATE_1_GRAY :
6597 IS_EM_GATE_GRAY_ACTIVE(element) ?
6598 element - EL_EM_GATE_1_GRAY_ACTIVE + EL_EM_GATE_1_GRAY :
6599 IS_EMC_GATE_GRAY_ACTIVE(element) ?
6600 element - EL_EMC_GATE_5_GRAY_ACTIVE + EL_EMC_GATE_5_GRAY :
6601 IS_DC_GATE_GRAY_ACTIVE(element) ?
6602 EL_DC_GATE_WHITE_GRAY :
6604 TEST_DrawLevelField(x, y);
6609 static void ToggleLightSwitch(int x, int y)
6611 int element = Tile[x][y];
6613 game.light_time_left =
6614 (element == EL_LIGHT_SWITCH ?
6615 level.time_light * FRAMES_PER_SECOND : 0);
6617 RedrawAllLightSwitchesAndInvisibleElements();
6620 static void ActivateTimegateSwitch(int x, int y)
6624 game.timegate_time_left = level.time_timegate * FRAMES_PER_SECOND;
6626 SCAN_PLAYFIELD(xx, yy)
6628 int element = Tile[xx][yy];
6630 if (element == EL_TIMEGATE_CLOSED ||
6631 element == EL_TIMEGATE_CLOSING)
6633 Tile[xx][yy] = EL_TIMEGATE_OPENING;
6634 PlayLevelSound(xx, yy, SND_CLASS_TIMEGATE_OPENING);
6638 else if (element == EL_TIMEGATE_SWITCH_ACTIVE)
6640 Tile[xx][yy] = EL_TIMEGATE_SWITCH;
6641 TEST_DrawLevelField(xx, yy);
6647 Tile[x][y] = (Tile[x][y] == EL_TIMEGATE_SWITCH ? EL_TIMEGATE_SWITCH_ACTIVE :
6648 EL_DC_TIMEGATE_SWITCH_ACTIVE);
6651 static void Impact(int x, int y)
6653 boolean last_line = (y == lev_fieldy - 1);
6654 boolean object_hit = FALSE;
6655 boolean impact = (last_line || object_hit);
6656 int element = Tile[x][y];
6657 int smashed = EL_STEELWALL;
6659 if (!last_line) // check if element below was hit
6661 if (Tile[x][y + 1] == EL_PLAYER_IS_LEAVING)
6664 object_hit = (!IS_FREE(x, y + 1) && (!IS_MOVING(x, y + 1) ||
6665 MovDir[x][y + 1] != MV_DOWN ||
6666 MovPos[x][y + 1] <= TILEY / 2));
6668 // do not smash moving elements that left the smashed field in time
6669 if (game.engine_version >= VERSION_IDENT(2,2,0,7) && IS_MOVING(x, y + 1) &&
6670 ABS(MovPos[x][y + 1] + getElementMoveStepsize(x, y + 1)) >= TILEX)
6673 #if USE_QUICKSAND_IMPACT_BUGFIX
6674 if (Tile[x][y + 1] == EL_QUICKSAND_EMPTYING && object_hit == FALSE)
6676 RemoveMovingField(x, y + 1);
6677 Tile[x][y + 1] = EL_QUICKSAND_EMPTY;
6678 Tile[x][y + 2] = EL_ROCK;
6679 TEST_DrawLevelField(x, y + 2);
6684 if (Tile[x][y + 1] == EL_QUICKSAND_FAST_EMPTYING && object_hit == FALSE)
6686 RemoveMovingField(x, y + 1);
6687 Tile[x][y + 1] = EL_QUICKSAND_FAST_EMPTY;
6688 Tile[x][y + 2] = EL_ROCK;
6689 TEST_DrawLevelField(x, y + 2);
6696 smashed = MovingOrBlocked2Element(x, y + 1);
6698 impact = (last_line || object_hit);
6701 if (!last_line && smashed == EL_ACID) // element falls into acid
6703 SplashAcid(x, y + 1);
6707 // !!! not sufficient for all cases -- see EL_PEARL below !!!
6708 // only reset graphic animation if graphic really changes after impact
6710 el_act_dir2img(element, GfxAction[x][y], MV_DOWN) != el2img(element))
6712 ResetGfxAnimation(x, y);
6713 TEST_DrawLevelField(x, y);
6716 if (impact && CAN_EXPLODE_IMPACT(element))
6721 else if (impact && element == EL_PEARL &&
6722 smashed != EL_DC_MAGIC_WALL && smashed != EL_DC_MAGIC_WALL_ACTIVE)
6724 ResetGfxAnimation(x, y);
6726 Tile[x][y] = EL_PEARL_BREAKING;
6727 PlayLevelSound(x, y, SND_PEARL_BREAKING);
6730 else if (impact && CheckElementChange(x, y, element, smashed, CE_IMPACT))
6732 PlayLevelSoundElementAction(x, y, element, ACTION_IMPACT);
6737 if (impact && element == EL_AMOEBA_DROP)
6739 if (object_hit && IS_PLAYER(x, y + 1))
6740 KillPlayerUnlessEnemyProtected(x, y + 1);
6741 else if (object_hit && smashed == EL_PENGUIN)
6745 Tile[x][y] = EL_AMOEBA_GROWING;
6746 Store[x][y] = EL_AMOEBA_WET;
6748 ResetRandomAnimationValue(x, y);
6753 if (object_hit) // check which object was hit
6755 if ((CAN_PASS_MAGIC_WALL(element) &&
6756 (smashed == EL_MAGIC_WALL ||
6757 smashed == EL_BD_MAGIC_WALL)) ||
6758 (CAN_PASS_DC_MAGIC_WALL(element) &&
6759 smashed == EL_DC_MAGIC_WALL))
6762 int activated_magic_wall =
6763 (smashed == EL_MAGIC_WALL ? EL_MAGIC_WALL_ACTIVE :
6764 smashed == EL_BD_MAGIC_WALL ? EL_BD_MAGIC_WALL_ACTIVE :
6765 EL_DC_MAGIC_WALL_ACTIVE);
6767 // activate magic wall / mill
6768 SCAN_PLAYFIELD(xx, yy)
6770 if (Tile[xx][yy] == smashed)
6771 Tile[xx][yy] = activated_magic_wall;
6774 game.magic_wall_time_left = level.time_magic_wall * FRAMES_PER_SECOND;
6775 game.magic_wall_active = TRUE;
6777 PlayLevelSound(x, y, (smashed == EL_MAGIC_WALL ?
6778 SND_MAGIC_WALL_ACTIVATING :
6779 smashed == EL_BD_MAGIC_WALL ?
6780 SND_BD_MAGIC_WALL_ACTIVATING :
6781 SND_DC_MAGIC_WALL_ACTIVATING));
6784 if (IS_PLAYER(x, y + 1))
6786 if (CAN_SMASH_PLAYER(element))
6788 KillPlayerUnlessEnemyProtected(x, y + 1);
6792 else if (smashed == EL_PENGUIN)
6794 if (CAN_SMASH_PLAYER(element))
6800 else if (element == EL_BD_DIAMOND)
6802 if (IS_CLASSIC_ENEMY(smashed) && IS_BD_ELEMENT(smashed))
6808 else if (((element == EL_SP_INFOTRON ||
6809 element == EL_SP_ZONK) &&
6810 (smashed == EL_SP_SNIKSNAK ||
6811 smashed == EL_SP_ELECTRON ||
6812 smashed == EL_SP_DISK_ORANGE)) ||
6813 (element == EL_SP_INFOTRON &&
6814 smashed == EL_SP_DISK_YELLOW))
6819 else if (CAN_SMASH_EVERYTHING(element))
6821 if (IS_CLASSIC_ENEMY(smashed) ||
6822 CAN_EXPLODE_SMASHED(smashed))
6827 else if (!IS_MOVING(x, y + 1) && !IS_BLOCKED(x, y + 1))
6829 if (smashed == EL_LAMP ||
6830 smashed == EL_LAMP_ACTIVE)
6835 else if (smashed == EL_NUT)
6837 Tile[x][y + 1] = EL_NUT_BREAKING;
6838 PlayLevelSound(x, y, SND_NUT_BREAKING);
6839 RaiseScoreElement(EL_NUT);
6842 else if (smashed == EL_PEARL)
6844 ResetGfxAnimation(x, y);
6846 Tile[x][y + 1] = EL_PEARL_BREAKING;
6847 PlayLevelSound(x, y, SND_PEARL_BREAKING);
6850 else if (smashed == EL_DIAMOND)
6852 Tile[x][y + 1] = EL_DIAMOND_BREAKING;
6853 PlayLevelSound(x, y, SND_DIAMOND_BREAKING);
6856 else if (IS_BELT_SWITCH(smashed))
6858 ToggleBeltSwitch(x, y + 1);
6860 else if (smashed == EL_SWITCHGATE_SWITCH_UP ||
6861 smashed == EL_SWITCHGATE_SWITCH_DOWN ||
6862 smashed == EL_DC_SWITCHGATE_SWITCH_UP ||
6863 smashed == EL_DC_SWITCHGATE_SWITCH_DOWN)
6865 ToggleSwitchgateSwitch(x, y + 1);
6867 else if (smashed == EL_LIGHT_SWITCH ||
6868 smashed == EL_LIGHT_SWITCH_ACTIVE)
6870 ToggleLightSwitch(x, y + 1);
6874 CheckElementChange(x, y + 1, smashed, element, CE_SMASHED);
6876 CheckElementChangeBySide(x, y + 1, smashed, element,
6877 CE_SWITCHED, CH_SIDE_TOP);
6878 CheckTriggeredElementChangeBySide(x, y + 1, smashed, CE_SWITCH_OF_X,
6884 CheckElementChange(x, y + 1, smashed, element, CE_SMASHED);
6889 // play sound of magic wall / mill
6891 (Tile[x][y + 1] == EL_MAGIC_WALL_ACTIVE ||
6892 Tile[x][y + 1] == EL_BD_MAGIC_WALL_ACTIVE ||
6893 Tile[x][y + 1] == EL_DC_MAGIC_WALL_ACTIVE))
6895 if (Tile[x][y + 1] == EL_MAGIC_WALL_ACTIVE)
6896 PlayLevelSound(x, y, SND_MAGIC_WALL_FILLING);
6897 else if (Tile[x][y + 1] == EL_BD_MAGIC_WALL_ACTIVE)
6898 PlayLevelSound(x, y, SND_BD_MAGIC_WALL_FILLING);
6899 else if (Tile[x][y + 1] == EL_DC_MAGIC_WALL_ACTIVE)
6900 PlayLevelSound(x, y, SND_DC_MAGIC_WALL_FILLING);
6905 // play sound of object that hits the ground
6906 if (last_line || object_hit)
6907 PlayLevelSoundElementAction(x, y, element, ACTION_IMPACT);
6910 static void TurnRoundExt(int x, int y)
6922 { 0, 0 }, { 0, 0 }, { 0, 0 },
6927 int left, right, back;
6931 { MV_DOWN, MV_UP, MV_RIGHT },
6932 { MV_UP, MV_DOWN, MV_LEFT },
6934 { MV_LEFT, MV_RIGHT, MV_DOWN },
6938 { MV_RIGHT, MV_LEFT, MV_UP }
6941 int element = Tile[x][y];
6942 int move_pattern = element_info[element].move_pattern;
6944 int old_move_dir = MovDir[x][y];
6945 int left_dir = turn[old_move_dir].left;
6946 int right_dir = turn[old_move_dir].right;
6947 int back_dir = turn[old_move_dir].back;
6949 int left_dx = move_xy[left_dir].dx, left_dy = move_xy[left_dir].dy;
6950 int right_dx = move_xy[right_dir].dx, right_dy = move_xy[right_dir].dy;
6951 int move_dx = move_xy[old_move_dir].dx, move_dy = move_xy[old_move_dir].dy;
6952 int back_dx = move_xy[back_dir].dx, back_dy = move_xy[back_dir].dy;
6954 int left_x = x + left_dx, left_y = y + left_dy;
6955 int right_x = x + right_dx, right_y = y + right_dy;
6956 int move_x = x + move_dx, move_y = y + move_dy;
6960 if (element == EL_BUG || element == EL_BD_BUTTERFLY)
6962 TestIfBadThingTouchesOtherBadThing(x, y);
6964 if (ENEMY_CAN_ENTER_FIELD(element, right_x, right_y))
6965 MovDir[x][y] = right_dir;
6966 else if (!ENEMY_CAN_ENTER_FIELD(element, move_x, move_y))
6967 MovDir[x][y] = left_dir;
6969 if (element == EL_BUG && MovDir[x][y] != old_move_dir)
6971 else if (element == EL_BD_BUTTERFLY) // && MovDir[x][y] == left_dir)
6974 else if (element == EL_SPACESHIP || element == EL_BD_FIREFLY)
6976 TestIfBadThingTouchesOtherBadThing(x, y);
6978 if (ENEMY_CAN_ENTER_FIELD(element, left_x, left_y))
6979 MovDir[x][y] = left_dir;
6980 else if (!ENEMY_CAN_ENTER_FIELD(element, move_x, move_y))
6981 MovDir[x][y] = right_dir;
6983 if (element == EL_SPACESHIP && MovDir[x][y] != old_move_dir)
6985 else if (element == EL_BD_FIREFLY) // && MovDir[x][y] == right_dir)
6988 else if (element == EL_SP_SNIKSNAK || element == EL_SP_ELECTRON)
6990 TestIfBadThingTouchesOtherBadThing(x, y);
6992 if (ELEMENT_CAN_ENTER_FIELD_BASE_4(element, left_x, left_y, 0))
6993 MovDir[x][y] = left_dir;
6994 else if (!ELEMENT_CAN_ENTER_FIELD_BASE_4(element, move_x, move_y, 0))
6995 MovDir[x][y] = right_dir;
6997 if (MovDir[x][y] != old_move_dir)
7000 else if (element == EL_YAMYAM)
7002 boolean can_turn_left = YAMYAM_CAN_ENTER_FIELD(element, left_x, left_y);
7003 boolean can_turn_right = YAMYAM_CAN_ENTER_FIELD(element, right_x, right_y);
7005 if (can_turn_left && can_turn_right)
7006 MovDir[x][y] = (RND(3) ? (RND(2) ? left_dir : right_dir) : back_dir);
7007 else if (can_turn_left)
7008 MovDir[x][y] = (RND(2) ? left_dir : back_dir);
7009 else if (can_turn_right)
7010 MovDir[x][y] = (RND(2) ? right_dir : back_dir);
7012 MovDir[x][y] = back_dir;
7014 MovDelay[x][y] = 16 + 16 * RND(3);
7016 else if (element == EL_DARK_YAMYAM)
7018 boolean can_turn_left = DARK_YAMYAM_CAN_ENTER_FIELD(element,
7020 boolean can_turn_right = DARK_YAMYAM_CAN_ENTER_FIELD(element,
7023 if (can_turn_left && can_turn_right)
7024 MovDir[x][y] = (RND(3) ? (RND(2) ? left_dir : right_dir) : back_dir);
7025 else if (can_turn_left)
7026 MovDir[x][y] = (RND(2) ? left_dir : back_dir);
7027 else if (can_turn_right)
7028 MovDir[x][y] = (RND(2) ? right_dir : back_dir);
7030 MovDir[x][y] = back_dir;
7032 MovDelay[x][y] = 16 + 16 * RND(3);
7034 else if (element == EL_PACMAN)
7036 boolean can_turn_left = PACMAN_CAN_ENTER_FIELD(element, left_x, left_y);
7037 boolean can_turn_right = PACMAN_CAN_ENTER_FIELD(element, right_x, right_y);
7039 if (can_turn_left && can_turn_right)
7040 MovDir[x][y] = (RND(3) ? (RND(2) ? left_dir : right_dir) : back_dir);
7041 else if (can_turn_left)
7042 MovDir[x][y] = (RND(2) ? left_dir : back_dir);
7043 else if (can_turn_right)
7044 MovDir[x][y] = (RND(2) ? right_dir : back_dir);
7046 MovDir[x][y] = back_dir;
7048 MovDelay[x][y] = 6 + RND(40);
7050 else if (element == EL_PIG)
7052 boolean can_turn_left = PIG_CAN_ENTER_FIELD(element, left_x, left_y);
7053 boolean can_turn_right = PIG_CAN_ENTER_FIELD(element, right_x, right_y);
7054 boolean can_move_on = PIG_CAN_ENTER_FIELD(element, move_x, move_y);
7055 boolean should_turn_left, should_turn_right, should_move_on;
7057 int rnd = RND(rnd_value);
7059 should_turn_left = (can_turn_left &&
7061 IN_LEV_FIELD_AND_NOT_FREE(x + back_dx + left_dx,
7062 y + back_dy + left_dy)));
7063 should_turn_right = (can_turn_right &&
7065 IN_LEV_FIELD_AND_NOT_FREE(x + back_dx + right_dx,
7066 y + back_dy + right_dy)));
7067 should_move_on = (can_move_on &&
7070 IN_LEV_FIELD_AND_NOT_FREE(x + move_dx + left_dx,
7071 y + move_dy + left_dy) ||
7072 IN_LEV_FIELD_AND_NOT_FREE(x + move_dx + right_dx,
7073 y + move_dy + right_dy)));
7075 if (should_turn_left || should_turn_right || should_move_on)
7077 if (should_turn_left && should_turn_right && should_move_on)
7078 MovDir[x][y] = (rnd < rnd_value / 3 ? left_dir :
7079 rnd < 2 * rnd_value / 3 ? right_dir :
7081 else if (should_turn_left && should_turn_right)
7082 MovDir[x][y] = (rnd < rnd_value / 2 ? left_dir : right_dir);
7083 else if (should_turn_left && should_move_on)
7084 MovDir[x][y] = (rnd < rnd_value / 2 ? left_dir : old_move_dir);
7085 else if (should_turn_right && should_move_on)
7086 MovDir[x][y] = (rnd < rnd_value / 2 ? right_dir : old_move_dir);
7087 else if (should_turn_left)
7088 MovDir[x][y] = left_dir;
7089 else if (should_turn_right)
7090 MovDir[x][y] = right_dir;
7091 else if (should_move_on)
7092 MovDir[x][y] = old_move_dir;
7094 else if (can_move_on && rnd > rnd_value / 8)
7095 MovDir[x][y] = old_move_dir;
7096 else if (can_turn_left && can_turn_right)
7097 MovDir[x][y] = (rnd < rnd_value / 2 ? left_dir : right_dir);
7098 else if (can_turn_left && rnd > rnd_value / 8)
7099 MovDir[x][y] = left_dir;
7100 else if (can_turn_right && rnd > rnd_value/8)
7101 MovDir[x][y] = right_dir;
7103 MovDir[x][y] = back_dir;
7105 xx = x + move_xy[MovDir[x][y]].dx;
7106 yy = y + move_xy[MovDir[x][y]].dy;
7108 if (!IN_LEV_FIELD(xx, yy) ||
7109 (!IS_FREE(xx, yy) && !IS_FOOD_PIG(Tile[xx][yy])))
7110 MovDir[x][y] = old_move_dir;
7114 else if (element == EL_DRAGON)
7116 boolean can_turn_left = DRAGON_CAN_ENTER_FIELD(element, left_x, left_y);
7117 boolean can_turn_right = DRAGON_CAN_ENTER_FIELD(element, right_x, right_y);
7118 boolean can_move_on = DRAGON_CAN_ENTER_FIELD(element, move_x, move_y);
7120 int rnd = RND(rnd_value);
7122 if (can_move_on && rnd > rnd_value / 8)
7123 MovDir[x][y] = old_move_dir;
7124 else if (can_turn_left && can_turn_right)
7125 MovDir[x][y] = (rnd < rnd_value / 2 ? left_dir : right_dir);
7126 else if (can_turn_left && rnd > rnd_value / 8)
7127 MovDir[x][y] = left_dir;
7128 else if (can_turn_right && rnd > rnd_value / 8)
7129 MovDir[x][y] = right_dir;
7131 MovDir[x][y] = back_dir;
7133 xx = x + move_xy[MovDir[x][y]].dx;
7134 yy = y + move_xy[MovDir[x][y]].dy;
7136 if (!IN_LEV_FIELD_AND_IS_FREE(xx, yy))
7137 MovDir[x][y] = old_move_dir;
7141 else if (element == EL_MOLE)
7143 boolean can_move_on =
7144 (MOLE_CAN_ENTER_FIELD(element, move_x, move_y,
7145 IS_AMOEBOID(Tile[move_x][move_y]) ||
7146 Tile[move_x][move_y] == EL_AMOEBA_SHRINKING));
7149 boolean can_turn_left =
7150 (MOLE_CAN_ENTER_FIELD(element, left_x, left_y,
7151 IS_AMOEBOID(Tile[left_x][left_y])));
7153 boolean can_turn_right =
7154 (MOLE_CAN_ENTER_FIELD(element, right_x, right_y,
7155 IS_AMOEBOID(Tile[right_x][right_y])));
7157 if (can_turn_left && can_turn_right)
7158 MovDir[x][y] = (RND(2) ? left_dir : right_dir);
7159 else if (can_turn_left)
7160 MovDir[x][y] = left_dir;
7162 MovDir[x][y] = right_dir;
7165 if (MovDir[x][y] != old_move_dir)
7168 else if (element == EL_BALLOON)
7170 MovDir[x][y] = game.wind_direction;
7173 else if (element == EL_SPRING)
7175 if (MovDir[x][y] & MV_HORIZONTAL)
7177 if (SPRING_CAN_BUMP_FROM_FIELD(move_x, move_y) &&
7178 !SPRING_CAN_ENTER_FIELD(element, x, y + 1))
7180 Tile[move_x][move_y] = EL_EMC_SPRING_BUMPER_ACTIVE;
7181 ResetGfxAnimation(move_x, move_y);
7182 TEST_DrawLevelField(move_x, move_y);
7184 MovDir[x][y] = back_dir;
7186 else if (!SPRING_CAN_ENTER_FIELD(element, move_x, move_y) ||
7187 SPRING_CAN_ENTER_FIELD(element, x, y + 1))
7188 MovDir[x][y] = MV_NONE;
7193 else if (element == EL_ROBOT ||
7194 element == EL_SATELLITE ||
7195 element == EL_PENGUIN ||
7196 element == EL_EMC_ANDROID)
7198 int attr_x = -1, attr_y = -1;
7200 if (game.all_players_gone)
7202 attr_x = game.exit_x;
7203 attr_y = game.exit_y;
7209 for (i = 0; i < MAX_PLAYERS; i++)
7211 struct PlayerInfo *player = &stored_player[i];
7212 int jx = player->jx, jy = player->jy;
7214 if (!player->active)
7218 ABS(jx - x) + ABS(jy - y) < ABS(attr_x - x) + ABS(attr_y - y))
7226 if (element == EL_ROBOT &&
7227 game.robot_wheel_x >= 0 &&
7228 game.robot_wheel_y >= 0 &&
7229 (Tile[game.robot_wheel_x][game.robot_wheel_y] == EL_ROBOT_WHEEL_ACTIVE ||
7230 game.engine_version < VERSION_IDENT(3,1,0,0)))
7232 attr_x = game.robot_wheel_x;
7233 attr_y = game.robot_wheel_y;
7236 if (element == EL_PENGUIN)
7239 static int xy[4][2] =
7247 for (i = 0; i < NUM_DIRECTIONS; i++)
7249 int ex = x + xy[i][0];
7250 int ey = y + xy[i][1];
7252 if (IN_LEV_FIELD(ex, ey) && (Tile[ex][ey] == EL_EXIT_OPEN ||
7253 Tile[ex][ey] == EL_EM_EXIT_OPEN ||
7254 Tile[ex][ey] == EL_STEEL_EXIT_OPEN ||
7255 Tile[ex][ey] == EL_EM_STEEL_EXIT_OPEN))
7264 MovDir[x][y] = MV_NONE;
7266 MovDir[x][y] |= (game.all_players_gone ? MV_RIGHT : MV_LEFT);
7267 else if (attr_x > x)
7268 MovDir[x][y] |= (game.all_players_gone ? MV_LEFT : MV_RIGHT);
7270 MovDir[x][y] |= (game.all_players_gone ? MV_DOWN : MV_UP);
7271 else if (attr_y > y)
7272 MovDir[x][y] |= (game.all_players_gone ? MV_UP : MV_DOWN);
7274 if (element == EL_ROBOT)
7278 if (MovDir[x][y] & MV_HORIZONTAL && MovDir[x][y] & MV_VERTICAL)
7279 MovDir[x][y] &= (RND(2) ? MV_HORIZONTAL : MV_VERTICAL);
7280 Moving2Blocked(x, y, &newx, &newy);
7282 if (IN_LEV_FIELD(newx, newy) && IS_FREE_OR_PLAYER(newx, newy))
7283 MovDelay[x][y] = 8 + 8 * !RND(3);
7285 MovDelay[x][y] = 16;
7287 else if (element == EL_PENGUIN)
7293 if (MovDir[x][y] & MV_HORIZONTAL && MovDir[x][y] & MV_VERTICAL)
7295 boolean first_horiz = RND(2);
7296 int new_move_dir = MovDir[x][y];
7299 new_move_dir & (first_horiz ? MV_HORIZONTAL : MV_VERTICAL);
7300 Moving2Blocked(x, y, &newx, &newy);
7302 if (PENGUIN_CAN_ENTER_FIELD(element, newx, newy))
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))
7312 MovDir[x][y] = old_move_dir;
7316 else if (element == EL_SATELLITE)
7322 if (MovDir[x][y] & MV_HORIZONTAL && MovDir[x][y] & MV_VERTICAL)
7324 boolean first_horiz = RND(2);
7325 int new_move_dir = MovDir[x][y];
7328 new_move_dir & (first_horiz ? MV_HORIZONTAL : MV_VERTICAL);
7329 Moving2Blocked(x, y, &newx, &newy);
7331 if (SATELLITE_CAN_ENTER_FIELD(newx, newy))
7335 new_move_dir & (!first_horiz ? MV_HORIZONTAL : MV_VERTICAL);
7336 Moving2Blocked(x, y, &newx, &newy);
7338 if (SATELLITE_CAN_ENTER_FIELD(newx, newy))
7341 MovDir[x][y] = old_move_dir;
7345 else if (element == EL_EMC_ANDROID)
7347 static int check_pos[16] =
7349 -1, // 0 => (invalid)
7352 -1, // 3 => (invalid)
7354 0, // 5 => MV_LEFT | MV_UP
7355 2, // 6 => MV_RIGHT | MV_UP
7356 -1, // 7 => (invalid)
7358 6, // 9 => MV_LEFT | MV_DOWN
7359 4, // 10 => MV_RIGHT | MV_DOWN
7360 -1, // 11 => (invalid)
7361 -1, // 12 => (invalid)
7362 -1, // 13 => (invalid)
7363 -1, // 14 => (invalid)
7364 -1, // 15 => (invalid)
7372 { -1, -1, MV_LEFT | MV_UP },
7374 { +1, -1, MV_RIGHT | MV_UP },
7375 { +1, 0, MV_RIGHT },
7376 { +1, +1, MV_RIGHT | MV_DOWN },
7378 { -1, +1, MV_LEFT | MV_DOWN },
7381 int start_pos, check_order;
7382 boolean can_clone = FALSE;
7385 // check if there is any free field around current position
7386 for (i = 0; i < 8; i++)
7388 int newx = x + check_xy[i].dx;
7389 int newy = y + check_xy[i].dy;
7391 if (IN_LEV_FIELD_AND_IS_FREE(newx, newy))
7399 if (can_clone) // randomly find an element to clone
7403 start_pos = check_pos[RND(8)];
7404 check_order = (RND(2) ? -1 : +1);
7406 for (i = 0; i < 8; i++)
7408 int pos_raw = start_pos + i * check_order;
7409 int pos = (pos_raw + 8) % 8;
7410 int newx = x + check_xy[pos].dx;
7411 int newy = y + check_xy[pos].dy;
7413 if (ANDROID_CAN_CLONE_FIELD(newx, newy))
7415 element_info[element].move_leave_type = LEAVE_TYPE_LIMITED;
7416 element_info[element].move_leave_element = EL_TRIGGER_ELEMENT;
7418 Store[x][y] = Tile[newx][newy];
7427 if (can_clone) // randomly find a direction to move
7431 start_pos = check_pos[RND(8)];
7432 check_order = (RND(2) ? -1 : +1);
7434 for (i = 0; i < 8; i++)
7436 int pos_raw = start_pos + i * check_order;
7437 int pos = (pos_raw + 8) % 8;
7438 int newx = x + check_xy[pos].dx;
7439 int newy = y + check_xy[pos].dy;
7440 int new_move_dir = check_xy[pos].dir;
7442 if (IN_LEV_FIELD_AND_IS_FREE(newx, newy))
7444 MovDir[x][y] = new_move_dir;
7445 MovDelay[x][y] = level.android_clone_time * 8 + 1;
7454 if (can_clone) // cloning and moving successful
7457 // cannot clone -- try to move towards player
7459 start_pos = check_pos[MovDir[x][y] & 0x0f];
7460 check_order = (RND(2) ? -1 : +1);
7462 for (i = 0; i < 3; i++)
7464 // first check start_pos, then previous/next or (next/previous) pos
7465 int pos_raw = start_pos + (i < 2 ? i : -1) * check_order;
7466 int pos = (pos_raw + 8) % 8;
7467 int newx = x + check_xy[pos].dx;
7468 int newy = y + check_xy[pos].dy;
7469 int new_move_dir = check_xy[pos].dir;
7471 if (IS_PLAYER(newx, newy))
7474 if (ANDROID_CAN_ENTER_FIELD(element, newx, newy))
7476 MovDir[x][y] = new_move_dir;
7477 MovDelay[x][y] = level.android_move_time * 8 + 1;
7484 else if (move_pattern == MV_TURNING_LEFT ||
7485 move_pattern == MV_TURNING_RIGHT ||
7486 move_pattern == MV_TURNING_LEFT_RIGHT ||
7487 move_pattern == MV_TURNING_RIGHT_LEFT ||
7488 move_pattern == MV_TURNING_RANDOM ||
7489 move_pattern == MV_ALL_DIRECTIONS)
7491 boolean can_turn_left =
7492 CUSTOM_ELEMENT_CAN_ENTER_FIELD(element, left_x, left_y);
7493 boolean can_turn_right =
7494 CUSTOM_ELEMENT_CAN_ENTER_FIELD(element, right_x,right_y);
7496 if (element_info[element].move_stepsize == 0) // "not moving"
7499 if (move_pattern == MV_TURNING_LEFT)
7500 MovDir[x][y] = left_dir;
7501 else if (move_pattern == MV_TURNING_RIGHT)
7502 MovDir[x][y] = right_dir;
7503 else if (move_pattern == MV_TURNING_LEFT_RIGHT)
7504 MovDir[x][y] = (can_turn_left || !can_turn_right ? left_dir : right_dir);
7505 else if (move_pattern == MV_TURNING_RIGHT_LEFT)
7506 MovDir[x][y] = (can_turn_right || !can_turn_left ? right_dir : left_dir);
7507 else if (move_pattern == MV_TURNING_RANDOM)
7508 MovDir[x][y] = (can_turn_left && !can_turn_right ? left_dir :
7509 can_turn_right && !can_turn_left ? right_dir :
7510 RND(2) ? left_dir : right_dir);
7511 else if (can_turn_left && can_turn_right)
7512 MovDir[x][y] = (RND(3) ? (RND(2) ? left_dir : right_dir) : back_dir);
7513 else if (can_turn_left)
7514 MovDir[x][y] = (RND(2) ? left_dir : back_dir);
7515 else if (can_turn_right)
7516 MovDir[x][y] = (RND(2) ? right_dir : back_dir);
7518 MovDir[x][y] = back_dir;
7520 MovDelay[x][y] = GET_NEW_MOVE_DELAY(element);
7522 else if (move_pattern == MV_HORIZONTAL ||
7523 move_pattern == MV_VERTICAL)
7525 if (move_pattern & old_move_dir)
7526 MovDir[x][y] = back_dir;
7527 else if (move_pattern == MV_HORIZONTAL)
7528 MovDir[x][y] = (RND(2) ? MV_LEFT : MV_RIGHT);
7529 else if (move_pattern == MV_VERTICAL)
7530 MovDir[x][y] = (RND(2) ? MV_UP : MV_DOWN);
7532 MovDelay[x][y] = GET_NEW_MOVE_DELAY(element);
7534 else if (move_pattern & MV_ANY_DIRECTION)
7536 MovDir[x][y] = move_pattern;
7537 MovDelay[x][y] = GET_NEW_MOVE_DELAY(element);
7539 else if (move_pattern & MV_WIND_DIRECTION)
7541 MovDir[x][y] = game.wind_direction;
7542 MovDelay[x][y] = GET_NEW_MOVE_DELAY(element);
7544 else if (move_pattern == MV_ALONG_LEFT_SIDE)
7546 if (CUSTOM_ELEMENT_CAN_ENTER_FIELD(element, left_x, left_y))
7547 MovDir[x][y] = left_dir;
7548 else if (!CUSTOM_ELEMENT_CAN_ENTER_FIELD(element, move_x, move_y))
7549 MovDir[x][y] = right_dir;
7551 if (MovDir[x][y] != old_move_dir)
7552 MovDelay[x][y] = GET_NEW_MOVE_DELAY(element);
7554 else if (move_pattern == MV_ALONG_RIGHT_SIDE)
7556 if (CUSTOM_ELEMENT_CAN_ENTER_FIELD(element, right_x, right_y))
7557 MovDir[x][y] = right_dir;
7558 else if (!CUSTOM_ELEMENT_CAN_ENTER_FIELD(element, move_x, move_y))
7559 MovDir[x][y] = left_dir;
7561 if (MovDir[x][y] != old_move_dir)
7562 MovDelay[x][y] = GET_NEW_MOVE_DELAY(element);
7564 else if (move_pattern == MV_TOWARDS_PLAYER ||
7565 move_pattern == MV_AWAY_FROM_PLAYER)
7567 int attr_x = -1, attr_y = -1;
7569 boolean move_away = (move_pattern == MV_AWAY_FROM_PLAYER);
7571 if (game.all_players_gone)
7573 attr_x = game.exit_x;
7574 attr_y = game.exit_y;
7580 for (i = 0; i < MAX_PLAYERS; i++)
7582 struct PlayerInfo *player = &stored_player[i];
7583 int jx = player->jx, jy = player->jy;
7585 if (!player->active)
7589 ABS(jx - x) + ABS(jy - y) < ABS(attr_x - x) + ABS(attr_y - y))
7597 MovDir[x][y] = MV_NONE;
7599 MovDir[x][y] |= (move_away ? MV_RIGHT : MV_LEFT);
7600 else if (attr_x > x)
7601 MovDir[x][y] |= (move_away ? MV_LEFT : MV_RIGHT);
7603 MovDir[x][y] |= (move_away ? MV_DOWN : MV_UP);
7604 else if (attr_y > y)
7605 MovDir[x][y] |= (move_away ? MV_UP : MV_DOWN);
7607 MovDelay[x][y] = GET_NEW_MOVE_DELAY(element);
7609 if (MovDir[x][y] & MV_HORIZONTAL && MovDir[x][y] & MV_VERTICAL)
7611 boolean first_horiz = RND(2);
7612 int new_move_dir = MovDir[x][y];
7614 if (element_info[element].move_stepsize == 0) // "not moving"
7616 first_horiz = (ABS(attr_x - x) >= ABS(attr_y - y));
7617 MovDir[x][y] &= (first_horiz ? MV_HORIZONTAL : MV_VERTICAL);
7623 new_move_dir & (first_horiz ? MV_HORIZONTAL : MV_VERTICAL);
7624 Moving2Blocked(x, y, &newx, &newy);
7626 if (CUSTOM_ELEMENT_CAN_ENTER_FIELD(element, newx, newy))
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))
7636 MovDir[x][y] = old_move_dir;
7639 else if (move_pattern == MV_WHEN_PUSHED ||
7640 move_pattern == MV_WHEN_DROPPED)
7642 if (!CUSTOM_ELEMENT_CAN_ENTER_FIELD(element, move_x, move_y))
7643 MovDir[x][y] = MV_NONE;
7647 else if (move_pattern & MV_MAZE_RUNNER_STYLE)
7649 static int test_xy[7][2] =
7659 static int test_dir[7] =
7669 boolean hunter_mode = (move_pattern == MV_MAZE_HUNTER);
7670 int move_preference = -1000000; // start with very low preference
7671 int new_move_dir = MV_NONE;
7672 int start_test = RND(4);
7675 for (i = 0; i < NUM_DIRECTIONS; i++)
7677 int move_dir = test_dir[start_test + i];
7678 int move_dir_preference;
7680 xx = x + test_xy[start_test + i][0];
7681 yy = y + test_xy[start_test + i][1];
7683 if (hunter_mode && IN_LEV_FIELD(xx, yy) &&
7684 (IS_PLAYER(xx, yy) || Tile[xx][yy] == EL_PLAYER_IS_LEAVING))
7686 new_move_dir = move_dir;
7691 if (!CUSTOM_ELEMENT_CAN_ENTER_FIELD(element, xx, yy))
7694 move_dir_preference = -1 * RunnerVisit[xx][yy];
7695 if (hunter_mode && PlayerVisit[xx][yy] > 0)
7696 move_dir_preference = PlayerVisit[xx][yy];
7698 if (move_dir_preference > move_preference)
7700 // prefer field that has not been visited for the longest time
7701 move_preference = move_dir_preference;
7702 new_move_dir = move_dir;
7704 else if (move_dir_preference == move_preference &&
7705 move_dir == old_move_dir)
7707 // prefer last direction when all directions are preferred equally
7708 move_preference = move_dir_preference;
7709 new_move_dir = move_dir;
7713 MovDir[x][y] = new_move_dir;
7714 if (old_move_dir != new_move_dir)
7715 MovDelay[x][y] = GET_NEW_MOVE_DELAY(element);
7719 static void TurnRound(int x, int y)
7721 int direction = MovDir[x][y];
7725 GfxDir[x][y] = MovDir[x][y];
7727 if (direction != MovDir[x][y])
7731 GfxAction[x][y] = ACTION_TURNING_FROM_LEFT + MV_DIR_TO_BIT(direction);
7733 ResetGfxFrame(x, y);
7736 static boolean JustBeingPushed(int x, int y)
7740 for (i = 0; i < MAX_PLAYERS; i++)
7742 struct PlayerInfo *player = &stored_player[i];
7744 if (player->active && player->is_pushing && player->MovPos)
7746 int next_jx = player->jx + (player->jx - player->last_jx);
7747 int next_jy = player->jy + (player->jy - player->last_jy);
7749 if (x == next_jx && y == next_jy)
7757 static void StartMoving(int x, int y)
7759 boolean started_moving = FALSE; // some elements can fall _and_ move
7760 int element = Tile[x][y];
7765 if (MovDelay[x][y] == 0)
7766 GfxAction[x][y] = ACTION_DEFAULT;
7768 if (CAN_FALL(element) && y < lev_fieldy - 1)
7770 if ((x > 0 && IS_PLAYER(x - 1, y)) ||
7771 (x < lev_fieldx - 1 && IS_PLAYER(x + 1, y)))
7772 if (JustBeingPushed(x, y))
7775 if (element == EL_QUICKSAND_FULL)
7777 if (IS_FREE(x, y + 1))
7779 InitMovingField(x, y, MV_DOWN);
7780 started_moving = TRUE;
7782 Tile[x][y] = EL_QUICKSAND_EMPTYING;
7783 #if USE_QUICKSAND_BD_ROCK_BUGFIX
7784 if (Store[x][y] != EL_ROCK && Store[x][y] != EL_BD_ROCK)
7785 Store[x][y] = EL_ROCK;
7787 Store[x][y] = EL_ROCK;
7790 PlayLevelSoundAction(x, y, ACTION_EMPTYING);
7792 else if (Tile[x][y + 1] == EL_QUICKSAND_EMPTY)
7794 if (!MovDelay[x][y])
7796 MovDelay[x][y] = TILEY + 1;
7798 ResetGfxAnimation(x, y);
7799 ResetGfxAnimation(x, y + 1);
7804 DrawLevelElement(x, y, EL_QUICKSAND_EMPTYING);
7805 DrawLevelElement(x, y + 1, EL_QUICKSAND_FILLING);
7812 Tile[x][y] = EL_QUICKSAND_EMPTY;
7813 Tile[x][y + 1] = EL_QUICKSAND_FULL;
7814 Store[x][y + 1] = Store[x][y];
7817 PlayLevelSoundAction(x, y, ACTION_FILLING);
7819 else if (Tile[x][y + 1] == EL_QUICKSAND_FAST_EMPTY)
7821 if (!MovDelay[x][y])
7823 MovDelay[x][y] = TILEY + 1;
7825 ResetGfxAnimation(x, y);
7826 ResetGfxAnimation(x, y + 1);
7831 DrawLevelElement(x, y, EL_QUICKSAND_EMPTYING);
7832 DrawLevelElement(x, y + 1, EL_QUICKSAND_FAST_FILLING);
7839 Tile[x][y] = EL_QUICKSAND_EMPTY;
7840 Tile[x][y + 1] = EL_QUICKSAND_FAST_FULL;
7841 Store[x][y + 1] = Store[x][y];
7844 PlayLevelSoundAction(x, y, ACTION_FILLING);
7847 else if (element == EL_QUICKSAND_FAST_FULL)
7849 if (IS_FREE(x, y + 1))
7851 InitMovingField(x, y, MV_DOWN);
7852 started_moving = TRUE;
7854 Tile[x][y] = EL_QUICKSAND_FAST_EMPTYING;
7855 #if USE_QUICKSAND_BD_ROCK_BUGFIX
7856 if (Store[x][y] != EL_ROCK && Store[x][y] != EL_BD_ROCK)
7857 Store[x][y] = EL_ROCK;
7859 Store[x][y] = EL_ROCK;
7862 PlayLevelSoundAction(x, y, ACTION_EMPTYING);
7864 else if (Tile[x][y + 1] == EL_QUICKSAND_FAST_EMPTY)
7866 if (!MovDelay[x][y])
7868 MovDelay[x][y] = TILEY + 1;
7870 ResetGfxAnimation(x, y);
7871 ResetGfxAnimation(x, y + 1);
7876 DrawLevelElement(x, y, EL_QUICKSAND_FAST_EMPTYING);
7877 DrawLevelElement(x, y + 1, EL_QUICKSAND_FAST_FILLING);
7884 Tile[x][y] = EL_QUICKSAND_FAST_EMPTY;
7885 Tile[x][y + 1] = EL_QUICKSAND_FAST_FULL;
7886 Store[x][y + 1] = Store[x][y];
7889 PlayLevelSoundAction(x, y, ACTION_FILLING);
7891 else if (Tile[x][y + 1] == EL_QUICKSAND_EMPTY)
7893 if (!MovDelay[x][y])
7895 MovDelay[x][y] = TILEY + 1;
7897 ResetGfxAnimation(x, y);
7898 ResetGfxAnimation(x, y + 1);
7903 DrawLevelElement(x, y, EL_QUICKSAND_FAST_EMPTYING);
7904 DrawLevelElement(x, y + 1, EL_QUICKSAND_FILLING);
7911 Tile[x][y] = EL_QUICKSAND_FAST_EMPTY;
7912 Tile[x][y + 1] = EL_QUICKSAND_FULL;
7913 Store[x][y + 1] = Store[x][y];
7916 PlayLevelSoundAction(x, y, ACTION_FILLING);
7919 else if ((element == EL_ROCK || element == EL_BD_ROCK) &&
7920 Tile[x][y + 1] == EL_QUICKSAND_EMPTY)
7922 InitMovingField(x, y, MV_DOWN);
7923 started_moving = TRUE;
7925 Tile[x][y] = EL_QUICKSAND_FILLING;
7926 Store[x][y] = element;
7928 PlayLevelSoundAction(x, y, ACTION_FILLING);
7930 else if ((element == EL_ROCK || element == EL_BD_ROCK) &&
7931 Tile[x][y + 1] == EL_QUICKSAND_FAST_EMPTY)
7933 InitMovingField(x, y, MV_DOWN);
7934 started_moving = TRUE;
7936 Tile[x][y] = EL_QUICKSAND_FAST_FILLING;
7937 Store[x][y] = element;
7939 PlayLevelSoundAction(x, y, ACTION_FILLING);
7941 else if (element == EL_MAGIC_WALL_FULL)
7943 if (IS_FREE(x, y + 1))
7945 InitMovingField(x, y, MV_DOWN);
7946 started_moving = TRUE;
7948 Tile[x][y] = EL_MAGIC_WALL_EMPTYING;
7949 Store[x][y] = EL_CHANGED(Store[x][y]);
7951 else if (Tile[x][y + 1] == EL_MAGIC_WALL_ACTIVE)
7953 if (!MovDelay[x][y])
7954 MovDelay[x][y] = TILEY / 4 + 1;
7963 Tile[x][y] = EL_MAGIC_WALL_ACTIVE;
7964 Tile[x][y + 1] = EL_MAGIC_WALL_FULL;
7965 Store[x][y + 1] = EL_CHANGED(Store[x][y]);
7969 else if (element == EL_BD_MAGIC_WALL_FULL)
7971 if (IS_FREE(x, y + 1))
7973 InitMovingField(x, y, MV_DOWN);
7974 started_moving = TRUE;
7976 Tile[x][y] = EL_BD_MAGIC_WALL_EMPTYING;
7977 Store[x][y] = EL_CHANGED_BD(Store[x][y]);
7979 else if (Tile[x][y + 1] == EL_BD_MAGIC_WALL_ACTIVE)
7981 if (!MovDelay[x][y])
7982 MovDelay[x][y] = TILEY / 4 + 1;
7991 Tile[x][y] = EL_BD_MAGIC_WALL_ACTIVE;
7992 Tile[x][y + 1] = EL_BD_MAGIC_WALL_FULL;
7993 Store[x][y + 1] = EL_CHANGED_BD(Store[x][y]);
7997 else if (element == EL_DC_MAGIC_WALL_FULL)
7999 if (IS_FREE(x, y + 1))
8001 InitMovingField(x, y, MV_DOWN);
8002 started_moving = TRUE;
8004 Tile[x][y] = EL_DC_MAGIC_WALL_EMPTYING;
8005 Store[x][y] = EL_CHANGED_DC(Store[x][y]);
8007 else if (Tile[x][y + 1] == EL_DC_MAGIC_WALL_ACTIVE)
8009 if (!MovDelay[x][y])
8010 MovDelay[x][y] = TILEY / 4 + 1;
8019 Tile[x][y] = EL_DC_MAGIC_WALL_ACTIVE;
8020 Tile[x][y + 1] = EL_DC_MAGIC_WALL_FULL;
8021 Store[x][y + 1] = EL_CHANGED_DC(Store[x][y]);
8025 else if ((CAN_PASS_MAGIC_WALL(element) &&
8026 (Tile[x][y + 1] == EL_MAGIC_WALL_ACTIVE ||
8027 Tile[x][y + 1] == EL_BD_MAGIC_WALL_ACTIVE)) ||
8028 (CAN_PASS_DC_MAGIC_WALL(element) &&
8029 (Tile[x][y + 1] == EL_DC_MAGIC_WALL_ACTIVE)))
8032 InitMovingField(x, y, MV_DOWN);
8033 started_moving = TRUE;
8036 (Tile[x][y + 1] == EL_MAGIC_WALL_ACTIVE ? EL_MAGIC_WALL_FILLING :
8037 Tile[x][y + 1] == EL_BD_MAGIC_WALL_ACTIVE ? EL_BD_MAGIC_WALL_FILLING :
8038 EL_DC_MAGIC_WALL_FILLING);
8039 Store[x][y] = element;
8041 else if (CAN_FALL(element) && Tile[x][y + 1] == EL_ACID)
8043 SplashAcid(x, y + 1);
8045 InitMovingField(x, y, MV_DOWN);
8046 started_moving = TRUE;
8048 Store[x][y] = EL_ACID;
8051 (game.engine_version >= VERSION_IDENT(3,1,0,0) &&
8052 CheckImpact[x][y] && !IS_FREE(x, y + 1)) ||
8053 (game.engine_version >= VERSION_IDENT(3,0,7,0) &&
8054 CAN_FALL(element) && WasJustFalling[x][y] &&
8055 (Tile[x][y + 1] == EL_BLOCKED || IS_PLAYER(x, y + 1))) ||
8057 (game.engine_version < VERSION_IDENT(2,2,0,7) &&
8058 CAN_FALL(element) && WasJustMoving[x][y] && !Pushed[x][y + 1] &&
8059 (Tile[x][y + 1] == EL_BLOCKED)))
8061 /* this is needed for a special case not covered by calling "Impact()"
8062 from "ContinueMoving()": if an element moves to a tile directly below
8063 another element which was just falling on that tile (which was empty
8064 in the previous frame), the falling element above would just stop
8065 instead of smashing the element below (in previous version, the above
8066 element was just checked for "moving" instead of "falling", resulting
8067 in incorrect smashes caused by horizontal movement of the above
8068 element; also, the case of the player being the element to smash was
8069 simply not covered here... :-/ ) */
8071 CheckCollision[x][y] = 0;
8072 CheckImpact[x][y] = 0;
8076 else if (IS_FREE(x, y + 1) && element == EL_SPRING && level.use_spring_bug)
8078 if (MovDir[x][y] == MV_NONE)
8080 InitMovingField(x, y, MV_DOWN);
8081 started_moving = TRUE;
8084 else if (IS_FREE(x, y + 1) || Tile[x][y + 1] == EL_DIAMOND_BREAKING)
8086 if (WasJustFalling[x][y]) // prevent animation from being restarted
8087 MovDir[x][y] = MV_DOWN;
8089 InitMovingField(x, y, MV_DOWN);
8090 started_moving = TRUE;
8092 else if (element == EL_AMOEBA_DROP)
8094 Tile[x][y] = EL_AMOEBA_GROWING;
8095 Store[x][y] = EL_AMOEBA_WET;
8097 else if (((IS_SLIPPERY(Tile[x][y + 1]) && !IS_PLAYER(x, y + 1)) ||
8098 (IS_EM_SLIPPERY_WALL(Tile[x][y + 1]) && IS_GEM(element))) &&
8099 !IS_FALLING(x, y + 1) && !WasJustMoving[x][y + 1] &&
8100 element != EL_DX_SUPABOMB && element != EL_SP_DISK_ORANGE)
8102 boolean can_fall_left = (x > 0 && IS_FREE(x - 1, y) &&
8103 (IS_FREE(x - 1, y + 1) ||
8104 Tile[x - 1][y + 1] == EL_ACID));
8105 boolean can_fall_right = (x < lev_fieldx - 1 && IS_FREE(x + 1, y) &&
8106 (IS_FREE(x + 1, y + 1) ||
8107 Tile[x + 1][y + 1] == EL_ACID));
8108 boolean can_fall_any = (can_fall_left || can_fall_right);
8109 boolean can_fall_both = (can_fall_left && can_fall_right);
8110 int slippery_type = element_info[Tile[x][y + 1]].slippery_type;
8112 if (can_fall_any && slippery_type != SLIPPERY_ANY_RANDOM)
8114 if (slippery_type == SLIPPERY_ANY_LEFT_RIGHT && can_fall_both)
8115 can_fall_right = FALSE;
8116 else if (slippery_type == SLIPPERY_ANY_RIGHT_LEFT && can_fall_both)
8117 can_fall_left = FALSE;
8118 else if (slippery_type == SLIPPERY_ONLY_LEFT)
8119 can_fall_right = FALSE;
8120 else if (slippery_type == SLIPPERY_ONLY_RIGHT)
8121 can_fall_left = FALSE;
8123 can_fall_any = (can_fall_left || can_fall_right);
8124 can_fall_both = FALSE;
8129 if (element == EL_BD_ROCK || element == EL_BD_DIAMOND)
8130 can_fall_right = FALSE; // slip down on left side
8132 can_fall_left = !(can_fall_right = RND(2));
8134 can_fall_both = FALSE;
8139 // if not determined otherwise, prefer left side for slipping down
8140 InitMovingField(x, y, can_fall_left ? MV_LEFT : MV_RIGHT);
8141 started_moving = TRUE;
8144 else if (IS_BELT_ACTIVE(Tile[x][y + 1]))
8146 boolean left_is_free = (x > 0 && IS_FREE(x - 1, y));
8147 boolean right_is_free = (x < lev_fieldx - 1 && IS_FREE(x + 1, y));
8148 int belt_nr = getBeltNrFromBeltActiveElement(Tile[x][y + 1]);
8149 int belt_dir = game.belt_dir[belt_nr];
8151 if ((belt_dir == MV_LEFT && left_is_free) ||
8152 (belt_dir == MV_RIGHT && right_is_free))
8154 int nextx = (belt_dir == MV_LEFT ? x - 1 : x + 1);
8156 InitMovingField(x, y, belt_dir);
8157 started_moving = TRUE;
8159 Pushed[x][y] = TRUE;
8160 Pushed[nextx][y] = TRUE;
8162 GfxAction[x][y] = ACTION_DEFAULT;
8166 MovDir[x][y] = 0; // if element was moving, stop it
8171 // not "else if" because of elements that can fall and move (EL_SPRING)
8172 if (CAN_MOVE(element) && !started_moving)
8174 int move_pattern = element_info[element].move_pattern;
8177 Moving2Blocked(x, y, &newx, &newy);
8179 if (IS_PUSHABLE(element) && JustBeingPushed(x, y))
8182 if (game.engine_version >= VERSION_IDENT(3,1,0,0) &&
8183 CheckCollision[x][y] && !IN_LEV_FIELD_AND_IS_FREE(newx, newy))
8185 WasJustMoving[x][y] = 0;
8186 CheckCollision[x][y] = 0;
8188 TestIfElementHitsCustomElement(x, y, MovDir[x][y]);
8190 if (Tile[x][y] != element) // element has changed
8194 if (!MovDelay[x][y]) // start new movement phase
8196 // all objects that can change their move direction after each step
8197 // (YAMYAM, DARK_YAMYAM and PACMAN go straight until they hit a wall
8199 if (element != EL_YAMYAM &&
8200 element != EL_DARK_YAMYAM &&
8201 element != EL_PACMAN &&
8202 !(move_pattern & MV_ANY_DIRECTION) &&
8203 move_pattern != MV_TURNING_LEFT &&
8204 move_pattern != MV_TURNING_RIGHT &&
8205 move_pattern != MV_TURNING_LEFT_RIGHT &&
8206 move_pattern != MV_TURNING_RIGHT_LEFT &&
8207 move_pattern != MV_TURNING_RANDOM)
8211 if (MovDelay[x][y] && (element == EL_BUG ||
8212 element == EL_SPACESHIP ||
8213 element == EL_SP_SNIKSNAK ||
8214 element == EL_SP_ELECTRON ||
8215 element == EL_MOLE))
8216 TEST_DrawLevelField(x, y);
8220 if (MovDelay[x][y]) // wait some time before next movement
8224 if (element == EL_ROBOT ||
8225 element == EL_YAMYAM ||
8226 element == EL_DARK_YAMYAM)
8228 DrawLevelElementAnimationIfNeeded(x, y, element);
8229 PlayLevelSoundAction(x, y, ACTION_WAITING);
8231 else if (element == EL_SP_ELECTRON)
8232 DrawLevelElementAnimationIfNeeded(x, y, element);
8233 else if (element == EL_DRAGON)
8236 int dir = MovDir[x][y];
8237 int dx = (dir == MV_LEFT ? -1 : dir == MV_RIGHT ? +1 : 0);
8238 int dy = (dir == MV_UP ? -1 : dir == MV_DOWN ? +1 : 0);
8239 int graphic = (dir == MV_LEFT ? IMG_FLAMES_1_LEFT :
8240 dir == MV_RIGHT ? IMG_FLAMES_1_RIGHT :
8241 dir == MV_UP ? IMG_FLAMES_1_UP :
8242 dir == MV_DOWN ? IMG_FLAMES_1_DOWN : IMG_EMPTY);
8243 int frame = getGraphicAnimationFrameXY(graphic, x, y);
8245 GfxAction[x][y] = ACTION_ATTACKING;
8247 if (IS_PLAYER(x, y))
8248 DrawPlayerField(x, y);
8250 TEST_DrawLevelField(x, y);
8252 PlayLevelSoundActionIfLoop(x, y, ACTION_ATTACKING);
8254 for (i = 1; i <= 3; i++)
8256 int xx = x + i * dx;
8257 int yy = y + i * dy;
8258 int sx = SCREENX(xx);
8259 int sy = SCREENY(yy);
8260 int flame_graphic = graphic + (i - 1);
8262 if (!IN_LEV_FIELD(xx, yy) || IS_DRAGONFIRE_PROOF(Tile[xx][yy]))
8267 int flamed = MovingOrBlocked2Element(xx, yy);
8269 if (IS_CLASSIC_ENEMY(flamed) || CAN_EXPLODE_BY_DRAGONFIRE(flamed))
8272 RemoveMovingField(xx, yy);
8274 ChangeDelay[xx][yy] = 0;
8276 Tile[xx][yy] = EL_FLAMES;
8278 if (IN_SCR_FIELD(sx, sy))
8280 TEST_DrawLevelFieldCrumbled(xx, yy);
8281 DrawGraphic(sx, sy, flame_graphic, frame);
8286 if (Tile[xx][yy] == EL_FLAMES)
8287 Tile[xx][yy] = EL_EMPTY;
8288 TEST_DrawLevelField(xx, yy);
8293 if (MovDelay[x][y]) // element still has to wait some time
8295 PlayLevelSoundAction(x, y, ACTION_WAITING);
8301 // now make next step
8303 Moving2Blocked(x, y, &newx, &newy); // get next screen position
8305 if (DONT_COLLIDE_WITH(element) &&
8306 IN_LEV_FIELD(newx, newy) && IS_PLAYER(newx, newy) &&
8307 !PLAYER_ENEMY_PROTECTED(newx, newy))
8309 TestIfBadThingRunsIntoPlayer(x, y, MovDir[x][y]);
8314 else if (CAN_MOVE_INTO_ACID(element) &&
8315 IN_LEV_FIELD(newx, newy) && Tile[newx][newy] == EL_ACID &&
8316 !IS_MV_DIAGONAL(MovDir[x][y]) &&
8317 (MovDir[x][y] == MV_DOWN ||
8318 game.engine_version >= VERSION_IDENT(3,1,0,0)))
8320 SplashAcid(newx, newy);
8321 Store[x][y] = EL_ACID;
8323 else if (element == EL_PENGUIN && IN_LEV_FIELD(newx, newy))
8325 if (Tile[newx][newy] == EL_EXIT_OPEN ||
8326 Tile[newx][newy] == EL_EM_EXIT_OPEN ||
8327 Tile[newx][newy] == EL_STEEL_EXIT_OPEN ||
8328 Tile[newx][newy] == EL_EM_STEEL_EXIT_OPEN)
8331 TEST_DrawLevelField(x, y);
8333 PlayLevelSound(newx, newy, SND_PENGUIN_PASSING);
8334 if (IN_SCR_FIELD(SCREENX(newx), SCREENY(newy)))
8335 DrawGraphicThruMask(SCREENX(newx),SCREENY(newy), el2img(element), 0);
8337 game.friends_still_needed--;
8338 if (!game.friends_still_needed &&
8340 game.all_players_gone)
8345 else if (IS_FOOD_PENGUIN(Tile[newx][newy]))
8347 if (DigField(local_player, x, y, newx, newy, 0,0, DF_DIG) == MP_MOVING)
8348 TEST_DrawLevelField(newx, newy);
8350 GfxDir[x][y] = MovDir[x][y] = MV_NONE;
8352 else if (!IS_FREE(newx, newy))
8354 GfxAction[x][y] = ACTION_WAITING;
8356 if (IS_PLAYER(x, y))
8357 DrawPlayerField(x, y);
8359 TEST_DrawLevelField(x, y);
8364 else if (element == EL_PIG && IN_LEV_FIELD(newx, newy))
8366 if (IS_FOOD_PIG(Tile[newx][newy]))
8368 if (IS_MOVING(newx, newy))
8369 RemoveMovingField(newx, newy);
8372 Tile[newx][newy] = EL_EMPTY;
8373 TEST_DrawLevelField(newx, newy);
8376 PlayLevelSound(x, y, SND_PIG_DIGGING);
8378 else if (!IS_FREE(newx, newy))
8380 if (IS_PLAYER(x, y))
8381 DrawPlayerField(x, y);
8383 TEST_DrawLevelField(x, y);
8388 else if (element == EL_EMC_ANDROID && IN_LEV_FIELD(newx, newy))
8390 if (Store[x][y] != EL_EMPTY)
8392 boolean can_clone = FALSE;
8395 // check if element to clone is still there
8396 for (yy = y - 1; yy <= y + 1; yy++) for (xx = x - 1; xx <= x + 1; xx++)
8398 if (IN_LEV_FIELD(xx, yy) && Tile[xx][yy] == Store[x][y])
8406 // cannot clone or target field not free anymore -- do not clone
8407 if (!can_clone || !ANDROID_CAN_ENTER_FIELD(element, newx, newy))
8408 Store[x][y] = EL_EMPTY;
8411 if (ANDROID_CAN_ENTER_FIELD(element, newx, newy))
8413 if (IS_MV_DIAGONAL(MovDir[x][y]))
8415 int diagonal_move_dir = MovDir[x][y];
8416 int stored = Store[x][y];
8417 int change_delay = 8;
8420 // android is moving diagonally
8422 CreateField(x, y, EL_DIAGONAL_SHRINKING);
8424 Store[x][y] = (stored == EL_ACID ? EL_EMPTY : stored);
8425 GfxElement[x][y] = EL_EMC_ANDROID;
8426 GfxAction[x][y] = ACTION_SHRINKING;
8427 GfxDir[x][y] = diagonal_move_dir;
8428 ChangeDelay[x][y] = change_delay;
8430 if (Store[x][y] == EL_EMPTY)
8431 Store[x][y] = GfxElementEmpty[x][y];
8433 graphic = el_act_dir2img(GfxElement[x][y], GfxAction[x][y],
8436 DrawLevelGraphicAnimation(x, y, graphic);
8437 PlayLevelSoundAction(x, y, ACTION_SHRINKING);
8439 if (Tile[newx][newy] == EL_ACID)
8441 SplashAcid(newx, newy);
8446 CreateField(newx, newy, EL_DIAGONAL_GROWING);
8448 Store[newx][newy] = EL_EMC_ANDROID;
8449 GfxElement[newx][newy] = EL_EMC_ANDROID;
8450 GfxAction[newx][newy] = ACTION_GROWING;
8451 GfxDir[newx][newy] = diagonal_move_dir;
8452 ChangeDelay[newx][newy] = change_delay;
8454 graphic = el_act_dir2img(GfxElement[newx][newy],
8455 GfxAction[newx][newy], GfxDir[newx][newy]);
8457 DrawLevelGraphicAnimation(newx, newy, graphic);
8458 PlayLevelSoundAction(newx, newy, ACTION_GROWING);
8464 Tile[newx][newy] = EL_EMPTY;
8465 TEST_DrawLevelField(newx, newy);
8467 PlayLevelSoundAction(x, y, ACTION_DIGGING);
8470 else if (!IS_FREE(newx, newy))
8475 else if (IS_CUSTOM_ELEMENT(element) &&
8476 CUSTOM_ELEMENT_CAN_ENTER_FIELD(element, newx, newy))
8478 if (!DigFieldByCE(newx, newy, element))
8481 if (move_pattern & MV_MAZE_RUNNER_STYLE)
8483 RunnerVisit[x][y] = FrameCounter;
8484 PlayerVisit[x][y] /= 8; // expire player visit path
8487 else if (element == EL_DRAGON && IN_LEV_FIELD(newx, newy))
8489 if (!IS_FREE(newx, newy))
8491 if (IS_PLAYER(x, y))
8492 DrawPlayerField(x, y);
8494 TEST_DrawLevelField(x, y);
8500 boolean wanna_flame = !RND(10);
8501 int dx = newx - x, dy = newy - y;
8502 int newx1 = newx + 1 * dx, newy1 = newy + 1 * dy;
8503 int newx2 = newx + 2 * dx, newy2 = newy + 2 * dy;
8504 int element1 = (IN_LEV_FIELD(newx1, newy1) ?
8505 MovingOrBlocked2Element(newx1, newy1) : EL_STEELWALL);
8506 int element2 = (IN_LEV_FIELD(newx2, newy2) ?
8507 MovingOrBlocked2Element(newx2, newy2) : EL_STEELWALL);
8510 IS_CLASSIC_ENEMY(element1) ||
8511 IS_CLASSIC_ENEMY(element2)) &&
8512 element1 != EL_DRAGON && element2 != EL_DRAGON &&
8513 element1 != EL_FLAMES && element2 != EL_FLAMES)
8515 ResetGfxAnimation(x, y);
8516 GfxAction[x][y] = ACTION_ATTACKING;
8518 if (IS_PLAYER(x, y))
8519 DrawPlayerField(x, y);
8521 TEST_DrawLevelField(x, y);
8523 PlayLevelSound(x, y, SND_DRAGON_ATTACKING);
8525 MovDelay[x][y] = 50;
8527 Tile[newx][newy] = EL_FLAMES;
8528 if (IN_LEV_FIELD(newx1, newy1) && Tile[newx1][newy1] == EL_EMPTY)
8529 Tile[newx1][newy1] = EL_FLAMES;
8530 if (IN_LEV_FIELD(newx2, newy2) && Tile[newx2][newy2] == EL_EMPTY)
8531 Tile[newx2][newy2] = EL_FLAMES;
8537 else if (element == EL_YAMYAM && IN_LEV_FIELD(newx, newy) &&
8538 Tile[newx][newy] == EL_DIAMOND)
8540 if (IS_MOVING(newx, newy))
8541 RemoveMovingField(newx, newy);
8544 Tile[newx][newy] = EL_EMPTY;
8545 TEST_DrawLevelField(newx, newy);
8548 PlayLevelSound(x, y, SND_YAMYAM_DIGGING);
8550 else if (element == EL_DARK_YAMYAM && IN_LEV_FIELD(newx, newy) &&
8551 IS_FOOD_DARK_YAMYAM(Tile[newx][newy]))
8553 if (AmoebaNr[newx][newy])
8555 AmoebaCnt2[AmoebaNr[newx][newy]]--;
8556 if (Tile[newx][newy] == EL_AMOEBA_FULL ||
8557 Tile[newx][newy] == EL_BD_AMOEBA)
8558 AmoebaCnt[AmoebaNr[newx][newy]]--;
8561 if (IS_MOVING(newx, newy))
8563 RemoveMovingField(newx, newy);
8567 Tile[newx][newy] = EL_EMPTY;
8568 TEST_DrawLevelField(newx, newy);
8571 PlayLevelSound(x, y, SND_DARK_YAMYAM_DIGGING);
8573 else if ((element == EL_PACMAN || element == EL_MOLE)
8574 && IN_LEV_FIELD(newx, newy) && IS_AMOEBOID(Tile[newx][newy]))
8576 if (AmoebaNr[newx][newy])
8578 AmoebaCnt2[AmoebaNr[newx][newy]]--;
8579 if (Tile[newx][newy] == EL_AMOEBA_FULL ||
8580 Tile[newx][newy] == EL_BD_AMOEBA)
8581 AmoebaCnt[AmoebaNr[newx][newy]]--;
8584 if (element == EL_MOLE)
8586 Tile[newx][newy] = EL_AMOEBA_SHRINKING;
8587 PlayLevelSound(x, y, SND_MOLE_DIGGING);
8589 ResetGfxAnimation(x, y);
8590 GfxAction[x][y] = ACTION_DIGGING;
8591 TEST_DrawLevelField(x, y);
8593 MovDelay[newx][newy] = 0; // start amoeba shrinking delay
8595 return; // wait for shrinking amoeba
8597 else // element == EL_PACMAN
8599 Tile[newx][newy] = EL_EMPTY;
8600 TEST_DrawLevelField(newx, newy);
8601 PlayLevelSound(x, y, SND_PACMAN_DIGGING);
8604 else if (element == EL_MOLE && IN_LEV_FIELD(newx, newy) &&
8605 (Tile[newx][newy] == EL_AMOEBA_SHRINKING ||
8606 (Tile[newx][newy] == EL_EMPTY && Stop[newx][newy])))
8608 // wait for shrinking amoeba to completely disappear
8611 else if (!IN_LEV_FIELD(newx, newy) || !IS_FREE(newx, newy))
8613 // object was running against a wall
8617 if (GFX_ELEMENT(element) != EL_SAND) // !!! FIX THIS (crumble) !!!
8618 DrawLevelElementAnimation(x, y, element);
8620 if (DONT_TOUCH(element))
8621 TestIfBadThingTouchesPlayer(x, y);
8626 InitMovingField(x, y, MovDir[x][y]);
8628 PlayLevelSoundAction(x, y, ACTION_MOVING);
8632 ContinueMoving(x, y);
8635 void ContinueMoving(int x, int y)
8637 int element = Tile[x][y];
8638 struct ElementInfo *ei = &element_info[element];
8639 int direction = MovDir[x][y];
8640 int dx = (direction == MV_LEFT ? -1 : direction == MV_RIGHT ? +1 : 0);
8641 int dy = (direction == MV_UP ? -1 : direction == MV_DOWN ? +1 : 0);
8642 int newx = x + dx, newy = y + dy;
8643 int stored = Store[x][y];
8644 int stored_new = Store[newx][newy];
8645 boolean pushed_by_player = (Pushed[x][y] && IS_PLAYER(x, y));
8646 boolean pushed_by_conveyor = (Pushed[x][y] && !IS_PLAYER(x, y));
8647 boolean last_line = (newy == lev_fieldy - 1);
8648 boolean use_step_delay = (GET_MAX_STEP_DELAY(element) != 0);
8650 if (pushed_by_player) // special case: moving object pushed by player
8652 MovPos[x][y] = SIGN(MovPos[x][y]) * (TILEX - ABS(PLAYERINFO(x,y)->MovPos));
8654 else if (use_step_delay) // special case: moving object has step delay
8656 if (!MovDelay[x][y])
8657 MovPos[x][y] += getElementMoveStepsize(x, y);
8662 MovDelay[x][y] = GET_NEW_STEP_DELAY(element);
8666 TEST_DrawLevelField(x, y);
8668 return; // element is still waiting
8671 else // normal case: generically moving object
8673 MovPos[x][y] += getElementMoveStepsize(x, y);
8676 if (ABS(MovPos[x][y]) < TILEX)
8678 TEST_DrawLevelField(x, y);
8680 return; // element is still moving
8683 // element reached destination field
8685 Tile[x][y] = EL_EMPTY;
8686 Tile[newx][newy] = element;
8687 MovPos[x][y] = 0; // force "not moving" for "crumbled sand"
8689 if (Store[x][y] == EL_ACID) // element is moving into acid pool
8691 element = Tile[newx][newy] = EL_ACID;
8693 else if (element == EL_MOLE)
8695 Tile[x][y] = EL_SAND;
8697 TEST_DrawLevelFieldCrumbledNeighbours(x, y);
8699 else if (element == EL_QUICKSAND_FILLING)
8701 element = Tile[newx][newy] = get_next_element(element);
8702 Store[newx][newy] = Store[x][y];
8704 else if (element == EL_QUICKSAND_EMPTYING)
8706 Tile[x][y] = get_next_element(element);
8707 element = Tile[newx][newy] = Store[x][y];
8709 else if (element == EL_QUICKSAND_FAST_FILLING)
8711 element = Tile[newx][newy] = get_next_element(element);
8712 Store[newx][newy] = Store[x][y];
8714 else if (element == EL_QUICKSAND_FAST_EMPTYING)
8716 Tile[x][y] = get_next_element(element);
8717 element = Tile[newx][newy] = Store[x][y];
8719 else if (element == EL_MAGIC_WALL_FILLING)
8721 element = Tile[newx][newy] = get_next_element(element);
8722 if (!game.magic_wall_active)
8723 element = Tile[newx][newy] = EL_MAGIC_WALL_DEAD;
8724 Store[newx][newy] = Store[x][y];
8726 else if (element == EL_MAGIC_WALL_EMPTYING)
8728 Tile[x][y] = get_next_element(element);
8729 if (!game.magic_wall_active)
8730 Tile[x][y] = EL_MAGIC_WALL_DEAD;
8731 element = Tile[newx][newy] = Store[x][y];
8733 InitField(newx, newy, FALSE);
8735 else if (element == EL_BD_MAGIC_WALL_FILLING)
8737 element = Tile[newx][newy] = get_next_element(element);
8738 if (!game.magic_wall_active)
8739 element = Tile[newx][newy] = EL_BD_MAGIC_WALL_DEAD;
8740 Store[newx][newy] = Store[x][y];
8742 else if (element == EL_BD_MAGIC_WALL_EMPTYING)
8744 Tile[x][y] = get_next_element(element);
8745 if (!game.magic_wall_active)
8746 Tile[x][y] = EL_BD_MAGIC_WALL_DEAD;
8747 element = Tile[newx][newy] = Store[x][y];
8749 InitField(newx, newy, FALSE);
8751 else if (element == EL_DC_MAGIC_WALL_FILLING)
8753 element = Tile[newx][newy] = get_next_element(element);
8754 if (!game.magic_wall_active)
8755 element = Tile[newx][newy] = EL_DC_MAGIC_WALL_DEAD;
8756 Store[newx][newy] = Store[x][y];
8758 else if (element == EL_DC_MAGIC_WALL_EMPTYING)
8760 Tile[x][y] = get_next_element(element);
8761 if (!game.magic_wall_active)
8762 Tile[x][y] = EL_DC_MAGIC_WALL_DEAD;
8763 element = Tile[newx][newy] = Store[x][y];
8765 InitField(newx, newy, FALSE);
8767 else if (element == EL_AMOEBA_DROPPING)
8769 Tile[x][y] = get_next_element(element);
8770 element = Tile[newx][newy] = Store[x][y];
8772 else if (element == EL_SOKOBAN_OBJECT)
8775 Tile[x][y] = Back[x][y];
8777 if (Back[newx][newy])
8778 Tile[newx][newy] = EL_SOKOBAN_FIELD_FULL;
8780 Back[x][y] = Back[newx][newy] = 0;
8783 Store[x][y] = EL_EMPTY;
8788 MovDelay[newx][newy] = 0;
8790 if (CAN_CHANGE_OR_HAS_ACTION(element))
8792 // copy element change control values to new field
8793 ChangeDelay[newx][newy] = ChangeDelay[x][y];
8794 ChangePage[newx][newy] = ChangePage[x][y];
8795 ChangeCount[newx][newy] = ChangeCount[x][y];
8796 ChangeEvent[newx][newy] = ChangeEvent[x][y];
8799 CustomValue[newx][newy] = CustomValue[x][y];
8801 ChangeDelay[x][y] = 0;
8802 ChangePage[x][y] = -1;
8803 ChangeCount[x][y] = 0;
8804 ChangeEvent[x][y] = -1;
8806 CustomValue[x][y] = 0;
8808 // copy animation control values to new field
8809 GfxFrame[newx][newy] = GfxFrame[x][y];
8810 GfxRandom[newx][newy] = GfxRandom[x][y]; // keep same random value
8811 GfxAction[newx][newy] = GfxAction[x][y]; // keep action one frame
8812 GfxDir[newx][newy] = GfxDir[x][y]; // keep element direction
8814 Pushed[x][y] = Pushed[newx][newy] = FALSE;
8816 // some elements can leave other elements behind after moving
8817 if (ei->move_leave_element != EL_EMPTY &&
8818 (ei->move_leave_type == LEAVE_TYPE_UNLIMITED || stored != EL_EMPTY) &&
8819 (!IS_PLAYER(x, y) || IS_WALKABLE(ei->move_leave_element)))
8821 int move_leave_element = ei->move_leave_element;
8823 // this makes it possible to leave the removed element again
8824 if (ei->move_leave_element == EL_TRIGGER_ELEMENT)
8825 move_leave_element = (stored == EL_ACID ? EL_EMPTY : stored);
8827 Tile[x][y] = move_leave_element;
8829 if (element_info[Tile[x][y]].move_direction_initial == MV_START_PREVIOUS)
8830 MovDir[x][y] = direction;
8832 InitField(x, y, FALSE);
8834 if (GFX_CRUMBLED(Tile[x][y]))
8835 TEST_DrawLevelFieldCrumbledNeighbours(x, y);
8837 if (IS_PLAYER_ELEMENT(move_leave_element))
8838 RelocatePlayer(x, y, move_leave_element);
8841 // do this after checking for left-behind element
8842 ResetGfxAnimation(x, y); // reset animation values for old field
8844 if (!CAN_MOVE(element) ||
8845 (CAN_FALL(element) && direction == MV_DOWN &&
8846 (element == EL_SPRING ||
8847 element_info[element].move_pattern == MV_WHEN_PUSHED ||
8848 element_info[element].move_pattern == MV_WHEN_DROPPED)))
8849 GfxDir[x][y] = MovDir[newx][newy] = 0;
8851 TEST_DrawLevelField(x, y);
8852 TEST_DrawLevelField(newx, newy);
8854 Stop[newx][newy] = TRUE; // ignore this element until the next frame
8856 // prevent pushed element from moving on in pushed direction
8857 if (pushed_by_player && CAN_MOVE(element) &&
8858 element_info[element].move_pattern & MV_ANY_DIRECTION &&
8859 !(element_info[element].move_pattern & direction))
8860 TurnRound(newx, newy);
8862 // prevent elements on conveyor belt from moving on in last direction
8863 if (pushed_by_conveyor && CAN_FALL(element) &&
8864 direction & MV_HORIZONTAL)
8865 MovDir[newx][newy] = 0;
8867 if (!pushed_by_player)
8869 int nextx = newx + dx, nexty = newy + dy;
8870 boolean check_collision_again = IN_LEV_FIELD_AND_IS_FREE(nextx, nexty);
8872 WasJustMoving[newx][newy] = CHECK_DELAY_MOVING;
8874 if (CAN_FALL(element) && direction == MV_DOWN)
8875 WasJustFalling[newx][newy] = CHECK_DELAY_FALLING;
8877 if ((!CAN_FALL(element) || direction == MV_DOWN) && check_collision_again)
8878 CheckCollision[newx][newy] = CHECK_DELAY_COLLISION;
8880 if (CAN_FALL(element) && direction == MV_DOWN && check_collision_again)
8881 CheckImpact[newx][newy] = CHECK_DELAY_IMPACT;
8884 if (DONT_TOUCH(element)) // object may be nasty to player or others
8886 TestIfBadThingTouchesPlayer(newx, newy);
8887 TestIfBadThingTouchesFriend(newx, newy);
8889 if (!IS_CUSTOM_ELEMENT(element))
8890 TestIfBadThingTouchesOtherBadThing(newx, newy);
8892 else if (element == EL_PENGUIN)
8893 TestIfFriendTouchesBadThing(newx, newy);
8895 if (DONT_GET_HIT_BY(element))
8897 TestIfGoodThingGetsHitByBadThing(newx, newy, direction);
8900 // give the player one last chance (one more frame) to move away
8901 if (CAN_FALL(element) && direction == MV_DOWN &&
8902 (last_line || (!IS_FREE(x, newy + 1) &&
8903 (!IS_PLAYER(x, newy + 1) ||
8904 game.engine_version < VERSION_IDENT(3,1,1,0)))))
8907 if (pushed_by_player && !game.use_change_when_pushing_bug)
8909 int push_side = MV_DIR_OPPOSITE(direction);
8910 struct PlayerInfo *player = PLAYERINFO(x, y);
8912 CheckElementChangeByPlayer(newx, newy, element, CE_PUSHED_BY_PLAYER,
8913 player->index_bit, push_side);
8914 CheckTriggeredElementChangeByPlayer(newx,newy, element, CE_PLAYER_PUSHES_X,
8915 player->index_bit, push_side);
8918 if (element == EL_EMC_ANDROID && pushed_by_player) // make another move
8919 MovDelay[newx][newy] = 1;
8921 CheckTriggeredElementChangeBySide(x, y, element, CE_MOVE_OF_X, direction);
8923 TestIfElementTouchesCustomElement(x, y); // empty or new element
8924 TestIfElementHitsCustomElement(newx, newy, direction);
8925 TestIfPlayerTouchesCustomElement(newx, newy);
8926 TestIfElementTouchesCustomElement(newx, newy);
8928 if (IS_CUSTOM_ELEMENT(element) && ei->move_enter_element != EL_EMPTY &&
8929 IS_EQUAL_OR_IN_GROUP(stored_new, ei->move_enter_element))
8930 CheckElementChangeBySide(newx, newy, element, stored_new, CE_DIGGING_X,
8931 MV_DIR_OPPOSITE(direction));
8934 int AmoebaNeighbourNr(int ax, int ay)
8937 int element = Tile[ax][ay];
8939 static int xy[4][2] =
8947 for (i = 0; i < NUM_DIRECTIONS; i++)
8949 int x = ax + xy[i][0];
8950 int y = ay + xy[i][1];
8952 if (!IN_LEV_FIELD(x, y))
8955 if (Tile[x][y] == element && AmoebaNr[x][y] > 0)
8956 group_nr = AmoebaNr[x][y];
8962 static void AmoebaMerge(int ax, int ay)
8964 int i, x, y, xx, yy;
8965 int new_group_nr = AmoebaNr[ax][ay];
8966 static int xy[4][2] =
8974 if (new_group_nr == 0)
8977 for (i = 0; i < NUM_DIRECTIONS; i++)
8982 if (!IN_LEV_FIELD(x, y))
8985 if ((Tile[x][y] == EL_AMOEBA_FULL ||
8986 Tile[x][y] == EL_BD_AMOEBA ||
8987 Tile[x][y] == EL_AMOEBA_DEAD) &&
8988 AmoebaNr[x][y] != new_group_nr)
8990 int old_group_nr = AmoebaNr[x][y];
8992 if (old_group_nr == 0)
8995 AmoebaCnt[new_group_nr] += AmoebaCnt[old_group_nr];
8996 AmoebaCnt[old_group_nr] = 0;
8997 AmoebaCnt2[new_group_nr] += AmoebaCnt2[old_group_nr];
8998 AmoebaCnt2[old_group_nr] = 0;
9000 SCAN_PLAYFIELD(xx, yy)
9002 if (AmoebaNr[xx][yy] == old_group_nr)
9003 AmoebaNr[xx][yy] = new_group_nr;
9009 void AmoebaToDiamond(int ax, int ay)
9013 if (Tile[ax][ay] == EL_AMOEBA_DEAD)
9015 int group_nr = AmoebaNr[ax][ay];
9020 Debug("game:playing:AmoebaToDiamond", "ax = %d, ay = %d", ax, ay);
9021 Debug("game:playing:AmoebaToDiamond", "This should never happen!");
9027 SCAN_PLAYFIELD(x, y)
9029 if (Tile[x][y] == EL_AMOEBA_DEAD && AmoebaNr[x][y] == group_nr)
9032 Tile[x][y] = EL_AMOEBA_TO_DIAMOND;
9036 PlayLevelSound(ax, ay, (IS_GEM(level.amoeba_content) ?
9037 SND_AMOEBA_TURNING_TO_GEM :
9038 SND_AMOEBA_TURNING_TO_ROCK));
9043 static int xy[4][2] =
9051 for (i = 0; i < NUM_DIRECTIONS; i++)
9056 if (!IN_LEV_FIELD(x, y))
9059 if (Tile[x][y] == EL_AMOEBA_TO_DIAMOND)
9061 PlayLevelSound(x, y, (IS_GEM(level.amoeba_content) ?
9062 SND_AMOEBA_TURNING_TO_GEM :
9063 SND_AMOEBA_TURNING_TO_ROCK));
9070 static void AmoebaToDiamondBD(int ax, int ay, int new_element)
9073 int group_nr = AmoebaNr[ax][ay];
9074 boolean done = FALSE;
9079 Debug("game:playing:AmoebaToDiamondBD", "ax = %d, ay = %d", ax, ay);
9080 Debug("game:playing:AmoebaToDiamondBD", "This should never happen!");
9086 SCAN_PLAYFIELD(x, y)
9088 if (AmoebaNr[x][y] == group_nr &&
9089 (Tile[x][y] == EL_AMOEBA_DEAD ||
9090 Tile[x][y] == EL_BD_AMOEBA ||
9091 Tile[x][y] == EL_AMOEBA_GROWING))
9094 Tile[x][y] = new_element;
9095 InitField(x, y, FALSE);
9096 TEST_DrawLevelField(x, y);
9102 PlayLevelSound(ax, ay, (new_element == EL_BD_ROCK ?
9103 SND_BD_AMOEBA_TURNING_TO_ROCK :
9104 SND_BD_AMOEBA_TURNING_TO_GEM));
9107 static void AmoebaGrowing(int x, int y)
9109 static unsigned int sound_delay = 0;
9110 static unsigned int sound_delay_value = 0;
9112 if (!MovDelay[x][y]) // start new growing cycle
9116 if (DelayReached(&sound_delay, sound_delay_value))
9118 PlayLevelSoundElementAction(x, y, Store[x][y], ACTION_GROWING);
9119 sound_delay_value = 30;
9123 if (MovDelay[x][y]) // wait some time before growing bigger
9126 if (MovDelay[x][y]/2 && IN_SCR_FIELD(SCREENX(x), SCREENY(y)))
9128 int frame = getGraphicAnimationFrame(IMG_AMOEBA_GROWING,
9129 6 - MovDelay[x][y]);
9131 DrawGraphic(SCREENX(x), SCREENY(y), IMG_AMOEBA_GROWING, frame);
9134 if (!MovDelay[x][y])
9136 Tile[x][y] = Store[x][y];
9138 TEST_DrawLevelField(x, y);
9143 static void AmoebaShrinking(int x, int y)
9145 static unsigned int sound_delay = 0;
9146 static unsigned int sound_delay_value = 0;
9148 if (!MovDelay[x][y]) // start new shrinking cycle
9152 if (DelayReached(&sound_delay, sound_delay_value))
9153 sound_delay_value = 30;
9156 if (MovDelay[x][y]) // wait some time before shrinking
9159 if (MovDelay[x][y]/2 && IN_SCR_FIELD(SCREENX(x), SCREENY(y)))
9161 int frame = getGraphicAnimationFrame(IMG_AMOEBA_SHRINKING,
9162 6 - MovDelay[x][y]);
9164 DrawGraphic(SCREENX(x), SCREENY(y), IMG_AMOEBA_SHRINKING, frame);
9167 if (!MovDelay[x][y])
9169 Tile[x][y] = EL_EMPTY;
9170 TEST_DrawLevelField(x, y);
9172 // don't let mole enter this field in this cycle;
9173 // (give priority to objects falling to this field from above)
9179 static void AmoebaReproduce(int ax, int ay)
9182 int element = Tile[ax][ay];
9183 int graphic = el2img(element);
9184 int newax = ax, neway = ay;
9185 boolean can_drop = (element == EL_AMOEBA_WET || element == EL_EMC_DRIPPER);
9186 static int xy[4][2] =
9194 if (!level.amoeba_speed && element != EL_EMC_DRIPPER)
9196 Tile[ax][ay] = EL_AMOEBA_DEAD;
9197 TEST_DrawLevelField(ax, ay);
9201 if (IS_ANIMATED(graphic))
9202 DrawLevelGraphicAnimationIfNeeded(ax, ay, graphic);
9204 if (!MovDelay[ax][ay]) // start making new amoeba field
9205 MovDelay[ax][ay] = RND(FRAMES_PER_SECOND * 25 / (1 + level.amoeba_speed));
9207 if (MovDelay[ax][ay]) // wait some time before making new amoeba
9210 if (MovDelay[ax][ay])
9214 if (can_drop) // EL_AMOEBA_WET or EL_EMC_DRIPPER
9217 int x = ax + xy[start][0];
9218 int y = ay + xy[start][1];
9220 if (!IN_LEV_FIELD(x, y))
9223 if (IS_FREE(x, y) ||
9224 CAN_GROW_INTO(Tile[x][y]) ||
9225 Tile[x][y] == EL_QUICKSAND_EMPTY ||
9226 Tile[x][y] == EL_QUICKSAND_FAST_EMPTY)
9232 if (newax == ax && neway == ay)
9235 else // normal or "filled" (BD style) amoeba
9238 boolean waiting_for_player = FALSE;
9240 for (i = 0; i < NUM_DIRECTIONS; i++)
9242 int j = (start + i) % 4;
9243 int x = ax + xy[j][0];
9244 int y = ay + xy[j][1];
9246 if (!IN_LEV_FIELD(x, y))
9249 if (IS_FREE(x, y) ||
9250 CAN_GROW_INTO(Tile[x][y]) ||
9251 Tile[x][y] == EL_QUICKSAND_EMPTY ||
9252 Tile[x][y] == EL_QUICKSAND_FAST_EMPTY)
9258 else if (IS_PLAYER(x, y))
9259 waiting_for_player = TRUE;
9262 if (newax == ax && neway == ay) // amoeba cannot grow
9264 if (i == 4 && (!waiting_for_player || element == EL_BD_AMOEBA))
9266 Tile[ax][ay] = EL_AMOEBA_DEAD;
9267 TEST_DrawLevelField(ax, ay);
9268 AmoebaCnt[AmoebaNr[ax][ay]]--;
9270 if (AmoebaCnt[AmoebaNr[ax][ay]] <= 0) // amoeba is completely dead
9272 if (element == EL_AMOEBA_FULL)
9273 AmoebaToDiamond(ax, ay);
9274 else if (element == EL_BD_AMOEBA)
9275 AmoebaToDiamondBD(ax, ay, level.amoeba_content);
9280 else if (element == EL_AMOEBA_FULL || element == EL_BD_AMOEBA)
9282 // amoeba gets larger by growing in some direction
9284 int new_group_nr = AmoebaNr[ax][ay];
9287 if (new_group_nr == 0)
9289 Debug("game:playing:AmoebaReproduce", "newax = %d, neway = %d",
9291 Debug("game:playing:AmoebaReproduce", "This should never happen!");
9297 AmoebaNr[newax][neway] = new_group_nr;
9298 AmoebaCnt[new_group_nr]++;
9299 AmoebaCnt2[new_group_nr]++;
9301 // if amoeba touches other amoeba(s) after growing, unify them
9302 AmoebaMerge(newax, neway);
9304 if (element == EL_BD_AMOEBA && AmoebaCnt2[new_group_nr] >= 200)
9306 AmoebaToDiamondBD(newax, neway, EL_BD_ROCK);
9312 if (!can_drop || neway < ay || !IS_FREE(newax, neway) ||
9313 (neway == lev_fieldy - 1 && newax != ax))
9315 Tile[newax][neway] = EL_AMOEBA_GROWING; // creation of new amoeba
9316 Store[newax][neway] = element;
9318 else if (neway == ay || element == EL_EMC_DRIPPER)
9320 Tile[newax][neway] = EL_AMOEBA_DROP; // drop left/right of amoeba
9322 PlayLevelSoundAction(newax, neway, ACTION_GROWING);
9326 InitMovingField(ax, ay, MV_DOWN); // drop dripping from amoeba
9327 Tile[ax][ay] = EL_AMOEBA_DROPPING;
9328 Store[ax][ay] = EL_AMOEBA_DROP;
9329 ContinueMoving(ax, ay);
9333 TEST_DrawLevelField(newax, neway);
9336 static void Life(int ax, int ay)
9340 int element = Tile[ax][ay];
9341 int graphic = el2img(element);
9342 int *life_parameter = (element == EL_GAME_OF_LIFE ? level.game_of_life :
9344 boolean changed = FALSE;
9346 if (IS_ANIMATED(graphic))
9347 DrawLevelGraphicAnimationIfNeeded(ax, ay, graphic);
9352 if (!MovDelay[ax][ay]) // start new "game of life" cycle
9353 MovDelay[ax][ay] = life_time;
9355 if (MovDelay[ax][ay]) // wait some time before next cycle
9358 if (MovDelay[ax][ay])
9362 for (y1 = -1; y1 < 2; y1++) for (x1 = -1; x1 < 2; x1++)
9364 int xx = ax+x1, yy = ay+y1;
9365 int old_element = Tile[xx][yy];
9366 int num_neighbours = 0;
9368 if (!IN_LEV_FIELD(xx, yy))
9371 for (y2 = -1; y2 < 2; y2++) for (x2 = -1; x2 < 2; x2++)
9373 int x = xx+x2, y = yy+y2;
9375 if (!IN_LEV_FIELD(x, y) || (x == xx && y == yy))
9378 boolean is_player_cell = (element == EL_GAME_OF_LIFE && IS_PLAYER(x, y));
9379 boolean is_neighbour = FALSE;
9381 if (level.use_life_bugs)
9383 (((Tile[x][y] == element || is_player_cell) && !Stop[x][y]) ||
9384 (IS_FREE(x, y) && Stop[x][y]));
9387 (Last[x][y] == element || is_player_cell);
9393 boolean is_free = FALSE;
9395 if (level.use_life_bugs)
9396 is_free = (IS_FREE(xx, yy));
9398 is_free = (IS_FREE(xx, yy) && Last[xx][yy] == EL_EMPTY);
9400 if (xx == ax && yy == ay) // field in the middle
9402 if (num_neighbours < life_parameter[0] ||
9403 num_neighbours > life_parameter[1])
9405 Tile[xx][yy] = EL_EMPTY;
9406 if (Tile[xx][yy] != old_element)
9407 TEST_DrawLevelField(xx, yy);
9408 Stop[xx][yy] = TRUE;
9412 else if (is_free || CAN_GROW_INTO(Tile[xx][yy]))
9413 { // free border field
9414 if (num_neighbours >= life_parameter[2] &&
9415 num_neighbours <= life_parameter[3])
9417 Tile[xx][yy] = element;
9418 MovDelay[xx][yy] = (element == EL_GAME_OF_LIFE ? 0 : life_time-1);
9419 if (Tile[xx][yy] != old_element)
9420 TEST_DrawLevelField(xx, yy);
9421 Stop[xx][yy] = TRUE;
9428 PlayLevelSound(ax, ay, element == EL_BIOMAZE ? SND_BIOMAZE_GROWING :
9429 SND_GAME_OF_LIFE_GROWING);
9432 static void InitRobotWheel(int x, int y)
9434 ChangeDelay[x][y] = level.time_wheel * FRAMES_PER_SECOND;
9437 static void RunRobotWheel(int x, int y)
9439 PlayLevelSound(x, y, SND_ROBOT_WHEEL_ACTIVE);
9442 static void StopRobotWheel(int x, int y)
9444 if (game.robot_wheel_x == x &&
9445 game.robot_wheel_y == y)
9447 game.robot_wheel_x = -1;
9448 game.robot_wheel_y = -1;
9449 game.robot_wheel_active = FALSE;
9453 static void InitTimegateWheel(int x, int y)
9455 ChangeDelay[x][y] = level.time_timegate * FRAMES_PER_SECOND;
9458 static void RunTimegateWheel(int x, int y)
9460 PlayLevelSound(x, y, SND_CLASS_TIMEGATE_SWITCH_ACTIVE);
9463 static void InitMagicBallDelay(int x, int y)
9465 ChangeDelay[x][y] = (level.ball_time + 1) * 8 + 1;
9468 static void ActivateMagicBall(int bx, int by)
9472 if (level.ball_random)
9474 int pos_border = RND(8); // select one of the eight border elements
9475 int pos_content = (pos_border > 3 ? pos_border + 1 : pos_border);
9476 int xx = pos_content % 3;
9477 int yy = pos_content / 3;
9482 if (IN_LEV_FIELD(x, y) && Tile[x][y] == EL_EMPTY)
9483 CreateField(x, y, level.ball_content[game.ball_content_nr].e[xx][yy]);
9487 for (y = by - 1; y <= by + 1; y++) for (x = bx - 1; x <= bx + 1; x++)
9489 int xx = x - bx + 1;
9490 int yy = y - by + 1;
9492 if (IN_LEV_FIELD(x, y) && Tile[x][y] == EL_EMPTY)
9493 CreateField(x, y, level.ball_content[game.ball_content_nr].e[xx][yy]);
9497 game.ball_content_nr = (game.ball_content_nr + 1) % level.num_ball_contents;
9500 static void CheckExit(int x, int y)
9502 if (game.gems_still_needed > 0 ||
9503 game.sokoban_fields_still_needed > 0 ||
9504 game.sokoban_objects_still_needed > 0 ||
9505 game.lights_still_needed > 0)
9507 int element = Tile[x][y];
9508 int graphic = el2img(element);
9510 if (IS_ANIMATED(graphic))
9511 DrawLevelGraphicAnimationIfNeeded(x, y, graphic);
9516 // do not re-open exit door closed after last player
9517 if (game.all_players_gone)
9520 Tile[x][y] = EL_EXIT_OPENING;
9522 PlayLevelSoundNearest(x, y, SND_CLASS_EXIT_OPENING);
9525 static void CheckExitEM(int x, int y)
9527 if (game.gems_still_needed > 0 ||
9528 game.sokoban_fields_still_needed > 0 ||
9529 game.sokoban_objects_still_needed > 0 ||
9530 game.lights_still_needed > 0)
9532 int element = Tile[x][y];
9533 int graphic = el2img(element);
9535 if (IS_ANIMATED(graphic))
9536 DrawLevelGraphicAnimationIfNeeded(x, y, graphic);
9541 // do not re-open exit door closed after last player
9542 if (game.all_players_gone)
9545 Tile[x][y] = EL_EM_EXIT_OPENING;
9547 PlayLevelSoundNearest(x, y, SND_CLASS_EM_EXIT_OPENING);
9550 static void CheckExitSteel(int x, int y)
9552 if (game.gems_still_needed > 0 ||
9553 game.sokoban_fields_still_needed > 0 ||
9554 game.sokoban_objects_still_needed > 0 ||
9555 game.lights_still_needed > 0)
9557 int element = Tile[x][y];
9558 int graphic = el2img(element);
9560 if (IS_ANIMATED(graphic))
9561 DrawLevelGraphicAnimationIfNeeded(x, y, graphic);
9566 // do not re-open exit door closed after last player
9567 if (game.all_players_gone)
9570 Tile[x][y] = EL_STEEL_EXIT_OPENING;
9572 PlayLevelSoundNearest(x, y, SND_CLASS_STEEL_EXIT_OPENING);
9575 static void CheckExitSteelEM(int x, int y)
9577 if (game.gems_still_needed > 0 ||
9578 game.sokoban_fields_still_needed > 0 ||
9579 game.sokoban_objects_still_needed > 0 ||
9580 game.lights_still_needed > 0)
9582 int element = Tile[x][y];
9583 int graphic = el2img(element);
9585 if (IS_ANIMATED(graphic))
9586 DrawLevelGraphicAnimationIfNeeded(x, y, graphic);
9591 // do not re-open exit door closed after last player
9592 if (game.all_players_gone)
9595 Tile[x][y] = EL_EM_STEEL_EXIT_OPENING;
9597 PlayLevelSoundNearest(x, y, SND_CLASS_EM_STEEL_EXIT_OPENING);
9600 static void CheckExitSP(int x, int y)
9602 if (game.gems_still_needed > 0)
9604 int element = Tile[x][y];
9605 int graphic = el2img(element);
9607 if (IS_ANIMATED(graphic))
9608 DrawLevelGraphicAnimationIfNeeded(x, y, graphic);
9613 // do not re-open exit door closed after last player
9614 if (game.all_players_gone)
9617 Tile[x][y] = EL_SP_EXIT_OPENING;
9619 PlayLevelSoundNearest(x, y, SND_CLASS_SP_EXIT_OPENING);
9622 static void CloseAllOpenTimegates(void)
9626 SCAN_PLAYFIELD(x, y)
9628 int element = Tile[x][y];
9630 if (element == EL_TIMEGATE_OPEN || element == EL_TIMEGATE_OPENING)
9632 Tile[x][y] = EL_TIMEGATE_CLOSING;
9634 PlayLevelSoundAction(x, y, ACTION_CLOSING);
9639 static void DrawTwinkleOnField(int x, int y)
9641 if (!IN_SCR_FIELD(SCREENX(x), SCREENY(y)) || IS_MOVING(x, y))
9644 if (Tile[x][y] == EL_BD_DIAMOND)
9647 if (MovDelay[x][y] == 0) // next animation frame
9648 MovDelay[x][y] = 11 * !GetSimpleRandom(500);
9650 if (MovDelay[x][y] != 0) // wait some time before next frame
9654 DrawLevelElementAnimation(x, y, Tile[x][y]);
9656 if (MovDelay[x][y] != 0)
9658 int frame = getGraphicAnimationFrame(IMG_TWINKLE_WHITE,
9659 10 - MovDelay[x][y]);
9661 DrawGraphicThruMask(SCREENX(x), SCREENY(y), IMG_TWINKLE_WHITE, frame);
9666 static void MauerWaechst(int x, int y)
9670 if (!MovDelay[x][y]) // next animation frame
9671 MovDelay[x][y] = 3 * delay;
9673 if (MovDelay[x][y]) // wait some time before next frame
9677 if (IN_SCR_FIELD(SCREENX(x), SCREENY(y)))
9679 int graphic = el_dir2img(Tile[x][y], GfxDir[x][y]);
9680 int frame = getGraphicAnimationFrame(graphic, 17 - MovDelay[x][y]);
9682 DrawGraphic(SCREENX(x), SCREENY(y), graphic, frame);
9685 if (!MovDelay[x][y])
9687 if (MovDir[x][y] == MV_LEFT)
9689 if (IN_LEV_FIELD(x - 1, y) && IS_WALL(Tile[x - 1][y]))
9690 TEST_DrawLevelField(x - 1, y);
9692 else if (MovDir[x][y] == MV_RIGHT)
9694 if (IN_LEV_FIELD(x + 1, y) && IS_WALL(Tile[x + 1][y]))
9695 TEST_DrawLevelField(x + 1, y);
9697 else if (MovDir[x][y] == MV_UP)
9699 if (IN_LEV_FIELD(x, y - 1) && IS_WALL(Tile[x][y - 1]))
9700 TEST_DrawLevelField(x, y - 1);
9704 if (IN_LEV_FIELD(x, y + 1) && IS_WALL(Tile[x][y + 1]))
9705 TEST_DrawLevelField(x, y + 1);
9708 Tile[x][y] = Store[x][y];
9710 GfxDir[x][y] = MovDir[x][y] = MV_NONE;
9711 TEST_DrawLevelField(x, y);
9716 static void MauerAbleger(int ax, int ay)
9718 int element = Tile[ax][ay];
9719 int graphic = el2img(element);
9720 boolean oben_frei = FALSE, unten_frei = FALSE;
9721 boolean links_frei = FALSE, rechts_frei = FALSE;
9722 boolean oben_massiv = FALSE, unten_massiv = FALSE;
9723 boolean links_massiv = FALSE, rechts_massiv = FALSE;
9724 boolean new_wall = FALSE;
9726 if (IS_ANIMATED(graphic))
9727 DrawLevelGraphicAnimationIfNeeded(ax, ay, graphic);
9729 if (!MovDelay[ax][ay]) // start building new wall
9730 MovDelay[ax][ay] = 6;
9732 if (MovDelay[ax][ay]) // wait some time before building new wall
9735 if (MovDelay[ax][ay])
9739 if (IN_LEV_FIELD(ax, ay-1) && IS_FREE(ax, ay-1))
9741 if (IN_LEV_FIELD(ax, ay+1) && IS_FREE(ax, ay+1))
9743 if (IN_LEV_FIELD(ax-1, ay) && IS_FREE(ax-1, ay))
9745 if (IN_LEV_FIELD(ax+1, ay) && IS_FREE(ax+1, ay))
9748 if (element == EL_EXPANDABLE_WALL_VERTICAL ||
9749 element == EL_EXPANDABLE_WALL_ANY)
9753 Tile[ax][ay-1] = EL_EXPANDABLE_WALL_GROWING;
9754 Store[ax][ay-1] = element;
9755 GfxDir[ax][ay-1] = MovDir[ax][ay-1] = MV_UP;
9756 if (IN_SCR_FIELD(SCREENX(ax), SCREENY(ay-1)))
9757 DrawGraphic(SCREENX(ax), SCREENY(ay - 1),
9758 IMG_EXPANDABLE_WALL_GROWING_UP, 0);
9763 Tile[ax][ay+1] = EL_EXPANDABLE_WALL_GROWING;
9764 Store[ax][ay+1] = element;
9765 GfxDir[ax][ay+1] = MovDir[ax][ay+1] = MV_DOWN;
9766 if (IN_SCR_FIELD(SCREENX(ax), SCREENY(ay+1)))
9767 DrawGraphic(SCREENX(ax), SCREENY(ay + 1),
9768 IMG_EXPANDABLE_WALL_GROWING_DOWN, 0);
9773 if (element == EL_EXPANDABLE_WALL_HORIZONTAL ||
9774 element == EL_EXPANDABLE_WALL_ANY ||
9775 element == EL_EXPANDABLE_WALL ||
9776 element == EL_BD_EXPANDABLE_WALL)
9780 Tile[ax-1][ay] = EL_EXPANDABLE_WALL_GROWING;
9781 Store[ax-1][ay] = element;
9782 GfxDir[ax-1][ay] = MovDir[ax-1][ay] = MV_LEFT;
9783 if (IN_SCR_FIELD(SCREENX(ax-1), SCREENY(ay)))
9784 DrawGraphic(SCREENX(ax - 1), SCREENY(ay),
9785 IMG_EXPANDABLE_WALL_GROWING_LEFT, 0);
9791 Tile[ax+1][ay] = EL_EXPANDABLE_WALL_GROWING;
9792 Store[ax+1][ay] = element;
9793 GfxDir[ax+1][ay] = MovDir[ax+1][ay] = MV_RIGHT;
9794 if (IN_SCR_FIELD(SCREENX(ax+1), SCREENY(ay)))
9795 DrawGraphic(SCREENX(ax + 1), SCREENY(ay),
9796 IMG_EXPANDABLE_WALL_GROWING_RIGHT, 0);
9801 if (element == EL_EXPANDABLE_WALL && (links_frei || rechts_frei))
9802 TEST_DrawLevelField(ax, ay);
9804 if (!IN_LEV_FIELD(ax, ay-1) || IS_WALL(Tile[ax][ay-1]))
9806 if (!IN_LEV_FIELD(ax, ay+1) || IS_WALL(Tile[ax][ay+1]))
9807 unten_massiv = TRUE;
9808 if (!IN_LEV_FIELD(ax-1, ay) || IS_WALL(Tile[ax-1][ay]))
9809 links_massiv = TRUE;
9810 if (!IN_LEV_FIELD(ax+1, ay) || IS_WALL(Tile[ax+1][ay]))
9811 rechts_massiv = TRUE;
9813 if (((oben_massiv && unten_massiv) ||
9814 element == EL_EXPANDABLE_WALL_HORIZONTAL ||
9815 element == EL_EXPANDABLE_WALL) &&
9816 ((links_massiv && rechts_massiv) ||
9817 element == EL_EXPANDABLE_WALL_VERTICAL))
9818 Tile[ax][ay] = EL_WALL;
9821 PlayLevelSoundAction(ax, ay, ACTION_GROWING);
9824 static void MauerAblegerStahl(int ax, int ay)
9826 int element = Tile[ax][ay];
9827 int graphic = el2img(element);
9828 boolean oben_frei = FALSE, unten_frei = FALSE;
9829 boolean links_frei = FALSE, rechts_frei = FALSE;
9830 boolean oben_massiv = FALSE, unten_massiv = FALSE;
9831 boolean links_massiv = FALSE, rechts_massiv = FALSE;
9832 boolean new_wall = FALSE;
9834 if (IS_ANIMATED(graphic))
9835 DrawLevelGraphicAnimationIfNeeded(ax, ay, graphic);
9837 if (!MovDelay[ax][ay]) // start building new wall
9838 MovDelay[ax][ay] = 6;
9840 if (MovDelay[ax][ay]) // wait some time before building new wall
9843 if (MovDelay[ax][ay])
9847 if (IN_LEV_FIELD(ax, ay-1) && IS_FREE(ax, ay-1))
9849 if (IN_LEV_FIELD(ax, ay+1) && IS_FREE(ax, ay+1))
9851 if (IN_LEV_FIELD(ax-1, ay) && IS_FREE(ax-1, ay))
9853 if (IN_LEV_FIELD(ax+1, ay) && IS_FREE(ax+1, ay))
9856 if (element == EL_EXPANDABLE_STEELWALL_VERTICAL ||
9857 element == EL_EXPANDABLE_STEELWALL_ANY)
9861 Tile[ax][ay-1] = EL_EXPANDABLE_STEELWALL_GROWING;
9862 Store[ax][ay-1] = element;
9863 GfxDir[ax][ay-1] = MovDir[ax][ay-1] = MV_UP;
9864 if (IN_SCR_FIELD(SCREENX(ax), SCREENY(ay-1)))
9865 DrawGraphic(SCREENX(ax), SCREENY(ay - 1),
9866 IMG_EXPANDABLE_STEELWALL_GROWING_UP, 0);
9871 Tile[ax][ay+1] = EL_EXPANDABLE_STEELWALL_GROWING;
9872 Store[ax][ay+1] = element;
9873 GfxDir[ax][ay+1] = MovDir[ax][ay+1] = MV_DOWN;
9874 if (IN_SCR_FIELD(SCREENX(ax), SCREENY(ay+1)))
9875 DrawGraphic(SCREENX(ax), SCREENY(ay + 1),
9876 IMG_EXPANDABLE_STEELWALL_GROWING_DOWN, 0);
9881 if (element == EL_EXPANDABLE_STEELWALL_HORIZONTAL ||
9882 element == EL_EXPANDABLE_STEELWALL_ANY)
9886 Tile[ax-1][ay] = EL_EXPANDABLE_STEELWALL_GROWING;
9887 Store[ax-1][ay] = element;
9888 GfxDir[ax-1][ay] = MovDir[ax-1][ay] = MV_LEFT;
9889 if (IN_SCR_FIELD(SCREENX(ax-1), SCREENY(ay)))
9890 DrawGraphic(SCREENX(ax - 1), SCREENY(ay),
9891 IMG_EXPANDABLE_STEELWALL_GROWING_LEFT, 0);
9897 Tile[ax+1][ay] = EL_EXPANDABLE_STEELWALL_GROWING;
9898 Store[ax+1][ay] = element;
9899 GfxDir[ax+1][ay] = MovDir[ax+1][ay] = MV_RIGHT;
9900 if (IN_SCR_FIELD(SCREENX(ax+1), SCREENY(ay)))
9901 DrawGraphic(SCREENX(ax + 1), SCREENY(ay),
9902 IMG_EXPANDABLE_STEELWALL_GROWING_RIGHT, 0);
9907 if (!IN_LEV_FIELD(ax, ay-1) || IS_WALL(Tile[ax][ay-1]))
9909 if (!IN_LEV_FIELD(ax, ay+1) || IS_WALL(Tile[ax][ay+1]))
9910 unten_massiv = TRUE;
9911 if (!IN_LEV_FIELD(ax-1, ay) || IS_WALL(Tile[ax-1][ay]))
9912 links_massiv = TRUE;
9913 if (!IN_LEV_FIELD(ax+1, ay) || IS_WALL(Tile[ax+1][ay]))
9914 rechts_massiv = TRUE;
9916 if (((oben_massiv && unten_massiv) ||
9917 element == EL_EXPANDABLE_STEELWALL_HORIZONTAL) &&
9918 ((links_massiv && rechts_massiv) ||
9919 element == EL_EXPANDABLE_STEELWALL_VERTICAL))
9920 Tile[ax][ay] = EL_STEELWALL;
9923 PlayLevelSoundAction(ax, ay, ACTION_GROWING);
9926 static void CheckForDragon(int x, int y)
9929 boolean dragon_found = FALSE;
9930 static int xy[4][2] =
9938 for (i = 0; i < NUM_DIRECTIONS; i++)
9940 for (j = 0; j < 4; j++)
9942 int xx = x + j * xy[i][0], yy = y + j * xy[i][1];
9944 if (IN_LEV_FIELD(xx, yy) &&
9945 (Tile[xx][yy] == EL_FLAMES || Tile[xx][yy] == EL_DRAGON))
9947 if (Tile[xx][yy] == EL_DRAGON)
9948 dragon_found = TRUE;
9957 for (i = 0; i < NUM_DIRECTIONS; i++)
9959 for (j = 0; j < 3; j++)
9961 int xx = x + j * xy[i][0], yy = y + j * xy[i][1];
9963 if (IN_LEV_FIELD(xx, yy) && Tile[xx][yy] == EL_FLAMES)
9965 Tile[xx][yy] = EL_EMPTY;
9966 TEST_DrawLevelField(xx, yy);
9975 static void InitBuggyBase(int x, int y)
9977 int element = Tile[x][y];
9978 int activating_delay = FRAMES_PER_SECOND / 4;
9981 (element == EL_SP_BUGGY_BASE ?
9982 2 * FRAMES_PER_SECOND + RND(5 * FRAMES_PER_SECOND) - activating_delay :
9983 element == EL_SP_BUGGY_BASE_ACTIVATING ?
9985 element == EL_SP_BUGGY_BASE_ACTIVE ?
9986 1 * FRAMES_PER_SECOND + RND(1 * FRAMES_PER_SECOND) : 1);
9989 static void WarnBuggyBase(int x, int y)
9992 static int xy[4][2] =
10000 for (i = 0; i < NUM_DIRECTIONS; i++)
10002 int xx = x + xy[i][0];
10003 int yy = y + xy[i][1];
10005 if (IN_LEV_FIELD(xx, yy) && IS_PLAYER(xx, yy))
10007 PlayLevelSound(x, y, SND_SP_BUGGY_BASE_ACTIVE);
10014 static void InitTrap(int x, int y)
10016 ChangeDelay[x][y] = 2 * FRAMES_PER_SECOND + RND(5 * FRAMES_PER_SECOND);
10019 static void ActivateTrap(int x, int y)
10021 PlayLevelSound(x, y, SND_TRAP_ACTIVATING);
10024 static void ChangeActiveTrap(int x, int y)
10026 int graphic = IMG_TRAP_ACTIVE;
10028 // if new animation frame was drawn, correct crumbled sand border
10029 if (IS_NEW_FRAME(GfxFrame[x][y], graphic))
10030 TEST_DrawLevelFieldCrumbled(x, y);
10033 static int getSpecialActionElement(int element, int number, int base_element)
10035 return (element != EL_EMPTY ? element :
10036 number != -1 ? base_element + number - 1 :
10040 static int getModifiedActionNumber(int value_old, int operator, int operand,
10041 int value_min, int value_max)
10043 int value_new = (operator == CA_MODE_SET ? operand :
10044 operator == CA_MODE_ADD ? value_old + operand :
10045 operator == CA_MODE_SUBTRACT ? value_old - operand :
10046 operator == CA_MODE_MULTIPLY ? value_old * operand :
10047 operator == CA_MODE_DIVIDE ? value_old / MAX(1, operand) :
10048 operator == CA_MODE_MODULO ? value_old % MAX(1, operand) :
10051 return (value_new < value_min ? value_min :
10052 value_new > value_max ? value_max :
10056 static void ExecuteCustomElementAction(int x, int y, int element, int page)
10058 struct ElementInfo *ei = &element_info[element];
10059 struct ElementChangeInfo *change = &ei->change_page[page];
10060 int target_element = change->target_element;
10061 int action_type = change->action_type;
10062 int action_mode = change->action_mode;
10063 int action_arg = change->action_arg;
10064 int action_element = change->action_element;
10067 if (!change->has_action)
10070 // ---------- determine action paramater values -----------------------------
10072 int level_time_value =
10073 (level.time > 0 ? TimeLeft :
10076 int action_arg_element_raw =
10077 (action_arg == CA_ARG_PLAYER_TRIGGER ? change->actual_trigger_player :
10078 action_arg == CA_ARG_ELEMENT_TRIGGER ? change->actual_trigger_element :
10079 action_arg == CA_ARG_ELEMENT_TARGET ? change->target_element :
10080 action_arg == CA_ARG_ELEMENT_ACTION ? change->action_element :
10081 action_arg == CA_ARG_INVENTORY_RM_TRIGGER ? change->actual_trigger_element:
10082 action_arg == CA_ARG_INVENTORY_RM_TARGET ? change->target_element :
10083 action_arg == CA_ARG_INVENTORY_RM_ACTION ? change->action_element :
10085 int action_arg_element = GetElementFromGroupElement(action_arg_element_raw);
10087 int action_arg_direction =
10088 (action_arg >= CA_ARG_DIRECTION_LEFT &&
10089 action_arg <= CA_ARG_DIRECTION_DOWN ? action_arg - CA_ARG_DIRECTION :
10090 action_arg == CA_ARG_DIRECTION_TRIGGER ?
10091 change->actual_trigger_side :
10092 action_arg == CA_ARG_DIRECTION_TRIGGER_BACK ?
10093 MV_DIR_OPPOSITE(change->actual_trigger_side) :
10096 int action_arg_number_min =
10097 (action_type == CA_SET_PLAYER_SPEED ? STEPSIZE_NOT_MOVING :
10100 int action_arg_number_max =
10101 (action_type == CA_SET_PLAYER_SPEED ? STEPSIZE_EVEN_FASTER :
10102 action_type == CA_SET_LEVEL_GEMS ? 999 :
10103 action_type == CA_SET_LEVEL_TIME ? 9999 :
10104 action_type == CA_SET_LEVEL_SCORE ? 99999 :
10105 action_type == CA_SET_CE_VALUE ? 9999 :
10106 action_type == CA_SET_CE_SCORE ? 9999 :
10109 int action_arg_number_reset =
10110 (action_type == CA_SET_PLAYER_SPEED ? level.initial_player_stepsize[0] :
10111 action_type == CA_SET_LEVEL_GEMS ? level.gems_needed :
10112 action_type == CA_SET_LEVEL_TIME ? level.time :
10113 action_type == CA_SET_LEVEL_SCORE ? 0 :
10114 action_type == CA_SET_CE_VALUE ? GET_NEW_CE_VALUE(element) :
10115 action_type == CA_SET_CE_SCORE ? 0 :
10118 int action_arg_number =
10119 (action_arg <= CA_ARG_MAX ? action_arg :
10120 action_arg >= CA_ARG_SPEED_NOT_MOVING &&
10121 action_arg <= CA_ARG_SPEED_EVEN_FASTER ? (action_arg - CA_ARG_SPEED) :
10122 action_arg == CA_ARG_SPEED_RESET ? action_arg_number_reset :
10123 action_arg == CA_ARG_NUMBER_MIN ? action_arg_number_min :
10124 action_arg == CA_ARG_NUMBER_MAX ? action_arg_number_max :
10125 action_arg == CA_ARG_NUMBER_RESET ? action_arg_number_reset :
10126 action_arg == CA_ARG_NUMBER_CE_VALUE ? CustomValue[x][y] :
10127 action_arg == CA_ARG_NUMBER_CE_SCORE ? ei->collect_score :
10128 action_arg == CA_ARG_NUMBER_CE_DELAY ? GET_CE_DELAY_VALUE(change) :
10129 action_arg == CA_ARG_NUMBER_LEVEL_TIME ? level_time_value :
10130 action_arg == CA_ARG_NUMBER_LEVEL_GEMS ? game.gems_still_needed :
10131 action_arg == CA_ARG_NUMBER_LEVEL_SCORE ? game.score :
10132 action_arg == CA_ARG_ELEMENT_CV_TARGET ? GET_NEW_CE_VALUE(target_element):
10133 action_arg == CA_ARG_ELEMENT_CV_TRIGGER ? change->actual_trigger_ce_value:
10134 action_arg == CA_ARG_ELEMENT_CV_ACTION ? GET_NEW_CE_VALUE(action_element):
10135 action_arg == CA_ARG_ELEMENT_CS_TARGET ? GET_CE_SCORE(target_element) :
10136 action_arg == CA_ARG_ELEMENT_CS_TRIGGER ? change->actual_trigger_ce_score:
10137 action_arg == CA_ARG_ELEMENT_CS_ACTION ? GET_CE_SCORE(action_element) :
10138 action_arg == CA_ARG_ELEMENT_NR_TARGET ? change->target_element :
10139 action_arg == CA_ARG_ELEMENT_NR_TRIGGER ? change->actual_trigger_element :
10140 action_arg == CA_ARG_ELEMENT_NR_ACTION ? change->action_element :
10143 int action_arg_number_old =
10144 (action_type == CA_SET_LEVEL_GEMS ? game.gems_still_needed :
10145 action_type == CA_SET_LEVEL_TIME ? TimeLeft :
10146 action_type == CA_SET_LEVEL_SCORE ? game.score :
10147 action_type == CA_SET_CE_VALUE ? CustomValue[x][y] :
10148 action_type == CA_SET_CE_SCORE ? ei->collect_score :
10151 int action_arg_number_new =
10152 getModifiedActionNumber(action_arg_number_old,
10153 action_mode, action_arg_number,
10154 action_arg_number_min, action_arg_number_max);
10156 int trigger_player_bits =
10157 (change->actual_trigger_player_bits != CH_PLAYER_NONE ?
10158 change->actual_trigger_player_bits : change->trigger_player);
10160 int action_arg_player_bits =
10161 (action_arg >= CA_ARG_PLAYER_1 &&
10162 action_arg <= CA_ARG_PLAYER_4 ? action_arg - CA_ARG_PLAYER :
10163 action_arg == CA_ARG_PLAYER_TRIGGER ? trigger_player_bits :
10164 action_arg == CA_ARG_PLAYER_ACTION ? 1 << GET_PLAYER_NR(action_element) :
10167 // ---------- execute action -----------------------------------------------
10169 switch (action_type)
10176 // ---------- level actions ----------------------------------------------
10178 case CA_RESTART_LEVEL:
10180 game.restart_level = TRUE;
10185 case CA_SHOW_ENVELOPE:
10187 int element = getSpecialActionElement(action_arg_element,
10188 action_arg_number, EL_ENVELOPE_1);
10190 if (IS_ENVELOPE(element))
10191 local_player->show_envelope = element;
10196 case CA_SET_LEVEL_TIME:
10198 if (level.time > 0) // only modify limited time value
10200 TimeLeft = action_arg_number_new;
10202 game_panel_controls[GAME_PANEL_TIME].value = TimeLeft;
10204 DisplayGameControlValues();
10206 if (!TimeLeft && setup.time_limit)
10207 for (i = 0; i < MAX_PLAYERS; i++)
10208 KillPlayer(&stored_player[i]);
10214 case CA_SET_LEVEL_SCORE:
10216 game.score = action_arg_number_new;
10218 game_panel_controls[GAME_PANEL_SCORE].value = game.score;
10220 DisplayGameControlValues();
10225 case CA_SET_LEVEL_GEMS:
10227 game.gems_still_needed = action_arg_number_new;
10229 game.snapshot.collected_item = TRUE;
10231 game_panel_controls[GAME_PANEL_GEMS].value = game.gems_still_needed;
10233 DisplayGameControlValues();
10238 case CA_SET_LEVEL_WIND:
10240 game.wind_direction = action_arg_direction;
10245 case CA_SET_LEVEL_RANDOM_SEED:
10247 // ensure that setting a new random seed while playing is predictable
10248 InitRND(action_arg_number_new ? action_arg_number_new : RND(1000000) + 1);
10253 // ---------- player actions ---------------------------------------------
10255 case CA_MOVE_PLAYER:
10256 case CA_MOVE_PLAYER_NEW:
10258 // automatically move to the next field in specified direction
10259 for (i = 0; i < MAX_PLAYERS; i++)
10260 if (trigger_player_bits & (1 << i))
10261 if (action_type == CA_MOVE_PLAYER ||
10262 stored_player[i].MovPos == 0)
10263 stored_player[i].programmed_action = action_arg_direction;
10268 case CA_EXIT_PLAYER:
10270 for (i = 0; i < MAX_PLAYERS; i++)
10271 if (action_arg_player_bits & (1 << i))
10272 ExitPlayer(&stored_player[i]);
10274 if (game.players_still_needed == 0)
10280 case CA_KILL_PLAYER:
10282 for (i = 0; i < MAX_PLAYERS; i++)
10283 if (action_arg_player_bits & (1 << i))
10284 KillPlayer(&stored_player[i]);
10289 case CA_SET_PLAYER_KEYS:
10291 int key_state = (action_mode == CA_MODE_ADD ? TRUE : FALSE);
10292 int element = getSpecialActionElement(action_arg_element,
10293 action_arg_number, EL_KEY_1);
10295 if (IS_KEY(element))
10297 for (i = 0; i < MAX_PLAYERS; i++)
10299 if (trigger_player_bits & (1 << i))
10301 stored_player[i].key[KEY_NR(element)] = key_state;
10303 DrawGameDoorValues();
10311 case CA_SET_PLAYER_SPEED:
10313 for (i = 0; i < MAX_PLAYERS; i++)
10315 if (trigger_player_bits & (1 << i))
10317 int move_stepsize = TILEX / stored_player[i].move_delay_value;
10319 if (action_arg == CA_ARG_SPEED_FASTER &&
10320 stored_player[i].cannot_move)
10322 action_arg_number = STEPSIZE_VERY_SLOW;
10324 else if (action_arg == CA_ARG_SPEED_SLOWER ||
10325 action_arg == CA_ARG_SPEED_FASTER)
10327 action_arg_number = 2;
10328 action_mode = (action_arg == CA_ARG_SPEED_SLOWER ? CA_MODE_DIVIDE :
10331 else if (action_arg == CA_ARG_NUMBER_RESET)
10333 action_arg_number = level.initial_player_stepsize[i];
10337 getModifiedActionNumber(move_stepsize,
10340 action_arg_number_min,
10341 action_arg_number_max);
10343 SetPlayerMoveSpeed(&stored_player[i], move_stepsize, FALSE);
10350 case CA_SET_PLAYER_SHIELD:
10352 for (i = 0; i < MAX_PLAYERS; i++)
10354 if (trigger_player_bits & (1 << i))
10356 if (action_arg == CA_ARG_SHIELD_OFF)
10358 stored_player[i].shield_normal_time_left = 0;
10359 stored_player[i].shield_deadly_time_left = 0;
10361 else if (action_arg == CA_ARG_SHIELD_NORMAL)
10363 stored_player[i].shield_normal_time_left = 999999;
10365 else if (action_arg == CA_ARG_SHIELD_DEADLY)
10367 stored_player[i].shield_normal_time_left = 999999;
10368 stored_player[i].shield_deadly_time_left = 999999;
10376 case CA_SET_PLAYER_GRAVITY:
10378 for (i = 0; i < MAX_PLAYERS; i++)
10380 if (trigger_player_bits & (1 << i))
10382 stored_player[i].gravity =
10383 (action_arg == CA_ARG_GRAVITY_OFF ? FALSE :
10384 action_arg == CA_ARG_GRAVITY_ON ? TRUE :
10385 action_arg == CA_ARG_GRAVITY_TOGGLE ? !stored_player[i].gravity :
10386 stored_player[i].gravity);
10393 case CA_SET_PLAYER_ARTWORK:
10395 for (i = 0; i < MAX_PLAYERS; i++)
10397 if (trigger_player_bits & (1 << i))
10399 int artwork_element = action_arg_element;
10401 if (action_arg == CA_ARG_ELEMENT_RESET)
10403 (level.use_artwork_element[i] ? level.artwork_element[i] :
10404 stored_player[i].element_nr);
10406 if (stored_player[i].artwork_element != artwork_element)
10407 stored_player[i].Frame = 0;
10409 stored_player[i].artwork_element = artwork_element;
10411 SetPlayerWaiting(&stored_player[i], FALSE);
10413 // set number of special actions for bored and sleeping animation
10414 stored_player[i].num_special_action_bored =
10415 get_num_special_action(artwork_element,
10416 ACTION_BORING_1, ACTION_BORING_LAST);
10417 stored_player[i].num_special_action_sleeping =
10418 get_num_special_action(artwork_element,
10419 ACTION_SLEEPING_1, ACTION_SLEEPING_LAST);
10426 case CA_SET_PLAYER_INVENTORY:
10428 for (i = 0; i < MAX_PLAYERS; i++)
10430 struct PlayerInfo *player = &stored_player[i];
10433 if (trigger_player_bits & (1 << i))
10435 int inventory_element = action_arg_element;
10437 if (action_arg == CA_ARG_ELEMENT_TARGET ||
10438 action_arg == CA_ARG_ELEMENT_TRIGGER ||
10439 action_arg == CA_ARG_ELEMENT_ACTION)
10441 int element = inventory_element;
10442 int collect_count = element_info[element].collect_count_initial;
10444 if (!IS_CUSTOM_ELEMENT(element))
10447 if (collect_count == 0)
10448 player->inventory_infinite_element = element;
10450 for (k = 0; k < collect_count; k++)
10451 if (player->inventory_size < MAX_INVENTORY_SIZE)
10452 player->inventory_element[player->inventory_size++] =
10455 else if (action_arg == CA_ARG_INVENTORY_RM_TARGET ||
10456 action_arg == CA_ARG_INVENTORY_RM_TRIGGER ||
10457 action_arg == CA_ARG_INVENTORY_RM_ACTION)
10459 if (player->inventory_infinite_element != EL_UNDEFINED &&
10460 IS_EQUAL_OR_IN_GROUP(player->inventory_infinite_element,
10461 action_arg_element_raw))
10462 player->inventory_infinite_element = EL_UNDEFINED;
10464 for (k = 0, j = 0; j < player->inventory_size; j++)
10466 if (!IS_EQUAL_OR_IN_GROUP(player->inventory_element[j],
10467 action_arg_element_raw))
10468 player->inventory_element[k++] = player->inventory_element[j];
10471 player->inventory_size = k;
10473 else if (action_arg == CA_ARG_INVENTORY_RM_FIRST)
10475 if (player->inventory_size > 0)
10477 for (j = 0; j < player->inventory_size - 1; j++)
10478 player->inventory_element[j] = player->inventory_element[j + 1];
10480 player->inventory_size--;
10483 else if (action_arg == CA_ARG_INVENTORY_RM_LAST)
10485 if (player->inventory_size > 0)
10486 player->inventory_size--;
10488 else if (action_arg == CA_ARG_INVENTORY_RM_ALL)
10490 player->inventory_infinite_element = EL_UNDEFINED;
10491 player->inventory_size = 0;
10493 else if (action_arg == CA_ARG_INVENTORY_RESET)
10495 player->inventory_infinite_element = EL_UNDEFINED;
10496 player->inventory_size = 0;
10498 if (level.use_initial_inventory[i])
10500 for (j = 0; j < level.initial_inventory_size[i]; j++)
10502 int element = level.initial_inventory_content[i][j];
10503 int collect_count = element_info[element].collect_count_initial;
10505 if (!IS_CUSTOM_ELEMENT(element))
10508 if (collect_count == 0)
10509 player->inventory_infinite_element = element;
10511 for (k = 0; k < collect_count; k++)
10512 if (player->inventory_size < MAX_INVENTORY_SIZE)
10513 player->inventory_element[player->inventory_size++] =
10524 // ---------- CE actions -------------------------------------------------
10526 case CA_SET_CE_VALUE:
10528 int last_ce_value = CustomValue[x][y];
10530 CustomValue[x][y] = action_arg_number_new;
10532 if (CustomValue[x][y] != last_ce_value)
10534 CheckElementChange(x, y, element, EL_UNDEFINED, CE_VALUE_CHANGES);
10535 CheckTriggeredElementChange(x, y, element, CE_VALUE_CHANGES_OF_X);
10537 if (CustomValue[x][y] == 0)
10539 // reset change counter (else CE_VALUE_GETS_ZERO would not work)
10540 ChangeCount[x][y] = 0; // allow at least one more change
10542 CheckElementChange(x, y, element, EL_UNDEFINED, CE_VALUE_GETS_ZERO);
10543 CheckTriggeredElementChange(x, y, element, CE_VALUE_GETS_ZERO_OF_X);
10550 case CA_SET_CE_SCORE:
10552 int last_ce_score = ei->collect_score;
10554 ei->collect_score = action_arg_number_new;
10556 if (ei->collect_score != last_ce_score)
10558 CheckElementChange(x, y, element, EL_UNDEFINED, CE_SCORE_CHANGES);
10559 CheckTriggeredElementChange(x, y, element, CE_SCORE_CHANGES_OF_X);
10561 if (ei->collect_score == 0)
10565 // reset change counter (else CE_SCORE_GETS_ZERO would not work)
10566 ChangeCount[x][y] = 0; // allow at least one more change
10568 CheckElementChange(x, y, element, EL_UNDEFINED, CE_SCORE_GETS_ZERO);
10569 CheckTriggeredElementChange(x, y, element, CE_SCORE_GETS_ZERO_OF_X);
10572 This is a very special case that seems to be a mixture between
10573 CheckElementChange() and CheckTriggeredElementChange(): while
10574 the first one only affects single elements that are triggered
10575 directly, the second one affects multiple elements in the playfield
10576 that are triggered indirectly by another element. This is a third
10577 case: Changing the CE score always affects multiple identical CEs,
10578 so every affected CE must be checked, not only the single CE for
10579 which the CE score was changed in the first place (as every instance
10580 of that CE shares the same CE score, and therefore also can change)!
10582 SCAN_PLAYFIELD(xx, yy)
10584 if (Tile[xx][yy] == element)
10585 CheckElementChange(xx, yy, element, EL_UNDEFINED,
10586 CE_SCORE_GETS_ZERO);
10594 case CA_SET_CE_ARTWORK:
10596 int artwork_element = action_arg_element;
10597 boolean reset_frame = FALSE;
10600 if (action_arg == CA_ARG_ELEMENT_RESET)
10601 artwork_element = (ei->use_gfx_element ? ei->gfx_element_initial :
10604 if (ei->gfx_element != artwork_element)
10605 reset_frame = TRUE;
10607 ei->gfx_element = artwork_element;
10609 SCAN_PLAYFIELD(xx, yy)
10611 if (Tile[xx][yy] == element)
10615 ResetGfxAnimation(xx, yy);
10616 ResetRandomAnimationValue(xx, yy);
10619 TEST_DrawLevelField(xx, yy);
10626 // ---------- engine actions ---------------------------------------------
10628 case CA_SET_ENGINE_SCAN_MODE:
10630 InitPlayfieldScanMode(action_arg);
10640 static void CreateFieldExt(int x, int y, int element, boolean is_change)
10642 int old_element = Tile[x][y];
10643 int new_element = GetElementFromGroupElement(element);
10644 int previous_move_direction = MovDir[x][y];
10645 int last_ce_value = CustomValue[x][y];
10646 boolean player_explosion_protected = PLAYER_EXPLOSION_PROTECTED(x, y);
10647 boolean new_element_is_player = IS_PLAYER_ELEMENT(new_element);
10648 boolean add_player_onto_element = (new_element_is_player &&
10649 new_element != EL_SOKOBAN_FIELD_PLAYER &&
10650 IS_WALKABLE(old_element));
10652 if (!add_player_onto_element)
10654 if (IS_MOVING(x, y) || IS_BLOCKED(x, y))
10655 RemoveMovingField(x, y);
10659 Tile[x][y] = new_element;
10661 if (element_info[new_element].move_direction_initial == MV_START_PREVIOUS)
10662 MovDir[x][y] = previous_move_direction;
10664 if (element_info[new_element].use_last_ce_value)
10665 CustomValue[x][y] = last_ce_value;
10667 InitField_WithBug1(x, y, FALSE);
10669 new_element = Tile[x][y]; // element may have changed
10671 ResetGfxAnimation(x, y);
10672 ResetRandomAnimationValue(x, y);
10674 TEST_DrawLevelField(x, y);
10676 if (GFX_CRUMBLED(new_element))
10677 TEST_DrawLevelFieldCrumbledNeighbours(x, y);
10680 // check if element under the player changes from accessible to unaccessible
10681 // (needed for special case of dropping element which then changes)
10682 // (must be checked after creating new element for walkable group elements)
10683 if (IS_PLAYER(x, y) && !player_explosion_protected &&
10684 IS_ACCESSIBLE(old_element) && !IS_ACCESSIBLE(new_element))
10691 // "ChangeCount" not set yet to allow "entered by player" change one time
10692 if (new_element_is_player)
10693 RelocatePlayer(x, y, new_element);
10696 ChangeCount[x][y]++; // count number of changes in the same frame
10698 TestIfBadThingTouchesPlayer(x, y);
10699 TestIfPlayerTouchesCustomElement(x, y);
10700 TestIfElementTouchesCustomElement(x, y);
10703 static void CreateField(int x, int y, int element)
10705 CreateFieldExt(x, y, element, FALSE);
10708 static void CreateElementFromChange(int x, int y, int element)
10710 element = GET_VALID_RUNTIME_ELEMENT(element);
10712 if (game.engine_version >= VERSION_IDENT(3,2,0,7))
10714 int old_element = Tile[x][y];
10716 // prevent changed element from moving in same engine frame
10717 // unless both old and new element can either fall or move
10718 if ((!CAN_FALL(old_element) || !CAN_FALL(element)) &&
10719 (!CAN_MOVE(old_element) || !CAN_MOVE(element)))
10723 CreateFieldExt(x, y, element, TRUE);
10726 static boolean ChangeElement(int x, int y, int element, int page)
10728 struct ElementInfo *ei = &element_info[element];
10729 struct ElementChangeInfo *change = &ei->change_page[page];
10730 int ce_value = CustomValue[x][y];
10731 int ce_score = ei->collect_score;
10732 int target_element;
10733 int old_element = Tile[x][y];
10735 // always use default change event to prevent running into a loop
10736 if (ChangeEvent[x][y] == -1)
10737 ChangeEvent[x][y] = CE_DELAY;
10739 if (ChangeEvent[x][y] == CE_DELAY)
10741 // reset actual trigger element, trigger player and action element
10742 change->actual_trigger_element = EL_EMPTY;
10743 change->actual_trigger_player = EL_EMPTY;
10744 change->actual_trigger_player_bits = CH_PLAYER_NONE;
10745 change->actual_trigger_side = CH_SIDE_NONE;
10746 change->actual_trigger_ce_value = 0;
10747 change->actual_trigger_ce_score = 0;
10750 // do not change elements more than a specified maximum number of changes
10751 if (ChangeCount[x][y] >= game.max_num_changes_per_frame)
10754 ChangeCount[x][y]++; // count number of changes in the same frame
10756 if (change->explode)
10763 if (change->use_target_content)
10765 boolean complete_replace = TRUE;
10766 boolean can_replace[3][3];
10769 for (yy = 0; yy < 3; yy++) for (xx = 0; xx < 3 ; xx++)
10772 boolean is_walkable;
10773 boolean is_diggable;
10774 boolean is_collectible;
10775 boolean is_removable;
10776 boolean is_destructible;
10777 int ex = x + xx - 1;
10778 int ey = y + yy - 1;
10779 int content_element = change->target_content.e[xx][yy];
10782 can_replace[xx][yy] = TRUE;
10784 if (ex == x && ey == y) // do not check changing element itself
10787 if (content_element == EL_EMPTY_SPACE)
10789 can_replace[xx][yy] = FALSE; // do not replace border with space
10794 if (!IN_LEV_FIELD(ex, ey))
10796 can_replace[xx][yy] = FALSE;
10797 complete_replace = FALSE;
10804 if (IS_MOVING(ex, ey) || IS_BLOCKED(ex, ey))
10805 e = MovingOrBlocked2Element(ex, ey);
10807 is_empty = (IS_FREE(ex, ey) ||
10808 (IS_FREE_OR_PLAYER(ex, ey) && IS_WALKABLE(content_element)));
10810 is_walkable = (is_empty || IS_WALKABLE(e));
10811 is_diggable = (is_empty || IS_DIGGABLE(e));
10812 is_collectible = (is_empty || IS_COLLECTIBLE(e));
10813 is_destructible = (is_empty || !IS_INDESTRUCTIBLE(e));
10814 is_removable = (is_diggable || is_collectible);
10816 can_replace[xx][yy] =
10817 (((change->replace_when == CP_WHEN_EMPTY && is_empty) ||
10818 (change->replace_when == CP_WHEN_WALKABLE && is_walkable) ||
10819 (change->replace_when == CP_WHEN_DIGGABLE && is_diggable) ||
10820 (change->replace_when == CP_WHEN_COLLECTIBLE && is_collectible) ||
10821 (change->replace_when == CP_WHEN_REMOVABLE && is_removable) ||
10822 (change->replace_when == CP_WHEN_DESTRUCTIBLE && is_destructible)) &&
10823 !(IS_PLAYER(ex, ey) && IS_PLAYER_ELEMENT(content_element)));
10825 if (!can_replace[xx][yy])
10826 complete_replace = FALSE;
10829 if (!change->only_if_complete || complete_replace)
10831 boolean something_has_changed = FALSE;
10833 if (change->only_if_complete && change->use_random_replace &&
10834 RND(100) < change->random_percentage)
10837 for (yy = 0; yy < 3; yy++) for (xx = 0; xx < 3 ; xx++)
10839 int ex = x + xx - 1;
10840 int ey = y + yy - 1;
10841 int content_element;
10843 if (can_replace[xx][yy] && (!change->use_random_replace ||
10844 RND(100) < change->random_percentage))
10846 if (IS_MOVING(ex, ey) || IS_BLOCKED(ex, ey))
10847 RemoveMovingField(ex, ey);
10849 ChangeEvent[ex][ey] = ChangeEvent[x][y];
10851 content_element = change->target_content.e[xx][yy];
10852 target_element = GET_TARGET_ELEMENT(element, content_element, change,
10853 ce_value, ce_score);
10855 CreateElementFromChange(ex, ey, target_element);
10857 something_has_changed = TRUE;
10859 // for symmetry reasons, freeze newly created border elements
10860 if (ex != x || ey != y)
10861 Stop[ex][ey] = TRUE; // no more moving in this frame
10865 if (something_has_changed)
10867 PlayLevelSoundElementAction(x, y, element, ACTION_CHANGING);
10868 PlayLevelSoundElementAction(x, y, element, ACTION_PAGE_1 + page);
10874 target_element = GET_TARGET_ELEMENT(element, change->target_element, change,
10875 ce_value, ce_score);
10877 if (element == EL_DIAGONAL_GROWING ||
10878 element == EL_DIAGONAL_SHRINKING)
10880 target_element = Store[x][y];
10882 Store[x][y] = EL_EMPTY;
10885 // special case: element changes to player (and may be kept if walkable)
10886 if (IS_PLAYER_ELEMENT(target_element) && !level.keep_walkable_ce)
10887 CreateElementFromChange(x, y, EL_EMPTY);
10889 CreateElementFromChange(x, y, target_element);
10891 PlayLevelSoundElementAction(x, y, element, ACTION_CHANGING);
10892 PlayLevelSoundElementAction(x, y, element, ACTION_PAGE_1 + page);
10895 // this uses direct change before indirect change
10896 CheckTriggeredElementChangeByPage(x, y, old_element, CE_CHANGE_OF_X, page);
10901 static void HandleElementChange(int x, int y, int page)
10903 int element = MovingOrBlocked2Element(x, y);
10904 struct ElementInfo *ei = &element_info[element];
10905 struct ElementChangeInfo *change = &ei->change_page[page];
10906 boolean handle_action_before_change = FALSE;
10909 if (!CAN_CHANGE_OR_HAS_ACTION(element) &&
10910 !CAN_CHANGE_OR_HAS_ACTION(Back[x][y]))
10912 Debug("game:playing:HandleElementChange", "%d,%d: element = %d ('%s')",
10913 x, y, element, element_info[element].token_name);
10914 Debug("game:playing:HandleElementChange", "This should never happen!");
10918 // this can happen with classic bombs on walkable, changing elements
10919 if (!CAN_CHANGE_OR_HAS_ACTION(element))
10924 if (ChangeDelay[x][y] == 0) // initialize element change
10926 ChangeDelay[x][y] = GET_CHANGE_DELAY(change) + 1;
10928 if (change->can_change)
10930 // !!! not clear why graphic animation should be reset at all here !!!
10931 // !!! UPDATE: but is needed for correct Snake Bite tail animation !!!
10932 // !!! SOLUTION: do not reset if graphics engine set to 4 or above !!!
10935 GRAPHICAL BUG ADDRESSED BY CHECKING GRAPHICS ENGINE VERSION:
10937 When using an animation frame delay of 1 (this only happens with
10938 "sp_zonk.moving.left/right" in the classic graphics), the default
10939 (non-moving) animation shows wrong animation frames (while the
10940 moving animation, like "sp_zonk.moving.left/right", is correct,
10941 so this graphical bug never shows up with the classic graphics).
10942 For an animation with 4 frames, this causes wrong frames 0,0,1,2
10943 be drawn instead of the correct frames 0,1,2,3. This is caused by
10944 "GfxFrame[][]" being reset *twice* (in two successive frames) after
10945 an element change: First when the change delay ("ChangeDelay[][]")
10946 counter has reached zero after decrementing, then a second time in
10947 the next frame (after "GfxFrame[][]" was already incremented) when
10948 "ChangeDelay[][]" is reset to the initial delay value again.
10950 This causes frame 0 to be drawn twice, while the last frame won't
10951 be drawn anymore, resulting in the wrong frame sequence 0,0,1,2.
10953 As some animations may already be cleverly designed around this bug
10954 (at least the "Snake Bite" snake tail animation does this), it cannot
10955 simply be fixed here without breaking such existing animations.
10956 Unfortunately, it cannot easily be detected if a graphics set was
10957 designed "before" or "after" the bug was fixed. As a workaround,
10958 a new graphics set option "game.graphics_engine_version" was added
10959 to be able to specify the game's major release version for which the
10960 graphics set was designed, which can then be used to decide if the
10961 bugfix should be used (version 4 and above) or not (version 3 or
10962 below, or if no version was specified at all, as with old sets).
10964 (The wrong/fixed animation frames can be tested with the test level set
10965 "test_gfxframe" and level "000", which contains a specially prepared
10966 custom element at level position (x/y) == (11/9) which uses the zonk
10967 animation mentioned above. Using "game.graphics_engine_version: 4"
10968 fixes the wrong animation frames, showing the correct frames 0,1,2,3.
10969 This can also be seen from the debug output for this test element.)
10972 // when a custom element is about to change (for example by change delay),
10973 // do not reset graphic animation when the custom element is moving
10974 if (game.graphics_engine_version < 4 &&
10977 ResetGfxAnimation(x, y);
10978 ResetRandomAnimationValue(x, y);
10981 if (change->pre_change_function)
10982 change->pre_change_function(x, y);
10986 ChangeDelay[x][y]--;
10988 if (ChangeDelay[x][y] != 0) // continue element change
10990 if (change->can_change)
10992 int graphic = el_act_dir2img(element, GfxAction[x][y], GfxDir[x][y]);
10994 if (IS_ANIMATED(graphic))
10995 DrawLevelGraphicAnimationIfNeeded(x, y, graphic);
10997 if (change->change_function)
10998 change->change_function(x, y);
11001 else // finish element change
11003 if (ChangePage[x][y] != -1) // remember page from delayed change
11005 page = ChangePage[x][y];
11006 ChangePage[x][y] = -1;
11008 change = &ei->change_page[page];
11011 if (IS_MOVING(x, y)) // never change a running system ;-)
11013 ChangeDelay[x][y] = 1; // try change after next move step
11014 ChangePage[x][y] = page; // remember page to use for change
11019 // special case: set new level random seed before changing element
11020 if (change->has_action && change->action_type == CA_SET_LEVEL_RANDOM_SEED)
11021 handle_action_before_change = TRUE;
11023 if (change->has_action && handle_action_before_change)
11024 ExecuteCustomElementAction(x, y, element, page);
11026 if (change->can_change)
11028 if (ChangeElement(x, y, element, page))
11030 if (change->post_change_function)
11031 change->post_change_function(x, y);
11035 if (change->has_action && !handle_action_before_change)
11036 ExecuteCustomElementAction(x, y, element, page);
11040 static boolean CheckTriggeredElementChangeExt(int trigger_x, int trigger_y,
11041 int trigger_element,
11043 int trigger_player,
11047 boolean change_done_any = FALSE;
11048 int trigger_page_bits = (trigger_page < 0 ? CH_PAGE_ANY : 1 << trigger_page);
11051 if (!(trigger_events[trigger_element][trigger_event]))
11054 RECURSION_LOOP_DETECTION_START(trigger_element, FALSE);
11056 for (i = 0; i < NUM_CUSTOM_ELEMENTS; i++)
11058 int element = EL_CUSTOM_START + i;
11059 boolean change_done = FALSE;
11062 if (!CAN_CHANGE_OR_HAS_ACTION(element) ||
11063 !HAS_ANY_CHANGE_EVENT(element, trigger_event))
11066 for (p = 0; p < element_info[element].num_change_pages; p++)
11068 struct ElementChangeInfo *change = &element_info[element].change_page[p];
11070 if (change->can_change_or_has_action &&
11071 change->has_event[trigger_event] &&
11072 change->trigger_side & trigger_side &&
11073 change->trigger_player & trigger_player &&
11074 change->trigger_page & trigger_page_bits &&
11075 IS_EQUAL_OR_IN_GROUP(trigger_element, change->trigger_element))
11077 change->actual_trigger_element = trigger_element;
11078 change->actual_trigger_player = GET_PLAYER_FROM_BITS(trigger_player);
11079 change->actual_trigger_player_bits = trigger_player;
11080 change->actual_trigger_side = trigger_side;
11081 change->actual_trigger_ce_value = CustomValue[trigger_x][trigger_y];
11082 change->actual_trigger_ce_score = GET_CE_SCORE(trigger_element);
11084 if ((change->can_change && !change_done) || change->has_action)
11088 SCAN_PLAYFIELD(x, y)
11090 if (Tile[x][y] == element)
11092 if (change->can_change && !change_done)
11094 // if element already changed in this frame, not only prevent
11095 // another element change (checked in ChangeElement()), but
11096 // also prevent additional element actions for this element
11098 if (ChangeCount[x][y] >= game.max_num_changes_per_frame &&
11099 !level.use_action_after_change_bug)
11102 ChangeDelay[x][y] = 1;
11103 ChangeEvent[x][y] = trigger_event;
11105 HandleElementChange(x, y, p);
11107 else if (change->has_action)
11109 // if element already changed in this frame, not only prevent
11110 // another element change (checked in ChangeElement()), but
11111 // also prevent additional element actions for this element
11113 if (ChangeCount[x][y] >= game.max_num_changes_per_frame &&
11114 !level.use_action_after_change_bug)
11117 ExecuteCustomElementAction(x, y, element, p);
11118 PlayLevelSoundElementAction(x, y, element, ACTION_PAGE_1 + p);
11123 if (change->can_change)
11125 change_done = TRUE;
11126 change_done_any = TRUE;
11133 RECURSION_LOOP_DETECTION_END();
11135 return change_done_any;
11138 static boolean CheckElementChangeExt(int x, int y,
11140 int trigger_element,
11142 int trigger_player,
11145 boolean change_done = FALSE;
11148 if (!CAN_CHANGE_OR_HAS_ACTION(element) ||
11149 !HAS_ANY_CHANGE_EVENT(element, trigger_event))
11152 if (Tile[x][y] == EL_BLOCKED)
11154 Blocked2Moving(x, y, &x, &y);
11155 element = Tile[x][y];
11158 // check if element has already changed or is about to change after moving
11159 if ((game.engine_version < VERSION_IDENT(3,2,0,7) &&
11160 Tile[x][y] != element) ||
11162 (game.engine_version >= VERSION_IDENT(3,2,0,7) &&
11163 (ChangeCount[x][y] >= game.max_num_changes_per_frame ||
11164 ChangePage[x][y] != -1)))
11167 RECURSION_LOOP_DETECTION_START(trigger_element, FALSE);
11169 for (p = 0; p < element_info[element].num_change_pages; p++)
11171 struct ElementChangeInfo *change = &element_info[element].change_page[p];
11173 /* check trigger element for all events where the element that is checked
11174 for changing interacts with a directly adjacent element -- this is
11175 different to element changes that affect other elements to change on the
11176 whole playfield (which is handeld by CheckTriggeredElementChangeExt()) */
11177 boolean check_trigger_element =
11178 (trigger_event == CE_NEXT_TO_X ||
11179 trigger_event == CE_TOUCHING_X ||
11180 trigger_event == CE_HITTING_X ||
11181 trigger_event == CE_HIT_BY_X ||
11182 trigger_event == CE_DIGGING_X); // this one was forgotten until 3.2.3
11184 if (change->can_change_or_has_action &&
11185 change->has_event[trigger_event] &&
11186 change->trigger_side & trigger_side &&
11187 change->trigger_player & trigger_player &&
11188 (!check_trigger_element ||
11189 IS_EQUAL_OR_IN_GROUP(trigger_element, change->trigger_element)))
11191 change->actual_trigger_element = trigger_element;
11192 change->actual_trigger_player = GET_PLAYER_FROM_BITS(trigger_player);
11193 change->actual_trigger_player_bits = trigger_player;
11194 change->actual_trigger_side = trigger_side;
11195 change->actual_trigger_ce_value = CustomValue[x][y];
11196 change->actual_trigger_ce_score = GET_CE_SCORE(trigger_element);
11198 // special case: trigger element not at (x,y) position for some events
11199 if (check_trigger_element)
11211 { 0, 0 }, { 0, 0 }, { 0, 0 },
11215 int xx = x + move_xy[MV_DIR_OPPOSITE(trigger_side)].dx;
11216 int yy = y + move_xy[MV_DIR_OPPOSITE(trigger_side)].dy;
11218 change->actual_trigger_ce_value = CustomValue[xx][yy];
11219 change->actual_trigger_ce_score = GET_CE_SCORE(trigger_element);
11222 if (change->can_change && !change_done)
11224 ChangeDelay[x][y] = 1;
11225 ChangeEvent[x][y] = trigger_event;
11227 HandleElementChange(x, y, p);
11229 change_done = TRUE;
11231 else if (change->has_action)
11233 ExecuteCustomElementAction(x, y, element, p);
11234 PlayLevelSoundElementAction(x, y, element, ACTION_PAGE_1 + p);
11239 RECURSION_LOOP_DETECTION_END();
11241 return change_done;
11244 static void PlayPlayerSound(struct PlayerInfo *player)
11246 int jx = player->jx, jy = player->jy;
11247 int sound_element = player->artwork_element;
11248 int last_action = player->last_action_waiting;
11249 int action = player->action_waiting;
11251 if (player->is_waiting)
11253 if (action != last_action)
11254 PlayLevelSoundElementAction(jx, jy, sound_element, action);
11256 PlayLevelSoundElementActionIfLoop(jx, jy, sound_element, action);
11260 if (action != last_action)
11261 StopSound(element_info[sound_element].sound[last_action]);
11263 if (last_action == ACTION_SLEEPING)
11264 PlayLevelSoundElementAction(jx, jy, sound_element, ACTION_AWAKENING);
11268 static void PlayAllPlayersSound(void)
11272 for (i = 0; i < MAX_PLAYERS; i++)
11273 if (stored_player[i].active)
11274 PlayPlayerSound(&stored_player[i]);
11277 static void SetPlayerWaiting(struct PlayerInfo *player, boolean is_waiting)
11279 boolean last_waiting = player->is_waiting;
11280 int move_dir = player->MovDir;
11282 player->dir_waiting = move_dir;
11283 player->last_action_waiting = player->action_waiting;
11287 if (!last_waiting) // not waiting -> waiting
11289 player->is_waiting = TRUE;
11291 player->frame_counter_bored =
11293 game.player_boring_delay_fixed +
11294 GetSimpleRandom(game.player_boring_delay_random);
11295 player->frame_counter_sleeping =
11297 game.player_sleeping_delay_fixed +
11298 GetSimpleRandom(game.player_sleeping_delay_random);
11300 InitPlayerGfxAnimation(player, ACTION_WAITING, move_dir);
11303 if (game.player_sleeping_delay_fixed +
11304 game.player_sleeping_delay_random > 0 &&
11305 player->anim_delay_counter == 0 &&
11306 player->post_delay_counter == 0 &&
11307 FrameCounter >= player->frame_counter_sleeping)
11308 player->is_sleeping = TRUE;
11309 else if (game.player_boring_delay_fixed +
11310 game.player_boring_delay_random > 0 &&
11311 FrameCounter >= player->frame_counter_bored)
11312 player->is_bored = TRUE;
11314 player->action_waiting = (player->is_sleeping ? ACTION_SLEEPING :
11315 player->is_bored ? ACTION_BORING :
11318 if (player->is_sleeping && player->use_murphy)
11320 // special case for sleeping Murphy when leaning against non-free tile
11322 if (!IN_LEV_FIELD(player->jx - 1, player->jy) ||
11323 (Tile[player->jx - 1][player->jy] != EL_EMPTY &&
11324 !IS_MOVING(player->jx - 1, player->jy)))
11325 move_dir = MV_LEFT;
11326 else if (!IN_LEV_FIELD(player->jx + 1, player->jy) ||
11327 (Tile[player->jx + 1][player->jy] != EL_EMPTY &&
11328 !IS_MOVING(player->jx + 1, player->jy)))
11329 move_dir = MV_RIGHT;
11331 player->is_sleeping = FALSE;
11333 player->dir_waiting = move_dir;
11336 if (player->is_sleeping)
11338 if (player->num_special_action_sleeping > 0)
11340 if (player->anim_delay_counter == 0 && player->post_delay_counter == 0)
11342 int last_special_action = player->special_action_sleeping;
11343 int num_special_action = player->num_special_action_sleeping;
11344 int special_action =
11345 (last_special_action == ACTION_DEFAULT ? ACTION_SLEEPING_1 :
11346 last_special_action == ACTION_SLEEPING ? ACTION_SLEEPING :
11347 last_special_action < ACTION_SLEEPING_1 + num_special_action - 1 ?
11348 last_special_action + 1 : ACTION_SLEEPING);
11349 int special_graphic =
11350 el_act_dir2img(player->artwork_element, special_action, move_dir);
11352 player->anim_delay_counter =
11353 graphic_info[special_graphic].anim_delay_fixed +
11354 GetSimpleRandom(graphic_info[special_graphic].anim_delay_random);
11355 player->post_delay_counter =
11356 graphic_info[special_graphic].post_delay_fixed +
11357 GetSimpleRandom(graphic_info[special_graphic].post_delay_random);
11359 player->special_action_sleeping = special_action;
11362 if (player->anim_delay_counter > 0)
11364 player->action_waiting = player->special_action_sleeping;
11365 player->anim_delay_counter--;
11367 else if (player->post_delay_counter > 0)
11369 player->post_delay_counter--;
11373 else if (player->is_bored)
11375 if (player->num_special_action_bored > 0)
11377 if (player->anim_delay_counter == 0 && player->post_delay_counter == 0)
11379 int special_action =
11380 ACTION_BORING_1 + GetSimpleRandom(player->num_special_action_bored);
11381 int special_graphic =
11382 el_act_dir2img(player->artwork_element, special_action, move_dir);
11384 player->anim_delay_counter =
11385 graphic_info[special_graphic].anim_delay_fixed +
11386 GetSimpleRandom(graphic_info[special_graphic].anim_delay_random);
11387 player->post_delay_counter =
11388 graphic_info[special_graphic].post_delay_fixed +
11389 GetSimpleRandom(graphic_info[special_graphic].post_delay_random);
11391 player->special_action_bored = special_action;
11394 if (player->anim_delay_counter > 0)
11396 player->action_waiting = player->special_action_bored;
11397 player->anim_delay_counter--;
11399 else if (player->post_delay_counter > 0)
11401 player->post_delay_counter--;
11406 else if (last_waiting) // waiting -> not waiting
11408 player->is_waiting = FALSE;
11409 player->is_bored = FALSE;
11410 player->is_sleeping = FALSE;
11412 player->frame_counter_bored = -1;
11413 player->frame_counter_sleeping = -1;
11415 player->anim_delay_counter = 0;
11416 player->post_delay_counter = 0;
11418 player->dir_waiting = player->MovDir;
11419 player->action_waiting = ACTION_DEFAULT;
11421 player->special_action_bored = ACTION_DEFAULT;
11422 player->special_action_sleeping = ACTION_DEFAULT;
11426 static void CheckSaveEngineSnapshot(struct PlayerInfo *player)
11428 if ((!player->is_moving && player->was_moving) ||
11429 (player->MovPos == 0 && player->was_moving) ||
11430 (player->is_snapping && !player->was_snapping) ||
11431 (player->is_dropping && !player->was_dropping))
11433 if (!CheckSaveEngineSnapshotToList())
11436 player->was_moving = FALSE;
11437 player->was_snapping = TRUE;
11438 player->was_dropping = TRUE;
11442 if (player->is_moving)
11443 player->was_moving = TRUE;
11445 if (!player->is_snapping)
11446 player->was_snapping = FALSE;
11448 if (!player->is_dropping)
11449 player->was_dropping = FALSE;
11452 static struct MouseActionInfo mouse_action_last = { 0 };
11453 struct MouseActionInfo mouse_action = player->effective_mouse_action;
11454 boolean new_released = (!mouse_action.button && mouse_action_last.button);
11457 CheckSaveEngineSnapshotToList();
11459 mouse_action_last = mouse_action;
11462 static void CheckSingleStepMode(struct PlayerInfo *player)
11464 if (tape.single_step && tape.recording && !tape.pausing)
11466 // as it is called "single step mode", just return to pause mode when the
11467 // player stopped moving after one tile (or never starts moving at all)
11468 // (reverse logic needed here in case single step mode used in team mode)
11469 if (player->is_moving ||
11470 player->is_pushing ||
11471 player->is_dropping_pressed ||
11472 player->effective_mouse_action.button)
11473 game.enter_single_step_mode = FALSE;
11476 CheckSaveEngineSnapshot(player);
11479 static byte PlayerActions(struct PlayerInfo *player, byte player_action)
11481 int left = player_action & JOY_LEFT;
11482 int right = player_action & JOY_RIGHT;
11483 int up = player_action & JOY_UP;
11484 int down = player_action & JOY_DOWN;
11485 int button1 = player_action & JOY_BUTTON_1;
11486 int button2 = player_action & JOY_BUTTON_2;
11487 int dx = (left ? -1 : right ? 1 : 0);
11488 int dy = (up ? -1 : down ? 1 : 0);
11490 if (!player->active || tape.pausing)
11496 SnapField(player, dx, dy);
11500 DropElement(player);
11502 MovePlayer(player, dx, dy);
11505 CheckSingleStepMode(player);
11507 SetPlayerWaiting(player, FALSE);
11509 return player_action;
11513 // no actions for this player (no input at player's configured device)
11515 DigField(player, 0, 0, 0, 0, 0, 0, DF_NO_PUSH);
11516 SnapField(player, 0, 0);
11517 CheckGravityMovementWhenNotMoving(player);
11519 if (player->MovPos == 0)
11520 SetPlayerWaiting(player, TRUE);
11522 if (player->MovPos == 0) // needed for tape.playing
11523 player->is_moving = FALSE;
11525 player->is_dropping = FALSE;
11526 player->is_dropping_pressed = FALSE;
11527 player->drop_pressed_delay = 0;
11529 CheckSingleStepMode(player);
11535 static void SetMouseActionFromTapeAction(struct MouseActionInfo *mouse_action,
11538 if (!tape.use_mouse_actions)
11541 mouse_action->lx = tape_action[TAPE_ACTION_LX];
11542 mouse_action->ly = tape_action[TAPE_ACTION_LY];
11543 mouse_action->button = tape_action[TAPE_ACTION_BUTTON];
11546 static void SetTapeActionFromMouseAction(byte *tape_action,
11547 struct MouseActionInfo *mouse_action)
11549 if (!tape.use_mouse_actions)
11552 tape_action[TAPE_ACTION_LX] = mouse_action->lx;
11553 tape_action[TAPE_ACTION_LY] = mouse_action->ly;
11554 tape_action[TAPE_ACTION_BUTTON] = mouse_action->button;
11557 static void CheckLevelSolved(void)
11559 if (level.game_engine_type == GAME_ENGINE_TYPE_EM)
11561 if (game_em.level_solved &&
11562 !game_em.game_over) // game won
11566 game_em.game_over = TRUE;
11568 game.all_players_gone = TRUE;
11571 if (game_em.game_over) // game lost
11572 game.all_players_gone = TRUE;
11574 else if (level.game_engine_type == GAME_ENGINE_TYPE_SP)
11576 if (game_sp.level_solved &&
11577 !game_sp.game_over) // game won
11581 game_sp.game_over = TRUE;
11583 game.all_players_gone = TRUE;
11586 if (game_sp.game_over) // game lost
11587 game.all_players_gone = TRUE;
11589 else if (level.game_engine_type == GAME_ENGINE_TYPE_MM)
11591 if (game_mm.level_solved &&
11592 !game_mm.game_over) // game won
11596 game_mm.game_over = TRUE;
11598 game.all_players_gone = TRUE;
11601 if (game_mm.game_over) // game lost
11602 game.all_players_gone = TRUE;
11606 static void CheckLevelTime_StepCounter(void)
11616 if (TimeLeft <= 10 && setup.time_limit && !game.LevelSolved)
11617 PlaySound(SND_GAME_RUNNING_OUT_OF_TIME);
11619 game_panel_controls[GAME_PANEL_TIME].value = TimeLeft;
11621 DisplayGameControlValues();
11623 if (!TimeLeft && setup.time_limit && !game.LevelSolved)
11624 for (i = 0; i < MAX_PLAYERS; i++)
11625 KillPlayer(&stored_player[i]);
11627 else if (game.no_time_limit && !game.all_players_gone)
11629 game_panel_controls[GAME_PANEL_TIME].value = TimePlayed;
11631 DisplayGameControlValues();
11635 static void CheckLevelTime(void)
11639 if (TimeFrames >= FRAMES_PER_SECOND)
11644 for (i = 0; i < MAX_PLAYERS; i++)
11646 struct PlayerInfo *player = &stored_player[i];
11648 if (SHIELD_ON(player))
11650 player->shield_normal_time_left--;
11652 if (player->shield_deadly_time_left > 0)
11653 player->shield_deadly_time_left--;
11657 if (!game.LevelSolved && !level.use_step_counter)
11665 if (TimeLeft <= 10 && setup.time_limit)
11666 PlaySound(SND_GAME_RUNNING_OUT_OF_TIME);
11668 /* this does not make sense: game_panel_controls[GAME_PANEL_TIME].value
11669 is reset from other values in UpdateGameDoorValues() -- FIX THIS */
11671 game_panel_controls[GAME_PANEL_TIME].value = TimeLeft;
11673 if (!TimeLeft && setup.time_limit)
11675 if (level.game_engine_type == GAME_ENGINE_TYPE_EM)
11676 game_em.lev->killed_out_of_time = TRUE;
11678 for (i = 0; i < MAX_PLAYERS; i++)
11679 KillPlayer(&stored_player[i]);
11682 else if (game.no_time_limit && !game.all_players_gone)
11684 game_panel_controls[GAME_PANEL_TIME].value = TimePlayed;
11687 game_em.lev->time = (game.no_time_limit ? TimePlayed : TimeLeft);
11690 if (tape.recording || tape.playing)
11691 DrawVideoDisplay(VIDEO_STATE_TIME_ON, TapeTime);
11694 if (tape.recording || tape.playing)
11695 DrawVideoDisplay(VIDEO_STATE_FRAME_ON, FrameCounter);
11697 UpdateAndDisplayGameControlValues();
11700 void AdvanceFrameAndPlayerCounters(int player_nr)
11704 // advance frame counters (global frame counter and time frame counter)
11708 // advance player counters (counters for move delay, move animation etc.)
11709 for (i = 0; i < MAX_PLAYERS; i++)
11711 boolean advance_player_counters = (player_nr == -1 || player_nr == i);
11712 int move_delay_value = stored_player[i].move_delay_value;
11713 int move_frames = MOVE_DELAY_NORMAL_SPEED / move_delay_value;
11715 if (!advance_player_counters) // not all players may be affected
11718 if (move_frames == 0) // less than one move per game frame
11720 int stepsize = TILEX / move_delay_value;
11721 int delay = move_delay_value / MOVE_DELAY_NORMAL_SPEED;
11722 int count = (stored_player[i].is_moving ?
11723 ABS(stored_player[i].MovPos) / stepsize : FrameCounter);
11725 if (count % delay == 0)
11729 stored_player[i].Frame += move_frames;
11731 if (stored_player[i].MovPos != 0)
11732 stored_player[i].StepFrame += move_frames;
11734 if (stored_player[i].move_delay > 0)
11735 stored_player[i].move_delay--;
11737 // due to bugs in previous versions, counter must count up, not down
11738 if (stored_player[i].push_delay != -1)
11739 stored_player[i].push_delay++;
11741 if (stored_player[i].drop_delay > 0)
11742 stored_player[i].drop_delay--;
11744 if (stored_player[i].is_dropping_pressed)
11745 stored_player[i].drop_pressed_delay++;
11749 void StartGameActions(boolean init_network_game, boolean record_tape,
11752 unsigned int new_random_seed = InitRND(random_seed);
11755 TapeStartRecording(new_random_seed);
11757 if (init_network_game)
11759 SendToServer_LevelFile();
11760 SendToServer_StartPlaying();
11768 static void GameActionsExt(void)
11771 static unsigned int game_frame_delay = 0;
11773 unsigned int game_frame_delay_value;
11774 byte *recorded_player_action;
11775 byte summarized_player_action = 0;
11776 byte tape_action[MAX_TAPE_ACTIONS] = { 0 };
11779 // detect endless loops, caused by custom element programming
11780 if (recursion_loop_detected && recursion_loop_depth == 0)
11782 char *message = getStringCat3("Internal Error! Element ",
11783 EL_NAME(recursion_loop_element),
11784 " caused endless loop! Quit the game?");
11786 Warn("element '%s' caused endless loop in game engine",
11787 EL_NAME(recursion_loop_element));
11789 RequestQuitGameExt(program.headless, level_editor_test_game, message);
11791 recursion_loop_detected = FALSE; // if game should be continued
11798 if (game.restart_level)
11799 StartGameActions(network.enabled, setup.autorecord, level.random_seed);
11801 CheckLevelSolved();
11803 if (game.LevelSolved && !game.LevelSolved_GameEnd)
11806 if (game.all_players_gone && !TAPE_IS_STOPPED(tape))
11809 if (game_status != GAME_MODE_PLAYING) // status might have changed
11812 game_frame_delay_value =
11813 (tape.playing && tape.fast_forward ? FfwdFrameDelay : GameFrameDelay);
11815 if (tape.playing && tape.warp_forward && !tape.pausing)
11816 game_frame_delay_value = 0;
11818 SetVideoFrameDelay(game_frame_delay_value);
11820 // (de)activate virtual buttons depending on current game status
11821 if (strEqual(setup.touch.control_type, TOUCH_CONTROL_VIRTUAL_BUTTONS))
11823 if (game.all_players_gone) // if no players there to be controlled anymore
11824 SetOverlayActive(FALSE);
11825 else if (!tape.playing) // if game continues after tape stopped playing
11826 SetOverlayActive(TRUE);
11831 // ---------- main game synchronization point ----------
11833 int skip = WaitUntilDelayReached(&game_frame_delay, game_frame_delay_value);
11835 Debug("game:playing:skip", "skip == %d", skip);
11838 // ---------- main game synchronization point ----------
11840 WaitUntilDelayReached(&game_frame_delay, game_frame_delay_value);
11844 if (network_playing && !network_player_action_received)
11846 // try to get network player actions in time
11848 // last chance to get network player actions without main loop delay
11849 HandleNetworking();
11851 // game was quit by network peer
11852 if (game_status != GAME_MODE_PLAYING)
11855 // check if network player actions still missing and game still running
11856 if (!network_player_action_received && !checkGameEnded())
11857 return; // failed to get network player actions in time
11859 // do not yet reset "network_player_action_received" (for tape.pausing)
11865 // at this point we know that we really continue executing the game
11867 network_player_action_received = FALSE;
11869 // when playing tape, read previously recorded player input from tape data
11870 recorded_player_action = (tape.playing ? TapePlayAction() : NULL);
11872 local_player->effective_mouse_action = local_player->mouse_action;
11874 if (recorded_player_action != NULL)
11875 SetMouseActionFromTapeAction(&local_player->effective_mouse_action,
11876 recorded_player_action);
11878 // TapePlayAction() may return NULL when toggling to "pause before death"
11882 if (tape.set_centered_player)
11884 game.centered_player_nr_next = tape.centered_player_nr_next;
11885 game.set_centered_player = TRUE;
11888 for (i = 0; i < MAX_PLAYERS; i++)
11890 summarized_player_action |= stored_player[i].action;
11892 if (!network_playing && (game.team_mode || tape.playing))
11893 stored_player[i].effective_action = stored_player[i].action;
11896 if (network_playing && !checkGameEnded())
11897 SendToServer_MovePlayer(summarized_player_action);
11899 // summarize all actions at local players mapped input device position
11900 // (this allows using different input devices in single player mode)
11901 if (!network.enabled && !game.team_mode)
11902 stored_player[map_player_action[local_player->index_nr]].effective_action =
11903 summarized_player_action;
11905 // summarize all actions at centered player in local team mode
11906 if (tape.recording &&
11907 setup.team_mode && !network.enabled &&
11908 setup.input_on_focus &&
11909 game.centered_player_nr != -1)
11911 for (i = 0; i < MAX_PLAYERS; i++)
11912 stored_player[map_player_action[i]].effective_action =
11913 (i == game.centered_player_nr ? summarized_player_action : 0);
11916 if (recorded_player_action != NULL)
11917 for (i = 0; i < MAX_PLAYERS; i++)
11918 stored_player[i].effective_action = recorded_player_action[i];
11920 for (i = 0; i < MAX_PLAYERS; i++)
11922 tape_action[i] = stored_player[i].effective_action;
11924 /* (this may happen in the RND game engine if a player was not present on
11925 the playfield on level start, but appeared later from a custom element */
11926 if (setup.team_mode &&
11929 !tape.player_participates[i])
11930 tape.player_participates[i] = TRUE;
11933 SetTapeActionFromMouseAction(tape_action,
11934 &local_player->effective_mouse_action);
11936 // only record actions from input devices, but not programmed actions
11937 if (tape.recording)
11938 TapeRecordAction(tape_action);
11940 // remember if game was played (especially after tape stopped playing)
11941 if (!tape.playing && summarized_player_action)
11942 game.GamePlayed = TRUE;
11944 #if USE_NEW_PLAYER_ASSIGNMENTS
11945 // !!! also map player actions in single player mode !!!
11946 // if (game.team_mode)
11949 byte mapped_action[MAX_PLAYERS];
11951 #if DEBUG_PLAYER_ACTIONS
11952 for (i = 0; i < MAX_PLAYERS; i++)
11953 DebugContinued("", "%d, ", stored_player[i].effective_action);
11956 for (i = 0; i < MAX_PLAYERS; i++)
11957 mapped_action[i] = stored_player[map_player_action[i]].effective_action;
11959 for (i = 0; i < MAX_PLAYERS; i++)
11960 stored_player[i].effective_action = mapped_action[i];
11962 #if DEBUG_PLAYER_ACTIONS
11963 DebugContinued("", "=> ");
11964 for (i = 0; i < MAX_PLAYERS; i++)
11965 DebugContinued("", "%d, ", stored_player[i].effective_action);
11966 DebugContinued("game:playing:player", "\n");
11969 #if DEBUG_PLAYER_ACTIONS
11972 for (i = 0; i < MAX_PLAYERS; i++)
11973 DebugContinued("", "%d, ", stored_player[i].effective_action);
11974 DebugContinued("game:playing:player", "\n");
11979 for (i = 0; i < MAX_PLAYERS; i++)
11981 // allow engine snapshot in case of changed movement attempt
11982 if ((game.snapshot.last_action[i] & KEY_MOTION) !=
11983 (stored_player[i].effective_action & KEY_MOTION))
11984 game.snapshot.changed_action = TRUE;
11986 // allow engine snapshot in case of snapping/dropping attempt
11987 if ((game.snapshot.last_action[i] & KEY_BUTTON) == 0 &&
11988 (stored_player[i].effective_action & KEY_BUTTON) != 0)
11989 game.snapshot.changed_action = TRUE;
11991 game.snapshot.last_action[i] = stored_player[i].effective_action;
11994 if (level.game_engine_type == GAME_ENGINE_TYPE_EM)
11996 GameActions_EM_Main();
11998 else if (level.game_engine_type == GAME_ENGINE_TYPE_SP)
12000 GameActions_SP_Main();
12002 else if (level.game_engine_type == GAME_ENGINE_TYPE_MM)
12004 GameActions_MM_Main();
12008 GameActions_RND_Main();
12011 BlitScreenToBitmap(backbuffer);
12013 CheckLevelSolved();
12016 AdvanceFrameAndPlayerCounters(-1); // advance counters for all players
12018 if (global.show_frames_per_second)
12020 static unsigned int fps_counter = 0;
12021 static int fps_frames = 0;
12022 unsigned int fps_delay_ms = Counter() - fps_counter;
12026 if (fps_delay_ms >= 500) // calculate FPS every 0.5 seconds
12028 global.frames_per_second = 1000 * (float)fps_frames / fps_delay_ms;
12031 fps_counter = Counter();
12033 // always draw FPS to screen after FPS value was updated
12034 redraw_mask |= REDRAW_FPS;
12037 // only draw FPS if no screen areas are deactivated (invisible warp mode)
12038 if (GetDrawDeactivationMask() == REDRAW_NONE)
12039 redraw_mask |= REDRAW_FPS;
12043 static void GameActions_CheckSaveEngineSnapshot(void)
12045 if (!game.snapshot.save_snapshot)
12048 // clear flag for saving snapshot _before_ saving snapshot
12049 game.snapshot.save_snapshot = FALSE;
12051 SaveEngineSnapshotToList();
12054 void GameActions(void)
12058 GameActions_CheckSaveEngineSnapshot();
12061 void GameActions_EM_Main(void)
12063 byte effective_action[MAX_PLAYERS];
12064 boolean warp_mode = (tape.playing && tape.warp_forward && !tape.pausing);
12067 for (i = 0; i < MAX_PLAYERS; i++)
12068 effective_action[i] = stored_player[i].effective_action;
12070 GameActions_EM(effective_action, warp_mode);
12073 void GameActions_SP_Main(void)
12075 byte effective_action[MAX_PLAYERS];
12076 boolean warp_mode = (tape.playing && tape.warp_forward && !tape.pausing);
12079 for (i = 0; i < MAX_PLAYERS; i++)
12080 effective_action[i] = stored_player[i].effective_action;
12082 GameActions_SP(effective_action, warp_mode);
12084 for (i = 0; i < MAX_PLAYERS; i++)
12086 if (stored_player[i].force_dropping)
12087 stored_player[i].action |= KEY_BUTTON_DROP;
12089 stored_player[i].force_dropping = FALSE;
12093 void GameActions_MM_Main(void)
12095 boolean warp_mode = (tape.playing && tape.warp_forward && !tape.pausing);
12097 GameActions_MM(local_player->effective_mouse_action, warp_mode);
12100 void GameActions_RND_Main(void)
12105 void GameActions_RND(void)
12107 static struct MouseActionInfo mouse_action_last = { 0 };
12108 struct MouseActionInfo mouse_action = local_player->effective_mouse_action;
12109 int magic_wall_x = 0, magic_wall_y = 0;
12110 int i, x, y, element, graphic, last_gfx_frame;
12112 InitPlayfieldScanModeVars();
12114 if (game.engine_version >= VERSION_IDENT(3,2,0,7))
12116 SCAN_PLAYFIELD(x, y)
12118 ChangeCount[x][y] = 0;
12119 ChangeEvent[x][y] = -1;
12123 if (game.set_centered_player)
12125 boolean all_players_fit_to_screen = checkIfAllPlayersFitToScreen_RND();
12127 // switching to "all players" only possible if all players fit to screen
12128 if (game.centered_player_nr_next == -1 && !all_players_fit_to_screen)
12130 game.centered_player_nr_next = game.centered_player_nr;
12131 game.set_centered_player = FALSE;
12134 // do not switch focus to non-existing (or non-active) player
12135 if (game.centered_player_nr_next >= 0 &&
12136 !stored_player[game.centered_player_nr_next].active)
12138 game.centered_player_nr_next = game.centered_player_nr;
12139 game.set_centered_player = FALSE;
12143 if (game.set_centered_player &&
12144 ScreenMovPos == 0) // screen currently aligned at tile position
12148 if (game.centered_player_nr_next == -1)
12150 setScreenCenteredToAllPlayers(&sx, &sy);
12154 sx = stored_player[game.centered_player_nr_next].jx;
12155 sy = stored_player[game.centered_player_nr_next].jy;
12158 game.centered_player_nr = game.centered_player_nr_next;
12159 game.set_centered_player = FALSE;
12161 DrawRelocateScreen(0, 0, sx, sy, MV_NONE, TRUE, setup.quick_switch);
12162 DrawGameDoorValues();
12165 // check single step mode (set flag and clear again if any player is active)
12166 game.enter_single_step_mode =
12167 (tape.single_step && tape.recording && !tape.pausing);
12169 for (i = 0; i < MAX_PLAYERS; i++)
12171 int actual_player_action = stored_player[i].effective_action;
12174 /* !!! THIS BREAKS THE FOLLOWING TAPES: !!!
12175 - rnd_equinox_tetrachloride 048
12176 - rnd_equinox_tetrachloride_ii 096
12177 - rnd_emanuel_schmieg 002
12178 - doctor_sloan_ww 001, 020
12180 if (stored_player[i].MovPos == 0)
12181 CheckGravityMovement(&stored_player[i]);
12184 // overwrite programmed action with tape action
12185 if (stored_player[i].programmed_action)
12186 actual_player_action = stored_player[i].programmed_action;
12188 PlayerActions(&stored_player[i], actual_player_action);
12190 ScrollPlayer(&stored_player[i], SCROLL_GO_ON);
12193 // single step pause mode may already have been toggled by "ScrollPlayer()"
12194 if (game.enter_single_step_mode && !tape.pausing)
12195 TapeTogglePause(TAPE_TOGGLE_AUTOMATIC);
12197 ScrollScreen(NULL, SCROLL_GO_ON);
12199 /* for backwards compatibility, the following code emulates a fixed bug that
12200 occured when pushing elements (causing elements that just made their last
12201 pushing step to already (if possible) make their first falling step in the
12202 same game frame, which is bad); this code is also needed to use the famous
12203 "spring push bug" which is used in older levels and might be wanted to be
12204 used also in newer levels, but in this case the buggy pushing code is only
12205 affecting the "spring" element and no other elements */
12207 if (game.engine_version < VERSION_IDENT(2,2,0,7) || level.use_spring_bug)
12209 for (i = 0; i < MAX_PLAYERS; i++)
12211 struct PlayerInfo *player = &stored_player[i];
12212 int x = player->jx;
12213 int y = player->jy;
12215 if (player->active && player->is_pushing && player->is_moving &&
12217 (game.engine_version < VERSION_IDENT(2,2,0,7) ||
12218 Tile[x][y] == EL_SPRING))
12220 ContinueMoving(x, y);
12222 // continue moving after pushing (this is actually a bug)
12223 if (!IS_MOVING(x, y))
12224 Stop[x][y] = FALSE;
12229 SCAN_PLAYFIELD(x, y)
12231 Last[x][y] = Tile[x][y];
12233 ChangeCount[x][y] = 0;
12234 ChangeEvent[x][y] = -1;
12236 // this must be handled before main playfield loop
12237 if (Tile[x][y] == EL_PLAYER_IS_LEAVING)
12240 if (MovDelay[x][y] <= 0)
12244 if (Tile[x][y] == EL_ELEMENT_SNAPPING)
12247 if (MovDelay[x][y] <= 0)
12249 int element = Store[x][y];
12250 int move_direction = MovDir[x][y];
12251 int player_index_bit = Store2[x][y];
12257 TEST_DrawLevelField(x, y);
12259 TestFieldAfterSnapping(x, y, element, move_direction, player_index_bit);
12261 if (IS_ENVELOPE(element))
12262 local_player->show_envelope = element;
12267 if (ChangePage[x][y] != -1 && ChangeDelay[x][y] != 1)
12269 Debug("game:playing:GameActions_RND", "x = %d, y = %d: ChangePage != -1",
12271 Debug("game:playing:GameActions_RND", "This should never happen!");
12273 ChangePage[x][y] = -1;
12277 Stop[x][y] = FALSE;
12278 if (WasJustMoving[x][y] > 0)
12279 WasJustMoving[x][y]--;
12280 if (WasJustFalling[x][y] > 0)
12281 WasJustFalling[x][y]--;
12282 if (CheckCollision[x][y] > 0)
12283 CheckCollision[x][y]--;
12284 if (CheckImpact[x][y] > 0)
12285 CheckImpact[x][y]--;
12289 /* reset finished pushing action (not done in ContinueMoving() to allow
12290 continuous pushing animation for elements with zero push delay) */
12291 if (GfxAction[x][y] == ACTION_PUSHING && !IS_MOVING(x, y))
12293 ResetGfxAnimation(x, y);
12294 TEST_DrawLevelField(x, y);
12298 if (IS_BLOCKED(x, y))
12302 Blocked2Moving(x, y, &oldx, &oldy);
12303 if (!IS_MOVING(oldx, oldy))
12305 Debug("game:playing:GameActions_RND", "(BLOCKED => MOVING) context corrupted!");
12306 Debug("game:playing:GameActions_RND", "BLOCKED: x = %d, y = %d", x, y);
12307 Debug("game:playing:GameActions_RND", "!MOVING: oldx = %d, oldy = %d", oldx, oldy);
12308 Debug("game:playing:GameActions_RND", "This should never happen!");
12314 if (mouse_action.button)
12316 int new_button = (mouse_action.button && mouse_action_last.button == 0);
12317 int ch_button = CH_SIDE_FROM_BUTTON(mouse_action.button);
12319 x = mouse_action.lx;
12320 y = mouse_action.ly;
12321 element = Tile[x][y];
12325 CheckElementChangeByMouse(x, y, element, CE_CLICKED_BY_MOUSE, ch_button);
12326 CheckTriggeredElementChangeByMouse(x, y, element, CE_MOUSE_CLICKED_ON_X,
12330 CheckElementChangeByMouse(x, y, element, CE_PRESSED_BY_MOUSE, ch_button);
12331 CheckTriggeredElementChangeByMouse(x, y, element, CE_MOUSE_PRESSED_ON_X,
12334 if (level.use_step_counter)
12336 boolean counted_click = FALSE;
12338 // element clicked that can change when clicked/pressed
12339 if (CAN_CHANGE_OR_HAS_ACTION(element) &&
12340 (HAS_ANY_CHANGE_EVENT(element, CE_CLICKED_BY_MOUSE) ||
12341 HAS_ANY_CHANGE_EVENT(element, CE_PRESSED_BY_MOUSE)))
12342 counted_click = TRUE;
12344 // element clicked that can trigger change when clicked/pressed
12345 if (trigger_events[element][CE_MOUSE_CLICKED_ON_X] ||
12346 trigger_events[element][CE_MOUSE_PRESSED_ON_X])
12347 counted_click = TRUE;
12349 if (new_button && counted_click)
12350 CheckLevelTime_StepCounter();
12354 SCAN_PLAYFIELD(x, y)
12356 element = Tile[x][y];
12357 graphic = el_act_dir2img(element, GfxAction[x][y], GfxDir[x][y]);
12358 last_gfx_frame = GfxFrame[x][y];
12360 if (element == EL_EMPTY)
12361 graphic = el2img(GfxElementEmpty[x][y]);
12363 ResetGfxFrame(x, y);
12365 if (GfxFrame[x][y] != last_gfx_frame && !Stop[x][y])
12366 DrawLevelGraphicAnimation(x, y, graphic);
12368 if (ANIM_MODE(graphic) == ANIM_RANDOM &&
12369 IS_NEXT_FRAME(GfxFrame[x][y], graphic))
12370 ResetRandomAnimationValue(x, y);
12372 SetRandomAnimationValue(x, y);
12374 PlayLevelSoundActionIfLoop(x, y, GfxAction[x][y]);
12376 if (IS_INACTIVE(element))
12378 if (IS_ANIMATED(graphic))
12379 DrawLevelGraphicAnimationIfNeeded(x, y, graphic);
12384 // this may take place after moving, so 'element' may have changed
12385 if (IS_CHANGING(x, y) &&
12386 (game.engine_version < VERSION_IDENT(3,0,7,1) || !Stop[x][y]))
12388 int page = element_info[element].event_page_nr[CE_DELAY];
12390 HandleElementChange(x, y, page);
12392 element = Tile[x][y];
12393 graphic = el_act_dir2img(element, GfxAction[x][y], GfxDir[x][y]);
12396 CheckNextToConditions(x, y);
12398 if (!IS_MOVING(x, y) && (CAN_FALL(element) || CAN_MOVE(element)))
12402 element = Tile[x][y];
12403 graphic = el_act_dir2img(element, GfxAction[x][y], GfxDir[x][y]);
12405 if (IS_ANIMATED(graphic) &&
12406 !IS_MOVING(x, y) &&
12408 DrawLevelGraphicAnimationIfNeeded(x, y, graphic);
12410 if (IS_GEM(element) || element == EL_SP_INFOTRON)
12411 TEST_DrawTwinkleOnField(x, y);
12413 else if (element == EL_ACID)
12416 DrawLevelGraphicAnimationIfNeeded(x, y, graphic);
12418 else if ((element == EL_EXIT_OPEN ||
12419 element == EL_EM_EXIT_OPEN ||
12420 element == EL_SP_EXIT_OPEN ||
12421 element == EL_STEEL_EXIT_OPEN ||
12422 element == EL_EM_STEEL_EXIT_OPEN ||
12423 element == EL_SP_TERMINAL ||
12424 element == EL_SP_TERMINAL_ACTIVE ||
12425 element == EL_EXTRA_TIME ||
12426 element == EL_SHIELD_NORMAL ||
12427 element == EL_SHIELD_DEADLY) &&
12428 IS_ANIMATED(graphic))
12429 DrawLevelGraphicAnimationIfNeeded(x, y, graphic);
12430 else if (IS_MOVING(x, y))
12431 ContinueMoving(x, y);
12432 else if (IS_ACTIVE_BOMB(element))
12433 CheckDynamite(x, y);
12434 else if (element == EL_AMOEBA_GROWING)
12435 AmoebaGrowing(x, y);
12436 else if (element == EL_AMOEBA_SHRINKING)
12437 AmoebaShrinking(x, y);
12439 #if !USE_NEW_AMOEBA_CODE
12440 else if (IS_AMOEBALIVE(element))
12441 AmoebaReproduce(x, y);
12444 else if (element == EL_GAME_OF_LIFE || element == EL_BIOMAZE)
12446 else if (element == EL_EXIT_CLOSED)
12448 else if (element == EL_EM_EXIT_CLOSED)
12450 else if (element == EL_STEEL_EXIT_CLOSED)
12451 CheckExitSteel(x, y);
12452 else if (element == EL_EM_STEEL_EXIT_CLOSED)
12453 CheckExitSteelEM(x, y);
12454 else if (element == EL_SP_EXIT_CLOSED)
12456 else if (element == EL_EXPANDABLE_WALL_GROWING ||
12457 element == EL_EXPANDABLE_STEELWALL_GROWING)
12458 MauerWaechst(x, y);
12459 else if (element == EL_EXPANDABLE_WALL ||
12460 element == EL_EXPANDABLE_WALL_HORIZONTAL ||
12461 element == EL_EXPANDABLE_WALL_VERTICAL ||
12462 element == EL_EXPANDABLE_WALL_ANY ||
12463 element == EL_BD_EXPANDABLE_WALL)
12464 MauerAbleger(x, y);
12465 else if (element == EL_EXPANDABLE_STEELWALL_HORIZONTAL ||
12466 element == EL_EXPANDABLE_STEELWALL_VERTICAL ||
12467 element == EL_EXPANDABLE_STEELWALL_ANY)
12468 MauerAblegerStahl(x, y);
12469 else if (element == EL_FLAMES)
12470 CheckForDragon(x, y);
12471 else if (element == EL_EXPLOSION)
12472 ; // drawing of correct explosion animation is handled separately
12473 else if (element == EL_ELEMENT_SNAPPING ||
12474 element == EL_DIAGONAL_SHRINKING ||
12475 element == EL_DIAGONAL_GROWING)
12477 graphic = el_act_dir2img(GfxElement[x][y], GfxAction[x][y],GfxDir[x][y]);
12479 DrawLevelGraphicAnimationIfNeeded(x, y, graphic);
12481 else if (IS_ANIMATED(graphic) && !IS_CHANGING(x, y))
12482 DrawLevelGraphicAnimationIfNeeded(x, y, graphic);
12484 if (IS_BELT_ACTIVE(element))
12485 PlayLevelSoundAction(x, y, ACTION_ACTIVE);
12487 if (game.magic_wall_active)
12489 int jx = local_player->jx, jy = local_player->jy;
12491 // play the element sound at the position nearest to the player
12492 if ((element == EL_MAGIC_WALL_FULL ||
12493 element == EL_MAGIC_WALL_ACTIVE ||
12494 element == EL_MAGIC_WALL_EMPTYING ||
12495 element == EL_BD_MAGIC_WALL_FULL ||
12496 element == EL_BD_MAGIC_WALL_ACTIVE ||
12497 element == EL_BD_MAGIC_WALL_EMPTYING ||
12498 element == EL_DC_MAGIC_WALL_FULL ||
12499 element == EL_DC_MAGIC_WALL_ACTIVE ||
12500 element == EL_DC_MAGIC_WALL_EMPTYING) &&
12501 ABS(x - jx) + ABS(y - jy) <
12502 ABS(magic_wall_x - jx) + ABS(magic_wall_y - jy))
12510 #if USE_NEW_AMOEBA_CODE
12511 // new experimental amoeba growth stuff
12512 if (!(FrameCounter % 8))
12514 static unsigned int random = 1684108901;
12516 for (i = 0; i < level.amoeba_speed * 28 / 8; i++)
12518 x = RND(lev_fieldx);
12519 y = RND(lev_fieldy);
12520 element = Tile[x][y];
12522 if (!IS_PLAYER(x,y) &&
12523 (element == EL_EMPTY ||
12524 CAN_GROW_INTO(element) ||
12525 element == EL_QUICKSAND_EMPTY ||
12526 element == EL_QUICKSAND_FAST_EMPTY ||
12527 element == EL_ACID_SPLASH_LEFT ||
12528 element == EL_ACID_SPLASH_RIGHT))
12530 if ((IN_LEV_FIELD(x, y-1) && Tile[x][y-1] == EL_AMOEBA_WET) ||
12531 (IN_LEV_FIELD(x-1, y) && Tile[x-1][y] == EL_AMOEBA_WET) ||
12532 (IN_LEV_FIELD(x+1, y) && Tile[x+1][y] == EL_AMOEBA_WET) ||
12533 (IN_LEV_FIELD(x, y+1) && Tile[x][y+1] == EL_AMOEBA_WET))
12534 Tile[x][y] = EL_AMOEBA_DROP;
12537 random = random * 129 + 1;
12542 game.explosions_delayed = FALSE;
12544 SCAN_PLAYFIELD(x, y)
12546 element = Tile[x][y];
12548 if (ExplodeField[x][y])
12549 Explode(x, y, EX_PHASE_START, ExplodeField[x][y]);
12550 else if (element == EL_EXPLOSION)
12551 Explode(x, y, ExplodePhase[x][y], EX_TYPE_NORMAL);
12553 ExplodeField[x][y] = EX_TYPE_NONE;
12556 game.explosions_delayed = TRUE;
12558 if (game.magic_wall_active)
12560 if (!(game.magic_wall_time_left % 4))
12562 int element = Tile[magic_wall_x][magic_wall_y];
12564 if (element == EL_BD_MAGIC_WALL_FULL ||
12565 element == EL_BD_MAGIC_WALL_ACTIVE ||
12566 element == EL_BD_MAGIC_WALL_EMPTYING)
12567 PlayLevelSound(magic_wall_x, magic_wall_y, SND_BD_MAGIC_WALL_ACTIVE);
12568 else if (element == EL_DC_MAGIC_WALL_FULL ||
12569 element == EL_DC_MAGIC_WALL_ACTIVE ||
12570 element == EL_DC_MAGIC_WALL_EMPTYING)
12571 PlayLevelSound(magic_wall_x, magic_wall_y, SND_DC_MAGIC_WALL_ACTIVE);
12573 PlayLevelSound(magic_wall_x, magic_wall_y, SND_MAGIC_WALL_ACTIVE);
12576 if (game.magic_wall_time_left > 0)
12578 game.magic_wall_time_left--;
12580 if (!game.magic_wall_time_left)
12582 SCAN_PLAYFIELD(x, y)
12584 element = Tile[x][y];
12586 if (element == EL_MAGIC_WALL_ACTIVE ||
12587 element == EL_MAGIC_WALL_FULL)
12589 Tile[x][y] = EL_MAGIC_WALL_DEAD;
12590 TEST_DrawLevelField(x, y);
12592 else if (element == EL_BD_MAGIC_WALL_ACTIVE ||
12593 element == EL_BD_MAGIC_WALL_FULL)
12595 Tile[x][y] = EL_BD_MAGIC_WALL_DEAD;
12596 TEST_DrawLevelField(x, y);
12598 else if (element == EL_DC_MAGIC_WALL_ACTIVE ||
12599 element == EL_DC_MAGIC_WALL_FULL)
12601 Tile[x][y] = EL_DC_MAGIC_WALL_DEAD;
12602 TEST_DrawLevelField(x, y);
12606 game.magic_wall_active = FALSE;
12611 if (game.light_time_left > 0)
12613 game.light_time_left--;
12615 if (game.light_time_left == 0)
12616 RedrawAllLightSwitchesAndInvisibleElements();
12619 if (game.timegate_time_left > 0)
12621 game.timegate_time_left--;
12623 if (game.timegate_time_left == 0)
12624 CloseAllOpenTimegates();
12627 if (game.lenses_time_left > 0)
12629 game.lenses_time_left--;
12631 if (game.lenses_time_left == 0)
12632 RedrawAllInvisibleElementsForLenses();
12635 if (game.magnify_time_left > 0)
12637 game.magnify_time_left--;
12639 if (game.magnify_time_left == 0)
12640 RedrawAllInvisibleElementsForMagnifier();
12643 for (i = 0; i < MAX_PLAYERS; i++)
12645 struct PlayerInfo *player = &stored_player[i];
12647 if (SHIELD_ON(player))
12649 if (player->shield_deadly_time_left)
12650 PlayLevelSound(player->jx, player->jy, SND_SHIELD_DEADLY_ACTIVE);
12651 else if (player->shield_normal_time_left)
12652 PlayLevelSound(player->jx, player->jy, SND_SHIELD_NORMAL_ACTIVE);
12656 #if USE_DELAYED_GFX_REDRAW
12657 SCAN_PLAYFIELD(x, y)
12659 if (GfxRedraw[x][y] != GFX_REDRAW_NONE)
12661 /* !!! PROBLEM: THIS REDRAWS THE PLAYFIELD _AFTER_ THE SCAN, BUT TILES
12662 !!! MAY HAVE CHANGED AFTER BEING DRAWN DURING PLAYFIELD SCAN !!! */
12664 if (GfxRedraw[x][y] & GFX_REDRAW_TILE)
12665 DrawLevelField(x, y);
12667 if (GfxRedraw[x][y] & GFX_REDRAW_TILE_CRUMBLED)
12668 DrawLevelFieldCrumbled(x, y);
12670 if (GfxRedraw[x][y] & GFX_REDRAW_TILE_CRUMBLED_NEIGHBOURS)
12671 DrawLevelFieldCrumbledNeighbours(x, y);
12673 if (GfxRedraw[x][y] & GFX_REDRAW_TILE_TWINKLED)
12674 DrawTwinkleOnField(x, y);
12677 GfxRedraw[x][y] = GFX_REDRAW_NONE;
12682 PlayAllPlayersSound();
12684 for (i = 0; i < MAX_PLAYERS; i++)
12686 struct PlayerInfo *player = &stored_player[i];
12688 if (player->show_envelope != 0 && (!player->active ||
12689 player->MovPos == 0))
12691 ShowEnvelope(player->show_envelope - EL_ENVELOPE_1);
12693 player->show_envelope = 0;
12697 // use random number generator in every frame to make it less predictable
12698 if (game.engine_version >= VERSION_IDENT(3,1,1,0))
12701 mouse_action_last = mouse_action;
12704 static boolean AllPlayersInSight(struct PlayerInfo *player, int x, int y)
12706 int min_x = x, min_y = y, max_x = x, max_y = y;
12707 int scr_fieldx = getScreenFieldSizeX();
12708 int scr_fieldy = getScreenFieldSizeY();
12711 for (i = 0; i < MAX_PLAYERS; i++)
12713 int jx = stored_player[i].jx, jy = stored_player[i].jy;
12715 if (!stored_player[i].active || &stored_player[i] == player)
12718 min_x = MIN(min_x, jx);
12719 min_y = MIN(min_y, jy);
12720 max_x = MAX(max_x, jx);
12721 max_y = MAX(max_y, jy);
12724 return (max_x - min_x < scr_fieldx && max_y - min_y < scr_fieldy);
12727 static boolean AllPlayersInVisibleScreen(void)
12731 for (i = 0; i < MAX_PLAYERS; i++)
12733 int jx = stored_player[i].jx, jy = stored_player[i].jy;
12735 if (!stored_player[i].active)
12738 if (!IN_VIS_FIELD(SCREENX(jx), SCREENY(jy)))
12745 void ScrollLevel(int dx, int dy)
12747 int scroll_offset = 2 * TILEX_VAR;
12750 BlitBitmap(drawto_field, drawto_field,
12751 FX + TILEX_VAR * (dx == -1) - scroll_offset,
12752 FY + TILEY_VAR * (dy == -1) - scroll_offset,
12753 SXSIZE - TILEX_VAR * (dx != 0) + 2 * scroll_offset,
12754 SYSIZE - TILEY_VAR * (dy != 0) + 2 * scroll_offset,
12755 FX + TILEX_VAR * (dx == 1) - scroll_offset,
12756 FY + TILEY_VAR * (dy == 1) - scroll_offset);
12760 x = (dx == 1 ? BX1 : BX2);
12761 for (y = BY1; y <= BY2; y++)
12762 DrawScreenField(x, y);
12767 y = (dy == 1 ? BY1 : BY2);
12768 for (x = BX1; x <= BX2; x++)
12769 DrawScreenField(x, y);
12772 redraw_mask |= REDRAW_FIELD;
12775 static boolean canFallDown(struct PlayerInfo *player)
12777 int jx = player->jx, jy = player->jy;
12779 return (IN_LEV_FIELD(jx, jy + 1) &&
12780 (IS_FREE(jx, jy + 1) ||
12781 (Tile[jx][jy + 1] == EL_ACID && player->can_fall_into_acid)) &&
12782 IS_WALKABLE_FROM(Tile[jx][jy], MV_DOWN) &&
12783 !IS_WALKABLE_INSIDE(Tile[jx][jy]));
12786 static boolean canPassField(int x, int y, int move_dir)
12788 int opposite_dir = MV_DIR_OPPOSITE(move_dir);
12789 int dx = (move_dir & MV_LEFT ? -1 : move_dir & MV_RIGHT ? +1 : 0);
12790 int dy = (move_dir & MV_UP ? -1 : move_dir & MV_DOWN ? +1 : 0);
12791 int nextx = x + dx;
12792 int nexty = y + dy;
12793 int element = Tile[x][y];
12795 return (IS_PASSABLE_FROM(element, opposite_dir) &&
12796 !CAN_MOVE(element) &&
12797 IN_LEV_FIELD(nextx, nexty) && !IS_PLAYER(nextx, nexty) &&
12798 IS_WALKABLE_FROM(Tile[nextx][nexty], move_dir) &&
12799 (level.can_pass_to_walkable || IS_FREE(nextx, nexty)));
12802 static boolean canMoveToValidFieldWithGravity(int x, int y, int move_dir)
12804 int opposite_dir = MV_DIR_OPPOSITE(move_dir);
12805 int dx = (move_dir & MV_LEFT ? -1 : move_dir & MV_RIGHT ? +1 : 0);
12806 int dy = (move_dir & MV_UP ? -1 : move_dir & MV_DOWN ? +1 : 0);
12810 return (IN_LEV_FIELD(newx, newy) && !IS_FREE_OR_PLAYER(newx, newy) &&
12811 IS_GRAVITY_REACHABLE(Tile[newx][newy]) &&
12812 (IS_DIGGABLE(Tile[newx][newy]) ||
12813 IS_WALKABLE_FROM(Tile[newx][newy], opposite_dir) ||
12814 canPassField(newx, newy, move_dir)));
12817 static void CheckGravityMovement(struct PlayerInfo *player)
12819 if (player->gravity && !player->programmed_action)
12821 int move_dir_horizontal = player->effective_action & MV_HORIZONTAL;
12822 int move_dir_vertical = player->effective_action & MV_VERTICAL;
12823 boolean player_is_snapping = (player->effective_action & JOY_BUTTON_1);
12824 int jx = player->jx, jy = player->jy;
12825 boolean player_is_moving_to_valid_field =
12826 (!player_is_snapping &&
12827 (canMoveToValidFieldWithGravity(jx, jy, move_dir_horizontal) ||
12828 canMoveToValidFieldWithGravity(jx, jy, move_dir_vertical)));
12829 boolean player_can_fall_down = canFallDown(player);
12831 if (player_can_fall_down &&
12832 !player_is_moving_to_valid_field)
12833 player->programmed_action = MV_DOWN;
12837 static void CheckGravityMovementWhenNotMoving(struct PlayerInfo *player)
12839 return CheckGravityMovement(player);
12841 if (player->gravity && !player->programmed_action)
12843 int jx = player->jx, jy = player->jy;
12844 boolean field_under_player_is_free =
12845 (IN_LEV_FIELD(jx, jy + 1) && IS_FREE(jx, jy + 1));
12846 boolean player_is_standing_on_valid_field =
12847 (IS_WALKABLE_INSIDE(Tile[jx][jy]) ||
12848 (IS_WALKABLE(Tile[jx][jy]) &&
12849 !(element_info[Tile[jx][jy]].access_direction & MV_DOWN)));
12851 if (field_under_player_is_free && !player_is_standing_on_valid_field)
12852 player->programmed_action = MV_DOWN;
12857 MovePlayerOneStep()
12858 -----------------------------------------------------------------------------
12859 dx, dy: direction (non-diagonal) to try to move the player to
12860 real_dx, real_dy: direction as read from input device (can be diagonal)
12863 boolean MovePlayerOneStep(struct PlayerInfo *player,
12864 int dx, int dy, int real_dx, int real_dy)
12866 int jx = player->jx, jy = player->jy;
12867 int new_jx = jx + dx, new_jy = jy + dy;
12869 boolean player_can_move = !player->cannot_move;
12871 if (!player->active || (!dx && !dy))
12872 return MP_NO_ACTION;
12874 player->MovDir = (dx < 0 ? MV_LEFT :
12875 dx > 0 ? MV_RIGHT :
12877 dy > 0 ? MV_DOWN : MV_NONE);
12879 if (!IN_LEV_FIELD(new_jx, new_jy))
12880 return MP_NO_ACTION;
12882 if (!player_can_move)
12884 if (player->MovPos == 0)
12886 player->is_moving = FALSE;
12887 player->is_digging = FALSE;
12888 player->is_collecting = FALSE;
12889 player->is_snapping = FALSE;
12890 player->is_pushing = FALSE;
12894 if (!network.enabled && game.centered_player_nr == -1 &&
12895 !AllPlayersInSight(player, new_jx, new_jy))
12896 return MP_NO_ACTION;
12898 can_move = DigField(player, jx, jy, new_jx, new_jy, real_dx,real_dy, DF_DIG);
12899 if (can_move != MP_MOVING)
12902 // check if DigField() has caused relocation of the player
12903 if (player->jx != jx || player->jy != jy)
12904 return MP_NO_ACTION; // <-- !!! CHECK THIS [-> MP_ACTION ?] !!!
12906 StorePlayer[jx][jy] = 0;
12907 player->last_jx = jx;
12908 player->last_jy = jy;
12909 player->jx = new_jx;
12910 player->jy = new_jy;
12911 StorePlayer[new_jx][new_jy] = player->element_nr;
12913 if (player->move_delay_value_next != -1)
12915 player->move_delay_value = player->move_delay_value_next;
12916 player->move_delay_value_next = -1;
12920 (dx > 0 || dy > 0 ? -1 : 1) * (TILEX - TILEX / player->move_delay_value);
12922 player->step_counter++;
12924 PlayerVisit[jx][jy] = FrameCounter;
12926 player->is_moving = TRUE;
12929 // should better be called in MovePlayer(), but this breaks some tapes
12930 ScrollPlayer(player, SCROLL_INIT);
12936 boolean MovePlayer(struct PlayerInfo *player, int dx, int dy)
12938 int jx = player->jx, jy = player->jy;
12939 int old_jx = jx, old_jy = jy;
12940 int moved = MP_NO_ACTION;
12942 if (!player->active)
12947 if (player->MovPos == 0)
12949 player->is_moving = FALSE;
12950 player->is_digging = FALSE;
12951 player->is_collecting = FALSE;
12952 player->is_snapping = FALSE;
12953 player->is_pushing = FALSE;
12959 if (player->move_delay > 0)
12962 player->move_delay = -1; // set to "uninitialized" value
12964 // store if player is automatically moved to next field
12965 player->is_auto_moving = (player->programmed_action != MV_NONE);
12967 // remove the last programmed player action
12968 player->programmed_action = 0;
12970 if (player->MovPos)
12972 // should only happen if pre-1.2 tape recordings are played
12973 // this is only for backward compatibility
12975 int original_move_delay_value = player->move_delay_value;
12978 Debug("game:playing:MovePlayer",
12979 "THIS SHOULD ONLY HAPPEN WITH PRE-1.2 LEVEL TAPES. [%d]",
12983 // scroll remaining steps with finest movement resolution
12984 player->move_delay_value = MOVE_DELAY_NORMAL_SPEED;
12986 while (player->MovPos)
12988 ScrollPlayer(player, SCROLL_GO_ON);
12989 ScrollScreen(NULL, SCROLL_GO_ON);
12991 AdvanceFrameAndPlayerCounters(player->index_nr);
12994 BackToFront_WithFrameDelay(0);
12997 player->move_delay_value = original_move_delay_value;
13000 player->is_active = FALSE;
13002 if (player->last_move_dir & MV_HORIZONTAL)
13004 if (!(moved |= MovePlayerOneStep(player, 0, dy, dx, dy)))
13005 moved |= MovePlayerOneStep(player, dx, 0, dx, dy);
13009 if (!(moved |= MovePlayerOneStep(player, dx, 0, dx, dy)))
13010 moved |= MovePlayerOneStep(player, 0, dy, dx, dy);
13013 if (!moved && !player->is_active)
13015 player->is_moving = FALSE;
13016 player->is_digging = FALSE;
13017 player->is_collecting = FALSE;
13018 player->is_snapping = FALSE;
13019 player->is_pushing = FALSE;
13025 if (moved & MP_MOVING && !ScreenMovPos &&
13026 (player->index_nr == game.centered_player_nr ||
13027 game.centered_player_nr == -1))
13029 int old_scroll_x = scroll_x, old_scroll_y = scroll_y;
13031 if (!IN_VIS_FIELD(SCREENX(jx), SCREENY(jy)))
13033 // actual player has left the screen -- scroll in that direction
13034 if (jx != old_jx) // player has moved horizontally
13035 scroll_x += (jx - old_jx);
13036 else // player has moved vertically
13037 scroll_y += (jy - old_jy);
13041 int offset_raw = game.scroll_delay_value;
13043 if (jx != old_jx) // player has moved horizontally
13045 int offset = MIN(offset_raw, (SCR_FIELDX - 2) / 2);
13046 int offset_x = offset * (player->MovDir == MV_LEFT ? +1 : -1);
13047 int new_scroll_x = jx - MIDPOSX + offset_x;
13049 if ((player->MovDir == MV_LEFT && scroll_x > new_scroll_x) ||
13050 (player->MovDir == MV_RIGHT && scroll_x < new_scroll_x))
13051 scroll_x = new_scroll_x;
13053 // don't scroll over playfield boundaries
13054 scroll_x = MIN(MAX(SBX_Left, scroll_x), SBX_Right);
13056 // don't scroll more than one field at a time
13057 scroll_x = old_scroll_x + SIGN(scroll_x - old_scroll_x);
13059 // don't scroll against the player's moving direction
13060 if ((player->MovDir == MV_LEFT && scroll_x > old_scroll_x) ||
13061 (player->MovDir == MV_RIGHT && scroll_x < old_scroll_x))
13062 scroll_x = old_scroll_x;
13064 else // player has moved vertically
13066 int offset = MIN(offset_raw, (SCR_FIELDY - 2) / 2);
13067 int offset_y = offset * (player->MovDir == MV_UP ? +1 : -1);
13068 int new_scroll_y = jy - MIDPOSY + offset_y;
13070 if ((player->MovDir == MV_UP && scroll_y > new_scroll_y) ||
13071 (player->MovDir == MV_DOWN && scroll_y < new_scroll_y))
13072 scroll_y = new_scroll_y;
13074 // don't scroll over playfield boundaries
13075 scroll_y = MIN(MAX(SBY_Upper, scroll_y), SBY_Lower);
13077 // don't scroll more than one field at a time
13078 scroll_y = old_scroll_y + SIGN(scroll_y - old_scroll_y);
13080 // don't scroll against the player's moving direction
13081 if ((player->MovDir == MV_UP && scroll_y > old_scroll_y) ||
13082 (player->MovDir == MV_DOWN && scroll_y < old_scroll_y))
13083 scroll_y = old_scroll_y;
13087 if (scroll_x != old_scroll_x || scroll_y != old_scroll_y)
13089 if (!network.enabled && game.centered_player_nr == -1 &&
13090 !AllPlayersInVisibleScreen())
13092 scroll_x = old_scroll_x;
13093 scroll_y = old_scroll_y;
13097 ScrollScreen(player, SCROLL_INIT);
13098 ScrollLevel(old_scroll_x - scroll_x, old_scroll_y - scroll_y);
13103 player->StepFrame = 0;
13105 if (moved & MP_MOVING)
13107 if (old_jx != jx && old_jy == jy)
13108 player->MovDir = (old_jx < jx ? MV_RIGHT : MV_LEFT);
13109 else if (old_jx == jx && old_jy != jy)
13110 player->MovDir = (old_jy < jy ? MV_DOWN : MV_UP);
13112 TEST_DrawLevelField(jx, jy); // for "crumbled sand"
13114 player->last_move_dir = player->MovDir;
13115 player->is_moving = TRUE;
13116 player->is_snapping = FALSE;
13117 player->is_switching = FALSE;
13118 player->is_dropping = FALSE;
13119 player->is_dropping_pressed = FALSE;
13120 player->drop_pressed_delay = 0;
13123 // should better be called here than above, but this breaks some tapes
13124 ScrollPlayer(player, SCROLL_INIT);
13129 CheckGravityMovementWhenNotMoving(player);
13131 player->is_moving = FALSE;
13133 /* at this point, the player is allowed to move, but cannot move right now
13134 (e.g. because of something blocking the way) -- ensure that the player
13135 is also allowed to move in the next frame (in old versions before 3.1.1,
13136 the player was forced to wait again for eight frames before next try) */
13138 if (game.engine_version >= VERSION_IDENT(3,1,1,0))
13139 player->move_delay = 0; // allow direct movement in the next frame
13142 if (player->move_delay == -1) // not yet initialized by DigField()
13143 player->move_delay = player->move_delay_value;
13145 if (game.engine_version < VERSION_IDENT(3,0,7,0))
13147 TestIfPlayerTouchesBadThing(jx, jy);
13148 TestIfPlayerTouchesCustomElement(jx, jy);
13151 if (!player->active)
13152 RemovePlayer(player);
13157 void ScrollPlayer(struct PlayerInfo *player, int mode)
13159 int jx = player->jx, jy = player->jy;
13160 int last_jx = player->last_jx, last_jy = player->last_jy;
13161 int move_stepsize = TILEX / player->move_delay_value;
13163 if (!player->active)
13166 if (player->MovPos == 0 && mode == SCROLL_GO_ON) // player not moving
13169 if (mode == SCROLL_INIT)
13171 player->actual_frame_counter = FrameCounter;
13172 player->GfxPos = move_stepsize * (player->MovPos / move_stepsize);
13174 if ((player->block_last_field || player->block_delay_adjustment > 0) &&
13175 Tile[last_jx][last_jy] == EL_EMPTY)
13177 int last_field_block_delay = 0; // start with no blocking at all
13178 int block_delay_adjustment = player->block_delay_adjustment;
13180 // if player blocks last field, add delay for exactly one move
13181 if (player->block_last_field)
13183 last_field_block_delay += player->move_delay_value;
13185 // when blocking enabled, prevent moving up despite gravity
13186 if (player->gravity && player->MovDir == MV_UP)
13187 block_delay_adjustment = -1;
13190 // add block delay adjustment (also possible when not blocking)
13191 last_field_block_delay += block_delay_adjustment;
13193 Tile[last_jx][last_jy] = EL_PLAYER_IS_LEAVING;
13194 MovDelay[last_jx][last_jy] = last_field_block_delay + 1;
13197 if (player->MovPos != 0) // player has not yet reached destination
13200 else if (!FrameReached(&player->actual_frame_counter, 1))
13203 if (player->MovPos != 0)
13205 player->MovPos += (player->MovPos > 0 ? -1 : 1) * move_stepsize;
13206 player->GfxPos = move_stepsize * (player->MovPos / move_stepsize);
13208 // before DrawPlayer() to draw correct player graphic for this case
13209 if (player->MovPos == 0)
13210 CheckGravityMovement(player);
13213 if (player->MovPos == 0) // player reached destination field
13215 if (player->move_delay_reset_counter > 0)
13217 player->move_delay_reset_counter--;
13219 if (player->move_delay_reset_counter == 0)
13221 // continue with normal speed after quickly moving through gate
13222 HALVE_PLAYER_SPEED(player);
13224 // be able to make the next move without delay
13225 player->move_delay = 0;
13229 player->last_jx = jx;
13230 player->last_jy = jy;
13232 if (Tile[jx][jy] == EL_EXIT_OPEN ||
13233 Tile[jx][jy] == EL_EM_EXIT_OPEN ||
13234 Tile[jx][jy] == EL_EM_EXIT_OPENING ||
13235 Tile[jx][jy] == EL_STEEL_EXIT_OPEN ||
13236 Tile[jx][jy] == EL_EM_STEEL_EXIT_OPEN ||
13237 Tile[jx][jy] == EL_EM_STEEL_EXIT_OPENING ||
13238 Tile[jx][jy] == EL_SP_EXIT_OPEN ||
13239 Tile[jx][jy] == EL_SP_EXIT_OPENING) // <-- special case
13241 ExitPlayer(player);
13243 if (game.players_still_needed == 0 &&
13244 (game.friends_still_needed == 0 ||
13245 IS_SP_ELEMENT(Tile[jx][jy])))
13249 // this breaks one level: "machine", level 000
13251 int move_direction = player->MovDir;
13252 int enter_side = MV_DIR_OPPOSITE(move_direction);
13253 int leave_side = move_direction;
13254 int old_jx = last_jx;
13255 int old_jy = last_jy;
13256 int old_element = Tile[old_jx][old_jy];
13257 int new_element = Tile[jx][jy];
13259 if (IS_CUSTOM_ELEMENT(old_element))
13260 CheckElementChangeByPlayer(old_jx, old_jy, old_element,
13262 player->index_bit, leave_side);
13264 CheckTriggeredElementChangeByPlayer(old_jx, old_jy, old_element,
13265 CE_PLAYER_LEAVES_X,
13266 player->index_bit, leave_side);
13268 if (IS_CUSTOM_ELEMENT(new_element))
13269 CheckElementChangeByPlayer(jx, jy, new_element, CE_ENTERED_BY_PLAYER,
13270 player->index_bit, enter_side);
13272 CheckTriggeredElementChangeByPlayer(jx, jy, new_element,
13273 CE_PLAYER_ENTERS_X,
13274 player->index_bit, enter_side);
13276 CheckTriggeredElementChangeBySide(jx, jy, player->initial_element,
13277 CE_MOVE_OF_X, move_direction);
13280 if (game.engine_version >= VERSION_IDENT(3,0,7,0))
13282 TestIfPlayerTouchesBadThing(jx, jy);
13283 TestIfPlayerTouchesCustomElement(jx, jy);
13285 /* needed because pushed element has not yet reached its destination,
13286 so it would trigger a change event at its previous field location */
13287 if (!player->is_pushing)
13288 TestIfElementTouchesCustomElement(jx, jy); // for empty space
13290 if (level.finish_dig_collect &&
13291 (player->is_digging || player->is_collecting))
13293 int last_element = player->last_removed_element;
13294 int move_direction = player->MovDir;
13295 int enter_side = MV_DIR_OPPOSITE(move_direction);
13296 int change_event = (player->is_digging ? CE_PLAYER_DIGS_X :
13297 CE_PLAYER_COLLECTS_X);
13299 CheckTriggeredElementChangeByPlayer(jx, jy, last_element, change_event,
13300 player->index_bit, enter_side);
13302 player->last_removed_element = EL_UNDEFINED;
13305 if (!player->active)
13306 RemovePlayer(player);
13309 if (level.use_step_counter)
13310 CheckLevelTime_StepCounter();
13312 if (tape.single_step && tape.recording && !tape.pausing &&
13313 !player->programmed_action)
13314 TapeTogglePause(TAPE_TOGGLE_AUTOMATIC);
13316 if (!player->programmed_action)
13317 CheckSaveEngineSnapshot(player);
13321 void ScrollScreen(struct PlayerInfo *player, int mode)
13323 static unsigned int screen_frame_counter = 0;
13325 if (mode == SCROLL_INIT)
13327 // set scrolling step size according to actual player's moving speed
13328 ScrollStepSize = TILEX / player->move_delay_value;
13330 screen_frame_counter = FrameCounter;
13331 ScreenMovDir = player->MovDir;
13332 ScreenMovPos = player->MovPos;
13333 ScreenGfxPos = ScrollStepSize * (ScreenMovPos / ScrollStepSize);
13336 else if (!FrameReached(&screen_frame_counter, 1))
13341 ScreenMovPos += (ScreenMovPos > 0 ? -1 : 1) * ScrollStepSize;
13342 ScreenGfxPos = ScrollStepSize * (ScreenMovPos / ScrollStepSize);
13343 redraw_mask |= REDRAW_FIELD;
13346 ScreenMovDir = MV_NONE;
13349 void CheckNextToConditions(int x, int y)
13351 int element = Tile[x][y];
13353 if (IS_PLAYER(x, y))
13354 TestIfPlayerNextToCustomElement(x, y);
13356 if (CAN_CHANGE_OR_HAS_ACTION(element) &&
13357 HAS_ANY_CHANGE_EVENT(element, CE_NEXT_TO_X))
13358 TestIfElementNextToCustomElement(x, y);
13361 void TestIfPlayerNextToCustomElement(int x, int y)
13363 static int xy[4][2] =
13370 static int trigger_sides[4][2] =
13372 // center side border side
13373 { CH_SIDE_TOP, CH_SIDE_BOTTOM }, // check top
13374 { CH_SIDE_LEFT, CH_SIDE_RIGHT }, // check left
13375 { CH_SIDE_RIGHT, CH_SIDE_LEFT }, // check right
13376 { CH_SIDE_BOTTOM, CH_SIDE_TOP } // check bottom
13380 if (!IS_PLAYER(x, y))
13383 struct PlayerInfo *player = PLAYERINFO(x, y);
13385 if (player->is_moving)
13388 for (i = 0; i < NUM_DIRECTIONS; i++)
13390 int xx = x + xy[i][0];
13391 int yy = y + xy[i][1];
13392 int border_side = trigger_sides[i][1];
13393 int border_element;
13395 if (!IN_LEV_FIELD(xx, yy))
13398 if (IS_MOVING(xx, yy) || IS_BLOCKED(xx, yy))
13399 continue; // center and border element not connected
13401 border_element = Tile[xx][yy];
13403 CheckElementChangeByPlayer(xx, yy, border_element, CE_NEXT_TO_PLAYER,
13404 player->index_bit, border_side);
13405 CheckTriggeredElementChangeByPlayer(xx, yy, border_element,
13406 CE_PLAYER_NEXT_TO_X,
13407 player->index_bit, border_side);
13409 /* use player element that is initially defined in the level playfield,
13410 not the player element that corresponds to the runtime player number
13411 (example: a level that contains EL_PLAYER_3 as the only player would
13412 incorrectly give EL_PLAYER_1 for "player->element_nr") */
13414 CheckElementChangeBySide(xx, yy, border_element, player->initial_element,
13415 CE_NEXT_TO_X, border_side);
13419 void TestIfPlayerTouchesCustomElement(int x, int y)
13421 static int xy[4][2] =
13428 static int trigger_sides[4][2] =
13430 // center side border side
13431 { CH_SIDE_TOP, CH_SIDE_BOTTOM }, // check top
13432 { CH_SIDE_LEFT, CH_SIDE_RIGHT }, // check left
13433 { CH_SIDE_RIGHT, CH_SIDE_LEFT }, // check right
13434 { CH_SIDE_BOTTOM, CH_SIDE_TOP } // check bottom
13436 static int touch_dir[4] =
13438 MV_LEFT | MV_RIGHT,
13443 int center_element = Tile[x][y]; // should always be non-moving!
13446 for (i = 0; i < NUM_DIRECTIONS; i++)
13448 int xx = x + xy[i][0];
13449 int yy = y + xy[i][1];
13450 int center_side = trigger_sides[i][0];
13451 int border_side = trigger_sides[i][1];
13452 int border_element;
13454 if (!IN_LEV_FIELD(xx, yy))
13457 if (IS_PLAYER(x, y)) // player found at center element
13459 struct PlayerInfo *player = PLAYERINFO(x, y);
13461 if (game.engine_version < VERSION_IDENT(3,0,7,0))
13462 border_element = Tile[xx][yy]; // may be moving!
13463 else if (!IS_MOVING(xx, yy) && !IS_BLOCKED(xx, yy))
13464 border_element = Tile[xx][yy];
13465 else if (MovDir[xx][yy] & touch_dir[i]) // elements are touching
13466 border_element = MovingOrBlocked2Element(xx, yy);
13468 continue; // center and border element do not touch
13470 CheckElementChangeByPlayer(xx, yy, border_element, CE_TOUCHED_BY_PLAYER,
13471 player->index_bit, border_side);
13472 CheckTriggeredElementChangeByPlayer(xx, yy, border_element,
13473 CE_PLAYER_TOUCHES_X,
13474 player->index_bit, border_side);
13477 /* use player element that is initially defined in the level playfield,
13478 not the player element that corresponds to the runtime player number
13479 (example: a level that contains EL_PLAYER_3 as the only player would
13480 incorrectly give EL_PLAYER_1 for "player->element_nr") */
13481 int player_element = PLAYERINFO(x, y)->initial_element;
13483 CheckElementChangeBySide(xx, yy, border_element, player_element,
13484 CE_TOUCHING_X, border_side);
13487 else if (IS_PLAYER(xx, yy)) // player found at border element
13489 struct PlayerInfo *player = PLAYERINFO(xx, yy);
13491 if (game.engine_version >= VERSION_IDENT(3,0,7,0))
13493 if (player->MovPos != 0 && !(player->MovDir & touch_dir[i]))
13494 continue; // center and border element do not touch
13497 CheckElementChangeByPlayer(x, y, center_element, CE_TOUCHED_BY_PLAYER,
13498 player->index_bit, center_side);
13499 CheckTriggeredElementChangeByPlayer(x, y, center_element,
13500 CE_PLAYER_TOUCHES_X,
13501 player->index_bit, center_side);
13504 /* use player element that is initially defined in the level playfield,
13505 not the player element that corresponds to the runtime player number
13506 (example: a level that contains EL_PLAYER_3 as the only player would
13507 incorrectly give EL_PLAYER_1 for "player->element_nr") */
13508 int player_element = PLAYERINFO(xx, yy)->initial_element;
13510 CheckElementChangeBySide(x, y, center_element, player_element,
13511 CE_TOUCHING_X, center_side);
13519 void TestIfElementNextToCustomElement(int x, int y)
13521 static int xy[4][2] =
13528 static int trigger_sides[4][2] =
13530 // center side border side
13531 { CH_SIDE_TOP, CH_SIDE_BOTTOM }, // check top
13532 { CH_SIDE_LEFT, CH_SIDE_RIGHT }, // check left
13533 { CH_SIDE_RIGHT, CH_SIDE_LEFT }, // check right
13534 { CH_SIDE_BOTTOM, CH_SIDE_TOP } // check bottom
13536 int center_element = Tile[x][y]; // should always be non-moving!
13539 if (IS_MOVING(x, y) || IS_BLOCKED(x, y))
13542 for (i = 0; i < NUM_DIRECTIONS; i++)
13544 int xx = x + xy[i][0];
13545 int yy = y + xy[i][1];
13546 int border_side = trigger_sides[i][1];
13547 int border_element;
13549 if (!IN_LEV_FIELD(xx, yy))
13552 if (IS_MOVING(xx, yy) || IS_BLOCKED(xx, yy))
13553 continue; // center and border element not connected
13555 border_element = Tile[xx][yy];
13557 // check for change of center element (but change it only once)
13558 if (CheckElementChangeBySide(x, y, center_element, border_element,
13559 CE_NEXT_TO_X, border_side))
13564 void TestIfElementTouchesCustomElement(int x, int y)
13566 static int xy[4][2] =
13573 static int trigger_sides[4][2] =
13575 // center side border side
13576 { CH_SIDE_TOP, CH_SIDE_BOTTOM }, // check top
13577 { CH_SIDE_LEFT, CH_SIDE_RIGHT }, // check left
13578 { CH_SIDE_RIGHT, CH_SIDE_LEFT }, // check right
13579 { CH_SIDE_BOTTOM, CH_SIDE_TOP } // check bottom
13581 static int touch_dir[4] =
13583 MV_LEFT | MV_RIGHT,
13588 boolean change_center_element = FALSE;
13589 int center_element = Tile[x][y]; // should always be non-moving!
13590 int border_element_old[NUM_DIRECTIONS];
13593 for (i = 0; i < NUM_DIRECTIONS; i++)
13595 int xx = x + xy[i][0];
13596 int yy = y + xy[i][1];
13597 int border_element;
13599 border_element_old[i] = -1;
13601 if (!IN_LEV_FIELD(xx, yy))
13604 if (game.engine_version < VERSION_IDENT(3,0,7,0))
13605 border_element = Tile[xx][yy]; // may be moving!
13606 else if (!IS_MOVING(xx, yy) && !IS_BLOCKED(xx, yy))
13607 border_element = Tile[xx][yy];
13608 else if (MovDir[xx][yy] & touch_dir[i]) // elements are touching
13609 border_element = MovingOrBlocked2Element(xx, yy);
13611 continue; // center and border element do not touch
13613 border_element_old[i] = border_element;
13616 for (i = 0; i < NUM_DIRECTIONS; i++)
13618 int xx = x + xy[i][0];
13619 int yy = y + xy[i][1];
13620 int center_side = trigger_sides[i][0];
13621 int border_element = border_element_old[i];
13623 if (border_element == -1)
13626 // check for change of border element
13627 CheckElementChangeBySide(xx, yy, border_element, center_element,
13628 CE_TOUCHING_X, center_side);
13630 // (center element cannot be player, so we dont have to check this here)
13633 for (i = 0; i < NUM_DIRECTIONS; i++)
13635 int xx = x + xy[i][0];
13636 int yy = y + xy[i][1];
13637 int border_side = trigger_sides[i][1];
13638 int border_element = border_element_old[i];
13640 if (border_element == -1)
13643 // check for change of center element (but change it only once)
13644 if (!change_center_element)
13645 change_center_element =
13646 CheckElementChangeBySide(x, y, center_element, border_element,
13647 CE_TOUCHING_X, border_side);
13649 if (IS_PLAYER(xx, yy))
13651 /* use player element that is initially defined in the level playfield,
13652 not the player element that corresponds to the runtime player number
13653 (example: a level that contains EL_PLAYER_3 as the only player would
13654 incorrectly give EL_PLAYER_1 for "player->element_nr") */
13655 int player_element = PLAYERINFO(xx, yy)->initial_element;
13657 CheckElementChangeBySide(x, y, center_element, player_element,
13658 CE_TOUCHING_X, border_side);
13663 void TestIfElementHitsCustomElement(int x, int y, int direction)
13665 int dx = (direction == MV_LEFT ? -1 : direction == MV_RIGHT ? +1 : 0);
13666 int dy = (direction == MV_UP ? -1 : direction == MV_DOWN ? +1 : 0);
13667 int hitx = x + dx, hity = y + dy;
13668 int hitting_element = Tile[x][y];
13669 int touched_element;
13671 if (IN_LEV_FIELD(hitx, hity) && IS_FREE(hitx, hity))
13674 touched_element = (IN_LEV_FIELD(hitx, hity) ?
13675 MovingOrBlocked2Element(hitx, hity) : EL_STEELWALL);
13677 if (IN_LEV_FIELD(hitx, hity))
13679 int opposite_direction = MV_DIR_OPPOSITE(direction);
13680 int hitting_side = direction;
13681 int touched_side = opposite_direction;
13682 boolean object_hit = (!IS_MOVING(hitx, hity) ||
13683 MovDir[hitx][hity] != direction ||
13684 ABS(MovPos[hitx][hity]) <= TILEY / 2);
13690 CheckElementChangeBySide(x, y, hitting_element, touched_element,
13691 CE_HITTING_X, touched_side);
13693 CheckElementChangeBySide(hitx, hity, touched_element, hitting_element,
13694 CE_HIT_BY_X, hitting_side);
13696 CheckElementChangeBySide(hitx, hity, touched_element, hitting_element,
13697 CE_HIT_BY_SOMETHING, opposite_direction);
13699 if (IS_PLAYER(hitx, hity))
13701 /* use player element that is initially defined in the level playfield,
13702 not the player element that corresponds to the runtime player number
13703 (example: a level that contains EL_PLAYER_3 as the only player would
13704 incorrectly give EL_PLAYER_1 for "player->element_nr") */
13705 int player_element = PLAYERINFO(hitx, hity)->initial_element;
13707 CheckElementChangeBySide(x, y, hitting_element, player_element,
13708 CE_HITTING_X, touched_side);
13713 // "hitting something" is also true when hitting the playfield border
13714 CheckElementChangeBySide(x, y, hitting_element, touched_element,
13715 CE_HITTING_SOMETHING, direction);
13718 void TestIfGoodThingHitsBadThing(int good_x, int good_y, int good_move_dir)
13720 int i, kill_x = -1, kill_y = -1;
13722 int bad_element = -1;
13723 static int test_xy[4][2] =
13730 static int test_dir[4] =
13738 for (i = 0; i < NUM_DIRECTIONS; i++)
13740 int test_x, test_y, test_move_dir, test_element;
13742 test_x = good_x + test_xy[i][0];
13743 test_y = good_y + test_xy[i][1];
13745 if (!IN_LEV_FIELD(test_x, test_y))
13749 (IS_MOVING(test_x, test_y) ? MovDir[test_x][test_y] : MV_NONE);
13751 test_element = MovingOrBlocked2ElementIfNotLeaving(test_x, test_y);
13753 /* 1st case: good thing is moving towards DONT_RUN_INTO style bad thing;
13754 2nd case: DONT_TOUCH style bad thing does not move away from good thing
13756 if ((DONT_RUN_INTO(test_element) && good_move_dir == test_dir[i]) ||
13757 (DONT_TOUCH(test_element) && test_move_dir != test_dir[i]))
13761 bad_element = test_element;
13767 if (kill_x != -1 || kill_y != -1)
13769 if (IS_PLAYER(good_x, good_y))
13771 struct PlayerInfo *player = PLAYERINFO(good_x, good_y);
13773 if (player->shield_deadly_time_left > 0 &&
13774 !IS_INDESTRUCTIBLE(bad_element))
13775 Bang(kill_x, kill_y);
13776 else if (!PLAYER_ENEMY_PROTECTED(good_x, good_y))
13777 KillPlayer(player);
13780 Bang(good_x, good_y);
13784 void TestIfBadThingHitsGoodThing(int bad_x, int bad_y, int bad_move_dir)
13786 int i, kill_x = -1, kill_y = -1;
13787 int bad_element = Tile[bad_x][bad_y];
13788 static int test_xy[4][2] =
13795 static int touch_dir[4] =
13797 MV_LEFT | MV_RIGHT,
13802 static int test_dir[4] =
13810 if (bad_element == EL_EXPLOSION) // skip just exploding bad things
13813 for (i = 0; i < NUM_DIRECTIONS; i++)
13815 int test_x, test_y, test_move_dir, test_element;
13817 test_x = bad_x + test_xy[i][0];
13818 test_y = bad_y + test_xy[i][1];
13820 if (!IN_LEV_FIELD(test_x, test_y))
13824 (IS_MOVING(test_x, test_y) ? MovDir[test_x][test_y] : MV_NONE);
13826 test_element = Tile[test_x][test_y];
13828 /* 1st case: good thing is moving towards DONT_RUN_INTO style bad thing;
13829 2nd case: DONT_TOUCH style bad thing does not move away from good thing
13831 if ((DONT_RUN_INTO(bad_element) && bad_move_dir == test_dir[i]) ||
13832 (DONT_TOUCH(bad_element) && test_move_dir != test_dir[i]))
13834 // good thing is player or penguin that does not move away
13835 if (IS_PLAYER(test_x, test_y))
13837 struct PlayerInfo *player = PLAYERINFO(test_x, test_y);
13839 if (bad_element == EL_ROBOT && player->is_moving)
13840 continue; // robot does not kill player if he is moving
13842 if (game.engine_version >= VERSION_IDENT(3,0,7,0))
13844 if (player->MovPos != 0 && !(player->MovDir & touch_dir[i]))
13845 continue; // center and border element do not touch
13853 else if (test_element == EL_PENGUIN)
13863 if (kill_x != -1 || kill_y != -1)
13865 if (IS_PLAYER(kill_x, kill_y))
13867 struct PlayerInfo *player = PLAYERINFO(kill_x, kill_y);
13869 if (player->shield_deadly_time_left > 0 &&
13870 !IS_INDESTRUCTIBLE(bad_element))
13871 Bang(bad_x, bad_y);
13872 else if (!PLAYER_ENEMY_PROTECTED(kill_x, kill_y))
13873 KillPlayer(player);
13876 Bang(kill_x, kill_y);
13880 void TestIfGoodThingGetsHitByBadThing(int bad_x, int bad_y, int bad_move_dir)
13882 int bad_element = Tile[bad_x][bad_y];
13883 int dx = (bad_move_dir == MV_LEFT ? -1 : bad_move_dir == MV_RIGHT ? +1 : 0);
13884 int dy = (bad_move_dir == MV_UP ? -1 : bad_move_dir == MV_DOWN ? +1 : 0);
13885 int test_x = bad_x + dx, test_y = bad_y + dy;
13886 int test_move_dir, test_element;
13887 int kill_x = -1, kill_y = -1;
13889 if (!IN_LEV_FIELD(test_x, test_y))
13893 (IS_MOVING(test_x, test_y) ? MovDir[test_x][test_y] : MV_NONE);
13895 test_element = Tile[test_x][test_y];
13897 if (test_move_dir != bad_move_dir)
13899 // good thing can be player or penguin that does not move away
13900 if (IS_PLAYER(test_x, test_y))
13902 struct PlayerInfo *player = PLAYERINFO(test_x, test_y);
13904 /* (note: in comparison to DONT_RUN_TO and DONT_TOUCH, also handle the
13905 player as being hit when he is moving towards the bad thing, because
13906 the "get hit by" condition would be lost after the player stops) */
13907 if (player->MovPos != 0 && player->MovDir == bad_move_dir)
13908 return; // player moves away from bad thing
13913 else if (test_element == EL_PENGUIN)
13920 if (kill_x != -1 || kill_y != -1)
13922 if (IS_PLAYER(kill_x, kill_y))
13924 struct PlayerInfo *player = PLAYERINFO(kill_x, kill_y);
13926 if (player->shield_deadly_time_left > 0 &&
13927 !IS_INDESTRUCTIBLE(bad_element))
13928 Bang(bad_x, bad_y);
13929 else if (!PLAYER_ENEMY_PROTECTED(kill_x, kill_y))
13930 KillPlayer(player);
13933 Bang(kill_x, kill_y);
13937 void TestIfPlayerTouchesBadThing(int x, int y)
13939 TestIfGoodThingHitsBadThing(x, y, MV_NONE);
13942 void TestIfPlayerRunsIntoBadThing(int x, int y, int move_dir)
13944 TestIfGoodThingHitsBadThing(x, y, move_dir);
13947 void TestIfBadThingTouchesPlayer(int x, int y)
13949 TestIfBadThingHitsGoodThing(x, y, MV_NONE);
13952 void TestIfBadThingRunsIntoPlayer(int x, int y, int move_dir)
13954 TestIfBadThingHitsGoodThing(x, y, move_dir);
13957 void TestIfFriendTouchesBadThing(int x, int y)
13959 TestIfGoodThingHitsBadThing(x, y, MV_NONE);
13962 void TestIfBadThingTouchesFriend(int x, int y)
13964 TestIfBadThingHitsGoodThing(x, y, MV_NONE);
13967 void TestIfBadThingTouchesOtherBadThing(int bad_x, int bad_y)
13969 int i, kill_x = bad_x, kill_y = bad_y;
13970 static int xy[4][2] =
13978 for (i = 0; i < NUM_DIRECTIONS; i++)
13982 x = bad_x + xy[i][0];
13983 y = bad_y + xy[i][1];
13984 if (!IN_LEV_FIELD(x, y))
13987 element = Tile[x][y];
13988 if (IS_AMOEBOID(element) || element == EL_GAME_OF_LIFE ||
13989 element == EL_AMOEBA_GROWING || element == EL_AMOEBA_DROP)
13997 if (kill_x != bad_x || kill_y != bad_y)
13998 Bang(bad_x, bad_y);
14001 void KillPlayer(struct PlayerInfo *player)
14003 int jx = player->jx, jy = player->jy;
14005 if (!player->active)
14009 Debug("game:playing:KillPlayer",
14010 "0: killed == %d, active == %d, reanimated == %d",
14011 player->killed, player->active, player->reanimated);
14014 /* the following code was introduced to prevent an infinite loop when calling
14016 -> CheckTriggeredElementChangeExt()
14017 -> ExecuteCustomElementAction()
14019 -> (infinitely repeating the above sequence of function calls)
14020 which occurs when killing the player while having a CE with the setting
14021 "kill player X when explosion of <player X>"; the solution using a new
14022 field "player->killed" was chosen for backwards compatibility, although
14023 clever use of the fields "player->active" etc. would probably also work */
14025 if (player->killed)
14029 player->killed = TRUE;
14031 // remove accessible field at the player's position
14032 Tile[jx][jy] = EL_EMPTY;
14034 // deactivate shield (else Bang()/Explode() would not work right)
14035 player->shield_normal_time_left = 0;
14036 player->shield_deadly_time_left = 0;
14039 Debug("game:playing:KillPlayer",
14040 "1: killed == %d, active == %d, reanimated == %d",
14041 player->killed, player->active, player->reanimated);
14047 Debug("game:playing:KillPlayer",
14048 "2: killed == %d, active == %d, reanimated == %d",
14049 player->killed, player->active, player->reanimated);
14052 if (player->reanimated) // killed player may have been reanimated
14053 player->killed = player->reanimated = FALSE;
14055 BuryPlayer(player);
14058 static void KillPlayerUnlessEnemyProtected(int x, int y)
14060 if (!PLAYER_ENEMY_PROTECTED(x, y))
14061 KillPlayer(PLAYERINFO(x, y));
14064 static void KillPlayerUnlessExplosionProtected(int x, int y)
14066 if (!PLAYER_EXPLOSION_PROTECTED(x, y))
14067 KillPlayer(PLAYERINFO(x, y));
14070 void BuryPlayer(struct PlayerInfo *player)
14072 int jx = player->jx, jy = player->jy;
14074 if (!player->active)
14077 PlayLevelSoundElementAction(jx, jy, player->artwork_element, ACTION_DYING);
14078 PlayLevelSound(jx, jy, SND_GAME_LOSING);
14080 RemovePlayer(player);
14082 player->buried = TRUE;
14084 if (game.all_players_gone)
14085 game.GameOver = TRUE;
14088 void RemovePlayer(struct PlayerInfo *player)
14090 int jx = player->jx, jy = player->jy;
14091 int i, found = FALSE;
14093 player->present = FALSE;
14094 player->active = FALSE;
14096 // required for some CE actions (even if the player is not active anymore)
14097 player->MovPos = 0;
14099 if (!ExplodeField[jx][jy])
14100 StorePlayer[jx][jy] = 0;
14102 if (player->is_moving)
14103 TEST_DrawLevelField(player->last_jx, player->last_jy);
14105 for (i = 0; i < MAX_PLAYERS; i++)
14106 if (stored_player[i].active)
14111 game.all_players_gone = TRUE;
14112 game.GameOver = TRUE;
14115 game.exit_x = game.robot_wheel_x = jx;
14116 game.exit_y = game.robot_wheel_y = jy;
14119 void ExitPlayer(struct PlayerInfo *player)
14121 DrawPlayer(player); // needed here only to cleanup last field
14122 RemovePlayer(player);
14124 if (game.players_still_needed > 0)
14125 game.players_still_needed--;
14128 static void SetFieldForSnapping(int x, int y, int element, int direction,
14129 int player_index_bit)
14131 struct ElementInfo *ei = &element_info[element];
14132 int direction_bit = MV_DIR_TO_BIT(direction);
14133 int graphic_snapping = ei->direction_graphic[ACTION_SNAPPING][direction_bit];
14134 int action = (graphic_snapping != IMG_EMPTY_SPACE ? ACTION_SNAPPING :
14135 IS_DIGGABLE(element) ? ACTION_DIGGING : ACTION_COLLECTING);
14137 Tile[x][y] = EL_ELEMENT_SNAPPING;
14138 MovDelay[x][y] = MOVE_DELAY_NORMAL_SPEED + 1 - 1;
14139 MovDir[x][y] = direction;
14140 Store[x][y] = element;
14141 Store2[x][y] = player_index_bit;
14143 ResetGfxAnimation(x, y);
14145 GfxElement[x][y] = element;
14146 GfxAction[x][y] = action;
14147 GfxDir[x][y] = direction;
14148 GfxFrame[x][y] = -1;
14151 static void TestFieldAfterSnapping(int x, int y, int element, int direction,
14152 int player_index_bit)
14154 TestIfElementTouchesCustomElement(x, y); // for empty space
14156 if (level.finish_dig_collect)
14158 int dig_side = MV_DIR_OPPOSITE(direction);
14159 int change_event = (IS_DIGGABLE(element) ? CE_PLAYER_DIGS_X :
14160 CE_PLAYER_COLLECTS_X);
14162 CheckTriggeredElementChangeByPlayer(x, y, element, change_event,
14163 player_index_bit, dig_side);
14164 CheckTriggeredElementChangeByPlayer(x, y, element, CE_PLAYER_SNAPS_X,
14165 player_index_bit, dig_side);
14170 =============================================================================
14171 checkDiagonalPushing()
14172 -----------------------------------------------------------------------------
14173 check if diagonal input device direction results in pushing of object
14174 (by checking if the alternative direction is walkable, diggable, ...)
14175 =============================================================================
14178 static boolean checkDiagonalPushing(struct PlayerInfo *player,
14179 int x, int y, int real_dx, int real_dy)
14181 int jx, jy, dx, dy, xx, yy;
14183 if (real_dx == 0 || real_dy == 0) // no diagonal direction => push
14186 // diagonal direction: check alternative direction
14191 xx = jx + (dx == 0 ? real_dx : 0);
14192 yy = jy + (dy == 0 ? real_dy : 0);
14194 return (!IN_LEV_FIELD(xx, yy) || IS_SOLID_FOR_PUSHING(Tile[xx][yy]));
14198 =============================================================================
14200 -----------------------------------------------------------------------------
14201 x, y: field next to player (non-diagonal) to try to dig to
14202 real_dx, real_dy: direction as read from input device (can be diagonal)
14203 =============================================================================
14206 static int DigField(struct PlayerInfo *player,
14207 int oldx, int oldy, int x, int y,
14208 int real_dx, int real_dy, int mode)
14210 boolean is_player = (IS_PLAYER(oldx, oldy) || mode != DF_DIG);
14211 boolean player_was_pushing = player->is_pushing;
14212 boolean player_can_move = (!player->cannot_move && mode != DF_SNAP);
14213 boolean player_can_move_or_snap = (!player->cannot_move || mode == DF_SNAP);
14214 int jx = oldx, jy = oldy;
14215 int dx = x - jx, dy = y - jy;
14216 int nextx = x + dx, nexty = y + dy;
14217 int move_direction = (dx == -1 ? MV_LEFT :
14218 dx == +1 ? MV_RIGHT :
14220 dy == +1 ? MV_DOWN : MV_NONE);
14221 int opposite_direction = MV_DIR_OPPOSITE(move_direction);
14222 int dig_side = MV_DIR_OPPOSITE(move_direction);
14223 int old_element = Tile[jx][jy];
14224 int element = MovingOrBlocked2ElementIfNotLeaving(x, y);
14227 if (is_player) // function can also be called by EL_PENGUIN
14229 if (player->MovPos == 0)
14231 player->is_digging = FALSE;
14232 player->is_collecting = FALSE;
14235 if (player->MovPos == 0) // last pushing move finished
14236 player->is_pushing = FALSE;
14238 if (mode == DF_NO_PUSH) // player just stopped pushing
14240 player->is_switching = FALSE;
14241 player->push_delay = -1;
14243 return MP_NO_ACTION;
14246 if (IS_TUBE(Back[jx][jy]) && game.engine_version >= VERSION_IDENT(2,2,0,0))
14247 old_element = Back[jx][jy];
14249 // in case of element dropped at player position, check background
14250 else if (Back[jx][jy] != EL_EMPTY &&
14251 game.engine_version >= VERSION_IDENT(2,2,0,0))
14252 old_element = Back[jx][jy];
14254 if (IS_WALKABLE(old_element) && !ACCESS_FROM(old_element, move_direction))
14255 return MP_NO_ACTION; // field has no opening in this direction
14257 if (IS_PASSABLE(old_element) && !ACCESS_FROM(old_element,opposite_direction))
14258 return MP_NO_ACTION; // field has no opening in this direction
14260 if (player_can_move && element == EL_ACID && move_direction == MV_DOWN)
14264 Tile[jx][jy] = player->artwork_element;
14265 InitMovingField(jx, jy, MV_DOWN);
14266 Store[jx][jy] = EL_ACID;
14267 ContinueMoving(jx, jy);
14268 BuryPlayer(player);
14270 return MP_DONT_RUN_INTO;
14273 if (player_can_move && DONT_RUN_INTO(element))
14275 TestIfPlayerRunsIntoBadThing(jx, jy, player->MovDir);
14277 return MP_DONT_RUN_INTO;
14280 if (IS_MOVING(x, y) || IS_PLAYER(x, y))
14281 return MP_NO_ACTION;
14283 collect_count = element_info[element].collect_count_initial;
14285 if (!is_player && !IS_COLLECTIBLE(element)) // penguin cannot collect it
14286 return MP_NO_ACTION;
14288 if (game.engine_version < VERSION_IDENT(2,2,0,0))
14289 player_can_move = player_can_move_or_snap;
14291 if (mode == DF_SNAP && !IS_SNAPPABLE(element) &&
14292 game.engine_version >= VERSION_IDENT(2,2,0,0))
14294 CheckElementChangeByPlayer(x, y, element, CE_SNAPPED_BY_PLAYER,
14295 player->index_bit, dig_side);
14296 CheckTriggeredElementChangeByPlayer(x, y, element, CE_PLAYER_SNAPS_X,
14297 player->index_bit, dig_side);
14299 if (element == EL_DC_LANDMINE)
14302 if (Tile[x][y] != element) // field changed by snapping
14305 return MP_NO_ACTION;
14308 if (player->gravity && is_player && !player->is_auto_moving &&
14309 canFallDown(player) && move_direction != MV_DOWN &&
14310 !canMoveToValidFieldWithGravity(jx, jy, move_direction))
14311 return MP_NO_ACTION; // player cannot walk here due to gravity
14313 if (player_can_move &&
14314 IS_WALKABLE(element) && ACCESS_FROM(element, opposite_direction))
14316 int sound_element = SND_ELEMENT(element);
14317 int sound_action = ACTION_WALKING;
14319 if (IS_RND_GATE(element))
14321 if (!player->key[RND_GATE_NR(element)])
14322 return MP_NO_ACTION;
14324 else if (IS_RND_GATE_GRAY(element))
14326 if (!player->key[RND_GATE_GRAY_NR(element)])
14327 return MP_NO_ACTION;
14329 else if (IS_RND_GATE_GRAY_ACTIVE(element))
14331 if (!player->key[RND_GATE_GRAY_ACTIVE_NR(element)])
14332 return MP_NO_ACTION;
14334 else if (element == EL_EXIT_OPEN ||
14335 element == EL_EM_EXIT_OPEN ||
14336 element == EL_EM_EXIT_OPENING ||
14337 element == EL_STEEL_EXIT_OPEN ||
14338 element == EL_EM_STEEL_EXIT_OPEN ||
14339 element == EL_EM_STEEL_EXIT_OPENING ||
14340 element == EL_SP_EXIT_OPEN ||
14341 element == EL_SP_EXIT_OPENING)
14343 sound_action = ACTION_PASSING; // player is passing exit
14345 else if (element == EL_EMPTY)
14347 sound_action = ACTION_MOVING; // nothing to walk on
14350 // play sound from background or player, whatever is available
14351 if (element_info[sound_element].sound[sound_action] != SND_UNDEFINED)
14352 PlayLevelSoundElementAction(x, y, sound_element, sound_action);
14354 PlayLevelSoundElementAction(x, y, player->artwork_element, sound_action);
14356 else if (player_can_move &&
14357 IS_PASSABLE(element) && canPassField(x, y, move_direction))
14359 if (!ACCESS_FROM(element, opposite_direction))
14360 return MP_NO_ACTION; // field not accessible from this direction
14362 if (CAN_MOVE(element)) // only fixed elements can be passed!
14363 return MP_NO_ACTION;
14365 if (IS_EM_GATE(element))
14367 if (!player->key[EM_GATE_NR(element)])
14368 return MP_NO_ACTION;
14370 else if (IS_EM_GATE_GRAY(element))
14372 if (!player->key[EM_GATE_GRAY_NR(element)])
14373 return MP_NO_ACTION;
14375 else if (IS_EM_GATE_GRAY_ACTIVE(element))
14377 if (!player->key[EM_GATE_GRAY_ACTIVE_NR(element)])
14378 return MP_NO_ACTION;
14380 else if (IS_EMC_GATE(element))
14382 if (!player->key[EMC_GATE_NR(element)])
14383 return MP_NO_ACTION;
14385 else if (IS_EMC_GATE_GRAY(element))
14387 if (!player->key[EMC_GATE_GRAY_NR(element)])
14388 return MP_NO_ACTION;
14390 else if (IS_EMC_GATE_GRAY_ACTIVE(element))
14392 if (!player->key[EMC_GATE_GRAY_ACTIVE_NR(element)])
14393 return MP_NO_ACTION;
14395 else if (element == EL_DC_GATE_WHITE ||
14396 element == EL_DC_GATE_WHITE_GRAY ||
14397 element == EL_DC_GATE_WHITE_GRAY_ACTIVE)
14399 if (player->num_white_keys == 0)
14400 return MP_NO_ACTION;
14402 player->num_white_keys--;
14404 else if (IS_SP_PORT(element))
14406 if (element == EL_SP_GRAVITY_PORT_LEFT ||
14407 element == EL_SP_GRAVITY_PORT_RIGHT ||
14408 element == EL_SP_GRAVITY_PORT_UP ||
14409 element == EL_SP_GRAVITY_PORT_DOWN)
14410 player->gravity = !player->gravity;
14411 else if (element == EL_SP_GRAVITY_ON_PORT_LEFT ||
14412 element == EL_SP_GRAVITY_ON_PORT_RIGHT ||
14413 element == EL_SP_GRAVITY_ON_PORT_UP ||
14414 element == EL_SP_GRAVITY_ON_PORT_DOWN)
14415 player->gravity = TRUE;
14416 else if (element == EL_SP_GRAVITY_OFF_PORT_LEFT ||
14417 element == EL_SP_GRAVITY_OFF_PORT_RIGHT ||
14418 element == EL_SP_GRAVITY_OFF_PORT_UP ||
14419 element == EL_SP_GRAVITY_OFF_PORT_DOWN)
14420 player->gravity = FALSE;
14423 // automatically move to the next field with double speed
14424 player->programmed_action = move_direction;
14426 if (player->move_delay_reset_counter == 0)
14428 player->move_delay_reset_counter = 2; // two double speed steps
14430 DOUBLE_PLAYER_SPEED(player);
14433 PlayLevelSoundAction(x, y, ACTION_PASSING);
14435 else if (player_can_move_or_snap && IS_DIGGABLE(element))
14439 if (mode != DF_SNAP)
14441 GfxElement[x][y] = GFX_ELEMENT(element);
14442 player->is_digging = TRUE;
14445 PlayLevelSoundElementAction(x, y, element, ACTION_DIGGING);
14447 // use old behaviour for old levels (digging)
14448 if (!level.finish_dig_collect)
14450 CheckTriggeredElementChangeByPlayer(x, y, element, CE_PLAYER_DIGS_X,
14451 player->index_bit, dig_side);
14453 // if digging triggered player relocation, finish digging tile
14454 if (mode == DF_DIG && (player->jx != jx || player->jy != jy))
14455 SetFieldForSnapping(x, y, element, move_direction, player->index_bit);
14458 if (mode == DF_SNAP)
14460 if (level.block_snap_field)
14461 SetFieldForSnapping(x, y, element, move_direction, player->index_bit);
14463 TestFieldAfterSnapping(x, y, element, move_direction, player->index_bit);
14465 // use old behaviour for old levels (snapping)
14466 if (!level.finish_dig_collect)
14467 CheckTriggeredElementChangeByPlayer(x, y, element, CE_PLAYER_SNAPS_X,
14468 player->index_bit, dig_side);
14471 else if (player_can_move_or_snap && IS_COLLECTIBLE(element))
14475 if (is_player && mode != DF_SNAP)
14477 GfxElement[x][y] = element;
14478 player->is_collecting = TRUE;
14481 if (element == EL_SPEED_PILL)
14483 player->move_delay_value = MOVE_DELAY_HIGH_SPEED;
14485 else if (element == EL_EXTRA_TIME && level.time > 0)
14487 TimeLeft += level.extra_time;
14489 game_panel_controls[GAME_PANEL_TIME].value = TimeLeft;
14491 DisplayGameControlValues();
14493 else if (element == EL_SHIELD_NORMAL || element == EL_SHIELD_DEADLY)
14495 player->shield_normal_time_left += level.shield_normal_time;
14496 if (element == EL_SHIELD_DEADLY)
14497 player->shield_deadly_time_left += level.shield_deadly_time;
14499 else if (element == EL_DYNAMITE ||
14500 element == EL_EM_DYNAMITE ||
14501 element == EL_SP_DISK_RED)
14503 if (player->inventory_size < MAX_INVENTORY_SIZE)
14504 player->inventory_element[player->inventory_size++] = element;
14506 DrawGameDoorValues();
14508 else if (element == EL_DYNABOMB_INCREASE_NUMBER)
14510 player->dynabomb_count++;
14511 player->dynabombs_left++;
14513 else if (element == EL_DYNABOMB_INCREASE_SIZE)
14515 player->dynabomb_size++;
14517 else if (element == EL_DYNABOMB_INCREASE_POWER)
14519 player->dynabomb_xl = TRUE;
14521 else if (IS_KEY(element))
14523 player->key[KEY_NR(element)] = TRUE;
14525 DrawGameDoorValues();
14527 else if (element == EL_DC_KEY_WHITE)
14529 player->num_white_keys++;
14531 // display white keys?
14532 // DrawGameDoorValues();
14534 else if (IS_ENVELOPE(element))
14536 boolean wait_for_snapping = (mode == DF_SNAP && level.block_snap_field);
14538 if (!wait_for_snapping)
14539 player->show_envelope = element;
14541 else if (element == EL_EMC_LENSES)
14543 game.lenses_time_left = level.lenses_time * FRAMES_PER_SECOND;
14545 RedrawAllInvisibleElementsForLenses();
14547 else if (element == EL_EMC_MAGNIFIER)
14549 game.magnify_time_left = level.magnify_time * FRAMES_PER_SECOND;
14551 RedrawAllInvisibleElementsForMagnifier();
14553 else if (IS_DROPPABLE(element) ||
14554 IS_THROWABLE(element)) // can be collected and dropped
14558 if (collect_count == 0)
14559 player->inventory_infinite_element = element;
14561 for (i = 0; i < collect_count; i++)
14562 if (player->inventory_size < MAX_INVENTORY_SIZE)
14563 player->inventory_element[player->inventory_size++] = element;
14565 DrawGameDoorValues();
14567 else if (collect_count > 0)
14569 game.gems_still_needed -= collect_count;
14570 if (game.gems_still_needed < 0)
14571 game.gems_still_needed = 0;
14573 game.snapshot.collected_item = TRUE;
14575 game_panel_controls[GAME_PANEL_GEMS].value = game.gems_still_needed;
14577 DisplayGameControlValues();
14580 RaiseScoreElement(element);
14581 PlayLevelSoundElementAction(x, y, element, ACTION_COLLECTING);
14583 // use old behaviour for old levels (collecting)
14584 if (!level.finish_dig_collect && is_player)
14586 CheckTriggeredElementChangeByPlayer(x, y, element, CE_PLAYER_COLLECTS_X,
14587 player->index_bit, dig_side);
14589 // if collecting triggered player relocation, finish collecting tile
14590 if (mode == DF_DIG && (player->jx != jx || player->jy != jy))
14591 SetFieldForSnapping(x, y, element, move_direction, player->index_bit);
14594 if (mode == DF_SNAP)
14596 if (level.block_snap_field)
14597 SetFieldForSnapping(x, y, element, move_direction, player->index_bit);
14599 TestFieldAfterSnapping(x, y, element, move_direction, player->index_bit);
14601 // use old behaviour for old levels (snapping)
14602 if (!level.finish_dig_collect)
14603 CheckTriggeredElementChangeByPlayer(x, y, element, CE_PLAYER_SNAPS_X,
14604 player->index_bit, dig_side);
14607 else if (player_can_move_or_snap && IS_PUSHABLE(element))
14609 if (mode == DF_SNAP && element != EL_BD_ROCK)
14610 return MP_NO_ACTION;
14612 if (CAN_FALL(element) && dy)
14613 return MP_NO_ACTION;
14615 if (CAN_FALL(element) && IN_LEV_FIELD(x, y + 1) && IS_FREE(x, y + 1) &&
14616 !(element == EL_SPRING && level.use_spring_bug))
14617 return MP_NO_ACTION;
14619 if (CAN_MOVE(element) && GET_MAX_MOVE_DELAY(element) == 0 &&
14620 ((move_direction & MV_VERTICAL &&
14621 ((element_info[element].move_pattern & MV_LEFT &&
14622 IN_LEV_FIELD(x - 1, y) && IS_FREE(x - 1, y)) ||
14623 (element_info[element].move_pattern & MV_RIGHT &&
14624 IN_LEV_FIELD(x + 1, y) && IS_FREE(x + 1, y)))) ||
14625 (move_direction & MV_HORIZONTAL &&
14626 ((element_info[element].move_pattern & MV_UP &&
14627 IN_LEV_FIELD(x, y - 1) && IS_FREE(x, y - 1)) ||
14628 (element_info[element].move_pattern & MV_DOWN &&
14629 IN_LEV_FIELD(x, y + 1) && IS_FREE(x, y + 1))))))
14630 return MP_NO_ACTION;
14632 // do not push elements already moving away faster than player
14633 if (CAN_MOVE(element) && MovDir[x][y] == move_direction &&
14634 ABS(getElementMoveStepsize(x, y)) > MOVE_STEPSIZE_NORMAL)
14635 return MP_NO_ACTION;
14637 if (game.engine_version >= VERSION_IDENT(3,1,0,0))
14639 if (player->push_delay_value == -1 || !player_was_pushing)
14640 player->push_delay_value = GET_NEW_PUSH_DELAY(element);
14642 else if (game.engine_version >= VERSION_IDENT(3,0,7,1))
14644 if (player->push_delay_value == -1)
14645 player->push_delay_value = GET_NEW_PUSH_DELAY(element);
14647 else if (game.engine_version >= VERSION_IDENT(2,2,0,7))
14649 if (!player->is_pushing)
14650 player->push_delay_value = GET_NEW_PUSH_DELAY(element);
14653 player->is_pushing = TRUE;
14654 player->is_active = TRUE;
14656 if (!(IN_LEV_FIELD(nextx, nexty) &&
14657 (IS_FREE(nextx, nexty) ||
14658 (IS_SB_ELEMENT(element) &&
14659 Tile[nextx][nexty] == EL_SOKOBAN_FIELD_EMPTY) ||
14660 (IS_CUSTOM_ELEMENT(element) &&
14661 CUSTOM_ELEMENT_CAN_ENTER_FIELD(element, nextx, nexty)))))
14662 return MP_NO_ACTION;
14664 if (!checkDiagonalPushing(player, x, y, real_dx, real_dy))
14665 return MP_NO_ACTION;
14667 if (player->push_delay == -1) // new pushing; restart delay
14668 player->push_delay = 0;
14670 if (player->push_delay < player->push_delay_value &&
14671 !(tape.playing && tape.file_version < FILE_VERSION_2_0) &&
14672 element != EL_SPRING && element != EL_BALLOON)
14674 // make sure that there is no move delay before next try to push
14675 if (game.engine_version >= VERSION_IDENT(3,0,7,1))
14676 player->move_delay = 0;
14678 return MP_NO_ACTION;
14681 if (IS_CUSTOM_ELEMENT(element) &&
14682 CUSTOM_ELEMENT_CAN_ENTER_FIELD(element, nextx, nexty))
14684 if (!DigFieldByCE(nextx, nexty, element))
14685 return MP_NO_ACTION;
14688 if (IS_SB_ELEMENT(element))
14690 boolean sokoban_task_solved = FALSE;
14692 if (element == EL_SOKOBAN_FIELD_FULL)
14694 Back[x][y] = EL_SOKOBAN_FIELD_EMPTY;
14696 IncrementSokobanFieldsNeeded();
14697 IncrementSokobanObjectsNeeded();
14700 if (Tile[nextx][nexty] == EL_SOKOBAN_FIELD_EMPTY)
14702 Back[nextx][nexty] = EL_SOKOBAN_FIELD_EMPTY;
14704 DecrementSokobanFieldsNeeded();
14705 DecrementSokobanObjectsNeeded();
14707 // sokoban object was pushed from empty field to sokoban field
14708 if (Back[x][y] == EL_EMPTY)
14709 sokoban_task_solved = TRUE;
14712 Tile[x][y] = EL_SOKOBAN_OBJECT;
14714 if (Back[x][y] == Back[nextx][nexty])
14715 PlayLevelSoundAction(x, y, ACTION_PUSHING);
14716 else if (Back[x][y] != 0)
14717 PlayLevelSoundElementAction(x, y, EL_SOKOBAN_FIELD_FULL,
14720 PlayLevelSoundElementAction(nextx, nexty, EL_SOKOBAN_FIELD_EMPTY,
14723 if (sokoban_task_solved &&
14724 game.sokoban_fields_still_needed == 0 &&
14725 game.sokoban_objects_still_needed == 0 &&
14726 level.auto_exit_sokoban)
14728 game.players_still_needed = 0;
14732 PlayLevelSound(x, y, SND_GAME_SOKOBAN_SOLVING);
14736 PlayLevelSoundElementAction(x, y, element, ACTION_PUSHING);
14738 InitMovingField(x, y, move_direction);
14739 GfxAction[x][y] = ACTION_PUSHING;
14741 if (mode == DF_SNAP)
14742 ContinueMoving(x, y);
14744 MovPos[x][y] = (dx != 0 ? dx : dy);
14746 Pushed[x][y] = TRUE;
14747 Pushed[nextx][nexty] = TRUE;
14749 if (game.engine_version < VERSION_IDENT(2,2,0,7))
14750 player->push_delay_value = GET_NEW_PUSH_DELAY(element);
14752 player->push_delay_value = -1; // get new value later
14754 // check for element change _after_ element has been pushed
14755 if (game.use_change_when_pushing_bug)
14757 CheckElementChangeByPlayer(x, y, element, CE_PUSHED_BY_PLAYER,
14758 player->index_bit, dig_side);
14759 CheckTriggeredElementChangeByPlayer(x, y, element, CE_PLAYER_PUSHES_X,
14760 player->index_bit, dig_side);
14763 else if (IS_SWITCHABLE(element))
14765 if (PLAYER_SWITCHING(player, x, y))
14767 CheckTriggeredElementChangeByPlayer(x, y, element, CE_PLAYER_PRESSES_X,
14768 player->index_bit, dig_side);
14773 player->is_switching = TRUE;
14774 player->switch_x = x;
14775 player->switch_y = y;
14777 PlayLevelSoundElementAction(x, y, element, ACTION_ACTIVATING);
14779 if (element == EL_ROBOT_WHEEL)
14781 Tile[x][y] = EL_ROBOT_WHEEL_ACTIVE;
14783 game.robot_wheel_x = x;
14784 game.robot_wheel_y = y;
14785 game.robot_wheel_active = TRUE;
14787 TEST_DrawLevelField(x, y);
14789 else if (element == EL_SP_TERMINAL)
14793 SCAN_PLAYFIELD(xx, yy)
14795 if (Tile[xx][yy] == EL_SP_DISK_YELLOW)
14799 else if (Tile[xx][yy] == EL_SP_TERMINAL)
14801 Tile[xx][yy] = EL_SP_TERMINAL_ACTIVE;
14803 ResetGfxAnimation(xx, yy);
14804 TEST_DrawLevelField(xx, yy);
14808 else if (IS_BELT_SWITCH(element))
14810 ToggleBeltSwitch(x, y);
14812 else if (element == EL_SWITCHGATE_SWITCH_UP ||
14813 element == EL_SWITCHGATE_SWITCH_DOWN ||
14814 element == EL_DC_SWITCHGATE_SWITCH_UP ||
14815 element == EL_DC_SWITCHGATE_SWITCH_DOWN)
14817 ToggleSwitchgateSwitch(x, y);
14819 else if (element == EL_LIGHT_SWITCH ||
14820 element == EL_LIGHT_SWITCH_ACTIVE)
14822 ToggleLightSwitch(x, y);
14824 else if (element == EL_TIMEGATE_SWITCH ||
14825 element == EL_DC_TIMEGATE_SWITCH)
14827 ActivateTimegateSwitch(x, y);
14829 else if (element == EL_BALLOON_SWITCH_LEFT ||
14830 element == EL_BALLOON_SWITCH_RIGHT ||
14831 element == EL_BALLOON_SWITCH_UP ||
14832 element == EL_BALLOON_SWITCH_DOWN ||
14833 element == EL_BALLOON_SWITCH_NONE ||
14834 element == EL_BALLOON_SWITCH_ANY)
14836 game.wind_direction = (element == EL_BALLOON_SWITCH_LEFT ? MV_LEFT :
14837 element == EL_BALLOON_SWITCH_RIGHT ? MV_RIGHT :
14838 element == EL_BALLOON_SWITCH_UP ? MV_UP :
14839 element == EL_BALLOON_SWITCH_DOWN ? MV_DOWN :
14840 element == EL_BALLOON_SWITCH_NONE ? MV_NONE :
14843 else if (element == EL_LAMP)
14845 Tile[x][y] = EL_LAMP_ACTIVE;
14846 game.lights_still_needed--;
14848 ResetGfxAnimation(x, y);
14849 TEST_DrawLevelField(x, y);
14851 else if (element == EL_TIME_ORB_FULL)
14853 Tile[x][y] = EL_TIME_ORB_EMPTY;
14855 if (level.time > 0 || level.use_time_orb_bug)
14857 TimeLeft += level.time_orb_time;
14858 game.no_time_limit = FALSE;
14860 game_panel_controls[GAME_PANEL_TIME].value = TimeLeft;
14862 DisplayGameControlValues();
14865 ResetGfxAnimation(x, y);
14866 TEST_DrawLevelField(x, y);
14868 else if (element == EL_EMC_MAGIC_BALL_SWITCH ||
14869 element == EL_EMC_MAGIC_BALL_SWITCH_ACTIVE)
14873 game.ball_active = !game.ball_active;
14875 SCAN_PLAYFIELD(xx, yy)
14877 int e = Tile[xx][yy];
14879 if (game.ball_active)
14881 if (e == EL_EMC_MAGIC_BALL)
14882 CreateField(xx, yy, EL_EMC_MAGIC_BALL_ACTIVE);
14883 else if (e == EL_EMC_MAGIC_BALL_SWITCH)
14884 CreateField(xx, yy, EL_EMC_MAGIC_BALL_SWITCH_ACTIVE);
14888 if (e == EL_EMC_MAGIC_BALL_ACTIVE)
14889 CreateField(xx, yy, EL_EMC_MAGIC_BALL);
14890 else if (e == EL_EMC_MAGIC_BALL_SWITCH_ACTIVE)
14891 CreateField(xx, yy, EL_EMC_MAGIC_BALL_SWITCH);
14896 CheckTriggeredElementChangeByPlayer(x, y, element, CE_SWITCH_OF_X,
14897 player->index_bit, dig_side);
14899 CheckTriggeredElementChangeByPlayer(x, y, element, CE_PLAYER_SWITCHES_X,
14900 player->index_bit, dig_side);
14902 CheckTriggeredElementChangeByPlayer(x, y, element, CE_PLAYER_PRESSES_X,
14903 player->index_bit, dig_side);
14909 if (!PLAYER_SWITCHING(player, x, y))
14911 player->is_switching = TRUE;
14912 player->switch_x = x;
14913 player->switch_y = y;
14915 CheckElementChangeByPlayer(x, y, element, CE_SWITCHED,
14916 player->index_bit, dig_side);
14917 CheckTriggeredElementChangeByPlayer(x, y, element, CE_SWITCH_OF_X,
14918 player->index_bit, dig_side);
14920 CheckElementChangeByPlayer(x, y, element, CE_SWITCHED_BY_PLAYER,
14921 player->index_bit, dig_side);
14922 CheckTriggeredElementChangeByPlayer(x, y, element, CE_PLAYER_SWITCHES_X,
14923 player->index_bit, dig_side);
14926 CheckElementChangeByPlayer(x, y, element, CE_PRESSED_BY_PLAYER,
14927 player->index_bit, dig_side);
14928 CheckTriggeredElementChangeByPlayer(x, y, element, CE_PLAYER_PRESSES_X,
14929 player->index_bit, dig_side);
14931 return MP_NO_ACTION;
14934 player->push_delay = -1;
14936 if (is_player) // function can also be called by EL_PENGUIN
14938 if (Tile[x][y] != element) // really digged/collected something
14940 player->is_collecting = !player->is_digging;
14941 player->is_active = TRUE;
14943 player->last_removed_element = element;
14950 static boolean DigFieldByCE(int x, int y, int digging_element)
14952 int element = Tile[x][y];
14954 if (!IS_FREE(x, y))
14956 int action = (IS_DIGGABLE(element) ? ACTION_DIGGING :
14957 IS_COLLECTIBLE(element) ? ACTION_COLLECTING :
14960 // no element can dig solid indestructible elements
14961 if (IS_INDESTRUCTIBLE(element) &&
14962 !IS_DIGGABLE(element) &&
14963 !IS_COLLECTIBLE(element))
14966 if (AmoebaNr[x][y] &&
14967 (element == EL_AMOEBA_FULL ||
14968 element == EL_BD_AMOEBA ||
14969 element == EL_AMOEBA_GROWING))
14971 AmoebaCnt[AmoebaNr[x][y]]--;
14972 AmoebaCnt2[AmoebaNr[x][y]]--;
14975 if (IS_MOVING(x, y))
14976 RemoveMovingField(x, y);
14980 TEST_DrawLevelField(x, y);
14983 // if digged element was about to explode, prevent the explosion
14984 ExplodeField[x][y] = EX_TYPE_NONE;
14986 PlayLevelSoundAction(x, y, action);
14989 Store[x][y] = EL_EMPTY;
14991 // this makes it possible to leave the removed element again
14992 if (IS_EQUAL_OR_IN_GROUP(element, MOVE_ENTER_EL(digging_element)))
14993 Store[x][y] = element;
14998 static boolean SnapField(struct PlayerInfo *player, int dx, int dy)
15000 int jx = player->jx, jy = player->jy;
15001 int x = jx + dx, y = jy + dy;
15002 int snap_direction = (dx == -1 ? MV_LEFT :
15003 dx == +1 ? MV_RIGHT :
15005 dy == +1 ? MV_DOWN : MV_NONE);
15006 boolean can_continue_snapping = (level.continuous_snapping &&
15007 WasJustFalling[x][y] < CHECK_DELAY_FALLING);
15009 if (player->MovPos != 0 && game.engine_version >= VERSION_IDENT(2,2,0,0))
15012 if (!player->active || !IN_LEV_FIELD(x, y))
15020 if (player->MovPos == 0)
15021 player->is_pushing = FALSE;
15023 player->is_snapping = FALSE;
15025 if (player->MovPos == 0)
15027 player->is_moving = FALSE;
15028 player->is_digging = FALSE;
15029 player->is_collecting = FALSE;
15035 // prevent snapping with already pressed snap key when not allowed
15036 if (player->is_snapping && !can_continue_snapping)
15039 player->MovDir = snap_direction;
15041 if (player->MovPos == 0)
15043 player->is_moving = FALSE;
15044 player->is_digging = FALSE;
15045 player->is_collecting = FALSE;
15048 player->is_dropping = FALSE;
15049 player->is_dropping_pressed = FALSE;
15050 player->drop_pressed_delay = 0;
15052 if (DigField(player, jx, jy, x, y, 0, 0, DF_SNAP) == MP_NO_ACTION)
15055 player->is_snapping = TRUE;
15056 player->is_active = TRUE;
15058 if (player->MovPos == 0)
15060 player->is_moving = FALSE;
15061 player->is_digging = FALSE;
15062 player->is_collecting = FALSE;
15065 if (player->MovPos != 0) // prevent graphic bugs in versions < 2.2.0
15066 TEST_DrawLevelField(player->last_jx, player->last_jy);
15068 TEST_DrawLevelField(x, y);
15073 static boolean DropElement(struct PlayerInfo *player)
15075 int old_element, new_element;
15076 int dropx = player->jx, dropy = player->jy;
15077 int drop_direction = player->MovDir;
15078 int drop_side = drop_direction;
15079 int drop_element = get_next_dropped_element(player);
15081 /* do not drop an element on top of another element; when holding drop key
15082 pressed without moving, dropped element must move away before the next
15083 element can be dropped (this is especially important if the next element
15084 is dynamite, which can be placed on background for historical reasons) */
15085 if (PLAYER_DROPPING(player, dropx, dropy) && Tile[dropx][dropy] != EL_EMPTY)
15088 if (IS_THROWABLE(drop_element))
15090 dropx += GET_DX_FROM_DIR(drop_direction);
15091 dropy += GET_DY_FROM_DIR(drop_direction);
15093 if (!IN_LEV_FIELD(dropx, dropy))
15097 old_element = Tile[dropx][dropy]; // old element at dropping position
15098 new_element = drop_element; // default: no change when dropping
15100 // check if player is active, not moving and ready to drop
15101 if (!player->active || player->MovPos || player->drop_delay > 0)
15104 // check if player has anything that can be dropped
15105 if (new_element == EL_UNDEFINED)
15108 // only set if player has anything that can be dropped
15109 player->is_dropping_pressed = TRUE;
15111 // check if drop key was pressed long enough for EM style dynamite
15112 if (new_element == EL_EM_DYNAMITE && player->drop_pressed_delay < 40)
15115 // check if anything can be dropped at the current position
15116 if (IS_ACTIVE_BOMB(old_element) || old_element == EL_EXPLOSION)
15119 // collected custom elements can only be dropped on empty fields
15120 if (IS_CUSTOM_ELEMENT(new_element) && old_element != EL_EMPTY)
15123 if (old_element != EL_EMPTY)
15124 Back[dropx][dropy] = old_element; // store old element on this field
15126 ResetGfxAnimation(dropx, dropy);
15127 ResetRandomAnimationValue(dropx, dropy);
15129 if (player->inventory_size > 0 ||
15130 player->inventory_infinite_element != EL_UNDEFINED)
15132 if (player->inventory_size > 0)
15134 player->inventory_size--;
15136 DrawGameDoorValues();
15138 if (new_element == EL_DYNAMITE)
15139 new_element = EL_DYNAMITE_ACTIVE;
15140 else if (new_element == EL_EM_DYNAMITE)
15141 new_element = EL_EM_DYNAMITE_ACTIVE;
15142 else if (new_element == EL_SP_DISK_RED)
15143 new_element = EL_SP_DISK_RED_ACTIVE;
15146 Tile[dropx][dropy] = new_element;
15148 if (IN_SCR_FIELD(SCREENX(dropx), SCREENY(dropy)))
15149 DrawGraphicThruMask(SCREENX(dropx), SCREENY(dropy),
15150 el2img(Tile[dropx][dropy]), 0);
15152 PlayLevelSoundAction(dropx, dropy, ACTION_DROPPING);
15154 // needed if previous element just changed to "empty" in the last frame
15155 ChangeCount[dropx][dropy] = 0; // allow at least one more change
15157 CheckElementChangeByPlayer(dropx, dropy, new_element, CE_DROPPED_BY_PLAYER,
15158 player->index_bit, drop_side);
15159 CheckTriggeredElementChangeByPlayer(dropx, dropy, new_element,
15161 player->index_bit, drop_side);
15163 TestIfElementTouchesCustomElement(dropx, dropy);
15165 else // player is dropping a dyna bomb
15167 player->dynabombs_left--;
15169 Tile[dropx][dropy] = new_element;
15171 if (IN_SCR_FIELD(SCREENX(dropx), SCREENY(dropy)))
15172 DrawGraphicThruMask(SCREENX(dropx), SCREENY(dropy),
15173 el2img(Tile[dropx][dropy]), 0);
15175 PlayLevelSoundAction(dropx, dropy, ACTION_DROPPING);
15178 if (Tile[dropx][dropy] == new_element) // uninitialized unless CE change
15179 InitField_WithBug1(dropx, dropy, FALSE);
15181 new_element = Tile[dropx][dropy]; // element might have changed
15183 if (IS_CUSTOM_ELEMENT(new_element) && CAN_MOVE(new_element) &&
15184 element_info[new_element].move_pattern == MV_WHEN_DROPPED)
15186 if (element_info[new_element].move_direction_initial == MV_START_AUTOMATIC)
15187 MovDir[dropx][dropy] = drop_direction;
15189 ChangeCount[dropx][dropy] = 0; // allow at least one more change
15191 // do not cause impact style collision by dropping elements that can fall
15192 CheckCollision[dropx][dropy] = CHECK_DELAY_COLLISION;
15195 player->drop_delay = GET_NEW_DROP_DELAY(drop_element);
15196 player->is_dropping = TRUE;
15198 player->drop_pressed_delay = 0;
15199 player->is_dropping_pressed = FALSE;
15201 player->drop_x = dropx;
15202 player->drop_y = dropy;
15207 // ----------------------------------------------------------------------------
15208 // game sound playing functions
15209 // ----------------------------------------------------------------------------
15211 static int *loop_sound_frame = NULL;
15212 static int *loop_sound_volume = NULL;
15214 void InitPlayLevelSound(void)
15216 int num_sounds = getSoundListSize();
15218 checked_free(loop_sound_frame);
15219 checked_free(loop_sound_volume);
15221 loop_sound_frame = checked_calloc(num_sounds * sizeof(int));
15222 loop_sound_volume = checked_calloc(num_sounds * sizeof(int));
15225 static void PlayLevelSound(int x, int y, int nr)
15227 int sx = SCREENX(x), sy = SCREENY(y);
15228 int volume, stereo_position;
15229 int max_distance = 8;
15230 int type = (IS_LOOP_SOUND(nr) ? SND_CTRL_PLAY_LOOP : SND_CTRL_PLAY_SOUND);
15232 if ((!setup.sound_simple && !IS_LOOP_SOUND(nr)) ||
15233 (!setup.sound_loops && IS_LOOP_SOUND(nr)))
15236 if (!IN_LEV_FIELD(x, y) ||
15237 sx < -max_distance || sx >= SCR_FIELDX + max_distance ||
15238 sy < -max_distance || sy >= SCR_FIELDY + max_distance)
15241 volume = SOUND_MAX_VOLUME;
15243 if (!IN_SCR_FIELD(sx, sy))
15245 int dx = ABS(sx - SCR_FIELDX / 2) - SCR_FIELDX / 2;
15246 int dy = ABS(sy - SCR_FIELDY / 2) - SCR_FIELDY / 2;
15248 volume -= volume * (dx > dy ? dx : dy) / max_distance;
15251 stereo_position = (SOUND_MAX_LEFT +
15252 (sx + max_distance) * SOUND_MAX_LEFT2RIGHT /
15253 (SCR_FIELDX + 2 * max_distance));
15255 if (IS_LOOP_SOUND(nr))
15257 /* This assures that quieter loop sounds do not overwrite louder ones,
15258 while restarting sound volume comparison with each new game frame. */
15260 if (loop_sound_volume[nr] > volume && loop_sound_frame[nr] == FrameCounter)
15263 loop_sound_volume[nr] = volume;
15264 loop_sound_frame[nr] = FrameCounter;
15267 PlaySoundExt(nr, volume, stereo_position, type);
15270 static void PlayLevelSoundNearest(int x, int y, int sound_action)
15272 PlayLevelSound(x < LEVELX(BX1) ? LEVELX(BX1) :
15273 x > LEVELX(BX2) ? LEVELX(BX2) : x,
15274 y < LEVELY(BY1) ? LEVELY(BY1) :
15275 y > LEVELY(BY2) ? LEVELY(BY2) : y,
15279 static void PlayLevelSoundAction(int x, int y, int action)
15281 PlayLevelSoundElementAction(x, y, Tile[x][y], action);
15284 static void PlayLevelSoundElementAction(int x, int y, int element, int action)
15286 int sound_effect = element_info[SND_ELEMENT(element)].sound[action];
15288 if (sound_effect != SND_UNDEFINED)
15289 PlayLevelSound(x, y, sound_effect);
15292 static void PlayLevelSoundElementActionIfLoop(int x, int y, int element,
15295 int sound_effect = element_info[SND_ELEMENT(element)].sound[action];
15297 if (sound_effect != SND_UNDEFINED && IS_LOOP_SOUND(sound_effect))
15298 PlayLevelSound(x, y, sound_effect);
15301 static void PlayLevelSoundActionIfLoop(int x, int y, int action)
15303 int sound_effect = element_info[SND_ELEMENT(Tile[x][y])].sound[action];
15305 if (sound_effect != SND_UNDEFINED && IS_LOOP_SOUND(sound_effect))
15306 PlayLevelSound(x, y, sound_effect);
15309 static void StopLevelSoundActionIfLoop(int x, int y, int action)
15311 int sound_effect = element_info[SND_ELEMENT(Tile[x][y])].sound[action];
15313 if (sound_effect != SND_UNDEFINED && IS_LOOP_SOUND(sound_effect))
15314 StopSound(sound_effect);
15317 static int getLevelMusicNr(void)
15319 if (levelset.music[level_nr] != MUS_UNDEFINED)
15320 return levelset.music[level_nr]; // from config file
15322 return MAP_NOCONF_MUSIC(level_nr); // from music dir
15325 static void FadeLevelSounds(void)
15330 static void FadeLevelMusic(void)
15332 int music_nr = getLevelMusicNr();
15333 char *curr_music = getCurrentlyPlayingMusicFilename();
15334 char *next_music = getMusicInfoEntryFilename(music_nr);
15336 if (!strEqual(curr_music, next_music))
15340 void FadeLevelSoundsAndMusic(void)
15346 static void PlayLevelMusic(void)
15348 int music_nr = getLevelMusicNr();
15349 char *curr_music = getCurrentlyPlayingMusicFilename();
15350 char *next_music = getMusicInfoEntryFilename(music_nr);
15352 if (!strEqual(curr_music, next_music))
15353 PlayMusicLoop(music_nr);
15356 void PlayLevelSound_EM(int xx, int yy, int element_em, int sample)
15358 int element = (element_em > -1 ? map_element_EM_to_RND_game(element_em) : 0);
15360 int x = xx - offset;
15361 int y = yy - offset;
15366 PlayLevelSoundElementAction(x, y, element, ACTION_WALKING);
15370 PlayLevelSoundElementAction(x, y, element, ACTION_PUSHING);
15374 PlayLevelSoundElementAction(x, y, element, ACTION_IMPACT);
15378 PlayLevelSoundElementAction(x, y, element, ACTION_IMPACT);
15382 PlayLevelSoundElementAction(x, y, element, ACTION_BREAKING);
15386 PlayLevelSoundElementAction(x, y, element, ACTION_MOVING);
15390 PlayLevelSoundElementAction(x, y, element, ACTION_MOVING);
15393 case SOUND_android_clone:
15394 PlayLevelSoundElementAction(x, y, element, ACTION_DROPPING);
15397 case SOUND_android_move:
15398 PlayLevelSoundElementAction(x, y, element, ACTION_MOVING);
15402 PlayLevelSoundElementAction(x, y, element, ACTION_IMPACT);
15406 PlayLevelSoundElementAction(x, y, element, ACTION_EATING);
15410 PlayLevelSoundElementAction(x, y, element, ACTION_WAITING);
15413 case SOUND_eater_eat:
15414 PlayLevelSoundElementAction(x, y, element, ACTION_DIGGING);
15418 PlayLevelSoundElementAction(x, y, element, ACTION_MOVING);
15421 case SOUND_collect:
15422 PlayLevelSoundElementAction(x, y, element, ACTION_COLLECTING);
15425 case SOUND_diamond:
15426 PlayLevelSoundElementAction(x, y, element, ACTION_IMPACT);
15430 // !!! CHECK THIS !!!
15432 PlayLevelSoundElementAction(x, y, element, ACTION_BREAKING);
15434 PlayLevelSoundElementAction(x, y, element, ACTION_SMASHED_BY_ROCK);
15438 case SOUND_wonderfall:
15439 PlayLevelSoundElementAction(x, y, element, ACTION_FILLING);
15443 PlayLevelSoundElementAction(x, y, element, ACTION_IMPACT);
15447 PlayLevelSoundElementAction(x, y, element, ACTION_PUSHING);
15451 PlayLevelSoundElementAction(x, y, element, ACTION_DIGGING);
15455 PlayLevelSoundElementAction(x, y, element, ACTION_SPLASHING);
15459 PlayLevelSoundElementAction(x, y, element, ACTION_DROPPING);
15463 PlayLevelSoundElementAction(x, y, element, ACTION_GROWING);
15467 PlayLevelSoundElementAction(x, y, element, ACTION_ACTIVE);
15471 PlayLevelSoundElementAction(x, y, element, ACTION_PASSING);
15474 case SOUND_exit_open:
15475 PlayLevelSoundElementAction(x, y, element, ACTION_OPENING);
15478 case SOUND_exit_leave:
15479 PlayLevelSoundElementAction(x, y, element, ACTION_PASSING);
15482 case SOUND_dynamite:
15483 PlayLevelSoundElementAction(x, y, element, ACTION_DROPPING);
15487 PlayLevelSoundElementAction(x, y, element, ACTION_ACTIVE);
15491 PlayLevelSoundElementAction(x, y, element, ACTION_ACTIVATING);
15495 PlayLevelSoundElementAction(x, y, element, ACTION_ACTIVE);
15499 PlayLevelSoundElementAction(x, y, element, ACTION_EXPLODING);
15503 PlayLevelSoundElementAction(x, y, element, ACTION_DYING);
15507 PlaySound(SND_GAME_RUNNING_OUT_OF_TIME);
15511 PlayLevelSoundElementAction(x, y, element, ACTION_DEFAULT);
15516 void PlayLevelSound_SP(int xx, int yy, int element_sp, int action_sp)
15518 int element = map_element_SP_to_RND(element_sp);
15519 int action = map_action_SP_to_RND(action_sp);
15520 int offset = (setup.sp_show_border_elements ? 0 : 1);
15521 int x = xx - offset;
15522 int y = yy - offset;
15524 PlayLevelSoundElementAction(x, y, element, action);
15527 void PlayLevelSound_MM(int xx, int yy, int element_mm, int action_mm)
15529 int element = map_element_MM_to_RND(element_mm);
15530 int action = map_action_MM_to_RND(action_mm);
15532 int x = xx - offset;
15533 int y = yy - offset;
15535 if (!IS_MM_ELEMENT(element))
15536 element = EL_MM_DEFAULT;
15538 PlayLevelSoundElementAction(x, y, element, action);
15541 void PlaySound_MM(int sound_mm)
15543 int sound = map_sound_MM_to_RND(sound_mm);
15545 if (sound == SND_UNDEFINED)
15551 void PlaySoundLoop_MM(int sound_mm)
15553 int sound = map_sound_MM_to_RND(sound_mm);
15555 if (sound == SND_UNDEFINED)
15558 PlaySoundLoop(sound);
15561 void StopSound_MM(int sound_mm)
15563 int sound = map_sound_MM_to_RND(sound_mm);
15565 if (sound == SND_UNDEFINED)
15571 void RaiseScore(int value)
15573 game.score += value;
15575 game_panel_controls[GAME_PANEL_SCORE].value = game.score;
15577 DisplayGameControlValues();
15580 void RaiseScoreElement(int element)
15585 case EL_BD_DIAMOND:
15586 case EL_EMERALD_YELLOW:
15587 case EL_EMERALD_RED:
15588 case EL_EMERALD_PURPLE:
15589 case EL_SP_INFOTRON:
15590 RaiseScore(level.score[SC_EMERALD]);
15593 RaiseScore(level.score[SC_DIAMOND]);
15596 RaiseScore(level.score[SC_CRYSTAL]);
15599 RaiseScore(level.score[SC_PEARL]);
15602 case EL_BD_BUTTERFLY:
15603 case EL_SP_ELECTRON:
15604 RaiseScore(level.score[SC_BUG]);
15607 case EL_BD_FIREFLY:
15608 case EL_SP_SNIKSNAK:
15609 RaiseScore(level.score[SC_SPACESHIP]);
15612 case EL_DARK_YAMYAM:
15613 RaiseScore(level.score[SC_YAMYAM]);
15616 RaiseScore(level.score[SC_ROBOT]);
15619 RaiseScore(level.score[SC_PACMAN]);
15622 RaiseScore(level.score[SC_NUT]);
15625 case EL_EM_DYNAMITE:
15626 case EL_SP_DISK_RED:
15627 case EL_DYNABOMB_INCREASE_NUMBER:
15628 case EL_DYNABOMB_INCREASE_SIZE:
15629 case EL_DYNABOMB_INCREASE_POWER:
15630 RaiseScore(level.score[SC_DYNAMITE]);
15632 case EL_SHIELD_NORMAL:
15633 case EL_SHIELD_DEADLY:
15634 RaiseScore(level.score[SC_SHIELD]);
15636 case EL_EXTRA_TIME:
15637 RaiseScore(level.extra_time_score);
15651 case EL_DC_KEY_WHITE:
15652 RaiseScore(level.score[SC_KEY]);
15655 RaiseScore(element_info[element].collect_score);
15660 void RequestQuitGameExt(boolean skip_request, boolean quick_quit, char *message)
15662 if (skip_request || Request(message, REQ_ASK | REQ_STAY_CLOSED))
15666 // prevent short reactivation of overlay buttons while closing door
15667 SetOverlayActive(FALSE);
15669 // door may still be open due to skipped or envelope style request
15670 CloseDoor(DOOR_CLOSE_1);
15673 if (network.enabled)
15674 SendToServer_StopPlaying(NETWORK_STOP_BY_PLAYER);
15678 FadeSkipNextFadeIn();
15680 SetGameStatus(GAME_MODE_MAIN);
15685 else // continue playing the game
15687 if (tape.playing && tape.deactivate_display)
15688 TapeDeactivateDisplayOff(TRUE);
15690 OpenDoor(DOOR_OPEN_1 | DOOR_COPY_BACK);
15692 if (tape.playing && tape.deactivate_display)
15693 TapeDeactivateDisplayOn();
15697 void RequestQuitGame(boolean escape_key_pressed)
15699 boolean ask_on_escape = (setup.ask_on_escape && setup.ask_on_quit_game);
15700 boolean quick_quit = ((escape_key_pressed && !ask_on_escape) ||
15701 level_editor_test_game);
15702 boolean skip_request = (game.all_players_gone || !setup.ask_on_quit_game ||
15705 RequestQuitGameExt(skip_request, quick_quit,
15706 "Do you really want to quit the game?");
15709 void RequestRestartGame(char *message)
15711 game.restart_game_message = NULL;
15713 boolean has_started_game = hasStartedNetworkGame();
15714 int request_mode = (has_started_game ? REQ_ASK : REQ_CONFIRM);
15716 if (Request(message, request_mode | REQ_STAY_CLOSED) && has_started_game)
15718 StartGameActions(network.enabled, setup.autorecord, level.random_seed);
15722 // needed in case of envelope request to close game panel
15723 CloseDoor(DOOR_CLOSE_1);
15725 SetGameStatus(GAME_MODE_MAIN);
15731 void CheckGameOver(void)
15733 static boolean last_game_over = FALSE;
15734 static int game_over_delay = 0;
15735 int game_over_delay_value = 50;
15736 boolean game_over = checkGameFailed();
15738 // do not handle game over if request dialog is already active
15739 if (game.request_active)
15742 // do not ask to play again if game was never actually played
15743 if (!game.GamePlayed)
15748 last_game_over = FALSE;
15749 game_over_delay = game_over_delay_value;
15754 if (game_over_delay > 0)
15761 if (last_game_over != game_over)
15762 game.restart_game_message = (hasStartedNetworkGame() ?
15763 "Game over! Play it again?" :
15766 last_game_over = game_over;
15769 boolean checkGameSolved(void)
15771 // set for all game engines if level was solved
15772 return game.LevelSolved_GameEnd;
15775 boolean checkGameFailed(void)
15777 if (level.game_engine_type == GAME_ENGINE_TYPE_EM)
15778 return (game_em.game_over && !game_em.level_solved);
15779 else if (level.game_engine_type == GAME_ENGINE_TYPE_SP)
15780 return (game_sp.game_over && !game_sp.level_solved);
15781 else if (level.game_engine_type == GAME_ENGINE_TYPE_MM)
15782 return (game_mm.game_over && !game_mm.level_solved);
15783 else // GAME_ENGINE_TYPE_RND
15784 return (game.GameOver && !game.LevelSolved);
15787 boolean checkGameEnded(void)
15789 return (checkGameSolved() || checkGameFailed());
15793 // ----------------------------------------------------------------------------
15794 // random generator functions
15795 // ----------------------------------------------------------------------------
15797 unsigned int InitEngineRandom_RND(int seed)
15799 game.num_random_calls = 0;
15801 return InitEngineRandom(seed);
15804 unsigned int RND(int max)
15808 game.num_random_calls++;
15810 return GetEngineRandom(max);
15817 // ----------------------------------------------------------------------------
15818 // game engine snapshot handling functions
15819 // ----------------------------------------------------------------------------
15821 struct EngineSnapshotInfo
15823 // runtime values for custom element collect score
15824 int collect_score[NUM_CUSTOM_ELEMENTS];
15826 // runtime values for group element choice position
15827 int choice_pos[NUM_GROUP_ELEMENTS];
15829 // runtime values for belt position animations
15830 int belt_graphic[4][NUM_BELT_PARTS];
15831 int belt_anim_mode[4][NUM_BELT_PARTS];
15834 static struct EngineSnapshotInfo engine_snapshot_rnd;
15835 static char *snapshot_level_identifier = NULL;
15836 static int snapshot_level_nr = -1;
15838 static void SaveEngineSnapshotValues_RND(void)
15840 static int belt_base_active_element[4] =
15842 EL_CONVEYOR_BELT_1_LEFT_ACTIVE,
15843 EL_CONVEYOR_BELT_2_LEFT_ACTIVE,
15844 EL_CONVEYOR_BELT_3_LEFT_ACTIVE,
15845 EL_CONVEYOR_BELT_4_LEFT_ACTIVE
15849 for (i = 0; i < NUM_CUSTOM_ELEMENTS; i++)
15851 int element = EL_CUSTOM_START + i;
15853 engine_snapshot_rnd.collect_score[i] = element_info[element].collect_score;
15856 for (i = 0; i < NUM_GROUP_ELEMENTS; i++)
15858 int element = EL_GROUP_START + i;
15860 engine_snapshot_rnd.choice_pos[i] = element_info[element].group->choice_pos;
15863 for (i = 0; i < 4; i++)
15865 for (j = 0; j < NUM_BELT_PARTS; j++)
15867 int element = belt_base_active_element[i] + j;
15868 int graphic = el2img(element);
15869 int anim_mode = graphic_info[graphic].anim_mode;
15871 engine_snapshot_rnd.belt_graphic[i][j] = graphic;
15872 engine_snapshot_rnd.belt_anim_mode[i][j] = anim_mode;
15877 static void LoadEngineSnapshotValues_RND(void)
15879 unsigned int num_random_calls = game.num_random_calls;
15882 for (i = 0; i < NUM_CUSTOM_ELEMENTS; i++)
15884 int element = EL_CUSTOM_START + i;
15886 element_info[element].collect_score = engine_snapshot_rnd.collect_score[i];
15889 for (i = 0; i < NUM_GROUP_ELEMENTS; i++)
15891 int element = EL_GROUP_START + i;
15893 element_info[element].group->choice_pos = engine_snapshot_rnd.choice_pos[i];
15896 for (i = 0; i < 4; i++)
15898 for (j = 0; j < NUM_BELT_PARTS; j++)
15900 int graphic = engine_snapshot_rnd.belt_graphic[i][j];
15901 int anim_mode = engine_snapshot_rnd.belt_anim_mode[i][j];
15903 graphic_info[graphic].anim_mode = anim_mode;
15907 if (level.game_engine_type == GAME_ENGINE_TYPE_RND)
15909 InitRND(tape.random_seed);
15910 for (i = 0; i < num_random_calls; i++)
15914 if (game.num_random_calls != num_random_calls)
15916 Error("number of random calls out of sync");
15917 Error("number of random calls should be %d", num_random_calls);
15918 Error("number of random calls is %d", game.num_random_calls);
15920 Fail("this should not happen -- please debug");
15924 void FreeEngineSnapshotSingle(void)
15926 FreeSnapshotSingle();
15928 setString(&snapshot_level_identifier, NULL);
15929 snapshot_level_nr = -1;
15932 void FreeEngineSnapshotList(void)
15934 FreeSnapshotList();
15937 static ListNode *SaveEngineSnapshotBuffers(void)
15939 ListNode *buffers = NULL;
15941 // copy some special values to a structure better suited for the snapshot
15943 if (level.game_engine_type == GAME_ENGINE_TYPE_RND)
15944 SaveEngineSnapshotValues_RND();
15945 if (level.game_engine_type == GAME_ENGINE_TYPE_EM)
15946 SaveEngineSnapshotValues_EM();
15947 if (level.game_engine_type == GAME_ENGINE_TYPE_SP)
15948 SaveEngineSnapshotValues_SP(&buffers);
15949 if (level.game_engine_type == GAME_ENGINE_TYPE_MM)
15950 SaveEngineSnapshotValues_MM(&buffers);
15952 // save values stored in special snapshot structure
15954 if (level.game_engine_type == GAME_ENGINE_TYPE_RND)
15955 SaveSnapshotBuffer(&buffers, ARGS_ADDRESS_AND_SIZEOF(engine_snapshot_rnd));
15956 if (level.game_engine_type == GAME_ENGINE_TYPE_EM)
15957 SaveSnapshotBuffer(&buffers, ARGS_ADDRESS_AND_SIZEOF(engine_snapshot_em));
15958 if (level.game_engine_type == GAME_ENGINE_TYPE_SP)
15959 SaveSnapshotBuffer(&buffers, ARGS_ADDRESS_AND_SIZEOF(engine_snapshot_sp));
15960 if (level.game_engine_type == GAME_ENGINE_TYPE_MM)
15961 SaveSnapshotBuffer(&buffers, ARGS_ADDRESS_AND_SIZEOF(engine_snapshot_mm));
15963 // save further RND engine values
15965 SaveSnapshotBuffer(&buffers, ARGS_ADDRESS_AND_SIZEOF(stored_player));
15966 SaveSnapshotBuffer(&buffers, ARGS_ADDRESS_AND_SIZEOF(game));
15967 SaveSnapshotBuffer(&buffers, ARGS_ADDRESS_AND_SIZEOF(tape));
15969 SaveSnapshotBuffer(&buffers, ARGS_ADDRESS_AND_SIZEOF(FrameCounter));
15970 SaveSnapshotBuffer(&buffers, ARGS_ADDRESS_AND_SIZEOF(TimeFrames));
15971 SaveSnapshotBuffer(&buffers, ARGS_ADDRESS_AND_SIZEOF(TimePlayed));
15972 SaveSnapshotBuffer(&buffers, ARGS_ADDRESS_AND_SIZEOF(TimeLeft));
15973 SaveSnapshotBuffer(&buffers, ARGS_ADDRESS_AND_SIZEOF(TapeTime));
15975 SaveSnapshotBuffer(&buffers, ARGS_ADDRESS_AND_SIZEOF(ScreenMovDir));
15976 SaveSnapshotBuffer(&buffers, ARGS_ADDRESS_AND_SIZEOF(ScreenMovPos));
15977 SaveSnapshotBuffer(&buffers, ARGS_ADDRESS_AND_SIZEOF(ScreenGfxPos));
15979 SaveSnapshotBuffer(&buffers, ARGS_ADDRESS_AND_SIZEOF(ScrollStepSize));
15981 SaveSnapshotBuffer(&buffers, ARGS_ADDRESS_AND_SIZEOF(AmoebaCnt));
15982 SaveSnapshotBuffer(&buffers, ARGS_ADDRESS_AND_SIZEOF(AmoebaCnt2));
15984 SaveSnapshotBuffer(&buffers, ARGS_ADDRESS_AND_SIZEOF(Tile));
15985 SaveSnapshotBuffer(&buffers, ARGS_ADDRESS_AND_SIZEOF(MovPos));
15986 SaveSnapshotBuffer(&buffers, ARGS_ADDRESS_AND_SIZEOF(MovDir));
15987 SaveSnapshotBuffer(&buffers, ARGS_ADDRESS_AND_SIZEOF(MovDelay));
15988 SaveSnapshotBuffer(&buffers, ARGS_ADDRESS_AND_SIZEOF(ChangeDelay));
15989 SaveSnapshotBuffer(&buffers, ARGS_ADDRESS_AND_SIZEOF(ChangePage));
15990 SaveSnapshotBuffer(&buffers, ARGS_ADDRESS_AND_SIZEOF(CustomValue));
15991 SaveSnapshotBuffer(&buffers, ARGS_ADDRESS_AND_SIZEOF(Store));
15992 SaveSnapshotBuffer(&buffers, ARGS_ADDRESS_AND_SIZEOF(Store2));
15993 SaveSnapshotBuffer(&buffers, ARGS_ADDRESS_AND_SIZEOF(StorePlayer));
15994 SaveSnapshotBuffer(&buffers, ARGS_ADDRESS_AND_SIZEOF(Back));
15995 SaveSnapshotBuffer(&buffers, ARGS_ADDRESS_AND_SIZEOF(AmoebaNr));
15996 SaveSnapshotBuffer(&buffers, ARGS_ADDRESS_AND_SIZEOF(WasJustMoving));
15997 SaveSnapshotBuffer(&buffers, ARGS_ADDRESS_AND_SIZEOF(WasJustFalling));
15998 SaveSnapshotBuffer(&buffers, ARGS_ADDRESS_AND_SIZEOF(CheckCollision));
15999 SaveSnapshotBuffer(&buffers, ARGS_ADDRESS_AND_SIZEOF(CheckImpact));
16000 SaveSnapshotBuffer(&buffers, ARGS_ADDRESS_AND_SIZEOF(Stop));
16001 SaveSnapshotBuffer(&buffers, ARGS_ADDRESS_AND_SIZEOF(Pushed));
16003 SaveSnapshotBuffer(&buffers, ARGS_ADDRESS_AND_SIZEOF(ChangeCount));
16004 SaveSnapshotBuffer(&buffers, ARGS_ADDRESS_AND_SIZEOF(ChangeEvent));
16006 SaveSnapshotBuffer(&buffers, ARGS_ADDRESS_AND_SIZEOF(ExplodePhase));
16007 SaveSnapshotBuffer(&buffers, ARGS_ADDRESS_AND_SIZEOF(ExplodeDelay));
16008 SaveSnapshotBuffer(&buffers, ARGS_ADDRESS_AND_SIZEOF(ExplodeField));
16010 SaveSnapshotBuffer(&buffers, ARGS_ADDRESS_AND_SIZEOF(RunnerVisit));
16011 SaveSnapshotBuffer(&buffers, ARGS_ADDRESS_AND_SIZEOF(PlayerVisit));
16013 SaveSnapshotBuffer(&buffers, ARGS_ADDRESS_AND_SIZEOF(GfxFrame));
16014 SaveSnapshotBuffer(&buffers, ARGS_ADDRESS_AND_SIZEOF(GfxRandom));
16015 SaveSnapshotBuffer(&buffers, ARGS_ADDRESS_AND_SIZEOF(GfxRandomStatic));
16016 SaveSnapshotBuffer(&buffers, ARGS_ADDRESS_AND_SIZEOF(GfxElement));
16017 SaveSnapshotBuffer(&buffers, ARGS_ADDRESS_AND_SIZEOF(GfxAction));
16018 SaveSnapshotBuffer(&buffers, ARGS_ADDRESS_AND_SIZEOF(GfxDir));
16020 SaveSnapshotBuffer(&buffers, ARGS_ADDRESS_AND_SIZEOF(scroll_x));
16021 SaveSnapshotBuffer(&buffers, ARGS_ADDRESS_AND_SIZEOF(scroll_y));
16024 ListNode *node = engine_snapshot_list_rnd;
16027 while (node != NULL)
16029 num_bytes += ((struct EngineSnapshotNodeInfo *)node->content)->size;
16034 Debug("game:playing:SaveEngineSnapshotBuffers",
16035 "size of engine snapshot: %d bytes", num_bytes);
16041 void SaveEngineSnapshotSingle(void)
16043 ListNode *buffers = SaveEngineSnapshotBuffers();
16045 // finally save all snapshot buffers to single snapshot
16046 SaveSnapshotSingle(buffers);
16048 // save level identification information
16049 setString(&snapshot_level_identifier, leveldir_current->identifier);
16050 snapshot_level_nr = level_nr;
16053 boolean CheckSaveEngineSnapshotToList(void)
16055 boolean save_snapshot =
16056 ((game.snapshot.mode == SNAPSHOT_MODE_EVERY_STEP) ||
16057 (game.snapshot.mode == SNAPSHOT_MODE_EVERY_MOVE &&
16058 game.snapshot.changed_action) ||
16059 (game.snapshot.mode == SNAPSHOT_MODE_EVERY_COLLECT &&
16060 game.snapshot.collected_item));
16062 game.snapshot.changed_action = FALSE;
16063 game.snapshot.collected_item = FALSE;
16064 game.snapshot.save_snapshot = save_snapshot;
16066 return save_snapshot;
16069 void SaveEngineSnapshotToList(void)
16071 if (game.snapshot.mode == SNAPSHOT_MODE_OFF ||
16075 ListNode *buffers = SaveEngineSnapshotBuffers();
16077 // finally save all snapshot buffers to snapshot list
16078 SaveSnapshotToList(buffers);
16081 void SaveEngineSnapshotToListInitial(void)
16083 FreeEngineSnapshotList();
16085 SaveEngineSnapshotToList();
16088 static void LoadEngineSnapshotValues(void)
16090 // restore special values from snapshot structure
16092 if (level.game_engine_type == GAME_ENGINE_TYPE_RND)
16093 LoadEngineSnapshotValues_RND();
16094 if (level.game_engine_type == GAME_ENGINE_TYPE_EM)
16095 LoadEngineSnapshotValues_EM();
16096 if (level.game_engine_type == GAME_ENGINE_TYPE_SP)
16097 LoadEngineSnapshotValues_SP();
16098 if (level.game_engine_type == GAME_ENGINE_TYPE_MM)
16099 LoadEngineSnapshotValues_MM();
16102 void LoadEngineSnapshotSingle(void)
16104 LoadSnapshotSingle();
16106 LoadEngineSnapshotValues();
16109 static void LoadEngineSnapshot_Undo(int steps)
16111 LoadSnapshotFromList_Older(steps);
16113 LoadEngineSnapshotValues();
16116 static void LoadEngineSnapshot_Redo(int steps)
16118 LoadSnapshotFromList_Newer(steps);
16120 LoadEngineSnapshotValues();
16123 boolean CheckEngineSnapshotSingle(void)
16125 return (strEqual(snapshot_level_identifier, leveldir_current->identifier) &&
16126 snapshot_level_nr == level_nr);
16129 boolean CheckEngineSnapshotList(void)
16131 return CheckSnapshotList();
16135 // ---------- new game button stuff -------------------------------------------
16142 boolean *setup_value;
16143 boolean allowed_on_tape;
16144 boolean is_touch_button;
16146 } gamebutton_info[NUM_GAME_BUTTONS] =
16149 IMG_GFX_GAME_BUTTON_STOP, &game.button.stop,
16150 GAME_CTRL_ID_STOP, NULL,
16151 TRUE, FALSE, "stop game"
16154 IMG_GFX_GAME_BUTTON_PAUSE, &game.button.pause,
16155 GAME_CTRL_ID_PAUSE, NULL,
16156 TRUE, FALSE, "pause game"
16159 IMG_GFX_GAME_BUTTON_PLAY, &game.button.play,
16160 GAME_CTRL_ID_PLAY, NULL,
16161 TRUE, FALSE, "play game"
16164 IMG_GFX_GAME_BUTTON_UNDO, &game.button.undo,
16165 GAME_CTRL_ID_UNDO, NULL,
16166 TRUE, FALSE, "undo step"
16169 IMG_GFX_GAME_BUTTON_REDO, &game.button.redo,
16170 GAME_CTRL_ID_REDO, NULL,
16171 TRUE, FALSE, "redo step"
16174 IMG_GFX_GAME_BUTTON_SAVE, &game.button.save,
16175 GAME_CTRL_ID_SAVE, NULL,
16176 TRUE, FALSE, "save game"
16179 IMG_GFX_GAME_BUTTON_PAUSE2, &game.button.pause2,
16180 GAME_CTRL_ID_PAUSE2, NULL,
16181 TRUE, FALSE, "pause game"
16184 IMG_GFX_GAME_BUTTON_LOAD, &game.button.load,
16185 GAME_CTRL_ID_LOAD, NULL,
16186 TRUE, FALSE, "load game"
16189 IMG_GFX_GAME_BUTTON_PANEL_STOP, &game.button.panel_stop,
16190 GAME_CTRL_ID_PANEL_STOP, NULL,
16191 FALSE, FALSE, "stop game"
16194 IMG_GFX_GAME_BUTTON_PANEL_PAUSE, &game.button.panel_pause,
16195 GAME_CTRL_ID_PANEL_PAUSE, NULL,
16196 FALSE, FALSE, "pause game"
16199 IMG_GFX_GAME_BUTTON_PANEL_PLAY, &game.button.panel_play,
16200 GAME_CTRL_ID_PANEL_PLAY, NULL,
16201 FALSE, FALSE, "play game"
16204 IMG_GFX_GAME_BUTTON_TOUCH_STOP, &game.button.touch_stop,
16205 GAME_CTRL_ID_TOUCH_STOP, NULL,
16206 FALSE, TRUE, "stop game"
16209 IMG_GFX_GAME_BUTTON_TOUCH_PAUSE, &game.button.touch_pause,
16210 GAME_CTRL_ID_TOUCH_PAUSE, NULL,
16211 FALSE, TRUE, "pause game"
16214 IMG_GFX_GAME_BUTTON_SOUND_MUSIC, &game.button.sound_music,
16215 SOUND_CTRL_ID_MUSIC, &setup.sound_music,
16216 TRUE, FALSE, "background music on/off"
16219 IMG_GFX_GAME_BUTTON_SOUND_LOOPS, &game.button.sound_loops,
16220 SOUND_CTRL_ID_LOOPS, &setup.sound_loops,
16221 TRUE, FALSE, "sound loops on/off"
16224 IMG_GFX_GAME_BUTTON_SOUND_SIMPLE, &game.button.sound_simple,
16225 SOUND_CTRL_ID_SIMPLE, &setup.sound_simple,
16226 TRUE, FALSE, "normal sounds on/off"
16229 IMG_GFX_GAME_BUTTON_PANEL_SOUND_MUSIC, &game.button.panel_sound_music,
16230 SOUND_CTRL_ID_PANEL_MUSIC, &setup.sound_music,
16231 FALSE, FALSE, "background music on/off"
16234 IMG_GFX_GAME_BUTTON_PANEL_SOUND_LOOPS, &game.button.panel_sound_loops,
16235 SOUND_CTRL_ID_PANEL_LOOPS, &setup.sound_loops,
16236 FALSE, FALSE, "sound loops on/off"
16239 IMG_GFX_GAME_BUTTON_PANEL_SOUND_SIMPLE, &game.button.panel_sound_simple,
16240 SOUND_CTRL_ID_PANEL_SIMPLE, &setup.sound_simple,
16241 FALSE, FALSE, "normal sounds on/off"
16245 void CreateGameButtons(void)
16249 for (i = 0; i < NUM_GAME_BUTTONS; i++)
16251 int graphic = gamebutton_info[i].graphic;
16252 struct GraphicInfo *gfx = &graphic_info[graphic];
16253 struct XY *pos = gamebutton_info[i].pos;
16254 struct GadgetInfo *gi;
16257 unsigned int event_mask;
16258 boolean is_touch_button = gamebutton_info[i].is_touch_button;
16259 boolean allowed_on_tape = gamebutton_info[i].allowed_on_tape;
16260 boolean on_tape = (tape.show_game_buttons && allowed_on_tape);
16261 int base_x = (is_touch_button ? 0 : on_tape ? VX : DX);
16262 int base_y = (is_touch_button ? 0 : on_tape ? VY : DY);
16263 int gd_x = gfx->src_x;
16264 int gd_y = gfx->src_y;
16265 int gd_xp = gfx->src_x + gfx->pressed_xoffset;
16266 int gd_yp = gfx->src_y + gfx->pressed_yoffset;
16267 int gd_xa = gfx->src_x + gfx->active_xoffset;
16268 int gd_ya = gfx->src_y + gfx->active_yoffset;
16269 int gd_xap = gfx->src_x + gfx->active_xoffset + gfx->pressed_xoffset;
16270 int gd_yap = gfx->src_y + gfx->active_yoffset + gfx->pressed_yoffset;
16271 int x = (is_touch_button ? pos->x : GDI_ACTIVE_POS(pos->x));
16272 int y = (is_touch_button ? pos->y : GDI_ACTIVE_POS(pos->y));
16275 if (gfx->bitmap == NULL)
16277 game_gadget[id] = NULL;
16282 if (id == GAME_CTRL_ID_STOP ||
16283 id == GAME_CTRL_ID_PANEL_STOP ||
16284 id == GAME_CTRL_ID_TOUCH_STOP ||
16285 id == GAME_CTRL_ID_PLAY ||
16286 id == GAME_CTRL_ID_PANEL_PLAY ||
16287 id == GAME_CTRL_ID_SAVE ||
16288 id == GAME_CTRL_ID_LOAD)
16290 button_type = GD_TYPE_NORMAL_BUTTON;
16292 event_mask = GD_EVENT_RELEASED;
16294 else if (id == GAME_CTRL_ID_UNDO ||
16295 id == GAME_CTRL_ID_REDO)
16297 button_type = GD_TYPE_NORMAL_BUTTON;
16299 event_mask = GD_EVENT_PRESSED | GD_EVENT_REPEATED;
16303 button_type = GD_TYPE_CHECK_BUTTON;
16304 checked = (gamebutton_info[i].setup_value != NULL ?
16305 *gamebutton_info[i].setup_value : FALSE);
16306 event_mask = GD_EVENT_PRESSED;
16309 gi = CreateGadget(GDI_CUSTOM_ID, id,
16310 GDI_IMAGE_ID, graphic,
16311 GDI_INFO_TEXT, gamebutton_info[i].infotext,
16314 GDI_WIDTH, gfx->width,
16315 GDI_HEIGHT, gfx->height,
16316 GDI_TYPE, button_type,
16317 GDI_STATE, GD_BUTTON_UNPRESSED,
16318 GDI_CHECKED, checked,
16319 GDI_DESIGN_UNPRESSED, gfx->bitmap, gd_x, gd_y,
16320 GDI_DESIGN_PRESSED, gfx->bitmap, gd_xp, gd_yp,
16321 GDI_ALT_DESIGN_UNPRESSED, gfx->bitmap, gd_xa, gd_ya,
16322 GDI_ALT_DESIGN_PRESSED, gfx->bitmap, gd_xap, gd_yap,
16323 GDI_DIRECT_DRAW, FALSE,
16324 GDI_OVERLAY_TOUCH_BUTTON, is_touch_button,
16325 GDI_EVENT_MASK, event_mask,
16326 GDI_CALLBACK_ACTION, HandleGameButtons,
16330 Fail("cannot create gadget");
16332 game_gadget[id] = gi;
16336 void FreeGameButtons(void)
16340 for (i = 0; i < NUM_GAME_BUTTONS; i++)
16341 FreeGadget(game_gadget[i]);
16344 static void UnmapGameButtonsAtSamePosition(int id)
16348 for (i = 0; i < NUM_GAME_BUTTONS; i++)
16350 gamebutton_info[i].pos->x == gamebutton_info[id].pos->x &&
16351 gamebutton_info[i].pos->y == gamebutton_info[id].pos->y)
16352 UnmapGadget(game_gadget[i]);
16355 static void UnmapGameButtonsAtSamePosition_All(void)
16357 if (setup.show_load_save_buttons)
16359 UnmapGameButtonsAtSamePosition(GAME_CTRL_ID_SAVE);
16360 UnmapGameButtonsAtSamePosition(GAME_CTRL_ID_PAUSE2);
16361 UnmapGameButtonsAtSamePosition(GAME_CTRL_ID_LOAD);
16363 else if (setup.show_undo_redo_buttons)
16365 UnmapGameButtonsAtSamePosition(GAME_CTRL_ID_UNDO);
16366 UnmapGameButtonsAtSamePosition(GAME_CTRL_ID_PAUSE2);
16367 UnmapGameButtonsAtSamePosition(GAME_CTRL_ID_REDO);
16371 UnmapGameButtonsAtSamePosition(GAME_CTRL_ID_STOP);
16372 UnmapGameButtonsAtSamePosition(GAME_CTRL_ID_PAUSE);
16373 UnmapGameButtonsAtSamePosition(GAME_CTRL_ID_PLAY);
16375 UnmapGameButtonsAtSamePosition(GAME_CTRL_ID_PANEL_STOP);
16376 UnmapGameButtonsAtSamePosition(GAME_CTRL_ID_PANEL_PAUSE);
16377 UnmapGameButtonsAtSamePosition(GAME_CTRL_ID_PANEL_PLAY);
16381 void MapLoadSaveButtons(void)
16383 UnmapGameButtonsAtSamePosition(GAME_CTRL_ID_LOAD);
16384 UnmapGameButtonsAtSamePosition(GAME_CTRL_ID_SAVE);
16386 MapGadget(game_gadget[GAME_CTRL_ID_LOAD]);
16387 MapGadget(game_gadget[GAME_CTRL_ID_SAVE]);
16390 void MapUndoRedoButtons(void)
16392 UnmapGameButtonsAtSamePosition(GAME_CTRL_ID_UNDO);
16393 UnmapGameButtonsAtSamePosition(GAME_CTRL_ID_REDO);
16395 MapGadget(game_gadget[GAME_CTRL_ID_UNDO]);
16396 MapGadget(game_gadget[GAME_CTRL_ID_REDO]);
16399 void ModifyPauseButtons(void)
16403 GAME_CTRL_ID_PAUSE,
16404 GAME_CTRL_ID_PAUSE2,
16405 GAME_CTRL_ID_PANEL_PAUSE,
16406 GAME_CTRL_ID_TOUCH_PAUSE,
16411 for (i = 0; ids[i] > -1; i++)
16412 ModifyGadget(game_gadget[ids[i]], GDI_CHECKED, tape.pausing, GDI_END);
16415 static void MapGameButtonsExt(boolean on_tape)
16419 for (i = 0; i < NUM_GAME_BUTTONS; i++)
16420 if (!on_tape || gamebutton_info[i].allowed_on_tape)
16421 MapGadget(game_gadget[i]);
16423 UnmapGameButtonsAtSamePosition_All();
16425 RedrawGameButtons();
16428 static void UnmapGameButtonsExt(boolean on_tape)
16432 for (i = 0; i < NUM_GAME_BUTTONS; i++)
16433 if (!on_tape || gamebutton_info[i].allowed_on_tape)
16434 UnmapGadget(game_gadget[i]);
16437 static void RedrawGameButtonsExt(boolean on_tape)
16441 for (i = 0; i < NUM_GAME_BUTTONS; i++)
16442 if (!on_tape || gamebutton_info[i].allowed_on_tape)
16443 RedrawGadget(game_gadget[i]);
16446 static void SetGadgetState(struct GadgetInfo *gi, boolean state)
16451 gi->checked = state;
16454 static void RedrawSoundButtonGadget(int id)
16456 int id2 = (id == SOUND_CTRL_ID_MUSIC ? SOUND_CTRL_ID_PANEL_MUSIC :
16457 id == SOUND_CTRL_ID_LOOPS ? SOUND_CTRL_ID_PANEL_LOOPS :
16458 id == SOUND_CTRL_ID_SIMPLE ? SOUND_CTRL_ID_PANEL_SIMPLE :
16459 id == SOUND_CTRL_ID_PANEL_MUSIC ? SOUND_CTRL_ID_MUSIC :
16460 id == SOUND_CTRL_ID_PANEL_LOOPS ? SOUND_CTRL_ID_LOOPS :
16461 id == SOUND_CTRL_ID_PANEL_SIMPLE ? SOUND_CTRL_ID_SIMPLE :
16464 SetGadgetState(game_gadget[id2], *gamebutton_info[id2].setup_value);
16465 RedrawGadget(game_gadget[id2]);
16468 void MapGameButtons(void)
16470 MapGameButtonsExt(FALSE);
16473 void UnmapGameButtons(void)
16475 UnmapGameButtonsExt(FALSE);
16478 void RedrawGameButtons(void)
16480 RedrawGameButtonsExt(FALSE);
16483 void MapGameButtonsOnTape(void)
16485 MapGameButtonsExt(TRUE);
16488 void UnmapGameButtonsOnTape(void)
16490 UnmapGameButtonsExt(TRUE);
16493 void RedrawGameButtonsOnTape(void)
16495 RedrawGameButtonsExt(TRUE);
16498 static void GameUndoRedoExt(void)
16500 ClearPlayerAction();
16502 tape.pausing = TRUE;
16505 UpdateAndDisplayGameControlValues();
16507 DrawCompleteVideoDisplay();
16508 DrawVideoDisplay(VIDEO_STATE_TIME_ON, TapeTime);
16509 DrawVideoDisplay(VIDEO_STATE_FRAME_ON, FrameCounter);
16510 DrawVideoDisplay(VIDEO_STATE_1STEP(tape.single_step), 0);
16512 ModifyPauseButtons();
16517 static void GameUndo(int steps)
16519 if (!CheckEngineSnapshotList())
16522 int tape_property_bits = tape.property_bits;
16524 LoadEngineSnapshot_Undo(steps);
16526 tape.property_bits |= tape_property_bits | TAPE_PROPERTY_SNAPSHOT;
16531 static void GameRedo(int steps)
16533 if (!CheckEngineSnapshotList())
16536 int tape_property_bits = tape.property_bits;
16538 LoadEngineSnapshot_Redo(steps);
16540 tape.property_bits |= tape_property_bits | TAPE_PROPERTY_SNAPSHOT;
16545 static void HandleGameButtonsExt(int id, int button)
16547 static boolean game_undo_executed = FALSE;
16548 int steps = BUTTON_STEPSIZE(button);
16549 boolean handle_game_buttons =
16550 (game_status == GAME_MODE_PLAYING ||
16551 (game_status == GAME_MODE_MAIN && tape.show_game_buttons));
16553 if (!handle_game_buttons)
16558 case GAME_CTRL_ID_STOP:
16559 case GAME_CTRL_ID_PANEL_STOP:
16560 case GAME_CTRL_ID_TOUCH_STOP:
16561 if (game_status == GAME_MODE_MAIN)
16567 RequestQuitGame(FALSE);
16571 case GAME_CTRL_ID_PAUSE:
16572 case GAME_CTRL_ID_PAUSE2:
16573 case GAME_CTRL_ID_PANEL_PAUSE:
16574 case GAME_CTRL_ID_TOUCH_PAUSE:
16575 if (network.enabled && game_status == GAME_MODE_PLAYING)
16578 SendToServer_ContinuePlaying();
16580 SendToServer_PausePlaying();
16583 TapeTogglePause(TAPE_TOGGLE_MANUAL);
16585 game_undo_executed = FALSE;
16589 case GAME_CTRL_ID_PLAY:
16590 case GAME_CTRL_ID_PANEL_PLAY:
16591 if (game_status == GAME_MODE_MAIN)
16593 StartGameActions(network.enabled, setup.autorecord, level.random_seed);
16595 else if (tape.pausing)
16597 if (network.enabled)
16598 SendToServer_ContinuePlaying();
16600 TapeTogglePause(TAPE_TOGGLE_MANUAL | TAPE_TOGGLE_PLAY_PAUSE);
16604 case GAME_CTRL_ID_UNDO:
16605 // Important: When using "save snapshot when collecting an item" mode,
16606 // load last (current) snapshot for first "undo" after pressing "pause"
16607 // (else the last-but-one snapshot would be loaded, because the snapshot
16608 // pointer already points to the last snapshot when pressing "pause",
16609 // which is fine for "every step/move" mode, but not for "every collect")
16610 if (game.snapshot.mode == SNAPSHOT_MODE_EVERY_COLLECT &&
16611 !game_undo_executed)
16614 game_undo_executed = TRUE;
16619 case GAME_CTRL_ID_REDO:
16623 case GAME_CTRL_ID_SAVE:
16627 case GAME_CTRL_ID_LOAD:
16631 case SOUND_CTRL_ID_MUSIC:
16632 case SOUND_CTRL_ID_PANEL_MUSIC:
16633 if (setup.sound_music)
16635 setup.sound_music = FALSE;
16639 else if (audio.music_available)
16641 setup.sound = setup.sound_music = TRUE;
16643 SetAudioMode(setup.sound);
16645 if (game_status == GAME_MODE_PLAYING)
16649 RedrawSoundButtonGadget(id);
16653 case SOUND_CTRL_ID_LOOPS:
16654 case SOUND_CTRL_ID_PANEL_LOOPS:
16655 if (setup.sound_loops)
16656 setup.sound_loops = FALSE;
16657 else if (audio.loops_available)
16659 setup.sound = setup.sound_loops = TRUE;
16661 SetAudioMode(setup.sound);
16664 RedrawSoundButtonGadget(id);
16668 case SOUND_CTRL_ID_SIMPLE:
16669 case SOUND_CTRL_ID_PANEL_SIMPLE:
16670 if (setup.sound_simple)
16671 setup.sound_simple = FALSE;
16672 else if (audio.sound_available)
16674 setup.sound = setup.sound_simple = TRUE;
16676 SetAudioMode(setup.sound);
16679 RedrawSoundButtonGadget(id);
16688 static void HandleGameButtons(struct GadgetInfo *gi)
16690 HandleGameButtonsExt(gi->custom_id, gi->event.button);
16693 void HandleSoundButtonKeys(Key key)
16695 if (key == setup.shortcut.sound_simple)
16696 ClickOnGadget(game_gadget[SOUND_CTRL_ID_SIMPLE], MB_LEFTBUTTON);
16697 else if (key == setup.shortcut.sound_loops)
16698 ClickOnGadget(game_gadget[SOUND_CTRL_ID_LOOPS], MB_LEFTBUTTON);
16699 else if (key == setup.shortcut.sound_music)
16700 ClickOnGadget(game_gadget[SOUND_CTRL_ID_MUSIC], MB_LEFTBUTTON);