1 // ============================================================================
2 // Rocks'n'Diamonds - McDuffin Strikes Back!
3 // ----------------------------------------------------------------------------
4 // (c) 1995-2014 by Artsoft Entertainment
7 // https://www.artsoft.org/
8 // ----------------------------------------------------------------------------
10 // ============================================================================
12 #include "libgame/libgame.h"
26 #define DEBUG_INIT_PLAYER 1
27 #define DEBUG_PLAYER_ACTIONS 0
30 #define USE_NEW_AMOEBA_CODE FALSE
33 #define USE_QUICKSAND_BD_ROCK_BUGFIX 0
34 #define USE_QUICKSAND_IMPACT_BUGFIX 0
35 #define USE_DELAYED_GFX_REDRAW 0
36 #define USE_NEW_PLAYER_ASSIGNMENTS 1
38 #if USE_DELAYED_GFX_REDRAW
39 #define TEST_DrawLevelField(x, y) \
40 GfxRedraw[x][y] |= GFX_REDRAW_TILE
41 #define TEST_DrawLevelFieldCrumbled(x, y) \
42 GfxRedraw[x][y] |= GFX_REDRAW_TILE_CRUMBLED
43 #define TEST_DrawLevelFieldCrumbledNeighbours(x, y) \
44 GfxRedraw[x][y] |= GFX_REDRAW_TILE_CRUMBLED_NEIGHBOURS
45 #define TEST_DrawTwinkleOnField(x, y) \
46 GfxRedraw[x][y] |= GFX_REDRAW_TILE_TWINKLED
48 #define TEST_DrawLevelField(x, y) \
50 #define TEST_DrawLevelFieldCrumbled(x, y) \
51 DrawLevelFieldCrumbled(x, y)
52 #define TEST_DrawLevelFieldCrumbledNeighbours(x, y) \
53 DrawLevelFieldCrumbledNeighbours(x, y)
54 #define TEST_DrawTwinkleOnField(x, y) \
55 DrawTwinkleOnField(x, y)
65 #define MP_NO_ACTION 0
68 #define MP_DONT_RUN_INTO (MP_MOVING | MP_ACTION)
72 #define SCROLL_GO_ON 1
74 // for Bang()/Explode()
75 #define EX_PHASE_START 0
76 #define EX_TYPE_NONE 0
77 #define EX_TYPE_NORMAL (1 << 0)
78 #define EX_TYPE_CENTER (1 << 1)
79 #define EX_TYPE_BORDER (1 << 2)
80 #define EX_TYPE_CROSS (1 << 3)
81 #define EX_TYPE_DYNA (1 << 4)
82 #define EX_TYPE_SINGLE_TILE (EX_TYPE_CENTER | EX_TYPE_BORDER)
84 #define PANEL_OFF() (game.panel.active == FALSE)
85 #define PANEL_DEACTIVATED(p) ((p)->x < 0 || (p)->y < 0 || PANEL_OFF())
86 #define PANEL_XPOS(p) (DX + ALIGNED_TEXT_XPOS(p))
87 #define PANEL_YPOS(p) (DY + ALIGNED_TEXT_YPOS(p))
89 // game panel display and control definitions
90 #define GAME_PANEL_LEVEL_NUMBER 0
91 #define GAME_PANEL_GEMS 1
92 #define GAME_PANEL_INVENTORY_COUNT 2
93 #define GAME_PANEL_INVENTORY_FIRST_1 3
94 #define GAME_PANEL_INVENTORY_FIRST_2 4
95 #define GAME_PANEL_INVENTORY_FIRST_3 5
96 #define GAME_PANEL_INVENTORY_FIRST_4 6
97 #define GAME_PANEL_INVENTORY_FIRST_5 7
98 #define GAME_PANEL_INVENTORY_FIRST_6 8
99 #define GAME_PANEL_INVENTORY_FIRST_7 9
100 #define GAME_PANEL_INVENTORY_FIRST_8 10
101 #define GAME_PANEL_INVENTORY_LAST_1 11
102 #define GAME_PANEL_INVENTORY_LAST_2 12
103 #define GAME_PANEL_INVENTORY_LAST_3 13
104 #define GAME_PANEL_INVENTORY_LAST_4 14
105 #define GAME_PANEL_INVENTORY_LAST_5 15
106 #define GAME_PANEL_INVENTORY_LAST_6 16
107 #define GAME_PANEL_INVENTORY_LAST_7 17
108 #define GAME_PANEL_INVENTORY_LAST_8 18
109 #define GAME_PANEL_KEY_1 19
110 #define GAME_PANEL_KEY_2 20
111 #define GAME_PANEL_KEY_3 21
112 #define GAME_PANEL_KEY_4 22
113 #define GAME_PANEL_KEY_5 23
114 #define GAME_PANEL_KEY_6 24
115 #define GAME_PANEL_KEY_7 25
116 #define GAME_PANEL_KEY_8 26
117 #define GAME_PANEL_KEY_WHITE 27
118 #define GAME_PANEL_KEY_WHITE_COUNT 28
119 #define GAME_PANEL_SCORE 29
120 #define GAME_PANEL_HIGHSCORE 30
121 #define GAME_PANEL_TIME 31
122 #define GAME_PANEL_TIME_HH 32
123 #define GAME_PANEL_TIME_MM 33
124 #define GAME_PANEL_TIME_SS 34
125 #define GAME_PANEL_TIME_ANIM 35
126 #define GAME_PANEL_HEALTH 36
127 #define GAME_PANEL_HEALTH_ANIM 37
128 #define GAME_PANEL_FRAME 38
129 #define GAME_PANEL_SHIELD_NORMAL 39
130 #define GAME_PANEL_SHIELD_NORMAL_TIME 40
131 #define GAME_PANEL_SHIELD_DEADLY 41
132 #define GAME_PANEL_SHIELD_DEADLY_TIME 42
133 #define GAME_PANEL_EXIT 43
134 #define GAME_PANEL_EMC_MAGIC_BALL 44
135 #define GAME_PANEL_EMC_MAGIC_BALL_SWITCH 45
136 #define GAME_PANEL_LIGHT_SWITCH 46
137 #define GAME_PANEL_LIGHT_SWITCH_TIME 47
138 #define GAME_PANEL_TIMEGATE_SWITCH 48
139 #define GAME_PANEL_TIMEGATE_SWITCH_TIME 49
140 #define GAME_PANEL_SWITCHGATE_SWITCH 50
141 #define GAME_PANEL_EMC_LENSES 51
142 #define GAME_PANEL_EMC_LENSES_TIME 52
143 #define GAME_PANEL_EMC_MAGNIFIER 53
144 #define GAME_PANEL_EMC_MAGNIFIER_TIME 54
145 #define GAME_PANEL_BALLOON_SWITCH 55
146 #define GAME_PANEL_DYNABOMB_NUMBER 56
147 #define GAME_PANEL_DYNABOMB_SIZE 57
148 #define GAME_PANEL_DYNABOMB_POWER 58
149 #define GAME_PANEL_PENGUINS 59
150 #define GAME_PANEL_SOKOBAN_OBJECTS 60
151 #define GAME_PANEL_SOKOBAN_FIELDS 61
152 #define GAME_PANEL_ROBOT_WHEEL 62
153 #define GAME_PANEL_CONVEYOR_BELT_1 63
154 #define GAME_PANEL_CONVEYOR_BELT_2 64
155 #define GAME_PANEL_CONVEYOR_BELT_3 65
156 #define GAME_PANEL_CONVEYOR_BELT_4 66
157 #define GAME_PANEL_CONVEYOR_BELT_1_SWITCH 67
158 #define GAME_PANEL_CONVEYOR_BELT_2_SWITCH 68
159 #define GAME_PANEL_CONVEYOR_BELT_3_SWITCH 69
160 #define GAME_PANEL_CONVEYOR_BELT_4_SWITCH 70
161 #define GAME_PANEL_MAGIC_WALL 71
162 #define GAME_PANEL_MAGIC_WALL_TIME 72
163 #define GAME_PANEL_GRAVITY_STATE 73
164 #define GAME_PANEL_GRAPHIC_1 74
165 #define GAME_PANEL_GRAPHIC_2 75
166 #define GAME_PANEL_GRAPHIC_3 76
167 #define GAME_PANEL_GRAPHIC_4 77
168 #define GAME_PANEL_GRAPHIC_5 78
169 #define GAME_PANEL_GRAPHIC_6 79
170 #define GAME_PANEL_GRAPHIC_7 80
171 #define GAME_PANEL_GRAPHIC_8 81
172 #define GAME_PANEL_ELEMENT_1 82
173 #define GAME_PANEL_ELEMENT_2 83
174 #define GAME_PANEL_ELEMENT_3 84
175 #define GAME_PANEL_ELEMENT_4 85
176 #define GAME_PANEL_ELEMENT_5 86
177 #define GAME_PANEL_ELEMENT_6 87
178 #define GAME_PANEL_ELEMENT_7 88
179 #define GAME_PANEL_ELEMENT_8 89
180 #define GAME_PANEL_ELEMENT_COUNT_1 90
181 #define GAME_PANEL_ELEMENT_COUNT_2 91
182 #define GAME_PANEL_ELEMENT_COUNT_3 92
183 #define GAME_PANEL_ELEMENT_COUNT_4 93
184 #define GAME_PANEL_ELEMENT_COUNT_5 94
185 #define GAME_PANEL_ELEMENT_COUNT_6 95
186 #define GAME_PANEL_ELEMENT_COUNT_7 96
187 #define GAME_PANEL_ELEMENT_COUNT_8 97
188 #define GAME_PANEL_CE_SCORE_1 98
189 #define GAME_PANEL_CE_SCORE_2 99
190 #define GAME_PANEL_CE_SCORE_3 100
191 #define GAME_PANEL_CE_SCORE_4 101
192 #define GAME_PANEL_CE_SCORE_5 102
193 #define GAME_PANEL_CE_SCORE_6 103
194 #define GAME_PANEL_CE_SCORE_7 104
195 #define GAME_PANEL_CE_SCORE_8 105
196 #define GAME_PANEL_CE_SCORE_1_ELEMENT 106
197 #define GAME_PANEL_CE_SCORE_2_ELEMENT 107
198 #define GAME_PANEL_CE_SCORE_3_ELEMENT 108
199 #define GAME_PANEL_CE_SCORE_4_ELEMENT 109
200 #define GAME_PANEL_CE_SCORE_5_ELEMENT 110
201 #define GAME_PANEL_CE_SCORE_6_ELEMENT 111
202 #define GAME_PANEL_CE_SCORE_7_ELEMENT 112
203 #define GAME_PANEL_CE_SCORE_8_ELEMENT 113
204 #define GAME_PANEL_PLAYER_NAME 114
205 #define GAME_PANEL_LEVEL_NAME 115
206 #define GAME_PANEL_LEVEL_AUTHOR 116
208 #define NUM_GAME_PANEL_CONTROLS 117
210 struct GamePanelOrderInfo
216 static struct GamePanelOrderInfo game_panel_order[NUM_GAME_PANEL_CONTROLS];
218 struct GamePanelControlInfo
222 struct TextPosInfo *pos;
225 int graphic, graphic_active;
227 int value, last_value;
228 int frame, last_frame;
233 static struct GamePanelControlInfo game_panel_controls[] =
236 GAME_PANEL_LEVEL_NUMBER,
237 &game.panel.level_number,
246 GAME_PANEL_INVENTORY_COUNT,
247 &game.panel.inventory_count,
251 GAME_PANEL_INVENTORY_FIRST_1,
252 &game.panel.inventory_first[0],
256 GAME_PANEL_INVENTORY_FIRST_2,
257 &game.panel.inventory_first[1],
261 GAME_PANEL_INVENTORY_FIRST_3,
262 &game.panel.inventory_first[2],
266 GAME_PANEL_INVENTORY_FIRST_4,
267 &game.panel.inventory_first[3],
271 GAME_PANEL_INVENTORY_FIRST_5,
272 &game.panel.inventory_first[4],
276 GAME_PANEL_INVENTORY_FIRST_6,
277 &game.panel.inventory_first[5],
281 GAME_PANEL_INVENTORY_FIRST_7,
282 &game.panel.inventory_first[6],
286 GAME_PANEL_INVENTORY_FIRST_8,
287 &game.panel.inventory_first[7],
291 GAME_PANEL_INVENTORY_LAST_1,
292 &game.panel.inventory_last[0],
296 GAME_PANEL_INVENTORY_LAST_2,
297 &game.panel.inventory_last[1],
301 GAME_PANEL_INVENTORY_LAST_3,
302 &game.panel.inventory_last[2],
306 GAME_PANEL_INVENTORY_LAST_4,
307 &game.panel.inventory_last[3],
311 GAME_PANEL_INVENTORY_LAST_5,
312 &game.panel.inventory_last[4],
316 GAME_PANEL_INVENTORY_LAST_6,
317 &game.panel.inventory_last[5],
321 GAME_PANEL_INVENTORY_LAST_7,
322 &game.panel.inventory_last[6],
326 GAME_PANEL_INVENTORY_LAST_8,
327 &game.panel.inventory_last[7],
371 GAME_PANEL_KEY_WHITE,
372 &game.panel.key_white,
376 GAME_PANEL_KEY_WHITE_COUNT,
377 &game.panel.key_white_count,
386 GAME_PANEL_HIGHSCORE,
387 &game.panel.highscore,
411 GAME_PANEL_TIME_ANIM,
412 &game.panel.time_anim,
415 IMG_GFX_GAME_PANEL_TIME_ANIM,
416 IMG_GFX_GAME_PANEL_TIME_ANIM_ACTIVE
424 GAME_PANEL_HEALTH_ANIM,
425 &game.panel.health_anim,
428 IMG_GFX_GAME_PANEL_HEALTH_ANIM,
429 IMG_GFX_GAME_PANEL_HEALTH_ANIM_ACTIVE
437 GAME_PANEL_SHIELD_NORMAL,
438 &game.panel.shield_normal,
442 GAME_PANEL_SHIELD_NORMAL_TIME,
443 &game.panel.shield_normal_time,
447 GAME_PANEL_SHIELD_DEADLY,
448 &game.panel.shield_deadly,
452 GAME_PANEL_SHIELD_DEADLY_TIME,
453 &game.panel.shield_deadly_time,
462 GAME_PANEL_EMC_MAGIC_BALL,
463 &game.panel.emc_magic_ball,
467 GAME_PANEL_EMC_MAGIC_BALL_SWITCH,
468 &game.panel.emc_magic_ball_switch,
472 GAME_PANEL_LIGHT_SWITCH,
473 &game.panel.light_switch,
477 GAME_PANEL_LIGHT_SWITCH_TIME,
478 &game.panel.light_switch_time,
482 GAME_PANEL_TIMEGATE_SWITCH,
483 &game.panel.timegate_switch,
487 GAME_PANEL_TIMEGATE_SWITCH_TIME,
488 &game.panel.timegate_switch_time,
492 GAME_PANEL_SWITCHGATE_SWITCH,
493 &game.panel.switchgate_switch,
497 GAME_PANEL_EMC_LENSES,
498 &game.panel.emc_lenses,
502 GAME_PANEL_EMC_LENSES_TIME,
503 &game.panel.emc_lenses_time,
507 GAME_PANEL_EMC_MAGNIFIER,
508 &game.panel.emc_magnifier,
512 GAME_PANEL_EMC_MAGNIFIER_TIME,
513 &game.panel.emc_magnifier_time,
517 GAME_PANEL_BALLOON_SWITCH,
518 &game.panel.balloon_switch,
522 GAME_PANEL_DYNABOMB_NUMBER,
523 &game.panel.dynabomb_number,
527 GAME_PANEL_DYNABOMB_SIZE,
528 &game.panel.dynabomb_size,
532 GAME_PANEL_DYNABOMB_POWER,
533 &game.panel.dynabomb_power,
538 &game.panel.penguins,
542 GAME_PANEL_SOKOBAN_OBJECTS,
543 &game.panel.sokoban_objects,
547 GAME_PANEL_SOKOBAN_FIELDS,
548 &game.panel.sokoban_fields,
552 GAME_PANEL_ROBOT_WHEEL,
553 &game.panel.robot_wheel,
557 GAME_PANEL_CONVEYOR_BELT_1,
558 &game.panel.conveyor_belt[0],
562 GAME_PANEL_CONVEYOR_BELT_2,
563 &game.panel.conveyor_belt[1],
567 GAME_PANEL_CONVEYOR_BELT_3,
568 &game.panel.conveyor_belt[2],
572 GAME_PANEL_CONVEYOR_BELT_4,
573 &game.panel.conveyor_belt[3],
577 GAME_PANEL_CONVEYOR_BELT_1_SWITCH,
578 &game.panel.conveyor_belt_switch[0],
582 GAME_PANEL_CONVEYOR_BELT_2_SWITCH,
583 &game.panel.conveyor_belt_switch[1],
587 GAME_PANEL_CONVEYOR_BELT_3_SWITCH,
588 &game.panel.conveyor_belt_switch[2],
592 GAME_PANEL_CONVEYOR_BELT_4_SWITCH,
593 &game.panel.conveyor_belt_switch[3],
597 GAME_PANEL_MAGIC_WALL,
598 &game.panel.magic_wall,
602 GAME_PANEL_MAGIC_WALL_TIME,
603 &game.panel.magic_wall_time,
607 GAME_PANEL_GRAVITY_STATE,
608 &game.panel.gravity_state,
612 GAME_PANEL_GRAPHIC_1,
613 &game.panel.graphic[0],
617 GAME_PANEL_GRAPHIC_2,
618 &game.panel.graphic[1],
622 GAME_PANEL_GRAPHIC_3,
623 &game.panel.graphic[2],
627 GAME_PANEL_GRAPHIC_4,
628 &game.panel.graphic[3],
632 GAME_PANEL_GRAPHIC_5,
633 &game.panel.graphic[4],
637 GAME_PANEL_GRAPHIC_6,
638 &game.panel.graphic[5],
642 GAME_PANEL_GRAPHIC_7,
643 &game.panel.graphic[6],
647 GAME_PANEL_GRAPHIC_8,
648 &game.panel.graphic[7],
652 GAME_PANEL_ELEMENT_1,
653 &game.panel.element[0],
657 GAME_PANEL_ELEMENT_2,
658 &game.panel.element[1],
662 GAME_PANEL_ELEMENT_3,
663 &game.panel.element[2],
667 GAME_PANEL_ELEMENT_4,
668 &game.panel.element[3],
672 GAME_PANEL_ELEMENT_5,
673 &game.panel.element[4],
677 GAME_PANEL_ELEMENT_6,
678 &game.panel.element[5],
682 GAME_PANEL_ELEMENT_7,
683 &game.panel.element[6],
687 GAME_PANEL_ELEMENT_8,
688 &game.panel.element[7],
692 GAME_PANEL_ELEMENT_COUNT_1,
693 &game.panel.element_count[0],
697 GAME_PANEL_ELEMENT_COUNT_2,
698 &game.panel.element_count[1],
702 GAME_PANEL_ELEMENT_COUNT_3,
703 &game.panel.element_count[2],
707 GAME_PANEL_ELEMENT_COUNT_4,
708 &game.panel.element_count[3],
712 GAME_PANEL_ELEMENT_COUNT_5,
713 &game.panel.element_count[4],
717 GAME_PANEL_ELEMENT_COUNT_6,
718 &game.panel.element_count[5],
722 GAME_PANEL_ELEMENT_COUNT_7,
723 &game.panel.element_count[6],
727 GAME_PANEL_ELEMENT_COUNT_8,
728 &game.panel.element_count[7],
732 GAME_PANEL_CE_SCORE_1,
733 &game.panel.ce_score[0],
737 GAME_PANEL_CE_SCORE_2,
738 &game.panel.ce_score[1],
742 GAME_PANEL_CE_SCORE_3,
743 &game.panel.ce_score[2],
747 GAME_PANEL_CE_SCORE_4,
748 &game.panel.ce_score[3],
752 GAME_PANEL_CE_SCORE_5,
753 &game.panel.ce_score[4],
757 GAME_PANEL_CE_SCORE_6,
758 &game.panel.ce_score[5],
762 GAME_PANEL_CE_SCORE_7,
763 &game.panel.ce_score[6],
767 GAME_PANEL_CE_SCORE_8,
768 &game.panel.ce_score[7],
772 GAME_PANEL_CE_SCORE_1_ELEMENT,
773 &game.panel.ce_score_element[0],
777 GAME_PANEL_CE_SCORE_2_ELEMENT,
778 &game.panel.ce_score_element[1],
782 GAME_PANEL_CE_SCORE_3_ELEMENT,
783 &game.panel.ce_score_element[2],
787 GAME_PANEL_CE_SCORE_4_ELEMENT,
788 &game.panel.ce_score_element[3],
792 GAME_PANEL_CE_SCORE_5_ELEMENT,
793 &game.panel.ce_score_element[4],
797 GAME_PANEL_CE_SCORE_6_ELEMENT,
798 &game.panel.ce_score_element[5],
802 GAME_PANEL_CE_SCORE_7_ELEMENT,
803 &game.panel.ce_score_element[6],
807 GAME_PANEL_CE_SCORE_8_ELEMENT,
808 &game.panel.ce_score_element[7],
812 GAME_PANEL_PLAYER_NAME,
813 &game.panel.player_name,
817 GAME_PANEL_LEVEL_NAME,
818 &game.panel.level_name,
822 GAME_PANEL_LEVEL_AUTHOR,
823 &game.panel.level_author,
834 // values for delayed check of falling and moving elements and for collision
835 #define CHECK_DELAY_MOVING 3
836 #define CHECK_DELAY_FALLING CHECK_DELAY_MOVING
837 #define CHECK_DELAY_COLLISION 2
838 #define CHECK_DELAY_IMPACT CHECK_DELAY_COLLISION
840 // values for initial player move delay (initial delay counter value)
841 #define INITIAL_MOVE_DELAY_OFF -1
842 #define INITIAL_MOVE_DELAY_ON 0
844 // values for player movement speed (which is in fact a delay value)
845 #define MOVE_DELAY_MIN_SPEED 32
846 #define MOVE_DELAY_NORMAL_SPEED 8
847 #define MOVE_DELAY_HIGH_SPEED 4
848 #define MOVE_DELAY_MAX_SPEED 1
850 #define DOUBLE_MOVE_DELAY(x) (x = (x < MOVE_DELAY_MIN_SPEED ? x * 2 : x))
851 #define HALVE_MOVE_DELAY(x) (x = (x > MOVE_DELAY_MAX_SPEED ? x / 2 : x))
853 #define DOUBLE_PLAYER_SPEED(p) (HALVE_MOVE_DELAY( (p)->move_delay_value))
854 #define HALVE_PLAYER_SPEED(p) (DOUBLE_MOVE_DELAY((p)->move_delay_value))
856 // values for scroll positions
857 #define SCROLL_POSITION_X(x) ((x) < SBX_Left + MIDPOSX ? SBX_Left : \
858 (x) > SBX_Right + MIDPOSX ? SBX_Right :\
860 #define SCROLL_POSITION_Y(y) ((y) < SBY_Upper + MIDPOSY ? SBY_Upper :\
861 (y) > SBY_Lower + MIDPOSY ? SBY_Lower :\
864 // values for other actions
865 #define MOVE_STEPSIZE_NORMAL (TILEX / MOVE_DELAY_NORMAL_SPEED)
866 #define MOVE_STEPSIZE_MIN (1)
867 #define MOVE_STEPSIZE_MAX (TILEX)
869 #define GET_DX_FROM_DIR(d) ((d) == MV_LEFT ? -1 : (d) == MV_RIGHT ? 1 : 0)
870 #define GET_DY_FROM_DIR(d) ((d) == MV_UP ? -1 : (d) == MV_DOWN ? 1 : 0)
872 #define INIT_GFX_RANDOM() (GetSimpleRandom(1000000))
874 #define GET_NEW_PUSH_DELAY(e) ( (element_info[e].push_delay_fixed) + \
875 RND(element_info[e].push_delay_random))
876 #define GET_NEW_DROP_DELAY(e) ( (element_info[e].drop_delay_fixed) + \
877 RND(element_info[e].drop_delay_random))
878 #define GET_NEW_MOVE_DELAY(e) ( (element_info[e].move_delay_fixed) + \
879 RND(element_info[e].move_delay_random))
880 #define GET_MAX_MOVE_DELAY(e) ( (element_info[e].move_delay_fixed) + \
881 (element_info[e].move_delay_random))
882 #define GET_NEW_STEP_DELAY(e) ( (element_info[e].step_delay_fixed) + \
883 RND(element_info[e].step_delay_random))
884 #define GET_MAX_STEP_DELAY(e) ( (element_info[e].step_delay_fixed) + \
885 (element_info[e].step_delay_random))
886 #define GET_NEW_CE_VALUE(e) ( (element_info[e].ce_value_fixed_initial) +\
887 RND(element_info[e].ce_value_random_initial))
888 #define GET_CE_SCORE(e) ( (element_info[e].collect_score))
889 #define GET_CHANGE_DELAY(c) ( ((c)->delay_fixed * (c)->delay_frames) + \
890 RND((c)->delay_random * (c)->delay_frames))
891 #define GET_CE_DELAY_VALUE(c) ( ((c)->delay_fixed) + \
892 RND((c)->delay_random))
895 #define GET_VALID_RUNTIME_ELEMENT(e) \
896 ((e) >= NUM_RUNTIME_ELEMENTS ? EL_UNKNOWN : (e))
898 #define RESOLVED_REFERENCE_ELEMENT(be, e) \
899 ((be) + (e) - EL_SELF < EL_CUSTOM_START ? EL_CUSTOM_START : \
900 (be) + (e) - EL_SELF > EL_CUSTOM_END ? EL_CUSTOM_END : \
901 (be) + (e) - EL_SELF)
903 #define GET_PLAYER_FROM_BITS(p) \
904 (EL_PLAYER_1 + ((p) != PLAYER_BITS_ANY ? log_2(p) : 0))
906 #define GET_TARGET_ELEMENT(be, e, ch, cv, cs) \
907 ((e) == EL_TRIGGER_PLAYER ? (ch)->actual_trigger_player : \
908 (e) == EL_TRIGGER_ELEMENT ? (ch)->actual_trigger_element : \
909 (e) == EL_TRIGGER_CE_VALUE ? (ch)->actual_trigger_ce_value : \
910 (e) == EL_TRIGGER_CE_SCORE ? (ch)->actual_trigger_ce_score : \
911 (e) == EL_CURRENT_CE_VALUE ? (cv) : \
912 (e) == EL_CURRENT_CE_SCORE ? (cs) : \
913 (e) >= EL_PREV_CE_8 && (e) <= EL_NEXT_CE_8 ? \
914 RESOLVED_REFERENCE_ELEMENT(be, e) : \
917 #define CAN_GROW_INTO(e) \
918 ((e) == EL_SAND || (IS_DIGGABLE(e) && level.grow_into_diggable))
920 #define ELEMENT_CAN_ENTER_FIELD_BASE_X(x, y, condition) \
921 (IN_LEV_FIELD(x, y) && (IS_FREE(x, y) || \
924 #define ELEMENT_CAN_ENTER_FIELD_BASE_2(e, x, y, condition) \
925 (IN_LEV_FIELD(x, y) && (IS_FREE(x, y) || \
926 (CAN_MOVE_INTO_ACID(e) && \
927 Tile[x][y] == EL_ACID) || \
930 #define ELEMENT_CAN_ENTER_FIELD_BASE_3(e, x, y, condition) \
931 (IN_LEV_FIELD(x, y) && (IS_FREE_OR_PLAYER(x, y) || \
932 (CAN_MOVE_INTO_ACID(e) && \
933 Tile[x][y] == EL_ACID) || \
936 #define ELEMENT_CAN_ENTER_FIELD_BASE_4(e, x, y, condition) \
937 (IN_LEV_FIELD(x, y) && (IS_FREE(x, y) || \
939 (CAN_MOVE_INTO_ACID(e) && \
940 Tile[x][y] == EL_ACID) || \
941 (DONT_COLLIDE_WITH(e) && \
943 !PLAYER_ENEMY_PROTECTED(x, y))))
945 #define ELEMENT_CAN_ENTER_FIELD(e, x, y) \
946 ELEMENT_CAN_ENTER_FIELD_BASE_4(e, x, y, 0)
948 #define SATELLITE_CAN_ENTER_FIELD(x, y) \
949 ELEMENT_CAN_ENTER_FIELD_BASE_2(EL_SATELLITE, x, y, 0)
951 #define ANDROID_CAN_ENTER_FIELD(e, x, y) \
952 ELEMENT_CAN_ENTER_FIELD_BASE_2(e, x, y, Tile[x][y] == EL_EMC_PLANT)
954 #define ANDROID_CAN_CLONE_FIELD(x, y) \
955 (IN_LEV_FIELD(x, y) && (CAN_BE_CLONED_BY_ANDROID(Tile[x][y]) || \
956 CAN_BE_CLONED_BY_ANDROID(EL_TRIGGER_ELEMENT)))
958 #define ENEMY_CAN_ENTER_FIELD(e, x, y) \
959 ELEMENT_CAN_ENTER_FIELD_BASE_2(e, x, y, 0)
961 #define YAMYAM_CAN_ENTER_FIELD(e, x, y) \
962 ELEMENT_CAN_ENTER_FIELD_BASE_3(e, x, y, Tile[x][y] == EL_DIAMOND)
964 #define DARK_YAMYAM_CAN_ENTER_FIELD(e, x, y) \
965 ELEMENT_CAN_ENTER_FIELD_BASE_3(e, x,y, IS_FOOD_DARK_YAMYAM(Tile[x][y]))
967 #define PACMAN_CAN_ENTER_FIELD(e, x, y) \
968 ELEMENT_CAN_ENTER_FIELD_BASE_3(e, x, y, IS_AMOEBOID(Tile[x][y]))
970 #define PIG_CAN_ENTER_FIELD(e, x, y) \
971 ELEMENT_CAN_ENTER_FIELD_BASE_2(e, x, y, IS_FOOD_PIG(Tile[x][y]))
973 #define PENGUIN_CAN_ENTER_FIELD(e, x, y) \
974 ELEMENT_CAN_ENTER_FIELD_BASE_2(e, x, y, (Tile[x][y] == EL_EXIT_OPEN || \
975 Tile[x][y] == EL_EM_EXIT_OPEN || \
976 Tile[x][y] == EL_STEEL_EXIT_OPEN || \
977 Tile[x][y] == EL_EM_STEEL_EXIT_OPEN || \
978 IS_FOOD_PENGUIN(Tile[x][y])))
979 #define DRAGON_CAN_ENTER_FIELD(e, x, y) \
980 ELEMENT_CAN_ENTER_FIELD_BASE_2(e, x, y, 0)
982 #define MOLE_CAN_ENTER_FIELD(e, x, y, condition) \
983 ELEMENT_CAN_ENTER_FIELD_BASE_2(e, x, y, (condition))
985 #define SPRING_CAN_ENTER_FIELD(e, x, y) \
986 ELEMENT_CAN_ENTER_FIELD_BASE_2(e, x, y, 0)
988 #define SPRING_CAN_BUMP_FROM_FIELD(x, y) \
989 (IN_LEV_FIELD(x, y) && (Tile[x][y] == EL_EMC_SPRING_BUMPER || \
990 Tile[x][y] == EL_EMC_SPRING_BUMPER_ACTIVE))
992 #define MOVE_ENTER_EL(e) (element_info[e].move_enter_element)
994 #define CE_ENTER_FIELD_COND(e, x, y) \
995 (!IS_PLAYER(x, y) && \
996 IS_EQUAL_OR_IN_GROUP(Tile[x][y], MOVE_ENTER_EL(e)))
998 #define CUSTOM_ELEMENT_CAN_ENTER_FIELD(e, x, y) \
999 ELEMENT_CAN_ENTER_FIELD_BASE_4(e, x, y, CE_ENTER_FIELD_COND(e, x, y))
1001 #define IN_LEV_FIELD_AND_IS_FREE(x, y) (IN_LEV_FIELD(x, y) && IS_FREE(x, y))
1002 #define IN_LEV_FIELD_AND_NOT_FREE(x, y) (IN_LEV_FIELD(x, y) && !IS_FREE(x, y))
1004 #define ACCESS_FROM(e, d) (element_info[e].access_direction &(d))
1005 #define IS_WALKABLE_FROM(e, d) (IS_WALKABLE(e) && ACCESS_FROM(e, d))
1006 #define IS_PASSABLE_FROM(e, d) (IS_PASSABLE(e) && ACCESS_FROM(e, d))
1007 #define IS_ACCESSIBLE_FROM(e, d) (IS_ACCESSIBLE(e) && ACCESS_FROM(e, d))
1009 #define MM_HEALTH(x) (MIN(MAX(0, MAX_HEALTH - (x)), MAX_HEALTH))
1011 // game button identifiers
1012 #define GAME_CTRL_ID_STOP 0
1013 #define GAME_CTRL_ID_PAUSE 1
1014 #define GAME_CTRL_ID_PLAY 2
1015 #define GAME_CTRL_ID_UNDO 3
1016 #define GAME_CTRL_ID_REDO 4
1017 #define GAME_CTRL_ID_SAVE 5
1018 #define GAME_CTRL_ID_PAUSE2 6
1019 #define GAME_CTRL_ID_LOAD 7
1020 #define GAME_CTRL_ID_PANEL_STOP 8
1021 #define GAME_CTRL_ID_PANEL_PAUSE 9
1022 #define GAME_CTRL_ID_PANEL_PLAY 10
1023 #define GAME_CTRL_ID_TOUCH_STOP 11
1024 #define GAME_CTRL_ID_TOUCH_PAUSE 12
1025 #define SOUND_CTRL_ID_MUSIC 13
1026 #define SOUND_CTRL_ID_LOOPS 14
1027 #define SOUND_CTRL_ID_SIMPLE 15
1028 #define SOUND_CTRL_ID_PANEL_MUSIC 16
1029 #define SOUND_CTRL_ID_PANEL_LOOPS 17
1030 #define SOUND_CTRL_ID_PANEL_SIMPLE 18
1032 #define NUM_GAME_BUTTONS 19
1035 // forward declaration for internal use
1037 static void CreateField(int, int, int);
1039 static void ResetGfxAnimation(int, int);
1041 static void SetPlayerWaiting(struct PlayerInfo *, boolean);
1042 static void AdvanceFrameAndPlayerCounters(int);
1044 static boolean MovePlayerOneStep(struct PlayerInfo *, int, int, int, int);
1045 static boolean MovePlayer(struct PlayerInfo *, int, int);
1046 static void ScrollPlayer(struct PlayerInfo *, int);
1047 static void ScrollScreen(struct PlayerInfo *, int);
1049 static int DigField(struct PlayerInfo *, int, int, int, int, int, int, int);
1050 static boolean DigFieldByCE(int, int, int);
1051 static boolean SnapField(struct PlayerInfo *, int, int);
1052 static boolean DropElement(struct PlayerInfo *);
1054 static void InitBeltMovement(void);
1055 static void CloseAllOpenTimegates(void);
1056 static void CheckGravityMovement(struct PlayerInfo *);
1057 static void CheckGravityMovementWhenNotMoving(struct PlayerInfo *);
1058 static void KillPlayerUnlessEnemyProtected(int, int);
1059 static void KillPlayerUnlessExplosionProtected(int, int);
1061 static void TestIfPlayerTouchesCustomElement(int, int);
1062 static void TestIfElementTouchesCustomElement(int, int);
1063 static void TestIfElementHitsCustomElement(int, int, int);
1065 static void HandleElementChange(int, int, int);
1066 static void ExecuteCustomElementAction(int, int, int, int);
1067 static boolean ChangeElement(int, int, int, int);
1069 static boolean CheckTriggeredElementChangeExt(int, int, int, int, int,int,int);
1070 #define CheckTriggeredElementChange(x, y, e, ev) \
1071 CheckTriggeredElementChangeExt(x,y,e,ev, CH_PLAYER_ANY,CH_SIDE_ANY, -1)
1072 #define CheckTriggeredElementChangeByPlayer(x, y, e, ev, p, s) \
1073 CheckTriggeredElementChangeExt(x, y, e, ev, p, s, -1)
1074 #define CheckTriggeredElementChangeBySide(x, y, e, ev, s) \
1075 CheckTriggeredElementChangeExt(x, y, e, ev, CH_PLAYER_ANY, s, -1)
1076 #define CheckTriggeredElementChangeByPage(x, y, e, ev, p) \
1077 CheckTriggeredElementChangeExt(x,y,e,ev, CH_PLAYER_ANY, CH_SIDE_ANY, p)
1078 #define CheckTriggeredElementChangeByMouse(x, y, e, ev, s) \
1079 CheckTriggeredElementChangeExt(x, y, e, ev, CH_PLAYER_ANY, s, -1)
1081 static boolean CheckElementChangeExt(int, int, int, int, int, int, int);
1082 #define CheckElementChange(x, y, e, te, ev) \
1083 CheckElementChangeExt(x, y, e, te, ev, CH_PLAYER_ANY, CH_SIDE_ANY)
1084 #define CheckElementChangeByPlayer(x, y, e, ev, p, s) \
1085 CheckElementChangeExt(x, y, e, EL_EMPTY, ev, p, s)
1086 #define CheckElementChangeBySide(x, y, e, te, ev, s) \
1087 CheckElementChangeExt(x, y, e, te, ev, CH_PLAYER_ANY, s)
1088 #define CheckElementChangeByMouse(x, y, e, ev, s) \
1089 CheckElementChangeExt(x, y, e, EL_UNDEFINED, ev, CH_PLAYER_ANY, s)
1091 static void PlayLevelSound(int, int, int);
1092 static void PlayLevelSoundNearest(int, int, int);
1093 static void PlayLevelSoundAction(int, int, int);
1094 static void PlayLevelSoundElementAction(int, int, int, int);
1095 static void PlayLevelSoundElementActionIfLoop(int, int, int, int);
1096 static void PlayLevelSoundActionIfLoop(int, int, int);
1097 static void StopLevelSoundActionIfLoop(int, int, int);
1098 static void PlayLevelMusic(void);
1099 static void FadeLevelSoundsAndMusic(void);
1101 static void HandleGameButtons(struct GadgetInfo *);
1103 int AmoebaNeighbourNr(int, int);
1104 void AmoebaToDiamond(int, int);
1105 void ContinueMoving(int, int);
1106 void Bang(int, int);
1107 void InitMovDir(int, int);
1108 void InitAmoebaNr(int, int);
1109 int NewHiScore(int);
1111 void TestIfGoodThingHitsBadThing(int, int, int);
1112 void TestIfBadThingHitsGoodThing(int, int, int);
1113 void TestIfPlayerTouchesBadThing(int, int);
1114 void TestIfPlayerRunsIntoBadThing(int, int, int);
1115 void TestIfBadThingTouchesPlayer(int, int);
1116 void TestIfBadThingRunsIntoPlayer(int, int, int);
1117 void TestIfFriendTouchesBadThing(int, int);
1118 void TestIfBadThingTouchesFriend(int, int);
1119 void TestIfBadThingTouchesOtherBadThing(int, int);
1120 void TestIfGoodThingGetsHitByBadThing(int, int, int);
1122 void KillPlayer(struct PlayerInfo *);
1123 void BuryPlayer(struct PlayerInfo *);
1124 void RemovePlayer(struct PlayerInfo *);
1125 void ExitPlayer(struct PlayerInfo *);
1127 static int getInvisibleActiveFromInvisibleElement(int);
1128 static int getInvisibleFromInvisibleActiveElement(int);
1130 static void TestFieldAfterSnapping(int, int, int, int, int);
1132 static struct GadgetInfo *game_gadget[NUM_GAME_BUTTONS];
1134 // for detection of endless loops, caused by custom element programming
1135 // (using maximal playfield width x 10 is just a rough approximation)
1136 #define MAX_ELEMENT_CHANGE_RECURSION_DEPTH (MAX_PLAYFIELD_WIDTH * 10)
1138 #define RECURSION_LOOP_DETECTION_START(e, rc) \
1140 if (recursion_loop_detected) \
1143 if (recursion_loop_depth > MAX_ELEMENT_CHANGE_RECURSION_DEPTH) \
1145 recursion_loop_detected = TRUE; \
1146 recursion_loop_element = (e); \
1149 recursion_loop_depth++; \
1152 #define RECURSION_LOOP_DETECTION_END() \
1154 recursion_loop_depth--; \
1157 static int recursion_loop_depth;
1158 static boolean recursion_loop_detected;
1159 static boolean recursion_loop_element;
1161 static int map_player_action[MAX_PLAYERS];
1164 // ----------------------------------------------------------------------------
1165 // definition of elements that automatically change to other elements after
1166 // a specified time, eventually calling a function when changing
1167 // ----------------------------------------------------------------------------
1169 // forward declaration for changer functions
1170 static void InitBuggyBase(int, int);
1171 static void WarnBuggyBase(int, int);
1173 static void InitTrap(int, int);
1174 static void ActivateTrap(int, int);
1175 static void ChangeActiveTrap(int, int);
1177 static void InitRobotWheel(int, int);
1178 static void RunRobotWheel(int, int);
1179 static void StopRobotWheel(int, int);
1181 static void InitTimegateWheel(int, int);
1182 static void RunTimegateWheel(int, int);
1184 static void InitMagicBallDelay(int, int);
1185 static void ActivateMagicBall(int, int);
1187 struct ChangingElementInfo
1192 void (*pre_change_function)(int x, int y);
1193 void (*change_function)(int x, int y);
1194 void (*post_change_function)(int x, int y);
1197 static struct ChangingElementInfo change_delay_list[] =
1232 EL_STEEL_EXIT_OPENING,
1240 EL_STEEL_EXIT_CLOSING,
1241 EL_STEEL_EXIT_CLOSED,
1264 EL_EM_STEEL_EXIT_OPENING,
1265 EL_EM_STEEL_EXIT_OPEN,
1272 EL_EM_STEEL_EXIT_CLOSING,
1296 EL_SWITCHGATE_OPENING,
1304 EL_SWITCHGATE_CLOSING,
1305 EL_SWITCHGATE_CLOSED,
1312 EL_TIMEGATE_OPENING,
1320 EL_TIMEGATE_CLOSING,
1329 EL_ACID_SPLASH_LEFT,
1337 EL_ACID_SPLASH_RIGHT,
1346 EL_SP_BUGGY_BASE_ACTIVATING,
1353 EL_SP_BUGGY_BASE_ACTIVATING,
1354 EL_SP_BUGGY_BASE_ACTIVE,
1361 EL_SP_BUGGY_BASE_ACTIVE,
1385 EL_ROBOT_WHEEL_ACTIVE,
1393 EL_TIMEGATE_SWITCH_ACTIVE,
1401 EL_DC_TIMEGATE_SWITCH_ACTIVE,
1402 EL_DC_TIMEGATE_SWITCH,
1409 EL_EMC_MAGIC_BALL_ACTIVE,
1410 EL_EMC_MAGIC_BALL_ACTIVE,
1417 EL_EMC_SPRING_BUMPER_ACTIVE,
1418 EL_EMC_SPRING_BUMPER,
1425 EL_DIAGONAL_SHRINKING,
1433 EL_DIAGONAL_GROWING,
1454 int push_delay_fixed, push_delay_random;
1458 { EL_SPRING, 0, 0 },
1459 { EL_BALLOON, 0, 0 },
1461 { EL_SOKOBAN_OBJECT, 2, 0 },
1462 { EL_SOKOBAN_FIELD_FULL, 2, 0 },
1463 { EL_SATELLITE, 2, 0 },
1464 { EL_SP_DISK_YELLOW, 2, 0 },
1466 { EL_UNDEFINED, 0, 0 },
1474 move_stepsize_list[] =
1476 { EL_AMOEBA_DROP, 2 },
1477 { EL_AMOEBA_DROPPING, 2 },
1478 { EL_QUICKSAND_FILLING, 1 },
1479 { EL_QUICKSAND_EMPTYING, 1 },
1480 { EL_QUICKSAND_FAST_FILLING, 2 },
1481 { EL_QUICKSAND_FAST_EMPTYING, 2 },
1482 { EL_MAGIC_WALL_FILLING, 2 },
1483 { EL_MAGIC_WALL_EMPTYING, 2 },
1484 { EL_BD_MAGIC_WALL_FILLING, 2 },
1485 { EL_BD_MAGIC_WALL_EMPTYING, 2 },
1486 { EL_DC_MAGIC_WALL_FILLING, 2 },
1487 { EL_DC_MAGIC_WALL_EMPTYING, 2 },
1489 { EL_UNDEFINED, 0 },
1497 collect_count_list[] =
1500 { EL_BD_DIAMOND, 1 },
1501 { EL_EMERALD_YELLOW, 1 },
1502 { EL_EMERALD_RED, 1 },
1503 { EL_EMERALD_PURPLE, 1 },
1505 { EL_SP_INFOTRON, 1 },
1509 { EL_UNDEFINED, 0 },
1517 access_direction_list[] =
1519 { EL_TUBE_ANY, MV_LEFT | MV_RIGHT | MV_UP | MV_DOWN },
1520 { EL_TUBE_VERTICAL, MV_UP | MV_DOWN },
1521 { EL_TUBE_HORIZONTAL, MV_LEFT | MV_RIGHT },
1522 { EL_TUBE_VERTICAL_LEFT, MV_LEFT | MV_UP | MV_DOWN },
1523 { EL_TUBE_VERTICAL_RIGHT, MV_RIGHT | MV_UP | MV_DOWN },
1524 { EL_TUBE_HORIZONTAL_UP, MV_LEFT | MV_RIGHT | MV_UP },
1525 { EL_TUBE_HORIZONTAL_DOWN, MV_LEFT | MV_RIGHT | MV_DOWN },
1526 { EL_TUBE_LEFT_UP, MV_LEFT | MV_UP },
1527 { EL_TUBE_LEFT_DOWN, MV_LEFT | MV_DOWN },
1528 { EL_TUBE_RIGHT_UP, MV_RIGHT | MV_UP },
1529 { EL_TUBE_RIGHT_DOWN, MV_RIGHT | MV_DOWN },
1531 { EL_SP_PORT_LEFT, MV_RIGHT },
1532 { EL_SP_PORT_RIGHT, MV_LEFT },
1533 { EL_SP_PORT_UP, MV_DOWN },
1534 { EL_SP_PORT_DOWN, MV_UP },
1535 { EL_SP_PORT_HORIZONTAL, MV_LEFT | MV_RIGHT },
1536 { EL_SP_PORT_VERTICAL, MV_UP | MV_DOWN },
1537 { EL_SP_PORT_ANY, MV_LEFT | MV_RIGHT | MV_UP | MV_DOWN },
1538 { EL_SP_GRAVITY_PORT_LEFT, MV_RIGHT },
1539 { EL_SP_GRAVITY_PORT_RIGHT, MV_LEFT },
1540 { EL_SP_GRAVITY_PORT_UP, MV_DOWN },
1541 { EL_SP_GRAVITY_PORT_DOWN, MV_UP },
1542 { EL_SP_GRAVITY_ON_PORT_LEFT, MV_RIGHT },
1543 { EL_SP_GRAVITY_ON_PORT_RIGHT, MV_LEFT },
1544 { EL_SP_GRAVITY_ON_PORT_UP, MV_DOWN },
1545 { EL_SP_GRAVITY_ON_PORT_DOWN, MV_UP },
1546 { EL_SP_GRAVITY_OFF_PORT_LEFT, MV_RIGHT },
1547 { EL_SP_GRAVITY_OFF_PORT_RIGHT, MV_LEFT },
1548 { EL_SP_GRAVITY_OFF_PORT_UP, MV_DOWN },
1549 { EL_SP_GRAVITY_OFF_PORT_DOWN, MV_UP },
1551 { EL_UNDEFINED, MV_NONE }
1554 static boolean trigger_events[MAX_NUM_ELEMENTS][NUM_CHANGE_EVENTS];
1556 #define IS_AUTO_CHANGING(e) (element_info[e].has_change_event[CE_DELAY])
1557 #define IS_JUST_CHANGING(x, y) (ChangeDelay[x][y] != 0)
1558 #define IS_CHANGING(x, y) (IS_AUTO_CHANGING(Tile[x][y]) || \
1559 IS_JUST_CHANGING(x, y))
1561 #define CE_PAGE(e, ce) (element_info[e].event_page[ce])
1563 // static variables for playfield scan mode (scanning forward or backward)
1564 static int playfield_scan_start_x = 0;
1565 static int playfield_scan_start_y = 0;
1566 static int playfield_scan_delta_x = 1;
1567 static int playfield_scan_delta_y = 1;
1569 #define SCAN_PLAYFIELD(x, y) for ((y) = playfield_scan_start_y; \
1570 (y) >= 0 && (y) <= lev_fieldy - 1; \
1571 (y) += playfield_scan_delta_y) \
1572 for ((x) = playfield_scan_start_x; \
1573 (x) >= 0 && (x) <= lev_fieldx - 1; \
1574 (x) += playfield_scan_delta_x)
1577 void DEBUG_SetMaximumDynamite(void)
1581 for (i = 0; i < MAX_INVENTORY_SIZE; i++)
1582 if (local_player->inventory_size < MAX_INVENTORY_SIZE)
1583 local_player->inventory_element[local_player->inventory_size++] =
1588 static void InitPlayfieldScanModeVars(void)
1590 if (game.use_reverse_scan_direction)
1592 playfield_scan_start_x = lev_fieldx - 1;
1593 playfield_scan_start_y = lev_fieldy - 1;
1595 playfield_scan_delta_x = -1;
1596 playfield_scan_delta_y = -1;
1600 playfield_scan_start_x = 0;
1601 playfield_scan_start_y = 0;
1603 playfield_scan_delta_x = 1;
1604 playfield_scan_delta_y = 1;
1608 static void InitPlayfieldScanMode(int mode)
1610 game.use_reverse_scan_direction =
1611 (mode == CA_ARG_SCAN_MODE_REVERSE ? TRUE : FALSE);
1613 InitPlayfieldScanModeVars();
1616 static int get_move_delay_from_stepsize(int move_stepsize)
1619 MIN(MAX(MOVE_STEPSIZE_MIN, move_stepsize), MOVE_STEPSIZE_MAX);
1621 // make sure that stepsize value is always a power of 2
1622 move_stepsize = (1 << log_2(move_stepsize));
1624 return TILEX / move_stepsize;
1627 static void SetPlayerMoveSpeed(struct PlayerInfo *player, int move_stepsize,
1630 int player_nr = player->index_nr;
1631 int move_delay = get_move_delay_from_stepsize(move_stepsize);
1632 boolean cannot_move = (move_stepsize == STEPSIZE_NOT_MOVING ? TRUE : FALSE);
1634 // do no immediately change move delay -- the player might just be moving
1635 player->move_delay_value_next = move_delay;
1637 // information if player can move must be set separately
1638 player->cannot_move = cannot_move;
1642 player->move_delay = game.initial_move_delay[player_nr];
1643 player->move_delay_value = game.initial_move_delay_value[player_nr];
1645 player->move_delay_value_next = -1;
1647 player->move_delay_reset_counter = 0;
1651 void GetPlayerConfig(void)
1653 GameFrameDelay = setup.game_frame_delay;
1655 if (!audio.sound_available)
1656 setup.sound_simple = FALSE;
1658 if (!audio.loops_available)
1659 setup.sound_loops = FALSE;
1661 if (!audio.music_available)
1662 setup.sound_music = FALSE;
1664 if (!video.fullscreen_available)
1665 setup.fullscreen = FALSE;
1667 setup.sound = (setup.sound_simple || setup.sound_loops || setup.sound_music);
1669 SetAudioMode(setup.sound);
1672 int GetElementFromGroupElement(int element)
1674 if (IS_GROUP_ELEMENT(element))
1676 struct ElementGroupInfo *group = element_info[element].group;
1677 int last_anim_random_frame = gfx.anim_random_frame;
1680 if (group->choice_mode == ANIM_RANDOM)
1681 gfx.anim_random_frame = RND(group->num_elements_resolved);
1683 element_pos = getAnimationFrame(group->num_elements_resolved, 1,
1684 group->choice_mode, 0,
1687 if (group->choice_mode == ANIM_RANDOM)
1688 gfx.anim_random_frame = last_anim_random_frame;
1690 group->choice_pos++;
1692 element = group->element_resolved[element_pos];
1698 static void IncrementSokobanFieldsNeeded(void)
1700 if (level.sb_fields_needed)
1701 game.sokoban_fields_still_needed++;
1704 static void IncrementSokobanObjectsNeeded(void)
1706 if (level.sb_objects_needed)
1707 game.sokoban_objects_still_needed++;
1710 static void DecrementSokobanFieldsNeeded(void)
1712 if (game.sokoban_fields_still_needed > 0)
1713 game.sokoban_fields_still_needed--;
1716 static void DecrementSokobanObjectsNeeded(void)
1718 if (game.sokoban_objects_still_needed > 0)
1719 game.sokoban_objects_still_needed--;
1722 static void InitPlayerField(int x, int y, int element, boolean init_game)
1724 if (element == EL_SP_MURPHY)
1728 if (stored_player[0].present)
1730 Tile[x][y] = EL_SP_MURPHY_CLONE;
1736 stored_player[0].initial_element = element;
1737 stored_player[0].use_murphy = TRUE;
1739 if (!level.use_artwork_element[0])
1740 stored_player[0].artwork_element = EL_SP_MURPHY;
1743 Tile[x][y] = EL_PLAYER_1;
1749 struct PlayerInfo *player = &stored_player[Tile[x][y] - EL_PLAYER_1];
1750 int jx = player->jx, jy = player->jy;
1752 player->present = TRUE;
1754 player->block_last_field = (element == EL_SP_MURPHY ?
1755 level.sp_block_last_field :
1756 level.block_last_field);
1758 // ---------- initialize player's last field block delay ------------------
1760 // always start with reliable default value (no adjustment needed)
1761 player->block_delay_adjustment = 0;
1763 // special case 1: in Supaplex, Murphy blocks last field one more frame
1764 if (player->block_last_field && element == EL_SP_MURPHY)
1765 player->block_delay_adjustment = 1;
1767 // special case 2: in game engines before 3.1.1, blocking was different
1768 if (game.use_block_last_field_bug)
1769 player->block_delay_adjustment = (player->block_last_field ? -1 : 1);
1771 if (!network.enabled || player->connected_network)
1773 player->active = TRUE;
1775 // remove potentially duplicate players
1776 if (StorePlayer[jx][jy] == Tile[x][y])
1777 StorePlayer[jx][jy] = 0;
1779 StorePlayer[x][y] = Tile[x][y];
1781 #if DEBUG_INIT_PLAYER
1782 Debug("game:init:player", "- player element %d activated",
1783 player->element_nr);
1784 Debug("game:init:player", " (local player is %d and currently %s)",
1785 local_player->element_nr,
1786 local_player->active ? "active" : "not active");
1790 Tile[x][y] = EL_EMPTY;
1792 player->jx = player->last_jx = x;
1793 player->jy = player->last_jy = y;
1796 // always check if player was just killed and should be reanimated
1798 int player_nr = GET_PLAYER_NR(element);
1799 struct PlayerInfo *player = &stored_player[player_nr];
1801 if (player->active && player->killed)
1802 player->reanimated = TRUE; // if player was just killed, reanimate him
1806 static void InitField(int x, int y, boolean init_game)
1808 int element = Tile[x][y];
1817 InitPlayerField(x, y, element, init_game);
1820 case EL_SOKOBAN_FIELD_PLAYER:
1821 element = Tile[x][y] = EL_PLAYER_1;
1822 InitField(x, y, init_game);
1824 element = Tile[x][y] = EL_SOKOBAN_FIELD_EMPTY;
1825 InitField(x, y, init_game);
1828 case EL_SOKOBAN_FIELD_EMPTY:
1829 IncrementSokobanFieldsNeeded();
1832 case EL_SOKOBAN_OBJECT:
1833 IncrementSokobanObjectsNeeded();
1837 if (x < lev_fieldx-1 && Tile[x+1][y] == EL_ACID)
1838 Tile[x][y] = EL_ACID_POOL_TOPLEFT;
1839 else if (x > 0 && Tile[x-1][y] == EL_ACID)
1840 Tile[x][y] = EL_ACID_POOL_TOPRIGHT;
1841 else if (y > 0 && Tile[x][y-1] == EL_ACID_POOL_TOPLEFT)
1842 Tile[x][y] = EL_ACID_POOL_BOTTOMLEFT;
1843 else if (y > 0 && Tile[x][y-1] == EL_ACID)
1844 Tile[x][y] = EL_ACID_POOL_BOTTOM;
1845 else if (y > 0 && Tile[x][y-1] == EL_ACID_POOL_TOPRIGHT)
1846 Tile[x][y] = EL_ACID_POOL_BOTTOMRIGHT;
1855 case EL_SPACESHIP_RIGHT:
1856 case EL_SPACESHIP_UP:
1857 case EL_SPACESHIP_LEFT:
1858 case EL_SPACESHIP_DOWN:
1859 case EL_BD_BUTTERFLY:
1860 case EL_BD_BUTTERFLY_RIGHT:
1861 case EL_BD_BUTTERFLY_UP:
1862 case EL_BD_BUTTERFLY_LEFT:
1863 case EL_BD_BUTTERFLY_DOWN:
1865 case EL_BD_FIREFLY_RIGHT:
1866 case EL_BD_FIREFLY_UP:
1867 case EL_BD_FIREFLY_LEFT:
1868 case EL_BD_FIREFLY_DOWN:
1869 case EL_PACMAN_RIGHT:
1871 case EL_PACMAN_LEFT:
1872 case EL_PACMAN_DOWN:
1874 case EL_YAMYAM_LEFT:
1875 case EL_YAMYAM_RIGHT:
1877 case EL_YAMYAM_DOWN:
1878 case EL_DARK_YAMYAM:
1881 case EL_SP_SNIKSNAK:
1882 case EL_SP_ELECTRON:
1888 case EL_SPRING_LEFT:
1889 case EL_SPRING_RIGHT:
1893 case EL_AMOEBA_FULL:
1898 case EL_AMOEBA_DROP:
1899 if (y == lev_fieldy - 1)
1901 Tile[x][y] = EL_AMOEBA_GROWING;
1902 Store[x][y] = EL_AMOEBA_WET;
1906 case EL_DYNAMITE_ACTIVE:
1907 case EL_SP_DISK_RED_ACTIVE:
1908 case EL_DYNABOMB_PLAYER_1_ACTIVE:
1909 case EL_DYNABOMB_PLAYER_2_ACTIVE:
1910 case EL_DYNABOMB_PLAYER_3_ACTIVE:
1911 case EL_DYNABOMB_PLAYER_4_ACTIVE:
1912 MovDelay[x][y] = 96;
1915 case EL_EM_DYNAMITE_ACTIVE:
1916 MovDelay[x][y] = 32;
1920 game.lights_still_needed++;
1924 game.friends_still_needed++;
1929 GfxDir[x][y] = MovDir[x][y] = 1 << RND(4);
1932 case EL_CONVEYOR_BELT_1_SWITCH_LEFT:
1933 case EL_CONVEYOR_BELT_1_SWITCH_MIDDLE:
1934 case EL_CONVEYOR_BELT_1_SWITCH_RIGHT:
1935 case EL_CONVEYOR_BELT_2_SWITCH_LEFT:
1936 case EL_CONVEYOR_BELT_2_SWITCH_MIDDLE:
1937 case EL_CONVEYOR_BELT_2_SWITCH_RIGHT:
1938 case EL_CONVEYOR_BELT_3_SWITCH_LEFT:
1939 case EL_CONVEYOR_BELT_3_SWITCH_MIDDLE:
1940 case EL_CONVEYOR_BELT_3_SWITCH_RIGHT:
1941 case EL_CONVEYOR_BELT_4_SWITCH_LEFT:
1942 case EL_CONVEYOR_BELT_4_SWITCH_MIDDLE:
1943 case EL_CONVEYOR_BELT_4_SWITCH_RIGHT:
1946 int belt_nr = getBeltNrFromBeltSwitchElement(Tile[x][y]);
1947 int belt_dir = getBeltDirFromBeltSwitchElement(Tile[x][y]);
1948 int belt_dir_nr = getBeltDirNrFromBeltSwitchElement(Tile[x][y]);
1950 if (game.belt_dir_nr[belt_nr] == 3) // initial value
1952 game.belt_dir[belt_nr] = belt_dir;
1953 game.belt_dir_nr[belt_nr] = belt_dir_nr;
1955 else // more than one switch -- set it like the first switch
1957 Tile[x][y] = Tile[x][y] - belt_dir_nr + game.belt_dir_nr[belt_nr];
1962 case EL_LIGHT_SWITCH_ACTIVE:
1964 game.light_time_left = level.time_light * FRAMES_PER_SECOND;
1967 case EL_INVISIBLE_STEELWALL:
1968 case EL_INVISIBLE_WALL:
1969 case EL_INVISIBLE_SAND:
1970 if (game.light_time_left > 0 ||
1971 game.lenses_time_left > 0)
1972 Tile[x][y] = getInvisibleActiveFromInvisibleElement(element);
1975 case EL_EMC_MAGIC_BALL:
1976 if (game.ball_active)
1977 Tile[x][y] = EL_EMC_MAGIC_BALL_ACTIVE;
1980 case EL_EMC_MAGIC_BALL_SWITCH:
1981 if (game.ball_active)
1982 Tile[x][y] = EL_EMC_MAGIC_BALL_SWITCH_ACTIVE;
1985 case EL_TRIGGER_PLAYER:
1986 case EL_TRIGGER_ELEMENT:
1987 case EL_TRIGGER_CE_VALUE:
1988 case EL_TRIGGER_CE_SCORE:
1990 case EL_ANY_ELEMENT:
1991 case EL_CURRENT_CE_VALUE:
1992 case EL_CURRENT_CE_SCORE:
2009 // reference elements should not be used on the playfield
2010 Tile[x][y] = EL_EMPTY;
2014 if (IS_CUSTOM_ELEMENT(element))
2016 if (CAN_MOVE(element))
2019 if (!element_info[element].use_last_ce_value || init_game)
2020 CustomValue[x][y] = GET_NEW_CE_VALUE(Tile[x][y]);
2022 else if (IS_GROUP_ELEMENT(element))
2024 Tile[x][y] = GetElementFromGroupElement(element);
2026 InitField(x, y, init_game);
2033 CheckTriggeredElementChange(x, y, element, CE_CREATION_OF_X);
2036 static void InitField_WithBug1(int x, int y, boolean init_game)
2038 InitField(x, y, init_game);
2040 // not needed to call InitMovDir() -- already done by InitField()!
2041 if (game.engine_version < VERSION_IDENT(3,1,0,0) &&
2042 CAN_MOVE(Tile[x][y]))
2046 static void InitField_WithBug2(int x, int y, boolean init_game)
2048 int old_element = Tile[x][y];
2050 InitField(x, y, init_game);
2052 // not needed to call InitMovDir() -- already done by InitField()!
2053 if (game.engine_version < VERSION_IDENT(3,1,0,0) &&
2054 CAN_MOVE(old_element) &&
2055 (old_element < EL_MOLE_LEFT || old_element > EL_MOLE_DOWN))
2058 /* this case is in fact a combination of not less than three bugs:
2059 first, it calls InitMovDir() for elements that can move, although this is
2060 already done by InitField(); then, it checks the element that was at this
2061 field _before_ the call to InitField() (which can change it); lastly, it
2062 was not called for "mole with direction" elements, which were treated as
2063 "cannot move" due to (fixed) wrong element initialization in "src/init.c"
2067 static int get_key_element_from_nr(int key_nr)
2069 int key_base_element = (key_nr >= STD_NUM_KEYS ? EL_EMC_KEY_5 - STD_NUM_KEYS :
2070 level.game_engine_type == GAME_ENGINE_TYPE_EM ?
2071 EL_EM_KEY_1 : EL_KEY_1);
2073 return key_base_element + key_nr;
2076 static int get_next_dropped_element(struct PlayerInfo *player)
2078 return (player->inventory_size > 0 ?
2079 player->inventory_element[player->inventory_size - 1] :
2080 player->inventory_infinite_element != EL_UNDEFINED ?
2081 player->inventory_infinite_element :
2082 player->dynabombs_left > 0 ?
2083 EL_DYNABOMB_PLAYER_1_ACTIVE + player->index_nr :
2087 static int get_inventory_element_from_pos(struct PlayerInfo *player, int pos)
2089 // pos >= 0: get element from bottom of the stack;
2090 // pos < 0: get element from top of the stack
2094 int min_inventory_size = -pos;
2095 int inventory_pos = player->inventory_size - min_inventory_size;
2096 int min_dynabombs_left = min_inventory_size - player->inventory_size;
2098 return (player->inventory_size >= min_inventory_size ?
2099 player->inventory_element[inventory_pos] :
2100 player->inventory_infinite_element != EL_UNDEFINED ?
2101 player->inventory_infinite_element :
2102 player->dynabombs_left >= min_dynabombs_left ?
2103 EL_DYNABOMB_PLAYER_1 + player->index_nr :
2108 int min_dynabombs_left = pos + 1;
2109 int min_inventory_size = pos + 1 - player->dynabombs_left;
2110 int inventory_pos = pos - player->dynabombs_left;
2112 return (player->inventory_infinite_element != EL_UNDEFINED ?
2113 player->inventory_infinite_element :
2114 player->dynabombs_left >= min_dynabombs_left ?
2115 EL_DYNABOMB_PLAYER_1 + player->index_nr :
2116 player->inventory_size >= min_inventory_size ?
2117 player->inventory_element[inventory_pos] :
2122 static int compareGamePanelOrderInfo(const void *object1, const void *object2)
2124 const struct GamePanelOrderInfo *gpo1 = (struct GamePanelOrderInfo *)object1;
2125 const struct GamePanelOrderInfo *gpo2 = (struct GamePanelOrderInfo *)object2;
2128 if (gpo1->sort_priority != gpo2->sort_priority)
2129 compare_result = gpo1->sort_priority - gpo2->sort_priority;
2131 compare_result = gpo1->nr - gpo2->nr;
2133 return compare_result;
2136 int getPlayerInventorySize(int player_nr)
2138 if (level.game_engine_type == GAME_ENGINE_TYPE_EM)
2139 return game_em.ply[player_nr]->dynamite;
2140 else if (level.game_engine_type == GAME_ENGINE_TYPE_SP)
2141 return game_sp.red_disk_count;
2143 return stored_player[player_nr].inventory_size;
2146 static void InitGameControlValues(void)
2150 for (i = 0; game_panel_controls[i].nr != -1; i++)
2152 struct GamePanelControlInfo *gpc = &game_panel_controls[i];
2153 struct GamePanelOrderInfo *gpo = &game_panel_order[i];
2154 struct TextPosInfo *pos = gpc->pos;
2156 int type = gpc->type;
2160 Error("'game_panel_controls' structure corrupted at %d", i);
2162 Fail("this should not happen -- please debug");
2165 // force update of game controls after initialization
2166 gpc->value = gpc->last_value = -1;
2167 gpc->frame = gpc->last_frame = -1;
2168 gpc->gfx_frame = -1;
2170 // determine panel value width for later calculation of alignment
2171 if (type == TYPE_INTEGER || type == TYPE_STRING)
2173 pos->width = pos->size * getFontWidth(pos->font);
2174 pos->height = getFontHeight(pos->font);
2176 else if (type == TYPE_ELEMENT)
2178 pos->width = pos->size;
2179 pos->height = pos->size;
2182 // fill structure for game panel draw order
2184 gpo->sort_priority = pos->sort_priority;
2187 // sort game panel controls according to sort_priority and control number
2188 qsort(game_panel_order, NUM_GAME_PANEL_CONTROLS,
2189 sizeof(struct GamePanelOrderInfo), compareGamePanelOrderInfo);
2192 static void UpdatePlayfieldElementCount(void)
2194 boolean use_element_count = FALSE;
2197 // first check if it is needed at all to calculate playfield element count
2198 for (i = GAME_PANEL_ELEMENT_COUNT_1; i <= GAME_PANEL_ELEMENT_COUNT_8; i++)
2199 if (!PANEL_DEACTIVATED(game_panel_controls[i].pos))
2200 use_element_count = TRUE;
2202 if (!use_element_count)
2205 for (i = 0; i < MAX_NUM_ELEMENTS; i++)
2206 element_info[i].element_count = 0;
2208 SCAN_PLAYFIELD(x, y)
2210 element_info[Tile[x][y]].element_count++;
2213 for (i = 0; i < NUM_GROUP_ELEMENTS; i++)
2214 for (j = 0; j < MAX_NUM_ELEMENTS; j++)
2215 if (IS_IN_GROUP(j, i))
2216 element_info[EL_GROUP_START + i].element_count +=
2217 element_info[j].element_count;
2220 static void UpdateGameControlValues(void)
2223 int time = (game.LevelSolved ?
2224 game.LevelSolved_CountingTime :
2225 level.game_engine_type == GAME_ENGINE_TYPE_EM ?
2227 level.game_engine_type == GAME_ENGINE_TYPE_SP ?
2228 game_sp.time_played :
2229 level.game_engine_type == GAME_ENGINE_TYPE_MM ?
2230 game_mm.energy_left :
2231 game.no_time_limit ? TimePlayed : TimeLeft);
2232 int score = (game.LevelSolved ?
2233 game.LevelSolved_CountingScore :
2234 level.game_engine_type == GAME_ENGINE_TYPE_EM ?
2235 game_em.lev->score :
2236 level.game_engine_type == GAME_ENGINE_TYPE_SP ?
2238 level.game_engine_type == GAME_ENGINE_TYPE_MM ?
2241 int gems = (level.game_engine_type == GAME_ENGINE_TYPE_EM ?
2242 game_em.lev->gems_needed :
2243 level.game_engine_type == GAME_ENGINE_TYPE_SP ?
2244 game_sp.infotrons_still_needed :
2245 level.game_engine_type == GAME_ENGINE_TYPE_MM ?
2246 game_mm.kettles_still_needed :
2247 game.gems_still_needed);
2248 int exit_closed = (level.game_engine_type == GAME_ENGINE_TYPE_EM ?
2249 game_em.lev->gems_needed > 0 :
2250 level.game_engine_type == GAME_ENGINE_TYPE_SP ?
2251 game_sp.infotrons_still_needed > 0 :
2252 level.game_engine_type == GAME_ENGINE_TYPE_MM ?
2253 game_mm.kettles_still_needed > 0 ||
2254 game_mm.lights_still_needed > 0 :
2255 game.gems_still_needed > 0 ||
2256 game.sokoban_fields_still_needed > 0 ||
2257 game.sokoban_objects_still_needed > 0 ||
2258 game.lights_still_needed > 0);
2259 int health = (game.LevelSolved ?
2260 game.LevelSolved_CountingHealth :
2261 level.game_engine_type == GAME_ENGINE_TYPE_MM ?
2262 MM_HEALTH(game_mm.laser_overload_value) :
2264 int sync_random_frame = INIT_GFX_RANDOM(); // random, but synchronized
2266 UpdatePlayfieldElementCount();
2268 // update game panel control values
2270 // used instead of "level_nr" (for network games)
2271 game_panel_controls[GAME_PANEL_LEVEL_NUMBER].value = levelset.level_nr;
2272 game_panel_controls[GAME_PANEL_GEMS].value = gems;
2274 game_panel_controls[GAME_PANEL_INVENTORY_COUNT].value = 0;
2275 for (i = 0; i < MAX_NUM_KEYS; i++)
2276 game_panel_controls[GAME_PANEL_KEY_1 + i].value = EL_EMPTY;
2277 game_panel_controls[GAME_PANEL_KEY_WHITE].value = EL_EMPTY;
2278 game_panel_controls[GAME_PANEL_KEY_WHITE_COUNT].value = 0;
2280 if (game.centered_player_nr == -1)
2282 for (i = 0; i < MAX_PLAYERS; i++)
2284 // only one player in Supaplex game engine
2285 if (level.game_engine_type == GAME_ENGINE_TYPE_SP && i > 0)
2288 for (k = 0; k < MAX_NUM_KEYS; k++)
2290 if (level.game_engine_type == GAME_ENGINE_TYPE_EM)
2292 if (game_em.ply[i]->keys & (1 << k))
2293 game_panel_controls[GAME_PANEL_KEY_1 + k].value =
2294 get_key_element_from_nr(k);
2296 else if (stored_player[i].key[k])
2297 game_panel_controls[GAME_PANEL_KEY_1 + k].value =
2298 get_key_element_from_nr(k);
2301 game_panel_controls[GAME_PANEL_INVENTORY_COUNT].value +=
2302 getPlayerInventorySize(i);
2304 if (stored_player[i].num_white_keys > 0)
2305 game_panel_controls[GAME_PANEL_KEY_WHITE].value =
2308 game_panel_controls[GAME_PANEL_KEY_WHITE_COUNT].value +=
2309 stored_player[i].num_white_keys;
2314 int player_nr = game.centered_player_nr;
2316 for (k = 0; k < MAX_NUM_KEYS; k++)
2318 if (level.game_engine_type == GAME_ENGINE_TYPE_EM)
2320 if (game_em.ply[player_nr]->keys & (1 << k))
2321 game_panel_controls[GAME_PANEL_KEY_1 + k].value =
2322 get_key_element_from_nr(k);
2324 else if (stored_player[player_nr].key[k])
2325 game_panel_controls[GAME_PANEL_KEY_1 + k].value =
2326 get_key_element_from_nr(k);
2329 game_panel_controls[GAME_PANEL_INVENTORY_COUNT].value +=
2330 getPlayerInventorySize(player_nr);
2332 if (stored_player[player_nr].num_white_keys > 0)
2333 game_panel_controls[GAME_PANEL_KEY_WHITE].value = EL_DC_KEY_WHITE;
2335 game_panel_controls[GAME_PANEL_KEY_WHITE_COUNT].value +=
2336 stored_player[player_nr].num_white_keys;
2339 // re-arrange keys on game panel, if needed or if defined by style settings
2340 for (i = 0; i < MAX_NUM_KEYS + 1; i++) // all normal keys + white key
2342 int nr = GAME_PANEL_KEY_1 + i;
2343 struct GamePanelControlInfo *gpc = &game_panel_controls[nr];
2344 struct TextPosInfo *pos = gpc->pos;
2346 // skip check if key is not in the player's inventory
2347 if (gpc->value == EL_EMPTY)
2350 // check if keys should be arranged on panel from left to right
2351 if (pos->style == STYLE_LEFTMOST_POSITION)
2353 // check previous key positions (left from current key)
2354 for (k = 0; k < i; k++)
2356 int nr_new = GAME_PANEL_KEY_1 + k;
2358 if (game_panel_controls[nr_new].value == EL_EMPTY)
2360 game_panel_controls[nr_new].value = gpc->value;
2361 gpc->value = EL_EMPTY;
2368 // check if "undefined" keys can be placed at some other position
2369 if (pos->x == -1 && pos->y == -1)
2371 int nr_new = GAME_PANEL_KEY_1 + i % STD_NUM_KEYS;
2373 // 1st try: display key at the same position as normal or EM keys
2374 if (game_panel_controls[nr_new].value == EL_EMPTY)
2376 game_panel_controls[nr_new].value = gpc->value;
2380 // 2nd try: display key at the next free position in the key panel
2381 for (k = 0; k < STD_NUM_KEYS; k++)
2383 nr_new = GAME_PANEL_KEY_1 + k;
2385 if (game_panel_controls[nr_new].value == EL_EMPTY)
2387 game_panel_controls[nr_new].value = gpc->value;
2396 for (i = 0; i < NUM_PANEL_INVENTORY; i++)
2398 game_panel_controls[GAME_PANEL_INVENTORY_FIRST_1 + i].value =
2399 get_inventory_element_from_pos(local_player, i);
2400 game_panel_controls[GAME_PANEL_INVENTORY_LAST_1 + i].value =
2401 get_inventory_element_from_pos(local_player, -i - 1);
2404 game_panel_controls[GAME_PANEL_SCORE].value = score;
2405 game_panel_controls[GAME_PANEL_HIGHSCORE].value = scores.entry[0].score;
2407 game_panel_controls[GAME_PANEL_TIME].value = time;
2409 game_panel_controls[GAME_PANEL_TIME_HH].value = time / 3600;
2410 game_panel_controls[GAME_PANEL_TIME_MM].value = (time / 60) % 60;
2411 game_panel_controls[GAME_PANEL_TIME_SS].value = time % 60;
2413 if (level.time == 0)
2414 game_panel_controls[GAME_PANEL_TIME_ANIM].value = 100;
2416 game_panel_controls[GAME_PANEL_TIME_ANIM].value = time * 100 / level.time;
2418 game_panel_controls[GAME_PANEL_HEALTH].value = health;
2419 game_panel_controls[GAME_PANEL_HEALTH_ANIM].value = health;
2421 game_panel_controls[GAME_PANEL_FRAME].value = FrameCounter;
2423 game_panel_controls[GAME_PANEL_SHIELD_NORMAL].value =
2424 (local_player->shield_normal_time_left > 0 ? EL_SHIELD_NORMAL_ACTIVE :
2426 game_panel_controls[GAME_PANEL_SHIELD_NORMAL_TIME].value =
2427 local_player->shield_normal_time_left;
2428 game_panel_controls[GAME_PANEL_SHIELD_DEADLY].value =
2429 (local_player->shield_deadly_time_left > 0 ? EL_SHIELD_DEADLY_ACTIVE :
2431 game_panel_controls[GAME_PANEL_SHIELD_DEADLY_TIME].value =
2432 local_player->shield_deadly_time_left;
2434 game_panel_controls[GAME_PANEL_EXIT].value =
2435 (exit_closed ? EL_EXIT_CLOSED : EL_EXIT_OPEN);
2437 game_panel_controls[GAME_PANEL_EMC_MAGIC_BALL].value =
2438 (game.ball_active ? EL_EMC_MAGIC_BALL_ACTIVE : EL_EMC_MAGIC_BALL);
2439 game_panel_controls[GAME_PANEL_EMC_MAGIC_BALL_SWITCH].value =
2440 (game.ball_active ? EL_EMC_MAGIC_BALL_SWITCH_ACTIVE :
2441 EL_EMC_MAGIC_BALL_SWITCH);
2443 game_panel_controls[GAME_PANEL_LIGHT_SWITCH].value =
2444 (game.light_time_left > 0 ? EL_LIGHT_SWITCH_ACTIVE : EL_LIGHT_SWITCH);
2445 game_panel_controls[GAME_PANEL_LIGHT_SWITCH_TIME].value =
2446 game.light_time_left;
2448 game_panel_controls[GAME_PANEL_TIMEGATE_SWITCH].value =
2449 (game.timegate_time_left > 0 ? EL_TIMEGATE_OPEN : EL_TIMEGATE_CLOSED);
2450 game_panel_controls[GAME_PANEL_TIMEGATE_SWITCH_TIME].value =
2451 game.timegate_time_left;
2453 game_panel_controls[GAME_PANEL_SWITCHGATE_SWITCH].value =
2454 EL_SWITCHGATE_SWITCH_UP + game.switchgate_pos;
2456 game_panel_controls[GAME_PANEL_EMC_LENSES].value =
2457 (game.lenses_time_left > 0 ? EL_EMC_LENSES : EL_EMPTY);
2458 game_panel_controls[GAME_PANEL_EMC_LENSES_TIME].value =
2459 game.lenses_time_left;
2461 game_panel_controls[GAME_PANEL_EMC_MAGNIFIER].value =
2462 (game.magnify_time_left > 0 ? EL_EMC_MAGNIFIER : EL_EMPTY);
2463 game_panel_controls[GAME_PANEL_EMC_MAGNIFIER_TIME].value =
2464 game.magnify_time_left;
2466 game_panel_controls[GAME_PANEL_BALLOON_SWITCH].value =
2467 (game.wind_direction == MV_LEFT ? EL_BALLOON_SWITCH_LEFT :
2468 game.wind_direction == MV_RIGHT ? EL_BALLOON_SWITCH_RIGHT :
2469 game.wind_direction == MV_UP ? EL_BALLOON_SWITCH_UP :
2470 game.wind_direction == MV_DOWN ? EL_BALLOON_SWITCH_DOWN :
2471 EL_BALLOON_SWITCH_NONE);
2473 game_panel_controls[GAME_PANEL_DYNABOMB_NUMBER].value =
2474 local_player->dynabomb_count;
2475 game_panel_controls[GAME_PANEL_DYNABOMB_SIZE].value =
2476 local_player->dynabomb_size;
2477 game_panel_controls[GAME_PANEL_DYNABOMB_POWER].value =
2478 (local_player->dynabomb_xl ? EL_DYNABOMB_INCREASE_POWER : EL_EMPTY);
2480 game_panel_controls[GAME_PANEL_PENGUINS].value =
2481 game.friends_still_needed;
2483 game_panel_controls[GAME_PANEL_SOKOBAN_OBJECTS].value =
2484 game.sokoban_objects_still_needed;
2485 game_panel_controls[GAME_PANEL_SOKOBAN_FIELDS].value =
2486 game.sokoban_fields_still_needed;
2488 game_panel_controls[GAME_PANEL_ROBOT_WHEEL].value =
2489 (game.robot_wheel_active ? EL_ROBOT_WHEEL_ACTIVE : EL_ROBOT_WHEEL);
2491 for (i = 0; i < NUM_BELTS; i++)
2493 game_panel_controls[GAME_PANEL_CONVEYOR_BELT_1 + i].value =
2494 (game.belt_dir[i] != MV_NONE ? EL_CONVEYOR_BELT_1_MIDDLE_ACTIVE :
2495 EL_CONVEYOR_BELT_1_MIDDLE) + i;
2496 game_panel_controls[GAME_PANEL_CONVEYOR_BELT_1_SWITCH + i].value =
2497 getBeltSwitchElementFromBeltNrAndBeltDir(i, game.belt_dir[i]);
2500 game_panel_controls[GAME_PANEL_MAGIC_WALL].value =
2501 (game.magic_wall_active ? EL_MAGIC_WALL_ACTIVE : EL_MAGIC_WALL);
2502 game_panel_controls[GAME_PANEL_MAGIC_WALL_TIME].value =
2503 game.magic_wall_time_left;
2505 game_panel_controls[GAME_PANEL_GRAVITY_STATE].value =
2506 local_player->gravity;
2508 for (i = 0; i < NUM_PANEL_GRAPHICS; i++)
2509 game_panel_controls[GAME_PANEL_GRAPHIC_1 + i].value = EL_GRAPHIC_1 + i;
2511 for (i = 0; i < NUM_PANEL_ELEMENTS; i++)
2512 game_panel_controls[GAME_PANEL_ELEMENT_1 + i].value =
2513 (IS_DRAWABLE_ELEMENT(game.panel.element[i].id) ?
2514 game.panel.element[i].id : EL_UNDEFINED);
2516 for (i = 0; i < NUM_PANEL_ELEMENTS; i++)
2517 game_panel_controls[GAME_PANEL_ELEMENT_COUNT_1 + i].value =
2518 (IS_VALID_ELEMENT(game.panel.element_count[i].id) ?
2519 element_info[game.panel.element_count[i].id].element_count : 0);
2521 for (i = 0; i < NUM_PANEL_CE_SCORE; i++)
2522 game_panel_controls[GAME_PANEL_CE_SCORE_1 + i].value =
2523 (IS_CUSTOM_ELEMENT(game.panel.ce_score[i].id) ?
2524 element_info[game.panel.ce_score[i].id].collect_score : 0);
2526 for (i = 0; i < NUM_PANEL_CE_SCORE; i++)
2527 game_panel_controls[GAME_PANEL_CE_SCORE_1_ELEMENT + i].value =
2528 (IS_CUSTOM_ELEMENT(game.panel.ce_score_element[i].id) ?
2529 element_info[game.panel.ce_score_element[i].id].collect_score :
2532 game_panel_controls[GAME_PANEL_PLAYER_NAME].value = 0;
2533 game_panel_controls[GAME_PANEL_LEVEL_NAME].value = 0;
2534 game_panel_controls[GAME_PANEL_LEVEL_AUTHOR].value = 0;
2536 // update game panel control frames
2538 for (i = 0; game_panel_controls[i].nr != -1; i++)
2540 struct GamePanelControlInfo *gpc = &game_panel_controls[i];
2542 if (gpc->type == TYPE_ELEMENT)
2544 if (gpc->value != EL_UNDEFINED && gpc->value != EL_EMPTY)
2546 int last_anim_random_frame = gfx.anim_random_frame;
2547 int element = gpc->value;
2548 int graphic = el2panelimg(element);
2549 int init_gfx_random = (graphic_info[graphic].anim_global_sync ?
2550 sync_random_frame : INIT_GFX_RANDOM());
2552 if (gpc->value != gpc->last_value)
2555 gpc->gfx_random = init_gfx_random;
2561 if (ANIM_MODE(graphic) == ANIM_RANDOM &&
2562 IS_NEXT_FRAME(gpc->gfx_frame, graphic))
2563 gpc->gfx_random = init_gfx_random;
2566 if (ANIM_MODE(graphic) == ANIM_RANDOM)
2567 gfx.anim_random_frame = gpc->gfx_random;
2569 if (ANIM_MODE(graphic) == ANIM_CE_SCORE)
2570 gpc->gfx_frame = element_info[element].collect_score;
2572 gpc->frame = getGraphicAnimationFrame(graphic, gpc->gfx_frame);
2574 if (ANIM_MODE(graphic) == ANIM_RANDOM)
2575 gfx.anim_random_frame = last_anim_random_frame;
2578 else if (gpc->type == TYPE_GRAPHIC)
2580 if (gpc->graphic != IMG_UNDEFINED)
2582 int last_anim_random_frame = gfx.anim_random_frame;
2583 int graphic = gpc->graphic;
2584 int init_gfx_random = (graphic_info[graphic].anim_global_sync ?
2585 sync_random_frame : INIT_GFX_RANDOM());
2587 if (gpc->value != gpc->last_value)
2590 gpc->gfx_random = init_gfx_random;
2596 if (ANIM_MODE(graphic) == ANIM_RANDOM &&
2597 IS_NEXT_FRAME(gpc->gfx_frame, graphic))
2598 gpc->gfx_random = init_gfx_random;
2601 if (ANIM_MODE(graphic) == ANIM_RANDOM)
2602 gfx.anim_random_frame = gpc->gfx_random;
2604 gpc->frame = getGraphicAnimationFrame(graphic, gpc->gfx_frame);
2606 if (ANIM_MODE(graphic) == ANIM_RANDOM)
2607 gfx.anim_random_frame = last_anim_random_frame;
2613 static void DisplayGameControlValues(void)
2615 boolean redraw_panel = FALSE;
2618 for (i = 0; game_panel_controls[i].nr != -1; i++)
2620 struct GamePanelControlInfo *gpc = &game_panel_controls[i];
2622 if (PANEL_DEACTIVATED(gpc->pos))
2625 if (gpc->value == gpc->last_value &&
2626 gpc->frame == gpc->last_frame)
2629 redraw_panel = TRUE;
2635 // copy default game door content to main double buffer
2637 // !!! CHECK AGAIN !!!
2638 SetPanelBackground();
2639 // SetDoorBackgroundImage(IMG_BACKGROUND_PANEL);
2640 DrawBackground(DX, DY, DXSIZE, DYSIZE);
2642 // redraw game control buttons
2643 RedrawGameButtons();
2645 SetGameStatus(GAME_MODE_PSEUDO_PANEL);
2647 for (i = 0; i < NUM_GAME_PANEL_CONTROLS; i++)
2649 int nr = game_panel_order[i].nr;
2650 struct GamePanelControlInfo *gpc = &game_panel_controls[nr];
2651 struct TextPosInfo *pos = gpc->pos;
2652 int type = gpc->type;
2653 int value = gpc->value;
2654 int frame = gpc->frame;
2655 int size = pos->size;
2656 int font = pos->font;
2657 boolean draw_masked = pos->draw_masked;
2658 int mask_mode = (draw_masked ? BLIT_MASKED : BLIT_OPAQUE);
2660 if (PANEL_DEACTIVATED(pos))
2663 if (pos->class == get_hash_from_key("extra_panel_items") &&
2664 !setup.prefer_extra_panel_items)
2667 gpc->last_value = value;
2668 gpc->last_frame = frame;
2670 if (type == TYPE_INTEGER)
2672 if (nr == GAME_PANEL_LEVEL_NUMBER ||
2673 nr == GAME_PANEL_TIME)
2675 boolean use_dynamic_size = (size == -1 ? TRUE : FALSE);
2677 if (use_dynamic_size) // use dynamic number of digits
2679 int value_change = (nr == GAME_PANEL_LEVEL_NUMBER ? 100 : 1000);
2680 int size1 = (nr == GAME_PANEL_LEVEL_NUMBER ? 2 : 3);
2681 int size2 = size1 + 1;
2682 int font1 = pos->font;
2683 int font2 = pos->font_alt;
2685 size = (value < value_change ? size1 : size2);
2686 font = (value < value_change ? font1 : font2);
2690 // correct text size if "digits" is zero or less
2692 size = strlen(int2str(value, size));
2694 // dynamically correct text alignment
2695 pos->width = size * getFontWidth(font);
2697 DrawTextExt(drawto, PANEL_XPOS(pos), PANEL_YPOS(pos),
2698 int2str(value, size), font, mask_mode);
2700 else if (type == TYPE_ELEMENT)
2702 int element, graphic;
2706 int dst_x = PANEL_XPOS(pos);
2707 int dst_y = PANEL_YPOS(pos);
2709 if (value != EL_UNDEFINED && value != EL_EMPTY)
2712 graphic = el2panelimg(value);
2715 Debug("game:DisplayGameControlValues", "%d, '%s' [%d]",
2716 element, EL_NAME(element), size);
2719 if (element >= EL_GRAPHIC_1 && element <= EL_GRAPHIC_8 && size == 0)
2722 getSizedGraphicSource(graphic, frame, size, &src_bitmap,
2725 width = graphic_info[graphic].width * size / TILESIZE;
2726 height = graphic_info[graphic].height * size / TILESIZE;
2729 BlitBitmapMasked(src_bitmap, drawto, src_x, src_y, width, height,
2732 BlitBitmap(src_bitmap, drawto, src_x, src_y, width, height,
2736 else if (type == TYPE_GRAPHIC)
2738 int graphic = gpc->graphic;
2739 int graphic_active = gpc->graphic_active;
2743 int dst_x = PANEL_XPOS(pos);
2744 int dst_y = PANEL_YPOS(pos);
2745 boolean skip = (pos->class == get_hash_from_key("mm_engine_only") &&
2746 level.game_engine_type != GAME_ENGINE_TYPE_MM);
2748 if (graphic != IMG_UNDEFINED && !skip)
2750 if (pos->style == STYLE_REVERSE)
2751 value = 100 - value;
2753 getGraphicSource(graphic_active, frame, &src_bitmap, &src_x, &src_y);
2755 if (pos->direction & MV_HORIZONTAL)
2757 width = graphic_info[graphic_active].width * value / 100;
2758 height = graphic_info[graphic_active].height;
2760 if (pos->direction == MV_LEFT)
2762 src_x += graphic_info[graphic_active].width - width;
2763 dst_x += graphic_info[graphic_active].width - width;
2768 width = graphic_info[graphic_active].width;
2769 height = graphic_info[graphic_active].height * value / 100;
2771 if (pos->direction == MV_UP)
2773 src_y += graphic_info[graphic_active].height - height;
2774 dst_y += graphic_info[graphic_active].height - height;
2779 BlitBitmapMasked(src_bitmap, drawto, src_x, src_y, width, height,
2782 BlitBitmap(src_bitmap, drawto, src_x, src_y, width, height,
2785 getGraphicSource(graphic, frame, &src_bitmap, &src_x, &src_y);
2787 if (pos->direction & MV_HORIZONTAL)
2789 if (pos->direction == MV_RIGHT)
2796 dst_x = PANEL_XPOS(pos);
2799 width = graphic_info[graphic].width - width;
2803 if (pos->direction == MV_DOWN)
2810 dst_y = PANEL_YPOS(pos);
2813 height = graphic_info[graphic].height - height;
2817 BlitBitmapMasked(src_bitmap, drawto, src_x, src_y, width, height,
2820 BlitBitmap(src_bitmap, drawto, src_x, src_y, width, height,
2824 else if (type == TYPE_STRING)
2826 boolean active = (value != 0);
2827 char *state_normal = "off";
2828 char *state_active = "on";
2829 char *state = (active ? state_active : state_normal);
2830 char *s = (nr == GAME_PANEL_GRAVITY_STATE ? state :
2831 nr == GAME_PANEL_PLAYER_NAME ? setup.player_name :
2832 nr == GAME_PANEL_LEVEL_NAME ? level.name :
2833 nr == GAME_PANEL_LEVEL_AUTHOR ? level.author : NULL);
2835 if (nr == GAME_PANEL_GRAVITY_STATE)
2837 int font1 = pos->font; // (used for normal state)
2838 int font2 = pos->font_alt; // (used for active state)
2840 font = (active ? font2 : font1);
2849 // don't truncate output if "chars" is zero or less
2852 // dynamically correct text alignment
2853 pos->width = size * getFontWidth(font);
2856 s_cut = getStringCopyN(s, size);
2858 DrawTextExt(drawto, PANEL_XPOS(pos), PANEL_YPOS(pos),
2859 s_cut, font, mask_mode);
2865 redraw_mask |= REDRAW_DOOR_1;
2868 SetGameStatus(GAME_MODE_PLAYING);
2871 void UpdateAndDisplayGameControlValues(void)
2873 if (tape.deactivate_display)
2876 UpdateGameControlValues();
2877 DisplayGameControlValues();
2880 void UpdateGameDoorValues(void)
2882 UpdateGameControlValues();
2885 void DrawGameDoorValues(void)
2887 DisplayGameControlValues();
2891 // ============================================================================
2893 // ----------------------------------------------------------------------------
2894 // initialize game engine due to level / tape version number
2895 // ============================================================================
2897 static void InitGameEngine(void)
2899 int i, j, k, l, x, y;
2901 // set game engine from tape file when re-playing, else from level file
2902 game.engine_version = (tape.playing ? tape.engine_version :
2903 level.game_version);
2905 // set single or multi-player game mode (needed for re-playing tapes)
2906 game.team_mode = setup.team_mode;
2910 int num_players = 0;
2912 for (i = 0; i < MAX_PLAYERS; i++)
2913 if (tape.player_participates[i])
2916 // multi-player tapes contain input data for more than one player
2917 game.team_mode = (num_players > 1);
2921 Debug("game:init:level", "level %d: level.game_version == %06d", level_nr,
2922 level.game_version);
2923 Debug("game:init:level", " tape.file_version == %06d",
2925 Debug("game:init:level", " tape.game_version == %06d",
2927 Debug("game:init:level", " tape.engine_version == %06d",
2928 tape.engine_version);
2929 Debug("game:init:level", " => game.engine_version == %06d [tape mode: %s]",
2930 game.engine_version, (tape.playing ? "PLAYING" : "RECORDING"));
2933 // --------------------------------------------------------------------------
2934 // set flags for bugs and changes according to active game engine version
2935 // --------------------------------------------------------------------------
2939 Fixed property "can fall" for run-time element "EL_AMOEBA_DROPPING"
2941 Bug was introduced in version:
2944 Bug was fixed in version:
2948 In version 2.0.1, a new run-time element "EL_AMOEBA_DROPPING" was added,
2949 but the property "can fall" was missing, which caused some levels to be
2950 unsolvable. This was fixed in version 4.2.0.0.
2952 Affected levels/tapes:
2953 An example for a tape that was fixed by this bugfix is tape 029 from the
2954 level set "rnd_sam_bateman".
2955 The wrong behaviour will still be used for all levels or tapes that were
2956 created/recorded with it. An example for this is tape 023 from the level
2957 set "rnd_gerhard_haeusler", which was recorded with a buggy game engine.
2960 boolean use_amoeba_dropping_cannot_fall_bug =
2961 ((game.engine_version >= VERSION_IDENT(2,0,1,0) &&
2962 game.engine_version < VERSION_IDENT(4,2,0,0)) ||
2964 tape.game_version >= VERSION_IDENT(2,0,1,0) &&
2965 tape.game_version < VERSION_IDENT(4,2,0,0)));
2968 Summary of bugfix/change:
2969 Fixed move speed of elements entering or leaving magic wall.
2971 Fixed/changed in version:
2975 Before 2.0.1, move speed of elements entering or leaving magic wall was
2976 twice as fast as it is now.
2977 Since 2.0.1, this is set to a lower value by using move_stepsize_list[].
2979 Affected levels/tapes:
2980 The first condition is generally needed for all levels/tapes before version
2981 2.0.1, which might use the old behaviour before it was changed; known tapes
2982 that are affected: Tape 014 from the level set "rnd_conor_mancone".
2983 The second condition is an exception from the above case and is needed for
2984 the special case of tapes recorded with game (not engine!) version 2.0.1 or
2985 above, but before it was known that this change would break tapes like the
2986 above and was fixed in 4.2.0.0, so that the changed behaviour was active
2987 although the engine version while recording maybe was before 2.0.1. There
2988 are a lot of tapes that are affected by this exception, like tape 006 from
2989 the level set "rnd_conor_mancone".
2992 boolean use_old_move_stepsize_for_magic_wall =
2993 (game.engine_version < VERSION_IDENT(2,0,1,0) &&
2995 tape.game_version >= VERSION_IDENT(2,0,1,0) &&
2996 tape.game_version < VERSION_IDENT(4,2,0,0)));
2999 Summary of bugfix/change:
3000 Fixed handling for custom elements that change when pushed by the player.
3002 Fixed/changed in version:
3006 Before 3.1.0, custom elements that "change when pushing" changed directly
3007 after the player started pushing them (until then handled in "DigField()").
3008 Since 3.1.0, these custom elements are not changed until the "pushing"
3009 move of the element is finished (now handled in "ContinueMoving()").
3011 Affected levels/tapes:
3012 The first condition is generally needed for all levels/tapes before version
3013 3.1.0, which might use the old behaviour before it was changed; known tapes
3014 that are affected are some tapes from the level set "Walpurgis Gardens" by
3016 The second condition is an exception from the above case and is needed for
3017 the special case of tapes recorded with game (not engine!) version 3.1.0 or
3018 above (including some development versions of 3.1.0), but before it was
3019 known that this change would break tapes like the above and was fixed in
3020 3.1.1, so that the changed behaviour was active although the engine version
3021 while recording maybe was before 3.1.0. There is at least one tape that is
3022 affected by this exception, which is the tape for the one-level set "Bug
3023 Machine" by Juergen Bonhagen.
3026 game.use_change_when_pushing_bug =
3027 (game.engine_version < VERSION_IDENT(3,1,0,0) &&
3029 tape.game_version >= VERSION_IDENT(3,1,0,0) &&
3030 tape.game_version < VERSION_IDENT(3,1,1,0)));
3033 Summary of bugfix/change:
3034 Fixed handling for blocking the field the player leaves when moving.
3036 Fixed/changed in version:
3040 Before 3.1.1, when "block last field when moving" was enabled, the field
3041 the player is leaving when moving was blocked for the time of the move,
3042 and was directly unblocked afterwards. This resulted in the last field
3043 being blocked for exactly one less than the number of frames of one player
3044 move. Additionally, even when blocking was disabled, the last field was
3045 blocked for exactly one frame.
3046 Since 3.1.1, due to changes in player movement handling, the last field
3047 is not blocked at all when blocking is disabled. When blocking is enabled,
3048 the last field is blocked for exactly the number of frames of one player
3049 move. Additionally, if the player is Murphy, the hero of Supaplex, the
3050 last field is blocked for exactly one more than the number of frames of
3053 Affected levels/tapes:
3054 (!!! yet to be determined -- probably many !!!)
3057 game.use_block_last_field_bug =
3058 (game.engine_version < VERSION_IDENT(3,1,1,0));
3060 /* various special flags and settings for native Emerald Mine game engine */
3062 game_em.use_single_button =
3063 (game.engine_version > VERSION_IDENT(4,0,0,2));
3065 game_em.use_snap_key_bug =
3066 (game.engine_version < VERSION_IDENT(4,0,1,0));
3068 game_em.use_random_bug =
3069 (tape.property_bits & TAPE_PROPERTY_EM_RANDOM_BUG);
3071 boolean use_old_em_engine = (game.engine_version < VERSION_IDENT(4,2,0,0));
3073 game_em.use_old_explosions = use_old_em_engine;
3074 game_em.use_old_android = use_old_em_engine;
3075 game_em.use_old_push_elements = use_old_em_engine;
3076 game_em.use_old_push_into_acid = use_old_em_engine;
3078 game_em.use_wrap_around = !use_old_em_engine;
3080 // --------------------------------------------------------------------------
3082 // set maximal allowed number of custom element changes per game frame
3083 game.max_num_changes_per_frame = 1;
3085 // default scan direction: scan playfield from top/left to bottom/right
3086 InitPlayfieldScanMode(CA_ARG_SCAN_MODE_NORMAL);
3088 // dynamically adjust element properties according to game engine version
3089 InitElementPropertiesEngine(game.engine_version);
3091 // ---------- initialize special element properties -------------------------
3093 // "EL_AMOEBA_DROPPING" missed property "can fall" in older game versions
3094 if (use_amoeba_dropping_cannot_fall_bug)
3095 SET_PROPERTY(EL_AMOEBA_DROPPING, EP_CAN_FALL, FALSE);
3097 // ---------- initialize player's initial move delay ------------------------
3099 // dynamically adjust player properties according to level information
3100 for (i = 0; i < MAX_PLAYERS; i++)
3101 game.initial_move_delay_value[i] =
3102 get_move_delay_from_stepsize(level.initial_player_stepsize[i]);
3104 // dynamically adjust player properties according to game engine version
3105 for (i = 0; i < MAX_PLAYERS; i++)
3106 game.initial_move_delay[i] =
3107 (game.engine_version <= VERSION_IDENT(2,0,1,0) ?
3108 game.initial_move_delay_value[i] : 0);
3110 // ---------- initialize player's initial push delay ------------------------
3112 // dynamically adjust player properties according to game engine version
3113 game.initial_push_delay_value =
3114 (game.engine_version < VERSION_IDENT(3,0,7,1) ? 5 : -1);
3116 // ---------- initialize changing elements ----------------------------------
3118 // initialize changing elements information
3119 for (i = 0; i < MAX_NUM_ELEMENTS; i++)
3121 struct ElementInfo *ei = &element_info[i];
3123 // this pointer might have been changed in the level editor
3124 ei->change = &ei->change_page[0];
3126 if (!IS_CUSTOM_ELEMENT(i))
3128 ei->change->target_element = EL_EMPTY_SPACE;
3129 ei->change->delay_fixed = 0;
3130 ei->change->delay_random = 0;
3131 ei->change->delay_frames = 1;
3134 for (j = 0; j < NUM_CHANGE_EVENTS; j++)
3136 ei->has_change_event[j] = FALSE;
3138 ei->event_page_nr[j] = 0;
3139 ei->event_page[j] = &ei->change_page[0];
3143 // add changing elements from pre-defined list
3144 for (i = 0; change_delay_list[i].element != EL_UNDEFINED; i++)
3146 struct ChangingElementInfo *ch_delay = &change_delay_list[i];
3147 struct ElementInfo *ei = &element_info[ch_delay->element];
3149 ei->change->target_element = ch_delay->target_element;
3150 ei->change->delay_fixed = ch_delay->change_delay;
3152 ei->change->pre_change_function = ch_delay->pre_change_function;
3153 ei->change->change_function = ch_delay->change_function;
3154 ei->change->post_change_function = ch_delay->post_change_function;
3156 ei->change->can_change = TRUE;
3157 ei->change->can_change_or_has_action = TRUE;
3159 ei->has_change_event[CE_DELAY] = TRUE;
3161 SET_PROPERTY(ch_delay->element, EP_CAN_CHANGE, TRUE);
3162 SET_PROPERTY(ch_delay->element, EP_CAN_CHANGE_OR_HAS_ACTION, TRUE);
3165 // ---------- initialize internal run-time variables ------------------------
3167 for (i = 0; i < NUM_CUSTOM_ELEMENTS; i++)
3169 struct ElementInfo *ei = &element_info[EL_CUSTOM_START + i];
3171 for (j = 0; j < ei->num_change_pages; j++)
3173 ei->change_page[j].can_change_or_has_action =
3174 (ei->change_page[j].can_change |
3175 ei->change_page[j].has_action);
3179 // add change events from custom element configuration
3180 for (i = 0; i < NUM_CUSTOM_ELEMENTS; i++)
3182 struct ElementInfo *ei = &element_info[EL_CUSTOM_START + i];
3184 for (j = 0; j < ei->num_change_pages; j++)
3186 if (!ei->change_page[j].can_change_or_has_action)
3189 for (k = 0; k < NUM_CHANGE_EVENTS; k++)
3191 // only add event page for the first page found with this event
3192 if (ei->change_page[j].has_event[k] && !(ei->has_change_event[k]))
3194 ei->has_change_event[k] = TRUE;
3196 ei->event_page_nr[k] = j;
3197 ei->event_page[k] = &ei->change_page[j];
3203 // ---------- initialize reference elements in change conditions ------------
3205 for (i = 0; i < NUM_CUSTOM_ELEMENTS; i++)
3207 int element = EL_CUSTOM_START + i;
3208 struct ElementInfo *ei = &element_info[element];
3210 for (j = 0; j < ei->num_change_pages; j++)
3212 int trigger_element = ei->change_page[j].initial_trigger_element;
3214 if (trigger_element >= EL_PREV_CE_8 &&
3215 trigger_element <= EL_NEXT_CE_8)
3216 trigger_element = RESOLVED_REFERENCE_ELEMENT(element, trigger_element);
3218 ei->change_page[j].trigger_element = trigger_element;
3222 // ---------- initialize run-time trigger player and element ----------------
3224 for (i = 0; i < NUM_CUSTOM_ELEMENTS; i++)
3226 struct ElementInfo *ei = &element_info[EL_CUSTOM_START + i];
3228 for (j = 0; j < ei->num_change_pages; j++)
3230 ei->change_page[j].actual_trigger_element = EL_EMPTY;
3231 ei->change_page[j].actual_trigger_player = EL_EMPTY;
3232 ei->change_page[j].actual_trigger_player_bits = CH_PLAYER_NONE;
3233 ei->change_page[j].actual_trigger_side = CH_SIDE_NONE;
3234 ei->change_page[j].actual_trigger_ce_value = 0;
3235 ei->change_page[j].actual_trigger_ce_score = 0;
3239 // ---------- initialize trigger events -------------------------------------
3241 // initialize trigger events information
3242 for (i = 0; i < MAX_NUM_ELEMENTS; i++)
3243 for (j = 0; j < NUM_CHANGE_EVENTS; j++)
3244 trigger_events[i][j] = FALSE;
3246 // add trigger events from element change event properties
3247 for (i = 0; i < MAX_NUM_ELEMENTS; i++)
3249 struct ElementInfo *ei = &element_info[i];
3251 for (j = 0; j < ei->num_change_pages; j++)
3253 if (!ei->change_page[j].can_change_or_has_action)
3256 if (ei->change_page[j].has_event[CE_BY_OTHER_ACTION])
3258 int trigger_element = ei->change_page[j].trigger_element;
3260 for (k = 0; k < NUM_CHANGE_EVENTS; k++)
3262 if (ei->change_page[j].has_event[k])
3264 if (IS_GROUP_ELEMENT(trigger_element))
3266 struct ElementGroupInfo *group =
3267 element_info[trigger_element].group;
3269 for (l = 0; l < group->num_elements_resolved; l++)
3270 trigger_events[group->element_resolved[l]][k] = TRUE;
3272 else if (trigger_element == EL_ANY_ELEMENT)
3273 for (l = 0; l < MAX_NUM_ELEMENTS; l++)
3274 trigger_events[l][k] = TRUE;
3276 trigger_events[trigger_element][k] = TRUE;
3283 // ---------- initialize push delay -----------------------------------------
3285 // initialize push delay values to default
3286 for (i = 0; i < MAX_NUM_ELEMENTS; i++)
3288 if (!IS_CUSTOM_ELEMENT(i))
3290 // set default push delay values (corrected since version 3.0.7-1)
3291 if (game.engine_version < VERSION_IDENT(3,0,7,1))
3293 element_info[i].push_delay_fixed = 2;
3294 element_info[i].push_delay_random = 8;
3298 element_info[i].push_delay_fixed = 8;
3299 element_info[i].push_delay_random = 8;
3304 // set push delay value for certain elements from pre-defined list
3305 for (i = 0; push_delay_list[i].element != EL_UNDEFINED; i++)
3307 int e = push_delay_list[i].element;
3309 element_info[e].push_delay_fixed = push_delay_list[i].push_delay_fixed;
3310 element_info[e].push_delay_random = push_delay_list[i].push_delay_random;
3313 // set push delay value for Supaplex elements for newer engine versions
3314 if (game.engine_version >= VERSION_IDENT(3,1,0,0))
3316 for (i = 0; i < MAX_NUM_ELEMENTS; i++)
3318 if (IS_SP_ELEMENT(i))
3320 // set SP push delay to just enough to push under a falling zonk
3321 int delay = (game.engine_version >= VERSION_IDENT(3,1,1,0) ? 8 : 6);
3323 element_info[i].push_delay_fixed = delay;
3324 element_info[i].push_delay_random = 0;
3329 // ---------- initialize move stepsize --------------------------------------
3331 // initialize move stepsize values to default
3332 for (i = 0; i < MAX_NUM_ELEMENTS; i++)
3333 if (!IS_CUSTOM_ELEMENT(i))
3334 element_info[i].move_stepsize = MOVE_STEPSIZE_NORMAL;
3336 // set move stepsize value for certain elements from pre-defined list
3337 for (i = 0; move_stepsize_list[i].element != EL_UNDEFINED; i++)
3339 int e = move_stepsize_list[i].element;
3341 element_info[e].move_stepsize = move_stepsize_list[i].move_stepsize;
3343 // set move stepsize value for certain elements for older engine versions
3344 if (use_old_move_stepsize_for_magic_wall)
3346 if (e == EL_MAGIC_WALL_FILLING ||
3347 e == EL_MAGIC_WALL_EMPTYING ||
3348 e == EL_BD_MAGIC_WALL_FILLING ||
3349 e == EL_BD_MAGIC_WALL_EMPTYING)
3350 element_info[e].move_stepsize *= 2;
3354 // ---------- initialize collect score --------------------------------------
3356 // initialize collect score values for custom elements from initial value
3357 for (i = 0; i < MAX_NUM_ELEMENTS; i++)
3358 if (IS_CUSTOM_ELEMENT(i))
3359 element_info[i].collect_score = element_info[i].collect_score_initial;
3361 // ---------- initialize collect count --------------------------------------
3363 // initialize collect count values for non-custom elements
3364 for (i = 0; i < MAX_NUM_ELEMENTS; i++)
3365 if (!IS_CUSTOM_ELEMENT(i))
3366 element_info[i].collect_count_initial = 0;
3368 // add collect count values for all elements from pre-defined list
3369 for (i = 0; collect_count_list[i].element != EL_UNDEFINED; i++)
3370 element_info[collect_count_list[i].element].collect_count_initial =
3371 collect_count_list[i].count;
3373 // ---------- initialize access direction -----------------------------------
3375 // initialize access direction values to default (access from every side)
3376 for (i = 0; i < MAX_NUM_ELEMENTS; i++)
3377 if (!IS_CUSTOM_ELEMENT(i))
3378 element_info[i].access_direction = MV_ALL_DIRECTIONS;
3380 // set access direction value for certain elements from pre-defined list
3381 for (i = 0; access_direction_list[i].element != EL_UNDEFINED; i++)
3382 element_info[access_direction_list[i].element].access_direction =
3383 access_direction_list[i].direction;
3385 // ---------- initialize explosion content ----------------------------------
3386 for (i = 0; i < MAX_NUM_ELEMENTS; i++)
3388 if (IS_CUSTOM_ELEMENT(i))
3391 for (y = 0; y < 3; y++) for (x = 0; x < 3; x++)
3393 // (content for EL_YAMYAM set at run-time with game.yamyam_content_nr)
3395 element_info[i].content.e[x][y] =
3396 (i == EL_PLAYER_1 ? EL_EMERALD_YELLOW :
3397 i == EL_PLAYER_2 ? EL_EMERALD_RED :
3398 i == EL_PLAYER_3 ? EL_EMERALD :
3399 i == EL_PLAYER_4 ? EL_EMERALD_PURPLE :
3400 i == EL_MOLE ? EL_EMERALD_RED :
3401 i == EL_PENGUIN ? EL_EMERALD_PURPLE :
3402 i == EL_BUG ? (x == 1 && y == 1 ? EL_DIAMOND : EL_EMERALD) :
3403 i == EL_BD_BUTTERFLY ? EL_BD_DIAMOND :
3404 i == EL_SP_ELECTRON ? EL_SP_INFOTRON :
3405 i == EL_AMOEBA_TO_DIAMOND ? level.amoeba_content :
3406 i == EL_WALL_EMERALD ? EL_EMERALD :
3407 i == EL_WALL_DIAMOND ? EL_DIAMOND :
3408 i == EL_WALL_BD_DIAMOND ? EL_BD_DIAMOND :
3409 i == EL_WALL_EMERALD_YELLOW ? EL_EMERALD_YELLOW :
3410 i == EL_WALL_EMERALD_RED ? EL_EMERALD_RED :
3411 i == EL_WALL_EMERALD_PURPLE ? EL_EMERALD_PURPLE :
3412 i == EL_WALL_PEARL ? EL_PEARL :
3413 i == EL_WALL_CRYSTAL ? EL_CRYSTAL :
3418 // ---------- initialize recursion detection --------------------------------
3419 recursion_loop_depth = 0;
3420 recursion_loop_detected = FALSE;
3421 recursion_loop_element = EL_UNDEFINED;
3423 // ---------- initialize graphics engine ------------------------------------
3424 game.scroll_delay_value =
3425 (game.forced_scroll_delay_value != -1 ? game.forced_scroll_delay_value :
3426 level.game_engine_type == GAME_ENGINE_TYPE_EM &&
3427 !setup.forced_scroll_delay ? 0 :
3428 setup.scroll_delay ? setup.scroll_delay_value : 0);
3429 game.scroll_delay_value =
3430 MIN(MAX(MIN_SCROLL_DELAY, game.scroll_delay_value), MAX_SCROLL_DELAY);
3432 // ---------- initialize game engine snapshots ------------------------------
3433 for (i = 0; i < MAX_PLAYERS; i++)
3434 game.snapshot.last_action[i] = 0;
3435 game.snapshot.changed_action = FALSE;
3436 game.snapshot.collected_item = FALSE;
3437 game.snapshot.mode =
3438 (strEqual(setup.engine_snapshot_mode, STR_SNAPSHOT_MODE_EVERY_STEP) ?
3439 SNAPSHOT_MODE_EVERY_STEP :
3440 strEqual(setup.engine_snapshot_mode, STR_SNAPSHOT_MODE_EVERY_MOVE) ?
3441 SNAPSHOT_MODE_EVERY_MOVE :
3442 strEqual(setup.engine_snapshot_mode, STR_SNAPSHOT_MODE_EVERY_COLLECT) ?
3443 SNAPSHOT_MODE_EVERY_COLLECT : SNAPSHOT_MODE_OFF);
3444 game.snapshot.save_snapshot = FALSE;
3446 // ---------- initialize level time for Supaplex engine ---------------------
3447 // Supaplex levels with time limit currently unsupported -- should be added
3448 if (level.game_engine_type == GAME_ENGINE_TYPE_SP)
3451 // ---------- initialize flags for handling game actions --------------------
3453 // set flags for game actions to default values
3454 game.use_key_actions = TRUE;
3455 game.use_mouse_actions = FALSE;
3457 // when using Mirror Magic game engine, handle mouse events only
3458 if (level.game_engine_type == GAME_ENGINE_TYPE_MM)
3460 game.use_key_actions = FALSE;
3461 game.use_mouse_actions = TRUE;
3464 // check for custom elements with mouse click events
3465 if (level.game_engine_type == GAME_ENGINE_TYPE_RND)
3467 for (i = 0; i < NUM_CUSTOM_ELEMENTS; i++)
3469 int element = EL_CUSTOM_START + i;
3471 if (HAS_CHANGE_EVENT(element, CE_CLICKED_BY_MOUSE) ||
3472 HAS_CHANGE_EVENT(element, CE_PRESSED_BY_MOUSE) ||
3473 HAS_CHANGE_EVENT(element, CE_MOUSE_CLICKED_ON_X) ||
3474 HAS_CHANGE_EVENT(element, CE_MOUSE_PRESSED_ON_X))
3475 game.use_mouse_actions = TRUE;
3480 static int get_num_special_action(int element, int action_first,
3483 int num_special_action = 0;
3486 for (i = action_first; i <= action_last; i++)
3488 boolean found = FALSE;
3490 for (j = 0; j < NUM_DIRECTIONS; j++)
3491 if (el_act_dir2img(element, i, j) !=
3492 el_act_dir2img(element, ACTION_DEFAULT, j))
3496 num_special_action++;
3501 return num_special_action;
3505 // ============================================================================
3507 // ----------------------------------------------------------------------------
3508 // initialize and start new game
3509 // ============================================================================
3511 #if DEBUG_INIT_PLAYER
3512 static void DebugPrintPlayerStatus(char *message)
3519 Debug("game:init:player", "%s:", message);
3521 for (i = 0; i < MAX_PLAYERS; i++)
3523 struct PlayerInfo *player = &stored_player[i];
3525 Debug("game:init:player",
3526 "- player %d: present == %d, connected == %d [%d/%d], active == %d%s",
3530 player->connected_locally,
3531 player->connected_network,
3533 (local_player == player ? " (local player)" : ""));
3540 int full_lev_fieldx = lev_fieldx + (BorderElement != EL_EMPTY ? 2 : 0);
3541 int full_lev_fieldy = lev_fieldy + (BorderElement != EL_EMPTY ? 2 : 0);
3542 int fade_mask = REDRAW_FIELD;
3544 boolean emulate_bd = TRUE; // unless non-BOULDERDASH elements found
3545 boolean emulate_sb = TRUE; // unless non-SOKOBAN elements found
3546 boolean emulate_sp = TRUE; // unless non-SUPAPLEX elements found
3547 int initial_move_dir = MV_DOWN;
3550 // required here to update video display before fading (FIX THIS)
3551 DrawMaskedBorder(REDRAW_DOOR_2);
3553 if (!game.restart_level)
3554 CloseDoor(DOOR_CLOSE_1);
3556 SetGameStatus(GAME_MODE_PLAYING);
3558 if (level_editor_test_game)
3559 FadeSkipNextFadeOut();
3561 FadeSetEnterScreen();
3564 fade_mask = REDRAW_ALL;
3566 FadeLevelSoundsAndMusic();
3568 ExpireSoundLoops(TRUE);
3572 if (level_editor_test_game)
3573 FadeSkipNextFadeIn();
3575 // needed if different viewport properties defined for playing
3576 ChangeViewportPropertiesIfNeeded();
3580 DrawCompleteVideoDisplay();
3582 OpenDoor(GetDoorState() | DOOR_NO_DELAY | DOOR_FORCE_REDRAW);
3585 InitGameControlValues();
3589 // initialize tape actions from game when recording tape
3590 tape.use_key_actions = game.use_key_actions;
3591 tape.use_mouse_actions = game.use_mouse_actions;
3593 // initialize visible playfield size when recording tape (for team mode)
3594 tape.scr_fieldx = SCR_FIELDX;
3595 tape.scr_fieldy = SCR_FIELDY;
3598 // don't play tapes over network
3599 network_playing = (network.enabled && !tape.playing);
3601 for (i = 0; i < MAX_PLAYERS; i++)
3603 struct PlayerInfo *player = &stored_player[i];
3605 player->index_nr = i;
3606 player->index_bit = (1 << i);
3607 player->element_nr = EL_PLAYER_1 + i;
3609 player->present = FALSE;
3610 player->active = FALSE;
3611 player->mapped = FALSE;
3613 player->killed = FALSE;
3614 player->reanimated = FALSE;
3615 player->buried = FALSE;
3618 player->effective_action = 0;
3619 player->programmed_action = 0;
3620 player->snap_action = 0;
3622 player->mouse_action.lx = 0;
3623 player->mouse_action.ly = 0;
3624 player->mouse_action.button = 0;
3625 player->mouse_action.button_hint = 0;
3627 player->effective_mouse_action.lx = 0;
3628 player->effective_mouse_action.ly = 0;
3629 player->effective_mouse_action.button = 0;
3630 player->effective_mouse_action.button_hint = 0;
3632 for (j = 0; j < MAX_NUM_KEYS; j++)
3633 player->key[j] = FALSE;
3635 player->num_white_keys = 0;
3637 player->dynabomb_count = 0;
3638 player->dynabomb_size = 1;
3639 player->dynabombs_left = 0;
3640 player->dynabomb_xl = FALSE;
3642 player->MovDir = initial_move_dir;
3645 player->GfxDir = initial_move_dir;
3646 player->GfxAction = ACTION_DEFAULT;
3648 player->StepFrame = 0;
3650 player->initial_element = player->element_nr;
3651 player->artwork_element =
3652 (level.use_artwork_element[i] ? level.artwork_element[i] :
3653 player->element_nr);
3654 player->use_murphy = FALSE;
3656 player->block_last_field = FALSE; // initialized in InitPlayerField()
3657 player->block_delay_adjustment = 0; // initialized in InitPlayerField()
3659 player->gravity = level.initial_player_gravity[i];
3661 player->can_fall_into_acid = CAN_MOVE_INTO_ACID(player->element_nr);
3663 player->actual_frame_counter = 0;
3665 player->step_counter = 0;
3667 player->last_move_dir = initial_move_dir;
3669 player->is_active = FALSE;
3671 player->is_waiting = FALSE;
3672 player->is_moving = FALSE;
3673 player->is_auto_moving = FALSE;
3674 player->is_digging = FALSE;
3675 player->is_snapping = FALSE;
3676 player->is_collecting = FALSE;
3677 player->is_pushing = FALSE;
3678 player->is_switching = FALSE;
3679 player->is_dropping = FALSE;
3680 player->is_dropping_pressed = FALSE;
3682 player->is_bored = FALSE;
3683 player->is_sleeping = FALSE;
3685 player->was_waiting = TRUE;
3686 player->was_moving = FALSE;
3687 player->was_snapping = FALSE;
3688 player->was_dropping = FALSE;
3690 player->force_dropping = FALSE;
3692 player->frame_counter_bored = -1;
3693 player->frame_counter_sleeping = -1;
3695 player->anim_delay_counter = 0;
3696 player->post_delay_counter = 0;
3698 player->dir_waiting = initial_move_dir;
3699 player->action_waiting = ACTION_DEFAULT;
3700 player->last_action_waiting = ACTION_DEFAULT;
3701 player->special_action_bored = ACTION_DEFAULT;
3702 player->special_action_sleeping = ACTION_DEFAULT;
3704 player->switch_x = -1;
3705 player->switch_y = -1;
3707 player->drop_x = -1;
3708 player->drop_y = -1;
3710 player->show_envelope = 0;
3712 SetPlayerMoveSpeed(player, level.initial_player_stepsize[i], TRUE);
3714 player->push_delay = -1; // initialized when pushing starts
3715 player->push_delay_value = game.initial_push_delay_value;
3717 player->drop_delay = 0;
3718 player->drop_pressed_delay = 0;
3720 player->last_jx = -1;
3721 player->last_jy = -1;
3725 player->shield_normal_time_left = 0;
3726 player->shield_deadly_time_left = 0;
3728 player->last_removed_element = EL_UNDEFINED;
3730 player->inventory_infinite_element = EL_UNDEFINED;
3731 player->inventory_size = 0;
3733 if (level.use_initial_inventory[i])
3735 for (j = 0; j < level.initial_inventory_size[i]; j++)
3737 int element = level.initial_inventory_content[i][j];
3738 int collect_count = element_info[element].collect_count_initial;
3741 if (!IS_CUSTOM_ELEMENT(element))
3744 if (collect_count == 0)
3745 player->inventory_infinite_element = element;
3747 for (k = 0; k < collect_count; k++)
3748 if (player->inventory_size < MAX_INVENTORY_SIZE)
3749 player->inventory_element[player->inventory_size++] = element;
3753 DigField(player, 0, 0, 0, 0, 0, 0, DF_NO_PUSH);
3754 SnapField(player, 0, 0);
3756 map_player_action[i] = i;
3759 network_player_action_received = FALSE;
3761 // initial null action
3762 if (network_playing)
3763 SendToServer_MovePlayer(MV_NONE);
3768 TimeLeft = level.time;
3771 ScreenMovDir = MV_NONE;
3775 ScrollStepSize = 0; // will be correctly initialized by ScrollScreen()
3777 game.robot_wheel_x = -1;
3778 game.robot_wheel_y = -1;
3783 game.all_players_gone = FALSE;
3785 game.LevelSolved = FALSE;
3786 game.GameOver = FALSE;
3788 game.GamePlayed = !tape.playing;
3790 game.LevelSolved_GameWon = FALSE;
3791 game.LevelSolved_GameEnd = FALSE;
3792 game.LevelSolved_SaveTape = FALSE;
3793 game.LevelSolved_SaveScore = FALSE;
3795 game.LevelSolved_CountingTime = 0;
3796 game.LevelSolved_CountingScore = 0;
3797 game.LevelSolved_CountingHealth = 0;
3799 game.panel.active = TRUE;
3801 game.no_time_limit = (level.time == 0);
3803 game.yamyam_content_nr = 0;
3804 game.robot_wheel_active = FALSE;
3805 game.magic_wall_active = FALSE;
3806 game.magic_wall_time_left = 0;
3807 game.light_time_left = 0;
3808 game.timegate_time_left = 0;
3809 game.switchgate_pos = 0;
3810 game.wind_direction = level.wind_direction_initial;
3812 game.time_final = 0;
3813 game.score_time_final = 0;
3816 game.score_final = 0;
3818 game.health = MAX_HEALTH;
3819 game.health_final = MAX_HEALTH;
3821 game.gems_still_needed = level.gems_needed;
3822 game.sokoban_fields_still_needed = 0;
3823 game.sokoban_objects_still_needed = 0;
3824 game.lights_still_needed = 0;
3825 game.players_still_needed = 0;
3826 game.friends_still_needed = 0;
3828 game.lenses_time_left = 0;
3829 game.magnify_time_left = 0;
3831 game.ball_active = level.ball_active_initial;
3832 game.ball_content_nr = 0;
3834 game.explosions_delayed = TRUE;
3836 game.envelope_active = FALSE;
3838 for (i = 0; i < NUM_BELTS; i++)
3840 game.belt_dir[i] = MV_NONE;
3841 game.belt_dir_nr[i] = 3; // not moving, next moving left
3844 for (i = 0; i < MAX_NUM_AMOEBA; i++)
3845 AmoebaCnt[i] = AmoebaCnt2[i] = 0;
3847 #if DEBUG_INIT_PLAYER
3848 DebugPrintPlayerStatus("Player status at level initialization");
3851 SCAN_PLAYFIELD(x, y)
3853 Tile[x][y] = Last[x][y] = level.field[x][y];
3854 MovPos[x][y] = MovDir[x][y] = MovDelay[x][y] = 0;
3855 ChangeDelay[x][y] = 0;
3856 ChangePage[x][y] = -1;
3857 CustomValue[x][y] = 0; // initialized in InitField()
3858 Store[x][y] = Store2[x][y] = StorePlayer[x][y] = Back[x][y] = 0;
3860 WasJustMoving[x][y] = 0;
3861 WasJustFalling[x][y] = 0;
3862 CheckCollision[x][y] = 0;
3863 CheckImpact[x][y] = 0;
3865 Pushed[x][y] = FALSE;
3867 ChangeCount[x][y] = 0;
3868 ChangeEvent[x][y] = -1;
3870 ExplodePhase[x][y] = 0;
3871 ExplodeDelay[x][y] = 0;
3872 ExplodeField[x][y] = EX_TYPE_NONE;
3874 RunnerVisit[x][y] = 0;
3875 PlayerVisit[x][y] = 0;
3878 GfxRandom[x][y] = INIT_GFX_RANDOM();
3879 GfxElement[x][y] = EL_UNDEFINED;
3880 GfxAction[x][y] = ACTION_DEFAULT;
3881 GfxDir[x][y] = MV_NONE;
3882 GfxRedraw[x][y] = GFX_REDRAW_NONE;
3885 SCAN_PLAYFIELD(x, y)
3887 if (emulate_bd && !IS_BD_ELEMENT(Tile[x][y]))
3889 if (emulate_sb && !IS_SB_ELEMENT(Tile[x][y]))
3891 if (emulate_sp && !IS_SP_ELEMENT(Tile[x][y]))
3894 InitField(x, y, TRUE);
3896 ResetGfxAnimation(x, y);
3901 for (i = 0; i < MAX_PLAYERS; i++)
3903 struct PlayerInfo *player = &stored_player[i];
3905 // set number of special actions for bored and sleeping animation
3906 player->num_special_action_bored =
3907 get_num_special_action(player->artwork_element,
3908 ACTION_BORING_1, ACTION_BORING_LAST);
3909 player->num_special_action_sleeping =
3910 get_num_special_action(player->artwork_element,
3911 ACTION_SLEEPING_1, ACTION_SLEEPING_LAST);
3914 game.emulation = (emulate_bd ? EMU_BOULDERDASH :
3915 emulate_sb ? EMU_SOKOBAN :
3916 emulate_sp ? EMU_SUPAPLEX : EMU_NONE);
3918 // initialize type of slippery elements
3919 for (i = 0; i < MAX_NUM_ELEMENTS; i++)
3921 if (!IS_CUSTOM_ELEMENT(i))
3923 // default: elements slip down either to the left or right randomly
3924 element_info[i].slippery_type = SLIPPERY_ANY_RANDOM;
3926 // SP style elements prefer to slip down on the left side
3927 if (game.engine_version >= VERSION_IDENT(3,1,1,0) && IS_SP_ELEMENT(i))
3928 element_info[i].slippery_type = SLIPPERY_ANY_LEFT_RIGHT;
3930 // BD style elements prefer to slip down on the left side
3931 if (game.emulation == EMU_BOULDERDASH)
3932 element_info[i].slippery_type = SLIPPERY_ANY_LEFT_RIGHT;
3936 // initialize explosion and ignition delay
3937 for (i = 0; i < MAX_NUM_ELEMENTS; i++)
3939 if (!IS_CUSTOM_ELEMENT(i))
3942 int delay = (((IS_SP_ELEMENT(i) && i != EL_EMPTY_SPACE) &&
3943 game.engine_version >= VERSION_IDENT(3,1,0,0)) ||
3944 game.emulation == EMU_SUPAPLEX ? 3 : 2);
3945 int last_phase = (num_phase + 1) * delay;
3946 int half_phase = (num_phase / 2) * delay;
3948 element_info[i].explosion_delay = last_phase - 1;
3949 element_info[i].ignition_delay = half_phase;
3951 if (i == EL_BLACK_ORB)
3952 element_info[i].ignition_delay = 1;
3956 // correct non-moving belts to start moving left
3957 for (i = 0; i < NUM_BELTS; i++)
3958 if (game.belt_dir[i] == MV_NONE)
3959 game.belt_dir_nr[i] = 3; // not moving, next moving left
3961 #if USE_NEW_PLAYER_ASSIGNMENTS
3962 // use preferred player also in local single-player mode
3963 if (!network.enabled && !game.team_mode)
3965 int new_index_nr = setup.network_player_nr;
3967 if (new_index_nr >= 0 && new_index_nr < MAX_PLAYERS)
3969 for (i = 0; i < MAX_PLAYERS; i++)
3970 stored_player[i].connected_locally = FALSE;
3972 stored_player[new_index_nr].connected_locally = TRUE;
3976 for (i = 0; i < MAX_PLAYERS; i++)
3978 stored_player[i].connected = FALSE;
3980 // in network game mode, the local player might not be the first player
3981 if (stored_player[i].connected_locally)
3982 local_player = &stored_player[i];
3985 if (!network.enabled)
3986 local_player->connected = TRUE;
3990 for (i = 0; i < MAX_PLAYERS; i++)
3991 stored_player[i].connected = tape.player_participates[i];
3993 else if (network.enabled)
3995 // add team mode players connected over the network (needed for correct
3996 // assignment of player figures from level to locally playing players)
3998 for (i = 0; i < MAX_PLAYERS; i++)
3999 if (stored_player[i].connected_network)
4000 stored_player[i].connected = TRUE;
4002 else if (game.team_mode)
4004 // try to guess locally connected team mode players (needed for correct
4005 // assignment of player figures from level to locally playing players)
4007 for (i = 0; i < MAX_PLAYERS; i++)
4008 if (setup.input[i].use_joystick ||
4009 setup.input[i].key.left != KSYM_UNDEFINED)
4010 stored_player[i].connected = TRUE;
4013 #if DEBUG_INIT_PLAYER
4014 DebugPrintPlayerStatus("Player status after level initialization");
4017 #if DEBUG_INIT_PLAYER
4018 Debug("game:init:player", "Reassigning players ...");
4021 // check if any connected player was not found in playfield
4022 for (i = 0; i < MAX_PLAYERS; i++)
4024 struct PlayerInfo *player = &stored_player[i];
4026 if (player->connected && !player->present)
4028 struct PlayerInfo *field_player = NULL;
4030 #if DEBUG_INIT_PLAYER
4031 Debug("game:init:player",
4032 "- looking for field player for player %d ...", i + 1);
4035 // assign first free player found that is present in the playfield
4037 // first try: look for unmapped playfield player that is not connected
4038 for (j = 0; j < MAX_PLAYERS; j++)
4039 if (field_player == NULL &&
4040 stored_player[j].present &&
4041 !stored_player[j].mapped &&
4042 !stored_player[j].connected)
4043 field_player = &stored_player[j];
4045 // second try: look for *any* unmapped playfield player
4046 for (j = 0; j < MAX_PLAYERS; j++)
4047 if (field_player == NULL &&
4048 stored_player[j].present &&
4049 !stored_player[j].mapped)
4050 field_player = &stored_player[j];
4052 if (field_player != NULL)
4054 int jx = field_player->jx, jy = field_player->jy;
4056 #if DEBUG_INIT_PLAYER
4057 Debug("game:init:player", "- found player %d",
4058 field_player->index_nr + 1);
4061 player->present = FALSE;
4062 player->active = FALSE;
4064 field_player->present = TRUE;
4065 field_player->active = TRUE;
4068 player->initial_element = field_player->initial_element;
4069 player->artwork_element = field_player->artwork_element;
4071 player->block_last_field = field_player->block_last_field;
4072 player->block_delay_adjustment = field_player->block_delay_adjustment;
4075 StorePlayer[jx][jy] = field_player->element_nr;
4077 field_player->jx = field_player->last_jx = jx;
4078 field_player->jy = field_player->last_jy = jy;
4080 if (local_player == player)
4081 local_player = field_player;
4083 map_player_action[field_player->index_nr] = i;
4085 field_player->mapped = TRUE;
4087 #if DEBUG_INIT_PLAYER
4088 Debug("game:init:player", "- map_player_action[%d] == %d",
4089 field_player->index_nr + 1, i + 1);
4094 if (player->connected && player->present)
4095 player->mapped = TRUE;
4098 #if DEBUG_INIT_PLAYER
4099 DebugPrintPlayerStatus("Player status after player assignment (first stage)");
4104 // check if any connected player was not found in playfield
4105 for (i = 0; i < MAX_PLAYERS; i++)
4107 struct PlayerInfo *player = &stored_player[i];
4109 if (player->connected && !player->present)
4111 for (j = 0; j < MAX_PLAYERS; j++)
4113 struct PlayerInfo *field_player = &stored_player[j];
4114 int jx = field_player->jx, jy = field_player->jy;
4116 // assign first free player found that is present in the playfield
4117 if (field_player->present && !field_player->connected)
4119 player->present = TRUE;
4120 player->active = TRUE;
4122 field_player->present = FALSE;
4123 field_player->active = FALSE;
4125 player->initial_element = field_player->initial_element;
4126 player->artwork_element = field_player->artwork_element;
4128 player->block_last_field = field_player->block_last_field;
4129 player->block_delay_adjustment = field_player->block_delay_adjustment;
4131 StorePlayer[jx][jy] = player->element_nr;
4133 player->jx = player->last_jx = jx;
4134 player->jy = player->last_jy = jy;
4144 Debug("game:init:player", "local_player->present == %d",
4145 local_player->present);
4148 // set focus to local player for network games, else to all players
4149 game.centered_player_nr = (network_playing ? local_player->index_nr : -1);
4150 game.centered_player_nr_next = game.centered_player_nr;
4151 game.set_centered_player = FALSE;
4152 game.set_centered_player_wrap = FALSE;
4154 if (network_playing && tape.recording)
4156 // store client dependent player focus when recording network games
4157 tape.centered_player_nr_next = game.centered_player_nr_next;
4158 tape.set_centered_player = TRUE;
4163 // when playing a tape, eliminate all players who do not participate
4165 #if USE_NEW_PLAYER_ASSIGNMENTS
4167 if (!game.team_mode)
4169 for (i = 0; i < MAX_PLAYERS; i++)
4171 if (stored_player[i].active &&
4172 !tape.player_participates[map_player_action[i]])
4174 struct PlayerInfo *player = &stored_player[i];
4175 int jx = player->jx, jy = player->jy;
4177 #if DEBUG_INIT_PLAYER
4178 Debug("game:init:player", "Removing player %d at (%d, %d)",
4182 player->active = FALSE;
4183 StorePlayer[jx][jy] = 0;
4184 Tile[jx][jy] = EL_EMPTY;
4191 for (i = 0; i < MAX_PLAYERS; i++)
4193 if (stored_player[i].active &&
4194 !tape.player_participates[i])
4196 struct PlayerInfo *player = &stored_player[i];
4197 int jx = player->jx, jy = player->jy;
4199 player->active = FALSE;
4200 StorePlayer[jx][jy] = 0;
4201 Tile[jx][jy] = EL_EMPTY;
4206 else if (!network.enabled && !game.team_mode) // && !tape.playing
4208 // when in single player mode, eliminate all but the local player
4210 for (i = 0; i < MAX_PLAYERS; i++)
4212 struct PlayerInfo *player = &stored_player[i];
4214 if (player->active && player != local_player)
4216 int jx = player->jx, jy = player->jy;
4218 player->active = FALSE;
4219 player->present = FALSE;
4221 StorePlayer[jx][jy] = 0;
4222 Tile[jx][jy] = EL_EMPTY;
4227 for (i = 0; i < MAX_PLAYERS; i++)
4228 if (stored_player[i].active)
4229 game.players_still_needed++;
4231 if (level.solved_by_one_player)
4232 game.players_still_needed = 1;
4234 // when recording the game, store which players take part in the game
4237 #if USE_NEW_PLAYER_ASSIGNMENTS
4238 for (i = 0; i < MAX_PLAYERS; i++)
4239 if (stored_player[i].connected)
4240 tape.player_participates[i] = TRUE;
4242 for (i = 0; i < MAX_PLAYERS; i++)
4243 if (stored_player[i].active)
4244 tape.player_participates[i] = TRUE;
4248 #if DEBUG_INIT_PLAYER
4249 DebugPrintPlayerStatus("Player status after player assignment (final stage)");
4252 if (BorderElement == EL_EMPTY)
4255 SBX_Right = lev_fieldx - SCR_FIELDX;
4257 SBY_Lower = lev_fieldy - SCR_FIELDY;
4262 SBX_Right = lev_fieldx - SCR_FIELDX + 1;
4264 SBY_Lower = lev_fieldy - SCR_FIELDY + 1;
4267 if (full_lev_fieldx <= SCR_FIELDX)
4268 SBX_Left = SBX_Right = -1 * (SCR_FIELDX - lev_fieldx) / 2;
4269 if (full_lev_fieldy <= SCR_FIELDY)
4270 SBY_Upper = SBY_Lower = -1 * (SCR_FIELDY - lev_fieldy) / 2;
4272 if (EVEN(SCR_FIELDX) && full_lev_fieldx > SCR_FIELDX)
4274 if (EVEN(SCR_FIELDY) && full_lev_fieldy > SCR_FIELDY)
4277 // if local player not found, look for custom element that might create
4278 // the player (make some assumptions about the right custom element)
4279 if (!local_player->present)
4281 int start_x = 0, start_y = 0;
4282 int found_rating = 0;
4283 int found_element = EL_UNDEFINED;
4284 int player_nr = local_player->index_nr;
4286 SCAN_PLAYFIELD(x, y)
4288 int element = Tile[x][y];
4293 if (level.use_start_element[player_nr] &&
4294 level.start_element[player_nr] == element &&
4301 found_element = element;
4304 if (!IS_CUSTOM_ELEMENT(element))
4307 if (CAN_CHANGE(element))
4309 for (i = 0; i < element_info[element].num_change_pages; i++)
4311 // check for player created from custom element as single target
4312 content = element_info[element].change_page[i].target_element;
4313 is_player = ELEM_IS_PLAYER(content);
4315 if (is_player && (found_rating < 3 ||
4316 (found_rating == 3 && element < found_element)))
4322 found_element = element;
4327 for (yy = 0; yy < 3; yy++) for (xx = 0; xx < 3; xx++)
4329 // check for player created from custom element as explosion content
4330 content = element_info[element].content.e[xx][yy];
4331 is_player = ELEM_IS_PLAYER(content);
4333 if (is_player && (found_rating < 2 ||
4334 (found_rating == 2 && element < found_element)))
4336 start_x = x + xx - 1;
4337 start_y = y + yy - 1;
4340 found_element = element;
4343 if (!CAN_CHANGE(element))
4346 for (i = 0; i < element_info[element].num_change_pages; i++)
4348 // check for player created from custom element as extended target
4350 element_info[element].change_page[i].target_content.e[xx][yy];
4352 is_player = ELEM_IS_PLAYER(content);
4354 if (is_player && (found_rating < 1 ||
4355 (found_rating == 1 && element < found_element)))
4357 start_x = x + xx - 1;
4358 start_y = y + yy - 1;
4361 found_element = element;
4367 scroll_x = SCROLL_POSITION_X(start_x);
4368 scroll_y = SCROLL_POSITION_Y(start_y);
4372 scroll_x = SCROLL_POSITION_X(local_player->jx);
4373 scroll_y = SCROLL_POSITION_Y(local_player->jy);
4376 // !!! FIX THIS (START) !!!
4377 if (level.game_engine_type == GAME_ENGINE_TYPE_EM)
4379 InitGameEngine_EM();
4381 else if (level.game_engine_type == GAME_ENGINE_TYPE_SP)
4383 InitGameEngine_SP();
4385 else if (level.game_engine_type == GAME_ENGINE_TYPE_MM)
4387 InitGameEngine_MM();
4391 DrawLevel(REDRAW_FIELD);
4394 // after drawing the level, correct some elements
4395 if (game.timegate_time_left == 0)
4396 CloseAllOpenTimegates();
4399 // blit playfield from scroll buffer to normal back buffer for fading in
4400 BlitScreenToBitmap(backbuffer);
4401 // !!! FIX THIS (END) !!!
4403 DrawMaskedBorder(fade_mask);
4408 // full screen redraw is required at this point in the following cases:
4409 // - special editor door undrawn when game was started from level editor
4410 // - drawing area (playfield) was changed and has to be removed completely
4411 redraw_mask = REDRAW_ALL;
4415 if (!game.restart_level)
4417 // copy default game door content to main double buffer
4419 // !!! CHECK AGAIN !!!
4420 SetPanelBackground();
4421 // SetDoorBackgroundImage(IMG_BACKGROUND_PANEL);
4422 DrawBackground(DX, DY, DXSIZE, DYSIZE);
4425 SetPanelBackground();
4426 SetDrawBackgroundMask(REDRAW_DOOR_1);
4428 UpdateAndDisplayGameControlValues();
4430 if (!game.restart_level)
4436 CreateGameButtons();
4441 // copy actual game door content to door double buffer for OpenDoor()
4442 BlitBitmap(drawto, bitmap_db_door_1, DX, DY, DXSIZE, DYSIZE, 0, 0);
4444 OpenDoor(DOOR_OPEN_ALL);
4446 KeyboardAutoRepeatOffUnlessAutoplay();
4448 #if DEBUG_INIT_PLAYER
4449 DebugPrintPlayerStatus("Player status (final)");
4458 if (!game.restart_level && !tape.playing)
4460 LevelStats_incPlayed(level_nr);
4462 SaveLevelSetup_SeriesInfo();
4465 game.restart_level = FALSE;
4466 game.restart_game_message = NULL;
4468 game.request_active = FALSE;
4469 game.request_active_or_moving = FALSE;
4471 if (level.game_engine_type == GAME_ENGINE_TYPE_MM)
4472 InitGameActions_MM();
4474 SaveEngineSnapshotToListInitial();
4476 if (!game.restart_level)
4478 PlaySound(SND_GAME_STARTING);
4480 if (setup.sound_music)
4485 void UpdateEngineValues(int actual_scroll_x, int actual_scroll_y,
4486 int actual_player_x, int actual_player_y)
4488 // this is used for non-R'n'D game engines to update certain engine values
4490 // needed to determine if sounds are played within the visible screen area
4491 scroll_x = actual_scroll_x;
4492 scroll_y = actual_scroll_y;
4494 // needed to get player position for "follow finger" playing input method
4495 local_player->jx = actual_player_x;
4496 local_player->jy = actual_player_y;
4499 void InitMovDir(int x, int y)
4501 int i, element = Tile[x][y];
4502 static int xy[4][2] =
4509 static int direction[3][4] =
4511 { MV_RIGHT, MV_UP, MV_LEFT, MV_DOWN },
4512 { MV_LEFT, MV_DOWN, MV_RIGHT, MV_UP },
4513 { MV_LEFT, MV_RIGHT, MV_UP, MV_DOWN }
4522 Tile[x][y] = EL_BUG;
4523 MovDir[x][y] = direction[0][element - EL_BUG_RIGHT];
4526 case EL_SPACESHIP_RIGHT:
4527 case EL_SPACESHIP_UP:
4528 case EL_SPACESHIP_LEFT:
4529 case EL_SPACESHIP_DOWN:
4530 Tile[x][y] = EL_SPACESHIP;
4531 MovDir[x][y] = direction[0][element - EL_SPACESHIP_RIGHT];
4534 case EL_BD_BUTTERFLY_RIGHT:
4535 case EL_BD_BUTTERFLY_UP:
4536 case EL_BD_BUTTERFLY_LEFT:
4537 case EL_BD_BUTTERFLY_DOWN:
4538 Tile[x][y] = EL_BD_BUTTERFLY;
4539 MovDir[x][y] = direction[0][element - EL_BD_BUTTERFLY_RIGHT];
4542 case EL_BD_FIREFLY_RIGHT:
4543 case EL_BD_FIREFLY_UP:
4544 case EL_BD_FIREFLY_LEFT:
4545 case EL_BD_FIREFLY_DOWN:
4546 Tile[x][y] = EL_BD_FIREFLY;
4547 MovDir[x][y] = direction[0][element - EL_BD_FIREFLY_RIGHT];
4550 case EL_PACMAN_RIGHT:
4552 case EL_PACMAN_LEFT:
4553 case EL_PACMAN_DOWN:
4554 Tile[x][y] = EL_PACMAN;
4555 MovDir[x][y] = direction[0][element - EL_PACMAN_RIGHT];
4558 case EL_YAMYAM_LEFT:
4559 case EL_YAMYAM_RIGHT:
4561 case EL_YAMYAM_DOWN:
4562 Tile[x][y] = EL_YAMYAM;
4563 MovDir[x][y] = direction[2][element - EL_YAMYAM_LEFT];
4566 case EL_SP_SNIKSNAK:
4567 MovDir[x][y] = MV_UP;
4570 case EL_SP_ELECTRON:
4571 MovDir[x][y] = MV_LEFT;
4578 Tile[x][y] = EL_MOLE;
4579 MovDir[x][y] = direction[2][element - EL_MOLE_LEFT];
4582 case EL_SPRING_LEFT:
4583 case EL_SPRING_RIGHT:
4584 Tile[x][y] = EL_SPRING;
4585 MovDir[x][y] = direction[2][element - EL_SPRING_LEFT];
4589 if (IS_CUSTOM_ELEMENT(element))
4591 struct ElementInfo *ei = &element_info[element];
4592 int move_direction_initial = ei->move_direction_initial;
4593 int move_pattern = ei->move_pattern;
4595 if (move_direction_initial == MV_START_PREVIOUS)
4597 if (MovDir[x][y] != MV_NONE)
4600 move_direction_initial = MV_START_AUTOMATIC;
4603 if (move_direction_initial == MV_START_RANDOM)
4604 MovDir[x][y] = 1 << RND(4);
4605 else if (move_direction_initial & MV_ANY_DIRECTION)
4606 MovDir[x][y] = move_direction_initial;
4607 else if (move_pattern == MV_ALL_DIRECTIONS ||
4608 move_pattern == MV_TURNING_LEFT ||
4609 move_pattern == MV_TURNING_RIGHT ||
4610 move_pattern == MV_TURNING_LEFT_RIGHT ||
4611 move_pattern == MV_TURNING_RIGHT_LEFT ||
4612 move_pattern == MV_TURNING_RANDOM)
4613 MovDir[x][y] = 1 << RND(4);
4614 else if (move_pattern == MV_HORIZONTAL)
4615 MovDir[x][y] = (RND(2) ? MV_LEFT : MV_RIGHT);
4616 else if (move_pattern == MV_VERTICAL)
4617 MovDir[x][y] = (RND(2) ? MV_UP : MV_DOWN);
4618 else if (move_pattern & MV_ANY_DIRECTION)
4619 MovDir[x][y] = element_info[element].move_pattern;
4620 else if (move_pattern == MV_ALONG_LEFT_SIDE ||
4621 move_pattern == MV_ALONG_RIGHT_SIDE)
4623 // use random direction as default start direction
4624 if (game.engine_version >= VERSION_IDENT(3,1,0,0))
4625 MovDir[x][y] = 1 << RND(4);
4627 for (i = 0; i < NUM_DIRECTIONS; i++)
4629 int x1 = x + xy[i][0];
4630 int y1 = y + xy[i][1];
4632 if (!IN_LEV_FIELD(x1, y1) || !IS_FREE(x1, y1))
4634 if (move_pattern == MV_ALONG_RIGHT_SIDE)
4635 MovDir[x][y] = direction[0][i];
4637 MovDir[x][y] = direction[1][i];
4646 MovDir[x][y] = 1 << RND(4);
4648 if (element != EL_BUG &&
4649 element != EL_SPACESHIP &&
4650 element != EL_BD_BUTTERFLY &&
4651 element != EL_BD_FIREFLY)
4654 for (i = 0; i < NUM_DIRECTIONS; i++)
4656 int x1 = x + xy[i][0];
4657 int y1 = y + xy[i][1];
4659 if (!IN_LEV_FIELD(x1, y1) || !IS_FREE(x1, y1))
4661 if (element == EL_BUG || element == EL_BD_BUTTERFLY)
4663 MovDir[x][y] = direction[0][i];
4666 else if (element == EL_SPACESHIP || element == EL_BD_FIREFLY ||
4667 element == EL_SP_SNIKSNAK || element == EL_SP_ELECTRON)
4669 MovDir[x][y] = direction[1][i];
4678 GfxDir[x][y] = MovDir[x][y];
4681 void InitAmoebaNr(int x, int y)
4684 int group_nr = AmoebaNeighbourNr(x, y);
4688 for (i = 1; i < MAX_NUM_AMOEBA; i++)
4690 if (AmoebaCnt[i] == 0)
4698 AmoebaNr[x][y] = group_nr;
4699 AmoebaCnt[group_nr]++;
4700 AmoebaCnt2[group_nr]++;
4703 static void LevelSolved(void)
4705 if (level.game_engine_type == GAME_ENGINE_TYPE_RND &&
4706 game.players_still_needed > 0)
4709 game.LevelSolved = TRUE;
4710 game.GameOver = TRUE;
4712 game.time_final = (game.no_time_limit ? TimePlayed : TimeLeft);
4713 game.score_time_final = (level.use_step_counter ? TimePlayed :
4714 TimePlayed * FRAMES_PER_SECOND + TimeFrames);
4716 game.score_final = (level.game_engine_type == GAME_ENGINE_TYPE_EM ?
4717 game_em.lev->score :
4718 level.game_engine_type == GAME_ENGINE_TYPE_MM ?
4722 game.health_final = (level.game_engine_type == GAME_ENGINE_TYPE_MM ?
4723 MM_HEALTH(game_mm.laser_overload_value) :
4726 game.LevelSolved_CountingTime = game.time_final;
4727 game.LevelSolved_CountingScore = game.score_final;
4728 game.LevelSolved_CountingHealth = game.health_final;
4733 static int time_count_steps;
4734 static int time, time_final;
4735 static float score, score_final; // needed for time score < 10 for 10 seconds
4736 static int health, health_final;
4737 static int game_over_delay_1 = 0;
4738 static int game_over_delay_2 = 0;
4739 static int game_over_delay_3 = 0;
4740 int time_score_base = MIN(MAX(1, level.time_score_base), 10);
4741 float time_score = (float)level.score[SC_TIME_BONUS] / time_score_base;
4743 if (!game.LevelSolved_GameWon)
4747 // do not start end game actions before the player stops moving (to exit)
4748 if (local_player->active && local_player->MovPos)
4751 game.LevelSolved_GameWon = TRUE;
4752 game.LevelSolved_SaveTape = tape.recording;
4753 game.LevelSolved_SaveScore = !tape.playing;
4757 LevelStats_incSolved(level_nr);
4759 SaveLevelSetup_SeriesInfo();
4762 if (tape.auto_play) // tape might already be stopped here
4763 tape.auto_play_level_solved = TRUE;
4767 game_over_delay_1 = FRAMES_PER_SECOND; // delay before counting time
4768 game_over_delay_2 = FRAMES_PER_SECOND / 2; // delay before counting health
4769 game_over_delay_3 = FRAMES_PER_SECOND; // delay before ending the game
4771 time = time_final = game.time_final;
4772 score = score_final = game.score_final;
4773 health = health_final = game.health_final;
4777 int time_final_max = 999;
4778 int time_frames_final_max = time_final_max * FRAMES_PER_SECOND;
4779 int time_frames = 0;
4780 int time_frames_left = TimeLeft * FRAMES_PER_SECOND - TimeFrames;
4781 int time_frames_played = TimePlayed * FRAMES_PER_SECOND + TimeFrames;
4786 time_frames = time_frames_left;
4788 else if (game.no_time_limit && TimePlayed < time_final_max)
4790 time_final = time_final_max;
4791 time_frames = time_frames_final_max - time_frames_played;
4794 score_final += time_score * time_frames / FRAMES_PER_SECOND + 0.5;
4796 time_count_steps = MAX(1, ABS(time_final - time) / 100);
4798 if (level.game_engine_type == GAME_ENGINE_TYPE_MM)
4801 score_final += health * time_score;
4804 game.score_final = score_final;
4805 game.health_final = health_final;
4808 if (level_editor_test_game || !setup.count_score_after_game)
4811 score = score_final;
4813 game.LevelSolved_CountingTime = time;
4814 game.LevelSolved_CountingScore = score;
4816 game_panel_controls[GAME_PANEL_TIME].value = time;
4817 game_panel_controls[GAME_PANEL_SCORE].value = score;
4819 DisplayGameControlValues();
4822 if (level.game_engine_type == GAME_ENGINE_TYPE_RND)
4824 // check if last player has left the level
4825 if (game.exit_x >= 0 &&
4828 int x = game.exit_x;
4829 int y = game.exit_y;
4830 int element = Tile[x][y];
4832 // close exit door after last player
4833 if ((game.all_players_gone &&
4834 (element == EL_EXIT_OPEN ||
4835 element == EL_SP_EXIT_OPEN ||
4836 element == EL_STEEL_EXIT_OPEN)) ||
4837 element == EL_EM_EXIT_OPEN ||
4838 element == EL_EM_STEEL_EXIT_OPEN)
4842 (element == EL_EXIT_OPEN ? EL_EXIT_CLOSING :
4843 element == EL_EM_EXIT_OPEN ? EL_EM_EXIT_CLOSING :
4844 element == EL_SP_EXIT_OPEN ? EL_SP_EXIT_CLOSING:
4845 element == EL_STEEL_EXIT_OPEN ? EL_STEEL_EXIT_CLOSING:
4846 EL_EM_STEEL_EXIT_CLOSING);
4848 PlayLevelSoundElementAction(x, y, element, ACTION_CLOSING);
4851 // player disappears
4852 DrawLevelField(x, y);
4855 for (i = 0; i < MAX_PLAYERS; i++)
4857 struct PlayerInfo *player = &stored_player[i];
4859 if (player->present)
4861 RemovePlayer(player);
4863 // player disappears
4864 DrawLevelField(player->jx, player->jy);
4869 PlaySound(SND_GAME_WINNING);
4872 if (setup.count_score_after_game)
4874 if (time != time_final)
4876 if (game_over_delay_1 > 0)
4878 game_over_delay_1--;
4883 int time_to_go = ABS(time_final - time);
4884 int time_count_dir = (time < time_final ? +1 : -1);
4886 if (time_to_go < time_count_steps)
4887 time_count_steps = 1;
4889 time += time_count_steps * time_count_dir;
4890 score += time_count_steps * time_score;
4892 // set final score to correct rounding differences after counting score
4893 if (time == time_final)
4894 score = score_final;
4896 game.LevelSolved_CountingTime = time;
4897 game.LevelSolved_CountingScore = score;
4899 game_panel_controls[GAME_PANEL_TIME].value = time;
4900 game_panel_controls[GAME_PANEL_SCORE].value = score;
4902 DisplayGameControlValues();
4904 if (time == time_final)
4905 StopSound(SND_GAME_LEVELTIME_BONUS);
4906 else if (setup.sound_loops)
4907 PlaySoundLoop(SND_GAME_LEVELTIME_BONUS);
4909 PlaySound(SND_GAME_LEVELTIME_BONUS);
4914 if (health != health_final)
4916 if (game_over_delay_2 > 0)
4918 game_over_delay_2--;
4923 int health_count_dir = (health < health_final ? +1 : -1);
4925 health += health_count_dir;
4926 score += time_score;
4928 game.LevelSolved_CountingHealth = health;
4929 game.LevelSolved_CountingScore = score;
4931 game_panel_controls[GAME_PANEL_HEALTH].value = health;
4932 game_panel_controls[GAME_PANEL_SCORE].value = score;
4934 DisplayGameControlValues();
4936 if (health == health_final)
4937 StopSound(SND_GAME_LEVELTIME_BONUS);
4938 else if (setup.sound_loops)
4939 PlaySoundLoop(SND_GAME_LEVELTIME_BONUS);
4941 PlaySound(SND_GAME_LEVELTIME_BONUS);
4947 game.panel.active = FALSE;
4949 if (game_over_delay_3 > 0)
4951 game_over_delay_3--;
4961 // used instead of "level_nr" (needed for network games)
4962 int last_level_nr = levelset.level_nr;
4965 game.LevelSolved_GameEnd = TRUE;
4967 if (game.LevelSolved_SaveTape)
4969 // make sure that request dialog to save tape does not open door again
4970 if (!global.use_envelope_request)
4971 CloseDoor(DOOR_CLOSE_1);
4973 SaveTapeChecked_LevelSolved(tape.level_nr); // ask to save tape
4976 // if no tape is to be saved, close both doors simultaneously
4977 CloseDoor(DOOR_CLOSE_ALL);
4979 if (level_editor_test_game)
4981 SetGameStatus(GAME_MODE_MAIN);
4988 if (!game.LevelSolved_SaveScore)
4990 SetGameStatus(GAME_MODE_MAIN);
4997 if (level_nr == leveldir_current->handicap_level)
4999 leveldir_current->handicap_level++;
5001 SaveLevelSetup_SeriesInfo();
5004 if (setup.increment_levels &&
5005 level_nr < leveldir_current->last_level &&
5008 level_nr++; // advance to next level
5009 TapeErase(); // start with empty tape
5011 if (setup.auto_play_next_level)
5013 LoadLevel(level_nr);
5015 SaveLevelSetup_SeriesInfo();
5019 hi_pos = NewHiScore(last_level_nr);
5021 if (hi_pos >= 0 && setup.show_scores_after_game)
5023 SetGameStatus(GAME_MODE_SCORES);
5025 DrawHallOfFame(last_level_nr, hi_pos);
5027 else if (setup.auto_play_next_level && setup.increment_levels &&
5028 last_level_nr < leveldir_current->last_level &&
5031 StartGameActions(network.enabled, setup.autorecord, level.random_seed);
5035 SetGameStatus(GAME_MODE_MAIN);
5041 int NewHiScore(int level_nr)
5045 boolean one_score_entry_per_name = !program.many_scores_per_name;
5047 LoadScore(level_nr);
5049 if (strEqual(setup.player_name, EMPTY_PLAYER_NAME) ||
5050 game.score_final < scores.entry[MAX_SCORE_ENTRIES - 1].score)
5053 for (k = 0; k < MAX_SCORE_ENTRIES; k++)
5055 boolean score_is_better = (game.score_final > scores.entry[k].score);
5056 boolean score_is_equal = (game.score_final == scores.entry[k].score);
5057 boolean time_is_better = (game.score_time_final < scores.entry[k].time);
5059 if (score_is_better || (score_is_equal && time_is_better))
5061 // player has made it to the hall of fame
5063 if (k < MAX_SCORE_ENTRIES - 1)
5065 int m = MAX_SCORE_ENTRIES - 1;
5067 if (one_score_entry_per_name)
5069 for (l = k; l < MAX_SCORE_ENTRIES; l++)
5070 if (strEqual(setup.player_name, scores.entry[l].name))
5073 if (m == k) // player's new highscore overwrites his old one
5077 for (l = m; l > k; l--)
5079 strcpy(scores.entry[l].name, scores.entry[l - 1].name);
5080 scores.entry[l].score = scores.entry[l - 1].score;
5081 scores.entry[l].time = scores.entry[l - 1].time;
5087 strncpy(scores.entry[k].name, setup.player_name, MAX_PLAYER_NAME_LEN);
5088 scores.entry[k].name[MAX_PLAYER_NAME_LEN] = '\0';
5089 scores.entry[k].score = game.score_final;
5090 scores.entry[k].time = game.score_time_final;
5095 else if (one_score_entry_per_name &&
5096 !strncmp(setup.player_name, scores.entry[k].name,
5097 MAX_PLAYER_NAME_LEN))
5098 break; // player already there with a higher score
5102 SaveScore(level_nr);
5107 static int getElementMoveStepsizeExt(int x, int y, int direction)
5109 int element = Tile[x][y];
5110 int dx = (direction == MV_LEFT ? -1 : direction == MV_RIGHT ? +1 : 0);
5111 int dy = (direction == MV_UP ? -1 : direction == MV_DOWN ? +1 : 0);
5112 int horiz_move = (dx != 0);
5113 int sign = (horiz_move ? dx : dy);
5114 int step = sign * element_info[element].move_stepsize;
5116 // special values for move stepsize for spring and things on conveyor belt
5119 if (CAN_FALL(element) &&
5120 y < lev_fieldy - 1 && IS_BELT_ACTIVE(Tile[x][y + 1]))
5121 step = sign * MOVE_STEPSIZE_NORMAL / 2;
5122 else if (element == EL_SPRING)
5123 step = sign * MOVE_STEPSIZE_NORMAL * 2;
5129 static int getElementMoveStepsize(int x, int y)
5131 return getElementMoveStepsizeExt(x, y, MovDir[x][y]);
5134 void InitPlayerGfxAnimation(struct PlayerInfo *player, int action, int dir)
5136 if (player->GfxAction != action || player->GfxDir != dir)
5138 player->GfxAction = action;
5139 player->GfxDir = dir;
5141 player->StepFrame = 0;
5145 static void ResetGfxFrame(int x, int y)
5147 // profiling showed that "autotest" spends 10~20% of its time in this function
5148 if (DrawingDeactivatedField())
5151 int element = Tile[x][y];
5152 int graphic = el_act_dir2img(element, GfxAction[x][y], GfxDir[x][y]);
5154 if (graphic_info[graphic].anim_global_sync)
5155 GfxFrame[x][y] = FrameCounter;
5156 else if (ANIM_MODE(graphic) == ANIM_CE_VALUE)
5157 GfxFrame[x][y] = CustomValue[x][y];
5158 else if (ANIM_MODE(graphic) == ANIM_CE_SCORE)
5159 GfxFrame[x][y] = element_info[element].collect_score;
5160 else if (ANIM_MODE(graphic) == ANIM_CE_DELAY)
5161 GfxFrame[x][y] = ChangeDelay[x][y];
5164 static void ResetGfxAnimation(int x, int y)
5166 GfxAction[x][y] = ACTION_DEFAULT;
5167 GfxDir[x][y] = MovDir[x][y];
5170 ResetGfxFrame(x, y);
5173 static void ResetRandomAnimationValue(int x, int y)
5175 GfxRandom[x][y] = INIT_GFX_RANDOM();
5178 static void InitMovingField(int x, int y, int direction)
5180 int element = Tile[x][y];
5181 int dx = (direction == MV_LEFT ? -1 : direction == MV_RIGHT ? +1 : 0);
5182 int dy = (direction == MV_UP ? -1 : direction == MV_DOWN ? +1 : 0);
5185 boolean is_moving_before, is_moving_after;
5187 // check if element was/is moving or being moved before/after mode change
5188 is_moving_before = (WasJustMoving[x][y] != 0);
5189 is_moving_after = (getElementMoveStepsizeExt(x, y, direction) != 0);
5191 // reset animation only for moving elements which change direction of moving
5192 // or which just started or stopped moving
5193 // (else CEs with property "can move" / "not moving" are reset each frame)
5194 if (is_moving_before != is_moving_after ||
5195 direction != MovDir[x][y])
5196 ResetGfxAnimation(x, y);
5198 MovDir[x][y] = direction;
5199 GfxDir[x][y] = direction;
5201 GfxAction[x][y] = (!is_moving_after ? ACTION_WAITING :
5202 direction == MV_DOWN && CAN_FALL(element) ?
5203 ACTION_FALLING : ACTION_MOVING);
5205 // this is needed for CEs with property "can move" / "not moving"
5207 if (is_moving_after)
5209 if (Tile[newx][newy] == EL_EMPTY)
5210 Tile[newx][newy] = EL_BLOCKED;
5212 MovDir[newx][newy] = MovDir[x][y];
5214 CustomValue[newx][newy] = CustomValue[x][y];
5216 GfxFrame[newx][newy] = GfxFrame[x][y];
5217 GfxRandom[newx][newy] = GfxRandom[x][y];
5218 GfxAction[newx][newy] = GfxAction[x][y];
5219 GfxDir[newx][newy] = GfxDir[x][y];
5223 void Moving2Blocked(int x, int y, int *goes_to_x, int *goes_to_y)
5225 int direction = MovDir[x][y];
5226 int newx = x + (direction & MV_LEFT ? -1 : direction & MV_RIGHT ? +1 : 0);
5227 int newy = y + (direction & MV_UP ? -1 : direction & MV_DOWN ? +1 : 0);
5233 void Blocked2Moving(int x, int y, int *comes_from_x, int *comes_from_y)
5235 int oldx = x, oldy = y;
5236 int direction = MovDir[x][y];
5238 if (direction == MV_LEFT)
5240 else if (direction == MV_RIGHT)
5242 else if (direction == MV_UP)
5244 else if (direction == MV_DOWN)
5247 *comes_from_x = oldx;
5248 *comes_from_y = oldy;
5251 static int MovingOrBlocked2Element(int x, int y)
5253 int element = Tile[x][y];
5255 if (element == EL_BLOCKED)
5259 Blocked2Moving(x, y, &oldx, &oldy);
5260 return Tile[oldx][oldy];
5266 static int MovingOrBlocked2ElementIfNotLeaving(int x, int y)
5268 // like MovingOrBlocked2Element(), but if element is moving
5269 // and (x,y) is the field the moving element is just leaving,
5270 // return EL_BLOCKED instead of the element value
5271 int element = Tile[x][y];
5273 if (IS_MOVING(x, y))
5275 if (element == EL_BLOCKED)
5279 Blocked2Moving(x, y, &oldx, &oldy);
5280 return Tile[oldx][oldy];
5289 static void RemoveField(int x, int y)
5291 Tile[x][y] = EL_EMPTY;
5297 CustomValue[x][y] = 0;
5300 ChangeDelay[x][y] = 0;
5301 ChangePage[x][y] = -1;
5302 Pushed[x][y] = FALSE;
5304 GfxElement[x][y] = EL_UNDEFINED;
5305 GfxAction[x][y] = ACTION_DEFAULT;
5306 GfxDir[x][y] = MV_NONE;
5309 static void RemoveMovingField(int x, int y)
5311 int oldx = x, oldy = y, newx = x, newy = y;
5312 int element = Tile[x][y];
5313 int next_element = EL_UNDEFINED;
5315 if (element != EL_BLOCKED && !IS_MOVING(x, y))
5318 if (IS_MOVING(x, y))
5320 Moving2Blocked(x, y, &newx, &newy);
5322 if (Tile[newx][newy] != EL_BLOCKED)
5324 // element is moving, but target field is not free (blocked), but
5325 // already occupied by something different (example: acid pool);
5326 // in this case, only remove the moving field, but not the target
5328 RemoveField(oldx, oldy);
5330 Store[oldx][oldy] = Store2[oldx][oldy] = 0;
5332 TEST_DrawLevelField(oldx, oldy);
5337 else if (element == EL_BLOCKED)
5339 Blocked2Moving(x, y, &oldx, &oldy);
5340 if (!IS_MOVING(oldx, oldy))
5344 if (element == EL_BLOCKED &&
5345 (Tile[oldx][oldy] == EL_QUICKSAND_EMPTYING ||
5346 Tile[oldx][oldy] == EL_QUICKSAND_FAST_EMPTYING ||
5347 Tile[oldx][oldy] == EL_MAGIC_WALL_EMPTYING ||
5348 Tile[oldx][oldy] == EL_BD_MAGIC_WALL_EMPTYING ||
5349 Tile[oldx][oldy] == EL_DC_MAGIC_WALL_EMPTYING ||
5350 Tile[oldx][oldy] == EL_AMOEBA_DROPPING))
5351 next_element = get_next_element(Tile[oldx][oldy]);
5353 RemoveField(oldx, oldy);
5354 RemoveField(newx, newy);
5356 Store[oldx][oldy] = Store2[oldx][oldy] = 0;
5358 if (next_element != EL_UNDEFINED)
5359 Tile[oldx][oldy] = next_element;
5361 TEST_DrawLevelField(oldx, oldy);
5362 TEST_DrawLevelField(newx, newy);
5365 void DrawDynamite(int x, int y)
5367 int sx = SCREENX(x), sy = SCREENY(y);
5368 int graphic = el2img(Tile[x][y]);
5371 if (!IN_SCR_FIELD(sx, sy) || IS_PLAYER(x, y))
5374 if (IS_WALKABLE_INSIDE(Back[x][y]))
5378 DrawLevelElement(x, y, Back[x][y]);
5379 else if (Store[x][y])
5380 DrawLevelElement(x, y, Store[x][y]);
5381 else if (game.use_masked_elements)
5382 DrawLevelElement(x, y, EL_EMPTY);
5384 frame = getGraphicAnimationFrame(graphic, GfxFrame[x][y]);
5386 if (Back[x][y] || Store[x][y] || game.use_masked_elements)
5387 DrawGraphicThruMask(sx, sy, graphic, frame);
5389 DrawGraphic(sx, sy, graphic, frame);
5392 static void CheckDynamite(int x, int y)
5394 if (MovDelay[x][y] != 0) // dynamite is still waiting to explode
5398 if (MovDelay[x][y] != 0)
5401 PlayLevelSoundActionIfLoop(x, y, ACTION_ACTIVE);
5407 StopLevelSoundActionIfLoop(x, y, ACTION_ACTIVE);
5412 static void setMinimalPlayerBoundaries(int *sx1, int *sy1, int *sx2, int *sy2)
5414 boolean num_checked_players = 0;
5417 for (i = 0; i < MAX_PLAYERS; i++)
5419 if (stored_player[i].active)
5421 int sx = stored_player[i].jx;
5422 int sy = stored_player[i].jy;
5424 if (num_checked_players == 0)
5431 *sx1 = MIN(*sx1, sx);
5432 *sy1 = MIN(*sy1, sy);
5433 *sx2 = MAX(*sx2, sx);
5434 *sy2 = MAX(*sy2, sy);
5437 num_checked_players++;
5442 static boolean checkIfAllPlayersFitToScreen_RND(void)
5444 int sx1 = 0, sy1 = 0, sx2 = 0, sy2 = 0;
5446 setMinimalPlayerBoundaries(&sx1, &sy1, &sx2, &sy2);
5448 return (sx2 - sx1 < SCR_FIELDX &&
5449 sy2 - sy1 < SCR_FIELDY);
5452 static void setScreenCenteredToAllPlayers(int *sx, int *sy)
5454 int sx1 = scroll_x, sy1 = scroll_y, sx2 = scroll_x, sy2 = scroll_y;
5456 setMinimalPlayerBoundaries(&sx1, &sy1, &sx2, &sy2);
5458 *sx = (sx1 + sx2) / 2;
5459 *sy = (sy1 + sy2) / 2;
5462 static void DrawRelocateScreen(int old_x, int old_y, int x, int y, int move_dir,
5463 boolean center_screen, boolean quick_relocation)
5465 unsigned int frame_delay_value_old = GetVideoFrameDelay();
5466 boolean ffwd_delay = (tape.playing && tape.fast_forward);
5467 boolean no_delay = (tape.warp_forward);
5468 int frame_delay_value = (ffwd_delay ? FfwdFrameDelay : GameFrameDelay);
5469 int wait_delay_value = (no_delay ? 0 : frame_delay_value);
5470 int new_scroll_x, new_scroll_y;
5472 if (level.lazy_relocation && IN_VIS_FIELD(SCREENX(x), SCREENY(y)))
5474 // case 1: quick relocation inside visible screen (without scrolling)
5481 if (!level.shifted_relocation || center_screen)
5483 // relocation _with_ centering of screen
5485 new_scroll_x = SCROLL_POSITION_X(x);
5486 new_scroll_y = SCROLL_POSITION_Y(y);
5490 // relocation _without_ centering of screen
5492 int center_scroll_x = SCROLL_POSITION_X(old_x);
5493 int center_scroll_y = SCROLL_POSITION_Y(old_y);
5494 int offset_x = x + (scroll_x - center_scroll_x);
5495 int offset_y = y + (scroll_y - center_scroll_y);
5497 // for new screen position, apply previous offset to center position
5498 new_scroll_x = SCROLL_POSITION_X(offset_x);
5499 new_scroll_y = SCROLL_POSITION_Y(offset_y);
5502 if (quick_relocation)
5504 // case 2: quick relocation (redraw without visible scrolling)
5506 scroll_x = new_scroll_x;
5507 scroll_y = new_scroll_y;
5514 // case 3: visible relocation (with scrolling to new position)
5516 ScrollScreen(NULL, SCROLL_GO_ON); // scroll last frame to full tile
5518 SetVideoFrameDelay(wait_delay_value);
5520 while (scroll_x != new_scroll_x || scroll_y != new_scroll_y)
5522 int dx = (new_scroll_x < scroll_x ? +1 : new_scroll_x > scroll_x ? -1 : 0);
5523 int dy = (new_scroll_y < scroll_y ? +1 : new_scroll_y > scroll_y ? -1 : 0);
5525 if (dx == 0 && dy == 0) // no scrolling needed at all
5531 // set values for horizontal/vertical screen scrolling (half tile size)
5532 int dir_x = (dx != 0 ? MV_HORIZONTAL : 0);
5533 int dir_y = (dy != 0 ? MV_VERTICAL : 0);
5534 int pos_x = dx * TILEX / 2;
5535 int pos_y = dy * TILEY / 2;
5536 int fx = getFieldbufferOffsetX_RND(dir_x, pos_x);
5537 int fy = getFieldbufferOffsetY_RND(dir_y, pos_y);
5539 ScrollLevel(dx, dy);
5542 // scroll in two steps of half tile size to make things smoother
5543 BlitScreenToBitmapExt_RND(window, fx, fy);
5545 // scroll second step to align at full tile size
5546 BlitScreenToBitmap(window);
5552 SetVideoFrameDelay(frame_delay_value_old);
5555 static void RelocatePlayer(int jx, int jy, int el_player_raw)
5557 int el_player = GET_PLAYER_ELEMENT(el_player_raw);
5558 int player_nr = GET_PLAYER_NR(el_player);
5559 struct PlayerInfo *player = &stored_player[player_nr];
5560 boolean ffwd_delay = (tape.playing && tape.fast_forward);
5561 boolean no_delay = (tape.warp_forward);
5562 int frame_delay_value = (ffwd_delay ? FfwdFrameDelay : GameFrameDelay);
5563 int wait_delay_value = (no_delay ? 0 : frame_delay_value);
5564 int old_jx = player->jx;
5565 int old_jy = player->jy;
5566 int old_element = Tile[old_jx][old_jy];
5567 int element = Tile[jx][jy];
5568 boolean player_relocated = (old_jx != jx || old_jy != jy);
5570 int move_dir_horiz = (jx < old_jx ? MV_LEFT : jx > old_jx ? MV_RIGHT : 0);
5571 int move_dir_vert = (jy < old_jy ? MV_UP : jy > old_jy ? MV_DOWN : 0);
5572 int enter_side_horiz = MV_DIR_OPPOSITE(move_dir_horiz);
5573 int enter_side_vert = MV_DIR_OPPOSITE(move_dir_vert);
5574 int leave_side_horiz = move_dir_horiz;
5575 int leave_side_vert = move_dir_vert;
5576 int enter_side = enter_side_horiz | enter_side_vert;
5577 int leave_side = leave_side_horiz | leave_side_vert;
5579 if (player->buried) // do not reanimate dead player
5582 if (!player_relocated) // no need to relocate the player
5585 if (IS_PLAYER(jx, jy)) // player already placed at new position
5587 RemoveField(jx, jy); // temporarily remove newly placed player
5588 DrawLevelField(jx, jy);
5591 if (player->present)
5593 while (player->MovPos)
5595 ScrollPlayer(player, SCROLL_GO_ON);
5596 ScrollScreen(NULL, SCROLL_GO_ON);
5598 AdvanceFrameAndPlayerCounters(player->index_nr);
5602 BackToFront_WithFrameDelay(wait_delay_value);
5605 DrawPlayer(player); // needed here only to cleanup last field
5606 DrawLevelField(player->jx, player->jy); // remove player graphic
5608 player->is_moving = FALSE;
5611 if (IS_CUSTOM_ELEMENT(old_element))
5612 CheckElementChangeByPlayer(old_jx, old_jy, old_element,
5614 player->index_bit, leave_side);
5616 CheckTriggeredElementChangeByPlayer(old_jx, old_jy, old_element,
5618 player->index_bit, leave_side);
5620 Tile[jx][jy] = el_player;
5621 InitPlayerField(jx, jy, el_player, TRUE);
5623 /* "InitPlayerField()" above sets Tile[jx][jy] to EL_EMPTY, but it may be
5624 possible that the relocation target field did not contain a player element,
5625 but a walkable element, to which the new player was relocated -- in this
5626 case, restore that (already initialized!) element on the player field */
5627 if (!ELEM_IS_PLAYER(element)) // player may be set on walkable element
5629 Tile[jx][jy] = element; // restore previously existing element
5632 // only visually relocate centered player
5633 DrawRelocateScreen(old_jx, old_jy, player->jx, player->jy, player->MovDir,
5634 FALSE, level.instant_relocation);
5636 TestIfPlayerTouchesBadThing(jx, jy);
5637 TestIfPlayerTouchesCustomElement(jx, jy);
5639 if (IS_CUSTOM_ELEMENT(element))
5640 CheckElementChangeByPlayer(jx, jy, element, CE_ENTERED_BY_PLAYER,
5641 player->index_bit, enter_side);
5643 CheckTriggeredElementChangeByPlayer(jx, jy, element, CE_PLAYER_ENTERS_X,
5644 player->index_bit, enter_side);
5646 if (player->is_switching)
5648 /* ensure that relocation while still switching an element does not cause
5649 a new element to be treated as also switched directly after relocation
5650 (this is important for teleporter switches that teleport the player to
5651 a place where another teleporter switch is in the same direction, which
5652 would then incorrectly be treated as immediately switched before the
5653 direction key that caused the switch was released) */
5655 player->switch_x += jx - old_jx;
5656 player->switch_y += jy - old_jy;
5660 static void Explode(int ex, int ey, int phase, int mode)
5666 // !!! eliminate this variable !!!
5667 int delay = (game.emulation == EMU_SUPAPLEX ? 3 : 2);
5669 if (game.explosions_delayed)
5671 ExplodeField[ex][ey] = mode;
5675 if (phase == EX_PHASE_START) // initialize 'Store[][]' field
5677 int center_element = Tile[ex][ey];
5678 int artwork_element, explosion_element; // set these values later
5680 // remove things displayed in background while burning dynamite
5681 if (Back[ex][ey] != EL_EMPTY && !IS_INDESTRUCTIBLE(Back[ex][ey]))
5684 if (IS_MOVING(ex, ey) || IS_BLOCKED(ex, ey))
5686 // put moving element to center field (and let it explode there)
5687 center_element = MovingOrBlocked2Element(ex, ey);
5688 RemoveMovingField(ex, ey);
5689 Tile[ex][ey] = center_element;
5692 // now "center_element" is finally determined -- set related values now
5693 artwork_element = center_element; // for custom player artwork
5694 explosion_element = center_element; // for custom player artwork
5696 if (IS_PLAYER(ex, ey))
5698 int player_nr = GET_PLAYER_NR(StorePlayer[ex][ey]);
5700 artwork_element = stored_player[player_nr].artwork_element;
5702 if (level.use_explosion_element[player_nr])
5704 explosion_element = level.explosion_element[player_nr];
5705 artwork_element = explosion_element;
5709 if (mode == EX_TYPE_NORMAL ||
5710 mode == EX_TYPE_CENTER ||
5711 mode == EX_TYPE_CROSS)
5712 PlayLevelSoundElementAction(ex, ey, artwork_element, ACTION_EXPLODING);
5714 last_phase = element_info[explosion_element].explosion_delay + 1;
5716 for (y = ey - 1; y <= ey + 1; y++) for (x = ex - 1; x <= ex + 1; x++)
5718 int xx = x - ex + 1;
5719 int yy = y - ey + 1;
5722 if (!IN_LEV_FIELD(x, y) ||
5723 (mode & EX_TYPE_SINGLE_TILE && (x != ex || y != ey)) ||
5724 (mode == EX_TYPE_CROSS && (x != ex && y != ey)))
5727 element = Tile[x][y];
5729 if (IS_MOVING(x, y) || IS_BLOCKED(x, y))
5731 element = MovingOrBlocked2Element(x, y);
5733 if (!IS_EXPLOSION_PROOF(element))
5734 RemoveMovingField(x, y);
5737 // indestructible elements can only explode in center (but not flames)
5738 if ((IS_EXPLOSION_PROOF(element) && (x != ex || y != ey ||
5739 mode == EX_TYPE_BORDER)) ||
5740 element == EL_FLAMES)
5743 /* no idea why this was changed from 3.0.8 to 3.1.0 -- this causes buggy
5744 behaviour, for example when touching a yamyam that explodes to rocks
5745 with active deadly shield, a rock is created under the player !!! */
5746 // (case 1 (surely buggy): >= 3.1.0, case 2 (maybe buggy): <= 3.0.8)
5748 if (IS_PLAYER(x, y) && SHIELD_ON(PLAYERINFO(x, y)) &&
5749 (game.engine_version < VERSION_IDENT(3,1,0,0) ||
5750 (x == ex && y == ey && mode != EX_TYPE_BORDER)))
5752 if (IS_PLAYER(x, y) && SHIELD_ON(PLAYERINFO(x, y)))
5755 if (IS_ACTIVE_BOMB(element))
5757 // re-activate things under the bomb like gate or penguin
5758 Tile[x][y] = (Back[x][y] ? Back[x][y] : EL_EMPTY);
5765 // save walkable background elements while explosion on same tile
5766 if (IS_WALKABLE(element) && IS_INDESTRUCTIBLE(element) &&
5767 (x != ex || y != ey || mode == EX_TYPE_BORDER))
5768 Back[x][y] = element;
5770 // ignite explodable elements reached by other explosion
5771 if (element == EL_EXPLOSION)
5772 element = Store2[x][y];
5774 if (AmoebaNr[x][y] &&
5775 (element == EL_AMOEBA_FULL ||
5776 element == EL_BD_AMOEBA ||
5777 element == EL_AMOEBA_GROWING))
5779 AmoebaCnt[AmoebaNr[x][y]]--;
5780 AmoebaCnt2[AmoebaNr[x][y]]--;
5785 if (IS_PLAYER(ex, ey) && !PLAYER_EXPLOSION_PROTECTED(ex, ey))
5787 int player_nr = StorePlayer[ex][ey] - EL_PLAYER_1;
5789 Store[x][y] = EL_PLAYER_IS_EXPLODING_1 + player_nr;
5791 if (PLAYERINFO(ex, ey)->use_murphy)
5792 Store[x][y] = EL_EMPTY;
5795 // !!! check this case -- currently needed for rnd_rado_negundo_v,
5796 // !!! levels 015 018 019 020 021 022 023 026 027 028 !!!
5797 else if (ELEM_IS_PLAYER(center_element))
5798 Store[x][y] = EL_EMPTY;
5799 else if (center_element == EL_YAMYAM)
5800 Store[x][y] = level.yamyam_content[game.yamyam_content_nr].e[xx][yy];
5801 else if (element_info[center_element].content.e[xx][yy] != EL_EMPTY)
5802 Store[x][y] = element_info[center_element].content.e[xx][yy];
5804 // needed because EL_BD_BUTTERFLY is not defined as "CAN_EXPLODE"
5805 // (killing EL_BD_BUTTERFLY with dynamite would result in BD diamond
5806 // otherwise) -- FIX THIS !!!
5807 else if (!CAN_EXPLODE(element) && element != EL_BD_BUTTERFLY)
5808 Store[x][y] = element_info[element].content.e[1][1];
5810 else if (!CAN_EXPLODE(element))
5811 Store[x][y] = element_info[element].content.e[1][1];
5814 Store[x][y] = EL_EMPTY;
5816 if (x != ex || y != ey || mode == EX_TYPE_BORDER ||
5817 center_element == EL_AMOEBA_TO_DIAMOND)
5818 Store2[x][y] = element;
5820 Tile[x][y] = EL_EXPLOSION;
5821 GfxElement[x][y] = artwork_element;
5823 ExplodePhase[x][y] = 1;
5824 ExplodeDelay[x][y] = last_phase;
5829 if (center_element == EL_YAMYAM)
5830 game.yamyam_content_nr =
5831 (game.yamyam_content_nr + 1) % level.num_yamyam_contents;
5843 GfxFrame[x][y] = 0; // restart explosion animation
5845 last_phase = ExplodeDelay[x][y];
5847 ExplodePhase[x][y] = (phase < last_phase ? phase + 1 : 0);
5849 // this can happen if the player leaves an explosion just in time
5850 if (GfxElement[x][y] == EL_UNDEFINED)
5851 GfxElement[x][y] = EL_EMPTY;
5853 border_element = Store2[x][y];
5854 if (IS_PLAYER(x, y) && !PLAYER_EXPLOSION_PROTECTED(x, y))
5855 border_element = StorePlayer[x][y];
5857 if (phase == element_info[border_element].ignition_delay ||
5858 phase == last_phase)
5860 boolean border_explosion = FALSE;
5862 if (IS_PLAYER(x, y) && PLAYERINFO(x, y)->present &&
5863 !PLAYER_EXPLOSION_PROTECTED(x, y))
5865 KillPlayerUnlessExplosionProtected(x, y);
5866 border_explosion = TRUE;
5868 else if (CAN_EXPLODE_BY_EXPLOSION(border_element))
5870 Tile[x][y] = Store2[x][y];
5873 border_explosion = TRUE;
5875 else if (border_element == EL_AMOEBA_TO_DIAMOND)
5877 AmoebaToDiamond(x, y);
5879 border_explosion = TRUE;
5882 // if an element just explodes due to another explosion (chain-reaction),
5883 // do not immediately end the new explosion when it was the last frame of
5884 // the explosion (as it would be done in the following "if"-statement!)
5885 if (border_explosion && phase == last_phase)
5889 if (phase == last_phase)
5893 element = Tile[x][y] = Store[x][y];
5894 Store[x][y] = Store2[x][y] = 0;
5895 GfxElement[x][y] = EL_UNDEFINED;
5897 // player can escape from explosions and might therefore be still alive
5898 if (element >= EL_PLAYER_IS_EXPLODING_1 &&
5899 element <= EL_PLAYER_IS_EXPLODING_4)
5901 int player_nr = element - EL_PLAYER_IS_EXPLODING_1;
5902 int explosion_element = EL_PLAYER_1 + player_nr;
5903 int xx = MIN(MAX(0, x - stored_player[player_nr].jx + 1), 2);
5904 int yy = MIN(MAX(0, y - stored_player[player_nr].jy + 1), 2);
5906 if (level.use_explosion_element[player_nr])
5907 explosion_element = level.explosion_element[player_nr];
5909 Tile[x][y] = (stored_player[player_nr].active ? EL_EMPTY :
5910 element_info[explosion_element].content.e[xx][yy]);
5913 // restore probably existing indestructible background element
5914 if (Back[x][y] && IS_INDESTRUCTIBLE(Back[x][y]))
5915 element = Tile[x][y] = Back[x][y];
5918 MovDir[x][y] = MovPos[x][y] = MovDelay[x][y] = 0;
5919 GfxDir[x][y] = MV_NONE;
5920 ChangeDelay[x][y] = 0;
5921 ChangePage[x][y] = -1;
5923 CustomValue[x][y] = 0;
5925 InitField_WithBug2(x, y, FALSE);
5927 TEST_DrawLevelField(x, y);
5929 TestIfElementTouchesCustomElement(x, y);
5931 if (GFX_CRUMBLED(element))
5932 TEST_DrawLevelFieldCrumbledNeighbours(x, y);
5934 if (IS_PLAYER(x, y) && !PLAYERINFO(x, y)->present)
5935 StorePlayer[x][y] = 0;
5937 if (ELEM_IS_PLAYER(element))
5938 RelocatePlayer(x, y, element);
5940 else if (IN_SCR_FIELD(SCREENX(x), SCREENY(y)))
5942 int graphic = el_act2img(GfxElement[x][y], ACTION_EXPLODING);
5943 int frame = getGraphicAnimationFrame(graphic, GfxFrame[x][y]);
5946 TEST_DrawLevelFieldCrumbled(x, y);
5948 if (IS_WALKABLE_OVER(Back[x][y]) && Back[x][y] != EL_EMPTY)
5950 DrawLevelElement(x, y, Back[x][y]);
5951 DrawGraphicThruMask(SCREENX(x), SCREENY(y), graphic, frame);
5953 else if (IS_WALKABLE_UNDER(Back[x][y]))
5955 DrawGraphic(SCREENX(x), SCREENY(y), graphic, frame);
5956 DrawLevelElementThruMask(x, y, Back[x][y]);
5958 else if (!IS_WALKABLE_INSIDE(Back[x][y]))
5959 DrawScreenGraphic(SCREENX(x), SCREENY(y), graphic, frame);
5963 static void DynaExplode(int ex, int ey)
5966 int dynabomb_element = Tile[ex][ey];
5967 int dynabomb_size = 1;
5968 boolean dynabomb_xl = FALSE;
5969 struct PlayerInfo *player;
5970 static int xy[4][2] =
5978 if (IS_ACTIVE_BOMB(dynabomb_element))
5980 player = &stored_player[dynabomb_element - EL_DYNABOMB_PLAYER_1_ACTIVE];
5981 dynabomb_size = player->dynabomb_size;
5982 dynabomb_xl = player->dynabomb_xl;
5983 player->dynabombs_left++;
5986 Explode(ex, ey, EX_PHASE_START, EX_TYPE_CENTER);
5988 for (i = 0; i < NUM_DIRECTIONS; i++)
5990 for (j = 1; j <= dynabomb_size; j++)
5992 int x = ex + j * xy[i][0];
5993 int y = ey + j * xy[i][1];
5996 if (!IN_LEV_FIELD(x, y) || IS_INDESTRUCTIBLE(Tile[x][y]))
5999 element = Tile[x][y];
6001 // do not restart explosions of fields with active bombs
6002 if (element == EL_EXPLOSION && IS_ACTIVE_BOMB(Store2[x][y]))
6005 Explode(x, y, EX_PHASE_START, EX_TYPE_BORDER);
6007 if (element != EL_EMPTY && element != EL_EXPLOSION &&
6008 !IS_DIGGABLE(element) && !dynabomb_xl)
6014 void Bang(int x, int y)
6016 int element = MovingOrBlocked2Element(x, y);
6017 int explosion_type = EX_TYPE_NORMAL;
6019 if (IS_PLAYER(x, y) && !PLAYER_EXPLOSION_PROTECTED(x, y))
6021 struct PlayerInfo *player = PLAYERINFO(x, y);
6023 element = Tile[x][y] = player->initial_element;
6025 if (level.use_explosion_element[player->index_nr])
6027 int explosion_element = level.explosion_element[player->index_nr];
6029 if (element_info[explosion_element].explosion_type == EXPLODES_CROSS)
6030 explosion_type = EX_TYPE_CROSS;
6031 else if (element_info[explosion_element].explosion_type == EXPLODES_1X1)
6032 explosion_type = EX_TYPE_CENTER;
6040 case EL_BD_BUTTERFLY:
6043 case EL_DARK_YAMYAM:
6047 RaiseScoreElement(element);
6050 case EL_DYNABOMB_PLAYER_1_ACTIVE:
6051 case EL_DYNABOMB_PLAYER_2_ACTIVE:
6052 case EL_DYNABOMB_PLAYER_3_ACTIVE:
6053 case EL_DYNABOMB_PLAYER_4_ACTIVE:
6054 case EL_DYNABOMB_INCREASE_NUMBER:
6055 case EL_DYNABOMB_INCREASE_SIZE:
6056 case EL_DYNABOMB_INCREASE_POWER:
6057 explosion_type = EX_TYPE_DYNA;
6060 case EL_DC_LANDMINE:
6061 explosion_type = EX_TYPE_CENTER;
6066 case EL_LAMP_ACTIVE:
6067 case EL_AMOEBA_TO_DIAMOND:
6068 if (!IS_PLAYER(x, y)) // penguin and player may be at same field
6069 explosion_type = EX_TYPE_CENTER;
6073 if (element_info[element].explosion_type == EXPLODES_CROSS)
6074 explosion_type = EX_TYPE_CROSS;
6075 else if (element_info[element].explosion_type == EXPLODES_1X1)
6076 explosion_type = EX_TYPE_CENTER;
6080 if (explosion_type == EX_TYPE_DYNA)
6083 Explode(x, y, EX_PHASE_START, explosion_type);
6085 CheckTriggeredElementChange(x, y, element, CE_EXPLOSION_OF_X);
6088 static void SplashAcid(int x, int y)
6090 if (IN_LEV_FIELD(x - 1, y - 1) && IS_FREE(x - 1, y - 1) &&
6091 (!IN_LEV_FIELD(x - 1, y - 2) ||
6092 !CAN_FALL(MovingOrBlocked2Element(x - 1, y - 2))))
6093 Tile[x - 1][y - 1] = EL_ACID_SPLASH_LEFT;
6095 if (IN_LEV_FIELD(x + 1, y - 1) && IS_FREE(x + 1, y - 1) &&
6096 (!IN_LEV_FIELD(x + 1, y - 2) ||
6097 !CAN_FALL(MovingOrBlocked2Element(x + 1, y - 2))))
6098 Tile[x + 1][y - 1] = EL_ACID_SPLASH_RIGHT;
6100 PlayLevelSound(x, y, SND_ACID_SPLASHING);
6103 static void InitBeltMovement(void)
6105 static int belt_base_element[4] =
6107 EL_CONVEYOR_BELT_1_LEFT,
6108 EL_CONVEYOR_BELT_2_LEFT,
6109 EL_CONVEYOR_BELT_3_LEFT,
6110 EL_CONVEYOR_BELT_4_LEFT
6112 static int belt_base_active_element[4] =
6114 EL_CONVEYOR_BELT_1_LEFT_ACTIVE,
6115 EL_CONVEYOR_BELT_2_LEFT_ACTIVE,
6116 EL_CONVEYOR_BELT_3_LEFT_ACTIVE,
6117 EL_CONVEYOR_BELT_4_LEFT_ACTIVE
6122 // set frame order for belt animation graphic according to belt direction
6123 for (i = 0; i < NUM_BELTS; i++)
6127 for (j = 0; j < NUM_BELT_PARTS; j++)
6129 int element = belt_base_active_element[belt_nr] + j;
6130 int graphic_1 = el2img(element);
6131 int graphic_2 = el2panelimg(element);
6133 if (game.belt_dir[i] == MV_LEFT)
6135 graphic_info[graphic_1].anim_mode &= ~ANIM_REVERSE;
6136 graphic_info[graphic_2].anim_mode &= ~ANIM_REVERSE;
6140 graphic_info[graphic_1].anim_mode |= ANIM_REVERSE;
6141 graphic_info[graphic_2].anim_mode |= ANIM_REVERSE;
6146 SCAN_PLAYFIELD(x, y)
6148 int element = Tile[x][y];
6150 for (i = 0; i < NUM_BELTS; i++)
6152 if (IS_BELT(element) && game.belt_dir[i] != MV_NONE)
6154 int e_belt_nr = getBeltNrFromBeltElement(element);
6157 if (e_belt_nr == belt_nr)
6159 int belt_part = Tile[x][y] - belt_base_element[belt_nr];
6161 Tile[x][y] = belt_base_active_element[belt_nr] + belt_part;
6168 static void ToggleBeltSwitch(int x, int y)
6170 static int belt_base_element[4] =
6172 EL_CONVEYOR_BELT_1_LEFT,
6173 EL_CONVEYOR_BELT_2_LEFT,
6174 EL_CONVEYOR_BELT_3_LEFT,
6175 EL_CONVEYOR_BELT_4_LEFT
6177 static int belt_base_active_element[4] =
6179 EL_CONVEYOR_BELT_1_LEFT_ACTIVE,
6180 EL_CONVEYOR_BELT_2_LEFT_ACTIVE,
6181 EL_CONVEYOR_BELT_3_LEFT_ACTIVE,
6182 EL_CONVEYOR_BELT_4_LEFT_ACTIVE
6184 static int belt_base_switch_element[4] =
6186 EL_CONVEYOR_BELT_1_SWITCH_LEFT,
6187 EL_CONVEYOR_BELT_2_SWITCH_LEFT,
6188 EL_CONVEYOR_BELT_3_SWITCH_LEFT,
6189 EL_CONVEYOR_BELT_4_SWITCH_LEFT
6191 static int belt_move_dir[4] =
6199 int element = Tile[x][y];
6200 int belt_nr = getBeltNrFromBeltSwitchElement(element);
6201 int belt_dir_nr = (game.belt_dir_nr[belt_nr] + 1) % 4;
6202 int belt_dir = belt_move_dir[belt_dir_nr];
6205 if (!IS_BELT_SWITCH(element))
6208 game.belt_dir_nr[belt_nr] = belt_dir_nr;
6209 game.belt_dir[belt_nr] = belt_dir;
6211 if (belt_dir_nr == 3)
6214 // set frame order for belt animation graphic according to belt direction
6215 for (i = 0; i < NUM_BELT_PARTS; i++)
6217 int element = belt_base_active_element[belt_nr] + i;
6218 int graphic_1 = el2img(element);
6219 int graphic_2 = el2panelimg(element);
6221 if (belt_dir == MV_LEFT)
6223 graphic_info[graphic_1].anim_mode &= ~ANIM_REVERSE;
6224 graphic_info[graphic_2].anim_mode &= ~ANIM_REVERSE;
6228 graphic_info[graphic_1].anim_mode |= ANIM_REVERSE;
6229 graphic_info[graphic_2].anim_mode |= ANIM_REVERSE;
6233 SCAN_PLAYFIELD(xx, yy)
6235 int element = Tile[xx][yy];
6237 if (IS_BELT_SWITCH(element))
6239 int e_belt_nr = getBeltNrFromBeltSwitchElement(element);
6241 if (e_belt_nr == belt_nr)
6243 Tile[xx][yy] = belt_base_switch_element[belt_nr] + belt_dir_nr;
6244 TEST_DrawLevelField(xx, yy);
6247 else if (IS_BELT(element) && belt_dir != MV_NONE)
6249 int e_belt_nr = getBeltNrFromBeltElement(element);
6251 if (e_belt_nr == belt_nr)
6253 int belt_part = Tile[xx][yy] - belt_base_element[belt_nr];
6255 Tile[xx][yy] = belt_base_active_element[belt_nr] + belt_part;
6256 TEST_DrawLevelField(xx, yy);
6259 else if (IS_BELT_ACTIVE(element) && belt_dir == MV_NONE)
6261 int e_belt_nr = getBeltNrFromBeltActiveElement(element);
6263 if (e_belt_nr == belt_nr)
6265 int belt_part = Tile[xx][yy] - belt_base_active_element[belt_nr];
6267 Tile[xx][yy] = belt_base_element[belt_nr] + belt_part;
6268 TEST_DrawLevelField(xx, yy);
6274 static void ToggleSwitchgateSwitch(int x, int y)
6278 game.switchgate_pos = !game.switchgate_pos;
6280 SCAN_PLAYFIELD(xx, yy)
6282 int element = Tile[xx][yy];
6284 if (element == EL_SWITCHGATE_SWITCH_UP)
6286 Tile[xx][yy] = EL_SWITCHGATE_SWITCH_DOWN;
6287 TEST_DrawLevelField(xx, yy);
6289 else if (element == EL_SWITCHGATE_SWITCH_DOWN)
6291 Tile[xx][yy] = EL_SWITCHGATE_SWITCH_UP;
6292 TEST_DrawLevelField(xx, yy);
6294 else if (element == EL_DC_SWITCHGATE_SWITCH_UP)
6296 Tile[xx][yy] = EL_DC_SWITCHGATE_SWITCH_DOWN;
6297 TEST_DrawLevelField(xx, yy);
6299 else if (element == EL_DC_SWITCHGATE_SWITCH_DOWN)
6301 Tile[xx][yy] = EL_DC_SWITCHGATE_SWITCH_UP;
6302 TEST_DrawLevelField(xx, yy);
6304 else if (element == EL_SWITCHGATE_OPEN ||
6305 element == EL_SWITCHGATE_OPENING)
6307 Tile[xx][yy] = EL_SWITCHGATE_CLOSING;
6309 PlayLevelSoundAction(xx, yy, ACTION_CLOSING);
6311 else if (element == EL_SWITCHGATE_CLOSED ||
6312 element == EL_SWITCHGATE_CLOSING)
6314 Tile[xx][yy] = EL_SWITCHGATE_OPENING;
6316 PlayLevelSoundAction(xx, yy, ACTION_OPENING);
6321 static int getInvisibleActiveFromInvisibleElement(int element)
6323 return (element == EL_INVISIBLE_STEELWALL ? EL_INVISIBLE_STEELWALL_ACTIVE :
6324 element == EL_INVISIBLE_WALL ? EL_INVISIBLE_WALL_ACTIVE :
6325 element == EL_INVISIBLE_SAND ? EL_INVISIBLE_SAND_ACTIVE :
6329 static int getInvisibleFromInvisibleActiveElement(int element)
6331 return (element == EL_INVISIBLE_STEELWALL_ACTIVE ? EL_INVISIBLE_STEELWALL :
6332 element == EL_INVISIBLE_WALL_ACTIVE ? EL_INVISIBLE_WALL :
6333 element == EL_INVISIBLE_SAND_ACTIVE ? EL_INVISIBLE_SAND :
6337 static void RedrawAllLightSwitchesAndInvisibleElements(void)
6341 SCAN_PLAYFIELD(x, y)
6343 int element = Tile[x][y];
6345 if (element == EL_LIGHT_SWITCH &&
6346 game.light_time_left > 0)
6348 Tile[x][y] = EL_LIGHT_SWITCH_ACTIVE;
6349 TEST_DrawLevelField(x, y);
6351 else if (element == EL_LIGHT_SWITCH_ACTIVE &&
6352 game.light_time_left == 0)
6354 Tile[x][y] = EL_LIGHT_SWITCH;
6355 TEST_DrawLevelField(x, y);
6357 else if (element == EL_EMC_DRIPPER &&
6358 game.light_time_left > 0)
6360 Tile[x][y] = EL_EMC_DRIPPER_ACTIVE;
6361 TEST_DrawLevelField(x, y);
6363 else if (element == EL_EMC_DRIPPER_ACTIVE &&
6364 game.light_time_left == 0)
6366 Tile[x][y] = EL_EMC_DRIPPER;
6367 TEST_DrawLevelField(x, y);
6369 else if (element == EL_INVISIBLE_STEELWALL ||
6370 element == EL_INVISIBLE_WALL ||
6371 element == EL_INVISIBLE_SAND)
6373 if (game.light_time_left > 0)
6374 Tile[x][y] = getInvisibleActiveFromInvisibleElement(element);
6376 TEST_DrawLevelField(x, y);
6378 // uncrumble neighbour fields, if needed
6379 if (element == EL_INVISIBLE_SAND)
6380 TEST_DrawLevelFieldCrumbledNeighbours(x, y);
6382 else if (element == EL_INVISIBLE_STEELWALL_ACTIVE ||
6383 element == EL_INVISIBLE_WALL_ACTIVE ||
6384 element == EL_INVISIBLE_SAND_ACTIVE)
6386 if (game.light_time_left == 0)
6387 Tile[x][y] = getInvisibleFromInvisibleActiveElement(element);
6389 TEST_DrawLevelField(x, y);
6391 // re-crumble neighbour fields, if needed
6392 if (element == EL_INVISIBLE_SAND)
6393 TEST_DrawLevelFieldCrumbledNeighbours(x, y);
6398 static void RedrawAllInvisibleElementsForLenses(void)
6402 SCAN_PLAYFIELD(x, y)
6404 int element = Tile[x][y];
6406 if (element == EL_EMC_DRIPPER &&
6407 game.lenses_time_left > 0)
6409 Tile[x][y] = EL_EMC_DRIPPER_ACTIVE;
6410 TEST_DrawLevelField(x, y);
6412 else if (element == EL_EMC_DRIPPER_ACTIVE &&
6413 game.lenses_time_left == 0)
6415 Tile[x][y] = EL_EMC_DRIPPER;
6416 TEST_DrawLevelField(x, y);
6418 else if (element == EL_INVISIBLE_STEELWALL ||
6419 element == EL_INVISIBLE_WALL ||
6420 element == EL_INVISIBLE_SAND)
6422 if (game.lenses_time_left > 0)
6423 Tile[x][y] = getInvisibleActiveFromInvisibleElement(element);
6425 TEST_DrawLevelField(x, y);
6427 // uncrumble neighbour fields, if needed
6428 if (element == EL_INVISIBLE_SAND)
6429 TEST_DrawLevelFieldCrumbledNeighbours(x, y);
6431 else if (element == EL_INVISIBLE_STEELWALL_ACTIVE ||
6432 element == EL_INVISIBLE_WALL_ACTIVE ||
6433 element == EL_INVISIBLE_SAND_ACTIVE)
6435 if (game.lenses_time_left == 0)
6436 Tile[x][y] = getInvisibleFromInvisibleActiveElement(element);
6438 TEST_DrawLevelField(x, y);
6440 // re-crumble neighbour fields, if needed
6441 if (element == EL_INVISIBLE_SAND)
6442 TEST_DrawLevelFieldCrumbledNeighbours(x, y);
6447 static void RedrawAllInvisibleElementsForMagnifier(void)
6451 SCAN_PLAYFIELD(x, y)
6453 int element = Tile[x][y];
6455 if (element == EL_EMC_FAKE_GRASS &&
6456 game.magnify_time_left > 0)
6458 Tile[x][y] = EL_EMC_FAKE_GRASS_ACTIVE;
6459 TEST_DrawLevelField(x, y);
6461 else if (element == EL_EMC_FAKE_GRASS_ACTIVE &&
6462 game.magnify_time_left == 0)
6464 Tile[x][y] = EL_EMC_FAKE_GRASS;
6465 TEST_DrawLevelField(x, y);
6467 else if (IS_GATE_GRAY(element) &&
6468 game.magnify_time_left > 0)
6470 Tile[x][y] = (IS_RND_GATE_GRAY(element) ?
6471 element - EL_GATE_1_GRAY + EL_GATE_1_GRAY_ACTIVE :
6472 IS_EM_GATE_GRAY(element) ?
6473 element - EL_EM_GATE_1_GRAY + EL_EM_GATE_1_GRAY_ACTIVE :
6474 IS_EMC_GATE_GRAY(element) ?
6475 element - EL_EMC_GATE_5_GRAY + EL_EMC_GATE_5_GRAY_ACTIVE :
6476 IS_DC_GATE_GRAY(element) ?
6477 EL_DC_GATE_WHITE_GRAY_ACTIVE :
6479 TEST_DrawLevelField(x, y);
6481 else if (IS_GATE_GRAY_ACTIVE(element) &&
6482 game.magnify_time_left == 0)
6484 Tile[x][y] = (IS_RND_GATE_GRAY_ACTIVE(element) ?
6485 element - EL_GATE_1_GRAY_ACTIVE + EL_GATE_1_GRAY :
6486 IS_EM_GATE_GRAY_ACTIVE(element) ?
6487 element - EL_EM_GATE_1_GRAY_ACTIVE + EL_EM_GATE_1_GRAY :
6488 IS_EMC_GATE_GRAY_ACTIVE(element) ?
6489 element - EL_EMC_GATE_5_GRAY_ACTIVE + EL_EMC_GATE_5_GRAY :
6490 IS_DC_GATE_GRAY_ACTIVE(element) ?
6491 EL_DC_GATE_WHITE_GRAY :
6493 TEST_DrawLevelField(x, y);
6498 static void ToggleLightSwitch(int x, int y)
6500 int element = Tile[x][y];
6502 game.light_time_left =
6503 (element == EL_LIGHT_SWITCH ?
6504 level.time_light * FRAMES_PER_SECOND : 0);
6506 RedrawAllLightSwitchesAndInvisibleElements();
6509 static void ActivateTimegateSwitch(int x, int y)
6513 game.timegate_time_left = level.time_timegate * FRAMES_PER_SECOND;
6515 SCAN_PLAYFIELD(xx, yy)
6517 int element = Tile[xx][yy];
6519 if (element == EL_TIMEGATE_CLOSED ||
6520 element == EL_TIMEGATE_CLOSING)
6522 Tile[xx][yy] = EL_TIMEGATE_OPENING;
6523 PlayLevelSound(xx, yy, SND_CLASS_TIMEGATE_OPENING);
6527 else if (element == EL_TIMEGATE_SWITCH_ACTIVE)
6529 Tile[xx][yy] = EL_TIMEGATE_SWITCH;
6530 TEST_DrawLevelField(xx, yy);
6536 Tile[x][y] = (Tile[x][y] == EL_TIMEGATE_SWITCH ? EL_TIMEGATE_SWITCH_ACTIVE :
6537 EL_DC_TIMEGATE_SWITCH_ACTIVE);
6540 static void Impact(int x, int y)
6542 boolean last_line = (y == lev_fieldy - 1);
6543 boolean object_hit = FALSE;
6544 boolean impact = (last_line || object_hit);
6545 int element = Tile[x][y];
6546 int smashed = EL_STEELWALL;
6548 if (!last_line) // check if element below was hit
6550 if (Tile[x][y + 1] == EL_PLAYER_IS_LEAVING)
6553 object_hit = (!IS_FREE(x, y + 1) && (!IS_MOVING(x, y + 1) ||
6554 MovDir[x][y + 1] != MV_DOWN ||
6555 MovPos[x][y + 1] <= TILEY / 2));
6557 // do not smash moving elements that left the smashed field in time
6558 if (game.engine_version >= VERSION_IDENT(2,2,0,7) && IS_MOVING(x, y + 1) &&
6559 ABS(MovPos[x][y + 1] + getElementMoveStepsize(x, y + 1)) >= TILEX)
6562 #if USE_QUICKSAND_IMPACT_BUGFIX
6563 if (Tile[x][y + 1] == EL_QUICKSAND_EMPTYING && object_hit == FALSE)
6565 RemoveMovingField(x, y + 1);
6566 Tile[x][y + 1] = EL_QUICKSAND_EMPTY;
6567 Tile[x][y + 2] = EL_ROCK;
6568 TEST_DrawLevelField(x, y + 2);
6573 if (Tile[x][y + 1] == EL_QUICKSAND_FAST_EMPTYING && object_hit == FALSE)
6575 RemoveMovingField(x, y + 1);
6576 Tile[x][y + 1] = EL_QUICKSAND_FAST_EMPTY;
6577 Tile[x][y + 2] = EL_ROCK;
6578 TEST_DrawLevelField(x, y + 2);
6585 smashed = MovingOrBlocked2Element(x, y + 1);
6587 impact = (last_line || object_hit);
6590 if (!last_line && smashed == EL_ACID) // element falls into acid
6592 SplashAcid(x, y + 1);
6596 // !!! not sufficient for all cases -- see EL_PEARL below !!!
6597 // only reset graphic animation if graphic really changes after impact
6599 el_act_dir2img(element, GfxAction[x][y], MV_DOWN) != el2img(element))
6601 ResetGfxAnimation(x, y);
6602 TEST_DrawLevelField(x, y);
6605 if (impact && CAN_EXPLODE_IMPACT(element))
6610 else if (impact && element == EL_PEARL &&
6611 smashed != EL_DC_MAGIC_WALL && smashed != EL_DC_MAGIC_WALL_ACTIVE)
6613 ResetGfxAnimation(x, y);
6615 Tile[x][y] = EL_PEARL_BREAKING;
6616 PlayLevelSound(x, y, SND_PEARL_BREAKING);
6619 else if (impact && CheckElementChange(x, y, element, smashed, CE_IMPACT))
6621 PlayLevelSoundElementAction(x, y, element, ACTION_IMPACT);
6626 if (impact && element == EL_AMOEBA_DROP)
6628 if (object_hit && IS_PLAYER(x, y + 1))
6629 KillPlayerUnlessEnemyProtected(x, y + 1);
6630 else if (object_hit && smashed == EL_PENGUIN)
6634 Tile[x][y] = EL_AMOEBA_GROWING;
6635 Store[x][y] = EL_AMOEBA_WET;
6637 ResetRandomAnimationValue(x, y);
6642 if (object_hit) // check which object was hit
6644 if ((CAN_PASS_MAGIC_WALL(element) &&
6645 (smashed == EL_MAGIC_WALL ||
6646 smashed == EL_BD_MAGIC_WALL)) ||
6647 (CAN_PASS_DC_MAGIC_WALL(element) &&
6648 smashed == EL_DC_MAGIC_WALL))
6651 int activated_magic_wall =
6652 (smashed == EL_MAGIC_WALL ? EL_MAGIC_WALL_ACTIVE :
6653 smashed == EL_BD_MAGIC_WALL ? EL_BD_MAGIC_WALL_ACTIVE :
6654 EL_DC_MAGIC_WALL_ACTIVE);
6656 // activate magic wall / mill
6657 SCAN_PLAYFIELD(xx, yy)
6659 if (Tile[xx][yy] == smashed)
6660 Tile[xx][yy] = activated_magic_wall;
6663 game.magic_wall_time_left = level.time_magic_wall * FRAMES_PER_SECOND;
6664 game.magic_wall_active = TRUE;
6666 PlayLevelSound(x, y, (smashed == EL_MAGIC_WALL ?
6667 SND_MAGIC_WALL_ACTIVATING :
6668 smashed == EL_BD_MAGIC_WALL ?
6669 SND_BD_MAGIC_WALL_ACTIVATING :
6670 SND_DC_MAGIC_WALL_ACTIVATING));
6673 if (IS_PLAYER(x, y + 1))
6675 if (CAN_SMASH_PLAYER(element))
6677 KillPlayerUnlessEnemyProtected(x, y + 1);
6681 else if (smashed == EL_PENGUIN)
6683 if (CAN_SMASH_PLAYER(element))
6689 else if (element == EL_BD_DIAMOND)
6691 if (IS_CLASSIC_ENEMY(smashed) && IS_BD_ELEMENT(smashed))
6697 else if (((element == EL_SP_INFOTRON ||
6698 element == EL_SP_ZONK) &&
6699 (smashed == EL_SP_SNIKSNAK ||
6700 smashed == EL_SP_ELECTRON ||
6701 smashed == EL_SP_DISK_ORANGE)) ||
6702 (element == EL_SP_INFOTRON &&
6703 smashed == EL_SP_DISK_YELLOW))
6708 else if (CAN_SMASH_EVERYTHING(element))
6710 if (IS_CLASSIC_ENEMY(smashed) ||
6711 CAN_EXPLODE_SMASHED(smashed))
6716 else if (!IS_MOVING(x, y + 1) && !IS_BLOCKED(x, y + 1))
6718 if (smashed == EL_LAMP ||
6719 smashed == EL_LAMP_ACTIVE)
6724 else if (smashed == EL_NUT)
6726 Tile[x][y + 1] = EL_NUT_BREAKING;
6727 PlayLevelSound(x, y, SND_NUT_BREAKING);
6728 RaiseScoreElement(EL_NUT);
6731 else if (smashed == EL_PEARL)
6733 ResetGfxAnimation(x, y);
6735 Tile[x][y + 1] = EL_PEARL_BREAKING;
6736 PlayLevelSound(x, y, SND_PEARL_BREAKING);
6739 else if (smashed == EL_DIAMOND)
6741 Tile[x][y + 1] = EL_DIAMOND_BREAKING;
6742 PlayLevelSound(x, y, SND_DIAMOND_BREAKING);
6745 else if (IS_BELT_SWITCH(smashed))
6747 ToggleBeltSwitch(x, y + 1);
6749 else if (smashed == EL_SWITCHGATE_SWITCH_UP ||
6750 smashed == EL_SWITCHGATE_SWITCH_DOWN ||
6751 smashed == EL_DC_SWITCHGATE_SWITCH_UP ||
6752 smashed == EL_DC_SWITCHGATE_SWITCH_DOWN)
6754 ToggleSwitchgateSwitch(x, y + 1);
6756 else if (smashed == EL_LIGHT_SWITCH ||
6757 smashed == EL_LIGHT_SWITCH_ACTIVE)
6759 ToggleLightSwitch(x, y + 1);
6763 CheckElementChange(x, y + 1, smashed, element, CE_SMASHED);
6765 CheckElementChangeBySide(x, y + 1, smashed, element,
6766 CE_SWITCHED, CH_SIDE_TOP);
6767 CheckTriggeredElementChangeBySide(x, y + 1, smashed, CE_SWITCH_OF_X,
6773 CheckElementChange(x, y + 1, smashed, element, CE_SMASHED);
6778 // play sound of magic wall / mill
6780 (Tile[x][y + 1] == EL_MAGIC_WALL_ACTIVE ||
6781 Tile[x][y + 1] == EL_BD_MAGIC_WALL_ACTIVE ||
6782 Tile[x][y + 1] == EL_DC_MAGIC_WALL_ACTIVE))
6784 if (Tile[x][y + 1] == EL_MAGIC_WALL_ACTIVE)
6785 PlayLevelSound(x, y, SND_MAGIC_WALL_FILLING);
6786 else if (Tile[x][y + 1] == EL_BD_MAGIC_WALL_ACTIVE)
6787 PlayLevelSound(x, y, SND_BD_MAGIC_WALL_FILLING);
6788 else if (Tile[x][y + 1] == EL_DC_MAGIC_WALL_ACTIVE)
6789 PlayLevelSound(x, y, SND_DC_MAGIC_WALL_FILLING);
6794 // play sound of object that hits the ground
6795 if (last_line || object_hit)
6796 PlayLevelSoundElementAction(x, y, element, ACTION_IMPACT);
6799 static void TurnRoundExt(int x, int y)
6811 { 0, 0 }, { 0, 0 }, { 0, 0 },
6816 int left, right, back;
6820 { MV_DOWN, MV_UP, MV_RIGHT },
6821 { MV_UP, MV_DOWN, MV_LEFT },
6823 { MV_LEFT, MV_RIGHT, MV_DOWN },
6827 { MV_RIGHT, MV_LEFT, MV_UP }
6830 int element = Tile[x][y];
6831 int move_pattern = element_info[element].move_pattern;
6833 int old_move_dir = MovDir[x][y];
6834 int left_dir = turn[old_move_dir].left;
6835 int right_dir = turn[old_move_dir].right;
6836 int back_dir = turn[old_move_dir].back;
6838 int left_dx = move_xy[left_dir].dx, left_dy = move_xy[left_dir].dy;
6839 int right_dx = move_xy[right_dir].dx, right_dy = move_xy[right_dir].dy;
6840 int move_dx = move_xy[old_move_dir].dx, move_dy = move_xy[old_move_dir].dy;
6841 int back_dx = move_xy[back_dir].dx, back_dy = move_xy[back_dir].dy;
6843 int left_x = x + left_dx, left_y = y + left_dy;
6844 int right_x = x + right_dx, right_y = y + right_dy;
6845 int move_x = x + move_dx, move_y = y + move_dy;
6849 if (element == EL_BUG || element == EL_BD_BUTTERFLY)
6851 TestIfBadThingTouchesOtherBadThing(x, y);
6853 if (ENEMY_CAN_ENTER_FIELD(element, right_x, right_y))
6854 MovDir[x][y] = right_dir;
6855 else if (!ENEMY_CAN_ENTER_FIELD(element, move_x, move_y))
6856 MovDir[x][y] = left_dir;
6858 if (element == EL_BUG && MovDir[x][y] != old_move_dir)
6860 else if (element == EL_BD_BUTTERFLY) // && MovDir[x][y] == left_dir)
6863 else if (element == EL_SPACESHIP || element == EL_BD_FIREFLY)
6865 TestIfBadThingTouchesOtherBadThing(x, y);
6867 if (ENEMY_CAN_ENTER_FIELD(element, left_x, left_y))
6868 MovDir[x][y] = left_dir;
6869 else if (!ENEMY_CAN_ENTER_FIELD(element, move_x, move_y))
6870 MovDir[x][y] = right_dir;
6872 if (element == EL_SPACESHIP && MovDir[x][y] != old_move_dir)
6874 else if (element == EL_BD_FIREFLY) // && MovDir[x][y] == right_dir)
6877 else if (element == EL_SP_SNIKSNAK || element == EL_SP_ELECTRON)
6879 TestIfBadThingTouchesOtherBadThing(x, y);
6881 if (ELEMENT_CAN_ENTER_FIELD_BASE_4(element, left_x, left_y, 0))
6882 MovDir[x][y] = left_dir;
6883 else if (!ELEMENT_CAN_ENTER_FIELD_BASE_4(element, move_x, move_y, 0))
6884 MovDir[x][y] = right_dir;
6886 if (MovDir[x][y] != old_move_dir)
6889 else if (element == EL_YAMYAM)
6891 boolean can_turn_left = YAMYAM_CAN_ENTER_FIELD(element, left_x, left_y);
6892 boolean can_turn_right = YAMYAM_CAN_ENTER_FIELD(element, right_x, right_y);
6894 if (can_turn_left && can_turn_right)
6895 MovDir[x][y] = (RND(3) ? (RND(2) ? left_dir : right_dir) : back_dir);
6896 else if (can_turn_left)
6897 MovDir[x][y] = (RND(2) ? left_dir : back_dir);
6898 else if (can_turn_right)
6899 MovDir[x][y] = (RND(2) ? right_dir : back_dir);
6901 MovDir[x][y] = back_dir;
6903 MovDelay[x][y] = 16 + 16 * RND(3);
6905 else if (element == EL_DARK_YAMYAM)
6907 boolean can_turn_left = DARK_YAMYAM_CAN_ENTER_FIELD(element,
6909 boolean can_turn_right = DARK_YAMYAM_CAN_ENTER_FIELD(element,
6912 if (can_turn_left && can_turn_right)
6913 MovDir[x][y] = (RND(3) ? (RND(2) ? left_dir : right_dir) : back_dir);
6914 else if (can_turn_left)
6915 MovDir[x][y] = (RND(2) ? left_dir : back_dir);
6916 else if (can_turn_right)
6917 MovDir[x][y] = (RND(2) ? right_dir : back_dir);
6919 MovDir[x][y] = back_dir;
6921 MovDelay[x][y] = 16 + 16 * RND(3);
6923 else if (element == EL_PACMAN)
6925 boolean can_turn_left = PACMAN_CAN_ENTER_FIELD(element, left_x, left_y);
6926 boolean can_turn_right = PACMAN_CAN_ENTER_FIELD(element, right_x, right_y);
6928 if (can_turn_left && can_turn_right)
6929 MovDir[x][y] = (RND(3) ? (RND(2) ? left_dir : right_dir) : back_dir);
6930 else if (can_turn_left)
6931 MovDir[x][y] = (RND(2) ? left_dir : back_dir);
6932 else if (can_turn_right)
6933 MovDir[x][y] = (RND(2) ? right_dir : back_dir);
6935 MovDir[x][y] = back_dir;
6937 MovDelay[x][y] = 6 + RND(40);
6939 else if (element == EL_PIG)
6941 boolean can_turn_left = PIG_CAN_ENTER_FIELD(element, left_x, left_y);
6942 boolean can_turn_right = PIG_CAN_ENTER_FIELD(element, right_x, right_y);
6943 boolean can_move_on = PIG_CAN_ENTER_FIELD(element, move_x, move_y);
6944 boolean should_turn_left, should_turn_right, should_move_on;
6946 int rnd = RND(rnd_value);
6948 should_turn_left = (can_turn_left &&
6950 IN_LEV_FIELD_AND_NOT_FREE(x + back_dx + left_dx,
6951 y + back_dy + left_dy)));
6952 should_turn_right = (can_turn_right &&
6954 IN_LEV_FIELD_AND_NOT_FREE(x + back_dx + right_dx,
6955 y + back_dy + right_dy)));
6956 should_move_on = (can_move_on &&
6959 IN_LEV_FIELD_AND_NOT_FREE(x + move_dx + left_dx,
6960 y + move_dy + left_dy) ||
6961 IN_LEV_FIELD_AND_NOT_FREE(x + move_dx + right_dx,
6962 y + move_dy + right_dy)));
6964 if (should_turn_left || should_turn_right || should_move_on)
6966 if (should_turn_left && should_turn_right && should_move_on)
6967 MovDir[x][y] = (rnd < rnd_value / 3 ? left_dir :
6968 rnd < 2 * rnd_value / 3 ? right_dir :
6970 else if (should_turn_left && should_turn_right)
6971 MovDir[x][y] = (rnd < rnd_value / 2 ? left_dir : right_dir);
6972 else if (should_turn_left && should_move_on)
6973 MovDir[x][y] = (rnd < rnd_value / 2 ? left_dir : old_move_dir);
6974 else if (should_turn_right && should_move_on)
6975 MovDir[x][y] = (rnd < rnd_value / 2 ? right_dir : old_move_dir);
6976 else if (should_turn_left)
6977 MovDir[x][y] = left_dir;
6978 else if (should_turn_right)
6979 MovDir[x][y] = right_dir;
6980 else if (should_move_on)
6981 MovDir[x][y] = old_move_dir;
6983 else if (can_move_on && rnd > rnd_value / 8)
6984 MovDir[x][y] = old_move_dir;
6985 else if (can_turn_left && can_turn_right)
6986 MovDir[x][y] = (rnd < rnd_value / 2 ? left_dir : right_dir);
6987 else if (can_turn_left && rnd > rnd_value / 8)
6988 MovDir[x][y] = left_dir;
6989 else if (can_turn_right && rnd > rnd_value/8)
6990 MovDir[x][y] = right_dir;
6992 MovDir[x][y] = back_dir;
6994 xx = x + move_xy[MovDir[x][y]].dx;
6995 yy = y + move_xy[MovDir[x][y]].dy;
6997 if (!IN_LEV_FIELD(xx, yy) ||
6998 (!IS_FREE(xx, yy) && !IS_FOOD_PIG(Tile[xx][yy])))
6999 MovDir[x][y] = old_move_dir;
7003 else if (element == EL_DRAGON)
7005 boolean can_turn_left = DRAGON_CAN_ENTER_FIELD(element, left_x, left_y);
7006 boolean can_turn_right = DRAGON_CAN_ENTER_FIELD(element, right_x, right_y);
7007 boolean can_move_on = DRAGON_CAN_ENTER_FIELD(element, move_x, move_y);
7009 int rnd = RND(rnd_value);
7011 if (can_move_on && rnd > rnd_value / 8)
7012 MovDir[x][y] = old_move_dir;
7013 else if (can_turn_left && can_turn_right)
7014 MovDir[x][y] = (rnd < rnd_value / 2 ? left_dir : right_dir);
7015 else if (can_turn_left && rnd > rnd_value / 8)
7016 MovDir[x][y] = left_dir;
7017 else if (can_turn_right && rnd > rnd_value / 8)
7018 MovDir[x][y] = right_dir;
7020 MovDir[x][y] = back_dir;
7022 xx = x + move_xy[MovDir[x][y]].dx;
7023 yy = y + move_xy[MovDir[x][y]].dy;
7025 if (!IN_LEV_FIELD_AND_IS_FREE(xx, yy))
7026 MovDir[x][y] = old_move_dir;
7030 else if (element == EL_MOLE)
7032 boolean can_move_on =
7033 (MOLE_CAN_ENTER_FIELD(element, move_x, move_y,
7034 IS_AMOEBOID(Tile[move_x][move_y]) ||
7035 Tile[move_x][move_y] == EL_AMOEBA_SHRINKING));
7038 boolean can_turn_left =
7039 (MOLE_CAN_ENTER_FIELD(element, left_x, left_y,
7040 IS_AMOEBOID(Tile[left_x][left_y])));
7042 boolean can_turn_right =
7043 (MOLE_CAN_ENTER_FIELD(element, right_x, right_y,
7044 IS_AMOEBOID(Tile[right_x][right_y])));
7046 if (can_turn_left && can_turn_right)
7047 MovDir[x][y] = (RND(2) ? left_dir : right_dir);
7048 else if (can_turn_left)
7049 MovDir[x][y] = left_dir;
7051 MovDir[x][y] = right_dir;
7054 if (MovDir[x][y] != old_move_dir)
7057 else if (element == EL_BALLOON)
7059 MovDir[x][y] = game.wind_direction;
7062 else if (element == EL_SPRING)
7064 if (MovDir[x][y] & MV_HORIZONTAL)
7066 if (SPRING_CAN_BUMP_FROM_FIELD(move_x, move_y) &&
7067 !SPRING_CAN_ENTER_FIELD(element, x, y + 1))
7069 Tile[move_x][move_y] = EL_EMC_SPRING_BUMPER_ACTIVE;
7070 ResetGfxAnimation(move_x, move_y);
7071 TEST_DrawLevelField(move_x, move_y);
7073 MovDir[x][y] = back_dir;
7075 else if (!SPRING_CAN_ENTER_FIELD(element, move_x, move_y) ||
7076 SPRING_CAN_ENTER_FIELD(element, x, y + 1))
7077 MovDir[x][y] = MV_NONE;
7082 else if (element == EL_ROBOT ||
7083 element == EL_SATELLITE ||
7084 element == EL_PENGUIN ||
7085 element == EL_EMC_ANDROID)
7087 int attr_x = -1, attr_y = -1;
7089 if (game.all_players_gone)
7091 attr_x = game.exit_x;
7092 attr_y = game.exit_y;
7098 for (i = 0; i < MAX_PLAYERS; i++)
7100 struct PlayerInfo *player = &stored_player[i];
7101 int jx = player->jx, jy = player->jy;
7103 if (!player->active)
7107 ABS(jx - x) + ABS(jy - y) < ABS(attr_x - x) + ABS(attr_y - y))
7115 if (element == EL_ROBOT &&
7116 game.robot_wheel_x >= 0 &&
7117 game.robot_wheel_y >= 0 &&
7118 (Tile[game.robot_wheel_x][game.robot_wheel_y] == EL_ROBOT_WHEEL_ACTIVE ||
7119 game.engine_version < VERSION_IDENT(3,1,0,0)))
7121 attr_x = game.robot_wheel_x;
7122 attr_y = game.robot_wheel_y;
7125 if (element == EL_PENGUIN)
7128 static int xy[4][2] =
7136 for (i = 0; i < NUM_DIRECTIONS; i++)
7138 int ex = x + xy[i][0];
7139 int ey = y + xy[i][1];
7141 if (IN_LEV_FIELD(ex, ey) && (Tile[ex][ey] == EL_EXIT_OPEN ||
7142 Tile[ex][ey] == EL_EM_EXIT_OPEN ||
7143 Tile[ex][ey] == EL_STEEL_EXIT_OPEN ||
7144 Tile[ex][ey] == EL_EM_STEEL_EXIT_OPEN))
7153 MovDir[x][y] = MV_NONE;
7155 MovDir[x][y] |= (game.all_players_gone ? MV_RIGHT : MV_LEFT);
7156 else if (attr_x > x)
7157 MovDir[x][y] |= (game.all_players_gone ? MV_LEFT : MV_RIGHT);
7159 MovDir[x][y] |= (game.all_players_gone ? MV_DOWN : MV_UP);
7160 else if (attr_y > y)
7161 MovDir[x][y] |= (game.all_players_gone ? MV_UP : MV_DOWN);
7163 if (element == EL_ROBOT)
7167 if (MovDir[x][y] & MV_HORIZONTAL && MovDir[x][y] & MV_VERTICAL)
7168 MovDir[x][y] &= (RND(2) ? MV_HORIZONTAL : MV_VERTICAL);
7169 Moving2Blocked(x, y, &newx, &newy);
7171 if (IN_LEV_FIELD(newx, newy) && IS_FREE_OR_PLAYER(newx, newy))
7172 MovDelay[x][y] = 8 + 8 * !RND(3);
7174 MovDelay[x][y] = 16;
7176 else if (element == EL_PENGUIN)
7182 if (MovDir[x][y] & MV_HORIZONTAL && MovDir[x][y] & MV_VERTICAL)
7184 boolean first_horiz = RND(2);
7185 int new_move_dir = MovDir[x][y];
7188 new_move_dir & (first_horiz ? MV_HORIZONTAL : MV_VERTICAL);
7189 Moving2Blocked(x, y, &newx, &newy);
7191 if (PENGUIN_CAN_ENTER_FIELD(element, newx, newy))
7195 new_move_dir & (!first_horiz ? MV_HORIZONTAL : MV_VERTICAL);
7196 Moving2Blocked(x, y, &newx, &newy);
7198 if (PENGUIN_CAN_ENTER_FIELD(element, newx, newy))
7201 MovDir[x][y] = old_move_dir;
7205 else if (element == EL_SATELLITE)
7211 if (MovDir[x][y] & MV_HORIZONTAL && MovDir[x][y] & MV_VERTICAL)
7213 boolean first_horiz = RND(2);
7214 int new_move_dir = MovDir[x][y];
7217 new_move_dir & (first_horiz ? MV_HORIZONTAL : MV_VERTICAL);
7218 Moving2Blocked(x, y, &newx, &newy);
7220 if (SATELLITE_CAN_ENTER_FIELD(newx, newy))
7224 new_move_dir & (!first_horiz ? MV_HORIZONTAL : MV_VERTICAL);
7225 Moving2Blocked(x, y, &newx, &newy);
7227 if (SATELLITE_CAN_ENTER_FIELD(newx, newy))
7230 MovDir[x][y] = old_move_dir;
7234 else if (element == EL_EMC_ANDROID)
7236 static int check_pos[16] =
7238 -1, // 0 => (invalid)
7241 -1, // 3 => (invalid)
7243 0, // 5 => MV_LEFT | MV_UP
7244 2, // 6 => MV_RIGHT | MV_UP
7245 -1, // 7 => (invalid)
7247 6, // 9 => MV_LEFT | MV_DOWN
7248 4, // 10 => MV_RIGHT | MV_DOWN
7249 -1, // 11 => (invalid)
7250 -1, // 12 => (invalid)
7251 -1, // 13 => (invalid)
7252 -1, // 14 => (invalid)
7253 -1, // 15 => (invalid)
7261 { -1, -1, MV_LEFT | MV_UP },
7263 { +1, -1, MV_RIGHT | MV_UP },
7264 { +1, 0, MV_RIGHT },
7265 { +1, +1, MV_RIGHT | MV_DOWN },
7267 { -1, +1, MV_LEFT | MV_DOWN },
7270 int start_pos, check_order;
7271 boolean can_clone = FALSE;
7274 // check if there is any free field around current position
7275 for (i = 0; i < 8; i++)
7277 int newx = x + check_xy[i].dx;
7278 int newy = y + check_xy[i].dy;
7280 if (IN_LEV_FIELD_AND_IS_FREE(newx, newy))
7288 if (can_clone) // randomly find an element to clone
7292 start_pos = check_pos[RND(8)];
7293 check_order = (RND(2) ? -1 : +1);
7295 for (i = 0; i < 8; i++)
7297 int pos_raw = start_pos + i * check_order;
7298 int pos = (pos_raw + 8) % 8;
7299 int newx = x + check_xy[pos].dx;
7300 int newy = y + check_xy[pos].dy;
7302 if (ANDROID_CAN_CLONE_FIELD(newx, newy))
7304 element_info[element].move_leave_type = LEAVE_TYPE_LIMITED;
7305 element_info[element].move_leave_element = EL_TRIGGER_ELEMENT;
7307 Store[x][y] = Tile[newx][newy];
7316 if (can_clone) // randomly find a direction to move
7320 start_pos = check_pos[RND(8)];
7321 check_order = (RND(2) ? -1 : +1);
7323 for (i = 0; i < 8; i++)
7325 int pos_raw = start_pos + i * check_order;
7326 int pos = (pos_raw + 8) % 8;
7327 int newx = x + check_xy[pos].dx;
7328 int newy = y + check_xy[pos].dy;
7329 int new_move_dir = check_xy[pos].dir;
7331 if (IN_LEV_FIELD_AND_IS_FREE(newx, newy))
7333 MovDir[x][y] = new_move_dir;
7334 MovDelay[x][y] = level.android_clone_time * 8 + 1;
7343 if (can_clone) // cloning and moving successful
7346 // cannot clone -- try to move towards player
7348 start_pos = check_pos[MovDir[x][y] & 0x0f];
7349 check_order = (RND(2) ? -1 : +1);
7351 for (i = 0; i < 3; i++)
7353 // first check start_pos, then previous/next or (next/previous) pos
7354 int pos_raw = start_pos + (i < 2 ? i : -1) * check_order;
7355 int pos = (pos_raw + 8) % 8;
7356 int newx = x + check_xy[pos].dx;
7357 int newy = y + check_xy[pos].dy;
7358 int new_move_dir = check_xy[pos].dir;
7360 if (IS_PLAYER(newx, newy))
7363 if (ANDROID_CAN_ENTER_FIELD(element, newx, newy))
7365 MovDir[x][y] = new_move_dir;
7366 MovDelay[x][y] = level.android_move_time * 8 + 1;
7373 else if (move_pattern == MV_TURNING_LEFT ||
7374 move_pattern == MV_TURNING_RIGHT ||
7375 move_pattern == MV_TURNING_LEFT_RIGHT ||
7376 move_pattern == MV_TURNING_RIGHT_LEFT ||
7377 move_pattern == MV_TURNING_RANDOM ||
7378 move_pattern == MV_ALL_DIRECTIONS)
7380 boolean can_turn_left =
7381 CUSTOM_ELEMENT_CAN_ENTER_FIELD(element, left_x, left_y);
7382 boolean can_turn_right =
7383 CUSTOM_ELEMENT_CAN_ENTER_FIELD(element, right_x,right_y);
7385 if (element_info[element].move_stepsize == 0) // "not moving"
7388 if (move_pattern == MV_TURNING_LEFT)
7389 MovDir[x][y] = left_dir;
7390 else if (move_pattern == MV_TURNING_RIGHT)
7391 MovDir[x][y] = right_dir;
7392 else if (move_pattern == MV_TURNING_LEFT_RIGHT)
7393 MovDir[x][y] = (can_turn_left || !can_turn_right ? left_dir : right_dir);
7394 else if (move_pattern == MV_TURNING_RIGHT_LEFT)
7395 MovDir[x][y] = (can_turn_right || !can_turn_left ? right_dir : left_dir);
7396 else if (move_pattern == MV_TURNING_RANDOM)
7397 MovDir[x][y] = (can_turn_left && !can_turn_right ? left_dir :
7398 can_turn_right && !can_turn_left ? right_dir :
7399 RND(2) ? left_dir : right_dir);
7400 else if (can_turn_left && can_turn_right)
7401 MovDir[x][y] = (RND(3) ? (RND(2) ? left_dir : right_dir) : back_dir);
7402 else if (can_turn_left)
7403 MovDir[x][y] = (RND(2) ? left_dir : back_dir);
7404 else if (can_turn_right)
7405 MovDir[x][y] = (RND(2) ? right_dir : back_dir);
7407 MovDir[x][y] = back_dir;
7409 MovDelay[x][y] = GET_NEW_MOVE_DELAY(element);
7411 else if (move_pattern == MV_HORIZONTAL ||
7412 move_pattern == MV_VERTICAL)
7414 if (move_pattern & old_move_dir)
7415 MovDir[x][y] = back_dir;
7416 else if (move_pattern == MV_HORIZONTAL)
7417 MovDir[x][y] = (RND(2) ? MV_LEFT : MV_RIGHT);
7418 else if (move_pattern == MV_VERTICAL)
7419 MovDir[x][y] = (RND(2) ? MV_UP : MV_DOWN);
7421 MovDelay[x][y] = GET_NEW_MOVE_DELAY(element);
7423 else if (move_pattern & MV_ANY_DIRECTION)
7425 MovDir[x][y] = move_pattern;
7426 MovDelay[x][y] = GET_NEW_MOVE_DELAY(element);
7428 else if (move_pattern & MV_WIND_DIRECTION)
7430 MovDir[x][y] = game.wind_direction;
7431 MovDelay[x][y] = GET_NEW_MOVE_DELAY(element);
7433 else if (move_pattern == MV_ALONG_LEFT_SIDE)
7435 if (CUSTOM_ELEMENT_CAN_ENTER_FIELD(element, left_x, left_y))
7436 MovDir[x][y] = left_dir;
7437 else if (!CUSTOM_ELEMENT_CAN_ENTER_FIELD(element, move_x, move_y))
7438 MovDir[x][y] = right_dir;
7440 if (MovDir[x][y] != old_move_dir)
7441 MovDelay[x][y] = GET_NEW_MOVE_DELAY(element);
7443 else if (move_pattern == MV_ALONG_RIGHT_SIDE)
7445 if (CUSTOM_ELEMENT_CAN_ENTER_FIELD(element, right_x, right_y))
7446 MovDir[x][y] = right_dir;
7447 else if (!CUSTOM_ELEMENT_CAN_ENTER_FIELD(element, move_x, move_y))
7448 MovDir[x][y] = left_dir;
7450 if (MovDir[x][y] != old_move_dir)
7451 MovDelay[x][y] = GET_NEW_MOVE_DELAY(element);
7453 else if (move_pattern == MV_TOWARDS_PLAYER ||
7454 move_pattern == MV_AWAY_FROM_PLAYER)
7456 int attr_x = -1, attr_y = -1;
7458 boolean move_away = (move_pattern == MV_AWAY_FROM_PLAYER);
7460 if (game.all_players_gone)
7462 attr_x = game.exit_x;
7463 attr_y = game.exit_y;
7469 for (i = 0; i < MAX_PLAYERS; i++)
7471 struct PlayerInfo *player = &stored_player[i];
7472 int jx = player->jx, jy = player->jy;
7474 if (!player->active)
7478 ABS(jx - x) + ABS(jy - y) < ABS(attr_x - x) + ABS(attr_y - y))
7486 MovDir[x][y] = MV_NONE;
7488 MovDir[x][y] |= (move_away ? MV_RIGHT : MV_LEFT);
7489 else if (attr_x > x)
7490 MovDir[x][y] |= (move_away ? MV_LEFT : MV_RIGHT);
7492 MovDir[x][y] |= (move_away ? MV_DOWN : MV_UP);
7493 else if (attr_y > y)
7494 MovDir[x][y] |= (move_away ? MV_UP : MV_DOWN);
7496 MovDelay[x][y] = GET_NEW_MOVE_DELAY(element);
7498 if (MovDir[x][y] & MV_HORIZONTAL && MovDir[x][y] & MV_VERTICAL)
7500 boolean first_horiz = RND(2);
7501 int new_move_dir = MovDir[x][y];
7503 if (element_info[element].move_stepsize == 0) // "not moving"
7505 first_horiz = (ABS(attr_x - x) >= ABS(attr_y - y));
7506 MovDir[x][y] &= (first_horiz ? MV_HORIZONTAL : MV_VERTICAL);
7512 new_move_dir & (first_horiz ? MV_HORIZONTAL : MV_VERTICAL);
7513 Moving2Blocked(x, y, &newx, &newy);
7515 if (CUSTOM_ELEMENT_CAN_ENTER_FIELD(element, newx, newy))
7519 new_move_dir & (!first_horiz ? MV_HORIZONTAL : MV_VERTICAL);
7520 Moving2Blocked(x, y, &newx, &newy);
7522 if (CUSTOM_ELEMENT_CAN_ENTER_FIELD(element, newx, newy))
7525 MovDir[x][y] = old_move_dir;
7528 else if (move_pattern == MV_WHEN_PUSHED ||
7529 move_pattern == MV_WHEN_DROPPED)
7531 if (!CUSTOM_ELEMENT_CAN_ENTER_FIELD(element, move_x, move_y))
7532 MovDir[x][y] = MV_NONE;
7536 else if (move_pattern & MV_MAZE_RUNNER_STYLE)
7538 static int test_xy[7][2] =
7548 static int test_dir[7] =
7558 boolean hunter_mode = (move_pattern == MV_MAZE_HUNTER);
7559 int move_preference = -1000000; // start with very low preference
7560 int new_move_dir = MV_NONE;
7561 int start_test = RND(4);
7564 for (i = 0; i < NUM_DIRECTIONS; i++)
7566 int move_dir = test_dir[start_test + i];
7567 int move_dir_preference;
7569 xx = x + test_xy[start_test + i][0];
7570 yy = y + test_xy[start_test + i][1];
7572 if (hunter_mode && IN_LEV_FIELD(xx, yy) &&
7573 (IS_PLAYER(xx, yy) || Tile[xx][yy] == EL_PLAYER_IS_LEAVING))
7575 new_move_dir = move_dir;
7580 if (!CUSTOM_ELEMENT_CAN_ENTER_FIELD(element, xx, yy))
7583 move_dir_preference = -1 * RunnerVisit[xx][yy];
7584 if (hunter_mode && PlayerVisit[xx][yy] > 0)
7585 move_dir_preference = PlayerVisit[xx][yy];
7587 if (move_dir_preference > move_preference)
7589 // prefer field that has not been visited for the longest time
7590 move_preference = move_dir_preference;
7591 new_move_dir = move_dir;
7593 else if (move_dir_preference == move_preference &&
7594 move_dir == old_move_dir)
7596 // prefer last direction when all directions are preferred equally
7597 move_preference = move_dir_preference;
7598 new_move_dir = move_dir;
7602 MovDir[x][y] = new_move_dir;
7603 if (old_move_dir != new_move_dir)
7604 MovDelay[x][y] = GET_NEW_MOVE_DELAY(element);
7608 static void TurnRound(int x, int y)
7610 int direction = MovDir[x][y];
7614 GfxDir[x][y] = MovDir[x][y];
7616 if (direction != MovDir[x][y])
7620 GfxAction[x][y] = ACTION_TURNING_FROM_LEFT + MV_DIR_TO_BIT(direction);
7622 ResetGfxFrame(x, y);
7625 static boolean JustBeingPushed(int x, int y)
7629 for (i = 0; i < MAX_PLAYERS; i++)
7631 struct PlayerInfo *player = &stored_player[i];
7633 if (player->active && player->is_pushing && player->MovPos)
7635 int next_jx = player->jx + (player->jx - player->last_jx);
7636 int next_jy = player->jy + (player->jy - player->last_jy);
7638 if (x == next_jx && y == next_jy)
7646 static void StartMoving(int x, int y)
7648 boolean started_moving = FALSE; // some elements can fall _and_ move
7649 int element = Tile[x][y];
7654 if (MovDelay[x][y] == 0)
7655 GfxAction[x][y] = ACTION_DEFAULT;
7657 if (CAN_FALL(element) && y < lev_fieldy - 1)
7659 if ((x > 0 && IS_PLAYER(x - 1, y)) ||
7660 (x < lev_fieldx - 1 && IS_PLAYER(x + 1, y)))
7661 if (JustBeingPushed(x, y))
7664 if (element == EL_QUICKSAND_FULL)
7666 if (IS_FREE(x, y + 1))
7668 InitMovingField(x, y, MV_DOWN);
7669 started_moving = TRUE;
7671 Tile[x][y] = EL_QUICKSAND_EMPTYING;
7672 #if USE_QUICKSAND_BD_ROCK_BUGFIX
7673 if (Store[x][y] != EL_ROCK && Store[x][y] != EL_BD_ROCK)
7674 Store[x][y] = EL_ROCK;
7676 Store[x][y] = EL_ROCK;
7679 PlayLevelSoundAction(x, y, ACTION_EMPTYING);
7681 else if (Tile[x][y + 1] == EL_QUICKSAND_EMPTY)
7683 if (!MovDelay[x][y])
7685 MovDelay[x][y] = TILEY + 1;
7687 ResetGfxAnimation(x, y);
7688 ResetGfxAnimation(x, y + 1);
7693 DrawLevelElement(x, y, EL_QUICKSAND_EMPTYING);
7694 DrawLevelElement(x, y + 1, EL_QUICKSAND_FILLING);
7701 Tile[x][y] = EL_QUICKSAND_EMPTY;
7702 Tile[x][y + 1] = EL_QUICKSAND_FULL;
7703 Store[x][y + 1] = Store[x][y];
7706 PlayLevelSoundAction(x, y, ACTION_FILLING);
7708 else if (Tile[x][y + 1] == EL_QUICKSAND_FAST_EMPTY)
7710 if (!MovDelay[x][y])
7712 MovDelay[x][y] = TILEY + 1;
7714 ResetGfxAnimation(x, y);
7715 ResetGfxAnimation(x, y + 1);
7720 DrawLevelElement(x, y, EL_QUICKSAND_EMPTYING);
7721 DrawLevelElement(x, y + 1, EL_QUICKSAND_FAST_FILLING);
7728 Tile[x][y] = EL_QUICKSAND_EMPTY;
7729 Tile[x][y + 1] = EL_QUICKSAND_FAST_FULL;
7730 Store[x][y + 1] = Store[x][y];
7733 PlayLevelSoundAction(x, y, ACTION_FILLING);
7736 else if (element == EL_QUICKSAND_FAST_FULL)
7738 if (IS_FREE(x, y + 1))
7740 InitMovingField(x, y, MV_DOWN);
7741 started_moving = TRUE;
7743 Tile[x][y] = EL_QUICKSAND_FAST_EMPTYING;
7744 #if USE_QUICKSAND_BD_ROCK_BUGFIX
7745 if (Store[x][y] != EL_ROCK && Store[x][y] != EL_BD_ROCK)
7746 Store[x][y] = EL_ROCK;
7748 Store[x][y] = EL_ROCK;
7751 PlayLevelSoundAction(x, y, ACTION_EMPTYING);
7753 else if (Tile[x][y + 1] == EL_QUICKSAND_FAST_EMPTY)
7755 if (!MovDelay[x][y])
7757 MovDelay[x][y] = TILEY + 1;
7759 ResetGfxAnimation(x, y);
7760 ResetGfxAnimation(x, y + 1);
7765 DrawLevelElement(x, y, EL_QUICKSAND_FAST_EMPTYING);
7766 DrawLevelElement(x, y + 1, EL_QUICKSAND_FAST_FILLING);
7773 Tile[x][y] = EL_QUICKSAND_FAST_EMPTY;
7774 Tile[x][y + 1] = EL_QUICKSAND_FAST_FULL;
7775 Store[x][y + 1] = Store[x][y];
7778 PlayLevelSoundAction(x, y, ACTION_FILLING);
7780 else if (Tile[x][y + 1] == EL_QUICKSAND_EMPTY)
7782 if (!MovDelay[x][y])
7784 MovDelay[x][y] = TILEY + 1;
7786 ResetGfxAnimation(x, y);
7787 ResetGfxAnimation(x, y + 1);
7792 DrawLevelElement(x, y, EL_QUICKSAND_FAST_EMPTYING);
7793 DrawLevelElement(x, y + 1, EL_QUICKSAND_FILLING);
7800 Tile[x][y] = EL_QUICKSAND_FAST_EMPTY;
7801 Tile[x][y + 1] = EL_QUICKSAND_FULL;
7802 Store[x][y + 1] = Store[x][y];
7805 PlayLevelSoundAction(x, y, ACTION_FILLING);
7808 else if ((element == EL_ROCK || element == EL_BD_ROCK) &&
7809 Tile[x][y + 1] == EL_QUICKSAND_EMPTY)
7811 InitMovingField(x, y, MV_DOWN);
7812 started_moving = TRUE;
7814 Tile[x][y] = EL_QUICKSAND_FILLING;
7815 Store[x][y] = element;
7817 PlayLevelSoundAction(x, y, ACTION_FILLING);
7819 else if ((element == EL_ROCK || element == EL_BD_ROCK) &&
7820 Tile[x][y + 1] == EL_QUICKSAND_FAST_EMPTY)
7822 InitMovingField(x, y, MV_DOWN);
7823 started_moving = TRUE;
7825 Tile[x][y] = EL_QUICKSAND_FAST_FILLING;
7826 Store[x][y] = element;
7828 PlayLevelSoundAction(x, y, ACTION_FILLING);
7830 else if (element == EL_MAGIC_WALL_FULL)
7832 if (IS_FREE(x, y + 1))
7834 InitMovingField(x, y, MV_DOWN);
7835 started_moving = TRUE;
7837 Tile[x][y] = EL_MAGIC_WALL_EMPTYING;
7838 Store[x][y] = EL_CHANGED(Store[x][y]);
7840 else if (Tile[x][y + 1] == EL_MAGIC_WALL_ACTIVE)
7842 if (!MovDelay[x][y])
7843 MovDelay[x][y] = TILEY / 4 + 1;
7852 Tile[x][y] = EL_MAGIC_WALL_ACTIVE;
7853 Tile[x][y + 1] = EL_MAGIC_WALL_FULL;
7854 Store[x][y + 1] = EL_CHANGED(Store[x][y]);
7858 else if (element == EL_BD_MAGIC_WALL_FULL)
7860 if (IS_FREE(x, y + 1))
7862 InitMovingField(x, y, MV_DOWN);
7863 started_moving = TRUE;
7865 Tile[x][y] = EL_BD_MAGIC_WALL_EMPTYING;
7866 Store[x][y] = EL_CHANGED_BD(Store[x][y]);
7868 else if (Tile[x][y + 1] == EL_BD_MAGIC_WALL_ACTIVE)
7870 if (!MovDelay[x][y])
7871 MovDelay[x][y] = TILEY / 4 + 1;
7880 Tile[x][y] = EL_BD_MAGIC_WALL_ACTIVE;
7881 Tile[x][y + 1] = EL_BD_MAGIC_WALL_FULL;
7882 Store[x][y + 1] = EL_CHANGED_BD(Store[x][y]);
7886 else if (element == EL_DC_MAGIC_WALL_FULL)
7888 if (IS_FREE(x, y + 1))
7890 InitMovingField(x, y, MV_DOWN);
7891 started_moving = TRUE;
7893 Tile[x][y] = EL_DC_MAGIC_WALL_EMPTYING;
7894 Store[x][y] = EL_CHANGED_DC(Store[x][y]);
7896 else if (Tile[x][y + 1] == EL_DC_MAGIC_WALL_ACTIVE)
7898 if (!MovDelay[x][y])
7899 MovDelay[x][y] = TILEY / 4 + 1;
7908 Tile[x][y] = EL_DC_MAGIC_WALL_ACTIVE;
7909 Tile[x][y + 1] = EL_DC_MAGIC_WALL_FULL;
7910 Store[x][y + 1] = EL_CHANGED_DC(Store[x][y]);
7914 else if ((CAN_PASS_MAGIC_WALL(element) &&
7915 (Tile[x][y + 1] == EL_MAGIC_WALL_ACTIVE ||
7916 Tile[x][y + 1] == EL_BD_MAGIC_WALL_ACTIVE)) ||
7917 (CAN_PASS_DC_MAGIC_WALL(element) &&
7918 (Tile[x][y + 1] == EL_DC_MAGIC_WALL_ACTIVE)))
7921 InitMovingField(x, y, MV_DOWN);
7922 started_moving = TRUE;
7925 (Tile[x][y + 1] == EL_MAGIC_WALL_ACTIVE ? EL_MAGIC_WALL_FILLING :
7926 Tile[x][y + 1] == EL_BD_MAGIC_WALL_ACTIVE ? EL_BD_MAGIC_WALL_FILLING :
7927 EL_DC_MAGIC_WALL_FILLING);
7928 Store[x][y] = element;
7930 else if (CAN_FALL(element) && Tile[x][y + 1] == EL_ACID)
7932 SplashAcid(x, y + 1);
7934 InitMovingField(x, y, MV_DOWN);
7935 started_moving = TRUE;
7937 Store[x][y] = EL_ACID;
7940 (game.engine_version >= VERSION_IDENT(3,1,0,0) &&
7941 CheckImpact[x][y] && !IS_FREE(x, y + 1)) ||
7942 (game.engine_version >= VERSION_IDENT(3,0,7,0) &&
7943 CAN_FALL(element) && WasJustFalling[x][y] &&
7944 (Tile[x][y + 1] == EL_BLOCKED || IS_PLAYER(x, y + 1))) ||
7946 (game.engine_version < VERSION_IDENT(2,2,0,7) &&
7947 CAN_FALL(element) && WasJustMoving[x][y] && !Pushed[x][y + 1] &&
7948 (Tile[x][y + 1] == EL_BLOCKED)))
7950 /* this is needed for a special case not covered by calling "Impact()"
7951 from "ContinueMoving()": if an element moves to a tile directly below
7952 another element which was just falling on that tile (which was empty
7953 in the previous frame), the falling element above would just stop
7954 instead of smashing the element below (in previous version, the above
7955 element was just checked for "moving" instead of "falling", resulting
7956 in incorrect smashes caused by horizontal movement of the above
7957 element; also, the case of the player being the element to smash was
7958 simply not covered here... :-/ ) */
7960 CheckCollision[x][y] = 0;
7961 CheckImpact[x][y] = 0;
7965 else if (IS_FREE(x, y + 1) && element == EL_SPRING && level.use_spring_bug)
7967 if (MovDir[x][y] == MV_NONE)
7969 InitMovingField(x, y, MV_DOWN);
7970 started_moving = TRUE;
7973 else if (IS_FREE(x, y + 1) || Tile[x][y + 1] == EL_DIAMOND_BREAKING)
7975 if (WasJustFalling[x][y]) // prevent animation from being restarted
7976 MovDir[x][y] = MV_DOWN;
7978 InitMovingField(x, y, MV_DOWN);
7979 started_moving = TRUE;
7981 else if (element == EL_AMOEBA_DROP)
7983 Tile[x][y] = EL_AMOEBA_GROWING;
7984 Store[x][y] = EL_AMOEBA_WET;
7986 else if (((IS_SLIPPERY(Tile[x][y + 1]) && !IS_PLAYER(x, y + 1)) ||
7987 (IS_EM_SLIPPERY_WALL(Tile[x][y + 1]) && IS_GEM(element))) &&
7988 !IS_FALLING(x, y + 1) && !WasJustMoving[x][y + 1] &&
7989 element != EL_DX_SUPABOMB && element != EL_SP_DISK_ORANGE)
7991 boolean can_fall_left = (x > 0 && IS_FREE(x - 1, y) &&
7992 (IS_FREE(x - 1, y + 1) ||
7993 Tile[x - 1][y + 1] == EL_ACID));
7994 boolean can_fall_right = (x < lev_fieldx - 1 && IS_FREE(x + 1, y) &&
7995 (IS_FREE(x + 1, y + 1) ||
7996 Tile[x + 1][y + 1] == EL_ACID));
7997 boolean can_fall_any = (can_fall_left || can_fall_right);
7998 boolean can_fall_both = (can_fall_left && can_fall_right);
7999 int slippery_type = element_info[Tile[x][y + 1]].slippery_type;
8001 if (can_fall_any && slippery_type != SLIPPERY_ANY_RANDOM)
8003 if (slippery_type == SLIPPERY_ANY_LEFT_RIGHT && can_fall_both)
8004 can_fall_right = FALSE;
8005 else if (slippery_type == SLIPPERY_ANY_RIGHT_LEFT && can_fall_both)
8006 can_fall_left = FALSE;
8007 else if (slippery_type == SLIPPERY_ONLY_LEFT)
8008 can_fall_right = FALSE;
8009 else if (slippery_type == SLIPPERY_ONLY_RIGHT)
8010 can_fall_left = FALSE;
8012 can_fall_any = (can_fall_left || can_fall_right);
8013 can_fall_both = FALSE;
8018 if (element == EL_BD_ROCK || element == EL_BD_DIAMOND)
8019 can_fall_right = FALSE; // slip down on left side
8021 can_fall_left = !(can_fall_right = RND(2));
8023 can_fall_both = FALSE;
8028 // if not determined otherwise, prefer left side for slipping down
8029 InitMovingField(x, y, can_fall_left ? MV_LEFT : MV_RIGHT);
8030 started_moving = TRUE;
8033 else if (IS_BELT_ACTIVE(Tile[x][y + 1]))
8035 boolean left_is_free = (x > 0 && IS_FREE(x - 1, y));
8036 boolean right_is_free = (x < lev_fieldx - 1 && IS_FREE(x + 1, y));
8037 int belt_nr = getBeltNrFromBeltActiveElement(Tile[x][y + 1]);
8038 int belt_dir = game.belt_dir[belt_nr];
8040 if ((belt_dir == MV_LEFT && left_is_free) ||
8041 (belt_dir == MV_RIGHT && right_is_free))
8043 int nextx = (belt_dir == MV_LEFT ? x - 1 : x + 1);
8045 InitMovingField(x, y, belt_dir);
8046 started_moving = TRUE;
8048 Pushed[x][y] = TRUE;
8049 Pushed[nextx][y] = TRUE;
8051 GfxAction[x][y] = ACTION_DEFAULT;
8055 MovDir[x][y] = 0; // if element was moving, stop it
8060 // not "else if" because of elements that can fall and move (EL_SPRING)
8061 if (CAN_MOVE(element) && !started_moving)
8063 int move_pattern = element_info[element].move_pattern;
8066 Moving2Blocked(x, y, &newx, &newy);
8068 if (IS_PUSHABLE(element) && JustBeingPushed(x, y))
8071 if (game.engine_version >= VERSION_IDENT(3,1,0,0) &&
8072 CheckCollision[x][y] && !IN_LEV_FIELD_AND_IS_FREE(newx, newy))
8074 WasJustMoving[x][y] = 0;
8075 CheckCollision[x][y] = 0;
8077 TestIfElementHitsCustomElement(x, y, MovDir[x][y]);
8079 if (Tile[x][y] != element) // element has changed
8083 if (!MovDelay[x][y]) // start new movement phase
8085 // all objects that can change their move direction after each step
8086 // (YAMYAM, DARK_YAMYAM and PACMAN go straight until they hit a wall
8088 if (element != EL_YAMYAM &&
8089 element != EL_DARK_YAMYAM &&
8090 element != EL_PACMAN &&
8091 !(move_pattern & MV_ANY_DIRECTION) &&
8092 move_pattern != MV_TURNING_LEFT &&
8093 move_pattern != MV_TURNING_RIGHT &&
8094 move_pattern != MV_TURNING_LEFT_RIGHT &&
8095 move_pattern != MV_TURNING_RIGHT_LEFT &&
8096 move_pattern != MV_TURNING_RANDOM)
8100 if (MovDelay[x][y] && (element == EL_BUG ||
8101 element == EL_SPACESHIP ||
8102 element == EL_SP_SNIKSNAK ||
8103 element == EL_SP_ELECTRON ||
8104 element == EL_MOLE))
8105 TEST_DrawLevelField(x, y);
8109 if (MovDelay[x][y]) // wait some time before next movement
8113 if (element == EL_ROBOT ||
8114 element == EL_YAMYAM ||
8115 element == EL_DARK_YAMYAM)
8117 DrawLevelElementAnimationIfNeeded(x, y, element);
8118 PlayLevelSoundAction(x, y, ACTION_WAITING);
8120 else if (element == EL_SP_ELECTRON)
8121 DrawLevelElementAnimationIfNeeded(x, y, element);
8122 else if (element == EL_DRAGON)
8125 int dir = MovDir[x][y];
8126 int dx = (dir == MV_LEFT ? -1 : dir == MV_RIGHT ? +1 : 0);
8127 int dy = (dir == MV_UP ? -1 : dir == MV_DOWN ? +1 : 0);
8128 int graphic = (dir == MV_LEFT ? IMG_FLAMES_1_LEFT :
8129 dir == MV_RIGHT ? IMG_FLAMES_1_RIGHT :
8130 dir == MV_UP ? IMG_FLAMES_1_UP :
8131 dir == MV_DOWN ? IMG_FLAMES_1_DOWN : IMG_EMPTY);
8132 int frame = getGraphicAnimationFrame(graphic, GfxFrame[x][y]);
8134 GfxAction[x][y] = ACTION_ATTACKING;
8136 if (IS_PLAYER(x, y))
8137 DrawPlayerField(x, y);
8139 TEST_DrawLevelField(x, y);
8141 PlayLevelSoundActionIfLoop(x, y, ACTION_ATTACKING);
8143 for (i = 1; i <= 3; i++)
8145 int xx = x + i * dx;
8146 int yy = y + i * dy;
8147 int sx = SCREENX(xx);
8148 int sy = SCREENY(yy);
8149 int flame_graphic = graphic + (i - 1);
8151 if (!IN_LEV_FIELD(xx, yy) || IS_DRAGONFIRE_PROOF(Tile[xx][yy]))
8156 int flamed = MovingOrBlocked2Element(xx, yy);
8158 if (IS_CLASSIC_ENEMY(flamed) || CAN_EXPLODE_BY_DRAGONFIRE(flamed))
8161 RemoveMovingField(xx, yy);
8163 ChangeDelay[xx][yy] = 0;
8165 Tile[xx][yy] = EL_FLAMES;
8167 if (IN_SCR_FIELD(sx, sy))
8169 TEST_DrawLevelFieldCrumbled(xx, yy);
8170 DrawGraphic(sx, sy, flame_graphic, frame);
8175 if (Tile[xx][yy] == EL_FLAMES)
8176 Tile[xx][yy] = EL_EMPTY;
8177 TEST_DrawLevelField(xx, yy);
8182 if (MovDelay[x][y]) // element still has to wait some time
8184 PlayLevelSoundAction(x, y, ACTION_WAITING);
8190 // now make next step
8192 Moving2Blocked(x, y, &newx, &newy); // get next screen position
8194 if (DONT_COLLIDE_WITH(element) &&
8195 IN_LEV_FIELD(newx, newy) && IS_PLAYER(newx, newy) &&
8196 !PLAYER_ENEMY_PROTECTED(newx, newy))
8198 TestIfBadThingRunsIntoPlayer(x, y, MovDir[x][y]);
8203 else if (CAN_MOVE_INTO_ACID(element) &&
8204 IN_LEV_FIELD(newx, newy) && Tile[newx][newy] == EL_ACID &&
8205 !IS_MV_DIAGONAL(MovDir[x][y]) &&
8206 (MovDir[x][y] == MV_DOWN ||
8207 game.engine_version >= VERSION_IDENT(3,1,0,0)))
8209 SplashAcid(newx, newy);
8210 Store[x][y] = EL_ACID;
8212 else if (element == EL_PENGUIN && IN_LEV_FIELD(newx, newy))
8214 if (Tile[newx][newy] == EL_EXIT_OPEN ||
8215 Tile[newx][newy] == EL_EM_EXIT_OPEN ||
8216 Tile[newx][newy] == EL_STEEL_EXIT_OPEN ||
8217 Tile[newx][newy] == EL_EM_STEEL_EXIT_OPEN)
8220 TEST_DrawLevelField(x, y);
8222 PlayLevelSound(newx, newy, SND_PENGUIN_PASSING);
8223 if (IN_SCR_FIELD(SCREENX(newx), SCREENY(newy)))
8224 DrawGraphicThruMask(SCREENX(newx),SCREENY(newy), el2img(element), 0);
8226 game.friends_still_needed--;
8227 if (!game.friends_still_needed &&
8229 game.all_players_gone)
8234 else if (IS_FOOD_PENGUIN(Tile[newx][newy]))
8236 if (DigField(local_player, x, y, newx, newy, 0,0, DF_DIG) == MP_MOVING)
8237 TEST_DrawLevelField(newx, newy);
8239 GfxDir[x][y] = MovDir[x][y] = MV_NONE;
8241 else if (!IS_FREE(newx, newy))
8243 GfxAction[x][y] = ACTION_WAITING;
8245 if (IS_PLAYER(x, y))
8246 DrawPlayerField(x, y);
8248 TEST_DrawLevelField(x, y);
8253 else if (element == EL_PIG && IN_LEV_FIELD(newx, newy))
8255 if (IS_FOOD_PIG(Tile[newx][newy]))
8257 if (IS_MOVING(newx, newy))
8258 RemoveMovingField(newx, newy);
8261 Tile[newx][newy] = EL_EMPTY;
8262 TEST_DrawLevelField(newx, newy);
8265 PlayLevelSound(x, y, SND_PIG_DIGGING);
8267 else if (!IS_FREE(newx, newy))
8269 if (IS_PLAYER(x, y))
8270 DrawPlayerField(x, y);
8272 TEST_DrawLevelField(x, y);
8277 else if (element == EL_EMC_ANDROID && IN_LEV_FIELD(newx, newy))
8279 if (Store[x][y] != EL_EMPTY)
8281 boolean can_clone = FALSE;
8284 // check if element to clone is still there
8285 for (yy = y - 1; yy <= y + 1; yy++) for (xx = x - 1; xx <= x + 1; xx++)
8287 if (IN_LEV_FIELD(xx, yy) && Tile[xx][yy] == Store[x][y])
8295 // cannot clone or target field not free anymore -- do not clone
8296 if (!can_clone || !ANDROID_CAN_ENTER_FIELD(element, newx, newy))
8297 Store[x][y] = EL_EMPTY;
8300 if (ANDROID_CAN_ENTER_FIELD(element, newx, newy))
8302 if (IS_MV_DIAGONAL(MovDir[x][y]))
8304 int diagonal_move_dir = MovDir[x][y];
8305 int stored = Store[x][y];
8306 int change_delay = 8;
8309 // android is moving diagonally
8311 CreateField(x, y, EL_DIAGONAL_SHRINKING);
8313 Store[x][y] = (stored == EL_ACID ? EL_EMPTY : stored);
8314 GfxElement[x][y] = EL_EMC_ANDROID;
8315 GfxAction[x][y] = ACTION_SHRINKING;
8316 GfxDir[x][y] = diagonal_move_dir;
8317 ChangeDelay[x][y] = change_delay;
8319 graphic = el_act_dir2img(GfxElement[x][y], GfxAction[x][y],
8322 DrawLevelGraphicAnimation(x, y, graphic);
8323 PlayLevelSoundAction(x, y, ACTION_SHRINKING);
8325 if (Tile[newx][newy] == EL_ACID)
8327 SplashAcid(newx, newy);
8332 CreateField(newx, newy, EL_DIAGONAL_GROWING);
8334 Store[newx][newy] = EL_EMC_ANDROID;
8335 GfxElement[newx][newy] = EL_EMC_ANDROID;
8336 GfxAction[newx][newy] = ACTION_GROWING;
8337 GfxDir[newx][newy] = diagonal_move_dir;
8338 ChangeDelay[newx][newy] = change_delay;
8340 graphic = el_act_dir2img(GfxElement[newx][newy],
8341 GfxAction[newx][newy], GfxDir[newx][newy]);
8343 DrawLevelGraphicAnimation(newx, newy, graphic);
8344 PlayLevelSoundAction(newx, newy, ACTION_GROWING);
8350 Tile[newx][newy] = EL_EMPTY;
8351 TEST_DrawLevelField(newx, newy);
8353 PlayLevelSoundAction(x, y, ACTION_DIGGING);
8356 else if (!IS_FREE(newx, newy))
8361 else if (IS_CUSTOM_ELEMENT(element) &&
8362 CUSTOM_ELEMENT_CAN_ENTER_FIELD(element, newx, newy))
8364 if (!DigFieldByCE(newx, newy, element))
8367 if (move_pattern & MV_MAZE_RUNNER_STYLE)
8369 RunnerVisit[x][y] = FrameCounter;
8370 PlayerVisit[x][y] /= 8; // expire player visit path
8373 else if (element == EL_DRAGON && IN_LEV_FIELD(newx, newy))
8375 if (!IS_FREE(newx, newy))
8377 if (IS_PLAYER(x, y))
8378 DrawPlayerField(x, y);
8380 TEST_DrawLevelField(x, y);
8386 boolean wanna_flame = !RND(10);
8387 int dx = newx - x, dy = newy - y;
8388 int newx1 = newx + 1 * dx, newy1 = newy + 1 * dy;
8389 int newx2 = newx + 2 * dx, newy2 = newy + 2 * dy;
8390 int element1 = (IN_LEV_FIELD(newx1, newy1) ?
8391 MovingOrBlocked2Element(newx1, newy1) : EL_STEELWALL);
8392 int element2 = (IN_LEV_FIELD(newx2, newy2) ?
8393 MovingOrBlocked2Element(newx2, newy2) : EL_STEELWALL);
8396 IS_CLASSIC_ENEMY(element1) ||
8397 IS_CLASSIC_ENEMY(element2)) &&
8398 element1 != EL_DRAGON && element2 != EL_DRAGON &&
8399 element1 != EL_FLAMES && element2 != EL_FLAMES)
8401 ResetGfxAnimation(x, y);
8402 GfxAction[x][y] = ACTION_ATTACKING;
8404 if (IS_PLAYER(x, y))
8405 DrawPlayerField(x, y);
8407 TEST_DrawLevelField(x, y);
8409 PlayLevelSound(x, y, SND_DRAGON_ATTACKING);
8411 MovDelay[x][y] = 50;
8413 Tile[newx][newy] = EL_FLAMES;
8414 if (IN_LEV_FIELD(newx1, newy1) && Tile[newx1][newy1] == EL_EMPTY)
8415 Tile[newx1][newy1] = EL_FLAMES;
8416 if (IN_LEV_FIELD(newx2, newy2) && Tile[newx2][newy2] == EL_EMPTY)
8417 Tile[newx2][newy2] = EL_FLAMES;
8423 else if (element == EL_YAMYAM && IN_LEV_FIELD(newx, newy) &&
8424 Tile[newx][newy] == EL_DIAMOND)
8426 if (IS_MOVING(newx, newy))
8427 RemoveMovingField(newx, newy);
8430 Tile[newx][newy] = EL_EMPTY;
8431 TEST_DrawLevelField(newx, newy);
8434 PlayLevelSound(x, y, SND_YAMYAM_DIGGING);
8436 else if (element == EL_DARK_YAMYAM && IN_LEV_FIELD(newx, newy) &&
8437 IS_FOOD_DARK_YAMYAM(Tile[newx][newy]))
8439 if (AmoebaNr[newx][newy])
8441 AmoebaCnt2[AmoebaNr[newx][newy]]--;
8442 if (Tile[newx][newy] == EL_AMOEBA_FULL ||
8443 Tile[newx][newy] == EL_BD_AMOEBA)
8444 AmoebaCnt[AmoebaNr[newx][newy]]--;
8447 if (IS_MOVING(newx, newy))
8449 RemoveMovingField(newx, newy);
8453 Tile[newx][newy] = EL_EMPTY;
8454 TEST_DrawLevelField(newx, newy);
8457 PlayLevelSound(x, y, SND_DARK_YAMYAM_DIGGING);
8459 else if ((element == EL_PACMAN || element == EL_MOLE)
8460 && IN_LEV_FIELD(newx, newy) && IS_AMOEBOID(Tile[newx][newy]))
8462 if (AmoebaNr[newx][newy])
8464 AmoebaCnt2[AmoebaNr[newx][newy]]--;
8465 if (Tile[newx][newy] == EL_AMOEBA_FULL ||
8466 Tile[newx][newy] == EL_BD_AMOEBA)
8467 AmoebaCnt[AmoebaNr[newx][newy]]--;
8470 if (element == EL_MOLE)
8472 Tile[newx][newy] = EL_AMOEBA_SHRINKING;
8473 PlayLevelSound(x, y, SND_MOLE_DIGGING);
8475 ResetGfxAnimation(x, y);
8476 GfxAction[x][y] = ACTION_DIGGING;
8477 TEST_DrawLevelField(x, y);
8479 MovDelay[newx][newy] = 0; // start amoeba shrinking delay
8481 return; // wait for shrinking amoeba
8483 else // element == EL_PACMAN
8485 Tile[newx][newy] = EL_EMPTY;
8486 TEST_DrawLevelField(newx, newy);
8487 PlayLevelSound(x, y, SND_PACMAN_DIGGING);
8490 else if (element == EL_MOLE && IN_LEV_FIELD(newx, newy) &&
8491 (Tile[newx][newy] == EL_AMOEBA_SHRINKING ||
8492 (Tile[newx][newy] == EL_EMPTY && Stop[newx][newy])))
8494 // wait for shrinking amoeba to completely disappear
8497 else if (!IN_LEV_FIELD(newx, newy) || !IS_FREE(newx, newy))
8499 // object was running against a wall
8503 if (GFX_ELEMENT(element) != EL_SAND) // !!! FIX THIS (crumble) !!!
8504 DrawLevelElementAnimation(x, y, element);
8506 if (DONT_TOUCH(element))
8507 TestIfBadThingTouchesPlayer(x, y);
8512 InitMovingField(x, y, MovDir[x][y]);
8514 PlayLevelSoundAction(x, y, ACTION_MOVING);
8518 ContinueMoving(x, y);
8521 void ContinueMoving(int x, int y)
8523 int element = Tile[x][y];
8524 struct ElementInfo *ei = &element_info[element];
8525 int direction = MovDir[x][y];
8526 int dx = (direction == MV_LEFT ? -1 : direction == MV_RIGHT ? +1 : 0);
8527 int dy = (direction == MV_UP ? -1 : direction == MV_DOWN ? +1 : 0);
8528 int newx = x + dx, newy = y + dy;
8529 int stored = Store[x][y];
8530 int stored_new = Store[newx][newy];
8531 boolean pushed_by_player = (Pushed[x][y] && IS_PLAYER(x, y));
8532 boolean pushed_by_conveyor = (Pushed[x][y] && !IS_PLAYER(x, y));
8533 boolean last_line = (newy == lev_fieldy - 1);
8534 boolean use_step_delay = (GET_MAX_STEP_DELAY(element) != 0);
8536 if (pushed_by_player) // special case: moving object pushed by player
8538 MovPos[x][y] = SIGN(MovPos[x][y]) * (TILEX - ABS(PLAYERINFO(x,y)->MovPos));
8540 else if (use_step_delay) // special case: moving object has step delay
8542 if (!MovDelay[x][y])
8543 MovPos[x][y] += getElementMoveStepsize(x, y);
8548 MovDelay[x][y] = GET_NEW_STEP_DELAY(element);
8552 TEST_DrawLevelField(x, y);
8554 return; // element is still waiting
8557 else // normal case: generically moving object
8559 MovPos[x][y] += getElementMoveStepsize(x, y);
8562 if (ABS(MovPos[x][y]) < TILEX)
8564 TEST_DrawLevelField(x, y);
8566 return; // element is still moving
8569 // element reached destination field
8571 Tile[x][y] = EL_EMPTY;
8572 Tile[newx][newy] = element;
8573 MovPos[x][y] = 0; // force "not moving" for "crumbled sand"
8575 if (Store[x][y] == EL_ACID) // element is moving into acid pool
8577 element = Tile[newx][newy] = EL_ACID;
8579 else if (element == EL_MOLE)
8581 Tile[x][y] = EL_SAND;
8583 TEST_DrawLevelFieldCrumbledNeighbours(x, y);
8585 else if (element == EL_QUICKSAND_FILLING)
8587 element = Tile[newx][newy] = get_next_element(element);
8588 Store[newx][newy] = Store[x][y];
8590 else if (element == EL_QUICKSAND_EMPTYING)
8592 Tile[x][y] = get_next_element(element);
8593 element = Tile[newx][newy] = Store[x][y];
8595 else if (element == EL_QUICKSAND_FAST_FILLING)
8597 element = Tile[newx][newy] = get_next_element(element);
8598 Store[newx][newy] = Store[x][y];
8600 else if (element == EL_QUICKSAND_FAST_EMPTYING)
8602 Tile[x][y] = get_next_element(element);
8603 element = Tile[newx][newy] = Store[x][y];
8605 else if (element == EL_MAGIC_WALL_FILLING)
8607 element = Tile[newx][newy] = get_next_element(element);
8608 if (!game.magic_wall_active)
8609 element = Tile[newx][newy] = EL_MAGIC_WALL_DEAD;
8610 Store[newx][newy] = Store[x][y];
8612 else if (element == EL_MAGIC_WALL_EMPTYING)
8614 Tile[x][y] = get_next_element(element);
8615 if (!game.magic_wall_active)
8616 Tile[x][y] = EL_MAGIC_WALL_DEAD;
8617 element = Tile[newx][newy] = Store[x][y];
8619 InitField(newx, newy, FALSE);
8621 else if (element == EL_BD_MAGIC_WALL_FILLING)
8623 element = Tile[newx][newy] = get_next_element(element);
8624 if (!game.magic_wall_active)
8625 element = Tile[newx][newy] = EL_BD_MAGIC_WALL_DEAD;
8626 Store[newx][newy] = Store[x][y];
8628 else if (element == EL_BD_MAGIC_WALL_EMPTYING)
8630 Tile[x][y] = get_next_element(element);
8631 if (!game.magic_wall_active)
8632 Tile[x][y] = EL_BD_MAGIC_WALL_DEAD;
8633 element = Tile[newx][newy] = Store[x][y];
8635 InitField(newx, newy, FALSE);
8637 else if (element == EL_DC_MAGIC_WALL_FILLING)
8639 element = Tile[newx][newy] = get_next_element(element);
8640 if (!game.magic_wall_active)
8641 element = Tile[newx][newy] = EL_DC_MAGIC_WALL_DEAD;
8642 Store[newx][newy] = Store[x][y];
8644 else if (element == EL_DC_MAGIC_WALL_EMPTYING)
8646 Tile[x][y] = get_next_element(element);
8647 if (!game.magic_wall_active)
8648 Tile[x][y] = EL_DC_MAGIC_WALL_DEAD;
8649 element = Tile[newx][newy] = Store[x][y];
8651 InitField(newx, newy, FALSE);
8653 else if (element == EL_AMOEBA_DROPPING)
8655 Tile[x][y] = get_next_element(element);
8656 element = Tile[newx][newy] = Store[x][y];
8658 else if (element == EL_SOKOBAN_OBJECT)
8661 Tile[x][y] = Back[x][y];
8663 if (Back[newx][newy])
8664 Tile[newx][newy] = EL_SOKOBAN_FIELD_FULL;
8666 Back[x][y] = Back[newx][newy] = 0;
8669 Store[x][y] = EL_EMPTY;
8674 MovDelay[newx][newy] = 0;
8676 if (CAN_CHANGE_OR_HAS_ACTION(element))
8678 // copy element change control values to new field
8679 ChangeDelay[newx][newy] = ChangeDelay[x][y];
8680 ChangePage[newx][newy] = ChangePage[x][y];
8681 ChangeCount[newx][newy] = ChangeCount[x][y];
8682 ChangeEvent[newx][newy] = ChangeEvent[x][y];
8685 CustomValue[newx][newy] = CustomValue[x][y];
8687 ChangeDelay[x][y] = 0;
8688 ChangePage[x][y] = -1;
8689 ChangeCount[x][y] = 0;
8690 ChangeEvent[x][y] = -1;
8692 CustomValue[x][y] = 0;
8694 // copy animation control values to new field
8695 GfxFrame[newx][newy] = GfxFrame[x][y];
8696 GfxRandom[newx][newy] = GfxRandom[x][y]; // keep same random value
8697 GfxAction[newx][newy] = GfxAction[x][y]; // keep action one frame
8698 GfxDir[newx][newy] = GfxDir[x][y]; // keep element direction
8700 Pushed[x][y] = Pushed[newx][newy] = FALSE;
8702 // some elements can leave other elements behind after moving
8703 if (ei->move_leave_element != EL_EMPTY &&
8704 (ei->move_leave_type == LEAVE_TYPE_UNLIMITED || stored != EL_EMPTY) &&
8705 (!IS_PLAYER(x, y) || IS_WALKABLE(ei->move_leave_element)))
8707 int move_leave_element = ei->move_leave_element;
8709 // this makes it possible to leave the removed element again
8710 if (ei->move_leave_element == EL_TRIGGER_ELEMENT)
8711 move_leave_element = (stored == EL_ACID ? EL_EMPTY : stored);
8713 Tile[x][y] = move_leave_element;
8715 if (element_info[Tile[x][y]].move_direction_initial == MV_START_PREVIOUS)
8716 MovDir[x][y] = direction;
8718 InitField(x, y, FALSE);
8720 if (GFX_CRUMBLED(Tile[x][y]))
8721 TEST_DrawLevelFieldCrumbledNeighbours(x, y);
8723 if (ELEM_IS_PLAYER(move_leave_element))
8724 RelocatePlayer(x, y, move_leave_element);
8727 // do this after checking for left-behind element
8728 ResetGfxAnimation(x, y); // reset animation values for old field
8730 if (!CAN_MOVE(element) ||
8731 (CAN_FALL(element) && direction == MV_DOWN &&
8732 (element == EL_SPRING ||
8733 element_info[element].move_pattern == MV_WHEN_PUSHED ||
8734 element_info[element].move_pattern == MV_WHEN_DROPPED)))
8735 GfxDir[x][y] = MovDir[newx][newy] = 0;
8737 TEST_DrawLevelField(x, y);
8738 TEST_DrawLevelField(newx, newy);
8740 Stop[newx][newy] = TRUE; // ignore this element until the next frame
8742 // prevent pushed element from moving on in pushed direction
8743 if (pushed_by_player && CAN_MOVE(element) &&
8744 element_info[element].move_pattern & MV_ANY_DIRECTION &&
8745 !(element_info[element].move_pattern & direction))
8746 TurnRound(newx, newy);
8748 // prevent elements on conveyor belt from moving on in last direction
8749 if (pushed_by_conveyor && CAN_FALL(element) &&
8750 direction & MV_HORIZONTAL)
8751 MovDir[newx][newy] = 0;
8753 if (!pushed_by_player)
8755 int nextx = newx + dx, nexty = newy + dy;
8756 boolean check_collision_again = IN_LEV_FIELD_AND_IS_FREE(nextx, nexty);
8758 WasJustMoving[newx][newy] = CHECK_DELAY_MOVING;
8760 if (CAN_FALL(element) && direction == MV_DOWN)
8761 WasJustFalling[newx][newy] = CHECK_DELAY_FALLING;
8763 if ((!CAN_FALL(element) || direction == MV_DOWN) && check_collision_again)
8764 CheckCollision[newx][newy] = CHECK_DELAY_COLLISION;
8766 if (CAN_FALL(element) && direction == MV_DOWN && check_collision_again)
8767 CheckImpact[newx][newy] = CHECK_DELAY_IMPACT;
8770 if (DONT_TOUCH(element)) // object may be nasty to player or others
8772 TestIfBadThingTouchesPlayer(newx, newy);
8773 TestIfBadThingTouchesFriend(newx, newy);
8775 if (!IS_CUSTOM_ELEMENT(element))
8776 TestIfBadThingTouchesOtherBadThing(newx, newy);
8778 else if (element == EL_PENGUIN)
8779 TestIfFriendTouchesBadThing(newx, newy);
8781 if (DONT_GET_HIT_BY(element))
8783 TestIfGoodThingGetsHitByBadThing(newx, newy, direction);
8786 // give the player one last chance (one more frame) to move away
8787 if (CAN_FALL(element) && direction == MV_DOWN &&
8788 (last_line || (!IS_FREE(x, newy + 1) &&
8789 (!IS_PLAYER(x, newy + 1) ||
8790 game.engine_version < VERSION_IDENT(3,1,1,0)))))
8793 if (pushed_by_player && !game.use_change_when_pushing_bug)
8795 int push_side = MV_DIR_OPPOSITE(direction);
8796 struct PlayerInfo *player = PLAYERINFO(x, y);
8798 CheckElementChangeByPlayer(newx, newy, element, CE_PUSHED_BY_PLAYER,
8799 player->index_bit, push_side);
8800 CheckTriggeredElementChangeByPlayer(newx,newy, element, CE_PLAYER_PUSHES_X,
8801 player->index_bit, push_side);
8804 if (element == EL_EMC_ANDROID && pushed_by_player) // make another move
8805 MovDelay[newx][newy] = 1;
8807 CheckTriggeredElementChangeBySide(x, y, element, CE_MOVE_OF_X, direction);
8809 TestIfElementTouchesCustomElement(x, y); // empty or new element
8810 TestIfElementHitsCustomElement(newx, newy, direction);
8811 TestIfPlayerTouchesCustomElement(newx, newy);
8812 TestIfElementTouchesCustomElement(newx, newy);
8814 if (IS_CUSTOM_ELEMENT(element) && ei->move_enter_element != EL_EMPTY &&
8815 IS_EQUAL_OR_IN_GROUP(stored_new, ei->move_enter_element))
8816 CheckElementChangeBySide(newx, newy, element, stored_new, CE_DIGGING_X,
8817 MV_DIR_OPPOSITE(direction));
8820 int AmoebaNeighbourNr(int ax, int ay)
8823 int element = Tile[ax][ay];
8825 static int xy[4][2] =
8833 for (i = 0; i < NUM_DIRECTIONS; i++)
8835 int x = ax + xy[i][0];
8836 int y = ay + xy[i][1];
8838 if (!IN_LEV_FIELD(x, y))
8841 if (Tile[x][y] == element && AmoebaNr[x][y] > 0)
8842 group_nr = AmoebaNr[x][y];
8848 static void AmoebaMerge(int ax, int ay)
8850 int i, x, y, xx, yy;
8851 int new_group_nr = AmoebaNr[ax][ay];
8852 static int xy[4][2] =
8860 if (new_group_nr == 0)
8863 for (i = 0; i < NUM_DIRECTIONS; i++)
8868 if (!IN_LEV_FIELD(x, y))
8871 if ((Tile[x][y] == EL_AMOEBA_FULL ||
8872 Tile[x][y] == EL_BD_AMOEBA ||
8873 Tile[x][y] == EL_AMOEBA_DEAD) &&
8874 AmoebaNr[x][y] != new_group_nr)
8876 int old_group_nr = AmoebaNr[x][y];
8878 if (old_group_nr == 0)
8881 AmoebaCnt[new_group_nr] += AmoebaCnt[old_group_nr];
8882 AmoebaCnt[old_group_nr] = 0;
8883 AmoebaCnt2[new_group_nr] += AmoebaCnt2[old_group_nr];
8884 AmoebaCnt2[old_group_nr] = 0;
8886 SCAN_PLAYFIELD(xx, yy)
8888 if (AmoebaNr[xx][yy] == old_group_nr)
8889 AmoebaNr[xx][yy] = new_group_nr;
8895 void AmoebaToDiamond(int ax, int ay)
8899 if (Tile[ax][ay] == EL_AMOEBA_DEAD)
8901 int group_nr = AmoebaNr[ax][ay];
8906 Debug("game:playing:AmoebaToDiamond", "ax = %d, ay = %d", ax, ay);
8907 Debug("game:playing:AmoebaToDiamond", "This should never happen!");
8913 SCAN_PLAYFIELD(x, y)
8915 if (Tile[x][y] == EL_AMOEBA_DEAD && AmoebaNr[x][y] == group_nr)
8918 Tile[x][y] = EL_AMOEBA_TO_DIAMOND;
8922 PlayLevelSound(ax, ay, (IS_GEM(level.amoeba_content) ?
8923 SND_AMOEBA_TURNING_TO_GEM :
8924 SND_AMOEBA_TURNING_TO_ROCK));
8929 static int xy[4][2] =
8937 for (i = 0; i < NUM_DIRECTIONS; i++)
8942 if (!IN_LEV_FIELD(x, y))
8945 if (Tile[x][y] == EL_AMOEBA_TO_DIAMOND)
8947 PlayLevelSound(x, y, (IS_GEM(level.amoeba_content) ?
8948 SND_AMOEBA_TURNING_TO_GEM :
8949 SND_AMOEBA_TURNING_TO_ROCK));
8956 static void AmoebaToDiamondBD(int ax, int ay, int new_element)
8959 int group_nr = AmoebaNr[ax][ay];
8960 boolean done = FALSE;
8965 Debug("game:playing:AmoebaToDiamondBD", "ax = %d, ay = %d", ax, ay);
8966 Debug("game:playing:AmoebaToDiamondBD", "This should never happen!");
8972 SCAN_PLAYFIELD(x, y)
8974 if (AmoebaNr[x][y] == group_nr &&
8975 (Tile[x][y] == EL_AMOEBA_DEAD ||
8976 Tile[x][y] == EL_BD_AMOEBA ||
8977 Tile[x][y] == EL_AMOEBA_GROWING))
8980 Tile[x][y] = new_element;
8981 InitField(x, y, FALSE);
8982 TEST_DrawLevelField(x, y);
8988 PlayLevelSound(ax, ay, (new_element == EL_BD_ROCK ?
8989 SND_BD_AMOEBA_TURNING_TO_ROCK :
8990 SND_BD_AMOEBA_TURNING_TO_GEM));
8993 static void AmoebaGrowing(int x, int y)
8995 static unsigned int sound_delay = 0;
8996 static unsigned int sound_delay_value = 0;
8998 if (!MovDelay[x][y]) // start new growing cycle
9002 if (DelayReached(&sound_delay, sound_delay_value))
9004 PlayLevelSoundElementAction(x, y, Store[x][y], ACTION_GROWING);
9005 sound_delay_value = 30;
9009 if (MovDelay[x][y]) // wait some time before growing bigger
9012 if (MovDelay[x][y]/2 && IN_SCR_FIELD(SCREENX(x), SCREENY(y)))
9014 int frame = getGraphicAnimationFrame(IMG_AMOEBA_GROWING,
9015 6 - MovDelay[x][y]);
9017 DrawGraphic(SCREENX(x), SCREENY(y), IMG_AMOEBA_GROWING, frame);
9020 if (!MovDelay[x][y])
9022 Tile[x][y] = Store[x][y];
9024 TEST_DrawLevelField(x, y);
9029 static void AmoebaShrinking(int x, int y)
9031 static unsigned int sound_delay = 0;
9032 static unsigned int sound_delay_value = 0;
9034 if (!MovDelay[x][y]) // start new shrinking cycle
9038 if (DelayReached(&sound_delay, sound_delay_value))
9039 sound_delay_value = 30;
9042 if (MovDelay[x][y]) // wait some time before shrinking
9045 if (MovDelay[x][y]/2 && IN_SCR_FIELD(SCREENX(x), SCREENY(y)))
9047 int frame = getGraphicAnimationFrame(IMG_AMOEBA_SHRINKING,
9048 6 - MovDelay[x][y]);
9050 DrawGraphic(SCREENX(x), SCREENY(y), IMG_AMOEBA_SHRINKING, frame);
9053 if (!MovDelay[x][y])
9055 Tile[x][y] = EL_EMPTY;
9056 TEST_DrawLevelField(x, y);
9058 // don't let mole enter this field in this cycle;
9059 // (give priority to objects falling to this field from above)
9065 static void AmoebaReproduce(int ax, int ay)
9068 int element = Tile[ax][ay];
9069 int graphic = el2img(element);
9070 int newax = ax, neway = ay;
9071 boolean can_drop = (element == EL_AMOEBA_WET || element == EL_EMC_DRIPPER);
9072 static int xy[4][2] =
9080 if (!level.amoeba_speed && element != EL_EMC_DRIPPER)
9082 Tile[ax][ay] = EL_AMOEBA_DEAD;
9083 TEST_DrawLevelField(ax, ay);
9087 if (IS_ANIMATED(graphic))
9088 DrawLevelGraphicAnimationIfNeeded(ax, ay, graphic);
9090 if (!MovDelay[ax][ay]) // start making new amoeba field
9091 MovDelay[ax][ay] = RND(FRAMES_PER_SECOND * 25 / (1 + level.amoeba_speed));
9093 if (MovDelay[ax][ay]) // wait some time before making new amoeba
9096 if (MovDelay[ax][ay])
9100 if (can_drop) // EL_AMOEBA_WET or EL_EMC_DRIPPER
9103 int x = ax + xy[start][0];
9104 int y = ay + xy[start][1];
9106 if (!IN_LEV_FIELD(x, y))
9109 if (IS_FREE(x, y) ||
9110 CAN_GROW_INTO(Tile[x][y]) ||
9111 Tile[x][y] == EL_QUICKSAND_EMPTY ||
9112 Tile[x][y] == EL_QUICKSAND_FAST_EMPTY)
9118 if (newax == ax && neway == ay)
9121 else // normal or "filled" (BD style) amoeba
9124 boolean waiting_for_player = FALSE;
9126 for (i = 0; i < NUM_DIRECTIONS; i++)
9128 int j = (start + i) % 4;
9129 int x = ax + xy[j][0];
9130 int y = ay + xy[j][1];
9132 if (!IN_LEV_FIELD(x, y))
9135 if (IS_FREE(x, y) ||
9136 CAN_GROW_INTO(Tile[x][y]) ||
9137 Tile[x][y] == EL_QUICKSAND_EMPTY ||
9138 Tile[x][y] == EL_QUICKSAND_FAST_EMPTY)
9144 else if (IS_PLAYER(x, y))
9145 waiting_for_player = TRUE;
9148 if (newax == ax && neway == ay) // amoeba cannot grow
9150 if (i == 4 && (!waiting_for_player || element == EL_BD_AMOEBA))
9152 Tile[ax][ay] = EL_AMOEBA_DEAD;
9153 TEST_DrawLevelField(ax, ay);
9154 AmoebaCnt[AmoebaNr[ax][ay]]--;
9156 if (AmoebaCnt[AmoebaNr[ax][ay]] <= 0) // amoeba is completely dead
9158 if (element == EL_AMOEBA_FULL)
9159 AmoebaToDiamond(ax, ay);
9160 else if (element == EL_BD_AMOEBA)
9161 AmoebaToDiamondBD(ax, ay, level.amoeba_content);
9166 else if (element == EL_AMOEBA_FULL || element == EL_BD_AMOEBA)
9168 // amoeba gets larger by growing in some direction
9170 int new_group_nr = AmoebaNr[ax][ay];
9173 if (new_group_nr == 0)
9175 Debug("game:playing:AmoebaReproduce", "newax = %d, neway = %d",
9177 Debug("game:playing:AmoebaReproduce", "This should never happen!");
9183 AmoebaNr[newax][neway] = new_group_nr;
9184 AmoebaCnt[new_group_nr]++;
9185 AmoebaCnt2[new_group_nr]++;
9187 // if amoeba touches other amoeba(s) after growing, unify them
9188 AmoebaMerge(newax, neway);
9190 if (element == EL_BD_AMOEBA && AmoebaCnt2[new_group_nr] >= 200)
9192 AmoebaToDiamondBD(newax, neway, EL_BD_ROCK);
9198 if (!can_drop || neway < ay || !IS_FREE(newax, neway) ||
9199 (neway == lev_fieldy - 1 && newax != ax))
9201 Tile[newax][neway] = EL_AMOEBA_GROWING; // creation of new amoeba
9202 Store[newax][neway] = element;
9204 else if (neway == ay || element == EL_EMC_DRIPPER)
9206 Tile[newax][neway] = EL_AMOEBA_DROP; // drop left/right of amoeba
9208 PlayLevelSoundAction(newax, neway, ACTION_GROWING);
9212 InitMovingField(ax, ay, MV_DOWN); // drop dripping from amoeba
9213 Tile[ax][ay] = EL_AMOEBA_DROPPING;
9214 Store[ax][ay] = EL_AMOEBA_DROP;
9215 ContinueMoving(ax, ay);
9219 TEST_DrawLevelField(newax, neway);
9222 static void Life(int ax, int ay)
9226 int element = Tile[ax][ay];
9227 int graphic = el2img(element);
9228 int *life_parameter = (element == EL_GAME_OF_LIFE ? level.game_of_life :
9230 boolean changed = FALSE;
9232 if (IS_ANIMATED(graphic))
9233 DrawLevelGraphicAnimationIfNeeded(ax, ay, graphic);
9238 if (!MovDelay[ax][ay]) // start new "game of life" cycle
9239 MovDelay[ax][ay] = life_time;
9241 if (MovDelay[ax][ay]) // wait some time before next cycle
9244 if (MovDelay[ax][ay])
9248 for (y1 = -1; y1 < 2; y1++) for (x1 = -1; x1 < 2; x1++)
9250 int xx = ax+x1, yy = ay+y1;
9251 int old_element = Tile[xx][yy];
9252 int num_neighbours = 0;
9254 if (!IN_LEV_FIELD(xx, yy))
9257 for (y2 = -1; y2 < 2; y2++) for (x2 = -1; x2 < 2; x2++)
9259 int x = xx+x2, y = yy+y2;
9261 if (!IN_LEV_FIELD(x, y) || (x == xx && y == yy))
9264 boolean is_player_cell = (element == EL_GAME_OF_LIFE && IS_PLAYER(x, y));
9265 boolean is_neighbour = FALSE;
9267 if (level.use_life_bugs)
9269 (((Tile[x][y] == element || is_player_cell) && !Stop[x][y]) ||
9270 (IS_FREE(x, y) && Stop[x][y]));
9273 (Last[x][y] == element || is_player_cell);
9279 boolean is_free = FALSE;
9281 if (level.use_life_bugs)
9282 is_free = (IS_FREE(xx, yy));
9284 is_free = (IS_FREE(xx, yy) && Last[xx][yy] == EL_EMPTY);
9286 if (xx == ax && yy == ay) // field in the middle
9288 if (num_neighbours < life_parameter[0] ||
9289 num_neighbours > life_parameter[1])
9291 Tile[xx][yy] = EL_EMPTY;
9292 if (Tile[xx][yy] != old_element)
9293 TEST_DrawLevelField(xx, yy);
9294 Stop[xx][yy] = TRUE;
9298 else if (is_free || CAN_GROW_INTO(Tile[xx][yy]))
9299 { // free border field
9300 if (num_neighbours >= life_parameter[2] &&
9301 num_neighbours <= life_parameter[3])
9303 Tile[xx][yy] = element;
9304 MovDelay[xx][yy] = (element == EL_GAME_OF_LIFE ? 0 : life_time-1);
9305 if (Tile[xx][yy] != old_element)
9306 TEST_DrawLevelField(xx, yy);
9307 Stop[xx][yy] = TRUE;
9314 PlayLevelSound(ax, ay, element == EL_BIOMAZE ? SND_BIOMAZE_GROWING :
9315 SND_GAME_OF_LIFE_GROWING);
9318 static void InitRobotWheel(int x, int y)
9320 ChangeDelay[x][y] = level.time_wheel * FRAMES_PER_SECOND;
9323 static void RunRobotWheel(int x, int y)
9325 PlayLevelSound(x, y, SND_ROBOT_WHEEL_ACTIVE);
9328 static void StopRobotWheel(int x, int y)
9330 if (game.robot_wheel_x == x &&
9331 game.robot_wheel_y == y)
9333 game.robot_wheel_x = -1;
9334 game.robot_wheel_y = -1;
9335 game.robot_wheel_active = FALSE;
9339 static void InitTimegateWheel(int x, int y)
9341 ChangeDelay[x][y] = level.time_timegate * FRAMES_PER_SECOND;
9344 static void RunTimegateWheel(int x, int y)
9346 PlayLevelSound(x, y, SND_CLASS_TIMEGATE_SWITCH_ACTIVE);
9349 static void InitMagicBallDelay(int x, int y)
9351 ChangeDelay[x][y] = (level.ball_time + 1) * 8 + 1;
9354 static void ActivateMagicBall(int bx, int by)
9358 if (level.ball_random)
9360 int pos_border = RND(8); // select one of the eight border elements
9361 int pos_content = (pos_border > 3 ? pos_border + 1 : pos_border);
9362 int xx = pos_content % 3;
9363 int yy = pos_content / 3;
9368 if (IN_LEV_FIELD(x, y) && Tile[x][y] == EL_EMPTY)
9369 CreateField(x, y, level.ball_content[game.ball_content_nr].e[xx][yy]);
9373 for (y = by - 1; y <= by + 1; y++) for (x = bx - 1; x <= bx + 1; x++)
9375 int xx = x - bx + 1;
9376 int yy = y - by + 1;
9378 if (IN_LEV_FIELD(x, y) && Tile[x][y] == EL_EMPTY)
9379 CreateField(x, y, level.ball_content[game.ball_content_nr].e[xx][yy]);
9383 game.ball_content_nr = (game.ball_content_nr + 1) % level.num_ball_contents;
9386 static void CheckExit(int x, int y)
9388 if (game.gems_still_needed > 0 ||
9389 game.sokoban_fields_still_needed > 0 ||
9390 game.sokoban_objects_still_needed > 0 ||
9391 game.lights_still_needed > 0)
9393 int element = Tile[x][y];
9394 int graphic = el2img(element);
9396 if (IS_ANIMATED(graphic))
9397 DrawLevelGraphicAnimationIfNeeded(x, y, graphic);
9402 // do not re-open exit door closed after last player
9403 if (game.all_players_gone)
9406 Tile[x][y] = EL_EXIT_OPENING;
9408 PlayLevelSoundNearest(x, y, SND_CLASS_EXIT_OPENING);
9411 static void CheckExitEM(int x, int y)
9413 if (game.gems_still_needed > 0 ||
9414 game.sokoban_fields_still_needed > 0 ||
9415 game.sokoban_objects_still_needed > 0 ||
9416 game.lights_still_needed > 0)
9418 int element = Tile[x][y];
9419 int graphic = el2img(element);
9421 if (IS_ANIMATED(graphic))
9422 DrawLevelGraphicAnimationIfNeeded(x, y, graphic);
9427 // do not re-open exit door closed after last player
9428 if (game.all_players_gone)
9431 Tile[x][y] = EL_EM_EXIT_OPENING;
9433 PlayLevelSoundNearest(x, y, SND_CLASS_EM_EXIT_OPENING);
9436 static void CheckExitSteel(int x, int y)
9438 if (game.gems_still_needed > 0 ||
9439 game.sokoban_fields_still_needed > 0 ||
9440 game.sokoban_objects_still_needed > 0 ||
9441 game.lights_still_needed > 0)
9443 int element = Tile[x][y];
9444 int graphic = el2img(element);
9446 if (IS_ANIMATED(graphic))
9447 DrawLevelGraphicAnimationIfNeeded(x, y, graphic);
9452 // do not re-open exit door closed after last player
9453 if (game.all_players_gone)
9456 Tile[x][y] = EL_STEEL_EXIT_OPENING;
9458 PlayLevelSoundNearest(x, y, SND_CLASS_STEEL_EXIT_OPENING);
9461 static void CheckExitSteelEM(int x, int y)
9463 if (game.gems_still_needed > 0 ||
9464 game.sokoban_fields_still_needed > 0 ||
9465 game.sokoban_objects_still_needed > 0 ||
9466 game.lights_still_needed > 0)
9468 int element = Tile[x][y];
9469 int graphic = el2img(element);
9471 if (IS_ANIMATED(graphic))
9472 DrawLevelGraphicAnimationIfNeeded(x, y, graphic);
9477 // do not re-open exit door closed after last player
9478 if (game.all_players_gone)
9481 Tile[x][y] = EL_EM_STEEL_EXIT_OPENING;
9483 PlayLevelSoundNearest(x, y, SND_CLASS_EM_STEEL_EXIT_OPENING);
9486 static void CheckExitSP(int x, int y)
9488 if (game.gems_still_needed > 0)
9490 int element = Tile[x][y];
9491 int graphic = el2img(element);
9493 if (IS_ANIMATED(graphic))
9494 DrawLevelGraphicAnimationIfNeeded(x, y, graphic);
9499 // do not re-open exit door closed after last player
9500 if (game.all_players_gone)
9503 Tile[x][y] = EL_SP_EXIT_OPENING;
9505 PlayLevelSoundNearest(x, y, SND_CLASS_SP_EXIT_OPENING);
9508 static void CloseAllOpenTimegates(void)
9512 SCAN_PLAYFIELD(x, y)
9514 int element = Tile[x][y];
9516 if (element == EL_TIMEGATE_OPEN || element == EL_TIMEGATE_OPENING)
9518 Tile[x][y] = EL_TIMEGATE_CLOSING;
9520 PlayLevelSoundAction(x, y, ACTION_CLOSING);
9525 static void DrawTwinkleOnField(int x, int y)
9527 if (!IN_SCR_FIELD(SCREENX(x), SCREENY(y)) || IS_MOVING(x, y))
9530 if (Tile[x][y] == EL_BD_DIAMOND)
9533 if (MovDelay[x][y] == 0) // next animation frame
9534 MovDelay[x][y] = 11 * !GetSimpleRandom(500);
9536 if (MovDelay[x][y] != 0) // wait some time before next frame
9540 DrawLevelElementAnimation(x, y, Tile[x][y]);
9542 if (MovDelay[x][y] != 0)
9544 int frame = getGraphicAnimationFrame(IMG_TWINKLE_WHITE,
9545 10 - MovDelay[x][y]);
9547 DrawGraphicThruMask(SCREENX(x), SCREENY(y), IMG_TWINKLE_WHITE, frame);
9552 static void MauerWaechst(int x, int y)
9556 if (!MovDelay[x][y]) // next animation frame
9557 MovDelay[x][y] = 3 * delay;
9559 if (MovDelay[x][y]) // wait some time before next frame
9563 if (IN_SCR_FIELD(SCREENX(x), SCREENY(y)))
9565 int graphic = el_dir2img(Tile[x][y], GfxDir[x][y]);
9566 int frame = getGraphicAnimationFrame(graphic, 17 - MovDelay[x][y]);
9568 DrawGraphic(SCREENX(x), SCREENY(y), graphic, frame);
9571 if (!MovDelay[x][y])
9573 if (MovDir[x][y] == MV_LEFT)
9575 if (IN_LEV_FIELD(x - 1, y) && IS_WALL(Tile[x - 1][y]))
9576 TEST_DrawLevelField(x - 1, y);
9578 else if (MovDir[x][y] == MV_RIGHT)
9580 if (IN_LEV_FIELD(x + 1, y) && IS_WALL(Tile[x + 1][y]))
9581 TEST_DrawLevelField(x + 1, y);
9583 else if (MovDir[x][y] == MV_UP)
9585 if (IN_LEV_FIELD(x, y - 1) && IS_WALL(Tile[x][y - 1]))
9586 TEST_DrawLevelField(x, y - 1);
9590 if (IN_LEV_FIELD(x, y + 1) && IS_WALL(Tile[x][y + 1]))
9591 TEST_DrawLevelField(x, y + 1);
9594 Tile[x][y] = Store[x][y];
9596 GfxDir[x][y] = MovDir[x][y] = MV_NONE;
9597 TEST_DrawLevelField(x, y);
9602 static void MauerAbleger(int ax, int ay)
9604 int element = Tile[ax][ay];
9605 int graphic = el2img(element);
9606 boolean oben_frei = FALSE, unten_frei = FALSE;
9607 boolean links_frei = FALSE, rechts_frei = FALSE;
9608 boolean oben_massiv = FALSE, unten_massiv = FALSE;
9609 boolean links_massiv = FALSE, rechts_massiv = FALSE;
9610 boolean new_wall = FALSE;
9612 if (IS_ANIMATED(graphic))
9613 DrawLevelGraphicAnimationIfNeeded(ax, ay, graphic);
9615 if (!MovDelay[ax][ay]) // start building new wall
9616 MovDelay[ax][ay] = 6;
9618 if (MovDelay[ax][ay]) // wait some time before building new wall
9621 if (MovDelay[ax][ay])
9625 if (IN_LEV_FIELD(ax, ay-1) && IS_FREE(ax, ay-1))
9627 if (IN_LEV_FIELD(ax, ay+1) && IS_FREE(ax, ay+1))
9629 if (IN_LEV_FIELD(ax-1, ay) && IS_FREE(ax-1, ay))
9631 if (IN_LEV_FIELD(ax+1, ay) && IS_FREE(ax+1, ay))
9634 if (element == EL_EXPANDABLE_WALL_VERTICAL ||
9635 element == EL_EXPANDABLE_WALL_ANY)
9639 Tile[ax][ay-1] = EL_EXPANDABLE_WALL_GROWING;
9640 Store[ax][ay-1] = element;
9641 GfxDir[ax][ay-1] = MovDir[ax][ay-1] = MV_UP;
9642 if (IN_SCR_FIELD(SCREENX(ax), SCREENY(ay-1)))
9643 DrawGraphic(SCREENX(ax), SCREENY(ay - 1),
9644 IMG_EXPANDABLE_WALL_GROWING_UP, 0);
9649 Tile[ax][ay+1] = EL_EXPANDABLE_WALL_GROWING;
9650 Store[ax][ay+1] = element;
9651 GfxDir[ax][ay+1] = MovDir[ax][ay+1] = MV_DOWN;
9652 if (IN_SCR_FIELD(SCREENX(ax), SCREENY(ay+1)))
9653 DrawGraphic(SCREENX(ax), SCREENY(ay + 1),
9654 IMG_EXPANDABLE_WALL_GROWING_DOWN, 0);
9659 if (element == EL_EXPANDABLE_WALL_HORIZONTAL ||
9660 element == EL_EXPANDABLE_WALL_ANY ||
9661 element == EL_EXPANDABLE_WALL ||
9662 element == EL_BD_EXPANDABLE_WALL)
9666 Tile[ax-1][ay] = EL_EXPANDABLE_WALL_GROWING;
9667 Store[ax-1][ay] = element;
9668 GfxDir[ax-1][ay] = MovDir[ax-1][ay] = MV_LEFT;
9669 if (IN_SCR_FIELD(SCREENX(ax-1), SCREENY(ay)))
9670 DrawGraphic(SCREENX(ax - 1), SCREENY(ay),
9671 IMG_EXPANDABLE_WALL_GROWING_LEFT, 0);
9677 Tile[ax+1][ay] = EL_EXPANDABLE_WALL_GROWING;
9678 Store[ax+1][ay] = element;
9679 GfxDir[ax+1][ay] = MovDir[ax+1][ay] = MV_RIGHT;
9680 if (IN_SCR_FIELD(SCREENX(ax+1), SCREENY(ay)))
9681 DrawGraphic(SCREENX(ax + 1), SCREENY(ay),
9682 IMG_EXPANDABLE_WALL_GROWING_RIGHT, 0);
9687 if (element == EL_EXPANDABLE_WALL && (links_frei || rechts_frei))
9688 TEST_DrawLevelField(ax, ay);
9690 if (!IN_LEV_FIELD(ax, ay-1) || IS_WALL(Tile[ax][ay-1]))
9692 if (!IN_LEV_FIELD(ax, ay+1) || IS_WALL(Tile[ax][ay+1]))
9693 unten_massiv = TRUE;
9694 if (!IN_LEV_FIELD(ax-1, ay) || IS_WALL(Tile[ax-1][ay]))
9695 links_massiv = TRUE;
9696 if (!IN_LEV_FIELD(ax+1, ay) || IS_WALL(Tile[ax+1][ay]))
9697 rechts_massiv = TRUE;
9699 if (((oben_massiv && unten_massiv) ||
9700 element == EL_EXPANDABLE_WALL_HORIZONTAL ||
9701 element == EL_EXPANDABLE_WALL) &&
9702 ((links_massiv && rechts_massiv) ||
9703 element == EL_EXPANDABLE_WALL_VERTICAL))
9704 Tile[ax][ay] = EL_WALL;
9707 PlayLevelSoundAction(ax, ay, ACTION_GROWING);
9710 static void MauerAblegerStahl(int ax, int ay)
9712 int element = Tile[ax][ay];
9713 int graphic = el2img(element);
9714 boolean oben_frei = FALSE, unten_frei = FALSE;
9715 boolean links_frei = FALSE, rechts_frei = FALSE;
9716 boolean oben_massiv = FALSE, unten_massiv = FALSE;
9717 boolean links_massiv = FALSE, rechts_massiv = FALSE;
9718 boolean new_wall = FALSE;
9720 if (IS_ANIMATED(graphic))
9721 DrawLevelGraphicAnimationIfNeeded(ax, ay, graphic);
9723 if (!MovDelay[ax][ay]) // start building new wall
9724 MovDelay[ax][ay] = 6;
9726 if (MovDelay[ax][ay]) // wait some time before building new wall
9729 if (MovDelay[ax][ay])
9733 if (IN_LEV_FIELD(ax, ay-1) && IS_FREE(ax, ay-1))
9735 if (IN_LEV_FIELD(ax, ay+1) && IS_FREE(ax, ay+1))
9737 if (IN_LEV_FIELD(ax-1, ay) && IS_FREE(ax-1, ay))
9739 if (IN_LEV_FIELD(ax+1, ay) && IS_FREE(ax+1, ay))
9742 if (element == EL_EXPANDABLE_STEELWALL_VERTICAL ||
9743 element == EL_EXPANDABLE_STEELWALL_ANY)
9747 Tile[ax][ay-1] = EL_EXPANDABLE_STEELWALL_GROWING;
9748 Store[ax][ay-1] = element;
9749 GfxDir[ax][ay-1] = MovDir[ax][ay-1] = MV_UP;
9750 if (IN_SCR_FIELD(SCREENX(ax), SCREENY(ay-1)))
9751 DrawGraphic(SCREENX(ax), SCREENY(ay - 1),
9752 IMG_EXPANDABLE_STEELWALL_GROWING_UP, 0);
9757 Tile[ax][ay+1] = EL_EXPANDABLE_STEELWALL_GROWING;
9758 Store[ax][ay+1] = element;
9759 GfxDir[ax][ay+1] = MovDir[ax][ay+1] = MV_DOWN;
9760 if (IN_SCR_FIELD(SCREENX(ax), SCREENY(ay+1)))
9761 DrawGraphic(SCREENX(ax), SCREENY(ay + 1),
9762 IMG_EXPANDABLE_STEELWALL_GROWING_DOWN, 0);
9767 if (element == EL_EXPANDABLE_STEELWALL_HORIZONTAL ||
9768 element == EL_EXPANDABLE_STEELWALL_ANY)
9772 Tile[ax-1][ay] = EL_EXPANDABLE_STEELWALL_GROWING;
9773 Store[ax-1][ay] = element;
9774 GfxDir[ax-1][ay] = MovDir[ax-1][ay] = MV_LEFT;
9775 if (IN_SCR_FIELD(SCREENX(ax-1), SCREENY(ay)))
9776 DrawGraphic(SCREENX(ax - 1), SCREENY(ay),
9777 IMG_EXPANDABLE_STEELWALL_GROWING_LEFT, 0);
9783 Tile[ax+1][ay] = EL_EXPANDABLE_STEELWALL_GROWING;
9784 Store[ax+1][ay] = element;
9785 GfxDir[ax+1][ay] = MovDir[ax+1][ay] = MV_RIGHT;
9786 if (IN_SCR_FIELD(SCREENX(ax+1), SCREENY(ay)))
9787 DrawGraphic(SCREENX(ax + 1), SCREENY(ay),
9788 IMG_EXPANDABLE_STEELWALL_GROWING_RIGHT, 0);
9793 if (!IN_LEV_FIELD(ax, ay-1) || IS_WALL(Tile[ax][ay-1]))
9795 if (!IN_LEV_FIELD(ax, ay+1) || IS_WALL(Tile[ax][ay+1]))
9796 unten_massiv = TRUE;
9797 if (!IN_LEV_FIELD(ax-1, ay) || IS_WALL(Tile[ax-1][ay]))
9798 links_massiv = TRUE;
9799 if (!IN_LEV_FIELD(ax+1, ay) || IS_WALL(Tile[ax+1][ay]))
9800 rechts_massiv = TRUE;
9802 if (((oben_massiv && unten_massiv) ||
9803 element == EL_EXPANDABLE_STEELWALL_HORIZONTAL) &&
9804 ((links_massiv && rechts_massiv) ||
9805 element == EL_EXPANDABLE_STEELWALL_VERTICAL))
9806 Tile[ax][ay] = EL_STEELWALL;
9809 PlayLevelSoundAction(ax, ay, ACTION_GROWING);
9812 static void CheckForDragon(int x, int y)
9815 boolean dragon_found = FALSE;
9816 static int xy[4][2] =
9824 for (i = 0; i < NUM_DIRECTIONS; i++)
9826 for (j = 0; j < 4; j++)
9828 int xx = x + j * xy[i][0], yy = y + j * xy[i][1];
9830 if (IN_LEV_FIELD(xx, yy) &&
9831 (Tile[xx][yy] == EL_FLAMES || Tile[xx][yy] == EL_DRAGON))
9833 if (Tile[xx][yy] == EL_DRAGON)
9834 dragon_found = TRUE;
9843 for (i = 0; i < NUM_DIRECTIONS; i++)
9845 for (j = 0; j < 3; j++)
9847 int xx = x + j * xy[i][0], yy = y + j * xy[i][1];
9849 if (IN_LEV_FIELD(xx, yy) && Tile[xx][yy] == EL_FLAMES)
9851 Tile[xx][yy] = EL_EMPTY;
9852 TEST_DrawLevelField(xx, yy);
9861 static void InitBuggyBase(int x, int y)
9863 int element = Tile[x][y];
9864 int activating_delay = FRAMES_PER_SECOND / 4;
9867 (element == EL_SP_BUGGY_BASE ?
9868 2 * FRAMES_PER_SECOND + RND(5 * FRAMES_PER_SECOND) - activating_delay :
9869 element == EL_SP_BUGGY_BASE_ACTIVATING ?
9871 element == EL_SP_BUGGY_BASE_ACTIVE ?
9872 1 * FRAMES_PER_SECOND + RND(1 * FRAMES_PER_SECOND) : 1);
9875 static void WarnBuggyBase(int x, int y)
9878 static int xy[4][2] =
9886 for (i = 0; i < NUM_DIRECTIONS; i++)
9888 int xx = x + xy[i][0];
9889 int yy = y + xy[i][1];
9891 if (IN_LEV_FIELD(xx, yy) && IS_PLAYER(xx, yy))
9893 PlayLevelSound(x, y, SND_SP_BUGGY_BASE_ACTIVE);
9900 static void InitTrap(int x, int y)
9902 ChangeDelay[x][y] = 2 * FRAMES_PER_SECOND + RND(5 * FRAMES_PER_SECOND);
9905 static void ActivateTrap(int x, int y)
9907 PlayLevelSound(x, y, SND_TRAP_ACTIVATING);
9910 static void ChangeActiveTrap(int x, int y)
9912 int graphic = IMG_TRAP_ACTIVE;
9914 // if new animation frame was drawn, correct crumbled sand border
9915 if (IS_NEW_FRAME(GfxFrame[x][y], graphic))
9916 TEST_DrawLevelFieldCrumbled(x, y);
9919 static int getSpecialActionElement(int element, int number, int base_element)
9921 return (element != EL_EMPTY ? element :
9922 number != -1 ? base_element + number - 1 :
9926 static int getModifiedActionNumber(int value_old, int operator, int operand,
9927 int value_min, int value_max)
9929 int value_new = (operator == CA_MODE_SET ? operand :
9930 operator == CA_MODE_ADD ? value_old + operand :
9931 operator == CA_MODE_SUBTRACT ? value_old - operand :
9932 operator == CA_MODE_MULTIPLY ? value_old * operand :
9933 operator == CA_MODE_DIVIDE ? value_old / MAX(1, operand) :
9934 operator == CA_MODE_MODULO ? value_old % MAX(1, operand) :
9937 return (value_new < value_min ? value_min :
9938 value_new > value_max ? value_max :
9942 static void ExecuteCustomElementAction(int x, int y, int element, int page)
9944 struct ElementInfo *ei = &element_info[element];
9945 struct ElementChangeInfo *change = &ei->change_page[page];
9946 int target_element = change->target_element;
9947 int action_type = change->action_type;
9948 int action_mode = change->action_mode;
9949 int action_arg = change->action_arg;
9950 int action_element = change->action_element;
9953 if (!change->has_action)
9956 // ---------- determine action paramater values -----------------------------
9958 int level_time_value =
9959 (level.time > 0 ? TimeLeft :
9962 int action_arg_element_raw =
9963 (action_arg == CA_ARG_PLAYER_TRIGGER ? change->actual_trigger_player :
9964 action_arg == CA_ARG_ELEMENT_TRIGGER ? change->actual_trigger_element :
9965 action_arg == CA_ARG_ELEMENT_TARGET ? change->target_element :
9966 action_arg == CA_ARG_ELEMENT_ACTION ? change->action_element :
9967 action_arg == CA_ARG_INVENTORY_RM_TRIGGER ? change->actual_trigger_element:
9968 action_arg == CA_ARG_INVENTORY_RM_TARGET ? change->target_element :
9969 action_arg == CA_ARG_INVENTORY_RM_ACTION ? change->action_element :
9971 int action_arg_element = GetElementFromGroupElement(action_arg_element_raw);
9973 int action_arg_direction =
9974 (action_arg >= CA_ARG_DIRECTION_LEFT &&
9975 action_arg <= CA_ARG_DIRECTION_DOWN ? action_arg - CA_ARG_DIRECTION :
9976 action_arg == CA_ARG_DIRECTION_TRIGGER ?
9977 change->actual_trigger_side :
9978 action_arg == CA_ARG_DIRECTION_TRIGGER_BACK ?
9979 MV_DIR_OPPOSITE(change->actual_trigger_side) :
9982 int action_arg_number_min =
9983 (action_type == CA_SET_PLAYER_SPEED ? STEPSIZE_NOT_MOVING :
9986 int action_arg_number_max =
9987 (action_type == CA_SET_PLAYER_SPEED ? STEPSIZE_EVEN_FASTER :
9988 action_type == CA_SET_LEVEL_GEMS ? 999 :
9989 action_type == CA_SET_LEVEL_TIME ? 9999 :
9990 action_type == CA_SET_LEVEL_SCORE ? 99999 :
9991 action_type == CA_SET_CE_VALUE ? 9999 :
9992 action_type == CA_SET_CE_SCORE ? 9999 :
9995 int action_arg_number_reset =
9996 (action_type == CA_SET_PLAYER_SPEED ? level.initial_player_stepsize[0] :
9997 action_type == CA_SET_LEVEL_GEMS ? level.gems_needed :
9998 action_type == CA_SET_LEVEL_TIME ? level.time :
9999 action_type == CA_SET_LEVEL_SCORE ? 0 :
10000 action_type == CA_SET_CE_VALUE ? GET_NEW_CE_VALUE(element) :
10001 action_type == CA_SET_CE_SCORE ? 0 :
10004 int action_arg_number =
10005 (action_arg <= CA_ARG_MAX ? action_arg :
10006 action_arg >= CA_ARG_SPEED_NOT_MOVING &&
10007 action_arg <= CA_ARG_SPEED_EVEN_FASTER ? (action_arg - CA_ARG_SPEED) :
10008 action_arg == CA_ARG_SPEED_RESET ? action_arg_number_reset :
10009 action_arg == CA_ARG_NUMBER_MIN ? action_arg_number_min :
10010 action_arg == CA_ARG_NUMBER_MAX ? action_arg_number_max :
10011 action_arg == CA_ARG_NUMBER_RESET ? action_arg_number_reset :
10012 action_arg == CA_ARG_NUMBER_CE_VALUE ? CustomValue[x][y] :
10013 action_arg == CA_ARG_NUMBER_CE_SCORE ? ei->collect_score :
10014 action_arg == CA_ARG_NUMBER_CE_DELAY ? GET_CE_DELAY_VALUE(change) :
10015 action_arg == CA_ARG_NUMBER_LEVEL_TIME ? level_time_value :
10016 action_arg == CA_ARG_NUMBER_LEVEL_GEMS ? game.gems_still_needed :
10017 action_arg == CA_ARG_NUMBER_LEVEL_SCORE ? game.score :
10018 action_arg == CA_ARG_ELEMENT_CV_TARGET ? GET_NEW_CE_VALUE(target_element):
10019 action_arg == CA_ARG_ELEMENT_CV_TRIGGER ? change->actual_trigger_ce_value:
10020 action_arg == CA_ARG_ELEMENT_CV_ACTION ? GET_NEW_CE_VALUE(action_element):
10021 action_arg == CA_ARG_ELEMENT_CS_TARGET ? GET_CE_SCORE(target_element) :
10022 action_arg == CA_ARG_ELEMENT_CS_TRIGGER ? change->actual_trigger_ce_score:
10023 action_arg == CA_ARG_ELEMENT_CS_ACTION ? GET_CE_SCORE(action_element) :
10024 action_arg == CA_ARG_ELEMENT_NR_TARGET ? change->target_element :
10025 action_arg == CA_ARG_ELEMENT_NR_TRIGGER ? change->actual_trigger_element :
10026 action_arg == CA_ARG_ELEMENT_NR_ACTION ? change->action_element :
10029 int action_arg_number_old =
10030 (action_type == CA_SET_LEVEL_GEMS ? game.gems_still_needed :
10031 action_type == CA_SET_LEVEL_TIME ? TimeLeft :
10032 action_type == CA_SET_LEVEL_SCORE ? game.score :
10033 action_type == CA_SET_CE_VALUE ? CustomValue[x][y] :
10034 action_type == CA_SET_CE_SCORE ? ei->collect_score :
10037 int action_arg_number_new =
10038 getModifiedActionNumber(action_arg_number_old,
10039 action_mode, action_arg_number,
10040 action_arg_number_min, action_arg_number_max);
10042 int trigger_player_bits =
10043 (change->actual_trigger_player_bits != CH_PLAYER_NONE ?
10044 change->actual_trigger_player_bits : change->trigger_player);
10046 int action_arg_player_bits =
10047 (action_arg >= CA_ARG_PLAYER_1 &&
10048 action_arg <= CA_ARG_PLAYER_4 ? action_arg - CA_ARG_PLAYER :
10049 action_arg == CA_ARG_PLAYER_TRIGGER ? trigger_player_bits :
10050 action_arg == CA_ARG_PLAYER_ACTION ? 1 << GET_PLAYER_NR(action_element) :
10053 // ---------- execute action -----------------------------------------------
10055 switch (action_type)
10062 // ---------- level actions ----------------------------------------------
10064 case CA_RESTART_LEVEL:
10066 game.restart_level = TRUE;
10071 case CA_SHOW_ENVELOPE:
10073 int element = getSpecialActionElement(action_arg_element,
10074 action_arg_number, EL_ENVELOPE_1);
10076 if (IS_ENVELOPE(element))
10077 local_player->show_envelope = element;
10082 case CA_SET_LEVEL_TIME:
10084 if (level.time > 0) // only modify limited time value
10086 TimeLeft = action_arg_number_new;
10088 game_panel_controls[GAME_PANEL_TIME].value = TimeLeft;
10090 DisplayGameControlValues();
10092 if (!TimeLeft && setup.time_limit)
10093 for (i = 0; i < MAX_PLAYERS; i++)
10094 KillPlayer(&stored_player[i]);
10100 case CA_SET_LEVEL_SCORE:
10102 game.score = action_arg_number_new;
10104 game_panel_controls[GAME_PANEL_SCORE].value = game.score;
10106 DisplayGameControlValues();
10111 case CA_SET_LEVEL_GEMS:
10113 game.gems_still_needed = action_arg_number_new;
10115 game.snapshot.collected_item = TRUE;
10117 game_panel_controls[GAME_PANEL_GEMS].value = game.gems_still_needed;
10119 DisplayGameControlValues();
10124 case CA_SET_LEVEL_WIND:
10126 game.wind_direction = action_arg_direction;
10131 case CA_SET_LEVEL_RANDOM_SEED:
10133 // ensure that setting a new random seed while playing is predictable
10134 InitRND(action_arg_number_new ? action_arg_number_new : RND(1000000) + 1);
10139 // ---------- player actions ---------------------------------------------
10141 case CA_MOVE_PLAYER:
10142 case CA_MOVE_PLAYER_NEW:
10144 // automatically move to the next field in specified direction
10145 for (i = 0; i < MAX_PLAYERS; i++)
10146 if (trigger_player_bits & (1 << i))
10147 if (action_type == CA_MOVE_PLAYER ||
10148 stored_player[i].MovPos == 0)
10149 stored_player[i].programmed_action = action_arg_direction;
10154 case CA_EXIT_PLAYER:
10156 for (i = 0; i < MAX_PLAYERS; i++)
10157 if (action_arg_player_bits & (1 << i))
10158 ExitPlayer(&stored_player[i]);
10160 if (game.players_still_needed == 0)
10166 case CA_KILL_PLAYER:
10168 for (i = 0; i < MAX_PLAYERS; i++)
10169 if (action_arg_player_bits & (1 << i))
10170 KillPlayer(&stored_player[i]);
10175 case CA_SET_PLAYER_KEYS:
10177 int key_state = (action_mode == CA_MODE_ADD ? TRUE : FALSE);
10178 int element = getSpecialActionElement(action_arg_element,
10179 action_arg_number, EL_KEY_1);
10181 if (IS_KEY(element))
10183 for (i = 0; i < MAX_PLAYERS; i++)
10185 if (trigger_player_bits & (1 << i))
10187 stored_player[i].key[KEY_NR(element)] = key_state;
10189 DrawGameDoorValues();
10197 case CA_SET_PLAYER_SPEED:
10199 for (i = 0; i < MAX_PLAYERS; i++)
10201 if (trigger_player_bits & (1 << i))
10203 int move_stepsize = TILEX / stored_player[i].move_delay_value;
10205 if (action_arg == CA_ARG_SPEED_FASTER &&
10206 stored_player[i].cannot_move)
10208 action_arg_number = STEPSIZE_VERY_SLOW;
10210 else if (action_arg == CA_ARG_SPEED_SLOWER ||
10211 action_arg == CA_ARG_SPEED_FASTER)
10213 action_arg_number = 2;
10214 action_mode = (action_arg == CA_ARG_SPEED_SLOWER ? CA_MODE_DIVIDE :
10217 else if (action_arg == CA_ARG_NUMBER_RESET)
10219 action_arg_number = level.initial_player_stepsize[i];
10223 getModifiedActionNumber(move_stepsize,
10226 action_arg_number_min,
10227 action_arg_number_max);
10229 SetPlayerMoveSpeed(&stored_player[i], move_stepsize, FALSE);
10236 case CA_SET_PLAYER_SHIELD:
10238 for (i = 0; i < MAX_PLAYERS; i++)
10240 if (trigger_player_bits & (1 << i))
10242 if (action_arg == CA_ARG_SHIELD_OFF)
10244 stored_player[i].shield_normal_time_left = 0;
10245 stored_player[i].shield_deadly_time_left = 0;
10247 else if (action_arg == CA_ARG_SHIELD_NORMAL)
10249 stored_player[i].shield_normal_time_left = 999999;
10251 else if (action_arg == CA_ARG_SHIELD_DEADLY)
10253 stored_player[i].shield_normal_time_left = 999999;
10254 stored_player[i].shield_deadly_time_left = 999999;
10262 case CA_SET_PLAYER_GRAVITY:
10264 for (i = 0; i < MAX_PLAYERS; i++)
10266 if (trigger_player_bits & (1 << i))
10268 stored_player[i].gravity =
10269 (action_arg == CA_ARG_GRAVITY_OFF ? FALSE :
10270 action_arg == CA_ARG_GRAVITY_ON ? TRUE :
10271 action_arg == CA_ARG_GRAVITY_TOGGLE ? !stored_player[i].gravity :
10272 stored_player[i].gravity);
10279 case CA_SET_PLAYER_ARTWORK:
10281 for (i = 0; i < MAX_PLAYERS; i++)
10283 if (trigger_player_bits & (1 << i))
10285 int artwork_element = action_arg_element;
10287 if (action_arg == CA_ARG_ELEMENT_RESET)
10289 (level.use_artwork_element[i] ? level.artwork_element[i] :
10290 stored_player[i].element_nr);
10292 if (stored_player[i].artwork_element != artwork_element)
10293 stored_player[i].Frame = 0;
10295 stored_player[i].artwork_element = artwork_element;
10297 SetPlayerWaiting(&stored_player[i], FALSE);
10299 // set number of special actions for bored and sleeping animation
10300 stored_player[i].num_special_action_bored =
10301 get_num_special_action(artwork_element,
10302 ACTION_BORING_1, ACTION_BORING_LAST);
10303 stored_player[i].num_special_action_sleeping =
10304 get_num_special_action(artwork_element,
10305 ACTION_SLEEPING_1, ACTION_SLEEPING_LAST);
10312 case CA_SET_PLAYER_INVENTORY:
10314 for (i = 0; i < MAX_PLAYERS; i++)
10316 struct PlayerInfo *player = &stored_player[i];
10319 if (trigger_player_bits & (1 << i))
10321 int inventory_element = action_arg_element;
10323 if (action_arg == CA_ARG_ELEMENT_TARGET ||
10324 action_arg == CA_ARG_ELEMENT_TRIGGER ||
10325 action_arg == CA_ARG_ELEMENT_ACTION)
10327 int element = inventory_element;
10328 int collect_count = element_info[element].collect_count_initial;
10330 if (!IS_CUSTOM_ELEMENT(element))
10333 if (collect_count == 0)
10334 player->inventory_infinite_element = element;
10336 for (k = 0; k < collect_count; k++)
10337 if (player->inventory_size < MAX_INVENTORY_SIZE)
10338 player->inventory_element[player->inventory_size++] =
10341 else if (action_arg == CA_ARG_INVENTORY_RM_TARGET ||
10342 action_arg == CA_ARG_INVENTORY_RM_TRIGGER ||
10343 action_arg == CA_ARG_INVENTORY_RM_ACTION)
10345 if (player->inventory_infinite_element != EL_UNDEFINED &&
10346 IS_EQUAL_OR_IN_GROUP(player->inventory_infinite_element,
10347 action_arg_element_raw))
10348 player->inventory_infinite_element = EL_UNDEFINED;
10350 for (k = 0, j = 0; j < player->inventory_size; j++)
10352 if (!IS_EQUAL_OR_IN_GROUP(player->inventory_element[j],
10353 action_arg_element_raw))
10354 player->inventory_element[k++] = player->inventory_element[j];
10357 player->inventory_size = k;
10359 else if (action_arg == CA_ARG_INVENTORY_RM_FIRST)
10361 if (player->inventory_size > 0)
10363 for (j = 0; j < player->inventory_size - 1; j++)
10364 player->inventory_element[j] = player->inventory_element[j + 1];
10366 player->inventory_size--;
10369 else if (action_arg == CA_ARG_INVENTORY_RM_LAST)
10371 if (player->inventory_size > 0)
10372 player->inventory_size--;
10374 else if (action_arg == CA_ARG_INVENTORY_RM_ALL)
10376 player->inventory_infinite_element = EL_UNDEFINED;
10377 player->inventory_size = 0;
10379 else if (action_arg == CA_ARG_INVENTORY_RESET)
10381 player->inventory_infinite_element = EL_UNDEFINED;
10382 player->inventory_size = 0;
10384 if (level.use_initial_inventory[i])
10386 for (j = 0; j < level.initial_inventory_size[i]; j++)
10388 int element = level.initial_inventory_content[i][j];
10389 int collect_count = element_info[element].collect_count_initial;
10391 if (!IS_CUSTOM_ELEMENT(element))
10394 if (collect_count == 0)
10395 player->inventory_infinite_element = element;
10397 for (k = 0; k < collect_count; k++)
10398 if (player->inventory_size < MAX_INVENTORY_SIZE)
10399 player->inventory_element[player->inventory_size++] =
10410 // ---------- CE actions -------------------------------------------------
10412 case CA_SET_CE_VALUE:
10414 int last_ce_value = CustomValue[x][y];
10416 CustomValue[x][y] = action_arg_number_new;
10418 if (CustomValue[x][y] != last_ce_value)
10420 CheckElementChange(x, y, element, EL_UNDEFINED, CE_VALUE_CHANGES);
10421 CheckTriggeredElementChange(x, y, element, CE_VALUE_CHANGES_OF_X);
10423 if (CustomValue[x][y] == 0)
10425 // reset change counter (else CE_VALUE_GETS_ZERO would not work)
10426 ChangeCount[x][y] = 0; // allow at least one more change
10428 CheckElementChange(x, y, element, EL_UNDEFINED, CE_VALUE_GETS_ZERO);
10429 CheckTriggeredElementChange(x, y, element, CE_VALUE_GETS_ZERO_OF_X);
10436 case CA_SET_CE_SCORE:
10438 int last_ce_score = ei->collect_score;
10440 ei->collect_score = action_arg_number_new;
10442 if (ei->collect_score != last_ce_score)
10444 CheckElementChange(x, y, element, EL_UNDEFINED, CE_SCORE_CHANGES);
10445 CheckTriggeredElementChange(x, y, element, CE_SCORE_CHANGES_OF_X);
10447 if (ei->collect_score == 0)
10451 // reset change counter (else CE_SCORE_GETS_ZERO would not work)
10452 ChangeCount[x][y] = 0; // allow at least one more change
10454 CheckElementChange(x, y, element, EL_UNDEFINED, CE_SCORE_GETS_ZERO);
10455 CheckTriggeredElementChange(x, y, element, CE_SCORE_GETS_ZERO_OF_X);
10458 This is a very special case that seems to be a mixture between
10459 CheckElementChange() and CheckTriggeredElementChange(): while
10460 the first one only affects single elements that are triggered
10461 directly, the second one affects multiple elements in the playfield
10462 that are triggered indirectly by another element. This is a third
10463 case: Changing the CE score always affects multiple identical CEs,
10464 so every affected CE must be checked, not only the single CE for
10465 which the CE score was changed in the first place (as every instance
10466 of that CE shares the same CE score, and therefore also can change)!
10468 SCAN_PLAYFIELD(xx, yy)
10470 if (Tile[xx][yy] == element)
10471 CheckElementChange(xx, yy, element, EL_UNDEFINED,
10472 CE_SCORE_GETS_ZERO);
10480 case CA_SET_CE_ARTWORK:
10482 int artwork_element = action_arg_element;
10483 boolean reset_frame = FALSE;
10486 if (action_arg == CA_ARG_ELEMENT_RESET)
10487 artwork_element = (ei->use_gfx_element ? ei->gfx_element_initial :
10490 if (ei->gfx_element != artwork_element)
10491 reset_frame = TRUE;
10493 ei->gfx_element = artwork_element;
10495 SCAN_PLAYFIELD(xx, yy)
10497 if (Tile[xx][yy] == element)
10501 ResetGfxAnimation(xx, yy);
10502 ResetRandomAnimationValue(xx, yy);
10505 TEST_DrawLevelField(xx, yy);
10512 // ---------- engine actions ---------------------------------------------
10514 case CA_SET_ENGINE_SCAN_MODE:
10516 InitPlayfieldScanMode(action_arg);
10526 static void CreateFieldExt(int x, int y, int element, boolean is_change)
10528 int old_element = Tile[x][y];
10529 int new_element = GetElementFromGroupElement(element);
10530 int previous_move_direction = MovDir[x][y];
10531 int last_ce_value = CustomValue[x][y];
10532 boolean player_explosion_protected = PLAYER_EXPLOSION_PROTECTED(x, y);
10533 boolean new_element_is_player = ELEM_IS_PLAYER(new_element);
10534 boolean add_player_onto_element = (new_element_is_player &&
10535 new_element != EL_SOKOBAN_FIELD_PLAYER &&
10536 IS_WALKABLE(old_element));
10538 if (!add_player_onto_element)
10540 if (IS_MOVING(x, y) || IS_BLOCKED(x, y))
10541 RemoveMovingField(x, y);
10545 Tile[x][y] = new_element;
10547 if (element_info[new_element].move_direction_initial == MV_START_PREVIOUS)
10548 MovDir[x][y] = previous_move_direction;
10550 if (element_info[new_element].use_last_ce_value)
10551 CustomValue[x][y] = last_ce_value;
10553 InitField_WithBug1(x, y, FALSE);
10555 new_element = Tile[x][y]; // element may have changed
10557 ResetGfxAnimation(x, y);
10558 ResetRandomAnimationValue(x, y);
10560 TEST_DrawLevelField(x, y);
10562 if (GFX_CRUMBLED(new_element))
10563 TEST_DrawLevelFieldCrumbledNeighbours(x, y);
10566 // check if element under the player changes from accessible to unaccessible
10567 // (needed for special case of dropping element which then changes)
10568 // (must be checked after creating new element for walkable group elements)
10569 if (IS_PLAYER(x, y) && !player_explosion_protected &&
10570 IS_ACCESSIBLE(old_element) && !IS_ACCESSIBLE(new_element))
10577 // "ChangeCount" not set yet to allow "entered by player" change one time
10578 if (new_element_is_player)
10579 RelocatePlayer(x, y, new_element);
10582 ChangeCount[x][y]++; // count number of changes in the same frame
10584 TestIfBadThingTouchesPlayer(x, y);
10585 TestIfPlayerTouchesCustomElement(x, y);
10586 TestIfElementTouchesCustomElement(x, y);
10589 static void CreateField(int x, int y, int element)
10591 CreateFieldExt(x, y, element, FALSE);
10594 static void CreateElementFromChange(int x, int y, int element)
10596 element = GET_VALID_RUNTIME_ELEMENT(element);
10598 if (game.engine_version >= VERSION_IDENT(3,2,0,7))
10600 int old_element = Tile[x][y];
10602 // prevent changed element from moving in same engine frame
10603 // unless both old and new element can either fall or move
10604 if ((!CAN_FALL(old_element) || !CAN_FALL(element)) &&
10605 (!CAN_MOVE(old_element) || !CAN_MOVE(element)))
10609 CreateFieldExt(x, y, element, TRUE);
10612 static boolean ChangeElement(int x, int y, int element, int page)
10614 struct ElementInfo *ei = &element_info[element];
10615 struct ElementChangeInfo *change = &ei->change_page[page];
10616 int ce_value = CustomValue[x][y];
10617 int ce_score = ei->collect_score;
10618 int target_element;
10619 int old_element = Tile[x][y];
10621 // always use default change event to prevent running into a loop
10622 if (ChangeEvent[x][y] == -1)
10623 ChangeEvent[x][y] = CE_DELAY;
10625 if (ChangeEvent[x][y] == CE_DELAY)
10627 // reset actual trigger element, trigger player and action element
10628 change->actual_trigger_element = EL_EMPTY;
10629 change->actual_trigger_player = EL_EMPTY;
10630 change->actual_trigger_player_bits = CH_PLAYER_NONE;
10631 change->actual_trigger_side = CH_SIDE_NONE;
10632 change->actual_trigger_ce_value = 0;
10633 change->actual_trigger_ce_score = 0;
10636 // do not change elements more than a specified maximum number of changes
10637 if (ChangeCount[x][y] >= game.max_num_changes_per_frame)
10640 ChangeCount[x][y]++; // count number of changes in the same frame
10642 if (change->explode)
10649 if (change->use_target_content)
10651 boolean complete_replace = TRUE;
10652 boolean can_replace[3][3];
10655 for (yy = 0; yy < 3; yy++) for (xx = 0; xx < 3 ; xx++)
10658 boolean is_walkable;
10659 boolean is_diggable;
10660 boolean is_collectible;
10661 boolean is_removable;
10662 boolean is_destructible;
10663 int ex = x + xx - 1;
10664 int ey = y + yy - 1;
10665 int content_element = change->target_content.e[xx][yy];
10668 can_replace[xx][yy] = TRUE;
10670 if (ex == x && ey == y) // do not check changing element itself
10673 if (content_element == EL_EMPTY_SPACE)
10675 can_replace[xx][yy] = FALSE; // do not replace border with space
10680 if (!IN_LEV_FIELD(ex, ey))
10682 can_replace[xx][yy] = FALSE;
10683 complete_replace = FALSE;
10690 if (IS_MOVING(ex, ey) || IS_BLOCKED(ex, ey))
10691 e = MovingOrBlocked2Element(ex, ey);
10693 is_empty = (IS_FREE(ex, ey) ||
10694 (IS_FREE_OR_PLAYER(ex, ey) && IS_WALKABLE(content_element)));
10696 is_walkable = (is_empty || IS_WALKABLE(e));
10697 is_diggable = (is_empty || IS_DIGGABLE(e));
10698 is_collectible = (is_empty || IS_COLLECTIBLE(e));
10699 is_destructible = (is_empty || !IS_INDESTRUCTIBLE(e));
10700 is_removable = (is_diggable || is_collectible);
10702 can_replace[xx][yy] =
10703 (((change->replace_when == CP_WHEN_EMPTY && is_empty) ||
10704 (change->replace_when == CP_WHEN_WALKABLE && is_walkable) ||
10705 (change->replace_when == CP_WHEN_DIGGABLE && is_diggable) ||
10706 (change->replace_when == CP_WHEN_COLLECTIBLE && is_collectible) ||
10707 (change->replace_when == CP_WHEN_REMOVABLE && is_removable) ||
10708 (change->replace_when == CP_WHEN_DESTRUCTIBLE && is_destructible)) &&
10709 !(IS_PLAYER(ex, ey) && ELEM_IS_PLAYER(content_element)));
10711 if (!can_replace[xx][yy])
10712 complete_replace = FALSE;
10715 if (!change->only_if_complete || complete_replace)
10717 boolean something_has_changed = FALSE;
10719 if (change->only_if_complete && change->use_random_replace &&
10720 RND(100) < change->random_percentage)
10723 for (yy = 0; yy < 3; yy++) for (xx = 0; xx < 3 ; xx++)
10725 int ex = x + xx - 1;
10726 int ey = y + yy - 1;
10727 int content_element;
10729 if (can_replace[xx][yy] && (!change->use_random_replace ||
10730 RND(100) < change->random_percentage))
10732 if (IS_MOVING(ex, ey) || IS_BLOCKED(ex, ey))
10733 RemoveMovingField(ex, ey);
10735 ChangeEvent[ex][ey] = ChangeEvent[x][y];
10737 content_element = change->target_content.e[xx][yy];
10738 target_element = GET_TARGET_ELEMENT(element, content_element, change,
10739 ce_value, ce_score);
10741 CreateElementFromChange(ex, ey, target_element);
10743 something_has_changed = TRUE;
10745 // for symmetry reasons, freeze newly created border elements
10746 if (ex != x || ey != y)
10747 Stop[ex][ey] = TRUE; // no more moving in this frame
10751 if (something_has_changed)
10753 PlayLevelSoundElementAction(x, y, element, ACTION_CHANGING);
10754 PlayLevelSoundElementAction(x, y, element, ACTION_PAGE_1 + page);
10760 target_element = GET_TARGET_ELEMENT(element, change->target_element, change,
10761 ce_value, ce_score);
10763 if (element == EL_DIAGONAL_GROWING ||
10764 element == EL_DIAGONAL_SHRINKING)
10766 target_element = Store[x][y];
10768 Store[x][y] = EL_EMPTY;
10771 CreateElementFromChange(x, y, target_element);
10773 PlayLevelSoundElementAction(x, y, element, ACTION_CHANGING);
10774 PlayLevelSoundElementAction(x, y, element, ACTION_PAGE_1 + page);
10777 // this uses direct change before indirect change
10778 CheckTriggeredElementChangeByPage(x, y, old_element, CE_CHANGE_OF_X, page);
10783 static void HandleElementChange(int x, int y, int page)
10785 int element = MovingOrBlocked2Element(x, y);
10786 struct ElementInfo *ei = &element_info[element];
10787 struct ElementChangeInfo *change = &ei->change_page[page];
10788 boolean handle_action_before_change = FALSE;
10791 if (!CAN_CHANGE_OR_HAS_ACTION(element) &&
10792 !CAN_CHANGE_OR_HAS_ACTION(Back[x][y]))
10794 Debug("game:playing:HandleElementChange", "%d,%d: element = %d ('%s')",
10795 x, y, element, element_info[element].token_name);
10796 Debug("game:playing:HandleElementChange", "This should never happen!");
10800 // this can happen with classic bombs on walkable, changing elements
10801 if (!CAN_CHANGE_OR_HAS_ACTION(element))
10806 if (ChangeDelay[x][y] == 0) // initialize element change
10808 ChangeDelay[x][y] = GET_CHANGE_DELAY(change) + 1;
10810 if (change->can_change)
10812 // !!! not clear why graphic animation should be reset at all here !!!
10813 // !!! UPDATE: but is needed for correct Snake Bite tail animation !!!
10814 // !!! SOLUTION: do not reset if graphics engine set to 4 or above !!!
10817 GRAPHICAL BUG ADDRESSED BY CHECKING GRAPHICS ENGINE VERSION:
10819 When using an animation frame delay of 1 (this only happens with
10820 "sp_zonk.moving.left/right" in the classic graphics), the default
10821 (non-moving) animation shows wrong animation frames (while the
10822 moving animation, like "sp_zonk.moving.left/right", is correct,
10823 so this graphical bug never shows up with the classic graphics).
10824 For an animation with 4 frames, this causes wrong frames 0,0,1,2
10825 be drawn instead of the correct frames 0,1,2,3. This is caused by
10826 "GfxFrame[][]" being reset *twice* (in two successive frames) after
10827 an element change: First when the change delay ("ChangeDelay[][]")
10828 counter has reached zero after decrementing, then a second time in
10829 the next frame (after "GfxFrame[][]" was already incremented) when
10830 "ChangeDelay[][]" is reset to the initial delay value again.
10832 This causes frame 0 to be drawn twice, while the last frame won't
10833 be drawn anymore, resulting in the wrong frame sequence 0,0,1,2.
10835 As some animations may already be cleverly designed around this bug
10836 (at least the "Snake Bite" snake tail animation does this), it cannot
10837 simply be fixed here without breaking such existing animations.
10838 Unfortunately, it cannot easily be detected if a graphics set was
10839 designed "before" or "after" the bug was fixed. As a workaround,
10840 a new graphics set option "game.graphics_engine_version" was added
10841 to be able to specify the game's major release version for which the
10842 graphics set was designed, which can then be used to decide if the
10843 bugfix should be used (version 4 and above) or not (version 3 or
10844 below, or if no version was specified at all, as with old sets).
10846 (The wrong/fixed animation frames can be tested with the test level set
10847 "test_gfxframe" and level "000", which contains a specially prepared
10848 custom element at level position (x/y) == (11/9) which uses the zonk
10849 animation mentioned above. Using "game.graphics_engine_version: 4"
10850 fixes the wrong animation frames, showing the correct frames 0,1,2,3.
10851 This can also be seen from the debug output for this test element.)
10854 // when a custom element is about to change (for example by change delay),
10855 // do not reset graphic animation when the custom element is moving
10856 if (game.graphics_engine_version < 4 &&
10859 ResetGfxAnimation(x, y);
10860 ResetRandomAnimationValue(x, y);
10863 if (change->pre_change_function)
10864 change->pre_change_function(x, y);
10868 ChangeDelay[x][y]--;
10870 if (ChangeDelay[x][y] != 0) // continue element change
10872 if (change->can_change)
10874 int graphic = el_act_dir2img(element, GfxAction[x][y], GfxDir[x][y]);
10876 if (IS_ANIMATED(graphic))
10877 DrawLevelGraphicAnimationIfNeeded(x, y, graphic);
10879 if (change->change_function)
10880 change->change_function(x, y);
10883 else // finish element change
10885 if (ChangePage[x][y] != -1) // remember page from delayed change
10887 page = ChangePage[x][y];
10888 ChangePage[x][y] = -1;
10890 change = &ei->change_page[page];
10893 if (IS_MOVING(x, y)) // never change a running system ;-)
10895 ChangeDelay[x][y] = 1; // try change after next move step
10896 ChangePage[x][y] = page; // remember page to use for change
10901 // special case: set new level random seed before changing element
10902 if (change->has_action && change->action_type == CA_SET_LEVEL_RANDOM_SEED)
10903 handle_action_before_change = TRUE;
10905 if (change->has_action && handle_action_before_change)
10906 ExecuteCustomElementAction(x, y, element, page);
10908 if (change->can_change)
10910 if (ChangeElement(x, y, element, page))
10912 if (change->post_change_function)
10913 change->post_change_function(x, y);
10917 if (change->has_action && !handle_action_before_change)
10918 ExecuteCustomElementAction(x, y, element, page);
10922 static boolean CheckTriggeredElementChangeExt(int trigger_x, int trigger_y,
10923 int trigger_element,
10925 int trigger_player,
10929 boolean change_done_any = FALSE;
10930 int trigger_page_bits = (trigger_page < 0 ? CH_PAGE_ANY : 1 << trigger_page);
10933 if (!(trigger_events[trigger_element][trigger_event]))
10936 RECURSION_LOOP_DETECTION_START(trigger_element, FALSE);
10938 for (i = 0; i < NUM_CUSTOM_ELEMENTS; i++)
10940 int element = EL_CUSTOM_START + i;
10941 boolean change_done = FALSE;
10944 if (!CAN_CHANGE_OR_HAS_ACTION(element) ||
10945 !HAS_ANY_CHANGE_EVENT(element, trigger_event))
10948 for (p = 0; p < element_info[element].num_change_pages; p++)
10950 struct ElementChangeInfo *change = &element_info[element].change_page[p];
10952 if (change->can_change_or_has_action &&
10953 change->has_event[trigger_event] &&
10954 change->trigger_side & trigger_side &&
10955 change->trigger_player & trigger_player &&
10956 change->trigger_page & trigger_page_bits &&
10957 IS_EQUAL_OR_IN_GROUP(trigger_element, change->trigger_element))
10959 change->actual_trigger_element = trigger_element;
10960 change->actual_trigger_player = GET_PLAYER_FROM_BITS(trigger_player);
10961 change->actual_trigger_player_bits = trigger_player;
10962 change->actual_trigger_side = trigger_side;
10963 change->actual_trigger_ce_value = CustomValue[trigger_x][trigger_y];
10964 change->actual_trigger_ce_score = GET_CE_SCORE(trigger_element);
10966 if ((change->can_change && !change_done) || change->has_action)
10970 SCAN_PLAYFIELD(x, y)
10972 if (Tile[x][y] == element)
10974 if (change->can_change && !change_done)
10976 // if element already changed in this frame, not only prevent
10977 // another element change (checked in ChangeElement()), but
10978 // also prevent additional element actions for this element
10980 if (ChangeCount[x][y] >= game.max_num_changes_per_frame &&
10981 !level.use_action_after_change_bug)
10984 ChangeDelay[x][y] = 1;
10985 ChangeEvent[x][y] = trigger_event;
10987 HandleElementChange(x, y, p);
10989 else if (change->has_action)
10991 // if element already changed in this frame, not only prevent
10992 // another element change (checked in ChangeElement()), but
10993 // also prevent additional element actions for this element
10995 if (ChangeCount[x][y] >= game.max_num_changes_per_frame &&
10996 !level.use_action_after_change_bug)
10999 ExecuteCustomElementAction(x, y, element, p);
11000 PlayLevelSoundElementAction(x, y, element, ACTION_PAGE_1 + p);
11005 if (change->can_change)
11007 change_done = TRUE;
11008 change_done_any = TRUE;
11015 RECURSION_LOOP_DETECTION_END();
11017 return change_done_any;
11020 static boolean CheckElementChangeExt(int x, int y,
11022 int trigger_element,
11024 int trigger_player,
11027 boolean change_done = FALSE;
11030 if (!CAN_CHANGE_OR_HAS_ACTION(element) ||
11031 !HAS_ANY_CHANGE_EVENT(element, trigger_event))
11034 if (Tile[x][y] == EL_BLOCKED)
11036 Blocked2Moving(x, y, &x, &y);
11037 element = Tile[x][y];
11040 // check if element has already changed or is about to change after moving
11041 if ((game.engine_version < VERSION_IDENT(3,2,0,7) &&
11042 Tile[x][y] != element) ||
11044 (game.engine_version >= VERSION_IDENT(3,2,0,7) &&
11045 (ChangeCount[x][y] >= game.max_num_changes_per_frame ||
11046 ChangePage[x][y] != -1)))
11049 RECURSION_LOOP_DETECTION_START(trigger_element, FALSE);
11051 for (p = 0; p < element_info[element].num_change_pages; p++)
11053 struct ElementChangeInfo *change = &element_info[element].change_page[p];
11055 /* check trigger element for all events where the element that is checked
11056 for changing interacts with a directly adjacent element -- this is
11057 different to element changes that affect other elements to change on the
11058 whole playfield (which is handeld by CheckTriggeredElementChangeExt()) */
11059 boolean check_trigger_element =
11060 (trigger_event == CE_TOUCHING_X ||
11061 trigger_event == CE_HITTING_X ||
11062 trigger_event == CE_HIT_BY_X ||
11063 trigger_event == CE_DIGGING_X); // this one was forgotten until 3.2.3
11065 if (change->can_change_or_has_action &&
11066 change->has_event[trigger_event] &&
11067 change->trigger_side & trigger_side &&
11068 change->trigger_player & trigger_player &&
11069 (!check_trigger_element ||
11070 IS_EQUAL_OR_IN_GROUP(trigger_element, change->trigger_element)))
11072 change->actual_trigger_element = trigger_element;
11073 change->actual_trigger_player = GET_PLAYER_FROM_BITS(trigger_player);
11074 change->actual_trigger_player_bits = trigger_player;
11075 change->actual_trigger_side = trigger_side;
11076 change->actual_trigger_ce_value = CustomValue[x][y];
11077 change->actual_trigger_ce_score = GET_CE_SCORE(trigger_element);
11079 // special case: trigger element not at (x,y) position for some events
11080 if (check_trigger_element)
11092 { 0, 0 }, { 0, 0 }, { 0, 0 },
11096 int xx = x + move_xy[MV_DIR_OPPOSITE(trigger_side)].dx;
11097 int yy = y + move_xy[MV_DIR_OPPOSITE(trigger_side)].dy;
11099 change->actual_trigger_ce_value = CustomValue[xx][yy];
11100 change->actual_trigger_ce_score = GET_CE_SCORE(trigger_element);
11103 if (change->can_change && !change_done)
11105 ChangeDelay[x][y] = 1;
11106 ChangeEvent[x][y] = trigger_event;
11108 HandleElementChange(x, y, p);
11110 change_done = TRUE;
11112 else if (change->has_action)
11114 ExecuteCustomElementAction(x, y, element, p);
11115 PlayLevelSoundElementAction(x, y, element, ACTION_PAGE_1 + p);
11120 RECURSION_LOOP_DETECTION_END();
11122 return change_done;
11125 static void PlayPlayerSound(struct PlayerInfo *player)
11127 int jx = player->jx, jy = player->jy;
11128 int sound_element = player->artwork_element;
11129 int last_action = player->last_action_waiting;
11130 int action = player->action_waiting;
11132 if (player->is_waiting)
11134 if (action != last_action)
11135 PlayLevelSoundElementAction(jx, jy, sound_element, action);
11137 PlayLevelSoundElementActionIfLoop(jx, jy, sound_element, action);
11141 if (action != last_action)
11142 StopSound(element_info[sound_element].sound[last_action]);
11144 if (last_action == ACTION_SLEEPING)
11145 PlayLevelSoundElementAction(jx, jy, sound_element, ACTION_AWAKENING);
11149 static void PlayAllPlayersSound(void)
11153 for (i = 0; i < MAX_PLAYERS; i++)
11154 if (stored_player[i].active)
11155 PlayPlayerSound(&stored_player[i]);
11158 static void SetPlayerWaiting(struct PlayerInfo *player, boolean is_waiting)
11160 boolean last_waiting = player->is_waiting;
11161 int move_dir = player->MovDir;
11163 player->dir_waiting = move_dir;
11164 player->last_action_waiting = player->action_waiting;
11168 if (!last_waiting) // not waiting -> waiting
11170 player->is_waiting = TRUE;
11172 player->frame_counter_bored =
11174 game.player_boring_delay_fixed +
11175 GetSimpleRandom(game.player_boring_delay_random);
11176 player->frame_counter_sleeping =
11178 game.player_sleeping_delay_fixed +
11179 GetSimpleRandom(game.player_sleeping_delay_random);
11181 InitPlayerGfxAnimation(player, ACTION_WAITING, move_dir);
11184 if (game.player_sleeping_delay_fixed +
11185 game.player_sleeping_delay_random > 0 &&
11186 player->anim_delay_counter == 0 &&
11187 player->post_delay_counter == 0 &&
11188 FrameCounter >= player->frame_counter_sleeping)
11189 player->is_sleeping = TRUE;
11190 else if (game.player_boring_delay_fixed +
11191 game.player_boring_delay_random > 0 &&
11192 FrameCounter >= player->frame_counter_bored)
11193 player->is_bored = TRUE;
11195 player->action_waiting = (player->is_sleeping ? ACTION_SLEEPING :
11196 player->is_bored ? ACTION_BORING :
11199 if (player->is_sleeping && player->use_murphy)
11201 // special case for sleeping Murphy when leaning against non-free tile
11203 if (!IN_LEV_FIELD(player->jx - 1, player->jy) ||
11204 (Tile[player->jx - 1][player->jy] != EL_EMPTY &&
11205 !IS_MOVING(player->jx - 1, player->jy)))
11206 move_dir = MV_LEFT;
11207 else if (!IN_LEV_FIELD(player->jx + 1, player->jy) ||
11208 (Tile[player->jx + 1][player->jy] != EL_EMPTY &&
11209 !IS_MOVING(player->jx + 1, player->jy)))
11210 move_dir = MV_RIGHT;
11212 player->is_sleeping = FALSE;
11214 player->dir_waiting = move_dir;
11217 if (player->is_sleeping)
11219 if (player->num_special_action_sleeping > 0)
11221 if (player->anim_delay_counter == 0 && player->post_delay_counter == 0)
11223 int last_special_action = player->special_action_sleeping;
11224 int num_special_action = player->num_special_action_sleeping;
11225 int special_action =
11226 (last_special_action == ACTION_DEFAULT ? ACTION_SLEEPING_1 :
11227 last_special_action == ACTION_SLEEPING ? ACTION_SLEEPING :
11228 last_special_action < ACTION_SLEEPING_1 + num_special_action - 1 ?
11229 last_special_action + 1 : ACTION_SLEEPING);
11230 int special_graphic =
11231 el_act_dir2img(player->artwork_element, special_action, move_dir);
11233 player->anim_delay_counter =
11234 graphic_info[special_graphic].anim_delay_fixed +
11235 GetSimpleRandom(graphic_info[special_graphic].anim_delay_random);
11236 player->post_delay_counter =
11237 graphic_info[special_graphic].post_delay_fixed +
11238 GetSimpleRandom(graphic_info[special_graphic].post_delay_random);
11240 player->special_action_sleeping = special_action;
11243 if (player->anim_delay_counter > 0)
11245 player->action_waiting = player->special_action_sleeping;
11246 player->anim_delay_counter--;
11248 else if (player->post_delay_counter > 0)
11250 player->post_delay_counter--;
11254 else if (player->is_bored)
11256 if (player->num_special_action_bored > 0)
11258 if (player->anim_delay_counter == 0 && player->post_delay_counter == 0)
11260 int special_action =
11261 ACTION_BORING_1 + GetSimpleRandom(player->num_special_action_bored);
11262 int special_graphic =
11263 el_act_dir2img(player->artwork_element, special_action, move_dir);
11265 player->anim_delay_counter =
11266 graphic_info[special_graphic].anim_delay_fixed +
11267 GetSimpleRandom(graphic_info[special_graphic].anim_delay_random);
11268 player->post_delay_counter =
11269 graphic_info[special_graphic].post_delay_fixed +
11270 GetSimpleRandom(graphic_info[special_graphic].post_delay_random);
11272 player->special_action_bored = special_action;
11275 if (player->anim_delay_counter > 0)
11277 player->action_waiting = player->special_action_bored;
11278 player->anim_delay_counter--;
11280 else if (player->post_delay_counter > 0)
11282 player->post_delay_counter--;
11287 else if (last_waiting) // waiting -> not waiting
11289 player->is_waiting = FALSE;
11290 player->is_bored = FALSE;
11291 player->is_sleeping = FALSE;
11293 player->frame_counter_bored = -1;
11294 player->frame_counter_sleeping = -1;
11296 player->anim_delay_counter = 0;
11297 player->post_delay_counter = 0;
11299 player->dir_waiting = player->MovDir;
11300 player->action_waiting = ACTION_DEFAULT;
11302 player->special_action_bored = ACTION_DEFAULT;
11303 player->special_action_sleeping = ACTION_DEFAULT;
11307 static void CheckSaveEngineSnapshot(struct PlayerInfo *player)
11309 if ((!player->is_moving && player->was_moving) ||
11310 (player->MovPos == 0 && player->was_moving) ||
11311 (player->is_snapping && !player->was_snapping) ||
11312 (player->is_dropping && !player->was_dropping))
11314 if (!CheckSaveEngineSnapshotToList())
11317 player->was_moving = FALSE;
11318 player->was_snapping = TRUE;
11319 player->was_dropping = TRUE;
11323 if (player->is_moving)
11324 player->was_moving = TRUE;
11326 if (!player->is_snapping)
11327 player->was_snapping = FALSE;
11329 if (!player->is_dropping)
11330 player->was_dropping = FALSE;
11333 static struct MouseActionInfo mouse_action_last = { 0 };
11334 struct MouseActionInfo mouse_action = player->effective_mouse_action;
11335 boolean new_released = (!mouse_action.button && mouse_action_last.button);
11338 CheckSaveEngineSnapshotToList();
11340 mouse_action_last = mouse_action;
11343 static void CheckSingleStepMode(struct PlayerInfo *player)
11345 if (tape.single_step && tape.recording && !tape.pausing)
11347 // as it is called "single step mode", just return to pause mode when the
11348 // player stopped moving after one tile (or never starts moving at all)
11349 // (reverse logic needed here in case single step mode used in team mode)
11350 if (player->is_moving ||
11351 player->is_pushing ||
11352 player->is_dropping_pressed ||
11353 player->effective_mouse_action.button)
11354 game.enter_single_step_mode = FALSE;
11357 CheckSaveEngineSnapshot(player);
11360 static byte PlayerActions(struct PlayerInfo *player, byte player_action)
11362 int left = player_action & JOY_LEFT;
11363 int right = player_action & JOY_RIGHT;
11364 int up = player_action & JOY_UP;
11365 int down = player_action & JOY_DOWN;
11366 int button1 = player_action & JOY_BUTTON_1;
11367 int button2 = player_action & JOY_BUTTON_2;
11368 int dx = (left ? -1 : right ? 1 : 0);
11369 int dy = (up ? -1 : down ? 1 : 0);
11371 if (!player->active || tape.pausing)
11377 SnapField(player, dx, dy);
11381 DropElement(player);
11383 MovePlayer(player, dx, dy);
11386 CheckSingleStepMode(player);
11388 SetPlayerWaiting(player, FALSE);
11390 return player_action;
11394 // no actions for this player (no input at player's configured device)
11396 DigField(player, 0, 0, 0, 0, 0, 0, DF_NO_PUSH);
11397 SnapField(player, 0, 0);
11398 CheckGravityMovementWhenNotMoving(player);
11400 if (player->MovPos == 0)
11401 SetPlayerWaiting(player, TRUE);
11403 if (player->MovPos == 0) // needed for tape.playing
11404 player->is_moving = FALSE;
11406 player->is_dropping = FALSE;
11407 player->is_dropping_pressed = FALSE;
11408 player->drop_pressed_delay = 0;
11410 CheckSingleStepMode(player);
11416 static void SetMouseActionFromTapeAction(struct MouseActionInfo *mouse_action,
11419 if (!tape.use_mouse_actions)
11422 mouse_action->lx = tape_action[TAPE_ACTION_LX];
11423 mouse_action->ly = tape_action[TAPE_ACTION_LY];
11424 mouse_action->button = tape_action[TAPE_ACTION_BUTTON];
11427 static void SetTapeActionFromMouseAction(byte *tape_action,
11428 struct MouseActionInfo *mouse_action)
11430 if (!tape.use_mouse_actions)
11433 tape_action[TAPE_ACTION_LX] = mouse_action->lx;
11434 tape_action[TAPE_ACTION_LY] = mouse_action->ly;
11435 tape_action[TAPE_ACTION_BUTTON] = mouse_action->button;
11438 static void CheckLevelSolved(void)
11440 if (level.game_engine_type == GAME_ENGINE_TYPE_EM)
11442 if (game_em.level_solved &&
11443 !game_em.game_over) // game won
11447 game_em.game_over = TRUE;
11449 game.all_players_gone = TRUE;
11452 if (game_em.game_over) // game lost
11453 game.all_players_gone = TRUE;
11455 else if (level.game_engine_type == GAME_ENGINE_TYPE_SP)
11457 if (game_sp.level_solved &&
11458 !game_sp.game_over) // game won
11462 game_sp.game_over = TRUE;
11464 game.all_players_gone = TRUE;
11467 if (game_sp.game_over) // game lost
11468 game.all_players_gone = TRUE;
11470 else if (level.game_engine_type == GAME_ENGINE_TYPE_MM)
11472 if (game_mm.level_solved &&
11473 !game_mm.game_over) // game won
11477 game_mm.game_over = TRUE;
11479 game.all_players_gone = TRUE;
11482 if (game_mm.game_over) // game lost
11483 game.all_players_gone = TRUE;
11487 static void CheckLevelTime(void)
11491 if (TimeFrames >= FRAMES_PER_SECOND)
11496 for (i = 0; i < MAX_PLAYERS; i++)
11498 struct PlayerInfo *player = &stored_player[i];
11500 if (SHIELD_ON(player))
11502 player->shield_normal_time_left--;
11504 if (player->shield_deadly_time_left > 0)
11505 player->shield_deadly_time_left--;
11509 if (!game.LevelSolved && !level.use_step_counter)
11517 if (TimeLeft <= 10 && setup.time_limit)
11518 PlaySound(SND_GAME_RUNNING_OUT_OF_TIME);
11520 /* this does not make sense: game_panel_controls[GAME_PANEL_TIME].value
11521 is reset from other values in UpdateGameDoorValues() -- FIX THIS */
11523 game_panel_controls[GAME_PANEL_TIME].value = TimeLeft;
11525 if (!TimeLeft && setup.time_limit)
11527 if (level.game_engine_type == GAME_ENGINE_TYPE_EM)
11528 game_em.lev->killed_out_of_time = TRUE;
11530 for (i = 0; i < MAX_PLAYERS; i++)
11531 KillPlayer(&stored_player[i]);
11534 else if (game.no_time_limit && !game.all_players_gone)
11536 game_panel_controls[GAME_PANEL_TIME].value = TimePlayed;
11539 game_em.lev->time = (game.no_time_limit ? TimePlayed : TimeLeft);
11542 if (tape.recording || tape.playing)
11543 DrawVideoDisplay(VIDEO_STATE_TIME_ON, TapeTime);
11546 if (tape.recording || tape.playing)
11547 DrawVideoDisplay(VIDEO_STATE_FRAME_ON, FrameCounter);
11549 UpdateAndDisplayGameControlValues();
11552 void AdvanceFrameAndPlayerCounters(int player_nr)
11556 // advance frame counters (global frame counter and time frame counter)
11560 // advance player counters (counters for move delay, move animation etc.)
11561 for (i = 0; i < MAX_PLAYERS; i++)
11563 boolean advance_player_counters = (player_nr == -1 || player_nr == i);
11564 int move_delay_value = stored_player[i].move_delay_value;
11565 int move_frames = MOVE_DELAY_NORMAL_SPEED / move_delay_value;
11567 if (!advance_player_counters) // not all players may be affected
11570 if (move_frames == 0) // less than one move per game frame
11572 int stepsize = TILEX / move_delay_value;
11573 int delay = move_delay_value / MOVE_DELAY_NORMAL_SPEED;
11574 int count = (stored_player[i].is_moving ?
11575 ABS(stored_player[i].MovPos) / stepsize : FrameCounter);
11577 if (count % delay == 0)
11581 stored_player[i].Frame += move_frames;
11583 if (stored_player[i].MovPos != 0)
11584 stored_player[i].StepFrame += move_frames;
11586 if (stored_player[i].move_delay > 0)
11587 stored_player[i].move_delay--;
11589 // due to bugs in previous versions, counter must count up, not down
11590 if (stored_player[i].push_delay != -1)
11591 stored_player[i].push_delay++;
11593 if (stored_player[i].drop_delay > 0)
11594 stored_player[i].drop_delay--;
11596 if (stored_player[i].is_dropping_pressed)
11597 stored_player[i].drop_pressed_delay++;
11601 void StartGameActions(boolean init_network_game, boolean record_tape,
11604 unsigned int new_random_seed = InitRND(random_seed);
11607 TapeStartRecording(new_random_seed);
11609 if (init_network_game)
11611 SendToServer_LevelFile();
11612 SendToServer_StartPlaying();
11620 static void GameActionsExt(void)
11623 static unsigned int game_frame_delay = 0;
11625 unsigned int game_frame_delay_value;
11626 byte *recorded_player_action;
11627 byte summarized_player_action = 0;
11628 byte tape_action[MAX_TAPE_ACTIONS] = { 0 };
11631 // detect endless loops, caused by custom element programming
11632 if (recursion_loop_detected && recursion_loop_depth == 0)
11634 char *message = getStringCat3("Internal Error! Element ",
11635 EL_NAME(recursion_loop_element),
11636 " caused endless loop! Quit the game?");
11638 Warn("element '%s' caused endless loop in game engine",
11639 EL_NAME(recursion_loop_element));
11641 RequestQuitGameExt(FALSE, level_editor_test_game, message);
11643 recursion_loop_detected = FALSE; // if game should be continued
11650 if (game.restart_level)
11651 StartGameActions(network.enabled, setup.autorecord, level.random_seed);
11653 CheckLevelSolved();
11655 if (game.LevelSolved && !game.LevelSolved_GameEnd)
11658 if (game.all_players_gone && !TAPE_IS_STOPPED(tape))
11661 if (game_status != GAME_MODE_PLAYING) // status might have changed
11664 game_frame_delay_value =
11665 (tape.playing && tape.fast_forward ? FfwdFrameDelay : GameFrameDelay);
11667 if (tape.playing && tape.warp_forward && !tape.pausing)
11668 game_frame_delay_value = 0;
11670 SetVideoFrameDelay(game_frame_delay_value);
11672 // (de)activate virtual buttons depending on current game status
11673 if (strEqual(setup.touch.control_type, TOUCH_CONTROL_VIRTUAL_BUTTONS))
11675 if (game.all_players_gone) // if no players there to be controlled anymore
11676 SetOverlayActive(FALSE);
11677 else if (!tape.playing) // if game continues after tape stopped playing
11678 SetOverlayActive(TRUE);
11683 // ---------- main game synchronization point ----------
11685 int skip = WaitUntilDelayReached(&game_frame_delay, game_frame_delay_value);
11687 Debug("game:playing:skip", "skip == %d", skip);
11690 // ---------- main game synchronization point ----------
11692 WaitUntilDelayReached(&game_frame_delay, game_frame_delay_value);
11696 if (network_playing && !network_player_action_received)
11698 // try to get network player actions in time
11700 // last chance to get network player actions without main loop delay
11701 HandleNetworking();
11703 // game was quit by network peer
11704 if (game_status != GAME_MODE_PLAYING)
11707 // check if network player actions still missing and game still running
11708 if (!network_player_action_received && !checkGameEnded())
11709 return; // failed to get network player actions in time
11711 // do not yet reset "network_player_action_received" (for tape.pausing)
11717 // at this point we know that we really continue executing the game
11719 network_player_action_received = FALSE;
11721 // when playing tape, read previously recorded player input from tape data
11722 recorded_player_action = (tape.playing ? TapePlayAction() : NULL);
11724 local_player->effective_mouse_action = local_player->mouse_action;
11726 if (recorded_player_action != NULL)
11727 SetMouseActionFromTapeAction(&local_player->effective_mouse_action,
11728 recorded_player_action);
11730 // TapePlayAction() may return NULL when toggling to "pause before death"
11734 if (tape.set_centered_player)
11736 game.centered_player_nr_next = tape.centered_player_nr_next;
11737 game.set_centered_player = TRUE;
11740 for (i = 0; i < MAX_PLAYERS; i++)
11742 summarized_player_action |= stored_player[i].action;
11744 if (!network_playing && (game.team_mode || tape.playing))
11745 stored_player[i].effective_action = stored_player[i].action;
11748 if (network_playing && !checkGameEnded())
11749 SendToServer_MovePlayer(summarized_player_action);
11751 // summarize all actions at local players mapped input device position
11752 // (this allows using different input devices in single player mode)
11753 if (!network.enabled && !game.team_mode)
11754 stored_player[map_player_action[local_player->index_nr]].effective_action =
11755 summarized_player_action;
11757 // summarize all actions at centered player in local team mode
11758 if (tape.recording &&
11759 setup.team_mode && !network.enabled &&
11760 setup.input_on_focus &&
11761 game.centered_player_nr != -1)
11763 for (i = 0; i < MAX_PLAYERS; i++)
11764 stored_player[map_player_action[i]].effective_action =
11765 (i == game.centered_player_nr ? summarized_player_action : 0);
11768 if (recorded_player_action != NULL)
11769 for (i = 0; i < MAX_PLAYERS; i++)
11770 stored_player[i].effective_action = recorded_player_action[i];
11772 for (i = 0; i < MAX_PLAYERS; i++)
11774 tape_action[i] = stored_player[i].effective_action;
11776 /* (this may happen in the RND game engine if a player was not present on
11777 the playfield on level start, but appeared later from a custom element */
11778 if (setup.team_mode &&
11781 !tape.player_participates[i])
11782 tape.player_participates[i] = TRUE;
11785 SetTapeActionFromMouseAction(tape_action,
11786 &local_player->effective_mouse_action);
11788 // only record actions from input devices, but not programmed actions
11789 if (tape.recording)
11790 TapeRecordAction(tape_action);
11792 // remember if game was played (especially after tape stopped playing)
11793 if (!tape.playing && summarized_player_action)
11794 game.GamePlayed = TRUE;
11796 #if USE_NEW_PLAYER_ASSIGNMENTS
11797 // !!! also map player actions in single player mode !!!
11798 // if (game.team_mode)
11801 byte mapped_action[MAX_PLAYERS];
11803 #if DEBUG_PLAYER_ACTIONS
11804 for (i = 0; i < MAX_PLAYERS; i++)
11805 DebugContinued("", "%d, ", stored_player[i].effective_action);
11808 for (i = 0; i < MAX_PLAYERS; i++)
11809 mapped_action[i] = stored_player[map_player_action[i]].effective_action;
11811 for (i = 0; i < MAX_PLAYERS; i++)
11812 stored_player[i].effective_action = mapped_action[i];
11814 #if DEBUG_PLAYER_ACTIONS
11815 DebugContinued("", "=> ");
11816 for (i = 0; i < MAX_PLAYERS; i++)
11817 DebugContinued("", "%d, ", stored_player[i].effective_action);
11818 DebugContinued("game:playing:player", "\n");
11821 #if DEBUG_PLAYER_ACTIONS
11824 for (i = 0; i < MAX_PLAYERS; i++)
11825 DebugContinued("", "%d, ", stored_player[i].effective_action);
11826 DebugContinued("game:playing:player", "\n");
11831 for (i = 0; i < MAX_PLAYERS; i++)
11833 // allow engine snapshot in case of changed movement attempt
11834 if ((game.snapshot.last_action[i] & KEY_MOTION) !=
11835 (stored_player[i].effective_action & KEY_MOTION))
11836 game.snapshot.changed_action = TRUE;
11838 // allow engine snapshot in case of snapping/dropping attempt
11839 if ((game.snapshot.last_action[i] & KEY_BUTTON) == 0 &&
11840 (stored_player[i].effective_action & KEY_BUTTON) != 0)
11841 game.snapshot.changed_action = TRUE;
11843 game.snapshot.last_action[i] = stored_player[i].effective_action;
11846 if (level.game_engine_type == GAME_ENGINE_TYPE_EM)
11848 GameActions_EM_Main();
11850 else if (level.game_engine_type == GAME_ENGINE_TYPE_SP)
11852 GameActions_SP_Main();
11854 else if (level.game_engine_type == GAME_ENGINE_TYPE_MM)
11856 GameActions_MM_Main();
11860 GameActions_RND_Main();
11863 BlitScreenToBitmap(backbuffer);
11865 CheckLevelSolved();
11868 AdvanceFrameAndPlayerCounters(-1); // advance counters for all players
11870 if (global.show_frames_per_second)
11872 static unsigned int fps_counter = 0;
11873 static int fps_frames = 0;
11874 unsigned int fps_delay_ms = Counter() - fps_counter;
11878 if (fps_delay_ms >= 500) // calculate FPS every 0.5 seconds
11880 global.frames_per_second = 1000 * (float)fps_frames / fps_delay_ms;
11883 fps_counter = Counter();
11885 // always draw FPS to screen after FPS value was updated
11886 redraw_mask |= REDRAW_FPS;
11889 // only draw FPS if no screen areas are deactivated (invisible warp mode)
11890 if (GetDrawDeactivationMask() == REDRAW_NONE)
11891 redraw_mask |= REDRAW_FPS;
11895 static void GameActions_CheckSaveEngineSnapshot(void)
11897 if (!game.snapshot.save_snapshot)
11900 // clear flag for saving snapshot _before_ saving snapshot
11901 game.snapshot.save_snapshot = FALSE;
11903 SaveEngineSnapshotToList();
11906 void GameActions(void)
11910 GameActions_CheckSaveEngineSnapshot();
11913 void GameActions_EM_Main(void)
11915 byte effective_action[MAX_PLAYERS];
11916 boolean warp_mode = (tape.playing && tape.warp_forward && !tape.pausing);
11919 for (i = 0; i < MAX_PLAYERS; i++)
11920 effective_action[i] = stored_player[i].effective_action;
11922 GameActions_EM(effective_action, warp_mode);
11925 void GameActions_SP_Main(void)
11927 byte effective_action[MAX_PLAYERS];
11928 boolean warp_mode = (tape.playing && tape.warp_forward && !tape.pausing);
11931 for (i = 0; i < MAX_PLAYERS; i++)
11932 effective_action[i] = stored_player[i].effective_action;
11934 GameActions_SP(effective_action, warp_mode);
11936 for (i = 0; i < MAX_PLAYERS; i++)
11938 if (stored_player[i].force_dropping)
11939 stored_player[i].action |= KEY_BUTTON_DROP;
11941 stored_player[i].force_dropping = FALSE;
11945 void GameActions_MM_Main(void)
11947 boolean warp_mode = (tape.playing && tape.warp_forward && !tape.pausing);
11949 GameActions_MM(local_player->effective_mouse_action, warp_mode);
11952 void GameActions_RND_Main(void)
11957 void GameActions_RND(void)
11959 static struct MouseActionInfo mouse_action_last = { 0 };
11960 struct MouseActionInfo mouse_action = local_player->effective_mouse_action;
11961 int magic_wall_x = 0, magic_wall_y = 0;
11962 int i, x, y, element, graphic, last_gfx_frame;
11964 InitPlayfieldScanModeVars();
11966 if (game.engine_version >= VERSION_IDENT(3,2,0,7))
11968 SCAN_PLAYFIELD(x, y)
11970 ChangeCount[x][y] = 0;
11971 ChangeEvent[x][y] = -1;
11975 if (game.set_centered_player)
11977 boolean all_players_fit_to_screen = checkIfAllPlayersFitToScreen_RND();
11979 // switching to "all players" only possible if all players fit to screen
11980 if (game.centered_player_nr_next == -1 && !all_players_fit_to_screen)
11982 game.centered_player_nr_next = game.centered_player_nr;
11983 game.set_centered_player = FALSE;
11986 // do not switch focus to non-existing (or non-active) player
11987 if (game.centered_player_nr_next >= 0 &&
11988 !stored_player[game.centered_player_nr_next].active)
11990 game.centered_player_nr_next = game.centered_player_nr;
11991 game.set_centered_player = FALSE;
11995 if (game.set_centered_player &&
11996 ScreenMovPos == 0) // screen currently aligned at tile position
12000 if (game.centered_player_nr_next == -1)
12002 setScreenCenteredToAllPlayers(&sx, &sy);
12006 sx = stored_player[game.centered_player_nr_next].jx;
12007 sy = stored_player[game.centered_player_nr_next].jy;
12010 game.centered_player_nr = game.centered_player_nr_next;
12011 game.set_centered_player = FALSE;
12013 DrawRelocateScreen(0, 0, sx, sy, MV_NONE, TRUE, setup.quick_switch);
12014 DrawGameDoorValues();
12017 // check single step mode (set flag and clear again if any player is active)
12018 game.enter_single_step_mode =
12019 (tape.single_step && tape.recording && !tape.pausing);
12021 for (i = 0; i < MAX_PLAYERS; i++)
12023 int actual_player_action = stored_player[i].effective_action;
12026 /* !!! THIS BREAKS THE FOLLOWING TAPES: !!!
12027 - rnd_equinox_tetrachloride 048
12028 - rnd_equinox_tetrachloride_ii 096
12029 - rnd_emanuel_schmieg 002
12030 - doctor_sloan_ww 001, 020
12032 if (stored_player[i].MovPos == 0)
12033 CheckGravityMovement(&stored_player[i]);
12036 // overwrite programmed action with tape action
12037 if (stored_player[i].programmed_action)
12038 actual_player_action = stored_player[i].programmed_action;
12040 PlayerActions(&stored_player[i], actual_player_action);
12042 ScrollPlayer(&stored_player[i], SCROLL_GO_ON);
12045 // single step pause mode may already have been toggled by "ScrollPlayer()"
12046 if (game.enter_single_step_mode && !tape.pausing)
12047 TapeTogglePause(TAPE_TOGGLE_AUTOMATIC);
12049 ScrollScreen(NULL, SCROLL_GO_ON);
12051 /* for backwards compatibility, the following code emulates a fixed bug that
12052 occured when pushing elements (causing elements that just made their last
12053 pushing step to already (if possible) make their first falling step in the
12054 same game frame, which is bad); this code is also needed to use the famous
12055 "spring push bug" which is used in older levels and might be wanted to be
12056 used also in newer levels, but in this case the buggy pushing code is only
12057 affecting the "spring" element and no other elements */
12059 if (game.engine_version < VERSION_IDENT(2,2,0,7) || level.use_spring_bug)
12061 for (i = 0; i < MAX_PLAYERS; i++)
12063 struct PlayerInfo *player = &stored_player[i];
12064 int x = player->jx;
12065 int y = player->jy;
12067 if (player->active && player->is_pushing && player->is_moving &&
12069 (game.engine_version < VERSION_IDENT(2,2,0,7) ||
12070 Tile[x][y] == EL_SPRING))
12072 ContinueMoving(x, y);
12074 // continue moving after pushing (this is actually a bug)
12075 if (!IS_MOVING(x, y))
12076 Stop[x][y] = FALSE;
12081 SCAN_PLAYFIELD(x, y)
12083 Last[x][y] = Tile[x][y];
12085 ChangeCount[x][y] = 0;
12086 ChangeEvent[x][y] = -1;
12088 // this must be handled before main playfield loop
12089 if (Tile[x][y] == EL_PLAYER_IS_LEAVING)
12092 if (MovDelay[x][y] <= 0)
12096 if (Tile[x][y] == EL_ELEMENT_SNAPPING)
12099 if (MovDelay[x][y] <= 0)
12101 int element = Store[x][y];
12102 int move_direction = MovDir[x][y];
12103 int player_index_bit = Store2[x][y];
12109 TEST_DrawLevelField(x, y);
12111 TestFieldAfterSnapping(x, y, element, move_direction, player_index_bit);
12116 if (ChangePage[x][y] != -1 && ChangeDelay[x][y] != 1)
12118 Debug("game:playing:GameActions_RND", "x = %d, y = %d: ChangePage != -1",
12120 Debug("game:playing:GameActions_RND", "This should never happen!");
12122 ChangePage[x][y] = -1;
12126 Stop[x][y] = FALSE;
12127 if (WasJustMoving[x][y] > 0)
12128 WasJustMoving[x][y]--;
12129 if (WasJustFalling[x][y] > 0)
12130 WasJustFalling[x][y]--;
12131 if (CheckCollision[x][y] > 0)
12132 CheckCollision[x][y]--;
12133 if (CheckImpact[x][y] > 0)
12134 CheckImpact[x][y]--;
12138 /* reset finished pushing action (not done in ContinueMoving() to allow
12139 continuous pushing animation for elements with zero push delay) */
12140 if (GfxAction[x][y] == ACTION_PUSHING && !IS_MOVING(x, y))
12142 ResetGfxAnimation(x, y);
12143 TEST_DrawLevelField(x, y);
12147 if (IS_BLOCKED(x, y))
12151 Blocked2Moving(x, y, &oldx, &oldy);
12152 if (!IS_MOVING(oldx, oldy))
12154 Debug("game:playing:GameActions_RND", "(BLOCKED => MOVING) context corrupted!");
12155 Debug("game:playing:GameActions_RND", "BLOCKED: x = %d, y = %d", x, y);
12156 Debug("game:playing:GameActions_RND", "!MOVING: oldx = %d, oldy = %d", oldx, oldy);
12157 Debug("game:playing:GameActions_RND", "This should never happen!");
12163 if (mouse_action.button)
12165 int new_button = (mouse_action.button && mouse_action_last.button == 0);
12166 int ch_button = CH_SIDE_FROM_BUTTON(mouse_action.button);
12168 x = mouse_action.lx;
12169 y = mouse_action.ly;
12170 element = Tile[x][y];
12174 CheckElementChangeByMouse(x, y, element, CE_CLICKED_BY_MOUSE, ch_button);
12175 CheckTriggeredElementChangeByMouse(x, y, element, CE_MOUSE_CLICKED_ON_X,
12179 CheckElementChangeByMouse(x, y, element, CE_PRESSED_BY_MOUSE, ch_button);
12180 CheckTriggeredElementChangeByMouse(x, y, element, CE_MOUSE_PRESSED_ON_X,
12184 SCAN_PLAYFIELD(x, y)
12186 element = Tile[x][y];
12187 graphic = el_act_dir2img(element, GfxAction[x][y], GfxDir[x][y]);
12188 last_gfx_frame = GfxFrame[x][y];
12190 ResetGfxFrame(x, y);
12192 if (GfxFrame[x][y] != last_gfx_frame && !Stop[x][y])
12193 DrawLevelGraphicAnimation(x, y, graphic);
12195 if (ANIM_MODE(graphic) == ANIM_RANDOM &&
12196 IS_NEXT_FRAME(GfxFrame[x][y], graphic))
12197 ResetRandomAnimationValue(x, y);
12199 SetRandomAnimationValue(x, y);
12201 PlayLevelSoundActionIfLoop(x, y, GfxAction[x][y]);
12203 if (IS_INACTIVE(element))
12205 if (IS_ANIMATED(graphic))
12206 DrawLevelGraphicAnimationIfNeeded(x, y, graphic);
12211 // this may take place after moving, so 'element' may have changed
12212 if (IS_CHANGING(x, y) &&
12213 (game.engine_version < VERSION_IDENT(3,0,7,1) || !Stop[x][y]))
12215 int page = element_info[element].event_page_nr[CE_DELAY];
12217 HandleElementChange(x, y, page);
12219 element = Tile[x][y];
12220 graphic = el_act_dir2img(element, GfxAction[x][y], GfxDir[x][y]);
12223 if (!IS_MOVING(x, y) && (CAN_FALL(element) || CAN_MOVE(element)))
12227 element = Tile[x][y];
12228 graphic = el_act_dir2img(element, GfxAction[x][y], GfxDir[x][y]);
12230 if (IS_ANIMATED(graphic) &&
12231 !IS_MOVING(x, y) &&
12233 DrawLevelGraphicAnimationIfNeeded(x, y, graphic);
12235 if (IS_GEM(element) || element == EL_SP_INFOTRON)
12236 TEST_DrawTwinkleOnField(x, y);
12238 else if (element == EL_ACID)
12241 DrawLevelGraphicAnimationIfNeeded(x, y, graphic);
12243 else if ((element == EL_EXIT_OPEN ||
12244 element == EL_EM_EXIT_OPEN ||
12245 element == EL_SP_EXIT_OPEN ||
12246 element == EL_STEEL_EXIT_OPEN ||
12247 element == EL_EM_STEEL_EXIT_OPEN ||
12248 element == EL_SP_TERMINAL ||
12249 element == EL_SP_TERMINAL_ACTIVE ||
12250 element == EL_EXTRA_TIME ||
12251 element == EL_SHIELD_NORMAL ||
12252 element == EL_SHIELD_DEADLY) &&
12253 IS_ANIMATED(graphic))
12254 DrawLevelGraphicAnimationIfNeeded(x, y, graphic);
12255 else if (IS_MOVING(x, y))
12256 ContinueMoving(x, y);
12257 else if (IS_ACTIVE_BOMB(element))
12258 CheckDynamite(x, y);
12259 else if (element == EL_AMOEBA_GROWING)
12260 AmoebaGrowing(x, y);
12261 else if (element == EL_AMOEBA_SHRINKING)
12262 AmoebaShrinking(x, y);
12264 #if !USE_NEW_AMOEBA_CODE
12265 else if (IS_AMOEBALIVE(element))
12266 AmoebaReproduce(x, y);
12269 else if (element == EL_GAME_OF_LIFE || element == EL_BIOMAZE)
12271 else if (element == EL_EXIT_CLOSED)
12273 else if (element == EL_EM_EXIT_CLOSED)
12275 else if (element == EL_STEEL_EXIT_CLOSED)
12276 CheckExitSteel(x, y);
12277 else if (element == EL_EM_STEEL_EXIT_CLOSED)
12278 CheckExitSteelEM(x, y);
12279 else if (element == EL_SP_EXIT_CLOSED)
12281 else if (element == EL_EXPANDABLE_WALL_GROWING ||
12282 element == EL_EXPANDABLE_STEELWALL_GROWING)
12283 MauerWaechst(x, y);
12284 else if (element == EL_EXPANDABLE_WALL ||
12285 element == EL_EXPANDABLE_WALL_HORIZONTAL ||
12286 element == EL_EXPANDABLE_WALL_VERTICAL ||
12287 element == EL_EXPANDABLE_WALL_ANY ||
12288 element == EL_BD_EXPANDABLE_WALL)
12289 MauerAbleger(x, y);
12290 else if (element == EL_EXPANDABLE_STEELWALL_HORIZONTAL ||
12291 element == EL_EXPANDABLE_STEELWALL_VERTICAL ||
12292 element == EL_EXPANDABLE_STEELWALL_ANY)
12293 MauerAblegerStahl(x, y);
12294 else if (element == EL_FLAMES)
12295 CheckForDragon(x, y);
12296 else if (element == EL_EXPLOSION)
12297 ; // drawing of correct explosion animation is handled separately
12298 else if (element == EL_ELEMENT_SNAPPING ||
12299 element == EL_DIAGONAL_SHRINKING ||
12300 element == EL_DIAGONAL_GROWING)
12302 graphic = el_act_dir2img(GfxElement[x][y], GfxAction[x][y],GfxDir[x][y]);
12304 DrawLevelGraphicAnimationIfNeeded(x, y, graphic);
12306 else if (IS_ANIMATED(graphic) && !IS_CHANGING(x, y))
12307 DrawLevelGraphicAnimationIfNeeded(x, y, graphic);
12309 if (IS_BELT_ACTIVE(element))
12310 PlayLevelSoundAction(x, y, ACTION_ACTIVE);
12312 if (game.magic_wall_active)
12314 int jx = local_player->jx, jy = local_player->jy;
12316 // play the element sound at the position nearest to the player
12317 if ((element == EL_MAGIC_WALL_FULL ||
12318 element == EL_MAGIC_WALL_ACTIVE ||
12319 element == EL_MAGIC_WALL_EMPTYING ||
12320 element == EL_BD_MAGIC_WALL_FULL ||
12321 element == EL_BD_MAGIC_WALL_ACTIVE ||
12322 element == EL_BD_MAGIC_WALL_EMPTYING ||
12323 element == EL_DC_MAGIC_WALL_FULL ||
12324 element == EL_DC_MAGIC_WALL_ACTIVE ||
12325 element == EL_DC_MAGIC_WALL_EMPTYING) &&
12326 ABS(x - jx) + ABS(y - jy) <
12327 ABS(magic_wall_x - jx) + ABS(magic_wall_y - jy))
12335 #if USE_NEW_AMOEBA_CODE
12336 // new experimental amoeba growth stuff
12337 if (!(FrameCounter % 8))
12339 static unsigned int random = 1684108901;
12341 for (i = 0; i < level.amoeba_speed * 28 / 8; i++)
12343 x = RND(lev_fieldx);
12344 y = RND(lev_fieldy);
12345 element = Tile[x][y];
12347 if (!IS_PLAYER(x,y) &&
12348 (element == EL_EMPTY ||
12349 CAN_GROW_INTO(element) ||
12350 element == EL_QUICKSAND_EMPTY ||
12351 element == EL_QUICKSAND_FAST_EMPTY ||
12352 element == EL_ACID_SPLASH_LEFT ||
12353 element == EL_ACID_SPLASH_RIGHT))
12355 if ((IN_LEV_FIELD(x, y-1) && Tile[x][y-1] == EL_AMOEBA_WET) ||
12356 (IN_LEV_FIELD(x-1, y) && Tile[x-1][y] == EL_AMOEBA_WET) ||
12357 (IN_LEV_FIELD(x+1, y) && Tile[x+1][y] == EL_AMOEBA_WET) ||
12358 (IN_LEV_FIELD(x, y+1) && Tile[x][y+1] == EL_AMOEBA_WET))
12359 Tile[x][y] = EL_AMOEBA_DROP;
12362 random = random * 129 + 1;
12367 game.explosions_delayed = FALSE;
12369 SCAN_PLAYFIELD(x, y)
12371 element = Tile[x][y];
12373 if (ExplodeField[x][y])
12374 Explode(x, y, EX_PHASE_START, ExplodeField[x][y]);
12375 else if (element == EL_EXPLOSION)
12376 Explode(x, y, ExplodePhase[x][y], EX_TYPE_NORMAL);
12378 ExplodeField[x][y] = EX_TYPE_NONE;
12381 game.explosions_delayed = TRUE;
12383 if (game.magic_wall_active)
12385 if (!(game.magic_wall_time_left % 4))
12387 int element = Tile[magic_wall_x][magic_wall_y];
12389 if (element == EL_BD_MAGIC_WALL_FULL ||
12390 element == EL_BD_MAGIC_WALL_ACTIVE ||
12391 element == EL_BD_MAGIC_WALL_EMPTYING)
12392 PlayLevelSound(magic_wall_x, magic_wall_y, SND_BD_MAGIC_WALL_ACTIVE);
12393 else if (element == EL_DC_MAGIC_WALL_FULL ||
12394 element == EL_DC_MAGIC_WALL_ACTIVE ||
12395 element == EL_DC_MAGIC_WALL_EMPTYING)
12396 PlayLevelSound(magic_wall_x, magic_wall_y, SND_DC_MAGIC_WALL_ACTIVE);
12398 PlayLevelSound(magic_wall_x, magic_wall_y, SND_MAGIC_WALL_ACTIVE);
12401 if (game.magic_wall_time_left > 0)
12403 game.magic_wall_time_left--;
12405 if (!game.magic_wall_time_left)
12407 SCAN_PLAYFIELD(x, y)
12409 element = Tile[x][y];
12411 if (element == EL_MAGIC_WALL_ACTIVE ||
12412 element == EL_MAGIC_WALL_FULL)
12414 Tile[x][y] = EL_MAGIC_WALL_DEAD;
12415 TEST_DrawLevelField(x, y);
12417 else if (element == EL_BD_MAGIC_WALL_ACTIVE ||
12418 element == EL_BD_MAGIC_WALL_FULL)
12420 Tile[x][y] = EL_BD_MAGIC_WALL_DEAD;
12421 TEST_DrawLevelField(x, y);
12423 else if (element == EL_DC_MAGIC_WALL_ACTIVE ||
12424 element == EL_DC_MAGIC_WALL_FULL)
12426 Tile[x][y] = EL_DC_MAGIC_WALL_DEAD;
12427 TEST_DrawLevelField(x, y);
12431 game.magic_wall_active = FALSE;
12436 if (game.light_time_left > 0)
12438 game.light_time_left--;
12440 if (game.light_time_left == 0)
12441 RedrawAllLightSwitchesAndInvisibleElements();
12444 if (game.timegate_time_left > 0)
12446 game.timegate_time_left--;
12448 if (game.timegate_time_left == 0)
12449 CloseAllOpenTimegates();
12452 if (game.lenses_time_left > 0)
12454 game.lenses_time_left--;
12456 if (game.lenses_time_left == 0)
12457 RedrawAllInvisibleElementsForLenses();
12460 if (game.magnify_time_left > 0)
12462 game.magnify_time_left--;
12464 if (game.magnify_time_left == 0)
12465 RedrawAllInvisibleElementsForMagnifier();
12468 for (i = 0; i < MAX_PLAYERS; i++)
12470 struct PlayerInfo *player = &stored_player[i];
12472 if (SHIELD_ON(player))
12474 if (player->shield_deadly_time_left)
12475 PlayLevelSound(player->jx, player->jy, SND_SHIELD_DEADLY_ACTIVE);
12476 else if (player->shield_normal_time_left)
12477 PlayLevelSound(player->jx, player->jy, SND_SHIELD_NORMAL_ACTIVE);
12481 #if USE_DELAYED_GFX_REDRAW
12482 SCAN_PLAYFIELD(x, y)
12484 if (GfxRedraw[x][y] != GFX_REDRAW_NONE)
12486 /* !!! PROBLEM: THIS REDRAWS THE PLAYFIELD _AFTER_ THE SCAN, BUT TILES
12487 !!! MAY HAVE CHANGED AFTER BEING DRAWN DURING PLAYFIELD SCAN !!! */
12489 if (GfxRedraw[x][y] & GFX_REDRAW_TILE)
12490 DrawLevelField(x, y);
12492 if (GfxRedraw[x][y] & GFX_REDRAW_TILE_CRUMBLED)
12493 DrawLevelFieldCrumbled(x, y);
12495 if (GfxRedraw[x][y] & GFX_REDRAW_TILE_CRUMBLED_NEIGHBOURS)
12496 DrawLevelFieldCrumbledNeighbours(x, y);
12498 if (GfxRedraw[x][y] & GFX_REDRAW_TILE_TWINKLED)
12499 DrawTwinkleOnField(x, y);
12502 GfxRedraw[x][y] = GFX_REDRAW_NONE;
12507 PlayAllPlayersSound();
12509 for (i = 0; i < MAX_PLAYERS; i++)
12511 struct PlayerInfo *player = &stored_player[i];
12513 if (player->show_envelope != 0 && (!player->active ||
12514 player->MovPos == 0))
12516 ShowEnvelope(player->show_envelope - EL_ENVELOPE_1);
12518 player->show_envelope = 0;
12522 // use random number generator in every frame to make it less predictable
12523 if (game.engine_version >= VERSION_IDENT(3,1,1,0))
12526 mouse_action_last = mouse_action;
12529 static boolean AllPlayersInSight(struct PlayerInfo *player, int x, int y)
12531 int min_x = x, min_y = y, max_x = x, max_y = y;
12532 int scr_fieldx = getScreenFieldSizeX();
12533 int scr_fieldy = getScreenFieldSizeY();
12536 for (i = 0; i < MAX_PLAYERS; i++)
12538 int jx = stored_player[i].jx, jy = stored_player[i].jy;
12540 if (!stored_player[i].active || &stored_player[i] == player)
12543 min_x = MIN(min_x, jx);
12544 min_y = MIN(min_y, jy);
12545 max_x = MAX(max_x, jx);
12546 max_y = MAX(max_y, jy);
12549 return (max_x - min_x < scr_fieldx && max_y - min_y < scr_fieldy);
12552 static boolean AllPlayersInVisibleScreen(void)
12556 for (i = 0; i < MAX_PLAYERS; i++)
12558 int jx = stored_player[i].jx, jy = stored_player[i].jy;
12560 if (!stored_player[i].active)
12563 if (!IN_VIS_FIELD(SCREENX(jx), SCREENY(jy)))
12570 void ScrollLevel(int dx, int dy)
12572 int scroll_offset = 2 * TILEX_VAR;
12575 BlitBitmap(drawto_field, drawto_field,
12576 FX + TILEX_VAR * (dx == -1) - scroll_offset,
12577 FY + TILEY_VAR * (dy == -1) - scroll_offset,
12578 SXSIZE - TILEX_VAR * (dx != 0) + 2 * scroll_offset,
12579 SYSIZE - TILEY_VAR * (dy != 0) + 2 * scroll_offset,
12580 FX + TILEX_VAR * (dx == 1) - scroll_offset,
12581 FY + TILEY_VAR * (dy == 1) - scroll_offset);
12585 x = (dx == 1 ? BX1 : BX2);
12586 for (y = BY1; y <= BY2; y++)
12587 DrawScreenField(x, y);
12592 y = (dy == 1 ? BY1 : BY2);
12593 for (x = BX1; x <= BX2; x++)
12594 DrawScreenField(x, y);
12597 redraw_mask |= REDRAW_FIELD;
12600 static boolean canFallDown(struct PlayerInfo *player)
12602 int jx = player->jx, jy = player->jy;
12604 return (IN_LEV_FIELD(jx, jy + 1) &&
12605 (IS_FREE(jx, jy + 1) ||
12606 (Tile[jx][jy + 1] == EL_ACID && player->can_fall_into_acid)) &&
12607 IS_WALKABLE_FROM(Tile[jx][jy], MV_DOWN) &&
12608 !IS_WALKABLE_INSIDE(Tile[jx][jy]));
12611 static boolean canPassField(int x, int y, int move_dir)
12613 int opposite_dir = MV_DIR_OPPOSITE(move_dir);
12614 int dx = (move_dir & MV_LEFT ? -1 : move_dir & MV_RIGHT ? +1 : 0);
12615 int dy = (move_dir & MV_UP ? -1 : move_dir & MV_DOWN ? +1 : 0);
12616 int nextx = x + dx;
12617 int nexty = y + dy;
12618 int element = Tile[x][y];
12620 return (IS_PASSABLE_FROM(element, opposite_dir) &&
12621 !CAN_MOVE(element) &&
12622 IN_LEV_FIELD(nextx, nexty) && !IS_PLAYER(nextx, nexty) &&
12623 IS_WALKABLE_FROM(Tile[nextx][nexty], move_dir) &&
12624 (level.can_pass_to_walkable || IS_FREE(nextx, nexty)));
12627 static boolean canMoveToValidFieldWithGravity(int x, int y, int move_dir)
12629 int opposite_dir = MV_DIR_OPPOSITE(move_dir);
12630 int dx = (move_dir & MV_LEFT ? -1 : move_dir & MV_RIGHT ? +1 : 0);
12631 int dy = (move_dir & MV_UP ? -1 : move_dir & MV_DOWN ? +1 : 0);
12635 return (IN_LEV_FIELD(newx, newy) && !IS_FREE_OR_PLAYER(newx, newy) &&
12636 IS_GRAVITY_REACHABLE(Tile[newx][newy]) &&
12637 (IS_DIGGABLE(Tile[newx][newy]) ||
12638 IS_WALKABLE_FROM(Tile[newx][newy], opposite_dir) ||
12639 canPassField(newx, newy, move_dir)));
12642 static void CheckGravityMovement(struct PlayerInfo *player)
12644 if (player->gravity && !player->programmed_action)
12646 int move_dir_horizontal = player->effective_action & MV_HORIZONTAL;
12647 int move_dir_vertical = player->effective_action & MV_VERTICAL;
12648 boolean player_is_snapping = (player->effective_action & JOY_BUTTON_1);
12649 int jx = player->jx, jy = player->jy;
12650 boolean player_is_moving_to_valid_field =
12651 (!player_is_snapping &&
12652 (canMoveToValidFieldWithGravity(jx, jy, move_dir_horizontal) ||
12653 canMoveToValidFieldWithGravity(jx, jy, move_dir_vertical)));
12654 boolean player_can_fall_down = canFallDown(player);
12656 if (player_can_fall_down &&
12657 !player_is_moving_to_valid_field)
12658 player->programmed_action = MV_DOWN;
12662 static void CheckGravityMovementWhenNotMoving(struct PlayerInfo *player)
12664 return CheckGravityMovement(player);
12666 if (player->gravity && !player->programmed_action)
12668 int jx = player->jx, jy = player->jy;
12669 boolean field_under_player_is_free =
12670 (IN_LEV_FIELD(jx, jy + 1) && IS_FREE(jx, jy + 1));
12671 boolean player_is_standing_on_valid_field =
12672 (IS_WALKABLE_INSIDE(Tile[jx][jy]) ||
12673 (IS_WALKABLE(Tile[jx][jy]) &&
12674 !(element_info[Tile[jx][jy]].access_direction & MV_DOWN)));
12676 if (field_under_player_is_free && !player_is_standing_on_valid_field)
12677 player->programmed_action = MV_DOWN;
12682 MovePlayerOneStep()
12683 -----------------------------------------------------------------------------
12684 dx, dy: direction (non-diagonal) to try to move the player to
12685 real_dx, real_dy: direction as read from input device (can be diagonal)
12688 boolean MovePlayerOneStep(struct PlayerInfo *player,
12689 int dx, int dy, int real_dx, int real_dy)
12691 int jx = player->jx, jy = player->jy;
12692 int new_jx = jx + dx, new_jy = jy + dy;
12694 boolean player_can_move = !player->cannot_move;
12696 if (!player->active || (!dx && !dy))
12697 return MP_NO_ACTION;
12699 player->MovDir = (dx < 0 ? MV_LEFT :
12700 dx > 0 ? MV_RIGHT :
12702 dy > 0 ? MV_DOWN : MV_NONE);
12704 if (!IN_LEV_FIELD(new_jx, new_jy))
12705 return MP_NO_ACTION;
12707 if (!player_can_move)
12709 if (player->MovPos == 0)
12711 player->is_moving = FALSE;
12712 player->is_digging = FALSE;
12713 player->is_collecting = FALSE;
12714 player->is_snapping = FALSE;
12715 player->is_pushing = FALSE;
12719 if (!network.enabled && game.centered_player_nr == -1 &&
12720 !AllPlayersInSight(player, new_jx, new_jy))
12721 return MP_NO_ACTION;
12723 can_move = DigField(player, jx, jy, new_jx, new_jy, real_dx,real_dy, DF_DIG);
12724 if (can_move != MP_MOVING)
12727 // check if DigField() has caused relocation of the player
12728 if (player->jx != jx || player->jy != jy)
12729 return MP_NO_ACTION; // <-- !!! CHECK THIS [-> MP_ACTION ?] !!!
12731 StorePlayer[jx][jy] = 0;
12732 player->last_jx = jx;
12733 player->last_jy = jy;
12734 player->jx = new_jx;
12735 player->jy = new_jy;
12736 StorePlayer[new_jx][new_jy] = player->element_nr;
12738 if (player->move_delay_value_next != -1)
12740 player->move_delay_value = player->move_delay_value_next;
12741 player->move_delay_value_next = -1;
12745 (dx > 0 || dy > 0 ? -1 : 1) * (TILEX - TILEX / player->move_delay_value);
12747 player->step_counter++;
12749 PlayerVisit[jx][jy] = FrameCounter;
12751 player->is_moving = TRUE;
12754 // should better be called in MovePlayer(), but this breaks some tapes
12755 ScrollPlayer(player, SCROLL_INIT);
12761 boolean MovePlayer(struct PlayerInfo *player, int dx, int dy)
12763 int jx = player->jx, jy = player->jy;
12764 int old_jx = jx, old_jy = jy;
12765 int moved = MP_NO_ACTION;
12767 if (!player->active)
12772 if (player->MovPos == 0)
12774 player->is_moving = FALSE;
12775 player->is_digging = FALSE;
12776 player->is_collecting = FALSE;
12777 player->is_snapping = FALSE;
12778 player->is_pushing = FALSE;
12784 if (player->move_delay > 0)
12787 player->move_delay = -1; // set to "uninitialized" value
12789 // store if player is automatically moved to next field
12790 player->is_auto_moving = (player->programmed_action != MV_NONE);
12792 // remove the last programmed player action
12793 player->programmed_action = 0;
12795 if (player->MovPos)
12797 // should only happen if pre-1.2 tape recordings are played
12798 // this is only for backward compatibility
12800 int original_move_delay_value = player->move_delay_value;
12803 Debug("game:playing:MovePlayer",
12804 "THIS SHOULD ONLY HAPPEN WITH PRE-1.2 LEVEL TAPES. [%d]",
12808 // scroll remaining steps with finest movement resolution
12809 player->move_delay_value = MOVE_DELAY_NORMAL_SPEED;
12811 while (player->MovPos)
12813 ScrollPlayer(player, SCROLL_GO_ON);
12814 ScrollScreen(NULL, SCROLL_GO_ON);
12816 AdvanceFrameAndPlayerCounters(player->index_nr);
12819 BackToFront_WithFrameDelay(0);
12822 player->move_delay_value = original_move_delay_value;
12825 player->is_active = FALSE;
12827 if (player->last_move_dir & MV_HORIZONTAL)
12829 if (!(moved |= MovePlayerOneStep(player, 0, dy, dx, dy)))
12830 moved |= MovePlayerOneStep(player, dx, 0, dx, dy);
12834 if (!(moved |= MovePlayerOneStep(player, dx, 0, dx, dy)))
12835 moved |= MovePlayerOneStep(player, 0, dy, dx, dy);
12838 if (!moved && !player->is_active)
12840 player->is_moving = FALSE;
12841 player->is_digging = FALSE;
12842 player->is_collecting = FALSE;
12843 player->is_snapping = FALSE;
12844 player->is_pushing = FALSE;
12850 if (moved & MP_MOVING && !ScreenMovPos &&
12851 (player->index_nr == game.centered_player_nr ||
12852 game.centered_player_nr == -1))
12854 int old_scroll_x = scroll_x, old_scroll_y = scroll_y;
12856 if (!IN_VIS_FIELD(SCREENX(jx), SCREENY(jy)))
12858 // actual player has left the screen -- scroll in that direction
12859 if (jx != old_jx) // player has moved horizontally
12860 scroll_x += (jx - old_jx);
12861 else // player has moved vertically
12862 scroll_y += (jy - old_jy);
12866 int offset_raw = game.scroll_delay_value;
12868 if (jx != old_jx) // player has moved horizontally
12870 int offset = MIN(offset_raw, (SCR_FIELDX - 2) / 2);
12871 int offset_x = offset * (player->MovDir == MV_LEFT ? +1 : -1);
12872 int new_scroll_x = jx - MIDPOSX + offset_x;
12874 if ((player->MovDir == MV_LEFT && scroll_x > new_scroll_x) ||
12875 (player->MovDir == MV_RIGHT && scroll_x < new_scroll_x))
12876 scroll_x = new_scroll_x;
12878 // don't scroll over playfield boundaries
12879 scroll_x = MIN(MAX(SBX_Left, scroll_x), SBX_Right);
12881 // don't scroll more than one field at a time
12882 scroll_x = old_scroll_x + SIGN(scroll_x - old_scroll_x);
12884 // don't scroll against the player's moving direction
12885 if ((player->MovDir == MV_LEFT && scroll_x > old_scroll_x) ||
12886 (player->MovDir == MV_RIGHT && scroll_x < old_scroll_x))
12887 scroll_x = old_scroll_x;
12889 else // player has moved vertically
12891 int offset = MIN(offset_raw, (SCR_FIELDY - 2) / 2);
12892 int offset_y = offset * (player->MovDir == MV_UP ? +1 : -1);
12893 int new_scroll_y = jy - MIDPOSY + offset_y;
12895 if ((player->MovDir == MV_UP && scroll_y > new_scroll_y) ||
12896 (player->MovDir == MV_DOWN && scroll_y < new_scroll_y))
12897 scroll_y = new_scroll_y;
12899 // don't scroll over playfield boundaries
12900 scroll_y = MIN(MAX(SBY_Upper, scroll_y), SBY_Lower);
12902 // don't scroll more than one field at a time
12903 scroll_y = old_scroll_y + SIGN(scroll_y - old_scroll_y);
12905 // don't scroll against the player's moving direction
12906 if ((player->MovDir == MV_UP && scroll_y > old_scroll_y) ||
12907 (player->MovDir == MV_DOWN && scroll_y < old_scroll_y))
12908 scroll_y = old_scroll_y;
12912 if (scroll_x != old_scroll_x || scroll_y != old_scroll_y)
12914 if (!network.enabled && game.centered_player_nr == -1 &&
12915 !AllPlayersInVisibleScreen())
12917 scroll_x = old_scroll_x;
12918 scroll_y = old_scroll_y;
12922 ScrollScreen(player, SCROLL_INIT);
12923 ScrollLevel(old_scroll_x - scroll_x, old_scroll_y - scroll_y);
12928 player->StepFrame = 0;
12930 if (moved & MP_MOVING)
12932 if (old_jx != jx && old_jy == jy)
12933 player->MovDir = (old_jx < jx ? MV_RIGHT : MV_LEFT);
12934 else if (old_jx == jx && old_jy != jy)
12935 player->MovDir = (old_jy < jy ? MV_DOWN : MV_UP);
12937 TEST_DrawLevelField(jx, jy); // for "crumbled sand"
12939 player->last_move_dir = player->MovDir;
12940 player->is_moving = TRUE;
12941 player->is_snapping = FALSE;
12942 player->is_switching = FALSE;
12943 player->is_dropping = FALSE;
12944 player->is_dropping_pressed = FALSE;
12945 player->drop_pressed_delay = 0;
12948 // should better be called here than above, but this breaks some tapes
12949 ScrollPlayer(player, SCROLL_INIT);
12954 CheckGravityMovementWhenNotMoving(player);
12956 player->is_moving = FALSE;
12958 /* at this point, the player is allowed to move, but cannot move right now
12959 (e.g. because of something blocking the way) -- ensure that the player
12960 is also allowed to move in the next frame (in old versions before 3.1.1,
12961 the player was forced to wait again for eight frames before next try) */
12963 if (game.engine_version >= VERSION_IDENT(3,1,1,0))
12964 player->move_delay = 0; // allow direct movement in the next frame
12967 if (player->move_delay == -1) // not yet initialized by DigField()
12968 player->move_delay = player->move_delay_value;
12970 if (game.engine_version < VERSION_IDENT(3,0,7,0))
12972 TestIfPlayerTouchesBadThing(jx, jy);
12973 TestIfPlayerTouchesCustomElement(jx, jy);
12976 if (!player->active)
12977 RemovePlayer(player);
12982 void ScrollPlayer(struct PlayerInfo *player, int mode)
12984 int jx = player->jx, jy = player->jy;
12985 int last_jx = player->last_jx, last_jy = player->last_jy;
12986 int move_stepsize = TILEX / player->move_delay_value;
12988 if (!player->active)
12991 if (player->MovPos == 0 && mode == SCROLL_GO_ON) // player not moving
12994 if (mode == SCROLL_INIT)
12996 player->actual_frame_counter = FrameCounter;
12997 player->GfxPos = move_stepsize * (player->MovPos / move_stepsize);
12999 if ((player->block_last_field || player->block_delay_adjustment > 0) &&
13000 Tile[last_jx][last_jy] == EL_EMPTY)
13002 int last_field_block_delay = 0; // start with no blocking at all
13003 int block_delay_adjustment = player->block_delay_adjustment;
13005 // if player blocks last field, add delay for exactly one move
13006 if (player->block_last_field)
13008 last_field_block_delay += player->move_delay_value;
13010 // when blocking enabled, prevent moving up despite gravity
13011 if (player->gravity && player->MovDir == MV_UP)
13012 block_delay_adjustment = -1;
13015 // add block delay adjustment (also possible when not blocking)
13016 last_field_block_delay += block_delay_adjustment;
13018 Tile[last_jx][last_jy] = EL_PLAYER_IS_LEAVING;
13019 MovDelay[last_jx][last_jy] = last_field_block_delay + 1;
13022 if (player->MovPos != 0) // player has not yet reached destination
13025 else if (!FrameReached(&player->actual_frame_counter, 1))
13028 if (player->MovPos != 0)
13030 player->MovPos += (player->MovPos > 0 ? -1 : 1) * move_stepsize;
13031 player->GfxPos = move_stepsize * (player->MovPos / move_stepsize);
13033 // before DrawPlayer() to draw correct player graphic for this case
13034 if (player->MovPos == 0)
13035 CheckGravityMovement(player);
13038 if (player->MovPos == 0) // player reached destination field
13040 if (player->move_delay_reset_counter > 0)
13042 player->move_delay_reset_counter--;
13044 if (player->move_delay_reset_counter == 0)
13046 // continue with normal speed after quickly moving through gate
13047 HALVE_PLAYER_SPEED(player);
13049 // be able to make the next move without delay
13050 player->move_delay = 0;
13054 player->last_jx = jx;
13055 player->last_jy = jy;
13057 if (Tile[jx][jy] == EL_EXIT_OPEN ||
13058 Tile[jx][jy] == EL_EM_EXIT_OPEN ||
13059 Tile[jx][jy] == EL_EM_EXIT_OPENING ||
13060 Tile[jx][jy] == EL_STEEL_EXIT_OPEN ||
13061 Tile[jx][jy] == EL_EM_STEEL_EXIT_OPEN ||
13062 Tile[jx][jy] == EL_EM_STEEL_EXIT_OPENING ||
13063 Tile[jx][jy] == EL_SP_EXIT_OPEN ||
13064 Tile[jx][jy] == EL_SP_EXIT_OPENING) // <-- special case
13066 ExitPlayer(player);
13068 if (game.players_still_needed == 0 &&
13069 (game.friends_still_needed == 0 ||
13070 IS_SP_ELEMENT(Tile[jx][jy])))
13074 // this breaks one level: "machine", level 000
13076 int move_direction = player->MovDir;
13077 int enter_side = MV_DIR_OPPOSITE(move_direction);
13078 int leave_side = move_direction;
13079 int old_jx = last_jx;
13080 int old_jy = last_jy;
13081 int old_element = Tile[old_jx][old_jy];
13082 int new_element = Tile[jx][jy];
13084 if (IS_CUSTOM_ELEMENT(old_element))
13085 CheckElementChangeByPlayer(old_jx, old_jy, old_element,
13087 player->index_bit, leave_side);
13089 CheckTriggeredElementChangeByPlayer(old_jx, old_jy, old_element,
13090 CE_PLAYER_LEAVES_X,
13091 player->index_bit, leave_side);
13093 if (IS_CUSTOM_ELEMENT(new_element))
13094 CheckElementChangeByPlayer(jx, jy, new_element, CE_ENTERED_BY_PLAYER,
13095 player->index_bit, enter_side);
13097 CheckTriggeredElementChangeByPlayer(jx, jy, new_element,
13098 CE_PLAYER_ENTERS_X,
13099 player->index_bit, enter_side);
13101 CheckTriggeredElementChangeBySide(jx, jy, player->initial_element,
13102 CE_MOVE_OF_X, move_direction);
13105 if (game.engine_version >= VERSION_IDENT(3,0,7,0))
13107 TestIfPlayerTouchesBadThing(jx, jy);
13108 TestIfPlayerTouchesCustomElement(jx, jy);
13110 /* needed because pushed element has not yet reached its destination,
13111 so it would trigger a change event at its previous field location */
13112 if (!player->is_pushing)
13113 TestIfElementTouchesCustomElement(jx, jy); // for empty space
13115 if (level.finish_dig_collect &&
13116 (player->is_digging || player->is_collecting))
13118 int last_element = player->last_removed_element;
13119 int move_direction = player->MovDir;
13120 int enter_side = MV_DIR_OPPOSITE(move_direction);
13121 int change_event = (player->is_digging ? CE_PLAYER_DIGS_X :
13122 CE_PLAYER_COLLECTS_X);
13124 CheckTriggeredElementChangeByPlayer(jx, jy, last_element, change_event,
13125 player->index_bit, enter_side);
13127 player->last_removed_element = EL_UNDEFINED;
13130 if (!player->active)
13131 RemovePlayer(player);
13134 if (!game.LevelSolved && level.use_step_counter)
13144 if (TimeLeft <= 10 && setup.time_limit)
13145 PlaySound(SND_GAME_RUNNING_OUT_OF_TIME);
13147 game_panel_controls[GAME_PANEL_TIME].value = TimeLeft;
13149 DisplayGameControlValues();
13151 if (!TimeLeft && setup.time_limit)
13152 for (i = 0; i < MAX_PLAYERS; i++)
13153 KillPlayer(&stored_player[i]);
13155 else if (game.no_time_limit && !game.all_players_gone)
13157 game_panel_controls[GAME_PANEL_TIME].value = TimePlayed;
13159 DisplayGameControlValues();
13163 if (tape.single_step && tape.recording && !tape.pausing &&
13164 !player->programmed_action)
13165 TapeTogglePause(TAPE_TOGGLE_AUTOMATIC);
13167 if (!player->programmed_action)
13168 CheckSaveEngineSnapshot(player);
13172 void ScrollScreen(struct PlayerInfo *player, int mode)
13174 static unsigned int screen_frame_counter = 0;
13176 if (mode == SCROLL_INIT)
13178 // set scrolling step size according to actual player's moving speed
13179 ScrollStepSize = TILEX / player->move_delay_value;
13181 screen_frame_counter = FrameCounter;
13182 ScreenMovDir = player->MovDir;
13183 ScreenMovPos = player->MovPos;
13184 ScreenGfxPos = ScrollStepSize * (ScreenMovPos / ScrollStepSize);
13187 else if (!FrameReached(&screen_frame_counter, 1))
13192 ScreenMovPos += (ScreenMovPos > 0 ? -1 : 1) * ScrollStepSize;
13193 ScreenGfxPos = ScrollStepSize * (ScreenMovPos / ScrollStepSize);
13194 redraw_mask |= REDRAW_FIELD;
13197 ScreenMovDir = MV_NONE;
13200 void TestIfPlayerTouchesCustomElement(int x, int y)
13202 static int xy[4][2] =
13209 static int trigger_sides[4][2] =
13211 // center side border side
13212 { CH_SIDE_TOP, CH_SIDE_BOTTOM }, // check top
13213 { CH_SIDE_LEFT, CH_SIDE_RIGHT }, // check left
13214 { CH_SIDE_RIGHT, CH_SIDE_LEFT }, // check right
13215 { CH_SIDE_BOTTOM, CH_SIDE_TOP } // check bottom
13217 static int touch_dir[4] =
13219 MV_LEFT | MV_RIGHT,
13224 int center_element = Tile[x][y]; // should always be non-moving!
13227 for (i = 0; i < NUM_DIRECTIONS; i++)
13229 int xx = x + xy[i][0];
13230 int yy = y + xy[i][1];
13231 int center_side = trigger_sides[i][0];
13232 int border_side = trigger_sides[i][1];
13233 int border_element;
13235 if (!IN_LEV_FIELD(xx, yy))
13238 if (IS_PLAYER(x, y)) // player found at center element
13240 struct PlayerInfo *player = PLAYERINFO(x, y);
13242 if (game.engine_version < VERSION_IDENT(3,0,7,0))
13243 border_element = Tile[xx][yy]; // may be moving!
13244 else if (!IS_MOVING(xx, yy) && !IS_BLOCKED(xx, yy))
13245 border_element = Tile[xx][yy];
13246 else if (MovDir[xx][yy] & touch_dir[i]) // elements are touching
13247 border_element = MovingOrBlocked2Element(xx, yy);
13249 continue; // center and border element do not touch
13251 CheckElementChangeByPlayer(xx, yy, border_element, CE_TOUCHED_BY_PLAYER,
13252 player->index_bit, border_side);
13253 CheckTriggeredElementChangeByPlayer(xx, yy, border_element,
13254 CE_PLAYER_TOUCHES_X,
13255 player->index_bit, border_side);
13258 /* use player element that is initially defined in the level playfield,
13259 not the player element that corresponds to the runtime player number
13260 (example: a level that contains EL_PLAYER_3 as the only player would
13261 incorrectly give EL_PLAYER_1 for "player->element_nr") */
13262 int player_element = PLAYERINFO(x, y)->initial_element;
13264 CheckElementChangeBySide(xx, yy, border_element, player_element,
13265 CE_TOUCHING_X, border_side);
13268 else if (IS_PLAYER(xx, yy)) // player found at border element
13270 struct PlayerInfo *player = PLAYERINFO(xx, yy);
13272 if (game.engine_version >= VERSION_IDENT(3,0,7,0))
13274 if (player->MovPos != 0 && !(player->MovDir & touch_dir[i]))
13275 continue; // center and border element do not touch
13278 CheckElementChangeByPlayer(x, y, center_element, CE_TOUCHED_BY_PLAYER,
13279 player->index_bit, center_side);
13280 CheckTriggeredElementChangeByPlayer(x, y, center_element,
13281 CE_PLAYER_TOUCHES_X,
13282 player->index_bit, center_side);
13285 /* use player element that is initially defined in the level playfield,
13286 not the player element that corresponds to the runtime player number
13287 (example: a level that contains EL_PLAYER_3 as the only player would
13288 incorrectly give EL_PLAYER_1 for "player->element_nr") */
13289 int player_element = PLAYERINFO(xx, yy)->initial_element;
13291 CheckElementChangeBySide(x, y, center_element, player_element,
13292 CE_TOUCHING_X, center_side);
13300 void TestIfElementTouchesCustomElement(int x, int y)
13302 static int xy[4][2] =
13309 static int trigger_sides[4][2] =
13311 // center side border side
13312 { CH_SIDE_TOP, CH_SIDE_BOTTOM }, // check top
13313 { CH_SIDE_LEFT, CH_SIDE_RIGHT }, // check left
13314 { CH_SIDE_RIGHT, CH_SIDE_LEFT }, // check right
13315 { CH_SIDE_BOTTOM, CH_SIDE_TOP } // check bottom
13317 static int touch_dir[4] =
13319 MV_LEFT | MV_RIGHT,
13324 boolean change_center_element = FALSE;
13325 int center_element = Tile[x][y]; // should always be non-moving!
13326 int border_element_old[NUM_DIRECTIONS];
13329 for (i = 0; i < NUM_DIRECTIONS; i++)
13331 int xx = x + xy[i][0];
13332 int yy = y + xy[i][1];
13333 int border_element;
13335 border_element_old[i] = -1;
13337 if (!IN_LEV_FIELD(xx, yy))
13340 if (game.engine_version < VERSION_IDENT(3,0,7,0))
13341 border_element = Tile[xx][yy]; // may be moving!
13342 else if (!IS_MOVING(xx, yy) && !IS_BLOCKED(xx, yy))
13343 border_element = Tile[xx][yy];
13344 else if (MovDir[xx][yy] & touch_dir[i]) // elements are touching
13345 border_element = MovingOrBlocked2Element(xx, yy);
13347 continue; // center and border element do not touch
13349 border_element_old[i] = border_element;
13352 for (i = 0; i < NUM_DIRECTIONS; i++)
13354 int xx = x + xy[i][0];
13355 int yy = y + xy[i][1];
13356 int center_side = trigger_sides[i][0];
13357 int border_element = border_element_old[i];
13359 if (border_element == -1)
13362 // check for change of border element
13363 CheckElementChangeBySide(xx, yy, border_element, center_element,
13364 CE_TOUCHING_X, center_side);
13366 // (center element cannot be player, so we dont have to check this here)
13369 for (i = 0; i < NUM_DIRECTIONS; i++)
13371 int xx = x + xy[i][0];
13372 int yy = y + xy[i][1];
13373 int border_side = trigger_sides[i][1];
13374 int border_element = border_element_old[i];
13376 if (border_element == -1)
13379 // check for change of center element (but change it only once)
13380 if (!change_center_element)
13381 change_center_element =
13382 CheckElementChangeBySide(x, y, center_element, border_element,
13383 CE_TOUCHING_X, border_side);
13385 if (IS_PLAYER(xx, yy))
13387 /* use player element that is initially defined in the level playfield,
13388 not the player element that corresponds to the runtime player number
13389 (example: a level that contains EL_PLAYER_3 as the only player would
13390 incorrectly give EL_PLAYER_1 for "player->element_nr") */
13391 int player_element = PLAYERINFO(xx, yy)->initial_element;
13393 CheckElementChangeBySide(x, y, center_element, player_element,
13394 CE_TOUCHING_X, border_side);
13399 void TestIfElementHitsCustomElement(int x, int y, int direction)
13401 int dx = (direction == MV_LEFT ? -1 : direction == MV_RIGHT ? +1 : 0);
13402 int dy = (direction == MV_UP ? -1 : direction == MV_DOWN ? +1 : 0);
13403 int hitx = x + dx, hity = y + dy;
13404 int hitting_element = Tile[x][y];
13405 int touched_element;
13407 if (IN_LEV_FIELD(hitx, hity) && IS_FREE(hitx, hity))
13410 touched_element = (IN_LEV_FIELD(hitx, hity) ?
13411 MovingOrBlocked2Element(hitx, hity) : EL_STEELWALL);
13413 if (IN_LEV_FIELD(hitx, hity))
13415 int opposite_direction = MV_DIR_OPPOSITE(direction);
13416 int hitting_side = direction;
13417 int touched_side = opposite_direction;
13418 boolean object_hit = (!IS_MOVING(hitx, hity) ||
13419 MovDir[hitx][hity] != direction ||
13420 ABS(MovPos[hitx][hity]) <= TILEY / 2);
13426 CheckElementChangeBySide(x, y, hitting_element, touched_element,
13427 CE_HITTING_X, touched_side);
13429 CheckElementChangeBySide(hitx, hity, touched_element, hitting_element,
13430 CE_HIT_BY_X, hitting_side);
13432 CheckElementChangeBySide(hitx, hity, touched_element, hitting_element,
13433 CE_HIT_BY_SOMETHING, opposite_direction);
13435 if (IS_PLAYER(hitx, hity))
13437 /* use player element that is initially defined in the level playfield,
13438 not the player element that corresponds to the runtime player number
13439 (example: a level that contains EL_PLAYER_3 as the only player would
13440 incorrectly give EL_PLAYER_1 for "player->element_nr") */
13441 int player_element = PLAYERINFO(hitx, hity)->initial_element;
13443 CheckElementChangeBySide(x, y, hitting_element, player_element,
13444 CE_HITTING_X, touched_side);
13449 // "hitting something" is also true when hitting the playfield border
13450 CheckElementChangeBySide(x, y, hitting_element, touched_element,
13451 CE_HITTING_SOMETHING, direction);
13454 void TestIfGoodThingHitsBadThing(int good_x, int good_y, int good_move_dir)
13456 int i, kill_x = -1, kill_y = -1;
13458 int bad_element = -1;
13459 static int test_xy[4][2] =
13466 static int test_dir[4] =
13474 for (i = 0; i < NUM_DIRECTIONS; i++)
13476 int test_x, test_y, test_move_dir, test_element;
13478 test_x = good_x + test_xy[i][0];
13479 test_y = good_y + test_xy[i][1];
13481 if (!IN_LEV_FIELD(test_x, test_y))
13485 (IS_MOVING(test_x, test_y) ? MovDir[test_x][test_y] : MV_NONE);
13487 test_element = MovingOrBlocked2ElementIfNotLeaving(test_x, test_y);
13489 /* 1st case: good thing is moving towards DONT_RUN_INTO style bad thing;
13490 2nd case: DONT_TOUCH style bad thing does not move away from good thing
13492 if ((DONT_RUN_INTO(test_element) && good_move_dir == test_dir[i]) ||
13493 (DONT_TOUCH(test_element) && test_move_dir != test_dir[i]))
13497 bad_element = test_element;
13503 if (kill_x != -1 || kill_y != -1)
13505 if (IS_PLAYER(good_x, good_y))
13507 struct PlayerInfo *player = PLAYERINFO(good_x, good_y);
13509 if (player->shield_deadly_time_left > 0 &&
13510 !IS_INDESTRUCTIBLE(bad_element))
13511 Bang(kill_x, kill_y);
13512 else if (!PLAYER_ENEMY_PROTECTED(good_x, good_y))
13513 KillPlayer(player);
13516 Bang(good_x, good_y);
13520 void TestIfBadThingHitsGoodThing(int bad_x, int bad_y, int bad_move_dir)
13522 int i, kill_x = -1, kill_y = -1;
13523 int bad_element = Tile[bad_x][bad_y];
13524 static int test_xy[4][2] =
13531 static int touch_dir[4] =
13533 MV_LEFT | MV_RIGHT,
13538 static int test_dir[4] =
13546 if (bad_element == EL_EXPLOSION) // skip just exploding bad things
13549 for (i = 0; i < NUM_DIRECTIONS; i++)
13551 int test_x, test_y, test_move_dir, test_element;
13553 test_x = bad_x + test_xy[i][0];
13554 test_y = bad_y + test_xy[i][1];
13556 if (!IN_LEV_FIELD(test_x, test_y))
13560 (IS_MOVING(test_x, test_y) ? MovDir[test_x][test_y] : MV_NONE);
13562 test_element = Tile[test_x][test_y];
13564 /* 1st case: good thing is moving towards DONT_RUN_INTO style bad thing;
13565 2nd case: DONT_TOUCH style bad thing does not move away from good thing
13567 if ((DONT_RUN_INTO(bad_element) && bad_move_dir == test_dir[i]) ||
13568 (DONT_TOUCH(bad_element) && test_move_dir != test_dir[i]))
13570 // good thing is player or penguin that does not move away
13571 if (IS_PLAYER(test_x, test_y))
13573 struct PlayerInfo *player = PLAYERINFO(test_x, test_y);
13575 if (bad_element == EL_ROBOT && player->is_moving)
13576 continue; // robot does not kill player if he is moving
13578 if (game.engine_version >= VERSION_IDENT(3,0,7,0))
13580 if (player->MovPos != 0 && !(player->MovDir & touch_dir[i]))
13581 continue; // center and border element do not touch
13589 else if (test_element == EL_PENGUIN)
13599 if (kill_x != -1 || kill_y != -1)
13601 if (IS_PLAYER(kill_x, kill_y))
13603 struct PlayerInfo *player = PLAYERINFO(kill_x, kill_y);
13605 if (player->shield_deadly_time_left > 0 &&
13606 !IS_INDESTRUCTIBLE(bad_element))
13607 Bang(bad_x, bad_y);
13608 else if (!PLAYER_ENEMY_PROTECTED(kill_x, kill_y))
13609 KillPlayer(player);
13612 Bang(kill_x, kill_y);
13616 void TestIfGoodThingGetsHitByBadThing(int bad_x, int bad_y, int bad_move_dir)
13618 int bad_element = Tile[bad_x][bad_y];
13619 int dx = (bad_move_dir == MV_LEFT ? -1 : bad_move_dir == MV_RIGHT ? +1 : 0);
13620 int dy = (bad_move_dir == MV_UP ? -1 : bad_move_dir == MV_DOWN ? +1 : 0);
13621 int test_x = bad_x + dx, test_y = bad_y + dy;
13622 int test_move_dir, test_element;
13623 int kill_x = -1, kill_y = -1;
13625 if (!IN_LEV_FIELD(test_x, test_y))
13629 (IS_MOVING(test_x, test_y) ? MovDir[test_x][test_y] : MV_NONE);
13631 test_element = Tile[test_x][test_y];
13633 if (test_move_dir != bad_move_dir)
13635 // good thing can be player or penguin that does not move away
13636 if (IS_PLAYER(test_x, test_y))
13638 struct PlayerInfo *player = PLAYERINFO(test_x, test_y);
13640 /* (note: in comparison to DONT_RUN_TO and DONT_TOUCH, also handle the
13641 player as being hit when he is moving towards the bad thing, because
13642 the "get hit by" condition would be lost after the player stops) */
13643 if (player->MovPos != 0 && player->MovDir == bad_move_dir)
13644 return; // player moves away from bad thing
13649 else if (test_element == EL_PENGUIN)
13656 if (kill_x != -1 || kill_y != -1)
13658 if (IS_PLAYER(kill_x, kill_y))
13660 struct PlayerInfo *player = PLAYERINFO(kill_x, kill_y);
13662 if (player->shield_deadly_time_left > 0 &&
13663 !IS_INDESTRUCTIBLE(bad_element))
13664 Bang(bad_x, bad_y);
13665 else if (!PLAYER_ENEMY_PROTECTED(kill_x, kill_y))
13666 KillPlayer(player);
13669 Bang(kill_x, kill_y);
13673 void TestIfPlayerTouchesBadThing(int x, int y)
13675 TestIfGoodThingHitsBadThing(x, y, MV_NONE);
13678 void TestIfPlayerRunsIntoBadThing(int x, int y, int move_dir)
13680 TestIfGoodThingHitsBadThing(x, y, move_dir);
13683 void TestIfBadThingTouchesPlayer(int x, int y)
13685 TestIfBadThingHitsGoodThing(x, y, MV_NONE);
13688 void TestIfBadThingRunsIntoPlayer(int x, int y, int move_dir)
13690 TestIfBadThingHitsGoodThing(x, y, move_dir);
13693 void TestIfFriendTouchesBadThing(int x, int y)
13695 TestIfGoodThingHitsBadThing(x, y, MV_NONE);
13698 void TestIfBadThingTouchesFriend(int x, int y)
13700 TestIfBadThingHitsGoodThing(x, y, MV_NONE);
13703 void TestIfBadThingTouchesOtherBadThing(int bad_x, int bad_y)
13705 int i, kill_x = bad_x, kill_y = bad_y;
13706 static int xy[4][2] =
13714 for (i = 0; i < NUM_DIRECTIONS; i++)
13718 x = bad_x + xy[i][0];
13719 y = bad_y + xy[i][1];
13720 if (!IN_LEV_FIELD(x, y))
13723 element = Tile[x][y];
13724 if (IS_AMOEBOID(element) || element == EL_GAME_OF_LIFE ||
13725 element == EL_AMOEBA_GROWING || element == EL_AMOEBA_DROP)
13733 if (kill_x != bad_x || kill_y != bad_y)
13734 Bang(bad_x, bad_y);
13737 void KillPlayer(struct PlayerInfo *player)
13739 int jx = player->jx, jy = player->jy;
13741 if (!player->active)
13745 Debug("game:playing:KillPlayer",
13746 "0: killed == %d, active == %d, reanimated == %d",
13747 player->killed, player->active, player->reanimated);
13750 /* the following code was introduced to prevent an infinite loop when calling
13752 -> CheckTriggeredElementChangeExt()
13753 -> ExecuteCustomElementAction()
13755 -> (infinitely repeating the above sequence of function calls)
13756 which occurs when killing the player while having a CE with the setting
13757 "kill player X when explosion of <player X>"; the solution using a new
13758 field "player->killed" was chosen for backwards compatibility, although
13759 clever use of the fields "player->active" etc. would probably also work */
13761 if (player->killed)
13765 player->killed = TRUE;
13767 // remove accessible field at the player's position
13768 Tile[jx][jy] = EL_EMPTY;
13770 // deactivate shield (else Bang()/Explode() would not work right)
13771 player->shield_normal_time_left = 0;
13772 player->shield_deadly_time_left = 0;
13775 Debug("game:playing:KillPlayer",
13776 "1: killed == %d, active == %d, reanimated == %d",
13777 player->killed, player->active, player->reanimated);
13783 Debug("game:playing:KillPlayer",
13784 "2: killed == %d, active == %d, reanimated == %d",
13785 player->killed, player->active, player->reanimated);
13788 if (player->reanimated) // killed player may have been reanimated
13789 player->killed = player->reanimated = FALSE;
13791 BuryPlayer(player);
13794 static void KillPlayerUnlessEnemyProtected(int x, int y)
13796 if (!PLAYER_ENEMY_PROTECTED(x, y))
13797 KillPlayer(PLAYERINFO(x, y));
13800 static void KillPlayerUnlessExplosionProtected(int x, int y)
13802 if (!PLAYER_EXPLOSION_PROTECTED(x, y))
13803 KillPlayer(PLAYERINFO(x, y));
13806 void BuryPlayer(struct PlayerInfo *player)
13808 int jx = player->jx, jy = player->jy;
13810 if (!player->active)
13813 PlayLevelSoundElementAction(jx, jy, player->artwork_element, ACTION_DYING);
13814 PlayLevelSound(jx, jy, SND_GAME_LOSING);
13816 RemovePlayer(player);
13818 player->buried = TRUE;
13820 if (game.all_players_gone)
13821 game.GameOver = TRUE;
13824 void RemovePlayer(struct PlayerInfo *player)
13826 int jx = player->jx, jy = player->jy;
13827 int i, found = FALSE;
13829 player->present = FALSE;
13830 player->active = FALSE;
13832 // required for some CE actions (even if the player is not active anymore)
13833 player->MovPos = 0;
13835 if (!ExplodeField[jx][jy])
13836 StorePlayer[jx][jy] = 0;
13838 if (player->is_moving)
13839 TEST_DrawLevelField(player->last_jx, player->last_jy);
13841 for (i = 0; i < MAX_PLAYERS; i++)
13842 if (stored_player[i].active)
13847 game.all_players_gone = TRUE;
13848 game.GameOver = TRUE;
13851 game.exit_x = game.robot_wheel_x = jx;
13852 game.exit_y = game.robot_wheel_y = jy;
13855 void ExitPlayer(struct PlayerInfo *player)
13857 DrawPlayer(player); // needed here only to cleanup last field
13858 RemovePlayer(player);
13860 if (game.players_still_needed > 0)
13861 game.players_still_needed--;
13864 static void SetFieldForSnapping(int x, int y, int element, int direction,
13865 int player_index_bit)
13867 struct ElementInfo *ei = &element_info[element];
13868 int direction_bit = MV_DIR_TO_BIT(direction);
13869 int graphic_snapping = ei->direction_graphic[ACTION_SNAPPING][direction_bit];
13870 int action = (graphic_snapping != IMG_EMPTY_SPACE ? ACTION_SNAPPING :
13871 IS_DIGGABLE(element) ? ACTION_DIGGING : ACTION_COLLECTING);
13873 Tile[x][y] = EL_ELEMENT_SNAPPING;
13874 MovDelay[x][y] = MOVE_DELAY_NORMAL_SPEED + 1 - 1;
13875 MovDir[x][y] = direction;
13876 Store[x][y] = element;
13877 Store2[x][y] = player_index_bit;
13879 ResetGfxAnimation(x, y);
13881 GfxElement[x][y] = element;
13882 GfxAction[x][y] = action;
13883 GfxDir[x][y] = direction;
13884 GfxFrame[x][y] = -1;
13887 static void TestFieldAfterSnapping(int x, int y, int element, int direction,
13888 int player_index_bit)
13890 TestIfElementTouchesCustomElement(x, y); // for empty space
13892 if (level.finish_dig_collect)
13894 int dig_side = MV_DIR_OPPOSITE(direction);
13896 CheckTriggeredElementChangeByPlayer(x, y, element, CE_PLAYER_SNAPS_X,
13897 player_index_bit, dig_side);
13902 =============================================================================
13903 checkDiagonalPushing()
13904 -----------------------------------------------------------------------------
13905 check if diagonal input device direction results in pushing of object
13906 (by checking if the alternative direction is walkable, diggable, ...)
13907 =============================================================================
13910 static boolean checkDiagonalPushing(struct PlayerInfo *player,
13911 int x, int y, int real_dx, int real_dy)
13913 int jx, jy, dx, dy, xx, yy;
13915 if (real_dx == 0 || real_dy == 0) // no diagonal direction => push
13918 // diagonal direction: check alternative direction
13923 xx = jx + (dx == 0 ? real_dx : 0);
13924 yy = jy + (dy == 0 ? real_dy : 0);
13926 return (!IN_LEV_FIELD(xx, yy) || IS_SOLID_FOR_PUSHING(Tile[xx][yy]));
13930 =============================================================================
13932 -----------------------------------------------------------------------------
13933 x, y: field next to player (non-diagonal) to try to dig to
13934 real_dx, real_dy: direction as read from input device (can be diagonal)
13935 =============================================================================
13938 static int DigField(struct PlayerInfo *player,
13939 int oldx, int oldy, int x, int y,
13940 int real_dx, int real_dy, int mode)
13942 boolean is_player = (IS_PLAYER(oldx, oldy) || mode != DF_DIG);
13943 boolean player_was_pushing = player->is_pushing;
13944 boolean player_can_move = (!player->cannot_move && mode != DF_SNAP);
13945 boolean player_can_move_or_snap = (!player->cannot_move || mode == DF_SNAP);
13946 int jx = oldx, jy = oldy;
13947 int dx = x - jx, dy = y - jy;
13948 int nextx = x + dx, nexty = y + dy;
13949 int move_direction = (dx == -1 ? MV_LEFT :
13950 dx == +1 ? MV_RIGHT :
13952 dy == +1 ? MV_DOWN : MV_NONE);
13953 int opposite_direction = MV_DIR_OPPOSITE(move_direction);
13954 int dig_side = MV_DIR_OPPOSITE(move_direction);
13955 int old_element = Tile[jx][jy];
13956 int element = MovingOrBlocked2ElementIfNotLeaving(x, y);
13959 if (is_player) // function can also be called by EL_PENGUIN
13961 if (player->MovPos == 0)
13963 player->is_digging = FALSE;
13964 player->is_collecting = FALSE;
13967 if (player->MovPos == 0) // last pushing move finished
13968 player->is_pushing = FALSE;
13970 if (mode == DF_NO_PUSH) // player just stopped pushing
13972 player->is_switching = FALSE;
13973 player->push_delay = -1;
13975 return MP_NO_ACTION;
13979 if (IS_TUBE(Back[jx][jy]) && game.engine_version >= VERSION_IDENT(2,2,0,0))
13980 old_element = Back[jx][jy];
13982 // in case of element dropped at player position, check background
13983 else if (Back[jx][jy] != EL_EMPTY &&
13984 game.engine_version >= VERSION_IDENT(2,2,0,0))
13985 old_element = Back[jx][jy];
13987 if (IS_WALKABLE(old_element) && !ACCESS_FROM(old_element, move_direction))
13988 return MP_NO_ACTION; // field has no opening in this direction
13990 if (IS_PASSABLE(old_element) && !ACCESS_FROM(old_element,opposite_direction))
13991 return MP_NO_ACTION; // field has no opening in this direction
13993 if (player_can_move && element == EL_ACID && move_direction == MV_DOWN)
13997 Tile[jx][jy] = player->artwork_element;
13998 InitMovingField(jx, jy, MV_DOWN);
13999 Store[jx][jy] = EL_ACID;
14000 ContinueMoving(jx, jy);
14001 BuryPlayer(player);
14003 return MP_DONT_RUN_INTO;
14006 if (player_can_move && DONT_RUN_INTO(element))
14008 TestIfPlayerRunsIntoBadThing(jx, jy, player->MovDir);
14010 return MP_DONT_RUN_INTO;
14013 if (IS_MOVING(x, y) || IS_PLAYER(x, y))
14014 return MP_NO_ACTION;
14016 collect_count = element_info[element].collect_count_initial;
14018 if (!is_player && !IS_COLLECTIBLE(element)) // penguin cannot collect it
14019 return MP_NO_ACTION;
14021 if (game.engine_version < VERSION_IDENT(2,2,0,0))
14022 player_can_move = player_can_move_or_snap;
14024 if (mode == DF_SNAP && !IS_SNAPPABLE(element) &&
14025 game.engine_version >= VERSION_IDENT(2,2,0,0))
14027 CheckElementChangeByPlayer(x, y, element, CE_SNAPPED_BY_PLAYER,
14028 player->index_bit, dig_side);
14029 CheckTriggeredElementChangeByPlayer(x, y, element, CE_PLAYER_SNAPS_X,
14030 player->index_bit, dig_side);
14032 if (element == EL_DC_LANDMINE)
14035 if (Tile[x][y] != element) // field changed by snapping
14038 return MP_NO_ACTION;
14041 if (player->gravity && is_player && !player->is_auto_moving &&
14042 canFallDown(player) && move_direction != MV_DOWN &&
14043 !canMoveToValidFieldWithGravity(jx, jy, move_direction))
14044 return MP_NO_ACTION; // player cannot walk here due to gravity
14046 if (player_can_move &&
14047 IS_WALKABLE(element) && ACCESS_FROM(element, opposite_direction))
14049 int sound_element = SND_ELEMENT(element);
14050 int sound_action = ACTION_WALKING;
14052 if (IS_RND_GATE(element))
14054 if (!player->key[RND_GATE_NR(element)])
14055 return MP_NO_ACTION;
14057 else if (IS_RND_GATE_GRAY(element))
14059 if (!player->key[RND_GATE_GRAY_NR(element)])
14060 return MP_NO_ACTION;
14062 else if (IS_RND_GATE_GRAY_ACTIVE(element))
14064 if (!player->key[RND_GATE_GRAY_ACTIVE_NR(element)])
14065 return MP_NO_ACTION;
14067 else if (element == EL_EXIT_OPEN ||
14068 element == EL_EM_EXIT_OPEN ||
14069 element == EL_EM_EXIT_OPENING ||
14070 element == EL_STEEL_EXIT_OPEN ||
14071 element == EL_EM_STEEL_EXIT_OPEN ||
14072 element == EL_EM_STEEL_EXIT_OPENING ||
14073 element == EL_SP_EXIT_OPEN ||
14074 element == EL_SP_EXIT_OPENING)
14076 sound_action = ACTION_PASSING; // player is passing exit
14078 else if (element == EL_EMPTY)
14080 sound_action = ACTION_MOVING; // nothing to walk on
14083 // play sound from background or player, whatever is available
14084 if (element_info[sound_element].sound[sound_action] != SND_UNDEFINED)
14085 PlayLevelSoundElementAction(x, y, sound_element, sound_action);
14087 PlayLevelSoundElementAction(x, y, player->artwork_element, sound_action);
14089 else if (player_can_move &&
14090 IS_PASSABLE(element) && canPassField(x, y, move_direction))
14092 if (!ACCESS_FROM(element, opposite_direction))
14093 return MP_NO_ACTION; // field not accessible from this direction
14095 if (CAN_MOVE(element)) // only fixed elements can be passed!
14096 return MP_NO_ACTION;
14098 if (IS_EM_GATE(element))
14100 if (!player->key[EM_GATE_NR(element)])
14101 return MP_NO_ACTION;
14103 else if (IS_EM_GATE_GRAY(element))
14105 if (!player->key[EM_GATE_GRAY_NR(element)])
14106 return MP_NO_ACTION;
14108 else if (IS_EM_GATE_GRAY_ACTIVE(element))
14110 if (!player->key[EM_GATE_GRAY_ACTIVE_NR(element)])
14111 return MP_NO_ACTION;
14113 else if (IS_EMC_GATE(element))
14115 if (!player->key[EMC_GATE_NR(element)])
14116 return MP_NO_ACTION;
14118 else if (IS_EMC_GATE_GRAY(element))
14120 if (!player->key[EMC_GATE_GRAY_NR(element)])
14121 return MP_NO_ACTION;
14123 else if (IS_EMC_GATE_GRAY_ACTIVE(element))
14125 if (!player->key[EMC_GATE_GRAY_ACTIVE_NR(element)])
14126 return MP_NO_ACTION;
14128 else if (element == EL_DC_GATE_WHITE ||
14129 element == EL_DC_GATE_WHITE_GRAY ||
14130 element == EL_DC_GATE_WHITE_GRAY_ACTIVE)
14132 if (player->num_white_keys == 0)
14133 return MP_NO_ACTION;
14135 player->num_white_keys--;
14137 else if (IS_SP_PORT(element))
14139 if (element == EL_SP_GRAVITY_PORT_LEFT ||
14140 element == EL_SP_GRAVITY_PORT_RIGHT ||
14141 element == EL_SP_GRAVITY_PORT_UP ||
14142 element == EL_SP_GRAVITY_PORT_DOWN)
14143 player->gravity = !player->gravity;
14144 else if (element == EL_SP_GRAVITY_ON_PORT_LEFT ||
14145 element == EL_SP_GRAVITY_ON_PORT_RIGHT ||
14146 element == EL_SP_GRAVITY_ON_PORT_UP ||
14147 element == EL_SP_GRAVITY_ON_PORT_DOWN)
14148 player->gravity = TRUE;
14149 else if (element == EL_SP_GRAVITY_OFF_PORT_LEFT ||
14150 element == EL_SP_GRAVITY_OFF_PORT_RIGHT ||
14151 element == EL_SP_GRAVITY_OFF_PORT_UP ||
14152 element == EL_SP_GRAVITY_OFF_PORT_DOWN)
14153 player->gravity = FALSE;
14156 // automatically move to the next field with double speed
14157 player->programmed_action = move_direction;
14159 if (player->move_delay_reset_counter == 0)
14161 player->move_delay_reset_counter = 2; // two double speed steps
14163 DOUBLE_PLAYER_SPEED(player);
14166 PlayLevelSoundAction(x, y, ACTION_PASSING);
14168 else if (player_can_move_or_snap && IS_DIGGABLE(element))
14172 if (mode != DF_SNAP)
14174 GfxElement[x][y] = GFX_ELEMENT(element);
14175 player->is_digging = TRUE;
14178 PlayLevelSoundElementAction(x, y, element, ACTION_DIGGING);
14180 // use old behaviour for old levels (digging)
14181 if (!level.finish_dig_collect)
14183 CheckTriggeredElementChangeByPlayer(x, y, element, CE_PLAYER_DIGS_X,
14184 player->index_bit, dig_side);
14186 // if digging triggered player relocation, finish digging tile
14187 if (mode == DF_DIG && (player->jx != jx || player->jy != jy))
14188 SetFieldForSnapping(x, y, element, move_direction, player->index_bit);
14191 if (mode == DF_SNAP)
14193 if (level.block_snap_field)
14194 SetFieldForSnapping(x, y, element, move_direction, player->index_bit);
14196 TestFieldAfterSnapping(x, y, element, move_direction, player->index_bit);
14198 // use old behaviour for old levels (snapping)
14199 if (!level.finish_dig_collect)
14200 CheckTriggeredElementChangeByPlayer(x, y, element, CE_PLAYER_SNAPS_X,
14201 player->index_bit, dig_side);
14204 else if (player_can_move_or_snap && IS_COLLECTIBLE(element))
14208 if (is_player && mode != DF_SNAP)
14210 GfxElement[x][y] = element;
14211 player->is_collecting = TRUE;
14214 if (element == EL_SPEED_PILL)
14216 player->move_delay_value = MOVE_DELAY_HIGH_SPEED;
14218 else if (element == EL_EXTRA_TIME && level.time > 0)
14220 TimeLeft += level.extra_time;
14222 game_panel_controls[GAME_PANEL_TIME].value = TimeLeft;
14224 DisplayGameControlValues();
14226 else if (element == EL_SHIELD_NORMAL || element == EL_SHIELD_DEADLY)
14228 player->shield_normal_time_left += level.shield_normal_time;
14229 if (element == EL_SHIELD_DEADLY)
14230 player->shield_deadly_time_left += level.shield_deadly_time;
14232 else if (element == EL_DYNAMITE ||
14233 element == EL_EM_DYNAMITE ||
14234 element == EL_SP_DISK_RED)
14236 if (player->inventory_size < MAX_INVENTORY_SIZE)
14237 player->inventory_element[player->inventory_size++] = element;
14239 DrawGameDoorValues();
14241 else if (element == EL_DYNABOMB_INCREASE_NUMBER)
14243 player->dynabomb_count++;
14244 player->dynabombs_left++;
14246 else if (element == EL_DYNABOMB_INCREASE_SIZE)
14248 player->dynabomb_size++;
14250 else if (element == EL_DYNABOMB_INCREASE_POWER)
14252 player->dynabomb_xl = TRUE;
14254 else if (IS_KEY(element))
14256 player->key[KEY_NR(element)] = TRUE;
14258 DrawGameDoorValues();
14260 else if (element == EL_DC_KEY_WHITE)
14262 player->num_white_keys++;
14264 // display white keys?
14265 // DrawGameDoorValues();
14267 else if (IS_ENVELOPE(element))
14269 player->show_envelope = element;
14271 else if (element == EL_EMC_LENSES)
14273 game.lenses_time_left = level.lenses_time * FRAMES_PER_SECOND;
14275 RedrawAllInvisibleElementsForLenses();
14277 else if (element == EL_EMC_MAGNIFIER)
14279 game.magnify_time_left = level.magnify_time * FRAMES_PER_SECOND;
14281 RedrawAllInvisibleElementsForMagnifier();
14283 else if (IS_DROPPABLE(element) ||
14284 IS_THROWABLE(element)) // can be collected and dropped
14288 if (collect_count == 0)
14289 player->inventory_infinite_element = element;
14291 for (i = 0; i < collect_count; i++)
14292 if (player->inventory_size < MAX_INVENTORY_SIZE)
14293 player->inventory_element[player->inventory_size++] = element;
14295 DrawGameDoorValues();
14297 else if (collect_count > 0)
14299 game.gems_still_needed -= collect_count;
14300 if (game.gems_still_needed < 0)
14301 game.gems_still_needed = 0;
14303 game.snapshot.collected_item = TRUE;
14305 game_panel_controls[GAME_PANEL_GEMS].value = game.gems_still_needed;
14307 DisplayGameControlValues();
14310 RaiseScoreElement(element);
14311 PlayLevelSoundElementAction(x, y, element, ACTION_COLLECTING);
14313 // use old behaviour for old levels (collecting)
14314 if (!level.finish_dig_collect && is_player)
14316 CheckTriggeredElementChangeByPlayer(x, y, element, CE_PLAYER_COLLECTS_X,
14317 player->index_bit, dig_side);
14319 // if collecting triggered player relocation, finish collecting tile
14320 if (mode == DF_DIG && (player->jx != jx || player->jy != jy))
14321 SetFieldForSnapping(x, y, element, move_direction, player->index_bit);
14324 if (mode == DF_SNAP)
14326 if (level.block_snap_field)
14327 SetFieldForSnapping(x, y, element, move_direction, player->index_bit);
14329 TestFieldAfterSnapping(x, y, element, move_direction, player->index_bit);
14331 // use old behaviour for old levels (snapping)
14332 if (!level.finish_dig_collect)
14333 CheckTriggeredElementChangeByPlayer(x, y, element, CE_PLAYER_SNAPS_X,
14334 player->index_bit, dig_side);
14337 else if (player_can_move_or_snap && IS_PUSHABLE(element))
14339 if (mode == DF_SNAP && element != EL_BD_ROCK)
14340 return MP_NO_ACTION;
14342 if (CAN_FALL(element) && dy)
14343 return MP_NO_ACTION;
14345 if (CAN_FALL(element) && IN_LEV_FIELD(x, y + 1) && IS_FREE(x, y + 1) &&
14346 !(element == EL_SPRING && level.use_spring_bug))
14347 return MP_NO_ACTION;
14349 if (CAN_MOVE(element) && GET_MAX_MOVE_DELAY(element) == 0 &&
14350 ((move_direction & MV_VERTICAL &&
14351 ((element_info[element].move_pattern & MV_LEFT &&
14352 IN_LEV_FIELD(x - 1, y) && IS_FREE(x - 1, y)) ||
14353 (element_info[element].move_pattern & MV_RIGHT &&
14354 IN_LEV_FIELD(x + 1, y) && IS_FREE(x + 1, y)))) ||
14355 (move_direction & MV_HORIZONTAL &&
14356 ((element_info[element].move_pattern & MV_UP &&
14357 IN_LEV_FIELD(x, y - 1) && IS_FREE(x, y - 1)) ||
14358 (element_info[element].move_pattern & MV_DOWN &&
14359 IN_LEV_FIELD(x, y + 1) && IS_FREE(x, y + 1))))))
14360 return MP_NO_ACTION;
14362 // do not push elements already moving away faster than player
14363 if (CAN_MOVE(element) && MovDir[x][y] == move_direction &&
14364 ABS(getElementMoveStepsize(x, y)) > MOVE_STEPSIZE_NORMAL)
14365 return MP_NO_ACTION;
14367 if (game.engine_version >= VERSION_IDENT(3,1,0,0))
14369 if (player->push_delay_value == -1 || !player_was_pushing)
14370 player->push_delay_value = GET_NEW_PUSH_DELAY(element);
14372 else if (game.engine_version >= VERSION_IDENT(3,0,7,1))
14374 if (player->push_delay_value == -1)
14375 player->push_delay_value = GET_NEW_PUSH_DELAY(element);
14377 else if (game.engine_version >= VERSION_IDENT(2,2,0,7))
14379 if (!player->is_pushing)
14380 player->push_delay_value = GET_NEW_PUSH_DELAY(element);
14383 player->is_pushing = TRUE;
14384 player->is_active = TRUE;
14386 if (!(IN_LEV_FIELD(nextx, nexty) &&
14387 (IS_FREE(nextx, nexty) ||
14388 (IS_SB_ELEMENT(element) &&
14389 Tile[nextx][nexty] == EL_SOKOBAN_FIELD_EMPTY) ||
14390 (IS_CUSTOM_ELEMENT(element) &&
14391 CUSTOM_ELEMENT_CAN_ENTER_FIELD(element, nextx, nexty)))))
14392 return MP_NO_ACTION;
14394 if (!checkDiagonalPushing(player, x, y, real_dx, real_dy))
14395 return MP_NO_ACTION;
14397 if (player->push_delay == -1) // new pushing; restart delay
14398 player->push_delay = 0;
14400 if (player->push_delay < player->push_delay_value &&
14401 !(tape.playing && tape.file_version < FILE_VERSION_2_0) &&
14402 element != EL_SPRING && element != EL_BALLOON)
14404 // make sure that there is no move delay before next try to push
14405 if (game.engine_version >= VERSION_IDENT(3,0,7,1))
14406 player->move_delay = 0;
14408 return MP_NO_ACTION;
14411 if (IS_CUSTOM_ELEMENT(element) &&
14412 CUSTOM_ELEMENT_CAN_ENTER_FIELD(element, nextx, nexty))
14414 if (!DigFieldByCE(nextx, nexty, element))
14415 return MP_NO_ACTION;
14418 if (IS_SB_ELEMENT(element))
14420 boolean sokoban_task_solved = FALSE;
14422 if (element == EL_SOKOBAN_FIELD_FULL)
14424 Back[x][y] = EL_SOKOBAN_FIELD_EMPTY;
14426 IncrementSokobanFieldsNeeded();
14427 IncrementSokobanObjectsNeeded();
14430 if (Tile[nextx][nexty] == EL_SOKOBAN_FIELD_EMPTY)
14432 Back[nextx][nexty] = EL_SOKOBAN_FIELD_EMPTY;
14434 DecrementSokobanFieldsNeeded();
14435 DecrementSokobanObjectsNeeded();
14437 // sokoban object was pushed from empty field to sokoban field
14438 if (Back[x][y] == EL_EMPTY)
14439 sokoban_task_solved = TRUE;
14442 Tile[x][y] = EL_SOKOBAN_OBJECT;
14444 if (Back[x][y] == Back[nextx][nexty])
14445 PlayLevelSoundAction(x, y, ACTION_PUSHING);
14446 else if (Back[x][y] != 0)
14447 PlayLevelSoundElementAction(x, y, EL_SOKOBAN_FIELD_FULL,
14450 PlayLevelSoundElementAction(nextx, nexty, EL_SOKOBAN_FIELD_EMPTY,
14453 if (sokoban_task_solved &&
14454 game.sokoban_fields_still_needed == 0 &&
14455 game.sokoban_objects_still_needed == 0 &&
14456 (game.emulation == EMU_SOKOBAN || level.auto_exit_sokoban))
14458 game.players_still_needed = 0;
14462 PlayLevelSound(x, y, SND_GAME_SOKOBAN_SOLVING);
14466 PlayLevelSoundElementAction(x, y, element, ACTION_PUSHING);
14468 InitMovingField(x, y, move_direction);
14469 GfxAction[x][y] = ACTION_PUSHING;
14471 if (mode == DF_SNAP)
14472 ContinueMoving(x, y);
14474 MovPos[x][y] = (dx != 0 ? dx : dy);
14476 Pushed[x][y] = TRUE;
14477 Pushed[nextx][nexty] = TRUE;
14479 if (game.engine_version < VERSION_IDENT(2,2,0,7))
14480 player->push_delay_value = GET_NEW_PUSH_DELAY(element);
14482 player->push_delay_value = -1; // get new value later
14484 // check for element change _after_ element has been pushed
14485 if (game.use_change_when_pushing_bug)
14487 CheckElementChangeByPlayer(x, y, element, CE_PUSHED_BY_PLAYER,
14488 player->index_bit, dig_side);
14489 CheckTriggeredElementChangeByPlayer(x, y, element, CE_PLAYER_PUSHES_X,
14490 player->index_bit, dig_side);
14493 else if (IS_SWITCHABLE(element))
14495 if (PLAYER_SWITCHING(player, x, y))
14497 CheckTriggeredElementChangeByPlayer(x, y, element, CE_PLAYER_PRESSES_X,
14498 player->index_bit, dig_side);
14503 player->is_switching = TRUE;
14504 player->switch_x = x;
14505 player->switch_y = y;
14507 PlayLevelSoundElementAction(x, y, element, ACTION_ACTIVATING);
14509 if (element == EL_ROBOT_WHEEL)
14511 Tile[x][y] = EL_ROBOT_WHEEL_ACTIVE;
14513 game.robot_wheel_x = x;
14514 game.robot_wheel_y = y;
14515 game.robot_wheel_active = TRUE;
14517 TEST_DrawLevelField(x, y);
14519 else if (element == EL_SP_TERMINAL)
14523 SCAN_PLAYFIELD(xx, yy)
14525 if (Tile[xx][yy] == EL_SP_DISK_YELLOW)
14529 else if (Tile[xx][yy] == EL_SP_TERMINAL)
14531 Tile[xx][yy] = EL_SP_TERMINAL_ACTIVE;
14533 ResetGfxAnimation(xx, yy);
14534 TEST_DrawLevelField(xx, yy);
14538 else if (IS_BELT_SWITCH(element))
14540 ToggleBeltSwitch(x, y);
14542 else if (element == EL_SWITCHGATE_SWITCH_UP ||
14543 element == EL_SWITCHGATE_SWITCH_DOWN ||
14544 element == EL_DC_SWITCHGATE_SWITCH_UP ||
14545 element == EL_DC_SWITCHGATE_SWITCH_DOWN)
14547 ToggleSwitchgateSwitch(x, y);
14549 else if (element == EL_LIGHT_SWITCH ||
14550 element == EL_LIGHT_SWITCH_ACTIVE)
14552 ToggleLightSwitch(x, y);
14554 else if (element == EL_TIMEGATE_SWITCH ||
14555 element == EL_DC_TIMEGATE_SWITCH)
14557 ActivateTimegateSwitch(x, y);
14559 else if (element == EL_BALLOON_SWITCH_LEFT ||
14560 element == EL_BALLOON_SWITCH_RIGHT ||
14561 element == EL_BALLOON_SWITCH_UP ||
14562 element == EL_BALLOON_SWITCH_DOWN ||
14563 element == EL_BALLOON_SWITCH_NONE ||
14564 element == EL_BALLOON_SWITCH_ANY)
14566 game.wind_direction = (element == EL_BALLOON_SWITCH_LEFT ? MV_LEFT :
14567 element == EL_BALLOON_SWITCH_RIGHT ? MV_RIGHT :
14568 element == EL_BALLOON_SWITCH_UP ? MV_UP :
14569 element == EL_BALLOON_SWITCH_DOWN ? MV_DOWN :
14570 element == EL_BALLOON_SWITCH_NONE ? MV_NONE :
14573 else if (element == EL_LAMP)
14575 Tile[x][y] = EL_LAMP_ACTIVE;
14576 game.lights_still_needed--;
14578 ResetGfxAnimation(x, y);
14579 TEST_DrawLevelField(x, y);
14581 else if (element == EL_TIME_ORB_FULL)
14583 Tile[x][y] = EL_TIME_ORB_EMPTY;
14585 if (level.time > 0 || level.use_time_orb_bug)
14587 TimeLeft += level.time_orb_time;
14588 game.no_time_limit = FALSE;
14590 game_panel_controls[GAME_PANEL_TIME].value = TimeLeft;
14592 DisplayGameControlValues();
14595 ResetGfxAnimation(x, y);
14596 TEST_DrawLevelField(x, y);
14598 else if (element == EL_EMC_MAGIC_BALL_SWITCH ||
14599 element == EL_EMC_MAGIC_BALL_SWITCH_ACTIVE)
14603 game.ball_active = !game.ball_active;
14605 SCAN_PLAYFIELD(xx, yy)
14607 int e = Tile[xx][yy];
14609 if (game.ball_active)
14611 if (e == EL_EMC_MAGIC_BALL)
14612 CreateField(xx, yy, EL_EMC_MAGIC_BALL_ACTIVE);
14613 else if (e == EL_EMC_MAGIC_BALL_SWITCH)
14614 CreateField(xx, yy, EL_EMC_MAGIC_BALL_SWITCH_ACTIVE);
14618 if (e == EL_EMC_MAGIC_BALL_ACTIVE)
14619 CreateField(xx, yy, EL_EMC_MAGIC_BALL);
14620 else if (e == EL_EMC_MAGIC_BALL_SWITCH_ACTIVE)
14621 CreateField(xx, yy, EL_EMC_MAGIC_BALL_SWITCH);
14626 CheckTriggeredElementChangeByPlayer(x, y, element, CE_SWITCH_OF_X,
14627 player->index_bit, dig_side);
14629 CheckTriggeredElementChangeByPlayer(x, y, element, CE_PLAYER_SWITCHES_X,
14630 player->index_bit, dig_side);
14632 CheckTriggeredElementChangeByPlayer(x, y, element, CE_PLAYER_PRESSES_X,
14633 player->index_bit, dig_side);
14639 if (!PLAYER_SWITCHING(player, x, y))
14641 player->is_switching = TRUE;
14642 player->switch_x = x;
14643 player->switch_y = y;
14645 CheckElementChangeByPlayer(x, y, element, CE_SWITCHED,
14646 player->index_bit, dig_side);
14647 CheckTriggeredElementChangeByPlayer(x, y, element, CE_SWITCH_OF_X,
14648 player->index_bit, dig_side);
14650 CheckElementChangeByPlayer(x, y, element, CE_SWITCHED_BY_PLAYER,
14651 player->index_bit, dig_side);
14652 CheckTriggeredElementChangeByPlayer(x, y, element, CE_PLAYER_SWITCHES_X,
14653 player->index_bit, dig_side);
14656 CheckElementChangeByPlayer(x, y, element, CE_PRESSED_BY_PLAYER,
14657 player->index_bit, dig_side);
14658 CheckTriggeredElementChangeByPlayer(x, y, element, CE_PLAYER_PRESSES_X,
14659 player->index_bit, dig_side);
14661 return MP_NO_ACTION;
14664 player->push_delay = -1;
14666 if (is_player) // function can also be called by EL_PENGUIN
14668 if (Tile[x][y] != element) // really digged/collected something
14670 player->is_collecting = !player->is_digging;
14671 player->is_active = TRUE;
14673 player->last_removed_element = element;
14680 static boolean DigFieldByCE(int x, int y, int digging_element)
14682 int element = Tile[x][y];
14684 if (!IS_FREE(x, y))
14686 int action = (IS_DIGGABLE(element) ? ACTION_DIGGING :
14687 IS_COLLECTIBLE(element) ? ACTION_COLLECTING :
14690 // no element can dig solid indestructible elements
14691 if (IS_INDESTRUCTIBLE(element) &&
14692 !IS_DIGGABLE(element) &&
14693 !IS_COLLECTIBLE(element))
14696 if (AmoebaNr[x][y] &&
14697 (element == EL_AMOEBA_FULL ||
14698 element == EL_BD_AMOEBA ||
14699 element == EL_AMOEBA_GROWING))
14701 AmoebaCnt[AmoebaNr[x][y]]--;
14702 AmoebaCnt2[AmoebaNr[x][y]]--;
14705 if (IS_MOVING(x, y))
14706 RemoveMovingField(x, y);
14710 TEST_DrawLevelField(x, y);
14713 // if digged element was about to explode, prevent the explosion
14714 ExplodeField[x][y] = EX_TYPE_NONE;
14716 PlayLevelSoundAction(x, y, action);
14719 Store[x][y] = EL_EMPTY;
14721 // this makes it possible to leave the removed element again
14722 if (IS_EQUAL_OR_IN_GROUP(element, MOVE_ENTER_EL(digging_element)))
14723 Store[x][y] = element;
14728 static boolean SnapField(struct PlayerInfo *player, int dx, int dy)
14730 int jx = player->jx, jy = player->jy;
14731 int x = jx + dx, y = jy + dy;
14732 int snap_direction = (dx == -1 ? MV_LEFT :
14733 dx == +1 ? MV_RIGHT :
14735 dy == +1 ? MV_DOWN : MV_NONE);
14736 boolean can_continue_snapping = (level.continuous_snapping &&
14737 WasJustFalling[x][y] < CHECK_DELAY_FALLING);
14739 if (player->MovPos != 0 && game.engine_version >= VERSION_IDENT(2,2,0,0))
14742 if (!player->active || !IN_LEV_FIELD(x, y))
14750 if (player->MovPos == 0)
14751 player->is_pushing = FALSE;
14753 player->is_snapping = FALSE;
14755 if (player->MovPos == 0)
14757 player->is_moving = FALSE;
14758 player->is_digging = FALSE;
14759 player->is_collecting = FALSE;
14765 // prevent snapping with already pressed snap key when not allowed
14766 if (player->is_snapping && !can_continue_snapping)
14769 player->MovDir = snap_direction;
14771 if (player->MovPos == 0)
14773 player->is_moving = FALSE;
14774 player->is_digging = FALSE;
14775 player->is_collecting = FALSE;
14778 player->is_dropping = FALSE;
14779 player->is_dropping_pressed = FALSE;
14780 player->drop_pressed_delay = 0;
14782 if (DigField(player, jx, jy, x, y, 0, 0, DF_SNAP) == MP_NO_ACTION)
14785 player->is_snapping = TRUE;
14786 player->is_active = TRUE;
14788 if (player->MovPos == 0)
14790 player->is_moving = FALSE;
14791 player->is_digging = FALSE;
14792 player->is_collecting = FALSE;
14795 if (player->MovPos != 0) // prevent graphic bugs in versions < 2.2.0
14796 TEST_DrawLevelField(player->last_jx, player->last_jy);
14798 TEST_DrawLevelField(x, y);
14803 static boolean DropElement(struct PlayerInfo *player)
14805 int old_element, new_element;
14806 int dropx = player->jx, dropy = player->jy;
14807 int drop_direction = player->MovDir;
14808 int drop_side = drop_direction;
14809 int drop_element = get_next_dropped_element(player);
14811 /* do not drop an element on top of another element; when holding drop key
14812 pressed without moving, dropped element must move away before the next
14813 element can be dropped (this is especially important if the next element
14814 is dynamite, which can be placed on background for historical reasons) */
14815 if (PLAYER_DROPPING(player, dropx, dropy) && Tile[dropx][dropy] != EL_EMPTY)
14818 if (IS_THROWABLE(drop_element))
14820 dropx += GET_DX_FROM_DIR(drop_direction);
14821 dropy += GET_DY_FROM_DIR(drop_direction);
14823 if (!IN_LEV_FIELD(dropx, dropy))
14827 old_element = Tile[dropx][dropy]; // old element at dropping position
14828 new_element = drop_element; // default: no change when dropping
14830 // check if player is active, not moving and ready to drop
14831 if (!player->active || player->MovPos || player->drop_delay > 0)
14834 // check if player has anything that can be dropped
14835 if (new_element == EL_UNDEFINED)
14838 // only set if player has anything that can be dropped
14839 player->is_dropping_pressed = TRUE;
14841 // check if drop key was pressed long enough for EM style dynamite
14842 if (new_element == EL_EM_DYNAMITE && player->drop_pressed_delay < 40)
14845 // check if anything can be dropped at the current position
14846 if (IS_ACTIVE_BOMB(old_element) || old_element == EL_EXPLOSION)
14849 // collected custom elements can only be dropped on empty fields
14850 if (IS_CUSTOM_ELEMENT(new_element) && old_element != EL_EMPTY)
14853 if (old_element != EL_EMPTY)
14854 Back[dropx][dropy] = old_element; // store old element on this field
14856 ResetGfxAnimation(dropx, dropy);
14857 ResetRandomAnimationValue(dropx, dropy);
14859 if (player->inventory_size > 0 ||
14860 player->inventory_infinite_element != EL_UNDEFINED)
14862 if (player->inventory_size > 0)
14864 player->inventory_size--;
14866 DrawGameDoorValues();
14868 if (new_element == EL_DYNAMITE)
14869 new_element = EL_DYNAMITE_ACTIVE;
14870 else if (new_element == EL_EM_DYNAMITE)
14871 new_element = EL_EM_DYNAMITE_ACTIVE;
14872 else if (new_element == EL_SP_DISK_RED)
14873 new_element = EL_SP_DISK_RED_ACTIVE;
14876 Tile[dropx][dropy] = new_element;
14878 if (IN_SCR_FIELD(SCREENX(dropx), SCREENY(dropy)))
14879 DrawGraphicThruMask(SCREENX(dropx), SCREENY(dropy),
14880 el2img(Tile[dropx][dropy]), 0);
14882 PlayLevelSoundAction(dropx, dropy, ACTION_DROPPING);
14884 // needed if previous element just changed to "empty" in the last frame
14885 ChangeCount[dropx][dropy] = 0; // allow at least one more change
14887 CheckElementChangeByPlayer(dropx, dropy, new_element, CE_DROPPED_BY_PLAYER,
14888 player->index_bit, drop_side);
14889 CheckTriggeredElementChangeByPlayer(dropx, dropy, new_element,
14891 player->index_bit, drop_side);
14893 TestIfElementTouchesCustomElement(dropx, dropy);
14895 else // player is dropping a dyna bomb
14897 player->dynabombs_left--;
14899 Tile[dropx][dropy] = new_element;
14901 if (IN_SCR_FIELD(SCREENX(dropx), SCREENY(dropy)))
14902 DrawGraphicThruMask(SCREENX(dropx), SCREENY(dropy),
14903 el2img(Tile[dropx][dropy]), 0);
14905 PlayLevelSoundAction(dropx, dropy, ACTION_DROPPING);
14908 if (Tile[dropx][dropy] == new_element) // uninitialized unless CE change
14909 InitField_WithBug1(dropx, dropy, FALSE);
14911 new_element = Tile[dropx][dropy]; // element might have changed
14913 if (IS_CUSTOM_ELEMENT(new_element) && CAN_MOVE(new_element) &&
14914 element_info[new_element].move_pattern == MV_WHEN_DROPPED)
14916 if (element_info[new_element].move_direction_initial == MV_START_AUTOMATIC)
14917 MovDir[dropx][dropy] = drop_direction;
14919 ChangeCount[dropx][dropy] = 0; // allow at least one more change
14921 // do not cause impact style collision by dropping elements that can fall
14922 CheckCollision[dropx][dropy] = CHECK_DELAY_COLLISION;
14925 player->drop_delay = GET_NEW_DROP_DELAY(drop_element);
14926 player->is_dropping = TRUE;
14928 player->drop_pressed_delay = 0;
14929 player->is_dropping_pressed = FALSE;
14931 player->drop_x = dropx;
14932 player->drop_y = dropy;
14937 // ----------------------------------------------------------------------------
14938 // game sound playing functions
14939 // ----------------------------------------------------------------------------
14941 static int *loop_sound_frame = NULL;
14942 static int *loop_sound_volume = NULL;
14944 void InitPlayLevelSound(void)
14946 int num_sounds = getSoundListSize();
14948 checked_free(loop_sound_frame);
14949 checked_free(loop_sound_volume);
14951 loop_sound_frame = checked_calloc(num_sounds * sizeof(int));
14952 loop_sound_volume = checked_calloc(num_sounds * sizeof(int));
14955 static void PlayLevelSound(int x, int y, int nr)
14957 int sx = SCREENX(x), sy = SCREENY(y);
14958 int volume, stereo_position;
14959 int max_distance = 8;
14960 int type = (IS_LOOP_SOUND(nr) ? SND_CTRL_PLAY_LOOP : SND_CTRL_PLAY_SOUND);
14962 if ((!setup.sound_simple && !IS_LOOP_SOUND(nr)) ||
14963 (!setup.sound_loops && IS_LOOP_SOUND(nr)))
14966 if (!IN_LEV_FIELD(x, y) ||
14967 sx < -max_distance || sx >= SCR_FIELDX + max_distance ||
14968 sy < -max_distance || sy >= SCR_FIELDY + max_distance)
14971 volume = SOUND_MAX_VOLUME;
14973 if (!IN_SCR_FIELD(sx, sy))
14975 int dx = ABS(sx - SCR_FIELDX / 2) - SCR_FIELDX / 2;
14976 int dy = ABS(sy - SCR_FIELDY / 2) - SCR_FIELDY / 2;
14978 volume -= volume * (dx > dy ? dx : dy) / max_distance;
14981 stereo_position = (SOUND_MAX_LEFT +
14982 (sx + max_distance) * SOUND_MAX_LEFT2RIGHT /
14983 (SCR_FIELDX + 2 * max_distance));
14985 if (IS_LOOP_SOUND(nr))
14987 /* This assures that quieter loop sounds do not overwrite louder ones,
14988 while restarting sound volume comparison with each new game frame. */
14990 if (loop_sound_volume[nr] > volume && loop_sound_frame[nr] == FrameCounter)
14993 loop_sound_volume[nr] = volume;
14994 loop_sound_frame[nr] = FrameCounter;
14997 PlaySoundExt(nr, volume, stereo_position, type);
15000 static void PlayLevelSoundNearest(int x, int y, int sound_action)
15002 PlayLevelSound(x < LEVELX(BX1) ? LEVELX(BX1) :
15003 x > LEVELX(BX2) ? LEVELX(BX2) : x,
15004 y < LEVELY(BY1) ? LEVELY(BY1) :
15005 y > LEVELY(BY2) ? LEVELY(BY2) : y,
15009 static void PlayLevelSoundAction(int x, int y, int action)
15011 PlayLevelSoundElementAction(x, y, Tile[x][y], action);
15014 static void PlayLevelSoundElementAction(int x, int y, int element, int action)
15016 int sound_effect = element_info[SND_ELEMENT(element)].sound[action];
15018 if (sound_effect != SND_UNDEFINED)
15019 PlayLevelSound(x, y, sound_effect);
15022 static void PlayLevelSoundElementActionIfLoop(int x, int y, int element,
15025 int sound_effect = element_info[SND_ELEMENT(element)].sound[action];
15027 if (sound_effect != SND_UNDEFINED && IS_LOOP_SOUND(sound_effect))
15028 PlayLevelSound(x, y, sound_effect);
15031 static void PlayLevelSoundActionIfLoop(int x, int y, int action)
15033 int sound_effect = element_info[SND_ELEMENT(Tile[x][y])].sound[action];
15035 if (sound_effect != SND_UNDEFINED && IS_LOOP_SOUND(sound_effect))
15036 PlayLevelSound(x, y, sound_effect);
15039 static void StopLevelSoundActionIfLoop(int x, int y, int action)
15041 int sound_effect = element_info[SND_ELEMENT(Tile[x][y])].sound[action];
15043 if (sound_effect != SND_UNDEFINED && IS_LOOP_SOUND(sound_effect))
15044 StopSound(sound_effect);
15047 static int getLevelMusicNr(void)
15049 if (levelset.music[level_nr] != MUS_UNDEFINED)
15050 return levelset.music[level_nr]; // from config file
15052 return MAP_NOCONF_MUSIC(level_nr); // from music dir
15055 static void FadeLevelSounds(void)
15060 static void FadeLevelMusic(void)
15062 int music_nr = getLevelMusicNr();
15063 char *curr_music = getCurrentlyPlayingMusicFilename();
15064 char *next_music = getMusicInfoEntryFilename(music_nr);
15066 if (!strEqual(curr_music, next_music))
15070 void FadeLevelSoundsAndMusic(void)
15076 static void PlayLevelMusic(void)
15078 int music_nr = getLevelMusicNr();
15079 char *curr_music = getCurrentlyPlayingMusicFilename();
15080 char *next_music = getMusicInfoEntryFilename(music_nr);
15082 if (!strEqual(curr_music, next_music))
15083 PlayMusicLoop(music_nr);
15086 void PlayLevelSound_EM(int xx, int yy, int element_em, int sample)
15088 int element = (element_em > -1 ? map_element_EM_to_RND_game(element_em) : 0);
15090 int x = xx - offset;
15091 int y = yy - offset;
15096 PlayLevelSoundElementAction(x, y, element, ACTION_WALKING);
15100 PlayLevelSoundElementAction(x, y, element, ACTION_PUSHING);
15104 PlayLevelSoundElementAction(x, y, element, ACTION_IMPACT);
15108 PlayLevelSoundElementAction(x, y, element, ACTION_IMPACT);
15112 PlayLevelSoundElementAction(x, y, element, ACTION_BREAKING);
15116 PlayLevelSoundElementAction(x, y, element, ACTION_MOVING);
15120 PlayLevelSoundElementAction(x, y, element, ACTION_MOVING);
15123 case SOUND_android_clone:
15124 PlayLevelSoundElementAction(x, y, element, ACTION_DROPPING);
15127 case SOUND_android_move:
15128 PlayLevelSoundElementAction(x, y, element, ACTION_MOVING);
15132 PlayLevelSoundElementAction(x, y, element, ACTION_IMPACT);
15136 PlayLevelSoundElementAction(x, y, element, ACTION_EATING);
15140 PlayLevelSoundElementAction(x, y, element, ACTION_WAITING);
15143 case SOUND_eater_eat:
15144 PlayLevelSoundElementAction(x, y, element, ACTION_DIGGING);
15148 PlayLevelSoundElementAction(x, y, element, ACTION_MOVING);
15151 case SOUND_collect:
15152 PlayLevelSoundElementAction(x, y, element, ACTION_COLLECTING);
15155 case SOUND_diamond:
15156 PlayLevelSoundElementAction(x, y, element, ACTION_IMPACT);
15160 // !!! CHECK THIS !!!
15162 PlayLevelSoundElementAction(x, y, element, ACTION_BREAKING);
15164 PlayLevelSoundElementAction(x, y, element, ACTION_SMASHED_BY_ROCK);
15168 case SOUND_wonderfall:
15169 PlayLevelSoundElementAction(x, y, element, ACTION_FILLING);
15173 PlayLevelSoundElementAction(x, y, element, ACTION_IMPACT);
15177 PlayLevelSoundElementAction(x, y, element, ACTION_PUSHING);
15181 PlayLevelSoundElementAction(x, y, element, ACTION_DIGGING);
15185 PlayLevelSoundElementAction(x, y, element, ACTION_SPLASHING);
15189 PlayLevelSoundElementAction(x, y, element, ACTION_DROPPING);
15193 PlayLevelSoundElementAction(x, y, element, ACTION_GROWING);
15197 PlayLevelSoundElementAction(x, y, element, ACTION_ACTIVE);
15201 PlayLevelSoundElementAction(x, y, element, ACTION_PASSING);
15204 case SOUND_exit_open:
15205 PlayLevelSoundElementAction(x, y, element, ACTION_OPENING);
15208 case SOUND_exit_leave:
15209 PlayLevelSoundElementAction(x, y, element, ACTION_PASSING);
15212 case SOUND_dynamite:
15213 PlayLevelSoundElementAction(x, y, element, ACTION_DROPPING);
15217 PlayLevelSoundElementAction(x, y, element, ACTION_ACTIVE);
15221 PlayLevelSoundElementAction(x, y, element, ACTION_ACTIVATING);
15225 PlayLevelSoundElementAction(x, y, element, ACTION_ACTIVE);
15229 PlayLevelSoundElementAction(x, y, element, ACTION_EXPLODING);
15233 PlayLevelSoundElementAction(x, y, element, ACTION_DYING);
15237 PlaySound(SND_GAME_RUNNING_OUT_OF_TIME);
15241 PlayLevelSoundElementAction(x, y, element, ACTION_DEFAULT);
15246 void PlayLevelSound_SP(int xx, int yy, int element_sp, int action_sp)
15248 int element = map_element_SP_to_RND(element_sp);
15249 int action = map_action_SP_to_RND(action_sp);
15250 int offset = (setup.sp_show_border_elements ? 0 : 1);
15251 int x = xx - offset;
15252 int y = yy - offset;
15254 PlayLevelSoundElementAction(x, y, element, action);
15257 void PlayLevelSound_MM(int xx, int yy, int element_mm, int action_mm)
15259 int element = map_element_MM_to_RND(element_mm);
15260 int action = map_action_MM_to_RND(action_mm);
15262 int x = xx - offset;
15263 int y = yy - offset;
15265 if (!IS_MM_ELEMENT(element))
15266 element = EL_MM_DEFAULT;
15268 PlayLevelSoundElementAction(x, y, element, action);
15271 void PlaySound_MM(int sound_mm)
15273 int sound = map_sound_MM_to_RND(sound_mm);
15275 if (sound == SND_UNDEFINED)
15281 void PlaySoundLoop_MM(int sound_mm)
15283 int sound = map_sound_MM_to_RND(sound_mm);
15285 if (sound == SND_UNDEFINED)
15288 PlaySoundLoop(sound);
15291 void StopSound_MM(int sound_mm)
15293 int sound = map_sound_MM_to_RND(sound_mm);
15295 if (sound == SND_UNDEFINED)
15301 void RaiseScore(int value)
15303 game.score += value;
15305 game_panel_controls[GAME_PANEL_SCORE].value = game.score;
15307 DisplayGameControlValues();
15310 void RaiseScoreElement(int element)
15315 case EL_BD_DIAMOND:
15316 case EL_EMERALD_YELLOW:
15317 case EL_EMERALD_RED:
15318 case EL_EMERALD_PURPLE:
15319 case EL_SP_INFOTRON:
15320 RaiseScore(level.score[SC_EMERALD]);
15323 RaiseScore(level.score[SC_DIAMOND]);
15326 RaiseScore(level.score[SC_CRYSTAL]);
15329 RaiseScore(level.score[SC_PEARL]);
15332 case EL_BD_BUTTERFLY:
15333 case EL_SP_ELECTRON:
15334 RaiseScore(level.score[SC_BUG]);
15337 case EL_BD_FIREFLY:
15338 case EL_SP_SNIKSNAK:
15339 RaiseScore(level.score[SC_SPACESHIP]);
15342 case EL_DARK_YAMYAM:
15343 RaiseScore(level.score[SC_YAMYAM]);
15346 RaiseScore(level.score[SC_ROBOT]);
15349 RaiseScore(level.score[SC_PACMAN]);
15352 RaiseScore(level.score[SC_NUT]);
15355 case EL_EM_DYNAMITE:
15356 case EL_SP_DISK_RED:
15357 case EL_DYNABOMB_INCREASE_NUMBER:
15358 case EL_DYNABOMB_INCREASE_SIZE:
15359 case EL_DYNABOMB_INCREASE_POWER:
15360 RaiseScore(level.score[SC_DYNAMITE]);
15362 case EL_SHIELD_NORMAL:
15363 case EL_SHIELD_DEADLY:
15364 RaiseScore(level.score[SC_SHIELD]);
15366 case EL_EXTRA_TIME:
15367 RaiseScore(level.extra_time_score);
15381 case EL_DC_KEY_WHITE:
15382 RaiseScore(level.score[SC_KEY]);
15385 RaiseScore(element_info[element].collect_score);
15390 void RequestQuitGameExt(boolean skip_request, boolean quick_quit, char *message)
15392 if (skip_request || Request(message, REQ_ASK | REQ_STAY_CLOSED))
15396 // prevent short reactivation of overlay buttons while closing door
15397 SetOverlayActive(FALSE);
15399 // door may still be open due to skipped or envelope style request
15400 CloseDoor(DOOR_CLOSE_1);
15403 if (network.enabled)
15404 SendToServer_StopPlaying(NETWORK_STOP_BY_PLAYER);
15408 FadeSkipNextFadeIn();
15410 SetGameStatus(GAME_MODE_MAIN);
15415 else // continue playing the game
15417 if (tape.playing && tape.deactivate_display)
15418 TapeDeactivateDisplayOff(TRUE);
15420 OpenDoor(DOOR_OPEN_1 | DOOR_COPY_BACK);
15422 if (tape.playing && tape.deactivate_display)
15423 TapeDeactivateDisplayOn();
15427 void RequestQuitGame(boolean escape_key_pressed)
15429 boolean ask_on_escape = (setup.ask_on_escape && setup.ask_on_quit_game);
15430 boolean quick_quit = ((escape_key_pressed && !ask_on_escape) ||
15431 level_editor_test_game);
15432 boolean skip_request = (game.all_players_gone || !setup.ask_on_quit_game ||
15435 RequestQuitGameExt(skip_request, quick_quit,
15436 "Do you really want to quit the game?");
15439 void RequestRestartGame(char *message)
15441 game.restart_game_message = NULL;
15443 boolean has_started_game = hasStartedNetworkGame();
15444 int request_mode = (has_started_game ? REQ_ASK : REQ_CONFIRM);
15446 if (Request(message, request_mode | REQ_STAY_CLOSED) && has_started_game)
15448 StartGameActions(network.enabled, setup.autorecord, level.random_seed);
15452 // needed in case of envelope request to close game panel
15453 CloseDoor(DOOR_CLOSE_1);
15455 SetGameStatus(GAME_MODE_MAIN);
15461 void CheckGameOver(void)
15463 static boolean last_game_over = FALSE;
15464 static int game_over_delay = 0;
15465 int game_over_delay_value = 50;
15466 boolean game_over = checkGameFailed();
15468 // do not handle game over if request dialog is already active
15469 if (game.request_active)
15472 // do not ask to play again if game was never actually played
15473 if (!game.GamePlayed)
15478 last_game_over = FALSE;
15479 game_over_delay = game_over_delay_value;
15484 if (game_over_delay > 0)
15491 if (last_game_over != game_over)
15492 game.restart_game_message = (hasStartedNetworkGame() ?
15493 "Game over! Play it again?" :
15496 last_game_over = game_over;
15499 boolean checkGameSolved(void)
15501 // set for all game engines if level was solved
15502 return game.LevelSolved_GameEnd;
15505 boolean checkGameFailed(void)
15507 if (level.game_engine_type == GAME_ENGINE_TYPE_EM)
15508 return (game_em.game_over && !game_em.level_solved);
15509 else if (level.game_engine_type == GAME_ENGINE_TYPE_SP)
15510 return (game_sp.game_over && !game_sp.level_solved);
15511 else if (level.game_engine_type == GAME_ENGINE_TYPE_MM)
15512 return (game_mm.game_over && !game_mm.level_solved);
15513 else // GAME_ENGINE_TYPE_RND
15514 return (game.GameOver && !game.LevelSolved);
15517 boolean checkGameEnded(void)
15519 return (checkGameSolved() || checkGameFailed());
15523 // ----------------------------------------------------------------------------
15524 // random generator functions
15525 // ----------------------------------------------------------------------------
15527 unsigned int InitEngineRandom_RND(int seed)
15529 game.num_random_calls = 0;
15531 return InitEngineRandom(seed);
15534 unsigned int RND(int max)
15538 game.num_random_calls++;
15540 return GetEngineRandom(max);
15547 // ----------------------------------------------------------------------------
15548 // game engine snapshot handling functions
15549 // ----------------------------------------------------------------------------
15551 struct EngineSnapshotInfo
15553 // runtime values for custom element collect score
15554 int collect_score[NUM_CUSTOM_ELEMENTS];
15556 // runtime values for group element choice position
15557 int choice_pos[NUM_GROUP_ELEMENTS];
15559 // runtime values for belt position animations
15560 int belt_graphic[4][NUM_BELT_PARTS];
15561 int belt_anim_mode[4][NUM_BELT_PARTS];
15564 static struct EngineSnapshotInfo engine_snapshot_rnd;
15565 static char *snapshot_level_identifier = NULL;
15566 static int snapshot_level_nr = -1;
15568 static void SaveEngineSnapshotValues_RND(void)
15570 static int belt_base_active_element[4] =
15572 EL_CONVEYOR_BELT_1_LEFT_ACTIVE,
15573 EL_CONVEYOR_BELT_2_LEFT_ACTIVE,
15574 EL_CONVEYOR_BELT_3_LEFT_ACTIVE,
15575 EL_CONVEYOR_BELT_4_LEFT_ACTIVE
15579 for (i = 0; i < NUM_CUSTOM_ELEMENTS; i++)
15581 int element = EL_CUSTOM_START + i;
15583 engine_snapshot_rnd.collect_score[i] = element_info[element].collect_score;
15586 for (i = 0; i < NUM_GROUP_ELEMENTS; i++)
15588 int element = EL_GROUP_START + i;
15590 engine_snapshot_rnd.choice_pos[i] = element_info[element].group->choice_pos;
15593 for (i = 0; i < 4; i++)
15595 for (j = 0; j < NUM_BELT_PARTS; j++)
15597 int element = belt_base_active_element[i] + j;
15598 int graphic = el2img(element);
15599 int anim_mode = graphic_info[graphic].anim_mode;
15601 engine_snapshot_rnd.belt_graphic[i][j] = graphic;
15602 engine_snapshot_rnd.belt_anim_mode[i][j] = anim_mode;
15607 static void LoadEngineSnapshotValues_RND(void)
15609 unsigned int num_random_calls = game.num_random_calls;
15612 for (i = 0; i < NUM_CUSTOM_ELEMENTS; i++)
15614 int element = EL_CUSTOM_START + i;
15616 element_info[element].collect_score = engine_snapshot_rnd.collect_score[i];
15619 for (i = 0; i < NUM_GROUP_ELEMENTS; i++)
15621 int element = EL_GROUP_START + i;
15623 element_info[element].group->choice_pos = engine_snapshot_rnd.choice_pos[i];
15626 for (i = 0; i < 4; i++)
15628 for (j = 0; j < NUM_BELT_PARTS; j++)
15630 int graphic = engine_snapshot_rnd.belt_graphic[i][j];
15631 int anim_mode = engine_snapshot_rnd.belt_anim_mode[i][j];
15633 graphic_info[graphic].anim_mode = anim_mode;
15637 if (level.game_engine_type == GAME_ENGINE_TYPE_RND)
15639 InitRND(tape.random_seed);
15640 for (i = 0; i < num_random_calls; i++)
15644 if (game.num_random_calls != num_random_calls)
15646 Error("number of random calls out of sync");
15647 Error("number of random calls should be %d", num_random_calls);
15648 Error("number of random calls is %d", game.num_random_calls);
15650 Fail("this should not happen -- please debug");
15654 void FreeEngineSnapshotSingle(void)
15656 FreeSnapshotSingle();
15658 setString(&snapshot_level_identifier, NULL);
15659 snapshot_level_nr = -1;
15662 void FreeEngineSnapshotList(void)
15664 FreeSnapshotList();
15667 static ListNode *SaveEngineSnapshotBuffers(void)
15669 ListNode *buffers = NULL;
15671 // copy some special values to a structure better suited for the snapshot
15673 if (level.game_engine_type == GAME_ENGINE_TYPE_RND)
15674 SaveEngineSnapshotValues_RND();
15675 if (level.game_engine_type == GAME_ENGINE_TYPE_EM)
15676 SaveEngineSnapshotValues_EM();
15677 if (level.game_engine_type == GAME_ENGINE_TYPE_SP)
15678 SaveEngineSnapshotValues_SP(&buffers);
15679 if (level.game_engine_type == GAME_ENGINE_TYPE_MM)
15680 SaveEngineSnapshotValues_MM(&buffers);
15682 // save values stored in special snapshot structure
15684 if (level.game_engine_type == GAME_ENGINE_TYPE_RND)
15685 SaveSnapshotBuffer(&buffers, ARGS_ADDRESS_AND_SIZEOF(engine_snapshot_rnd));
15686 if (level.game_engine_type == GAME_ENGINE_TYPE_EM)
15687 SaveSnapshotBuffer(&buffers, ARGS_ADDRESS_AND_SIZEOF(engine_snapshot_em));
15688 if (level.game_engine_type == GAME_ENGINE_TYPE_SP)
15689 SaveSnapshotBuffer(&buffers, ARGS_ADDRESS_AND_SIZEOF(engine_snapshot_sp));
15690 if (level.game_engine_type == GAME_ENGINE_TYPE_MM)
15691 SaveSnapshotBuffer(&buffers, ARGS_ADDRESS_AND_SIZEOF(engine_snapshot_mm));
15693 // save further RND engine values
15695 SaveSnapshotBuffer(&buffers, ARGS_ADDRESS_AND_SIZEOF(stored_player));
15696 SaveSnapshotBuffer(&buffers, ARGS_ADDRESS_AND_SIZEOF(game));
15697 SaveSnapshotBuffer(&buffers, ARGS_ADDRESS_AND_SIZEOF(tape));
15699 SaveSnapshotBuffer(&buffers, ARGS_ADDRESS_AND_SIZEOF(FrameCounter));
15700 SaveSnapshotBuffer(&buffers, ARGS_ADDRESS_AND_SIZEOF(TimeFrames));
15701 SaveSnapshotBuffer(&buffers, ARGS_ADDRESS_AND_SIZEOF(TimePlayed));
15702 SaveSnapshotBuffer(&buffers, ARGS_ADDRESS_AND_SIZEOF(TimeLeft));
15703 SaveSnapshotBuffer(&buffers, ARGS_ADDRESS_AND_SIZEOF(TapeTime));
15705 SaveSnapshotBuffer(&buffers, ARGS_ADDRESS_AND_SIZEOF(ScreenMovDir));
15706 SaveSnapshotBuffer(&buffers, ARGS_ADDRESS_AND_SIZEOF(ScreenMovPos));
15707 SaveSnapshotBuffer(&buffers, ARGS_ADDRESS_AND_SIZEOF(ScreenGfxPos));
15709 SaveSnapshotBuffer(&buffers, ARGS_ADDRESS_AND_SIZEOF(ScrollStepSize));
15711 SaveSnapshotBuffer(&buffers, ARGS_ADDRESS_AND_SIZEOF(AmoebaCnt));
15712 SaveSnapshotBuffer(&buffers, ARGS_ADDRESS_AND_SIZEOF(AmoebaCnt2));
15714 SaveSnapshotBuffer(&buffers, ARGS_ADDRESS_AND_SIZEOF(Tile));
15715 SaveSnapshotBuffer(&buffers, ARGS_ADDRESS_AND_SIZEOF(MovPos));
15716 SaveSnapshotBuffer(&buffers, ARGS_ADDRESS_AND_SIZEOF(MovDir));
15717 SaveSnapshotBuffer(&buffers, ARGS_ADDRESS_AND_SIZEOF(MovDelay));
15718 SaveSnapshotBuffer(&buffers, ARGS_ADDRESS_AND_SIZEOF(ChangeDelay));
15719 SaveSnapshotBuffer(&buffers, ARGS_ADDRESS_AND_SIZEOF(ChangePage));
15720 SaveSnapshotBuffer(&buffers, ARGS_ADDRESS_AND_SIZEOF(CustomValue));
15721 SaveSnapshotBuffer(&buffers, ARGS_ADDRESS_AND_SIZEOF(Store));
15722 SaveSnapshotBuffer(&buffers, ARGS_ADDRESS_AND_SIZEOF(Store2));
15723 SaveSnapshotBuffer(&buffers, ARGS_ADDRESS_AND_SIZEOF(StorePlayer));
15724 SaveSnapshotBuffer(&buffers, ARGS_ADDRESS_AND_SIZEOF(Back));
15725 SaveSnapshotBuffer(&buffers, ARGS_ADDRESS_AND_SIZEOF(AmoebaNr));
15726 SaveSnapshotBuffer(&buffers, ARGS_ADDRESS_AND_SIZEOF(WasJustMoving));
15727 SaveSnapshotBuffer(&buffers, ARGS_ADDRESS_AND_SIZEOF(WasJustFalling));
15728 SaveSnapshotBuffer(&buffers, ARGS_ADDRESS_AND_SIZEOF(CheckCollision));
15729 SaveSnapshotBuffer(&buffers, ARGS_ADDRESS_AND_SIZEOF(CheckImpact));
15730 SaveSnapshotBuffer(&buffers, ARGS_ADDRESS_AND_SIZEOF(Stop));
15731 SaveSnapshotBuffer(&buffers, ARGS_ADDRESS_AND_SIZEOF(Pushed));
15733 SaveSnapshotBuffer(&buffers, ARGS_ADDRESS_AND_SIZEOF(ChangeCount));
15734 SaveSnapshotBuffer(&buffers, ARGS_ADDRESS_AND_SIZEOF(ChangeEvent));
15736 SaveSnapshotBuffer(&buffers, ARGS_ADDRESS_AND_SIZEOF(ExplodePhase));
15737 SaveSnapshotBuffer(&buffers, ARGS_ADDRESS_AND_SIZEOF(ExplodeDelay));
15738 SaveSnapshotBuffer(&buffers, ARGS_ADDRESS_AND_SIZEOF(ExplodeField));
15740 SaveSnapshotBuffer(&buffers, ARGS_ADDRESS_AND_SIZEOF(RunnerVisit));
15741 SaveSnapshotBuffer(&buffers, ARGS_ADDRESS_AND_SIZEOF(PlayerVisit));
15743 SaveSnapshotBuffer(&buffers, ARGS_ADDRESS_AND_SIZEOF(GfxFrame));
15744 SaveSnapshotBuffer(&buffers, ARGS_ADDRESS_AND_SIZEOF(GfxRandom));
15745 SaveSnapshotBuffer(&buffers, ARGS_ADDRESS_AND_SIZEOF(GfxElement));
15746 SaveSnapshotBuffer(&buffers, ARGS_ADDRESS_AND_SIZEOF(GfxAction));
15747 SaveSnapshotBuffer(&buffers, ARGS_ADDRESS_AND_SIZEOF(GfxDir));
15749 SaveSnapshotBuffer(&buffers, ARGS_ADDRESS_AND_SIZEOF(scroll_x));
15750 SaveSnapshotBuffer(&buffers, ARGS_ADDRESS_AND_SIZEOF(scroll_y));
15753 ListNode *node = engine_snapshot_list_rnd;
15756 while (node != NULL)
15758 num_bytes += ((struct EngineSnapshotNodeInfo *)node->content)->size;
15763 Debug("game:playing:SaveEngineSnapshotBuffers",
15764 "size of engine snapshot: %d bytes", num_bytes);
15770 void SaveEngineSnapshotSingle(void)
15772 ListNode *buffers = SaveEngineSnapshotBuffers();
15774 // finally save all snapshot buffers to single snapshot
15775 SaveSnapshotSingle(buffers);
15777 // save level identification information
15778 setString(&snapshot_level_identifier, leveldir_current->identifier);
15779 snapshot_level_nr = level_nr;
15782 boolean CheckSaveEngineSnapshotToList(void)
15784 boolean save_snapshot =
15785 ((game.snapshot.mode == SNAPSHOT_MODE_EVERY_STEP) ||
15786 (game.snapshot.mode == SNAPSHOT_MODE_EVERY_MOVE &&
15787 game.snapshot.changed_action) ||
15788 (game.snapshot.mode == SNAPSHOT_MODE_EVERY_COLLECT &&
15789 game.snapshot.collected_item));
15791 game.snapshot.changed_action = FALSE;
15792 game.snapshot.collected_item = FALSE;
15793 game.snapshot.save_snapshot = save_snapshot;
15795 return save_snapshot;
15798 void SaveEngineSnapshotToList(void)
15800 if (game.snapshot.mode == SNAPSHOT_MODE_OFF ||
15804 ListNode *buffers = SaveEngineSnapshotBuffers();
15806 // finally save all snapshot buffers to snapshot list
15807 SaveSnapshotToList(buffers);
15810 void SaveEngineSnapshotToListInitial(void)
15812 FreeEngineSnapshotList();
15814 SaveEngineSnapshotToList();
15817 static void LoadEngineSnapshotValues(void)
15819 // restore special values from snapshot structure
15821 if (level.game_engine_type == GAME_ENGINE_TYPE_RND)
15822 LoadEngineSnapshotValues_RND();
15823 if (level.game_engine_type == GAME_ENGINE_TYPE_EM)
15824 LoadEngineSnapshotValues_EM();
15825 if (level.game_engine_type == GAME_ENGINE_TYPE_SP)
15826 LoadEngineSnapshotValues_SP();
15827 if (level.game_engine_type == GAME_ENGINE_TYPE_MM)
15828 LoadEngineSnapshotValues_MM();
15831 void LoadEngineSnapshotSingle(void)
15833 LoadSnapshotSingle();
15835 LoadEngineSnapshotValues();
15838 static void LoadEngineSnapshot_Undo(int steps)
15840 LoadSnapshotFromList_Older(steps);
15842 LoadEngineSnapshotValues();
15845 static void LoadEngineSnapshot_Redo(int steps)
15847 LoadSnapshotFromList_Newer(steps);
15849 LoadEngineSnapshotValues();
15852 boolean CheckEngineSnapshotSingle(void)
15854 return (strEqual(snapshot_level_identifier, leveldir_current->identifier) &&
15855 snapshot_level_nr == level_nr);
15858 boolean CheckEngineSnapshotList(void)
15860 return CheckSnapshotList();
15864 // ---------- new game button stuff -------------------------------------------
15871 boolean *setup_value;
15872 boolean allowed_on_tape;
15873 boolean is_touch_button;
15875 } gamebutton_info[NUM_GAME_BUTTONS] =
15878 IMG_GFX_GAME_BUTTON_STOP, &game.button.stop,
15879 GAME_CTRL_ID_STOP, NULL,
15880 TRUE, FALSE, "stop game"
15883 IMG_GFX_GAME_BUTTON_PAUSE, &game.button.pause,
15884 GAME_CTRL_ID_PAUSE, NULL,
15885 TRUE, FALSE, "pause game"
15888 IMG_GFX_GAME_BUTTON_PLAY, &game.button.play,
15889 GAME_CTRL_ID_PLAY, NULL,
15890 TRUE, FALSE, "play game"
15893 IMG_GFX_GAME_BUTTON_UNDO, &game.button.undo,
15894 GAME_CTRL_ID_UNDO, NULL,
15895 TRUE, FALSE, "undo step"
15898 IMG_GFX_GAME_BUTTON_REDO, &game.button.redo,
15899 GAME_CTRL_ID_REDO, NULL,
15900 TRUE, FALSE, "redo step"
15903 IMG_GFX_GAME_BUTTON_SAVE, &game.button.save,
15904 GAME_CTRL_ID_SAVE, NULL,
15905 TRUE, FALSE, "save game"
15908 IMG_GFX_GAME_BUTTON_PAUSE2, &game.button.pause2,
15909 GAME_CTRL_ID_PAUSE2, NULL,
15910 TRUE, FALSE, "pause game"
15913 IMG_GFX_GAME_BUTTON_LOAD, &game.button.load,
15914 GAME_CTRL_ID_LOAD, NULL,
15915 TRUE, FALSE, "load game"
15918 IMG_GFX_GAME_BUTTON_PANEL_STOP, &game.button.panel_stop,
15919 GAME_CTRL_ID_PANEL_STOP, NULL,
15920 FALSE, FALSE, "stop game"
15923 IMG_GFX_GAME_BUTTON_PANEL_PAUSE, &game.button.panel_pause,
15924 GAME_CTRL_ID_PANEL_PAUSE, NULL,
15925 FALSE, FALSE, "pause game"
15928 IMG_GFX_GAME_BUTTON_PANEL_PLAY, &game.button.panel_play,
15929 GAME_CTRL_ID_PANEL_PLAY, NULL,
15930 FALSE, FALSE, "play game"
15933 IMG_GFX_GAME_BUTTON_TOUCH_STOP, &game.button.touch_stop,
15934 GAME_CTRL_ID_TOUCH_STOP, NULL,
15935 FALSE, TRUE, "stop game"
15938 IMG_GFX_GAME_BUTTON_TOUCH_PAUSE, &game.button.touch_pause,
15939 GAME_CTRL_ID_TOUCH_PAUSE, NULL,
15940 FALSE, TRUE, "pause game"
15943 IMG_GFX_GAME_BUTTON_SOUND_MUSIC, &game.button.sound_music,
15944 SOUND_CTRL_ID_MUSIC, &setup.sound_music,
15945 TRUE, FALSE, "background music on/off"
15948 IMG_GFX_GAME_BUTTON_SOUND_LOOPS, &game.button.sound_loops,
15949 SOUND_CTRL_ID_LOOPS, &setup.sound_loops,
15950 TRUE, FALSE, "sound loops on/off"
15953 IMG_GFX_GAME_BUTTON_SOUND_SIMPLE, &game.button.sound_simple,
15954 SOUND_CTRL_ID_SIMPLE, &setup.sound_simple,
15955 TRUE, FALSE, "normal sounds on/off"
15958 IMG_GFX_GAME_BUTTON_PANEL_SOUND_MUSIC, &game.button.panel_sound_music,
15959 SOUND_CTRL_ID_PANEL_MUSIC, &setup.sound_music,
15960 FALSE, FALSE, "background music on/off"
15963 IMG_GFX_GAME_BUTTON_PANEL_SOUND_LOOPS, &game.button.panel_sound_loops,
15964 SOUND_CTRL_ID_PANEL_LOOPS, &setup.sound_loops,
15965 FALSE, FALSE, "sound loops on/off"
15968 IMG_GFX_GAME_BUTTON_PANEL_SOUND_SIMPLE, &game.button.panel_sound_simple,
15969 SOUND_CTRL_ID_PANEL_SIMPLE, &setup.sound_simple,
15970 FALSE, FALSE, "normal sounds on/off"
15974 void CreateGameButtons(void)
15978 for (i = 0; i < NUM_GAME_BUTTONS; i++)
15980 int graphic = gamebutton_info[i].graphic;
15981 struct GraphicInfo *gfx = &graphic_info[graphic];
15982 struct XY *pos = gamebutton_info[i].pos;
15983 struct GadgetInfo *gi;
15986 unsigned int event_mask;
15987 boolean is_touch_button = gamebutton_info[i].is_touch_button;
15988 boolean allowed_on_tape = gamebutton_info[i].allowed_on_tape;
15989 boolean on_tape = (tape.show_game_buttons && allowed_on_tape);
15990 int base_x = (is_touch_button ? 0 : on_tape ? VX : DX);
15991 int base_y = (is_touch_button ? 0 : on_tape ? VY : DY);
15992 int gd_x = gfx->src_x;
15993 int gd_y = gfx->src_y;
15994 int gd_xp = gfx->src_x + gfx->pressed_xoffset;
15995 int gd_yp = gfx->src_y + gfx->pressed_yoffset;
15996 int gd_xa = gfx->src_x + gfx->active_xoffset;
15997 int gd_ya = gfx->src_y + gfx->active_yoffset;
15998 int gd_xap = gfx->src_x + gfx->active_xoffset + gfx->pressed_xoffset;
15999 int gd_yap = gfx->src_y + gfx->active_yoffset + gfx->pressed_yoffset;
16000 int x = (is_touch_button ? pos->x : GDI_ACTIVE_POS(pos->x));
16001 int y = (is_touch_button ? pos->y : GDI_ACTIVE_POS(pos->y));
16004 if (gfx->bitmap == NULL)
16006 game_gadget[id] = NULL;
16011 if (id == GAME_CTRL_ID_STOP ||
16012 id == GAME_CTRL_ID_PANEL_STOP ||
16013 id == GAME_CTRL_ID_TOUCH_STOP ||
16014 id == GAME_CTRL_ID_PLAY ||
16015 id == GAME_CTRL_ID_PANEL_PLAY ||
16016 id == GAME_CTRL_ID_SAVE ||
16017 id == GAME_CTRL_ID_LOAD)
16019 button_type = GD_TYPE_NORMAL_BUTTON;
16021 event_mask = GD_EVENT_RELEASED;
16023 else if (id == GAME_CTRL_ID_UNDO ||
16024 id == GAME_CTRL_ID_REDO)
16026 button_type = GD_TYPE_NORMAL_BUTTON;
16028 event_mask = GD_EVENT_PRESSED | GD_EVENT_REPEATED;
16032 button_type = GD_TYPE_CHECK_BUTTON;
16033 checked = (gamebutton_info[i].setup_value != NULL ?
16034 *gamebutton_info[i].setup_value : FALSE);
16035 event_mask = GD_EVENT_PRESSED;
16038 gi = CreateGadget(GDI_CUSTOM_ID, id,
16039 GDI_IMAGE_ID, graphic,
16040 GDI_INFO_TEXT, gamebutton_info[i].infotext,
16043 GDI_WIDTH, gfx->width,
16044 GDI_HEIGHT, gfx->height,
16045 GDI_TYPE, button_type,
16046 GDI_STATE, GD_BUTTON_UNPRESSED,
16047 GDI_CHECKED, checked,
16048 GDI_DESIGN_UNPRESSED, gfx->bitmap, gd_x, gd_y,
16049 GDI_DESIGN_PRESSED, gfx->bitmap, gd_xp, gd_yp,
16050 GDI_ALT_DESIGN_UNPRESSED, gfx->bitmap, gd_xa, gd_ya,
16051 GDI_ALT_DESIGN_PRESSED, gfx->bitmap, gd_xap, gd_yap,
16052 GDI_DIRECT_DRAW, FALSE,
16053 GDI_OVERLAY_TOUCH_BUTTON, is_touch_button,
16054 GDI_EVENT_MASK, event_mask,
16055 GDI_CALLBACK_ACTION, HandleGameButtons,
16059 Fail("cannot create gadget");
16061 game_gadget[id] = gi;
16065 void FreeGameButtons(void)
16069 for (i = 0; i < NUM_GAME_BUTTONS; i++)
16070 FreeGadget(game_gadget[i]);
16073 static void UnmapGameButtonsAtSamePosition(int id)
16077 for (i = 0; i < NUM_GAME_BUTTONS; i++)
16079 gamebutton_info[i].pos->x == gamebutton_info[id].pos->x &&
16080 gamebutton_info[i].pos->y == gamebutton_info[id].pos->y)
16081 UnmapGadget(game_gadget[i]);
16084 static void UnmapGameButtonsAtSamePosition_All(void)
16086 if (setup.show_snapshot_buttons)
16088 UnmapGameButtonsAtSamePosition(GAME_CTRL_ID_SAVE);
16089 UnmapGameButtonsAtSamePosition(GAME_CTRL_ID_PAUSE2);
16090 UnmapGameButtonsAtSamePosition(GAME_CTRL_ID_LOAD);
16094 UnmapGameButtonsAtSamePosition(GAME_CTRL_ID_STOP);
16095 UnmapGameButtonsAtSamePosition(GAME_CTRL_ID_PAUSE);
16096 UnmapGameButtonsAtSamePosition(GAME_CTRL_ID_PLAY);
16098 UnmapGameButtonsAtSamePosition(GAME_CTRL_ID_PANEL_STOP);
16099 UnmapGameButtonsAtSamePosition(GAME_CTRL_ID_PANEL_PAUSE);
16100 UnmapGameButtonsAtSamePosition(GAME_CTRL_ID_PANEL_PLAY);
16104 static void MapGameButtonsAtSamePosition(int id)
16108 for (i = 0; i < NUM_GAME_BUTTONS; i++)
16110 gamebutton_info[i].pos->x == gamebutton_info[id].pos->x &&
16111 gamebutton_info[i].pos->y == gamebutton_info[id].pos->y)
16112 MapGadget(game_gadget[i]);
16114 UnmapGameButtonsAtSamePosition_All();
16117 void MapUndoRedoButtons(void)
16119 UnmapGameButtonsAtSamePosition(GAME_CTRL_ID_UNDO);
16120 UnmapGameButtonsAtSamePosition(GAME_CTRL_ID_REDO);
16122 MapGadget(game_gadget[GAME_CTRL_ID_UNDO]);
16123 MapGadget(game_gadget[GAME_CTRL_ID_REDO]);
16126 void UnmapUndoRedoButtons(void)
16128 UnmapGadget(game_gadget[GAME_CTRL_ID_UNDO]);
16129 UnmapGadget(game_gadget[GAME_CTRL_ID_REDO]);
16131 MapGameButtonsAtSamePosition(GAME_CTRL_ID_UNDO);
16132 MapGameButtonsAtSamePosition(GAME_CTRL_ID_REDO);
16135 void ModifyPauseButtons(void)
16139 GAME_CTRL_ID_PAUSE,
16140 GAME_CTRL_ID_PAUSE2,
16141 GAME_CTRL_ID_PANEL_PAUSE,
16142 GAME_CTRL_ID_TOUCH_PAUSE,
16147 for (i = 0; ids[i] > -1; i++)
16148 ModifyGadget(game_gadget[ids[i]], GDI_CHECKED, tape.pausing, GDI_END);
16151 static void MapGameButtonsExt(boolean on_tape)
16155 for (i = 0; i < NUM_GAME_BUTTONS; i++)
16156 if ((!on_tape || gamebutton_info[i].allowed_on_tape) &&
16157 i != GAME_CTRL_ID_UNDO &&
16158 i != GAME_CTRL_ID_REDO)
16159 MapGadget(game_gadget[i]);
16161 UnmapGameButtonsAtSamePosition_All();
16163 RedrawGameButtons();
16166 static void UnmapGameButtonsExt(boolean on_tape)
16170 for (i = 0; i < NUM_GAME_BUTTONS; i++)
16171 if (!on_tape || gamebutton_info[i].allowed_on_tape)
16172 UnmapGadget(game_gadget[i]);
16175 static void RedrawGameButtonsExt(boolean on_tape)
16179 for (i = 0; i < NUM_GAME_BUTTONS; i++)
16180 if (!on_tape || gamebutton_info[i].allowed_on_tape)
16181 RedrawGadget(game_gadget[i]);
16184 static void SetGadgetState(struct GadgetInfo *gi, boolean state)
16189 gi->checked = state;
16192 static void RedrawSoundButtonGadget(int id)
16194 int id2 = (id == SOUND_CTRL_ID_MUSIC ? SOUND_CTRL_ID_PANEL_MUSIC :
16195 id == SOUND_CTRL_ID_LOOPS ? SOUND_CTRL_ID_PANEL_LOOPS :
16196 id == SOUND_CTRL_ID_SIMPLE ? SOUND_CTRL_ID_PANEL_SIMPLE :
16197 id == SOUND_CTRL_ID_PANEL_MUSIC ? SOUND_CTRL_ID_MUSIC :
16198 id == SOUND_CTRL_ID_PANEL_LOOPS ? SOUND_CTRL_ID_LOOPS :
16199 id == SOUND_CTRL_ID_PANEL_SIMPLE ? SOUND_CTRL_ID_SIMPLE :
16202 SetGadgetState(game_gadget[id2], *gamebutton_info[id2].setup_value);
16203 RedrawGadget(game_gadget[id2]);
16206 void MapGameButtons(void)
16208 MapGameButtonsExt(FALSE);
16211 void UnmapGameButtons(void)
16213 UnmapGameButtonsExt(FALSE);
16216 void RedrawGameButtons(void)
16218 RedrawGameButtonsExt(FALSE);
16221 void MapGameButtonsOnTape(void)
16223 MapGameButtonsExt(TRUE);
16226 void UnmapGameButtonsOnTape(void)
16228 UnmapGameButtonsExt(TRUE);
16231 void RedrawGameButtonsOnTape(void)
16233 RedrawGameButtonsExt(TRUE);
16236 static void GameUndoRedoExt(void)
16238 ClearPlayerAction();
16240 tape.pausing = TRUE;
16243 UpdateAndDisplayGameControlValues();
16245 DrawCompleteVideoDisplay();
16246 DrawVideoDisplay(VIDEO_STATE_TIME_ON, TapeTime);
16247 DrawVideoDisplay(VIDEO_STATE_FRAME_ON, FrameCounter);
16248 DrawVideoDisplay(VIDEO_STATE_1STEP(tape.single_step), 0);
16253 static void GameUndo(int steps)
16255 if (!CheckEngineSnapshotList())
16258 LoadEngineSnapshot_Undo(steps);
16263 static void GameRedo(int steps)
16265 if (!CheckEngineSnapshotList())
16268 LoadEngineSnapshot_Redo(steps);
16273 static void HandleGameButtonsExt(int id, int button)
16275 static boolean game_undo_executed = FALSE;
16276 int steps = BUTTON_STEPSIZE(button);
16277 boolean handle_game_buttons =
16278 (game_status == GAME_MODE_PLAYING ||
16279 (game_status == GAME_MODE_MAIN && tape.show_game_buttons));
16281 if (!handle_game_buttons)
16286 case GAME_CTRL_ID_STOP:
16287 case GAME_CTRL_ID_PANEL_STOP:
16288 case GAME_CTRL_ID_TOUCH_STOP:
16289 if (game_status == GAME_MODE_MAIN)
16295 RequestQuitGame(FALSE);
16299 case GAME_CTRL_ID_PAUSE:
16300 case GAME_CTRL_ID_PAUSE2:
16301 case GAME_CTRL_ID_PANEL_PAUSE:
16302 case GAME_CTRL_ID_TOUCH_PAUSE:
16303 if (network.enabled && game_status == GAME_MODE_PLAYING)
16306 SendToServer_ContinuePlaying();
16308 SendToServer_PausePlaying();
16311 TapeTogglePause(TAPE_TOGGLE_MANUAL);
16313 game_undo_executed = FALSE;
16317 case GAME_CTRL_ID_PLAY:
16318 case GAME_CTRL_ID_PANEL_PLAY:
16319 if (game_status == GAME_MODE_MAIN)
16321 StartGameActions(network.enabled, setup.autorecord, level.random_seed);
16323 else if (tape.pausing)
16325 if (network.enabled)
16326 SendToServer_ContinuePlaying();
16328 TapeTogglePause(TAPE_TOGGLE_MANUAL | TAPE_TOGGLE_PLAY_PAUSE);
16332 case GAME_CTRL_ID_UNDO:
16333 // Important: When using "save snapshot when collecting an item" mode,
16334 // load last (current) snapshot for first "undo" after pressing "pause"
16335 // (else the last-but-one snapshot would be loaded, because the snapshot
16336 // pointer already points to the last snapshot when pressing "pause",
16337 // which is fine for "every step/move" mode, but not for "every collect")
16338 if (game.snapshot.mode == SNAPSHOT_MODE_EVERY_COLLECT &&
16339 !game_undo_executed)
16342 game_undo_executed = TRUE;
16347 case GAME_CTRL_ID_REDO:
16351 case GAME_CTRL_ID_SAVE:
16355 case GAME_CTRL_ID_LOAD:
16359 case SOUND_CTRL_ID_MUSIC:
16360 case SOUND_CTRL_ID_PANEL_MUSIC:
16361 if (setup.sound_music)
16363 setup.sound_music = FALSE;
16367 else if (audio.music_available)
16369 setup.sound = setup.sound_music = TRUE;
16371 SetAudioMode(setup.sound);
16373 if (game_status == GAME_MODE_PLAYING)
16377 RedrawSoundButtonGadget(id);
16381 case SOUND_CTRL_ID_LOOPS:
16382 case SOUND_CTRL_ID_PANEL_LOOPS:
16383 if (setup.sound_loops)
16384 setup.sound_loops = FALSE;
16385 else if (audio.loops_available)
16387 setup.sound = setup.sound_loops = TRUE;
16389 SetAudioMode(setup.sound);
16392 RedrawSoundButtonGadget(id);
16396 case SOUND_CTRL_ID_SIMPLE:
16397 case SOUND_CTRL_ID_PANEL_SIMPLE:
16398 if (setup.sound_simple)
16399 setup.sound_simple = FALSE;
16400 else if (audio.sound_available)
16402 setup.sound = setup.sound_simple = TRUE;
16404 SetAudioMode(setup.sound);
16407 RedrawSoundButtonGadget(id);
16416 static void HandleGameButtons(struct GadgetInfo *gi)
16418 HandleGameButtonsExt(gi->custom_id, gi->event.button);
16421 void HandleSoundButtonKeys(Key key)
16423 if (key == setup.shortcut.sound_simple)
16424 ClickOnGadget(game_gadget[SOUND_CTRL_ID_SIMPLE], MB_LEFTBUTTON);
16425 else if (key == setup.shortcut.sound_loops)
16426 ClickOnGadget(game_gadget[SOUND_CTRL_ID_LOOPS], MB_LEFTBUTTON);
16427 else if (key == setup.shortcut.sound_music)
16428 ClickOnGadget(game_gadget[SOUND_CTRL_ID_MUSIC], MB_LEFTBUTTON);