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 void NewHighScore(int, boolean);
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_sp = TRUE; // unless non-SUPAPLEX elements found
3546 int initial_move_dir = MV_DOWN;
3549 // required here to update video display before fading (FIX THIS)
3550 DrawMaskedBorder(REDRAW_DOOR_2);
3552 if (!game.restart_level)
3553 CloseDoor(DOOR_CLOSE_1);
3555 SetGameStatus(GAME_MODE_PLAYING);
3557 if (level_editor_test_game)
3558 FadeSkipNextFadeOut();
3560 FadeSetEnterScreen();
3563 fade_mask = REDRAW_ALL;
3565 FadeLevelSoundsAndMusic();
3567 ExpireSoundLoops(TRUE);
3571 if (level_editor_test_game)
3572 FadeSkipNextFadeIn();
3574 // needed if different viewport properties defined for playing
3575 ChangeViewportPropertiesIfNeeded();
3579 DrawCompleteVideoDisplay();
3581 OpenDoor(GetDoorState() | DOOR_NO_DELAY | DOOR_FORCE_REDRAW);
3584 InitGameControlValues();
3588 // initialize tape actions from game when recording tape
3589 tape.use_key_actions = game.use_key_actions;
3590 tape.use_mouse_actions = game.use_mouse_actions;
3592 // initialize visible playfield size when recording tape (for team mode)
3593 tape.scr_fieldx = SCR_FIELDX;
3594 tape.scr_fieldy = SCR_FIELDY;
3597 // don't play tapes over network
3598 network_playing = (network.enabled && !tape.playing);
3600 for (i = 0; i < MAX_PLAYERS; i++)
3602 struct PlayerInfo *player = &stored_player[i];
3604 player->index_nr = i;
3605 player->index_bit = (1 << i);
3606 player->element_nr = EL_PLAYER_1 + i;
3608 player->present = FALSE;
3609 player->active = FALSE;
3610 player->mapped = FALSE;
3612 player->killed = FALSE;
3613 player->reanimated = FALSE;
3614 player->buried = FALSE;
3617 player->effective_action = 0;
3618 player->programmed_action = 0;
3619 player->snap_action = 0;
3621 player->mouse_action.lx = 0;
3622 player->mouse_action.ly = 0;
3623 player->mouse_action.button = 0;
3624 player->mouse_action.button_hint = 0;
3626 player->effective_mouse_action.lx = 0;
3627 player->effective_mouse_action.ly = 0;
3628 player->effective_mouse_action.button = 0;
3629 player->effective_mouse_action.button_hint = 0;
3631 for (j = 0; j < MAX_NUM_KEYS; j++)
3632 player->key[j] = FALSE;
3634 player->num_white_keys = 0;
3636 player->dynabomb_count = 0;
3637 player->dynabomb_size = 1;
3638 player->dynabombs_left = 0;
3639 player->dynabomb_xl = FALSE;
3641 player->MovDir = initial_move_dir;
3644 player->GfxDir = initial_move_dir;
3645 player->GfxAction = ACTION_DEFAULT;
3647 player->StepFrame = 0;
3649 player->initial_element = player->element_nr;
3650 player->artwork_element =
3651 (level.use_artwork_element[i] ? level.artwork_element[i] :
3652 player->element_nr);
3653 player->use_murphy = FALSE;
3655 player->block_last_field = FALSE; // initialized in InitPlayerField()
3656 player->block_delay_adjustment = 0; // initialized in InitPlayerField()
3658 player->gravity = level.initial_player_gravity[i];
3660 player->can_fall_into_acid = CAN_MOVE_INTO_ACID(player->element_nr);
3662 player->actual_frame_counter = 0;
3664 player->step_counter = 0;
3666 player->last_move_dir = initial_move_dir;
3668 player->is_active = FALSE;
3670 player->is_waiting = FALSE;
3671 player->is_moving = FALSE;
3672 player->is_auto_moving = FALSE;
3673 player->is_digging = FALSE;
3674 player->is_snapping = FALSE;
3675 player->is_collecting = FALSE;
3676 player->is_pushing = FALSE;
3677 player->is_switching = FALSE;
3678 player->is_dropping = FALSE;
3679 player->is_dropping_pressed = FALSE;
3681 player->is_bored = FALSE;
3682 player->is_sleeping = FALSE;
3684 player->was_waiting = TRUE;
3685 player->was_moving = FALSE;
3686 player->was_snapping = FALSE;
3687 player->was_dropping = FALSE;
3689 player->force_dropping = FALSE;
3691 player->frame_counter_bored = -1;
3692 player->frame_counter_sleeping = -1;
3694 player->anim_delay_counter = 0;
3695 player->post_delay_counter = 0;
3697 player->dir_waiting = initial_move_dir;
3698 player->action_waiting = ACTION_DEFAULT;
3699 player->last_action_waiting = ACTION_DEFAULT;
3700 player->special_action_bored = ACTION_DEFAULT;
3701 player->special_action_sleeping = ACTION_DEFAULT;
3703 player->switch_x = -1;
3704 player->switch_y = -1;
3706 player->drop_x = -1;
3707 player->drop_y = -1;
3709 player->show_envelope = 0;
3711 SetPlayerMoveSpeed(player, level.initial_player_stepsize[i], TRUE);
3713 player->push_delay = -1; // initialized when pushing starts
3714 player->push_delay_value = game.initial_push_delay_value;
3716 player->drop_delay = 0;
3717 player->drop_pressed_delay = 0;
3719 player->last_jx = -1;
3720 player->last_jy = -1;
3724 player->shield_normal_time_left = 0;
3725 player->shield_deadly_time_left = 0;
3727 player->last_removed_element = EL_UNDEFINED;
3729 player->inventory_infinite_element = EL_UNDEFINED;
3730 player->inventory_size = 0;
3732 if (level.use_initial_inventory[i])
3734 for (j = 0; j < level.initial_inventory_size[i]; j++)
3736 int element = level.initial_inventory_content[i][j];
3737 int collect_count = element_info[element].collect_count_initial;
3740 if (!IS_CUSTOM_ELEMENT(element))
3743 if (collect_count == 0)
3744 player->inventory_infinite_element = element;
3746 for (k = 0; k < collect_count; k++)
3747 if (player->inventory_size < MAX_INVENTORY_SIZE)
3748 player->inventory_element[player->inventory_size++] = element;
3752 DigField(player, 0, 0, 0, 0, 0, 0, DF_NO_PUSH);
3753 SnapField(player, 0, 0);
3755 map_player_action[i] = i;
3758 network_player_action_received = FALSE;
3760 // initial null action
3761 if (network_playing)
3762 SendToServer_MovePlayer(MV_NONE);
3767 TimeLeft = level.time;
3770 ScreenMovDir = MV_NONE;
3774 ScrollStepSize = 0; // will be correctly initialized by ScrollScreen()
3776 game.robot_wheel_x = -1;
3777 game.robot_wheel_y = -1;
3782 game.all_players_gone = FALSE;
3784 game.LevelSolved = FALSE;
3785 game.GameOver = FALSE;
3787 game.GamePlayed = !tape.playing;
3789 game.LevelSolved_GameWon = FALSE;
3790 game.LevelSolved_GameEnd = FALSE;
3791 game.LevelSolved_SaveTape = FALSE;
3792 game.LevelSolved_SaveScore = FALSE;
3794 game.LevelSolved_CountingTime = 0;
3795 game.LevelSolved_CountingScore = 0;
3796 game.LevelSolved_CountingHealth = 0;
3798 game.panel.active = TRUE;
3800 game.no_time_limit = (level.time == 0);
3802 game.yamyam_content_nr = 0;
3803 game.robot_wheel_active = FALSE;
3804 game.magic_wall_active = FALSE;
3805 game.magic_wall_time_left = 0;
3806 game.light_time_left = 0;
3807 game.timegate_time_left = 0;
3808 game.switchgate_pos = 0;
3809 game.wind_direction = level.wind_direction_initial;
3811 game.time_final = 0;
3812 game.score_time_final = 0;
3815 game.score_final = 0;
3817 game.health = MAX_HEALTH;
3818 game.health_final = MAX_HEALTH;
3820 game.gems_still_needed = level.gems_needed;
3821 game.sokoban_fields_still_needed = 0;
3822 game.sokoban_objects_still_needed = 0;
3823 game.lights_still_needed = 0;
3824 game.players_still_needed = 0;
3825 game.friends_still_needed = 0;
3827 game.lenses_time_left = 0;
3828 game.magnify_time_left = 0;
3830 game.ball_active = level.ball_active_initial;
3831 game.ball_content_nr = 0;
3833 game.explosions_delayed = TRUE;
3835 game.envelope_active = FALSE;
3837 for (i = 0; i < NUM_BELTS; i++)
3839 game.belt_dir[i] = MV_NONE;
3840 game.belt_dir_nr[i] = 3; // not moving, next moving left
3843 for (i = 0; i < MAX_NUM_AMOEBA; i++)
3844 AmoebaCnt[i] = AmoebaCnt2[i] = 0;
3846 #if DEBUG_INIT_PLAYER
3847 DebugPrintPlayerStatus("Player status at level initialization");
3850 SCAN_PLAYFIELD(x, y)
3852 Tile[x][y] = Last[x][y] = level.field[x][y];
3853 MovPos[x][y] = MovDir[x][y] = MovDelay[x][y] = 0;
3854 ChangeDelay[x][y] = 0;
3855 ChangePage[x][y] = -1;
3856 CustomValue[x][y] = 0; // initialized in InitField()
3857 Store[x][y] = Store2[x][y] = StorePlayer[x][y] = Back[x][y] = 0;
3859 WasJustMoving[x][y] = 0;
3860 WasJustFalling[x][y] = 0;
3861 CheckCollision[x][y] = 0;
3862 CheckImpact[x][y] = 0;
3864 Pushed[x][y] = FALSE;
3866 ChangeCount[x][y] = 0;
3867 ChangeEvent[x][y] = -1;
3869 ExplodePhase[x][y] = 0;
3870 ExplodeDelay[x][y] = 0;
3871 ExplodeField[x][y] = EX_TYPE_NONE;
3873 RunnerVisit[x][y] = 0;
3874 PlayerVisit[x][y] = 0;
3877 GfxRandom[x][y] = INIT_GFX_RANDOM();
3878 GfxElement[x][y] = EL_UNDEFINED;
3879 GfxAction[x][y] = ACTION_DEFAULT;
3880 GfxDir[x][y] = MV_NONE;
3881 GfxRedraw[x][y] = GFX_REDRAW_NONE;
3884 SCAN_PLAYFIELD(x, y)
3886 if (emulate_bd && !IS_BD_ELEMENT(Tile[x][y]))
3888 if (emulate_sp && !IS_SP_ELEMENT(Tile[x][y]))
3891 InitField(x, y, TRUE);
3893 ResetGfxAnimation(x, y);
3898 for (i = 0; i < MAX_PLAYERS; i++)
3900 struct PlayerInfo *player = &stored_player[i];
3902 // set number of special actions for bored and sleeping animation
3903 player->num_special_action_bored =
3904 get_num_special_action(player->artwork_element,
3905 ACTION_BORING_1, ACTION_BORING_LAST);
3906 player->num_special_action_sleeping =
3907 get_num_special_action(player->artwork_element,
3908 ACTION_SLEEPING_1, ACTION_SLEEPING_LAST);
3911 game.emulation = (emulate_bd ? EMU_BOULDERDASH :
3912 emulate_sp ? EMU_SUPAPLEX : EMU_NONE);
3914 // initialize type of slippery elements
3915 for (i = 0; i < MAX_NUM_ELEMENTS; i++)
3917 if (!IS_CUSTOM_ELEMENT(i))
3919 // default: elements slip down either to the left or right randomly
3920 element_info[i].slippery_type = SLIPPERY_ANY_RANDOM;
3922 // SP style elements prefer to slip down on the left side
3923 if (game.engine_version >= VERSION_IDENT(3,1,1,0) && IS_SP_ELEMENT(i))
3924 element_info[i].slippery_type = SLIPPERY_ANY_LEFT_RIGHT;
3926 // BD style elements prefer to slip down on the left side
3927 if (game.emulation == EMU_BOULDERDASH)
3928 element_info[i].slippery_type = SLIPPERY_ANY_LEFT_RIGHT;
3932 // initialize explosion and ignition delay
3933 for (i = 0; i < MAX_NUM_ELEMENTS; i++)
3935 if (!IS_CUSTOM_ELEMENT(i))
3938 int delay = (((IS_SP_ELEMENT(i) && i != EL_EMPTY_SPACE) &&
3939 game.engine_version >= VERSION_IDENT(3,1,0,0)) ||
3940 game.emulation == EMU_SUPAPLEX ? 3 : 2);
3941 int last_phase = (num_phase + 1) * delay;
3942 int half_phase = (num_phase / 2) * delay;
3944 element_info[i].explosion_delay = last_phase - 1;
3945 element_info[i].ignition_delay = half_phase;
3947 if (i == EL_BLACK_ORB)
3948 element_info[i].ignition_delay = 1;
3952 // correct non-moving belts to start moving left
3953 for (i = 0; i < NUM_BELTS; i++)
3954 if (game.belt_dir[i] == MV_NONE)
3955 game.belt_dir_nr[i] = 3; // not moving, next moving left
3957 #if USE_NEW_PLAYER_ASSIGNMENTS
3958 // use preferred player also in local single-player mode
3959 if (!network.enabled && !game.team_mode)
3961 int new_index_nr = setup.network_player_nr;
3963 if (new_index_nr >= 0 && new_index_nr < MAX_PLAYERS)
3965 for (i = 0; i < MAX_PLAYERS; i++)
3966 stored_player[i].connected_locally = FALSE;
3968 stored_player[new_index_nr].connected_locally = TRUE;
3972 for (i = 0; i < MAX_PLAYERS; i++)
3974 stored_player[i].connected = FALSE;
3976 // in network game mode, the local player might not be the first player
3977 if (stored_player[i].connected_locally)
3978 local_player = &stored_player[i];
3981 if (!network.enabled)
3982 local_player->connected = TRUE;
3986 for (i = 0; i < MAX_PLAYERS; i++)
3987 stored_player[i].connected = tape.player_participates[i];
3989 else if (network.enabled)
3991 // add team mode players connected over the network (needed for correct
3992 // assignment of player figures from level to locally playing players)
3994 for (i = 0; i < MAX_PLAYERS; i++)
3995 if (stored_player[i].connected_network)
3996 stored_player[i].connected = TRUE;
3998 else if (game.team_mode)
4000 // try to guess locally connected team mode players (needed for correct
4001 // assignment of player figures from level to locally playing players)
4003 for (i = 0; i < MAX_PLAYERS; i++)
4004 if (setup.input[i].use_joystick ||
4005 setup.input[i].key.left != KSYM_UNDEFINED)
4006 stored_player[i].connected = TRUE;
4009 #if DEBUG_INIT_PLAYER
4010 DebugPrintPlayerStatus("Player status after level initialization");
4013 #if DEBUG_INIT_PLAYER
4014 Debug("game:init:player", "Reassigning players ...");
4017 // check if any connected player was not found in playfield
4018 for (i = 0; i < MAX_PLAYERS; i++)
4020 struct PlayerInfo *player = &stored_player[i];
4022 if (player->connected && !player->present)
4024 struct PlayerInfo *field_player = NULL;
4026 #if DEBUG_INIT_PLAYER
4027 Debug("game:init:player",
4028 "- looking for field player for player %d ...", i + 1);
4031 // assign first free player found that is present in the playfield
4033 // first try: look for unmapped playfield player that is not connected
4034 for (j = 0; j < MAX_PLAYERS; j++)
4035 if (field_player == NULL &&
4036 stored_player[j].present &&
4037 !stored_player[j].mapped &&
4038 !stored_player[j].connected)
4039 field_player = &stored_player[j];
4041 // second try: look for *any* unmapped playfield player
4042 for (j = 0; j < MAX_PLAYERS; j++)
4043 if (field_player == NULL &&
4044 stored_player[j].present &&
4045 !stored_player[j].mapped)
4046 field_player = &stored_player[j];
4048 if (field_player != NULL)
4050 int jx = field_player->jx, jy = field_player->jy;
4052 #if DEBUG_INIT_PLAYER
4053 Debug("game:init:player", "- found player %d",
4054 field_player->index_nr + 1);
4057 player->present = FALSE;
4058 player->active = FALSE;
4060 field_player->present = TRUE;
4061 field_player->active = TRUE;
4064 player->initial_element = field_player->initial_element;
4065 player->artwork_element = field_player->artwork_element;
4067 player->block_last_field = field_player->block_last_field;
4068 player->block_delay_adjustment = field_player->block_delay_adjustment;
4071 StorePlayer[jx][jy] = field_player->element_nr;
4073 field_player->jx = field_player->last_jx = jx;
4074 field_player->jy = field_player->last_jy = jy;
4076 if (local_player == player)
4077 local_player = field_player;
4079 map_player_action[field_player->index_nr] = i;
4081 field_player->mapped = TRUE;
4083 #if DEBUG_INIT_PLAYER
4084 Debug("game:init:player", "- map_player_action[%d] == %d",
4085 field_player->index_nr + 1, i + 1);
4090 if (player->connected && player->present)
4091 player->mapped = TRUE;
4094 #if DEBUG_INIT_PLAYER
4095 DebugPrintPlayerStatus("Player status after player assignment (first stage)");
4100 // check if any connected player was not found in playfield
4101 for (i = 0; i < MAX_PLAYERS; i++)
4103 struct PlayerInfo *player = &stored_player[i];
4105 if (player->connected && !player->present)
4107 for (j = 0; j < MAX_PLAYERS; j++)
4109 struct PlayerInfo *field_player = &stored_player[j];
4110 int jx = field_player->jx, jy = field_player->jy;
4112 // assign first free player found that is present in the playfield
4113 if (field_player->present && !field_player->connected)
4115 player->present = TRUE;
4116 player->active = TRUE;
4118 field_player->present = FALSE;
4119 field_player->active = FALSE;
4121 player->initial_element = field_player->initial_element;
4122 player->artwork_element = field_player->artwork_element;
4124 player->block_last_field = field_player->block_last_field;
4125 player->block_delay_adjustment = field_player->block_delay_adjustment;
4127 StorePlayer[jx][jy] = player->element_nr;
4129 player->jx = player->last_jx = jx;
4130 player->jy = player->last_jy = jy;
4140 Debug("game:init:player", "local_player->present == %d",
4141 local_player->present);
4144 // set focus to local player for network games, else to all players
4145 game.centered_player_nr = (network_playing ? local_player->index_nr : -1);
4146 game.centered_player_nr_next = game.centered_player_nr;
4147 game.set_centered_player = FALSE;
4148 game.set_centered_player_wrap = FALSE;
4150 if (network_playing && tape.recording)
4152 // store client dependent player focus when recording network games
4153 tape.centered_player_nr_next = game.centered_player_nr_next;
4154 tape.set_centered_player = TRUE;
4159 // when playing a tape, eliminate all players who do not participate
4161 #if USE_NEW_PLAYER_ASSIGNMENTS
4163 if (!game.team_mode)
4165 for (i = 0; i < MAX_PLAYERS; i++)
4167 if (stored_player[i].active &&
4168 !tape.player_participates[map_player_action[i]])
4170 struct PlayerInfo *player = &stored_player[i];
4171 int jx = player->jx, jy = player->jy;
4173 #if DEBUG_INIT_PLAYER
4174 Debug("game:init:player", "Removing player %d at (%d, %d)",
4178 player->active = FALSE;
4179 StorePlayer[jx][jy] = 0;
4180 Tile[jx][jy] = EL_EMPTY;
4187 for (i = 0; i < MAX_PLAYERS; i++)
4189 if (stored_player[i].active &&
4190 !tape.player_participates[i])
4192 struct PlayerInfo *player = &stored_player[i];
4193 int jx = player->jx, jy = player->jy;
4195 player->active = FALSE;
4196 StorePlayer[jx][jy] = 0;
4197 Tile[jx][jy] = EL_EMPTY;
4202 else if (!network.enabled && !game.team_mode) // && !tape.playing
4204 // when in single player mode, eliminate all but the local player
4206 for (i = 0; i < MAX_PLAYERS; i++)
4208 struct PlayerInfo *player = &stored_player[i];
4210 if (player->active && player != local_player)
4212 int jx = player->jx, jy = player->jy;
4214 player->active = FALSE;
4215 player->present = FALSE;
4217 StorePlayer[jx][jy] = 0;
4218 Tile[jx][jy] = EL_EMPTY;
4223 for (i = 0; i < MAX_PLAYERS; i++)
4224 if (stored_player[i].active)
4225 game.players_still_needed++;
4227 if (level.solved_by_one_player)
4228 game.players_still_needed = 1;
4230 // when recording the game, store which players take part in the game
4233 #if USE_NEW_PLAYER_ASSIGNMENTS
4234 for (i = 0; i < MAX_PLAYERS; i++)
4235 if (stored_player[i].connected)
4236 tape.player_participates[i] = TRUE;
4238 for (i = 0; i < MAX_PLAYERS; i++)
4239 if (stored_player[i].active)
4240 tape.player_participates[i] = TRUE;
4244 #if DEBUG_INIT_PLAYER
4245 DebugPrintPlayerStatus("Player status after player assignment (final stage)");
4248 if (BorderElement == EL_EMPTY)
4251 SBX_Right = lev_fieldx - SCR_FIELDX;
4253 SBY_Lower = lev_fieldy - SCR_FIELDY;
4258 SBX_Right = lev_fieldx - SCR_FIELDX + 1;
4260 SBY_Lower = lev_fieldy - SCR_FIELDY + 1;
4263 if (full_lev_fieldx <= SCR_FIELDX)
4264 SBX_Left = SBX_Right = -1 * (SCR_FIELDX - lev_fieldx) / 2;
4265 if (full_lev_fieldy <= SCR_FIELDY)
4266 SBY_Upper = SBY_Lower = -1 * (SCR_FIELDY - lev_fieldy) / 2;
4268 if (EVEN(SCR_FIELDX) && full_lev_fieldx > SCR_FIELDX)
4270 if (EVEN(SCR_FIELDY) && full_lev_fieldy > SCR_FIELDY)
4273 // if local player not found, look for custom element that might create
4274 // the player (make some assumptions about the right custom element)
4275 if (!local_player->present)
4277 int start_x = 0, start_y = 0;
4278 int found_rating = 0;
4279 int found_element = EL_UNDEFINED;
4280 int player_nr = local_player->index_nr;
4282 SCAN_PLAYFIELD(x, y)
4284 int element = Tile[x][y];
4289 if (level.use_start_element[player_nr] &&
4290 level.start_element[player_nr] == element &&
4297 found_element = element;
4300 if (!IS_CUSTOM_ELEMENT(element))
4303 if (CAN_CHANGE(element))
4305 for (i = 0; i < element_info[element].num_change_pages; i++)
4307 // check for player created from custom element as single target
4308 content = element_info[element].change_page[i].target_element;
4309 is_player = IS_PLAYER_ELEMENT(content);
4311 if (is_player && (found_rating < 3 ||
4312 (found_rating == 3 && element < found_element)))
4318 found_element = element;
4323 for (yy = 0; yy < 3; yy++) for (xx = 0; xx < 3; xx++)
4325 // check for player created from custom element as explosion content
4326 content = element_info[element].content.e[xx][yy];
4327 is_player = IS_PLAYER_ELEMENT(content);
4329 if (is_player && (found_rating < 2 ||
4330 (found_rating == 2 && element < found_element)))
4332 start_x = x + xx - 1;
4333 start_y = y + yy - 1;
4336 found_element = element;
4339 if (!CAN_CHANGE(element))
4342 for (i = 0; i < element_info[element].num_change_pages; i++)
4344 // check for player created from custom element as extended target
4346 element_info[element].change_page[i].target_content.e[xx][yy];
4348 is_player = IS_PLAYER_ELEMENT(content);
4350 if (is_player && (found_rating < 1 ||
4351 (found_rating == 1 && element < found_element)))
4353 start_x = x + xx - 1;
4354 start_y = y + yy - 1;
4357 found_element = element;
4363 scroll_x = SCROLL_POSITION_X(start_x);
4364 scroll_y = SCROLL_POSITION_Y(start_y);
4368 scroll_x = SCROLL_POSITION_X(local_player->jx);
4369 scroll_y = SCROLL_POSITION_Y(local_player->jy);
4372 // !!! FIX THIS (START) !!!
4373 if (level.game_engine_type == GAME_ENGINE_TYPE_EM)
4375 InitGameEngine_EM();
4377 else if (level.game_engine_type == GAME_ENGINE_TYPE_SP)
4379 InitGameEngine_SP();
4381 else if (level.game_engine_type == GAME_ENGINE_TYPE_MM)
4383 InitGameEngine_MM();
4387 DrawLevel(REDRAW_FIELD);
4390 // after drawing the level, correct some elements
4391 if (game.timegate_time_left == 0)
4392 CloseAllOpenTimegates();
4395 // blit playfield from scroll buffer to normal back buffer for fading in
4396 BlitScreenToBitmap(backbuffer);
4397 // !!! FIX THIS (END) !!!
4399 DrawMaskedBorder(fade_mask);
4404 // full screen redraw is required at this point in the following cases:
4405 // - special editor door undrawn when game was started from level editor
4406 // - drawing area (playfield) was changed and has to be removed completely
4407 redraw_mask = REDRAW_ALL;
4411 if (!game.restart_level)
4413 // copy default game door content to main double buffer
4415 // !!! CHECK AGAIN !!!
4416 SetPanelBackground();
4417 // SetDoorBackgroundImage(IMG_BACKGROUND_PANEL);
4418 DrawBackground(DX, DY, DXSIZE, DYSIZE);
4421 SetPanelBackground();
4422 SetDrawBackgroundMask(REDRAW_DOOR_1);
4424 UpdateAndDisplayGameControlValues();
4426 if (!game.restart_level)
4432 CreateGameButtons();
4437 // copy actual game door content to door double buffer for OpenDoor()
4438 BlitBitmap(drawto, bitmap_db_door_1, DX, DY, DXSIZE, DYSIZE, 0, 0);
4440 OpenDoor(DOOR_OPEN_ALL);
4442 KeyboardAutoRepeatOffUnlessAutoplay();
4444 #if DEBUG_INIT_PLAYER
4445 DebugPrintPlayerStatus("Player status (final)");
4454 if (!game.restart_level && !tape.playing)
4456 LevelStats_incPlayed(level_nr);
4458 SaveLevelSetup_SeriesInfo();
4461 game.restart_level = FALSE;
4462 game.restart_game_message = NULL;
4464 game.request_active = FALSE;
4465 game.request_active_or_moving = FALSE;
4467 if (level.game_engine_type == GAME_ENGINE_TYPE_MM)
4468 InitGameActions_MM();
4470 SaveEngineSnapshotToListInitial();
4472 if (!game.restart_level)
4474 PlaySound(SND_GAME_STARTING);
4476 if (setup.sound_music)
4481 void UpdateEngineValues(int actual_scroll_x, int actual_scroll_y,
4482 int actual_player_x, int actual_player_y)
4484 // this is used for non-R'n'D game engines to update certain engine values
4486 // needed to determine if sounds are played within the visible screen area
4487 scroll_x = actual_scroll_x;
4488 scroll_y = actual_scroll_y;
4490 // needed to get player position for "follow finger" playing input method
4491 local_player->jx = actual_player_x;
4492 local_player->jy = actual_player_y;
4495 void InitMovDir(int x, int y)
4497 int i, element = Tile[x][y];
4498 static int xy[4][2] =
4505 static int direction[3][4] =
4507 { MV_RIGHT, MV_UP, MV_LEFT, MV_DOWN },
4508 { MV_LEFT, MV_DOWN, MV_RIGHT, MV_UP },
4509 { MV_LEFT, MV_RIGHT, MV_UP, MV_DOWN }
4518 Tile[x][y] = EL_BUG;
4519 MovDir[x][y] = direction[0][element - EL_BUG_RIGHT];
4522 case EL_SPACESHIP_RIGHT:
4523 case EL_SPACESHIP_UP:
4524 case EL_SPACESHIP_LEFT:
4525 case EL_SPACESHIP_DOWN:
4526 Tile[x][y] = EL_SPACESHIP;
4527 MovDir[x][y] = direction[0][element - EL_SPACESHIP_RIGHT];
4530 case EL_BD_BUTTERFLY_RIGHT:
4531 case EL_BD_BUTTERFLY_UP:
4532 case EL_BD_BUTTERFLY_LEFT:
4533 case EL_BD_BUTTERFLY_DOWN:
4534 Tile[x][y] = EL_BD_BUTTERFLY;
4535 MovDir[x][y] = direction[0][element - EL_BD_BUTTERFLY_RIGHT];
4538 case EL_BD_FIREFLY_RIGHT:
4539 case EL_BD_FIREFLY_UP:
4540 case EL_BD_FIREFLY_LEFT:
4541 case EL_BD_FIREFLY_DOWN:
4542 Tile[x][y] = EL_BD_FIREFLY;
4543 MovDir[x][y] = direction[0][element - EL_BD_FIREFLY_RIGHT];
4546 case EL_PACMAN_RIGHT:
4548 case EL_PACMAN_LEFT:
4549 case EL_PACMAN_DOWN:
4550 Tile[x][y] = EL_PACMAN;
4551 MovDir[x][y] = direction[0][element - EL_PACMAN_RIGHT];
4554 case EL_YAMYAM_LEFT:
4555 case EL_YAMYAM_RIGHT:
4557 case EL_YAMYAM_DOWN:
4558 Tile[x][y] = EL_YAMYAM;
4559 MovDir[x][y] = direction[2][element - EL_YAMYAM_LEFT];
4562 case EL_SP_SNIKSNAK:
4563 MovDir[x][y] = MV_UP;
4566 case EL_SP_ELECTRON:
4567 MovDir[x][y] = MV_LEFT;
4574 Tile[x][y] = EL_MOLE;
4575 MovDir[x][y] = direction[2][element - EL_MOLE_LEFT];
4578 case EL_SPRING_LEFT:
4579 case EL_SPRING_RIGHT:
4580 Tile[x][y] = EL_SPRING;
4581 MovDir[x][y] = direction[2][element - EL_SPRING_LEFT];
4585 if (IS_CUSTOM_ELEMENT(element))
4587 struct ElementInfo *ei = &element_info[element];
4588 int move_direction_initial = ei->move_direction_initial;
4589 int move_pattern = ei->move_pattern;
4591 if (move_direction_initial == MV_START_PREVIOUS)
4593 if (MovDir[x][y] != MV_NONE)
4596 move_direction_initial = MV_START_AUTOMATIC;
4599 if (move_direction_initial == MV_START_RANDOM)
4600 MovDir[x][y] = 1 << RND(4);
4601 else if (move_direction_initial & MV_ANY_DIRECTION)
4602 MovDir[x][y] = move_direction_initial;
4603 else if (move_pattern == MV_ALL_DIRECTIONS ||
4604 move_pattern == MV_TURNING_LEFT ||
4605 move_pattern == MV_TURNING_RIGHT ||
4606 move_pattern == MV_TURNING_LEFT_RIGHT ||
4607 move_pattern == MV_TURNING_RIGHT_LEFT ||
4608 move_pattern == MV_TURNING_RANDOM)
4609 MovDir[x][y] = 1 << RND(4);
4610 else if (move_pattern == MV_HORIZONTAL)
4611 MovDir[x][y] = (RND(2) ? MV_LEFT : MV_RIGHT);
4612 else if (move_pattern == MV_VERTICAL)
4613 MovDir[x][y] = (RND(2) ? MV_UP : MV_DOWN);
4614 else if (move_pattern & MV_ANY_DIRECTION)
4615 MovDir[x][y] = element_info[element].move_pattern;
4616 else if (move_pattern == MV_ALONG_LEFT_SIDE ||
4617 move_pattern == MV_ALONG_RIGHT_SIDE)
4619 // use random direction as default start direction
4620 if (game.engine_version >= VERSION_IDENT(3,1,0,0))
4621 MovDir[x][y] = 1 << RND(4);
4623 for (i = 0; i < NUM_DIRECTIONS; i++)
4625 int x1 = x + xy[i][0];
4626 int y1 = y + xy[i][1];
4628 if (!IN_LEV_FIELD(x1, y1) || !IS_FREE(x1, y1))
4630 if (move_pattern == MV_ALONG_RIGHT_SIDE)
4631 MovDir[x][y] = direction[0][i];
4633 MovDir[x][y] = direction[1][i];
4642 MovDir[x][y] = 1 << RND(4);
4644 if (element != EL_BUG &&
4645 element != EL_SPACESHIP &&
4646 element != EL_BD_BUTTERFLY &&
4647 element != EL_BD_FIREFLY)
4650 for (i = 0; i < NUM_DIRECTIONS; i++)
4652 int x1 = x + xy[i][0];
4653 int y1 = y + xy[i][1];
4655 if (!IN_LEV_FIELD(x1, y1) || !IS_FREE(x1, y1))
4657 if (element == EL_BUG || element == EL_BD_BUTTERFLY)
4659 MovDir[x][y] = direction[0][i];
4662 else if (element == EL_SPACESHIP || element == EL_BD_FIREFLY ||
4663 element == EL_SP_SNIKSNAK || element == EL_SP_ELECTRON)
4665 MovDir[x][y] = direction[1][i];
4674 GfxDir[x][y] = MovDir[x][y];
4677 void InitAmoebaNr(int x, int y)
4680 int group_nr = AmoebaNeighbourNr(x, y);
4684 for (i = 1; i < MAX_NUM_AMOEBA; i++)
4686 if (AmoebaCnt[i] == 0)
4694 AmoebaNr[x][y] = group_nr;
4695 AmoebaCnt[group_nr]++;
4696 AmoebaCnt2[group_nr]++;
4699 static void LevelSolved_SetFinalGameValues(void)
4701 game.time_final = (game.no_time_limit ? TimePlayed : TimeLeft);
4702 game.score_time_final = (level.use_step_counter ? TimePlayed :
4703 TimePlayed * FRAMES_PER_SECOND + TimeFrames);
4705 game.score_final = (level.game_engine_type == GAME_ENGINE_TYPE_EM ?
4706 game_em.lev->score :
4707 level.game_engine_type == GAME_ENGINE_TYPE_MM ?
4711 game.health_final = (level.game_engine_type == GAME_ENGINE_TYPE_MM ?
4712 MM_HEALTH(game_mm.laser_overload_value) :
4715 game.LevelSolved_CountingTime = game.time_final;
4716 game.LevelSolved_CountingScore = game.score_final;
4717 game.LevelSolved_CountingHealth = game.health_final;
4720 static void LevelSolved_DisplayFinalGameValues(int time, int score, int health)
4722 game.LevelSolved_CountingTime = time;
4723 game.LevelSolved_CountingScore = score;
4724 game.LevelSolved_CountingHealth = health;
4726 game_panel_controls[GAME_PANEL_TIME].value = time;
4727 game_panel_controls[GAME_PANEL_SCORE].value = score;
4728 game_panel_controls[GAME_PANEL_HEALTH].value = health;
4730 DisplayGameControlValues();
4733 static void LevelSolved(void)
4735 if (level.game_engine_type == GAME_ENGINE_TYPE_RND &&
4736 game.players_still_needed > 0)
4739 game.LevelSolved = TRUE;
4740 game.GameOver = TRUE;
4742 // needed here to display correct panel values while player walks into exit
4743 LevelSolved_SetFinalGameValues();
4748 static int time_count_steps;
4749 static int time, time_final;
4750 static float score, score_final; // needed for time score < 10 for 10 seconds
4751 static int health, health_final;
4752 static int game_over_delay_1 = 0;
4753 static int game_over_delay_2 = 0;
4754 static int game_over_delay_3 = 0;
4755 int time_score_base = MIN(MAX(1, level.time_score_base), 10);
4756 float time_score = (float)level.score[SC_TIME_BONUS] / time_score_base;
4758 if (!game.LevelSolved_GameWon)
4762 // do not start end game actions before the player stops moving (to exit)
4763 if (local_player->active && local_player->MovPos)
4766 // calculate final game values after player finished walking into exit
4767 LevelSolved_SetFinalGameValues();
4769 game.LevelSolved_GameWon = TRUE;
4770 game.LevelSolved_SaveTape = tape.recording;
4771 game.LevelSolved_SaveScore = !tape.playing;
4775 LevelStats_incSolved(level_nr);
4777 SaveLevelSetup_SeriesInfo();
4780 if (tape.auto_play) // tape might already be stopped here
4781 tape.auto_play_level_solved = TRUE;
4785 game_over_delay_1 = FRAMES_PER_SECOND; // delay before counting time
4786 game_over_delay_2 = FRAMES_PER_SECOND / 2; // delay before counting health
4787 game_over_delay_3 = FRAMES_PER_SECOND; // delay before ending the game
4789 time = time_final = game.time_final;
4790 score = score_final = game.score_final;
4791 health = health_final = game.health_final;
4793 // update game panel values before (delayed) counting of score (if any)
4794 LevelSolved_DisplayFinalGameValues(time, score, health);
4796 // if level has time score defined, calculate new final game values
4799 int time_final_max = 999;
4800 int time_frames_final_max = time_final_max * FRAMES_PER_SECOND;
4801 int time_frames = 0;
4802 int time_frames_left = TimeLeft * FRAMES_PER_SECOND - TimeFrames;
4803 int time_frames_played = TimePlayed * FRAMES_PER_SECOND + TimeFrames;
4808 time_frames = time_frames_left;
4810 else if (game.no_time_limit && TimePlayed < time_final_max)
4812 time_final = time_final_max;
4813 time_frames = time_frames_final_max - time_frames_played;
4816 score_final += time_score * time_frames / FRAMES_PER_SECOND + 0.5;
4818 time_count_steps = MAX(1, ABS(time_final - time) / 100);
4820 if (level.game_engine_type == GAME_ENGINE_TYPE_MM)
4823 score_final += health * time_score;
4826 game.score_final = score_final;
4827 game.health_final = health_final;
4830 // if not counting score after game, immediately update game panel values
4831 if (level_editor_test_game || !setup.count_score_after_game)
4834 score = score_final;
4836 LevelSolved_DisplayFinalGameValues(time, score, health);
4839 if (level.game_engine_type == GAME_ENGINE_TYPE_RND)
4841 // check if last player has left the level
4842 if (game.exit_x >= 0 &&
4845 int x = game.exit_x;
4846 int y = game.exit_y;
4847 int element = Tile[x][y];
4849 // close exit door after last player
4850 if ((game.all_players_gone &&
4851 (element == EL_EXIT_OPEN ||
4852 element == EL_SP_EXIT_OPEN ||
4853 element == EL_STEEL_EXIT_OPEN)) ||
4854 element == EL_EM_EXIT_OPEN ||
4855 element == EL_EM_STEEL_EXIT_OPEN)
4859 (element == EL_EXIT_OPEN ? EL_EXIT_CLOSING :
4860 element == EL_EM_EXIT_OPEN ? EL_EM_EXIT_CLOSING :
4861 element == EL_SP_EXIT_OPEN ? EL_SP_EXIT_CLOSING:
4862 element == EL_STEEL_EXIT_OPEN ? EL_STEEL_EXIT_CLOSING:
4863 EL_EM_STEEL_EXIT_CLOSING);
4865 PlayLevelSoundElementAction(x, y, element, ACTION_CLOSING);
4868 // player disappears
4869 DrawLevelField(x, y);
4872 for (i = 0; i < MAX_PLAYERS; i++)
4874 struct PlayerInfo *player = &stored_player[i];
4876 if (player->present)
4878 RemovePlayer(player);
4880 // player disappears
4881 DrawLevelField(player->jx, player->jy);
4886 PlaySound(SND_GAME_WINNING);
4889 if (setup.count_score_after_game)
4891 if (time != time_final)
4893 if (game_over_delay_1 > 0)
4895 game_over_delay_1--;
4900 int time_to_go = ABS(time_final - time);
4901 int time_count_dir = (time < time_final ? +1 : -1);
4903 if (time_to_go < time_count_steps)
4904 time_count_steps = 1;
4906 time += time_count_steps * time_count_dir;
4907 score += time_count_steps * time_score;
4909 // set final score to correct rounding differences after counting score
4910 if (time == time_final)
4911 score = score_final;
4913 LevelSolved_DisplayFinalGameValues(time, score, health);
4915 if (time == time_final)
4916 StopSound(SND_GAME_LEVELTIME_BONUS);
4917 else if (setup.sound_loops)
4918 PlaySoundLoop(SND_GAME_LEVELTIME_BONUS);
4920 PlaySound(SND_GAME_LEVELTIME_BONUS);
4925 if (health != health_final)
4927 if (game_over_delay_2 > 0)
4929 game_over_delay_2--;
4934 int health_count_dir = (health < health_final ? +1 : -1);
4936 health += health_count_dir;
4937 score += time_score;
4939 LevelSolved_DisplayFinalGameValues(time, score, health);
4941 if (health == health_final)
4942 StopSound(SND_GAME_LEVELTIME_BONUS);
4943 else if (setup.sound_loops)
4944 PlaySoundLoop(SND_GAME_LEVELTIME_BONUS);
4946 PlaySound(SND_GAME_LEVELTIME_BONUS);
4952 game.panel.active = FALSE;
4954 if (game_over_delay_3 > 0)
4956 game_over_delay_3--;
4966 // used instead of "level_nr" (needed for network games)
4967 int last_level_nr = levelset.level_nr;
4968 boolean tape_saved = FALSE;
4970 game.LevelSolved_GameEnd = TRUE;
4972 if (game.LevelSolved_SaveTape)
4974 // make sure that request dialog to save tape does not open door again
4975 if (!global.use_envelope_request)
4976 CloseDoor(DOOR_CLOSE_1);
4979 tape_saved = SaveTapeChecked_LevelSolved(tape.level_nr);
4981 // set unique basename for score tape (also saved in high score table)
4982 strcpy(tape.score_tape_basename, getScoreTapeBasename(setup.player_name));
4985 // if no tape is to be saved, close both doors simultaneously
4986 CloseDoor(DOOR_CLOSE_ALL);
4988 if (level_editor_test_game)
4990 SetGameStatus(GAME_MODE_MAIN);
4997 if (!game.LevelSolved_SaveScore)
4999 SetGameStatus(GAME_MODE_MAIN);
5006 if (level_nr == leveldir_current->handicap_level)
5008 leveldir_current->handicap_level++;
5010 SaveLevelSetup_SeriesInfo();
5013 // save score and score tape before potentially erasing tape below
5014 NewHighScore(last_level_nr, tape_saved);
5016 if (setup.increment_levels &&
5017 level_nr < leveldir_current->last_level &&
5020 level_nr++; // advance to next level
5021 TapeErase(); // start with empty tape
5023 if (setup.auto_play_next_level)
5025 LoadLevel(level_nr);
5027 SaveLevelSetup_SeriesInfo();
5031 if (scores.last_added >= 0 && setup.show_scores_after_game)
5033 SetGameStatus(GAME_MODE_SCORES);
5035 DrawHallOfFame(last_level_nr);
5037 else if (setup.auto_play_next_level && setup.increment_levels &&
5038 last_level_nr < leveldir_current->last_level &&
5041 StartGameActions(network.enabled, setup.autorecord, level.random_seed);
5045 SetGameStatus(GAME_MODE_MAIN);
5051 static int addScoreEntry(struct ScoreInfo *list, struct ScoreEntry *new_entry,
5052 boolean one_score_entry_per_name)
5056 if (strEqual(new_entry->name, EMPTY_PLAYER_NAME))
5059 for (i = 0; i < MAX_SCORE_ENTRIES; i++)
5061 struct ScoreEntry *entry = &list->entry[i];
5062 boolean score_is_better = (new_entry->score > entry->score);
5063 boolean score_is_equal = (new_entry->score == entry->score);
5064 boolean time_is_better = (new_entry->time < entry->time);
5065 boolean time_is_equal = (new_entry->time == entry->time);
5066 boolean better_by_score = (score_is_better ||
5067 (score_is_equal && time_is_better));
5068 boolean better_by_time = (time_is_better ||
5069 (time_is_equal && score_is_better));
5070 boolean is_better = (level.rate_time_over_score ? better_by_time :
5072 boolean entry_is_empty = (entry->score == 0 &&
5075 // prevent adding server score entries if also existing in local score file
5076 // (special case: historic score entries have an empty tape basename entry)
5077 if (strEqual(new_entry->tape_basename, entry->tape_basename) &&
5078 !strEqual(new_entry->tape_basename, UNDEFINED_FILENAME))
5081 if (is_better || entry_is_empty)
5083 // player has made it to the hall of fame
5085 if (i < MAX_SCORE_ENTRIES - 1)
5087 int m = MAX_SCORE_ENTRIES - 1;
5090 if (one_score_entry_per_name)
5092 for (l = i; l < MAX_SCORE_ENTRIES; l++)
5093 if (strEqual(list->entry[l].name, new_entry->name))
5096 if (m == i) // player's new highscore overwrites his old one
5100 for (l = m; l > i; l--)
5101 list->entry[l] = list->entry[l - 1];
5106 *entry = *new_entry;
5110 else if (one_score_entry_per_name &&
5111 strEqual(entry->name, new_entry->name))
5113 // player already in high score list with better score or time
5122 void NewHighScore(int level_nr, boolean tape_saved)
5124 struct ScoreEntry new_entry = {{ 0 }}; // (prevent warning from GCC bug 53119)
5125 boolean one_per_name = FALSE;
5127 strncpy(new_entry.tape_basename, tape.score_tape_basename, MAX_FILENAME_LEN);
5128 strncpy(new_entry.name, setup.player_name, MAX_PLAYER_NAME_LEN);
5130 new_entry.score = game.score_final;
5131 new_entry.time = game.score_time_final;
5133 LoadScore(level_nr);
5135 scores.last_added = addScoreEntry(&scores, &new_entry, one_per_name);
5137 if (scores.last_added < 0)
5140 SaveScore(level_nr);
5142 // store last added local score entry (before merging server scores)
5143 scores.last_added_local = scores.last_added;
5145 if (!game.LevelSolved_SaveTape)
5148 SaveScoreTape(level_nr);
5150 if (setup.ask_for_using_api_server)
5152 setup.use_api_server =
5153 Request("Upload your score and tape to the high score server?", REQ_ASK);
5155 if (!setup.use_api_server)
5156 Request("Not using high score server! Use setup menu to enable again!",
5159 runtime.use_api_server = setup.use_api_server;
5161 // after asking for using API server once, do not ask again
5162 setup.ask_for_using_api_server = FALSE;
5164 SaveSetup_ServerSetup();
5167 SaveServerScore(level_nr, tape_saved);
5170 void MergeServerScore(void)
5172 struct ScoreEntry last_added_entry;
5173 boolean one_per_name = FALSE;
5176 if (scores.last_added >= 0)
5177 last_added_entry = scores.entry[scores.last_added];
5179 for (i = 0; i < server_scores.num_entries; i++)
5181 int pos = addScoreEntry(&scores, &server_scores.entry[i], one_per_name);
5183 if (pos >= 0 && pos <= scores.last_added)
5184 scores.last_added++;
5187 if (scores.last_added >= MAX_SCORE_ENTRIES)
5189 scores.last_added = MAX_SCORE_ENTRIES - 1;
5190 scores.force_last_added = TRUE;
5192 scores.entry[scores.last_added] = last_added_entry;
5196 static int getElementMoveStepsizeExt(int x, int y, int direction)
5198 int element = Tile[x][y];
5199 int dx = (direction == MV_LEFT ? -1 : direction == MV_RIGHT ? +1 : 0);
5200 int dy = (direction == MV_UP ? -1 : direction == MV_DOWN ? +1 : 0);
5201 int horiz_move = (dx != 0);
5202 int sign = (horiz_move ? dx : dy);
5203 int step = sign * element_info[element].move_stepsize;
5205 // special values for move stepsize for spring and things on conveyor belt
5208 if (CAN_FALL(element) &&
5209 y < lev_fieldy - 1 && IS_BELT_ACTIVE(Tile[x][y + 1]))
5210 step = sign * MOVE_STEPSIZE_NORMAL / 2;
5211 else if (element == EL_SPRING)
5212 step = sign * MOVE_STEPSIZE_NORMAL * 2;
5218 static int getElementMoveStepsize(int x, int y)
5220 return getElementMoveStepsizeExt(x, y, MovDir[x][y]);
5223 void InitPlayerGfxAnimation(struct PlayerInfo *player, int action, int dir)
5225 if (player->GfxAction != action || player->GfxDir != dir)
5227 player->GfxAction = action;
5228 player->GfxDir = dir;
5230 player->StepFrame = 0;
5234 static void ResetGfxFrame(int x, int y)
5236 // profiling showed that "autotest" spends 10~20% of its time in this function
5237 if (DrawingDeactivatedField())
5240 int element = Tile[x][y];
5241 int graphic = el_act_dir2img(element, GfxAction[x][y], GfxDir[x][y]);
5243 if (graphic_info[graphic].anim_global_sync)
5244 GfxFrame[x][y] = FrameCounter;
5245 else if (ANIM_MODE(graphic) == ANIM_CE_VALUE)
5246 GfxFrame[x][y] = CustomValue[x][y];
5247 else if (ANIM_MODE(graphic) == ANIM_CE_SCORE)
5248 GfxFrame[x][y] = element_info[element].collect_score;
5249 else if (ANIM_MODE(graphic) == ANIM_CE_DELAY)
5250 GfxFrame[x][y] = ChangeDelay[x][y];
5253 static void ResetGfxAnimation(int x, int y)
5255 GfxAction[x][y] = ACTION_DEFAULT;
5256 GfxDir[x][y] = MovDir[x][y];
5259 ResetGfxFrame(x, y);
5262 static void ResetRandomAnimationValue(int x, int y)
5264 GfxRandom[x][y] = INIT_GFX_RANDOM();
5267 static void InitMovingField(int x, int y, int direction)
5269 int element = Tile[x][y];
5270 int dx = (direction == MV_LEFT ? -1 : direction == MV_RIGHT ? +1 : 0);
5271 int dy = (direction == MV_UP ? -1 : direction == MV_DOWN ? +1 : 0);
5274 boolean is_moving_before, is_moving_after;
5276 // check if element was/is moving or being moved before/after mode change
5277 is_moving_before = (WasJustMoving[x][y] != 0);
5278 is_moving_after = (getElementMoveStepsizeExt(x, y, direction) != 0);
5280 // reset animation only for moving elements which change direction of moving
5281 // or which just started or stopped moving
5282 // (else CEs with property "can move" / "not moving" are reset each frame)
5283 if (is_moving_before != is_moving_after ||
5284 direction != MovDir[x][y])
5285 ResetGfxAnimation(x, y);
5287 MovDir[x][y] = direction;
5288 GfxDir[x][y] = direction;
5290 GfxAction[x][y] = (!is_moving_after ? ACTION_WAITING :
5291 direction == MV_DOWN && CAN_FALL(element) ?
5292 ACTION_FALLING : ACTION_MOVING);
5294 // this is needed for CEs with property "can move" / "not moving"
5296 if (is_moving_after)
5298 if (Tile[newx][newy] == EL_EMPTY)
5299 Tile[newx][newy] = EL_BLOCKED;
5301 MovDir[newx][newy] = MovDir[x][y];
5303 CustomValue[newx][newy] = CustomValue[x][y];
5305 GfxFrame[newx][newy] = GfxFrame[x][y];
5306 GfxRandom[newx][newy] = GfxRandom[x][y];
5307 GfxAction[newx][newy] = GfxAction[x][y];
5308 GfxDir[newx][newy] = GfxDir[x][y];
5312 void Moving2Blocked(int x, int y, int *goes_to_x, int *goes_to_y)
5314 int direction = MovDir[x][y];
5315 int newx = x + (direction & MV_LEFT ? -1 : direction & MV_RIGHT ? +1 : 0);
5316 int newy = y + (direction & MV_UP ? -1 : direction & MV_DOWN ? +1 : 0);
5322 void Blocked2Moving(int x, int y, int *comes_from_x, int *comes_from_y)
5324 int oldx = x, oldy = y;
5325 int direction = MovDir[x][y];
5327 if (direction == MV_LEFT)
5329 else if (direction == MV_RIGHT)
5331 else if (direction == MV_UP)
5333 else if (direction == MV_DOWN)
5336 *comes_from_x = oldx;
5337 *comes_from_y = oldy;
5340 static int MovingOrBlocked2Element(int x, int y)
5342 int element = Tile[x][y];
5344 if (element == EL_BLOCKED)
5348 Blocked2Moving(x, y, &oldx, &oldy);
5349 return Tile[oldx][oldy];
5355 static int MovingOrBlocked2ElementIfNotLeaving(int x, int y)
5357 // like MovingOrBlocked2Element(), but if element is moving
5358 // and (x,y) is the field the moving element is just leaving,
5359 // return EL_BLOCKED instead of the element value
5360 int element = Tile[x][y];
5362 if (IS_MOVING(x, y))
5364 if (element == EL_BLOCKED)
5368 Blocked2Moving(x, y, &oldx, &oldy);
5369 return Tile[oldx][oldy];
5378 static void RemoveField(int x, int y)
5380 Tile[x][y] = EL_EMPTY;
5386 CustomValue[x][y] = 0;
5389 ChangeDelay[x][y] = 0;
5390 ChangePage[x][y] = -1;
5391 Pushed[x][y] = FALSE;
5393 GfxElement[x][y] = EL_UNDEFINED;
5394 GfxAction[x][y] = ACTION_DEFAULT;
5395 GfxDir[x][y] = MV_NONE;
5398 static void RemoveMovingField(int x, int y)
5400 int oldx = x, oldy = y, newx = x, newy = y;
5401 int element = Tile[x][y];
5402 int next_element = EL_UNDEFINED;
5404 if (element != EL_BLOCKED && !IS_MOVING(x, y))
5407 if (IS_MOVING(x, y))
5409 Moving2Blocked(x, y, &newx, &newy);
5411 if (Tile[newx][newy] != EL_BLOCKED)
5413 // element is moving, but target field is not free (blocked), but
5414 // already occupied by something different (example: acid pool);
5415 // in this case, only remove the moving field, but not the target
5417 RemoveField(oldx, oldy);
5419 Store[oldx][oldy] = Store2[oldx][oldy] = 0;
5421 TEST_DrawLevelField(oldx, oldy);
5426 else if (element == EL_BLOCKED)
5428 Blocked2Moving(x, y, &oldx, &oldy);
5429 if (!IS_MOVING(oldx, oldy))
5433 if (element == EL_BLOCKED &&
5434 (Tile[oldx][oldy] == EL_QUICKSAND_EMPTYING ||
5435 Tile[oldx][oldy] == EL_QUICKSAND_FAST_EMPTYING ||
5436 Tile[oldx][oldy] == EL_MAGIC_WALL_EMPTYING ||
5437 Tile[oldx][oldy] == EL_BD_MAGIC_WALL_EMPTYING ||
5438 Tile[oldx][oldy] == EL_DC_MAGIC_WALL_EMPTYING ||
5439 Tile[oldx][oldy] == EL_AMOEBA_DROPPING))
5440 next_element = get_next_element(Tile[oldx][oldy]);
5442 RemoveField(oldx, oldy);
5443 RemoveField(newx, newy);
5445 Store[oldx][oldy] = Store2[oldx][oldy] = 0;
5447 if (next_element != EL_UNDEFINED)
5448 Tile[oldx][oldy] = next_element;
5450 TEST_DrawLevelField(oldx, oldy);
5451 TEST_DrawLevelField(newx, newy);
5454 void DrawDynamite(int x, int y)
5456 int sx = SCREENX(x), sy = SCREENY(y);
5457 int graphic = el2img(Tile[x][y]);
5460 if (!IN_SCR_FIELD(sx, sy) || IS_PLAYER(x, y))
5463 if (IS_WALKABLE_INSIDE(Back[x][y]))
5467 DrawLevelElement(x, y, Back[x][y]);
5468 else if (Store[x][y])
5469 DrawLevelElement(x, y, Store[x][y]);
5470 else if (game.use_masked_elements)
5471 DrawLevelElement(x, y, EL_EMPTY);
5473 frame = getGraphicAnimationFrame(graphic, GfxFrame[x][y]);
5475 if (Back[x][y] || Store[x][y] || game.use_masked_elements)
5476 DrawGraphicThruMask(sx, sy, graphic, frame);
5478 DrawGraphic(sx, sy, graphic, frame);
5481 static void CheckDynamite(int x, int y)
5483 if (MovDelay[x][y] != 0) // dynamite is still waiting to explode
5487 if (MovDelay[x][y] != 0)
5490 PlayLevelSoundActionIfLoop(x, y, ACTION_ACTIVE);
5496 StopLevelSoundActionIfLoop(x, y, ACTION_ACTIVE);
5501 static void setMinimalPlayerBoundaries(int *sx1, int *sy1, int *sx2, int *sy2)
5503 boolean num_checked_players = 0;
5506 for (i = 0; i < MAX_PLAYERS; i++)
5508 if (stored_player[i].active)
5510 int sx = stored_player[i].jx;
5511 int sy = stored_player[i].jy;
5513 if (num_checked_players == 0)
5520 *sx1 = MIN(*sx1, sx);
5521 *sy1 = MIN(*sy1, sy);
5522 *sx2 = MAX(*sx2, sx);
5523 *sy2 = MAX(*sy2, sy);
5526 num_checked_players++;
5531 static boolean checkIfAllPlayersFitToScreen_RND(void)
5533 int sx1 = 0, sy1 = 0, sx2 = 0, sy2 = 0;
5535 setMinimalPlayerBoundaries(&sx1, &sy1, &sx2, &sy2);
5537 return (sx2 - sx1 < SCR_FIELDX &&
5538 sy2 - sy1 < SCR_FIELDY);
5541 static void setScreenCenteredToAllPlayers(int *sx, int *sy)
5543 int sx1 = scroll_x, sy1 = scroll_y, sx2 = scroll_x, sy2 = scroll_y;
5545 setMinimalPlayerBoundaries(&sx1, &sy1, &sx2, &sy2);
5547 *sx = (sx1 + sx2) / 2;
5548 *sy = (sy1 + sy2) / 2;
5551 static void DrawRelocateScreen(int old_x, int old_y, int x, int y, int move_dir,
5552 boolean center_screen, boolean quick_relocation)
5554 unsigned int frame_delay_value_old = GetVideoFrameDelay();
5555 boolean ffwd_delay = (tape.playing && tape.fast_forward);
5556 boolean no_delay = (tape.warp_forward);
5557 int frame_delay_value = (ffwd_delay ? FfwdFrameDelay : GameFrameDelay);
5558 int wait_delay_value = (no_delay ? 0 : frame_delay_value);
5559 int new_scroll_x, new_scroll_y;
5561 if (level.lazy_relocation && IN_VIS_FIELD(SCREENX(x), SCREENY(y)))
5563 // case 1: quick relocation inside visible screen (without scrolling)
5570 if (!level.shifted_relocation || center_screen)
5572 // relocation _with_ centering of screen
5574 new_scroll_x = SCROLL_POSITION_X(x);
5575 new_scroll_y = SCROLL_POSITION_Y(y);
5579 // relocation _without_ centering of screen
5581 int center_scroll_x = SCROLL_POSITION_X(old_x);
5582 int center_scroll_y = SCROLL_POSITION_Y(old_y);
5583 int offset_x = x + (scroll_x - center_scroll_x);
5584 int offset_y = y + (scroll_y - center_scroll_y);
5586 // for new screen position, apply previous offset to center position
5587 new_scroll_x = SCROLL_POSITION_X(offset_x);
5588 new_scroll_y = SCROLL_POSITION_Y(offset_y);
5591 if (quick_relocation)
5593 // case 2: quick relocation (redraw without visible scrolling)
5595 scroll_x = new_scroll_x;
5596 scroll_y = new_scroll_y;
5603 // case 3: visible relocation (with scrolling to new position)
5605 ScrollScreen(NULL, SCROLL_GO_ON); // scroll last frame to full tile
5607 SetVideoFrameDelay(wait_delay_value);
5609 while (scroll_x != new_scroll_x || scroll_y != new_scroll_y)
5611 int dx = (new_scroll_x < scroll_x ? +1 : new_scroll_x > scroll_x ? -1 : 0);
5612 int dy = (new_scroll_y < scroll_y ? +1 : new_scroll_y > scroll_y ? -1 : 0);
5614 if (dx == 0 && dy == 0) // no scrolling needed at all
5620 // set values for horizontal/vertical screen scrolling (half tile size)
5621 int dir_x = (dx != 0 ? MV_HORIZONTAL : 0);
5622 int dir_y = (dy != 0 ? MV_VERTICAL : 0);
5623 int pos_x = dx * TILEX / 2;
5624 int pos_y = dy * TILEY / 2;
5625 int fx = getFieldbufferOffsetX_RND(dir_x, pos_x);
5626 int fy = getFieldbufferOffsetY_RND(dir_y, pos_y);
5628 ScrollLevel(dx, dy);
5631 // scroll in two steps of half tile size to make things smoother
5632 BlitScreenToBitmapExt_RND(window, fx, fy);
5634 // scroll second step to align at full tile size
5635 BlitScreenToBitmap(window);
5641 SetVideoFrameDelay(frame_delay_value_old);
5644 static void RelocatePlayer(int jx, int jy, int el_player_raw)
5646 int el_player = GET_PLAYER_ELEMENT(el_player_raw);
5647 int player_nr = GET_PLAYER_NR(el_player);
5648 struct PlayerInfo *player = &stored_player[player_nr];
5649 boolean ffwd_delay = (tape.playing && tape.fast_forward);
5650 boolean no_delay = (tape.warp_forward);
5651 int frame_delay_value = (ffwd_delay ? FfwdFrameDelay : GameFrameDelay);
5652 int wait_delay_value = (no_delay ? 0 : frame_delay_value);
5653 int old_jx = player->jx;
5654 int old_jy = player->jy;
5655 int old_element = Tile[old_jx][old_jy];
5656 int element = Tile[jx][jy];
5657 boolean player_relocated = (old_jx != jx || old_jy != jy);
5659 int move_dir_horiz = (jx < old_jx ? MV_LEFT : jx > old_jx ? MV_RIGHT : 0);
5660 int move_dir_vert = (jy < old_jy ? MV_UP : jy > old_jy ? MV_DOWN : 0);
5661 int enter_side_horiz = MV_DIR_OPPOSITE(move_dir_horiz);
5662 int enter_side_vert = MV_DIR_OPPOSITE(move_dir_vert);
5663 int leave_side_horiz = move_dir_horiz;
5664 int leave_side_vert = move_dir_vert;
5665 int enter_side = enter_side_horiz | enter_side_vert;
5666 int leave_side = leave_side_horiz | leave_side_vert;
5668 if (player->buried) // do not reanimate dead player
5671 if (!player_relocated) // no need to relocate the player
5674 if (IS_PLAYER(jx, jy)) // player already placed at new position
5676 RemoveField(jx, jy); // temporarily remove newly placed player
5677 DrawLevelField(jx, jy);
5680 if (player->present)
5682 while (player->MovPos)
5684 ScrollPlayer(player, SCROLL_GO_ON);
5685 ScrollScreen(NULL, SCROLL_GO_ON);
5687 AdvanceFrameAndPlayerCounters(player->index_nr);
5691 BackToFront_WithFrameDelay(wait_delay_value);
5694 DrawPlayer(player); // needed here only to cleanup last field
5695 DrawLevelField(player->jx, player->jy); // remove player graphic
5697 player->is_moving = FALSE;
5700 if (IS_CUSTOM_ELEMENT(old_element))
5701 CheckElementChangeByPlayer(old_jx, old_jy, old_element,
5703 player->index_bit, leave_side);
5705 CheckTriggeredElementChangeByPlayer(old_jx, old_jy, old_element,
5707 player->index_bit, leave_side);
5709 Tile[jx][jy] = el_player;
5710 InitPlayerField(jx, jy, el_player, TRUE);
5712 /* "InitPlayerField()" above sets Tile[jx][jy] to EL_EMPTY, but it may be
5713 possible that the relocation target field did not contain a player element,
5714 but a walkable element, to which the new player was relocated -- in this
5715 case, restore that (already initialized!) element on the player field */
5716 if (!IS_PLAYER_ELEMENT(element)) // player may be set on walkable element
5718 Tile[jx][jy] = element; // restore previously existing element
5721 // only visually relocate centered player
5722 DrawRelocateScreen(old_jx, old_jy, player->jx, player->jy, player->MovDir,
5723 FALSE, level.instant_relocation);
5725 TestIfPlayerTouchesBadThing(jx, jy);
5726 TestIfPlayerTouchesCustomElement(jx, jy);
5728 if (IS_CUSTOM_ELEMENT(element))
5729 CheckElementChangeByPlayer(jx, jy, element, CE_ENTERED_BY_PLAYER,
5730 player->index_bit, enter_side);
5732 CheckTriggeredElementChangeByPlayer(jx, jy, element, CE_PLAYER_ENTERS_X,
5733 player->index_bit, enter_side);
5735 if (player->is_switching)
5737 /* ensure that relocation while still switching an element does not cause
5738 a new element to be treated as also switched directly after relocation
5739 (this is important for teleporter switches that teleport the player to
5740 a place where another teleporter switch is in the same direction, which
5741 would then incorrectly be treated as immediately switched before the
5742 direction key that caused the switch was released) */
5744 player->switch_x += jx - old_jx;
5745 player->switch_y += jy - old_jy;
5749 static void Explode(int ex, int ey, int phase, int mode)
5755 // !!! eliminate this variable !!!
5756 int delay = (game.emulation == EMU_SUPAPLEX ? 3 : 2);
5758 if (game.explosions_delayed)
5760 ExplodeField[ex][ey] = mode;
5764 if (phase == EX_PHASE_START) // initialize 'Store[][]' field
5766 int center_element = Tile[ex][ey];
5767 int artwork_element, explosion_element; // set these values later
5769 // remove things displayed in background while burning dynamite
5770 if (Back[ex][ey] != EL_EMPTY && !IS_INDESTRUCTIBLE(Back[ex][ey]))
5773 if (IS_MOVING(ex, ey) || IS_BLOCKED(ex, ey))
5775 // put moving element to center field (and let it explode there)
5776 center_element = MovingOrBlocked2Element(ex, ey);
5777 RemoveMovingField(ex, ey);
5778 Tile[ex][ey] = center_element;
5781 // now "center_element" is finally determined -- set related values now
5782 artwork_element = center_element; // for custom player artwork
5783 explosion_element = center_element; // for custom player artwork
5785 if (IS_PLAYER(ex, ey))
5787 int player_nr = GET_PLAYER_NR(StorePlayer[ex][ey]);
5789 artwork_element = stored_player[player_nr].artwork_element;
5791 if (level.use_explosion_element[player_nr])
5793 explosion_element = level.explosion_element[player_nr];
5794 artwork_element = explosion_element;
5798 if (mode == EX_TYPE_NORMAL ||
5799 mode == EX_TYPE_CENTER ||
5800 mode == EX_TYPE_CROSS)
5801 PlayLevelSoundElementAction(ex, ey, artwork_element, ACTION_EXPLODING);
5803 last_phase = element_info[explosion_element].explosion_delay + 1;
5805 for (y = ey - 1; y <= ey + 1; y++) for (x = ex - 1; x <= ex + 1; x++)
5807 int xx = x - ex + 1;
5808 int yy = y - ey + 1;
5811 if (!IN_LEV_FIELD(x, y) ||
5812 (mode & EX_TYPE_SINGLE_TILE && (x != ex || y != ey)) ||
5813 (mode == EX_TYPE_CROSS && (x != ex && y != ey)))
5816 element = Tile[x][y];
5818 if (IS_MOVING(x, y) || IS_BLOCKED(x, y))
5820 element = MovingOrBlocked2Element(x, y);
5822 if (!IS_EXPLOSION_PROOF(element))
5823 RemoveMovingField(x, y);
5826 // indestructible elements can only explode in center (but not flames)
5827 if ((IS_EXPLOSION_PROOF(element) && (x != ex || y != ey ||
5828 mode == EX_TYPE_BORDER)) ||
5829 element == EL_FLAMES)
5832 /* no idea why this was changed from 3.0.8 to 3.1.0 -- this causes buggy
5833 behaviour, for example when touching a yamyam that explodes to rocks
5834 with active deadly shield, a rock is created under the player !!! */
5835 // (case 1 (surely buggy): >= 3.1.0, case 2 (maybe buggy): <= 3.0.8)
5837 if (IS_PLAYER(x, y) && SHIELD_ON(PLAYERINFO(x, y)) &&
5838 (game.engine_version < VERSION_IDENT(3,1,0,0) ||
5839 (x == ex && y == ey && mode != EX_TYPE_BORDER)))
5841 if (IS_PLAYER(x, y) && SHIELD_ON(PLAYERINFO(x, y)))
5844 if (IS_ACTIVE_BOMB(element))
5846 // re-activate things under the bomb like gate or penguin
5847 Tile[x][y] = (Back[x][y] ? Back[x][y] : EL_EMPTY);
5854 // save walkable background elements while explosion on same tile
5855 if (IS_WALKABLE(element) && IS_INDESTRUCTIBLE(element) &&
5856 (x != ex || y != ey || mode == EX_TYPE_BORDER))
5857 Back[x][y] = element;
5859 // ignite explodable elements reached by other explosion
5860 if (element == EL_EXPLOSION)
5861 element = Store2[x][y];
5863 if (AmoebaNr[x][y] &&
5864 (element == EL_AMOEBA_FULL ||
5865 element == EL_BD_AMOEBA ||
5866 element == EL_AMOEBA_GROWING))
5868 AmoebaCnt[AmoebaNr[x][y]]--;
5869 AmoebaCnt2[AmoebaNr[x][y]]--;
5874 if (IS_PLAYER(ex, ey) && !PLAYER_EXPLOSION_PROTECTED(ex, ey))
5876 int player_nr = StorePlayer[ex][ey] - EL_PLAYER_1;
5878 Store[x][y] = EL_PLAYER_IS_EXPLODING_1 + player_nr;
5880 if (PLAYERINFO(ex, ey)->use_murphy)
5881 Store[x][y] = EL_EMPTY;
5884 // !!! check this case -- currently needed for rnd_rado_negundo_v,
5885 // !!! levels 015 018 019 020 021 022 023 026 027 028 !!!
5886 else if (IS_PLAYER_ELEMENT(center_element))
5887 Store[x][y] = EL_EMPTY;
5888 else if (center_element == EL_YAMYAM)
5889 Store[x][y] = level.yamyam_content[game.yamyam_content_nr].e[xx][yy];
5890 else if (element_info[center_element].content.e[xx][yy] != EL_EMPTY)
5891 Store[x][y] = element_info[center_element].content.e[xx][yy];
5893 // needed because EL_BD_BUTTERFLY is not defined as "CAN_EXPLODE"
5894 // (killing EL_BD_BUTTERFLY with dynamite would result in BD diamond
5895 // otherwise) -- FIX THIS !!!
5896 else if (!CAN_EXPLODE(element) && element != EL_BD_BUTTERFLY)
5897 Store[x][y] = element_info[element].content.e[1][1];
5899 else if (!CAN_EXPLODE(element))
5900 Store[x][y] = element_info[element].content.e[1][1];
5903 Store[x][y] = EL_EMPTY;
5905 if (x != ex || y != ey || mode == EX_TYPE_BORDER ||
5906 center_element == EL_AMOEBA_TO_DIAMOND)
5907 Store2[x][y] = element;
5909 Tile[x][y] = EL_EXPLOSION;
5910 GfxElement[x][y] = artwork_element;
5912 ExplodePhase[x][y] = 1;
5913 ExplodeDelay[x][y] = last_phase;
5918 if (center_element == EL_YAMYAM)
5919 game.yamyam_content_nr =
5920 (game.yamyam_content_nr + 1) % level.num_yamyam_contents;
5932 GfxFrame[x][y] = 0; // restart explosion animation
5934 last_phase = ExplodeDelay[x][y];
5936 ExplodePhase[x][y] = (phase < last_phase ? phase + 1 : 0);
5938 // this can happen if the player leaves an explosion just in time
5939 if (GfxElement[x][y] == EL_UNDEFINED)
5940 GfxElement[x][y] = EL_EMPTY;
5942 border_element = Store2[x][y];
5943 if (IS_PLAYER(x, y) && !PLAYER_EXPLOSION_PROTECTED(x, y))
5944 border_element = StorePlayer[x][y];
5946 if (phase == element_info[border_element].ignition_delay ||
5947 phase == last_phase)
5949 boolean border_explosion = FALSE;
5951 if (IS_PLAYER(x, y) && PLAYERINFO(x, y)->present &&
5952 !PLAYER_EXPLOSION_PROTECTED(x, y))
5954 KillPlayerUnlessExplosionProtected(x, y);
5955 border_explosion = TRUE;
5957 else if (CAN_EXPLODE_BY_EXPLOSION(border_element))
5959 Tile[x][y] = Store2[x][y];
5962 border_explosion = TRUE;
5964 else if (border_element == EL_AMOEBA_TO_DIAMOND)
5966 AmoebaToDiamond(x, y);
5968 border_explosion = TRUE;
5971 // if an element just explodes due to another explosion (chain-reaction),
5972 // do not immediately end the new explosion when it was the last frame of
5973 // the explosion (as it would be done in the following "if"-statement!)
5974 if (border_explosion && phase == last_phase)
5978 if (phase == last_phase)
5982 element = Tile[x][y] = Store[x][y];
5983 Store[x][y] = Store2[x][y] = 0;
5984 GfxElement[x][y] = EL_UNDEFINED;
5986 // player can escape from explosions and might therefore be still alive
5987 if (element >= EL_PLAYER_IS_EXPLODING_1 &&
5988 element <= EL_PLAYER_IS_EXPLODING_4)
5990 int player_nr = element - EL_PLAYER_IS_EXPLODING_1;
5991 int explosion_element = EL_PLAYER_1 + player_nr;
5992 int xx = MIN(MAX(0, x - stored_player[player_nr].jx + 1), 2);
5993 int yy = MIN(MAX(0, y - stored_player[player_nr].jy + 1), 2);
5995 if (level.use_explosion_element[player_nr])
5996 explosion_element = level.explosion_element[player_nr];
5998 Tile[x][y] = (stored_player[player_nr].active ? EL_EMPTY :
5999 element_info[explosion_element].content.e[xx][yy]);
6002 // restore probably existing indestructible background element
6003 if (Back[x][y] && IS_INDESTRUCTIBLE(Back[x][y]))
6004 element = Tile[x][y] = Back[x][y];
6007 MovDir[x][y] = MovPos[x][y] = MovDelay[x][y] = 0;
6008 GfxDir[x][y] = MV_NONE;
6009 ChangeDelay[x][y] = 0;
6010 ChangePage[x][y] = -1;
6012 CustomValue[x][y] = 0;
6014 InitField_WithBug2(x, y, FALSE);
6016 TEST_DrawLevelField(x, y);
6018 TestIfElementTouchesCustomElement(x, y);
6020 if (GFX_CRUMBLED(element))
6021 TEST_DrawLevelFieldCrumbledNeighbours(x, y);
6023 if (IS_PLAYER(x, y) && !PLAYERINFO(x, y)->present)
6024 StorePlayer[x][y] = 0;
6026 if (IS_PLAYER_ELEMENT(element))
6027 RelocatePlayer(x, y, element);
6029 else if (IN_SCR_FIELD(SCREENX(x), SCREENY(y)))
6031 int graphic = el_act2img(GfxElement[x][y], ACTION_EXPLODING);
6032 int frame = getGraphicAnimationFrame(graphic, GfxFrame[x][y]);
6035 TEST_DrawLevelFieldCrumbled(x, y);
6037 if (IS_WALKABLE_OVER(Back[x][y]) && Back[x][y] != EL_EMPTY)
6039 DrawLevelElement(x, y, Back[x][y]);
6040 DrawGraphicThruMask(SCREENX(x), SCREENY(y), graphic, frame);
6042 else if (IS_WALKABLE_UNDER(Back[x][y]))
6044 DrawGraphic(SCREENX(x), SCREENY(y), graphic, frame);
6045 DrawLevelElementThruMask(x, y, Back[x][y]);
6047 else if (!IS_WALKABLE_INSIDE(Back[x][y]))
6048 DrawScreenGraphic(SCREENX(x), SCREENY(y), graphic, frame);
6052 static void DynaExplode(int ex, int ey)
6055 int dynabomb_element = Tile[ex][ey];
6056 int dynabomb_size = 1;
6057 boolean dynabomb_xl = FALSE;
6058 struct PlayerInfo *player;
6059 static int xy[4][2] =
6067 if (IS_ACTIVE_BOMB(dynabomb_element))
6069 player = &stored_player[dynabomb_element - EL_DYNABOMB_PLAYER_1_ACTIVE];
6070 dynabomb_size = player->dynabomb_size;
6071 dynabomb_xl = player->dynabomb_xl;
6072 player->dynabombs_left++;
6075 Explode(ex, ey, EX_PHASE_START, EX_TYPE_CENTER);
6077 for (i = 0; i < NUM_DIRECTIONS; i++)
6079 for (j = 1; j <= dynabomb_size; j++)
6081 int x = ex + j * xy[i][0];
6082 int y = ey + j * xy[i][1];
6085 if (!IN_LEV_FIELD(x, y) || IS_INDESTRUCTIBLE(Tile[x][y]))
6088 element = Tile[x][y];
6090 // do not restart explosions of fields with active bombs
6091 if (element == EL_EXPLOSION && IS_ACTIVE_BOMB(Store2[x][y]))
6094 Explode(x, y, EX_PHASE_START, EX_TYPE_BORDER);
6096 if (element != EL_EMPTY && element != EL_EXPLOSION &&
6097 !IS_DIGGABLE(element) && !dynabomb_xl)
6103 void Bang(int x, int y)
6105 int element = MovingOrBlocked2Element(x, y);
6106 int explosion_type = EX_TYPE_NORMAL;
6108 if (IS_PLAYER(x, y) && !PLAYER_EXPLOSION_PROTECTED(x, y))
6110 struct PlayerInfo *player = PLAYERINFO(x, y);
6112 element = Tile[x][y] = player->initial_element;
6114 if (level.use_explosion_element[player->index_nr])
6116 int explosion_element = level.explosion_element[player->index_nr];
6118 if (element_info[explosion_element].explosion_type == EXPLODES_CROSS)
6119 explosion_type = EX_TYPE_CROSS;
6120 else if (element_info[explosion_element].explosion_type == EXPLODES_1X1)
6121 explosion_type = EX_TYPE_CENTER;
6129 case EL_BD_BUTTERFLY:
6132 case EL_DARK_YAMYAM:
6136 RaiseScoreElement(element);
6139 case EL_DYNABOMB_PLAYER_1_ACTIVE:
6140 case EL_DYNABOMB_PLAYER_2_ACTIVE:
6141 case EL_DYNABOMB_PLAYER_3_ACTIVE:
6142 case EL_DYNABOMB_PLAYER_4_ACTIVE:
6143 case EL_DYNABOMB_INCREASE_NUMBER:
6144 case EL_DYNABOMB_INCREASE_SIZE:
6145 case EL_DYNABOMB_INCREASE_POWER:
6146 explosion_type = EX_TYPE_DYNA;
6149 case EL_DC_LANDMINE:
6150 explosion_type = EX_TYPE_CENTER;
6155 case EL_LAMP_ACTIVE:
6156 case EL_AMOEBA_TO_DIAMOND:
6157 if (!IS_PLAYER(x, y)) // penguin and player may be at same field
6158 explosion_type = EX_TYPE_CENTER;
6162 if (element_info[element].explosion_type == EXPLODES_CROSS)
6163 explosion_type = EX_TYPE_CROSS;
6164 else if (element_info[element].explosion_type == EXPLODES_1X1)
6165 explosion_type = EX_TYPE_CENTER;
6169 if (explosion_type == EX_TYPE_DYNA)
6172 Explode(x, y, EX_PHASE_START, explosion_type);
6174 CheckTriggeredElementChange(x, y, element, CE_EXPLOSION_OF_X);
6177 static void SplashAcid(int x, int y)
6179 if (IN_LEV_FIELD(x - 1, y - 1) && IS_FREE(x - 1, y - 1) &&
6180 (!IN_LEV_FIELD(x - 1, y - 2) ||
6181 !CAN_FALL(MovingOrBlocked2Element(x - 1, y - 2))))
6182 Tile[x - 1][y - 1] = EL_ACID_SPLASH_LEFT;
6184 if (IN_LEV_FIELD(x + 1, y - 1) && IS_FREE(x + 1, y - 1) &&
6185 (!IN_LEV_FIELD(x + 1, y - 2) ||
6186 !CAN_FALL(MovingOrBlocked2Element(x + 1, y - 2))))
6187 Tile[x + 1][y - 1] = EL_ACID_SPLASH_RIGHT;
6189 PlayLevelSound(x, y, SND_ACID_SPLASHING);
6192 static void InitBeltMovement(void)
6194 static int belt_base_element[4] =
6196 EL_CONVEYOR_BELT_1_LEFT,
6197 EL_CONVEYOR_BELT_2_LEFT,
6198 EL_CONVEYOR_BELT_3_LEFT,
6199 EL_CONVEYOR_BELT_4_LEFT
6201 static int belt_base_active_element[4] =
6203 EL_CONVEYOR_BELT_1_LEFT_ACTIVE,
6204 EL_CONVEYOR_BELT_2_LEFT_ACTIVE,
6205 EL_CONVEYOR_BELT_3_LEFT_ACTIVE,
6206 EL_CONVEYOR_BELT_4_LEFT_ACTIVE
6211 // set frame order for belt animation graphic according to belt direction
6212 for (i = 0; i < NUM_BELTS; i++)
6216 for (j = 0; j < NUM_BELT_PARTS; j++)
6218 int element = belt_base_active_element[belt_nr] + j;
6219 int graphic_1 = el2img(element);
6220 int graphic_2 = el2panelimg(element);
6222 if (game.belt_dir[i] == MV_LEFT)
6224 graphic_info[graphic_1].anim_mode &= ~ANIM_REVERSE;
6225 graphic_info[graphic_2].anim_mode &= ~ANIM_REVERSE;
6229 graphic_info[graphic_1].anim_mode |= ANIM_REVERSE;
6230 graphic_info[graphic_2].anim_mode |= ANIM_REVERSE;
6235 SCAN_PLAYFIELD(x, y)
6237 int element = Tile[x][y];
6239 for (i = 0; i < NUM_BELTS; i++)
6241 if (IS_BELT(element) && game.belt_dir[i] != MV_NONE)
6243 int e_belt_nr = getBeltNrFromBeltElement(element);
6246 if (e_belt_nr == belt_nr)
6248 int belt_part = Tile[x][y] - belt_base_element[belt_nr];
6250 Tile[x][y] = belt_base_active_element[belt_nr] + belt_part;
6257 static void ToggleBeltSwitch(int x, int y)
6259 static int belt_base_element[4] =
6261 EL_CONVEYOR_BELT_1_LEFT,
6262 EL_CONVEYOR_BELT_2_LEFT,
6263 EL_CONVEYOR_BELT_3_LEFT,
6264 EL_CONVEYOR_BELT_4_LEFT
6266 static int belt_base_active_element[4] =
6268 EL_CONVEYOR_BELT_1_LEFT_ACTIVE,
6269 EL_CONVEYOR_BELT_2_LEFT_ACTIVE,
6270 EL_CONVEYOR_BELT_3_LEFT_ACTIVE,
6271 EL_CONVEYOR_BELT_4_LEFT_ACTIVE
6273 static int belt_base_switch_element[4] =
6275 EL_CONVEYOR_BELT_1_SWITCH_LEFT,
6276 EL_CONVEYOR_BELT_2_SWITCH_LEFT,
6277 EL_CONVEYOR_BELT_3_SWITCH_LEFT,
6278 EL_CONVEYOR_BELT_4_SWITCH_LEFT
6280 static int belt_move_dir[4] =
6288 int element = Tile[x][y];
6289 int belt_nr = getBeltNrFromBeltSwitchElement(element);
6290 int belt_dir_nr = (game.belt_dir_nr[belt_nr] + 1) % 4;
6291 int belt_dir = belt_move_dir[belt_dir_nr];
6294 if (!IS_BELT_SWITCH(element))
6297 game.belt_dir_nr[belt_nr] = belt_dir_nr;
6298 game.belt_dir[belt_nr] = belt_dir;
6300 if (belt_dir_nr == 3)
6303 // set frame order for belt animation graphic according to belt direction
6304 for (i = 0; i < NUM_BELT_PARTS; i++)
6306 int element = belt_base_active_element[belt_nr] + i;
6307 int graphic_1 = el2img(element);
6308 int graphic_2 = el2panelimg(element);
6310 if (belt_dir == MV_LEFT)
6312 graphic_info[graphic_1].anim_mode &= ~ANIM_REVERSE;
6313 graphic_info[graphic_2].anim_mode &= ~ANIM_REVERSE;
6317 graphic_info[graphic_1].anim_mode |= ANIM_REVERSE;
6318 graphic_info[graphic_2].anim_mode |= ANIM_REVERSE;
6322 SCAN_PLAYFIELD(xx, yy)
6324 int element = Tile[xx][yy];
6326 if (IS_BELT_SWITCH(element))
6328 int e_belt_nr = getBeltNrFromBeltSwitchElement(element);
6330 if (e_belt_nr == belt_nr)
6332 Tile[xx][yy] = belt_base_switch_element[belt_nr] + belt_dir_nr;
6333 TEST_DrawLevelField(xx, yy);
6336 else if (IS_BELT(element) && belt_dir != MV_NONE)
6338 int e_belt_nr = getBeltNrFromBeltElement(element);
6340 if (e_belt_nr == belt_nr)
6342 int belt_part = Tile[xx][yy] - belt_base_element[belt_nr];
6344 Tile[xx][yy] = belt_base_active_element[belt_nr] + belt_part;
6345 TEST_DrawLevelField(xx, yy);
6348 else if (IS_BELT_ACTIVE(element) && belt_dir == MV_NONE)
6350 int e_belt_nr = getBeltNrFromBeltActiveElement(element);
6352 if (e_belt_nr == belt_nr)
6354 int belt_part = Tile[xx][yy] - belt_base_active_element[belt_nr];
6356 Tile[xx][yy] = belt_base_element[belt_nr] + belt_part;
6357 TEST_DrawLevelField(xx, yy);
6363 static void ToggleSwitchgateSwitch(int x, int y)
6367 game.switchgate_pos = !game.switchgate_pos;
6369 SCAN_PLAYFIELD(xx, yy)
6371 int element = Tile[xx][yy];
6373 if (element == EL_SWITCHGATE_SWITCH_UP)
6375 Tile[xx][yy] = EL_SWITCHGATE_SWITCH_DOWN;
6376 TEST_DrawLevelField(xx, yy);
6378 else if (element == EL_SWITCHGATE_SWITCH_DOWN)
6380 Tile[xx][yy] = EL_SWITCHGATE_SWITCH_UP;
6381 TEST_DrawLevelField(xx, yy);
6383 else if (element == EL_DC_SWITCHGATE_SWITCH_UP)
6385 Tile[xx][yy] = EL_DC_SWITCHGATE_SWITCH_DOWN;
6386 TEST_DrawLevelField(xx, yy);
6388 else if (element == EL_DC_SWITCHGATE_SWITCH_DOWN)
6390 Tile[xx][yy] = EL_DC_SWITCHGATE_SWITCH_UP;
6391 TEST_DrawLevelField(xx, yy);
6393 else if (element == EL_SWITCHGATE_OPEN ||
6394 element == EL_SWITCHGATE_OPENING)
6396 Tile[xx][yy] = EL_SWITCHGATE_CLOSING;
6398 PlayLevelSoundAction(xx, yy, ACTION_CLOSING);
6400 else if (element == EL_SWITCHGATE_CLOSED ||
6401 element == EL_SWITCHGATE_CLOSING)
6403 Tile[xx][yy] = EL_SWITCHGATE_OPENING;
6405 PlayLevelSoundAction(xx, yy, ACTION_OPENING);
6410 static int getInvisibleActiveFromInvisibleElement(int element)
6412 return (element == EL_INVISIBLE_STEELWALL ? EL_INVISIBLE_STEELWALL_ACTIVE :
6413 element == EL_INVISIBLE_WALL ? EL_INVISIBLE_WALL_ACTIVE :
6414 element == EL_INVISIBLE_SAND ? EL_INVISIBLE_SAND_ACTIVE :
6418 static int getInvisibleFromInvisibleActiveElement(int element)
6420 return (element == EL_INVISIBLE_STEELWALL_ACTIVE ? EL_INVISIBLE_STEELWALL :
6421 element == EL_INVISIBLE_WALL_ACTIVE ? EL_INVISIBLE_WALL :
6422 element == EL_INVISIBLE_SAND_ACTIVE ? EL_INVISIBLE_SAND :
6426 static void RedrawAllLightSwitchesAndInvisibleElements(void)
6430 SCAN_PLAYFIELD(x, y)
6432 int element = Tile[x][y];
6434 if (element == EL_LIGHT_SWITCH &&
6435 game.light_time_left > 0)
6437 Tile[x][y] = EL_LIGHT_SWITCH_ACTIVE;
6438 TEST_DrawLevelField(x, y);
6440 else if (element == EL_LIGHT_SWITCH_ACTIVE &&
6441 game.light_time_left == 0)
6443 Tile[x][y] = EL_LIGHT_SWITCH;
6444 TEST_DrawLevelField(x, y);
6446 else if (element == EL_EMC_DRIPPER &&
6447 game.light_time_left > 0)
6449 Tile[x][y] = EL_EMC_DRIPPER_ACTIVE;
6450 TEST_DrawLevelField(x, y);
6452 else if (element == EL_EMC_DRIPPER_ACTIVE &&
6453 game.light_time_left == 0)
6455 Tile[x][y] = EL_EMC_DRIPPER;
6456 TEST_DrawLevelField(x, y);
6458 else if (element == EL_INVISIBLE_STEELWALL ||
6459 element == EL_INVISIBLE_WALL ||
6460 element == EL_INVISIBLE_SAND)
6462 if (game.light_time_left > 0)
6463 Tile[x][y] = getInvisibleActiveFromInvisibleElement(element);
6465 TEST_DrawLevelField(x, y);
6467 // uncrumble neighbour fields, if needed
6468 if (element == EL_INVISIBLE_SAND)
6469 TEST_DrawLevelFieldCrumbledNeighbours(x, y);
6471 else if (element == EL_INVISIBLE_STEELWALL_ACTIVE ||
6472 element == EL_INVISIBLE_WALL_ACTIVE ||
6473 element == EL_INVISIBLE_SAND_ACTIVE)
6475 if (game.light_time_left == 0)
6476 Tile[x][y] = getInvisibleFromInvisibleActiveElement(element);
6478 TEST_DrawLevelField(x, y);
6480 // re-crumble neighbour fields, if needed
6481 if (element == EL_INVISIBLE_SAND)
6482 TEST_DrawLevelFieldCrumbledNeighbours(x, y);
6487 static void RedrawAllInvisibleElementsForLenses(void)
6491 SCAN_PLAYFIELD(x, y)
6493 int element = Tile[x][y];
6495 if (element == EL_EMC_DRIPPER &&
6496 game.lenses_time_left > 0)
6498 Tile[x][y] = EL_EMC_DRIPPER_ACTIVE;
6499 TEST_DrawLevelField(x, y);
6501 else if (element == EL_EMC_DRIPPER_ACTIVE &&
6502 game.lenses_time_left == 0)
6504 Tile[x][y] = EL_EMC_DRIPPER;
6505 TEST_DrawLevelField(x, y);
6507 else if (element == EL_INVISIBLE_STEELWALL ||
6508 element == EL_INVISIBLE_WALL ||
6509 element == EL_INVISIBLE_SAND)
6511 if (game.lenses_time_left > 0)
6512 Tile[x][y] = getInvisibleActiveFromInvisibleElement(element);
6514 TEST_DrawLevelField(x, y);
6516 // uncrumble neighbour fields, if needed
6517 if (element == EL_INVISIBLE_SAND)
6518 TEST_DrawLevelFieldCrumbledNeighbours(x, y);
6520 else if (element == EL_INVISIBLE_STEELWALL_ACTIVE ||
6521 element == EL_INVISIBLE_WALL_ACTIVE ||
6522 element == EL_INVISIBLE_SAND_ACTIVE)
6524 if (game.lenses_time_left == 0)
6525 Tile[x][y] = getInvisibleFromInvisibleActiveElement(element);
6527 TEST_DrawLevelField(x, y);
6529 // re-crumble neighbour fields, if needed
6530 if (element == EL_INVISIBLE_SAND)
6531 TEST_DrawLevelFieldCrumbledNeighbours(x, y);
6536 static void RedrawAllInvisibleElementsForMagnifier(void)
6540 SCAN_PLAYFIELD(x, y)
6542 int element = Tile[x][y];
6544 if (element == EL_EMC_FAKE_GRASS &&
6545 game.magnify_time_left > 0)
6547 Tile[x][y] = EL_EMC_FAKE_GRASS_ACTIVE;
6548 TEST_DrawLevelField(x, y);
6550 else if (element == EL_EMC_FAKE_GRASS_ACTIVE &&
6551 game.magnify_time_left == 0)
6553 Tile[x][y] = EL_EMC_FAKE_GRASS;
6554 TEST_DrawLevelField(x, y);
6556 else if (IS_GATE_GRAY(element) &&
6557 game.magnify_time_left > 0)
6559 Tile[x][y] = (IS_RND_GATE_GRAY(element) ?
6560 element - EL_GATE_1_GRAY + EL_GATE_1_GRAY_ACTIVE :
6561 IS_EM_GATE_GRAY(element) ?
6562 element - EL_EM_GATE_1_GRAY + EL_EM_GATE_1_GRAY_ACTIVE :
6563 IS_EMC_GATE_GRAY(element) ?
6564 element - EL_EMC_GATE_5_GRAY + EL_EMC_GATE_5_GRAY_ACTIVE :
6565 IS_DC_GATE_GRAY(element) ?
6566 EL_DC_GATE_WHITE_GRAY_ACTIVE :
6568 TEST_DrawLevelField(x, y);
6570 else if (IS_GATE_GRAY_ACTIVE(element) &&
6571 game.magnify_time_left == 0)
6573 Tile[x][y] = (IS_RND_GATE_GRAY_ACTIVE(element) ?
6574 element - EL_GATE_1_GRAY_ACTIVE + EL_GATE_1_GRAY :
6575 IS_EM_GATE_GRAY_ACTIVE(element) ?
6576 element - EL_EM_GATE_1_GRAY_ACTIVE + EL_EM_GATE_1_GRAY :
6577 IS_EMC_GATE_GRAY_ACTIVE(element) ?
6578 element - EL_EMC_GATE_5_GRAY_ACTIVE + EL_EMC_GATE_5_GRAY :
6579 IS_DC_GATE_GRAY_ACTIVE(element) ?
6580 EL_DC_GATE_WHITE_GRAY :
6582 TEST_DrawLevelField(x, y);
6587 static void ToggleLightSwitch(int x, int y)
6589 int element = Tile[x][y];
6591 game.light_time_left =
6592 (element == EL_LIGHT_SWITCH ?
6593 level.time_light * FRAMES_PER_SECOND : 0);
6595 RedrawAllLightSwitchesAndInvisibleElements();
6598 static void ActivateTimegateSwitch(int x, int y)
6602 game.timegate_time_left = level.time_timegate * FRAMES_PER_SECOND;
6604 SCAN_PLAYFIELD(xx, yy)
6606 int element = Tile[xx][yy];
6608 if (element == EL_TIMEGATE_CLOSED ||
6609 element == EL_TIMEGATE_CLOSING)
6611 Tile[xx][yy] = EL_TIMEGATE_OPENING;
6612 PlayLevelSound(xx, yy, SND_CLASS_TIMEGATE_OPENING);
6616 else if (element == EL_TIMEGATE_SWITCH_ACTIVE)
6618 Tile[xx][yy] = EL_TIMEGATE_SWITCH;
6619 TEST_DrawLevelField(xx, yy);
6625 Tile[x][y] = (Tile[x][y] == EL_TIMEGATE_SWITCH ? EL_TIMEGATE_SWITCH_ACTIVE :
6626 EL_DC_TIMEGATE_SWITCH_ACTIVE);
6629 static void Impact(int x, int y)
6631 boolean last_line = (y == lev_fieldy - 1);
6632 boolean object_hit = FALSE;
6633 boolean impact = (last_line || object_hit);
6634 int element = Tile[x][y];
6635 int smashed = EL_STEELWALL;
6637 if (!last_line) // check if element below was hit
6639 if (Tile[x][y + 1] == EL_PLAYER_IS_LEAVING)
6642 object_hit = (!IS_FREE(x, y + 1) && (!IS_MOVING(x, y + 1) ||
6643 MovDir[x][y + 1] != MV_DOWN ||
6644 MovPos[x][y + 1] <= TILEY / 2));
6646 // do not smash moving elements that left the smashed field in time
6647 if (game.engine_version >= VERSION_IDENT(2,2,0,7) && IS_MOVING(x, y + 1) &&
6648 ABS(MovPos[x][y + 1] + getElementMoveStepsize(x, y + 1)) >= TILEX)
6651 #if USE_QUICKSAND_IMPACT_BUGFIX
6652 if (Tile[x][y + 1] == EL_QUICKSAND_EMPTYING && object_hit == FALSE)
6654 RemoveMovingField(x, y + 1);
6655 Tile[x][y + 1] = EL_QUICKSAND_EMPTY;
6656 Tile[x][y + 2] = EL_ROCK;
6657 TEST_DrawLevelField(x, y + 2);
6662 if (Tile[x][y + 1] == EL_QUICKSAND_FAST_EMPTYING && object_hit == FALSE)
6664 RemoveMovingField(x, y + 1);
6665 Tile[x][y + 1] = EL_QUICKSAND_FAST_EMPTY;
6666 Tile[x][y + 2] = EL_ROCK;
6667 TEST_DrawLevelField(x, y + 2);
6674 smashed = MovingOrBlocked2Element(x, y + 1);
6676 impact = (last_line || object_hit);
6679 if (!last_line && smashed == EL_ACID) // element falls into acid
6681 SplashAcid(x, y + 1);
6685 // !!! not sufficient for all cases -- see EL_PEARL below !!!
6686 // only reset graphic animation if graphic really changes after impact
6688 el_act_dir2img(element, GfxAction[x][y], MV_DOWN) != el2img(element))
6690 ResetGfxAnimation(x, y);
6691 TEST_DrawLevelField(x, y);
6694 if (impact && CAN_EXPLODE_IMPACT(element))
6699 else if (impact && element == EL_PEARL &&
6700 smashed != EL_DC_MAGIC_WALL && smashed != EL_DC_MAGIC_WALL_ACTIVE)
6702 ResetGfxAnimation(x, y);
6704 Tile[x][y] = EL_PEARL_BREAKING;
6705 PlayLevelSound(x, y, SND_PEARL_BREAKING);
6708 else if (impact && CheckElementChange(x, y, element, smashed, CE_IMPACT))
6710 PlayLevelSoundElementAction(x, y, element, ACTION_IMPACT);
6715 if (impact && element == EL_AMOEBA_DROP)
6717 if (object_hit && IS_PLAYER(x, y + 1))
6718 KillPlayerUnlessEnemyProtected(x, y + 1);
6719 else if (object_hit && smashed == EL_PENGUIN)
6723 Tile[x][y] = EL_AMOEBA_GROWING;
6724 Store[x][y] = EL_AMOEBA_WET;
6726 ResetRandomAnimationValue(x, y);
6731 if (object_hit) // check which object was hit
6733 if ((CAN_PASS_MAGIC_WALL(element) &&
6734 (smashed == EL_MAGIC_WALL ||
6735 smashed == EL_BD_MAGIC_WALL)) ||
6736 (CAN_PASS_DC_MAGIC_WALL(element) &&
6737 smashed == EL_DC_MAGIC_WALL))
6740 int activated_magic_wall =
6741 (smashed == EL_MAGIC_WALL ? EL_MAGIC_WALL_ACTIVE :
6742 smashed == EL_BD_MAGIC_WALL ? EL_BD_MAGIC_WALL_ACTIVE :
6743 EL_DC_MAGIC_WALL_ACTIVE);
6745 // activate magic wall / mill
6746 SCAN_PLAYFIELD(xx, yy)
6748 if (Tile[xx][yy] == smashed)
6749 Tile[xx][yy] = activated_magic_wall;
6752 game.magic_wall_time_left = level.time_magic_wall * FRAMES_PER_SECOND;
6753 game.magic_wall_active = TRUE;
6755 PlayLevelSound(x, y, (smashed == EL_MAGIC_WALL ?
6756 SND_MAGIC_WALL_ACTIVATING :
6757 smashed == EL_BD_MAGIC_WALL ?
6758 SND_BD_MAGIC_WALL_ACTIVATING :
6759 SND_DC_MAGIC_WALL_ACTIVATING));
6762 if (IS_PLAYER(x, y + 1))
6764 if (CAN_SMASH_PLAYER(element))
6766 KillPlayerUnlessEnemyProtected(x, y + 1);
6770 else if (smashed == EL_PENGUIN)
6772 if (CAN_SMASH_PLAYER(element))
6778 else if (element == EL_BD_DIAMOND)
6780 if (IS_CLASSIC_ENEMY(smashed) && IS_BD_ELEMENT(smashed))
6786 else if (((element == EL_SP_INFOTRON ||
6787 element == EL_SP_ZONK) &&
6788 (smashed == EL_SP_SNIKSNAK ||
6789 smashed == EL_SP_ELECTRON ||
6790 smashed == EL_SP_DISK_ORANGE)) ||
6791 (element == EL_SP_INFOTRON &&
6792 smashed == EL_SP_DISK_YELLOW))
6797 else if (CAN_SMASH_EVERYTHING(element))
6799 if (IS_CLASSIC_ENEMY(smashed) ||
6800 CAN_EXPLODE_SMASHED(smashed))
6805 else if (!IS_MOVING(x, y + 1) && !IS_BLOCKED(x, y + 1))
6807 if (smashed == EL_LAMP ||
6808 smashed == EL_LAMP_ACTIVE)
6813 else if (smashed == EL_NUT)
6815 Tile[x][y + 1] = EL_NUT_BREAKING;
6816 PlayLevelSound(x, y, SND_NUT_BREAKING);
6817 RaiseScoreElement(EL_NUT);
6820 else if (smashed == EL_PEARL)
6822 ResetGfxAnimation(x, y);
6824 Tile[x][y + 1] = EL_PEARL_BREAKING;
6825 PlayLevelSound(x, y, SND_PEARL_BREAKING);
6828 else if (smashed == EL_DIAMOND)
6830 Tile[x][y + 1] = EL_DIAMOND_BREAKING;
6831 PlayLevelSound(x, y, SND_DIAMOND_BREAKING);
6834 else if (IS_BELT_SWITCH(smashed))
6836 ToggleBeltSwitch(x, y + 1);
6838 else if (smashed == EL_SWITCHGATE_SWITCH_UP ||
6839 smashed == EL_SWITCHGATE_SWITCH_DOWN ||
6840 smashed == EL_DC_SWITCHGATE_SWITCH_UP ||
6841 smashed == EL_DC_SWITCHGATE_SWITCH_DOWN)
6843 ToggleSwitchgateSwitch(x, y + 1);
6845 else if (smashed == EL_LIGHT_SWITCH ||
6846 smashed == EL_LIGHT_SWITCH_ACTIVE)
6848 ToggleLightSwitch(x, y + 1);
6852 CheckElementChange(x, y + 1, smashed, element, CE_SMASHED);
6854 CheckElementChangeBySide(x, y + 1, smashed, element,
6855 CE_SWITCHED, CH_SIDE_TOP);
6856 CheckTriggeredElementChangeBySide(x, y + 1, smashed, CE_SWITCH_OF_X,
6862 CheckElementChange(x, y + 1, smashed, element, CE_SMASHED);
6867 // play sound of magic wall / mill
6869 (Tile[x][y + 1] == EL_MAGIC_WALL_ACTIVE ||
6870 Tile[x][y + 1] == EL_BD_MAGIC_WALL_ACTIVE ||
6871 Tile[x][y + 1] == EL_DC_MAGIC_WALL_ACTIVE))
6873 if (Tile[x][y + 1] == EL_MAGIC_WALL_ACTIVE)
6874 PlayLevelSound(x, y, SND_MAGIC_WALL_FILLING);
6875 else if (Tile[x][y + 1] == EL_BD_MAGIC_WALL_ACTIVE)
6876 PlayLevelSound(x, y, SND_BD_MAGIC_WALL_FILLING);
6877 else if (Tile[x][y + 1] == EL_DC_MAGIC_WALL_ACTIVE)
6878 PlayLevelSound(x, y, SND_DC_MAGIC_WALL_FILLING);
6883 // play sound of object that hits the ground
6884 if (last_line || object_hit)
6885 PlayLevelSoundElementAction(x, y, element, ACTION_IMPACT);
6888 static void TurnRoundExt(int x, int y)
6900 { 0, 0 }, { 0, 0 }, { 0, 0 },
6905 int left, right, back;
6909 { MV_DOWN, MV_UP, MV_RIGHT },
6910 { MV_UP, MV_DOWN, MV_LEFT },
6912 { MV_LEFT, MV_RIGHT, MV_DOWN },
6916 { MV_RIGHT, MV_LEFT, MV_UP }
6919 int element = Tile[x][y];
6920 int move_pattern = element_info[element].move_pattern;
6922 int old_move_dir = MovDir[x][y];
6923 int left_dir = turn[old_move_dir].left;
6924 int right_dir = turn[old_move_dir].right;
6925 int back_dir = turn[old_move_dir].back;
6927 int left_dx = move_xy[left_dir].dx, left_dy = move_xy[left_dir].dy;
6928 int right_dx = move_xy[right_dir].dx, right_dy = move_xy[right_dir].dy;
6929 int move_dx = move_xy[old_move_dir].dx, move_dy = move_xy[old_move_dir].dy;
6930 int back_dx = move_xy[back_dir].dx, back_dy = move_xy[back_dir].dy;
6932 int left_x = x + left_dx, left_y = y + left_dy;
6933 int right_x = x + right_dx, right_y = y + right_dy;
6934 int move_x = x + move_dx, move_y = y + move_dy;
6938 if (element == EL_BUG || element == EL_BD_BUTTERFLY)
6940 TestIfBadThingTouchesOtherBadThing(x, y);
6942 if (ENEMY_CAN_ENTER_FIELD(element, right_x, right_y))
6943 MovDir[x][y] = right_dir;
6944 else if (!ENEMY_CAN_ENTER_FIELD(element, move_x, move_y))
6945 MovDir[x][y] = left_dir;
6947 if (element == EL_BUG && MovDir[x][y] != old_move_dir)
6949 else if (element == EL_BD_BUTTERFLY) // && MovDir[x][y] == left_dir)
6952 else if (element == EL_SPACESHIP || element == EL_BD_FIREFLY)
6954 TestIfBadThingTouchesOtherBadThing(x, y);
6956 if (ENEMY_CAN_ENTER_FIELD(element, left_x, left_y))
6957 MovDir[x][y] = left_dir;
6958 else if (!ENEMY_CAN_ENTER_FIELD(element, move_x, move_y))
6959 MovDir[x][y] = right_dir;
6961 if (element == EL_SPACESHIP && MovDir[x][y] != old_move_dir)
6963 else if (element == EL_BD_FIREFLY) // && MovDir[x][y] == right_dir)
6966 else if (element == EL_SP_SNIKSNAK || element == EL_SP_ELECTRON)
6968 TestIfBadThingTouchesOtherBadThing(x, y);
6970 if (ELEMENT_CAN_ENTER_FIELD_BASE_4(element, left_x, left_y, 0))
6971 MovDir[x][y] = left_dir;
6972 else if (!ELEMENT_CAN_ENTER_FIELD_BASE_4(element, move_x, move_y, 0))
6973 MovDir[x][y] = right_dir;
6975 if (MovDir[x][y] != old_move_dir)
6978 else if (element == EL_YAMYAM)
6980 boolean can_turn_left = YAMYAM_CAN_ENTER_FIELD(element, left_x, left_y);
6981 boolean can_turn_right = YAMYAM_CAN_ENTER_FIELD(element, right_x, right_y);
6983 if (can_turn_left && can_turn_right)
6984 MovDir[x][y] = (RND(3) ? (RND(2) ? left_dir : right_dir) : back_dir);
6985 else if (can_turn_left)
6986 MovDir[x][y] = (RND(2) ? left_dir : back_dir);
6987 else if (can_turn_right)
6988 MovDir[x][y] = (RND(2) ? right_dir : back_dir);
6990 MovDir[x][y] = back_dir;
6992 MovDelay[x][y] = 16 + 16 * RND(3);
6994 else if (element == EL_DARK_YAMYAM)
6996 boolean can_turn_left = DARK_YAMYAM_CAN_ENTER_FIELD(element,
6998 boolean can_turn_right = DARK_YAMYAM_CAN_ENTER_FIELD(element,
7001 if (can_turn_left && can_turn_right)
7002 MovDir[x][y] = (RND(3) ? (RND(2) ? left_dir : right_dir) : back_dir);
7003 else if (can_turn_left)
7004 MovDir[x][y] = (RND(2) ? left_dir : back_dir);
7005 else if (can_turn_right)
7006 MovDir[x][y] = (RND(2) ? right_dir : back_dir);
7008 MovDir[x][y] = back_dir;
7010 MovDelay[x][y] = 16 + 16 * RND(3);
7012 else if (element == EL_PACMAN)
7014 boolean can_turn_left = PACMAN_CAN_ENTER_FIELD(element, left_x, left_y);
7015 boolean can_turn_right = PACMAN_CAN_ENTER_FIELD(element, right_x, right_y);
7017 if (can_turn_left && can_turn_right)
7018 MovDir[x][y] = (RND(3) ? (RND(2) ? left_dir : right_dir) : back_dir);
7019 else if (can_turn_left)
7020 MovDir[x][y] = (RND(2) ? left_dir : back_dir);
7021 else if (can_turn_right)
7022 MovDir[x][y] = (RND(2) ? right_dir : back_dir);
7024 MovDir[x][y] = back_dir;
7026 MovDelay[x][y] = 6 + RND(40);
7028 else if (element == EL_PIG)
7030 boolean can_turn_left = PIG_CAN_ENTER_FIELD(element, left_x, left_y);
7031 boolean can_turn_right = PIG_CAN_ENTER_FIELD(element, right_x, right_y);
7032 boolean can_move_on = PIG_CAN_ENTER_FIELD(element, move_x, move_y);
7033 boolean should_turn_left, should_turn_right, should_move_on;
7035 int rnd = RND(rnd_value);
7037 should_turn_left = (can_turn_left &&
7039 IN_LEV_FIELD_AND_NOT_FREE(x + back_dx + left_dx,
7040 y + back_dy + left_dy)));
7041 should_turn_right = (can_turn_right &&
7043 IN_LEV_FIELD_AND_NOT_FREE(x + back_dx + right_dx,
7044 y + back_dy + right_dy)));
7045 should_move_on = (can_move_on &&
7048 IN_LEV_FIELD_AND_NOT_FREE(x + move_dx + left_dx,
7049 y + move_dy + left_dy) ||
7050 IN_LEV_FIELD_AND_NOT_FREE(x + move_dx + right_dx,
7051 y + move_dy + right_dy)));
7053 if (should_turn_left || should_turn_right || should_move_on)
7055 if (should_turn_left && should_turn_right && should_move_on)
7056 MovDir[x][y] = (rnd < rnd_value / 3 ? left_dir :
7057 rnd < 2 * rnd_value / 3 ? right_dir :
7059 else if (should_turn_left && should_turn_right)
7060 MovDir[x][y] = (rnd < rnd_value / 2 ? left_dir : right_dir);
7061 else if (should_turn_left && should_move_on)
7062 MovDir[x][y] = (rnd < rnd_value / 2 ? left_dir : old_move_dir);
7063 else if (should_turn_right && should_move_on)
7064 MovDir[x][y] = (rnd < rnd_value / 2 ? right_dir : old_move_dir);
7065 else if (should_turn_left)
7066 MovDir[x][y] = left_dir;
7067 else if (should_turn_right)
7068 MovDir[x][y] = right_dir;
7069 else if (should_move_on)
7070 MovDir[x][y] = old_move_dir;
7072 else if (can_move_on && rnd > rnd_value / 8)
7073 MovDir[x][y] = old_move_dir;
7074 else if (can_turn_left && can_turn_right)
7075 MovDir[x][y] = (rnd < rnd_value / 2 ? left_dir : right_dir);
7076 else if (can_turn_left && rnd > rnd_value / 8)
7077 MovDir[x][y] = left_dir;
7078 else if (can_turn_right && rnd > rnd_value/8)
7079 MovDir[x][y] = right_dir;
7081 MovDir[x][y] = back_dir;
7083 xx = x + move_xy[MovDir[x][y]].dx;
7084 yy = y + move_xy[MovDir[x][y]].dy;
7086 if (!IN_LEV_FIELD(xx, yy) ||
7087 (!IS_FREE(xx, yy) && !IS_FOOD_PIG(Tile[xx][yy])))
7088 MovDir[x][y] = old_move_dir;
7092 else if (element == EL_DRAGON)
7094 boolean can_turn_left = DRAGON_CAN_ENTER_FIELD(element, left_x, left_y);
7095 boolean can_turn_right = DRAGON_CAN_ENTER_FIELD(element, right_x, right_y);
7096 boolean can_move_on = DRAGON_CAN_ENTER_FIELD(element, move_x, move_y);
7098 int rnd = RND(rnd_value);
7100 if (can_move_on && rnd > rnd_value / 8)
7101 MovDir[x][y] = old_move_dir;
7102 else if (can_turn_left && can_turn_right)
7103 MovDir[x][y] = (rnd < rnd_value / 2 ? left_dir : right_dir);
7104 else if (can_turn_left && rnd > rnd_value / 8)
7105 MovDir[x][y] = left_dir;
7106 else if (can_turn_right && rnd > rnd_value / 8)
7107 MovDir[x][y] = right_dir;
7109 MovDir[x][y] = back_dir;
7111 xx = x + move_xy[MovDir[x][y]].dx;
7112 yy = y + move_xy[MovDir[x][y]].dy;
7114 if (!IN_LEV_FIELD_AND_IS_FREE(xx, yy))
7115 MovDir[x][y] = old_move_dir;
7119 else if (element == EL_MOLE)
7121 boolean can_move_on =
7122 (MOLE_CAN_ENTER_FIELD(element, move_x, move_y,
7123 IS_AMOEBOID(Tile[move_x][move_y]) ||
7124 Tile[move_x][move_y] == EL_AMOEBA_SHRINKING));
7127 boolean can_turn_left =
7128 (MOLE_CAN_ENTER_FIELD(element, left_x, left_y,
7129 IS_AMOEBOID(Tile[left_x][left_y])));
7131 boolean can_turn_right =
7132 (MOLE_CAN_ENTER_FIELD(element, right_x, right_y,
7133 IS_AMOEBOID(Tile[right_x][right_y])));
7135 if (can_turn_left && can_turn_right)
7136 MovDir[x][y] = (RND(2) ? left_dir : right_dir);
7137 else if (can_turn_left)
7138 MovDir[x][y] = left_dir;
7140 MovDir[x][y] = right_dir;
7143 if (MovDir[x][y] != old_move_dir)
7146 else if (element == EL_BALLOON)
7148 MovDir[x][y] = game.wind_direction;
7151 else if (element == EL_SPRING)
7153 if (MovDir[x][y] & MV_HORIZONTAL)
7155 if (SPRING_CAN_BUMP_FROM_FIELD(move_x, move_y) &&
7156 !SPRING_CAN_ENTER_FIELD(element, x, y + 1))
7158 Tile[move_x][move_y] = EL_EMC_SPRING_BUMPER_ACTIVE;
7159 ResetGfxAnimation(move_x, move_y);
7160 TEST_DrawLevelField(move_x, move_y);
7162 MovDir[x][y] = back_dir;
7164 else if (!SPRING_CAN_ENTER_FIELD(element, move_x, move_y) ||
7165 SPRING_CAN_ENTER_FIELD(element, x, y + 1))
7166 MovDir[x][y] = MV_NONE;
7171 else if (element == EL_ROBOT ||
7172 element == EL_SATELLITE ||
7173 element == EL_PENGUIN ||
7174 element == EL_EMC_ANDROID)
7176 int attr_x = -1, attr_y = -1;
7178 if (game.all_players_gone)
7180 attr_x = game.exit_x;
7181 attr_y = game.exit_y;
7187 for (i = 0; i < MAX_PLAYERS; i++)
7189 struct PlayerInfo *player = &stored_player[i];
7190 int jx = player->jx, jy = player->jy;
7192 if (!player->active)
7196 ABS(jx - x) + ABS(jy - y) < ABS(attr_x - x) + ABS(attr_y - y))
7204 if (element == EL_ROBOT &&
7205 game.robot_wheel_x >= 0 &&
7206 game.robot_wheel_y >= 0 &&
7207 (Tile[game.robot_wheel_x][game.robot_wheel_y] == EL_ROBOT_WHEEL_ACTIVE ||
7208 game.engine_version < VERSION_IDENT(3,1,0,0)))
7210 attr_x = game.robot_wheel_x;
7211 attr_y = game.robot_wheel_y;
7214 if (element == EL_PENGUIN)
7217 static int xy[4][2] =
7225 for (i = 0; i < NUM_DIRECTIONS; i++)
7227 int ex = x + xy[i][0];
7228 int ey = y + xy[i][1];
7230 if (IN_LEV_FIELD(ex, ey) && (Tile[ex][ey] == EL_EXIT_OPEN ||
7231 Tile[ex][ey] == EL_EM_EXIT_OPEN ||
7232 Tile[ex][ey] == EL_STEEL_EXIT_OPEN ||
7233 Tile[ex][ey] == EL_EM_STEEL_EXIT_OPEN))
7242 MovDir[x][y] = MV_NONE;
7244 MovDir[x][y] |= (game.all_players_gone ? MV_RIGHT : MV_LEFT);
7245 else if (attr_x > x)
7246 MovDir[x][y] |= (game.all_players_gone ? MV_LEFT : MV_RIGHT);
7248 MovDir[x][y] |= (game.all_players_gone ? MV_DOWN : MV_UP);
7249 else if (attr_y > y)
7250 MovDir[x][y] |= (game.all_players_gone ? MV_UP : MV_DOWN);
7252 if (element == EL_ROBOT)
7256 if (MovDir[x][y] & MV_HORIZONTAL && MovDir[x][y] & MV_VERTICAL)
7257 MovDir[x][y] &= (RND(2) ? MV_HORIZONTAL : MV_VERTICAL);
7258 Moving2Blocked(x, y, &newx, &newy);
7260 if (IN_LEV_FIELD(newx, newy) && IS_FREE_OR_PLAYER(newx, newy))
7261 MovDelay[x][y] = 8 + 8 * !RND(3);
7263 MovDelay[x][y] = 16;
7265 else if (element == EL_PENGUIN)
7271 if (MovDir[x][y] & MV_HORIZONTAL && MovDir[x][y] & MV_VERTICAL)
7273 boolean first_horiz = RND(2);
7274 int new_move_dir = MovDir[x][y];
7277 new_move_dir & (first_horiz ? MV_HORIZONTAL : MV_VERTICAL);
7278 Moving2Blocked(x, y, &newx, &newy);
7280 if (PENGUIN_CAN_ENTER_FIELD(element, newx, newy))
7284 new_move_dir & (!first_horiz ? MV_HORIZONTAL : MV_VERTICAL);
7285 Moving2Blocked(x, y, &newx, &newy);
7287 if (PENGUIN_CAN_ENTER_FIELD(element, newx, newy))
7290 MovDir[x][y] = old_move_dir;
7294 else if (element == EL_SATELLITE)
7300 if (MovDir[x][y] & MV_HORIZONTAL && MovDir[x][y] & MV_VERTICAL)
7302 boolean first_horiz = RND(2);
7303 int new_move_dir = MovDir[x][y];
7306 new_move_dir & (first_horiz ? MV_HORIZONTAL : MV_VERTICAL);
7307 Moving2Blocked(x, y, &newx, &newy);
7309 if (SATELLITE_CAN_ENTER_FIELD(newx, newy))
7313 new_move_dir & (!first_horiz ? MV_HORIZONTAL : MV_VERTICAL);
7314 Moving2Blocked(x, y, &newx, &newy);
7316 if (SATELLITE_CAN_ENTER_FIELD(newx, newy))
7319 MovDir[x][y] = old_move_dir;
7323 else if (element == EL_EMC_ANDROID)
7325 static int check_pos[16] =
7327 -1, // 0 => (invalid)
7330 -1, // 3 => (invalid)
7332 0, // 5 => MV_LEFT | MV_UP
7333 2, // 6 => MV_RIGHT | MV_UP
7334 -1, // 7 => (invalid)
7336 6, // 9 => MV_LEFT | MV_DOWN
7337 4, // 10 => MV_RIGHT | MV_DOWN
7338 -1, // 11 => (invalid)
7339 -1, // 12 => (invalid)
7340 -1, // 13 => (invalid)
7341 -1, // 14 => (invalid)
7342 -1, // 15 => (invalid)
7350 { -1, -1, MV_LEFT | MV_UP },
7352 { +1, -1, MV_RIGHT | MV_UP },
7353 { +1, 0, MV_RIGHT },
7354 { +1, +1, MV_RIGHT | MV_DOWN },
7356 { -1, +1, MV_LEFT | MV_DOWN },
7359 int start_pos, check_order;
7360 boolean can_clone = FALSE;
7363 // check if there is any free field around current position
7364 for (i = 0; i < 8; i++)
7366 int newx = x + check_xy[i].dx;
7367 int newy = y + check_xy[i].dy;
7369 if (IN_LEV_FIELD_AND_IS_FREE(newx, newy))
7377 if (can_clone) // randomly find an element to clone
7381 start_pos = check_pos[RND(8)];
7382 check_order = (RND(2) ? -1 : +1);
7384 for (i = 0; i < 8; i++)
7386 int pos_raw = start_pos + i * check_order;
7387 int pos = (pos_raw + 8) % 8;
7388 int newx = x + check_xy[pos].dx;
7389 int newy = y + check_xy[pos].dy;
7391 if (ANDROID_CAN_CLONE_FIELD(newx, newy))
7393 element_info[element].move_leave_type = LEAVE_TYPE_LIMITED;
7394 element_info[element].move_leave_element = EL_TRIGGER_ELEMENT;
7396 Store[x][y] = Tile[newx][newy];
7405 if (can_clone) // randomly find a direction to move
7409 start_pos = check_pos[RND(8)];
7410 check_order = (RND(2) ? -1 : +1);
7412 for (i = 0; i < 8; i++)
7414 int pos_raw = start_pos + i * check_order;
7415 int pos = (pos_raw + 8) % 8;
7416 int newx = x + check_xy[pos].dx;
7417 int newy = y + check_xy[pos].dy;
7418 int new_move_dir = check_xy[pos].dir;
7420 if (IN_LEV_FIELD_AND_IS_FREE(newx, newy))
7422 MovDir[x][y] = new_move_dir;
7423 MovDelay[x][y] = level.android_clone_time * 8 + 1;
7432 if (can_clone) // cloning and moving successful
7435 // cannot clone -- try to move towards player
7437 start_pos = check_pos[MovDir[x][y] & 0x0f];
7438 check_order = (RND(2) ? -1 : +1);
7440 for (i = 0; i < 3; i++)
7442 // first check start_pos, then previous/next or (next/previous) pos
7443 int pos_raw = start_pos + (i < 2 ? i : -1) * check_order;
7444 int pos = (pos_raw + 8) % 8;
7445 int newx = x + check_xy[pos].dx;
7446 int newy = y + check_xy[pos].dy;
7447 int new_move_dir = check_xy[pos].dir;
7449 if (IS_PLAYER(newx, newy))
7452 if (ANDROID_CAN_ENTER_FIELD(element, newx, newy))
7454 MovDir[x][y] = new_move_dir;
7455 MovDelay[x][y] = level.android_move_time * 8 + 1;
7462 else if (move_pattern == MV_TURNING_LEFT ||
7463 move_pattern == MV_TURNING_RIGHT ||
7464 move_pattern == MV_TURNING_LEFT_RIGHT ||
7465 move_pattern == MV_TURNING_RIGHT_LEFT ||
7466 move_pattern == MV_TURNING_RANDOM ||
7467 move_pattern == MV_ALL_DIRECTIONS)
7469 boolean can_turn_left =
7470 CUSTOM_ELEMENT_CAN_ENTER_FIELD(element, left_x, left_y);
7471 boolean can_turn_right =
7472 CUSTOM_ELEMENT_CAN_ENTER_FIELD(element, right_x,right_y);
7474 if (element_info[element].move_stepsize == 0) // "not moving"
7477 if (move_pattern == MV_TURNING_LEFT)
7478 MovDir[x][y] = left_dir;
7479 else if (move_pattern == MV_TURNING_RIGHT)
7480 MovDir[x][y] = right_dir;
7481 else if (move_pattern == MV_TURNING_LEFT_RIGHT)
7482 MovDir[x][y] = (can_turn_left || !can_turn_right ? left_dir : right_dir);
7483 else if (move_pattern == MV_TURNING_RIGHT_LEFT)
7484 MovDir[x][y] = (can_turn_right || !can_turn_left ? right_dir : left_dir);
7485 else if (move_pattern == MV_TURNING_RANDOM)
7486 MovDir[x][y] = (can_turn_left && !can_turn_right ? left_dir :
7487 can_turn_right && !can_turn_left ? right_dir :
7488 RND(2) ? left_dir : right_dir);
7489 else if (can_turn_left && can_turn_right)
7490 MovDir[x][y] = (RND(3) ? (RND(2) ? left_dir : right_dir) : back_dir);
7491 else if (can_turn_left)
7492 MovDir[x][y] = (RND(2) ? left_dir : back_dir);
7493 else if (can_turn_right)
7494 MovDir[x][y] = (RND(2) ? right_dir : back_dir);
7496 MovDir[x][y] = back_dir;
7498 MovDelay[x][y] = GET_NEW_MOVE_DELAY(element);
7500 else if (move_pattern == MV_HORIZONTAL ||
7501 move_pattern == MV_VERTICAL)
7503 if (move_pattern & old_move_dir)
7504 MovDir[x][y] = back_dir;
7505 else if (move_pattern == MV_HORIZONTAL)
7506 MovDir[x][y] = (RND(2) ? MV_LEFT : MV_RIGHT);
7507 else if (move_pattern == MV_VERTICAL)
7508 MovDir[x][y] = (RND(2) ? MV_UP : MV_DOWN);
7510 MovDelay[x][y] = GET_NEW_MOVE_DELAY(element);
7512 else if (move_pattern & MV_ANY_DIRECTION)
7514 MovDir[x][y] = move_pattern;
7515 MovDelay[x][y] = GET_NEW_MOVE_DELAY(element);
7517 else if (move_pattern & MV_WIND_DIRECTION)
7519 MovDir[x][y] = game.wind_direction;
7520 MovDelay[x][y] = GET_NEW_MOVE_DELAY(element);
7522 else if (move_pattern == MV_ALONG_LEFT_SIDE)
7524 if (CUSTOM_ELEMENT_CAN_ENTER_FIELD(element, left_x, left_y))
7525 MovDir[x][y] = left_dir;
7526 else if (!CUSTOM_ELEMENT_CAN_ENTER_FIELD(element, move_x, move_y))
7527 MovDir[x][y] = right_dir;
7529 if (MovDir[x][y] != old_move_dir)
7530 MovDelay[x][y] = GET_NEW_MOVE_DELAY(element);
7532 else if (move_pattern == MV_ALONG_RIGHT_SIDE)
7534 if (CUSTOM_ELEMENT_CAN_ENTER_FIELD(element, right_x, right_y))
7535 MovDir[x][y] = right_dir;
7536 else if (!CUSTOM_ELEMENT_CAN_ENTER_FIELD(element, move_x, move_y))
7537 MovDir[x][y] = left_dir;
7539 if (MovDir[x][y] != old_move_dir)
7540 MovDelay[x][y] = GET_NEW_MOVE_DELAY(element);
7542 else if (move_pattern == MV_TOWARDS_PLAYER ||
7543 move_pattern == MV_AWAY_FROM_PLAYER)
7545 int attr_x = -1, attr_y = -1;
7547 boolean move_away = (move_pattern == MV_AWAY_FROM_PLAYER);
7549 if (game.all_players_gone)
7551 attr_x = game.exit_x;
7552 attr_y = game.exit_y;
7558 for (i = 0; i < MAX_PLAYERS; i++)
7560 struct PlayerInfo *player = &stored_player[i];
7561 int jx = player->jx, jy = player->jy;
7563 if (!player->active)
7567 ABS(jx - x) + ABS(jy - y) < ABS(attr_x - x) + ABS(attr_y - y))
7575 MovDir[x][y] = MV_NONE;
7577 MovDir[x][y] |= (move_away ? MV_RIGHT : MV_LEFT);
7578 else if (attr_x > x)
7579 MovDir[x][y] |= (move_away ? MV_LEFT : MV_RIGHT);
7581 MovDir[x][y] |= (move_away ? MV_DOWN : MV_UP);
7582 else if (attr_y > y)
7583 MovDir[x][y] |= (move_away ? MV_UP : MV_DOWN);
7585 MovDelay[x][y] = GET_NEW_MOVE_DELAY(element);
7587 if (MovDir[x][y] & MV_HORIZONTAL && MovDir[x][y] & MV_VERTICAL)
7589 boolean first_horiz = RND(2);
7590 int new_move_dir = MovDir[x][y];
7592 if (element_info[element].move_stepsize == 0) // "not moving"
7594 first_horiz = (ABS(attr_x - x) >= ABS(attr_y - y));
7595 MovDir[x][y] &= (first_horiz ? MV_HORIZONTAL : MV_VERTICAL);
7601 new_move_dir & (first_horiz ? MV_HORIZONTAL : MV_VERTICAL);
7602 Moving2Blocked(x, y, &newx, &newy);
7604 if (CUSTOM_ELEMENT_CAN_ENTER_FIELD(element, newx, newy))
7608 new_move_dir & (!first_horiz ? MV_HORIZONTAL : MV_VERTICAL);
7609 Moving2Blocked(x, y, &newx, &newy);
7611 if (CUSTOM_ELEMENT_CAN_ENTER_FIELD(element, newx, newy))
7614 MovDir[x][y] = old_move_dir;
7617 else if (move_pattern == MV_WHEN_PUSHED ||
7618 move_pattern == MV_WHEN_DROPPED)
7620 if (!CUSTOM_ELEMENT_CAN_ENTER_FIELD(element, move_x, move_y))
7621 MovDir[x][y] = MV_NONE;
7625 else if (move_pattern & MV_MAZE_RUNNER_STYLE)
7627 static int test_xy[7][2] =
7637 static int test_dir[7] =
7647 boolean hunter_mode = (move_pattern == MV_MAZE_HUNTER);
7648 int move_preference = -1000000; // start with very low preference
7649 int new_move_dir = MV_NONE;
7650 int start_test = RND(4);
7653 for (i = 0; i < NUM_DIRECTIONS; i++)
7655 int move_dir = test_dir[start_test + i];
7656 int move_dir_preference;
7658 xx = x + test_xy[start_test + i][0];
7659 yy = y + test_xy[start_test + i][1];
7661 if (hunter_mode && IN_LEV_FIELD(xx, yy) &&
7662 (IS_PLAYER(xx, yy) || Tile[xx][yy] == EL_PLAYER_IS_LEAVING))
7664 new_move_dir = move_dir;
7669 if (!CUSTOM_ELEMENT_CAN_ENTER_FIELD(element, xx, yy))
7672 move_dir_preference = -1 * RunnerVisit[xx][yy];
7673 if (hunter_mode && PlayerVisit[xx][yy] > 0)
7674 move_dir_preference = PlayerVisit[xx][yy];
7676 if (move_dir_preference > move_preference)
7678 // prefer field that has not been visited for the longest time
7679 move_preference = move_dir_preference;
7680 new_move_dir = move_dir;
7682 else if (move_dir_preference == move_preference &&
7683 move_dir == old_move_dir)
7685 // prefer last direction when all directions are preferred equally
7686 move_preference = move_dir_preference;
7687 new_move_dir = move_dir;
7691 MovDir[x][y] = new_move_dir;
7692 if (old_move_dir != new_move_dir)
7693 MovDelay[x][y] = GET_NEW_MOVE_DELAY(element);
7697 static void TurnRound(int x, int y)
7699 int direction = MovDir[x][y];
7703 GfxDir[x][y] = MovDir[x][y];
7705 if (direction != MovDir[x][y])
7709 GfxAction[x][y] = ACTION_TURNING_FROM_LEFT + MV_DIR_TO_BIT(direction);
7711 ResetGfxFrame(x, y);
7714 static boolean JustBeingPushed(int x, int y)
7718 for (i = 0; i < MAX_PLAYERS; i++)
7720 struct PlayerInfo *player = &stored_player[i];
7722 if (player->active && player->is_pushing && player->MovPos)
7724 int next_jx = player->jx + (player->jx - player->last_jx);
7725 int next_jy = player->jy + (player->jy - player->last_jy);
7727 if (x == next_jx && y == next_jy)
7735 static void StartMoving(int x, int y)
7737 boolean started_moving = FALSE; // some elements can fall _and_ move
7738 int element = Tile[x][y];
7743 if (MovDelay[x][y] == 0)
7744 GfxAction[x][y] = ACTION_DEFAULT;
7746 if (CAN_FALL(element) && y < lev_fieldy - 1)
7748 if ((x > 0 && IS_PLAYER(x - 1, y)) ||
7749 (x < lev_fieldx - 1 && IS_PLAYER(x + 1, y)))
7750 if (JustBeingPushed(x, y))
7753 if (element == EL_QUICKSAND_FULL)
7755 if (IS_FREE(x, y + 1))
7757 InitMovingField(x, y, MV_DOWN);
7758 started_moving = TRUE;
7760 Tile[x][y] = EL_QUICKSAND_EMPTYING;
7761 #if USE_QUICKSAND_BD_ROCK_BUGFIX
7762 if (Store[x][y] != EL_ROCK && Store[x][y] != EL_BD_ROCK)
7763 Store[x][y] = EL_ROCK;
7765 Store[x][y] = EL_ROCK;
7768 PlayLevelSoundAction(x, y, ACTION_EMPTYING);
7770 else if (Tile[x][y + 1] == EL_QUICKSAND_EMPTY)
7772 if (!MovDelay[x][y])
7774 MovDelay[x][y] = TILEY + 1;
7776 ResetGfxAnimation(x, y);
7777 ResetGfxAnimation(x, y + 1);
7782 DrawLevelElement(x, y, EL_QUICKSAND_EMPTYING);
7783 DrawLevelElement(x, y + 1, EL_QUICKSAND_FILLING);
7790 Tile[x][y] = EL_QUICKSAND_EMPTY;
7791 Tile[x][y + 1] = EL_QUICKSAND_FULL;
7792 Store[x][y + 1] = Store[x][y];
7795 PlayLevelSoundAction(x, y, ACTION_FILLING);
7797 else if (Tile[x][y + 1] == EL_QUICKSAND_FAST_EMPTY)
7799 if (!MovDelay[x][y])
7801 MovDelay[x][y] = TILEY + 1;
7803 ResetGfxAnimation(x, y);
7804 ResetGfxAnimation(x, y + 1);
7809 DrawLevelElement(x, y, EL_QUICKSAND_EMPTYING);
7810 DrawLevelElement(x, y + 1, EL_QUICKSAND_FAST_FILLING);
7817 Tile[x][y] = EL_QUICKSAND_EMPTY;
7818 Tile[x][y + 1] = EL_QUICKSAND_FAST_FULL;
7819 Store[x][y + 1] = Store[x][y];
7822 PlayLevelSoundAction(x, y, ACTION_FILLING);
7825 else if (element == EL_QUICKSAND_FAST_FULL)
7827 if (IS_FREE(x, y + 1))
7829 InitMovingField(x, y, MV_DOWN);
7830 started_moving = TRUE;
7832 Tile[x][y] = EL_QUICKSAND_FAST_EMPTYING;
7833 #if USE_QUICKSAND_BD_ROCK_BUGFIX
7834 if (Store[x][y] != EL_ROCK && Store[x][y] != EL_BD_ROCK)
7835 Store[x][y] = EL_ROCK;
7837 Store[x][y] = EL_ROCK;
7840 PlayLevelSoundAction(x, y, ACTION_EMPTYING);
7842 else if (Tile[x][y + 1] == EL_QUICKSAND_FAST_EMPTY)
7844 if (!MovDelay[x][y])
7846 MovDelay[x][y] = TILEY + 1;
7848 ResetGfxAnimation(x, y);
7849 ResetGfxAnimation(x, y + 1);
7854 DrawLevelElement(x, y, EL_QUICKSAND_FAST_EMPTYING);
7855 DrawLevelElement(x, y + 1, EL_QUICKSAND_FAST_FILLING);
7862 Tile[x][y] = EL_QUICKSAND_FAST_EMPTY;
7863 Tile[x][y + 1] = EL_QUICKSAND_FAST_FULL;
7864 Store[x][y + 1] = Store[x][y];
7867 PlayLevelSoundAction(x, y, ACTION_FILLING);
7869 else if (Tile[x][y + 1] == EL_QUICKSAND_EMPTY)
7871 if (!MovDelay[x][y])
7873 MovDelay[x][y] = TILEY + 1;
7875 ResetGfxAnimation(x, y);
7876 ResetGfxAnimation(x, y + 1);
7881 DrawLevelElement(x, y, EL_QUICKSAND_FAST_EMPTYING);
7882 DrawLevelElement(x, y + 1, EL_QUICKSAND_FILLING);
7889 Tile[x][y] = EL_QUICKSAND_FAST_EMPTY;
7890 Tile[x][y + 1] = EL_QUICKSAND_FULL;
7891 Store[x][y + 1] = Store[x][y];
7894 PlayLevelSoundAction(x, y, ACTION_FILLING);
7897 else if ((element == EL_ROCK || element == EL_BD_ROCK) &&
7898 Tile[x][y + 1] == EL_QUICKSAND_EMPTY)
7900 InitMovingField(x, y, MV_DOWN);
7901 started_moving = TRUE;
7903 Tile[x][y] = EL_QUICKSAND_FILLING;
7904 Store[x][y] = element;
7906 PlayLevelSoundAction(x, y, ACTION_FILLING);
7908 else if ((element == EL_ROCK || element == EL_BD_ROCK) &&
7909 Tile[x][y + 1] == EL_QUICKSAND_FAST_EMPTY)
7911 InitMovingField(x, y, MV_DOWN);
7912 started_moving = TRUE;
7914 Tile[x][y] = EL_QUICKSAND_FAST_FILLING;
7915 Store[x][y] = element;
7917 PlayLevelSoundAction(x, y, ACTION_FILLING);
7919 else if (element == EL_MAGIC_WALL_FULL)
7921 if (IS_FREE(x, y + 1))
7923 InitMovingField(x, y, MV_DOWN);
7924 started_moving = TRUE;
7926 Tile[x][y] = EL_MAGIC_WALL_EMPTYING;
7927 Store[x][y] = EL_CHANGED(Store[x][y]);
7929 else if (Tile[x][y + 1] == EL_MAGIC_WALL_ACTIVE)
7931 if (!MovDelay[x][y])
7932 MovDelay[x][y] = TILEY / 4 + 1;
7941 Tile[x][y] = EL_MAGIC_WALL_ACTIVE;
7942 Tile[x][y + 1] = EL_MAGIC_WALL_FULL;
7943 Store[x][y + 1] = EL_CHANGED(Store[x][y]);
7947 else if (element == EL_BD_MAGIC_WALL_FULL)
7949 if (IS_FREE(x, y + 1))
7951 InitMovingField(x, y, MV_DOWN);
7952 started_moving = TRUE;
7954 Tile[x][y] = EL_BD_MAGIC_WALL_EMPTYING;
7955 Store[x][y] = EL_CHANGED_BD(Store[x][y]);
7957 else if (Tile[x][y + 1] == EL_BD_MAGIC_WALL_ACTIVE)
7959 if (!MovDelay[x][y])
7960 MovDelay[x][y] = TILEY / 4 + 1;
7969 Tile[x][y] = EL_BD_MAGIC_WALL_ACTIVE;
7970 Tile[x][y + 1] = EL_BD_MAGIC_WALL_FULL;
7971 Store[x][y + 1] = EL_CHANGED_BD(Store[x][y]);
7975 else if (element == EL_DC_MAGIC_WALL_FULL)
7977 if (IS_FREE(x, y + 1))
7979 InitMovingField(x, y, MV_DOWN);
7980 started_moving = TRUE;
7982 Tile[x][y] = EL_DC_MAGIC_WALL_EMPTYING;
7983 Store[x][y] = EL_CHANGED_DC(Store[x][y]);
7985 else if (Tile[x][y + 1] == EL_DC_MAGIC_WALL_ACTIVE)
7987 if (!MovDelay[x][y])
7988 MovDelay[x][y] = TILEY / 4 + 1;
7997 Tile[x][y] = EL_DC_MAGIC_WALL_ACTIVE;
7998 Tile[x][y + 1] = EL_DC_MAGIC_WALL_FULL;
7999 Store[x][y + 1] = EL_CHANGED_DC(Store[x][y]);
8003 else if ((CAN_PASS_MAGIC_WALL(element) &&
8004 (Tile[x][y + 1] == EL_MAGIC_WALL_ACTIVE ||
8005 Tile[x][y + 1] == EL_BD_MAGIC_WALL_ACTIVE)) ||
8006 (CAN_PASS_DC_MAGIC_WALL(element) &&
8007 (Tile[x][y + 1] == EL_DC_MAGIC_WALL_ACTIVE)))
8010 InitMovingField(x, y, MV_DOWN);
8011 started_moving = TRUE;
8014 (Tile[x][y + 1] == EL_MAGIC_WALL_ACTIVE ? EL_MAGIC_WALL_FILLING :
8015 Tile[x][y + 1] == EL_BD_MAGIC_WALL_ACTIVE ? EL_BD_MAGIC_WALL_FILLING :
8016 EL_DC_MAGIC_WALL_FILLING);
8017 Store[x][y] = element;
8019 else if (CAN_FALL(element) && Tile[x][y + 1] == EL_ACID)
8021 SplashAcid(x, y + 1);
8023 InitMovingField(x, y, MV_DOWN);
8024 started_moving = TRUE;
8026 Store[x][y] = EL_ACID;
8029 (game.engine_version >= VERSION_IDENT(3,1,0,0) &&
8030 CheckImpact[x][y] && !IS_FREE(x, y + 1)) ||
8031 (game.engine_version >= VERSION_IDENT(3,0,7,0) &&
8032 CAN_FALL(element) && WasJustFalling[x][y] &&
8033 (Tile[x][y + 1] == EL_BLOCKED || IS_PLAYER(x, y + 1))) ||
8035 (game.engine_version < VERSION_IDENT(2,2,0,7) &&
8036 CAN_FALL(element) && WasJustMoving[x][y] && !Pushed[x][y + 1] &&
8037 (Tile[x][y + 1] == EL_BLOCKED)))
8039 /* this is needed for a special case not covered by calling "Impact()"
8040 from "ContinueMoving()": if an element moves to a tile directly below
8041 another element which was just falling on that tile (which was empty
8042 in the previous frame), the falling element above would just stop
8043 instead of smashing the element below (in previous version, the above
8044 element was just checked for "moving" instead of "falling", resulting
8045 in incorrect smashes caused by horizontal movement of the above
8046 element; also, the case of the player being the element to smash was
8047 simply not covered here... :-/ ) */
8049 CheckCollision[x][y] = 0;
8050 CheckImpact[x][y] = 0;
8054 else if (IS_FREE(x, y + 1) && element == EL_SPRING && level.use_spring_bug)
8056 if (MovDir[x][y] == MV_NONE)
8058 InitMovingField(x, y, MV_DOWN);
8059 started_moving = TRUE;
8062 else if (IS_FREE(x, y + 1) || Tile[x][y + 1] == EL_DIAMOND_BREAKING)
8064 if (WasJustFalling[x][y]) // prevent animation from being restarted
8065 MovDir[x][y] = MV_DOWN;
8067 InitMovingField(x, y, MV_DOWN);
8068 started_moving = TRUE;
8070 else if (element == EL_AMOEBA_DROP)
8072 Tile[x][y] = EL_AMOEBA_GROWING;
8073 Store[x][y] = EL_AMOEBA_WET;
8075 else if (((IS_SLIPPERY(Tile[x][y + 1]) && !IS_PLAYER(x, y + 1)) ||
8076 (IS_EM_SLIPPERY_WALL(Tile[x][y + 1]) && IS_GEM(element))) &&
8077 !IS_FALLING(x, y + 1) && !WasJustMoving[x][y + 1] &&
8078 element != EL_DX_SUPABOMB && element != EL_SP_DISK_ORANGE)
8080 boolean can_fall_left = (x > 0 && IS_FREE(x - 1, y) &&
8081 (IS_FREE(x - 1, y + 1) ||
8082 Tile[x - 1][y + 1] == EL_ACID));
8083 boolean can_fall_right = (x < lev_fieldx - 1 && IS_FREE(x + 1, y) &&
8084 (IS_FREE(x + 1, y + 1) ||
8085 Tile[x + 1][y + 1] == EL_ACID));
8086 boolean can_fall_any = (can_fall_left || can_fall_right);
8087 boolean can_fall_both = (can_fall_left && can_fall_right);
8088 int slippery_type = element_info[Tile[x][y + 1]].slippery_type;
8090 if (can_fall_any && slippery_type != SLIPPERY_ANY_RANDOM)
8092 if (slippery_type == SLIPPERY_ANY_LEFT_RIGHT && can_fall_both)
8093 can_fall_right = FALSE;
8094 else if (slippery_type == SLIPPERY_ANY_RIGHT_LEFT && can_fall_both)
8095 can_fall_left = FALSE;
8096 else if (slippery_type == SLIPPERY_ONLY_LEFT)
8097 can_fall_right = FALSE;
8098 else if (slippery_type == SLIPPERY_ONLY_RIGHT)
8099 can_fall_left = FALSE;
8101 can_fall_any = (can_fall_left || can_fall_right);
8102 can_fall_both = FALSE;
8107 if (element == EL_BD_ROCK || element == EL_BD_DIAMOND)
8108 can_fall_right = FALSE; // slip down on left side
8110 can_fall_left = !(can_fall_right = RND(2));
8112 can_fall_both = FALSE;
8117 // if not determined otherwise, prefer left side for slipping down
8118 InitMovingField(x, y, can_fall_left ? MV_LEFT : MV_RIGHT);
8119 started_moving = TRUE;
8122 else if (IS_BELT_ACTIVE(Tile[x][y + 1]))
8124 boolean left_is_free = (x > 0 && IS_FREE(x - 1, y));
8125 boolean right_is_free = (x < lev_fieldx - 1 && IS_FREE(x + 1, y));
8126 int belt_nr = getBeltNrFromBeltActiveElement(Tile[x][y + 1]);
8127 int belt_dir = game.belt_dir[belt_nr];
8129 if ((belt_dir == MV_LEFT && left_is_free) ||
8130 (belt_dir == MV_RIGHT && right_is_free))
8132 int nextx = (belt_dir == MV_LEFT ? x - 1 : x + 1);
8134 InitMovingField(x, y, belt_dir);
8135 started_moving = TRUE;
8137 Pushed[x][y] = TRUE;
8138 Pushed[nextx][y] = TRUE;
8140 GfxAction[x][y] = ACTION_DEFAULT;
8144 MovDir[x][y] = 0; // if element was moving, stop it
8149 // not "else if" because of elements that can fall and move (EL_SPRING)
8150 if (CAN_MOVE(element) && !started_moving)
8152 int move_pattern = element_info[element].move_pattern;
8155 Moving2Blocked(x, y, &newx, &newy);
8157 if (IS_PUSHABLE(element) && JustBeingPushed(x, y))
8160 if (game.engine_version >= VERSION_IDENT(3,1,0,0) &&
8161 CheckCollision[x][y] && !IN_LEV_FIELD_AND_IS_FREE(newx, newy))
8163 WasJustMoving[x][y] = 0;
8164 CheckCollision[x][y] = 0;
8166 TestIfElementHitsCustomElement(x, y, MovDir[x][y]);
8168 if (Tile[x][y] != element) // element has changed
8172 if (!MovDelay[x][y]) // start new movement phase
8174 // all objects that can change their move direction after each step
8175 // (YAMYAM, DARK_YAMYAM and PACMAN go straight until they hit a wall
8177 if (element != EL_YAMYAM &&
8178 element != EL_DARK_YAMYAM &&
8179 element != EL_PACMAN &&
8180 !(move_pattern & MV_ANY_DIRECTION) &&
8181 move_pattern != MV_TURNING_LEFT &&
8182 move_pattern != MV_TURNING_RIGHT &&
8183 move_pattern != MV_TURNING_LEFT_RIGHT &&
8184 move_pattern != MV_TURNING_RIGHT_LEFT &&
8185 move_pattern != MV_TURNING_RANDOM)
8189 if (MovDelay[x][y] && (element == EL_BUG ||
8190 element == EL_SPACESHIP ||
8191 element == EL_SP_SNIKSNAK ||
8192 element == EL_SP_ELECTRON ||
8193 element == EL_MOLE))
8194 TEST_DrawLevelField(x, y);
8198 if (MovDelay[x][y]) // wait some time before next movement
8202 if (element == EL_ROBOT ||
8203 element == EL_YAMYAM ||
8204 element == EL_DARK_YAMYAM)
8206 DrawLevelElementAnimationIfNeeded(x, y, element);
8207 PlayLevelSoundAction(x, y, ACTION_WAITING);
8209 else if (element == EL_SP_ELECTRON)
8210 DrawLevelElementAnimationIfNeeded(x, y, element);
8211 else if (element == EL_DRAGON)
8214 int dir = MovDir[x][y];
8215 int dx = (dir == MV_LEFT ? -1 : dir == MV_RIGHT ? +1 : 0);
8216 int dy = (dir == MV_UP ? -1 : dir == MV_DOWN ? +1 : 0);
8217 int graphic = (dir == MV_LEFT ? IMG_FLAMES_1_LEFT :
8218 dir == MV_RIGHT ? IMG_FLAMES_1_RIGHT :
8219 dir == MV_UP ? IMG_FLAMES_1_UP :
8220 dir == MV_DOWN ? IMG_FLAMES_1_DOWN : IMG_EMPTY);
8221 int frame = getGraphicAnimationFrame(graphic, GfxFrame[x][y]);
8223 GfxAction[x][y] = ACTION_ATTACKING;
8225 if (IS_PLAYER(x, y))
8226 DrawPlayerField(x, y);
8228 TEST_DrawLevelField(x, y);
8230 PlayLevelSoundActionIfLoop(x, y, ACTION_ATTACKING);
8232 for (i = 1; i <= 3; i++)
8234 int xx = x + i * dx;
8235 int yy = y + i * dy;
8236 int sx = SCREENX(xx);
8237 int sy = SCREENY(yy);
8238 int flame_graphic = graphic + (i - 1);
8240 if (!IN_LEV_FIELD(xx, yy) || IS_DRAGONFIRE_PROOF(Tile[xx][yy]))
8245 int flamed = MovingOrBlocked2Element(xx, yy);
8247 if (IS_CLASSIC_ENEMY(flamed) || CAN_EXPLODE_BY_DRAGONFIRE(flamed))
8250 RemoveMovingField(xx, yy);
8252 ChangeDelay[xx][yy] = 0;
8254 Tile[xx][yy] = EL_FLAMES;
8256 if (IN_SCR_FIELD(sx, sy))
8258 TEST_DrawLevelFieldCrumbled(xx, yy);
8259 DrawGraphic(sx, sy, flame_graphic, frame);
8264 if (Tile[xx][yy] == EL_FLAMES)
8265 Tile[xx][yy] = EL_EMPTY;
8266 TEST_DrawLevelField(xx, yy);
8271 if (MovDelay[x][y]) // element still has to wait some time
8273 PlayLevelSoundAction(x, y, ACTION_WAITING);
8279 // now make next step
8281 Moving2Blocked(x, y, &newx, &newy); // get next screen position
8283 if (DONT_COLLIDE_WITH(element) &&
8284 IN_LEV_FIELD(newx, newy) && IS_PLAYER(newx, newy) &&
8285 !PLAYER_ENEMY_PROTECTED(newx, newy))
8287 TestIfBadThingRunsIntoPlayer(x, y, MovDir[x][y]);
8292 else if (CAN_MOVE_INTO_ACID(element) &&
8293 IN_LEV_FIELD(newx, newy) && Tile[newx][newy] == EL_ACID &&
8294 !IS_MV_DIAGONAL(MovDir[x][y]) &&
8295 (MovDir[x][y] == MV_DOWN ||
8296 game.engine_version >= VERSION_IDENT(3,1,0,0)))
8298 SplashAcid(newx, newy);
8299 Store[x][y] = EL_ACID;
8301 else if (element == EL_PENGUIN && IN_LEV_FIELD(newx, newy))
8303 if (Tile[newx][newy] == EL_EXIT_OPEN ||
8304 Tile[newx][newy] == EL_EM_EXIT_OPEN ||
8305 Tile[newx][newy] == EL_STEEL_EXIT_OPEN ||
8306 Tile[newx][newy] == EL_EM_STEEL_EXIT_OPEN)
8309 TEST_DrawLevelField(x, y);
8311 PlayLevelSound(newx, newy, SND_PENGUIN_PASSING);
8312 if (IN_SCR_FIELD(SCREENX(newx), SCREENY(newy)))
8313 DrawGraphicThruMask(SCREENX(newx),SCREENY(newy), el2img(element), 0);
8315 game.friends_still_needed--;
8316 if (!game.friends_still_needed &&
8318 game.all_players_gone)
8323 else if (IS_FOOD_PENGUIN(Tile[newx][newy]))
8325 if (DigField(local_player, x, y, newx, newy, 0,0, DF_DIG) == MP_MOVING)
8326 TEST_DrawLevelField(newx, newy);
8328 GfxDir[x][y] = MovDir[x][y] = MV_NONE;
8330 else if (!IS_FREE(newx, newy))
8332 GfxAction[x][y] = ACTION_WAITING;
8334 if (IS_PLAYER(x, y))
8335 DrawPlayerField(x, y);
8337 TEST_DrawLevelField(x, y);
8342 else if (element == EL_PIG && IN_LEV_FIELD(newx, newy))
8344 if (IS_FOOD_PIG(Tile[newx][newy]))
8346 if (IS_MOVING(newx, newy))
8347 RemoveMovingField(newx, newy);
8350 Tile[newx][newy] = EL_EMPTY;
8351 TEST_DrawLevelField(newx, newy);
8354 PlayLevelSound(x, y, SND_PIG_DIGGING);
8356 else if (!IS_FREE(newx, newy))
8358 if (IS_PLAYER(x, y))
8359 DrawPlayerField(x, y);
8361 TEST_DrawLevelField(x, y);
8366 else if (element == EL_EMC_ANDROID && IN_LEV_FIELD(newx, newy))
8368 if (Store[x][y] != EL_EMPTY)
8370 boolean can_clone = FALSE;
8373 // check if element to clone is still there
8374 for (yy = y - 1; yy <= y + 1; yy++) for (xx = x - 1; xx <= x + 1; xx++)
8376 if (IN_LEV_FIELD(xx, yy) && Tile[xx][yy] == Store[x][y])
8384 // cannot clone or target field not free anymore -- do not clone
8385 if (!can_clone || !ANDROID_CAN_ENTER_FIELD(element, newx, newy))
8386 Store[x][y] = EL_EMPTY;
8389 if (ANDROID_CAN_ENTER_FIELD(element, newx, newy))
8391 if (IS_MV_DIAGONAL(MovDir[x][y]))
8393 int diagonal_move_dir = MovDir[x][y];
8394 int stored = Store[x][y];
8395 int change_delay = 8;
8398 // android is moving diagonally
8400 CreateField(x, y, EL_DIAGONAL_SHRINKING);
8402 Store[x][y] = (stored == EL_ACID ? EL_EMPTY : stored);
8403 GfxElement[x][y] = EL_EMC_ANDROID;
8404 GfxAction[x][y] = ACTION_SHRINKING;
8405 GfxDir[x][y] = diagonal_move_dir;
8406 ChangeDelay[x][y] = change_delay;
8408 graphic = el_act_dir2img(GfxElement[x][y], GfxAction[x][y],
8411 DrawLevelGraphicAnimation(x, y, graphic);
8412 PlayLevelSoundAction(x, y, ACTION_SHRINKING);
8414 if (Tile[newx][newy] == EL_ACID)
8416 SplashAcid(newx, newy);
8421 CreateField(newx, newy, EL_DIAGONAL_GROWING);
8423 Store[newx][newy] = EL_EMC_ANDROID;
8424 GfxElement[newx][newy] = EL_EMC_ANDROID;
8425 GfxAction[newx][newy] = ACTION_GROWING;
8426 GfxDir[newx][newy] = diagonal_move_dir;
8427 ChangeDelay[newx][newy] = change_delay;
8429 graphic = el_act_dir2img(GfxElement[newx][newy],
8430 GfxAction[newx][newy], GfxDir[newx][newy]);
8432 DrawLevelGraphicAnimation(newx, newy, graphic);
8433 PlayLevelSoundAction(newx, newy, ACTION_GROWING);
8439 Tile[newx][newy] = EL_EMPTY;
8440 TEST_DrawLevelField(newx, newy);
8442 PlayLevelSoundAction(x, y, ACTION_DIGGING);
8445 else if (!IS_FREE(newx, newy))
8450 else if (IS_CUSTOM_ELEMENT(element) &&
8451 CUSTOM_ELEMENT_CAN_ENTER_FIELD(element, newx, newy))
8453 if (!DigFieldByCE(newx, newy, element))
8456 if (move_pattern & MV_MAZE_RUNNER_STYLE)
8458 RunnerVisit[x][y] = FrameCounter;
8459 PlayerVisit[x][y] /= 8; // expire player visit path
8462 else if (element == EL_DRAGON && IN_LEV_FIELD(newx, newy))
8464 if (!IS_FREE(newx, newy))
8466 if (IS_PLAYER(x, y))
8467 DrawPlayerField(x, y);
8469 TEST_DrawLevelField(x, y);
8475 boolean wanna_flame = !RND(10);
8476 int dx = newx - x, dy = newy - y;
8477 int newx1 = newx + 1 * dx, newy1 = newy + 1 * dy;
8478 int newx2 = newx + 2 * dx, newy2 = newy + 2 * dy;
8479 int element1 = (IN_LEV_FIELD(newx1, newy1) ?
8480 MovingOrBlocked2Element(newx1, newy1) : EL_STEELWALL);
8481 int element2 = (IN_LEV_FIELD(newx2, newy2) ?
8482 MovingOrBlocked2Element(newx2, newy2) : EL_STEELWALL);
8485 IS_CLASSIC_ENEMY(element1) ||
8486 IS_CLASSIC_ENEMY(element2)) &&
8487 element1 != EL_DRAGON && element2 != EL_DRAGON &&
8488 element1 != EL_FLAMES && element2 != EL_FLAMES)
8490 ResetGfxAnimation(x, y);
8491 GfxAction[x][y] = ACTION_ATTACKING;
8493 if (IS_PLAYER(x, y))
8494 DrawPlayerField(x, y);
8496 TEST_DrawLevelField(x, y);
8498 PlayLevelSound(x, y, SND_DRAGON_ATTACKING);
8500 MovDelay[x][y] = 50;
8502 Tile[newx][newy] = EL_FLAMES;
8503 if (IN_LEV_FIELD(newx1, newy1) && Tile[newx1][newy1] == EL_EMPTY)
8504 Tile[newx1][newy1] = EL_FLAMES;
8505 if (IN_LEV_FIELD(newx2, newy2) && Tile[newx2][newy2] == EL_EMPTY)
8506 Tile[newx2][newy2] = EL_FLAMES;
8512 else if (element == EL_YAMYAM && IN_LEV_FIELD(newx, newy) &&
8513 Tile[newx][newy] == EL_DIAMOND)
8515 if (IS_MOVING(newx, newy))
8516 RemoveMovingField(newx, newy);
8519 Tile[newx][newy] = EL_EMPTY;
8520 TEST_DrawLevelField(newx, newy);
8523 PlayLevelSound(x, y, SND_YAMYAM_DIGGING);
8525 else if (element == EL_DARK_YAMYAM && IN_LEV_FIELD(newx, newy) &&
8526 IS_FOOD_DARK_YAMYAM(Tile[newx][newy]))
8528 if (AmoebaNr[newx][newy])
8530 AmoebaCnt2[AmoebaNr[newx][newy]]--;
8531 if (Tile[newx][newy] == EL_AMOEBA_FULL ||
8532 Tile[newx][newy] == EL_BD_AMOEBA)
8533 AmoebaCnt[AmoebaNr[newx][newy]]--;
8536 if (IS_MOVING(newx, newy))
8538 RemoveMovingField(newx, newy);
8542 Tile[newx][newy] = EL_EMPTY;
8543 TEST_DrawLevelField(newx, newy);
8546 PlayLevelSound(x, y, SND_DARK_YAMYAM_DIGGING);
8548 else if ((element == EL_PACMAN || element == EL_MOLE)
8549 && IN_LEV_FIELD(newx, newy) && IS_AMOEBOID(Tile[newx][newy]))
8551 if (AmoebaNr[newx][newy])
8553 AmoebaCnt2[AmoebaNr[newx][newy]]--;
8554 if (Tile[newx][newy] == EL_AMOEBA_FULL ||
8555 Tile[newx][newy] == EL_BD_AMOEBA)
8556 AmoebaCnt[AmoebaNr[newx][newy]]--;
8559 if (element == EL_MOLE)
8561 Tile[newx][newy] = EL_AMOEBA_SHRINKING;
8562 PlayLevelSound(x, y, SND_MOLE_DIGGING);
8564 ResetGfxAnimation(x, y);
8565 GfxAction[x][y] = ACTION_DIGGING;
8566 TEST_DrawLevelField(x, y);
8568 MovDelay[newx][newy] = 0; // start amoeba shrinking delay
8570 return; // wait for shrinking amoeba
8572 else // element == EL_PACMAN
8574 Tile[newx][newy] = EL_EMPTY;
8575 TEST_DrawLevelField(newx, newy);
8576 PlayLevelSound(x, y, SND_PACMAN_DIGGING);
8579 else if (element == EL_MOLE && IN_LEV_FIELD(newx, newy) &&
8580 (Tile[newx][newy] == EL_AMOEBA_SHRINKING ||
8581 (Tile[newx][newy] == EL_EMPTY && Stop[newx][newy])))
8583 // wait for shrinking amoeba to completely disappear
8586 else if (!IN_LEV_FIELD(newx, newy) || !IS_FREE(newx, newy))
8588 // object was running against a wall
8592 if (GFX_ELEMENT(element) != EL_SAND) // !!! FIX THIS (crumble) !!!
8593 DrawLevelElementAnimation(x, y, element);
8595 if (DONT_TOUCH(element))
8596 TestIfBadThingTouchesPlayer(x, y);
8601 InitMovingField(x, y, MovDir[x][y]);
8603 PlayLevelSoundAction(x, y, ACTION_MOVING);
8607 ContinueMoving(x, y);
8610 void ContinueMoving(int x, int y)
8612 int element = Tile[x][y];
8613 struct ElementInfo *ei = &element_info[element];
8614 int direction = MovDir[x][y];
8615 int dx = (direction == MV_LEFT ? -1 : direction == MV_RIGHT ? +1 : 0);
8616 int dy = (direction == MV_UP ? -1 : direction == MV_DOWN ? +1 : 0);
8617 int newx = x + dx, newy = y + dy;
8618 int stored = Store[x][y];
8619 int stored_new = Store[newx][newy];
8620 boolean pushed_by_player = (Pushed[x][y] && IS_PLAYER(x, y));
8621 boolean pushed_by_conveyor = (Pushed[x][y] && !IS_PLAYER(x, y));
8622 boolean last_line = (newy == lev_fieldy - 1);
8623 boolean use_step_delay = (GET_MAX_STEP_DELAY(element) != 0);
8625 if (pushed_by_player) // special case: moving object pushed by player
8627 MovPos[x][y] = SIGN(MovPos[x][y]) * (TILEX - ABS(PLAYERINFO(x,y)->MovPos));
8629 else if (use_step_delay) // special case: moving object has step delay
8631 if (!MovDelay[x][y])
8632 MovPos[x][y] += getElementMoveStepsize(x, y);
8637 MovDelay[x][y] = GET_NEW_STEP_DELAY(element);
8641 TEST_DrawLevelField(x, y);
8643 return; // element is still waiting
8646 else // normal case: generically moving object
8648 MovPos[x][y] += getElementMoveStepsize(x, y);
8651 if (ABS(MovPos[x][y]) < TILEX)
8653 TEST_DrawLevelField(x, y);
8655 return; // element is still moving
8658 // element reached destination field
8660 Tile[x][y] = EL_EMPTY;
8661 Tile[newx][newy] = element;
8662 MovPos[x][y] = 0; // force "not moving" for "crumbled sand"
8664 if (Store[x][y] == EL_ACID) // element is moving into acid pool
8666 element = Tile[newx][newy] = EL_ACID;
8668 else if (element == EL_MOLE)
8670 Tile[x][y] = EL_SAND;
8672 TEST_DrawLevelFieldCrumbledNeighbours(x, y);
8674 else if (element == EL_QUICKSAND_FILLING)
8676 element = Tile[newx][newy] = get_next_element(element);
8677 Store[newx][newy] = Store[x][y];
8679 else if (element == EL_QUICKSAND_EMPTYING)
8681 Tile[x][y] = get_next_element(element);
8682 element = Tile[newx][newy] = Store[x][y];
8684 else if (element == EL_QUICKSAND_FAST_FILLING)
8686 element = Tile[newx][newy] = get_next_element(element);
8687 Store[newx][newy] = Store[x][y];
8689 else if (element == EL_QUICKSAND_FAST_EMPTYING)
8691 Tile[x][y] = get_next_element(element);
8692 element = Tile[newx][newy] = Store[x][y];
8694 else if (element == EL_MAGIC_WALL_FILLING)
8696 element = Tile[newx][newy] = get_next_element(element);
8697 if (!game.magic_wall_active)
8698 element = Tile[newx][newy] = EL_MAGIC_WALL_DEAD;
8699 Store[newx][newy] = Store[x][y];
8701 else if (element == EL_MAGIC_WALL_EMPTYING)
8703 Tile[x][y] = get_next_element(element);
8704 if (!game.magic_wall_active)
8705 Tile[x][y] = EL_MAGIC_WALL_DEAD;
8706 element = Tile[newx][newy] = Store[x][y];
8708 InitField(newx, newy, FALSE);
8710 else if (element == EL_BD_MAGIC_WALL_FILLING)
8712 element = Tile[newx][newy] = get_next_element(element);
8713 if (!game.magic_wall_active)
8714 element = Tile[newx][newy] = EL_BD_MAGIC_WALL_DEAD;
8715 Store[newx][newy] = Store[x][y];
8717 else if (element == EL_BD_MAGIC_WALL_EMPTYING)
8719 Tile[x][y] = get_next_element(element);
8720 if (!game.magic_wall_active)
8721 Tile[x][y] = EL_BD_MAGIC_WALL_DEAD;
8722 element = Tile[newx][newy] = Store[x][y];
8724 InitField(newx, newy, FALSE);
8726 else if (element == EL_DC_MAGIC_WALL_FILLING)
8728 element = Tile[newx][newy] = get_next_element(element);
8729 if (!game.magic_wall_active)
8730 element = Tile[newx][newy] = EL_DC_MAGIC_WALL_DEAD;
8731 Store[newx][newy] = Store[x][y];
8733 else if (element == EL_DC_MAGIC_WALL_EMPTYING)
8735 Tile[x][y] = get_next_element(element);
8736 if (!game.magic_wall_active)
8737 Tile[x][y] = EL_DC_MAGIC_WALL_DEAD;
8738 element = Tile[newx][newy] = Store[x][y];
8740 InitField(newx, newy, FALSE);
8742 else if (element == EL_AMOEBA_DROPPING)
8744 Tile[x][y] = get_next_element(element);
8745 element = Tile[newx][newy] = Store[x][y];
8747 else if (element == EL_SOKOBAN_OBJECT)
8750 Tile[x][y] = Back[x][y];
8752 if (Back[newx][newy])
8753 Tile[newx][newy] = EL_SOKOBAN_FIELD_FULL;
8755 Back[x][y] = Back[newx][newy] = 0;
8758 Store[x][y] = EL_EMPTY;
8763 MovDelay[newx][newy] = 0;
8765 if (CAN_CHANGE_OR_HAS_ACTION(element))
8767 // copy element change control values to new field
8768 ChangeDelay[newx][newy] = ChangeDelay[x][y];
8769 ChangePage[newx][newy] = ChangePage[x][y];
8770 ChangeCount[newx][newy] = ChangeCount[x][y];
8771 ChangeEvent[newx][newy] = ChangeEvent[x][y];
8774 CustomValue[newx][newy] = CustomValue[x][y];
8776 ChangeDelay[x][y] = 0;
8777 ChangePage[x][y] = -1;
8778 ChangeCount[x][y] = 0;
8779 ChangeEvent[x][y] = -1;
8781 CustomValue[x][y] = 0;
8783 // copy animation control values to new field
8784 GfxFrame[newx][newy] = GfxFrame[x][y];
8785 GfxRandom[newx][newy] = GfxRandom[x][y]; // keep same random value
8786 GfxAction[newx][newy] = GfxAction[x][y]; // keep action one frame
8787 GfxDir[newx][newy] = GfxDir[x][y]; // keep element direction
8789 Pushed[x][y] = Pushed[newx][newy] = FALSE;
8791 // some elements can leave other elements behind after moving
8792 if (ei->move_leave_element != EL_EMPTY &&
8793 (ei->move_leave_type == LEAVE_TYPE_UNLIMITED || stored != EL_EMPTY) &&
8794 (!IS_PLAYER(x, y) || IS_WALKABLE(ei->move_leave_element)))
8796 int move_leave_element = ei->move_leave_element;
8798 // this makes it possible to leave the removed element again
8799 if (ei->move_leave_element == EL_TRIGGER_ELEMENT)
8800 move_leave_element = (stored == EL_ACID ? EL_EMPTY : stored);
8802 Tile[x][y] = move_leave_element;
8804 if (element_info[Tile[x][y]].move_direction_initial == MV_START_PREVIOUS)
8805 MovDir[x][y] = direction;
8807 InitField(x, y, FALSE);
8809 if (GFX_CRUMBLED(Tile[x][y]))
8810 TEST_DrawLevelFieldCrumbledNeighbours(x, y);
8812 if (IS_PLAYER_ELEMENT(move_leave_element))
8813 RelocatePlayer(x, y, move_leave_element);
8816 // do this after checking for left-behind element
8817 ResetGfxAnimation(x, y); // reset animation values for old field
8819 if (!CAN_MOVE(element) ||
8820 (CAN_FALL(element) && direction == MV_DOWN &&
8821 (element == EL_SPRING ||
8822 element_info[element].move_pattern == MV_WHEN_PUSHED ||
8823 element_info[element].move_pattern == MV_WHEN_DROPPED)))
8824 GfxDir[x][y] = MovDir[newx][newy] = 0;
8826 TEST_DrawLevelField(x, y);
8827 TEST_DrawLevelField(newx, newy);
8829 Stop[newx][newy] = TRUE; // ignore this element until the next frame
8831 // prevent pushed element from moving on in pushed direction
8832 if (pushed_by_player && CAN_MOVE(element) &&
8833 element_info[element].move_pattern & MV_ANY_DIRECTION &&
8834 !(element_info[element].move_pattern & direction))
8835 TurnRound(newx, newy);
8837 // prevent elements on conveyor belt from moving on in last direction
8838 if (pushed_by_conveyor && CAN_FALL(element) &&
8839 direction & MV_HORIZONTAL)
8840 MovDir[newx][newy] = 0;
8842 if (!pushed_by_player)
8844 int nextx = newx + dx, nexty = newy + dy;
8845 boolean check_collision_again = IN_LEV_FIELD_AND_IS_FREE(nextx, nexty);
8847 WasJustMoving[newx][newy] = CHECK_DELAY_MOVING;
8849 if (CAN_FALL(element) && direction == MV_DOWN)
8850 WasJustFalling[newx][newy] = CHECK_DELAY_FALLING;
8852 if ((!CAN_FALL(element) || direction == MV_DOWN) && check_collision_again)
8853 CheckCollision[newx][newy] = CHECK_DELAY_COLLISION;
8855 if (CAN_FALL(element) && direction == MV_DOWN && check_collision_again)
8856 CheckImpact[newx][newy] = CHECK_DELAY_IMPACT;
8859 if (DONT_TOUCH(element)) // object may be nasty to player or others
8861 TestIfBadThingTouchesPlayer(newx, newy);
8862 TestIfBadThingTouchesFriend(newx, newy);
8864 if (!IS_CUSTOM_ELEMENT(element))
8865 TestIfBadThingTouchesOtherBadThing(newx, newy);
8867 else if (element == EL_PENGUIN)
8868 TestIfFriendTouchesBadThing(newx, newy);
8870 if (DONT_GET_HIT_BY(element))
8872 TestIfGoodThingGetsHitByBadThing(newx, newy, direction);
8875 // give the player one last chance (one more frame) to move away
8876 if (CAN_FALL(element) && direction == MV_DOWN &&
8877 (last_line || (!IS_FREE(x, newy + 1) &&
8878 (!IS_PLAYER(x, newy + 1) ||
8879 game.engine_version < VERSION_IDENT(3,1,1,0)))))
8882 if (pushed_by_player && !game.use_change_when_pushing_bug)
8884 int push_side = MV_DIR_OPPOSITE(direction);
8885 struct PlayerInfo *player = PLAYERINFO(x, y);
8887 CheckElementChangeByPlayer(newx, newy, element, CE_PUSHED_BY_PLAYER,
8888 player->index_bit, push_side);
8889 CheckTriggeredElementChangeByPlayer(newx,newy, element, CE_PLAYER_PUSHES_X,
8890 player->index_bit, push_side);
8893 if (element == EL_EMC_ANDROID && pushed_by_player) // make another move
8894 MovDelay[newx][newy] = 1;
8896 CheckTriggeredElementChangeBySide(x, y, element, CE_MOVE_OF_X, direction);
8898 TestIfElementTouchesCustomElement(x, y); // empty or new element
8899 TestIfElementHitsCustomElement(newx, newy, direction);
8900 TestIfPlayerTouchesCustomElement(newx, newy);
8901 TestIfElementTouchesCustomElement(newx, newy);
8903 if (IS_CUSTOM_ELEMENT(element) && ei->move_enter_element != EL_EMPTY &&
8904 IS_EQUAL_OR_IN_GROUP(stored_new, ei->move_enter_element))
8905 CheckElementChangeBySide(newx, newy, element, stored_new, CE_DIGGING_X,
8906 MV_DIR_OPPOSITE(direction));
8909 int AmoebaNeighbourNr(int ax, int ay)
8912 int element = Tile[ax][ay];
8914 static int xy[4][2] =
8922 for (i = 0; i < NUM_DIRECTIONS; i++)
8924 int x = ax + xy[i][0];
8925 int y = ay + xy[i][1];
8927 if (!IN_LEV_FIELD(x, y))
8930 if (Tile[x][y] == element && AmoebaNr[x][y] > 0)
8931 group_nr = AmoebaNr[x][y];
8937 static void AmoebaMerge(int ax, int ay)
8939 int i, x, y, xx, yy;
8940 int new_group_nr = AmoebaNr[ax][ay];
8941 static int xy[4][2] =
8949 if (new_group_nr == 0)
8952 for (i = 0; i < NUM_DIRECTIONS; i++)
8957 if (!IN_LEV_FIELD(x, y))
8960 if ((Tile[x][y] == EL_AMOEBA_FULL ||
8961 Tile[x][y] == EL_BD_AMOEBA ||
8962 Tile[x][y] == EL_AMOEBA_DEAD) &&
8963 AmoebaNr[x][y] != new_group_nr)
8965 int old_group_nr = AmoebaNr[x][y];
8967 if (old_group_nr == 0)
8970 AmoebaCnt[new_group_nr] += AmoebaCnt[old_group_nr];
8971 AmoebaCnt[old_group_nr] = 0;
8972 AmoebaCnt2[new_group_nr] += AmoebaCnt2[old_group_nr];
8973 AmoebaCnt2[old_group_nr] = 0;
8975 SCAN_PLAYFIELD(xx, yy)
8977 if (AmoebaNr[xx][yy] == old_group_nr)
8978 AmoebaNr[xx][yy] = new_group_nr;
8984 void AmoebaToDiamond(int ax, int ay)
8988 if (Tile[ax][ay] == EL_AMOEBA_DEAD)
8990 int group_nr = AmoebaNr[ax][ay];
8995 Debug("game:playing:AmoebaToDiamond", "ax = %d, ay = %d", ax, ay);
8996 Debug("game:playing:AmoebaToDiamond", "This should never happen!");
9002 SCAN_PLAYFIELD(x, y)
9004 if (Tile[x][y] == EL_AMOEBA_DEAD && AmoebaNr[x][y] == group_nr)
9007 Tile[x][y] = EL_AMOEBA_TO_DIAMOND;
9011 PlayLevelSound(ax, ay, (IS_GEM(level.amoeba_content) ?
9012 SND_AMOEBA_TURNING_TO_GEM :
9013 SND_AMOEBA_TURNING_TO_ROCK));
9018 static int xy[4][2] =
9026 for (i = 0; i < NUM_DIRECTIONS; i++)
9031 if (!IN_LEV_FIELD(x, y))
9034 if (Tile[x][y] == EL_AMOEBA_TO_DIAMOND)
9036 PlayLevelSound(x, y, (IS_GEM(level.amoeba_content) ?
9037 SND_AMOEBA_TURNING_TO_GEM :
9038 SND_AMOEBA_TURNING_TO_ROCK));
9045 static void AmoebaToDiamondBD(int ax, int ay, int new_element)
9048 int group_nr = AmoebaNr[ax][ay];
9049 boolean done = FALSE;
9054 Debug("game:playing:AmoebaToDiamondBD", "ax = %d, ay = %d", ax, ay);
9055 Debug("game:playing:AmoebaToDiamondBD", "This should never happen!");
9061 SCAN_PLAYFIELD(x, y)
9063 if (AmoebaNr[x][y] == group_nr &&
9064 (Tile[x][y] == EL_AMOEBA_DEAD ||
9065 Tile[x][y] == EL_BD_AMOEBA ||
9066 Tile[x][y] == EL_AMOEBA_GROWING))
9069 Tile[x][y] = new_element;
9070 InitField(x, y, FALSE);
9071 TEST_DrawLevelField(x, y);
9077 PlayLevelSound(ax, ay, (new_element == EL_BD_ROCK ?
9078 SND_BD_AMOEBA_TURNING_TO_ROCK :
9079 SND_BD_AMOEBA_TURNING_TO_GEM));
9082 static void AmoebaGrowing(int x, int y)
9084 static unsigned int sound_delay = 0;
9085 static unsigned int sound_delay_value = 0;
9087 if (!MovDelay[x][y]) // start new growing cycle
9091 if (DelayReached(&sound_delay, sound_delay_value))
9093 PlayLevelSoundElementAction(x, y, Store[x][y], ACTION_GROWING);
9094 sound_delay_value = 30;
9098 if (MovDelay[x][y]) // wait some time before growing bigger
9101 if (MovDelay[x][y]/2 && IN_SCR_FIELD(SCREENX(x), SCREENY(y)))
9103 int frame = getGraphicAnimationFrame(IMG_AMOEBA_GROWING,
9104 6 - MovDelay[x][y]);
9106 DrawGraphic(SCREENX(x), SCREENY(y), IMG_AMOEBA_GROWING, frame);
9109 if (!MovDelay[x][y])
9111 Tile[x][y] = Store[x][y];
9113 TEST_DrawLevelField(x, y);
9118 static void AmoebaShrinking(int x, int y)
9120 static unsigned int sound_delay = 0;
9121 static unsigned int sound_delay_value = 0;
9123 if (!MovDelay[x][y]) // start new shrinking cycle
9127 if (DelayReached(&sound_delay, sound_delay_value))
9128 sound_delay_value = 30;
9131 if (MovDelay[x][y]) // wait some time before shrinking
9134 if (MovDelay[x][y]/2 && IN_SCR_FIELD(SCREENX(x), SCREENY(y)))
9136 int frame = getGraphicAnimationFrame(IMG_AMOEBA_SHRINKING,
9137 6 - MovDelay[x][y]);
9139 DrawGraphic(SCREENX(x), SCREENY(y), IMG_AMOEBA_SHRINKING, frame);
9142 if (!MovDelay[x][y])
9144 Tile[x][y] = EL_EMPTY;
9145 TEST_DrawLevelField(x, y);
9147 // don't let mole enter this field in this cycle;
9148 // (give priority to objects falling to this field from above)
9154 static void AmoebaReproduce(int ax, int ay)
9157 int element = Tile[ax][ay];
9158 int graphic = el2img(element);
9159 int newax = ax, neway = ay;
9160 boolean can_drop = (element == EL_AMOEBA_WET || element == EL_EMC_DRIPPER);
9161 static int xy[4][2] =
9169 if (!level.amoeba_speed && element != EL_EMC_DRIPPER)
9171 Tile[ax][ay] = EL_AMOEBA_DEAD;
9172 TEST_DrawLevelField(ax, ay);
9176 if (IS_ANIMATED(graphic))
9177 DrawLevelGraphicAnimationIfNeeded(ax, ay, graphic);
9179 if (!MovDelay[ax][ay]) // start making new amoeba field
9180 MovDelay[ax][ay] = RND(FRAMES_PER_SECOND * 25 / (1 + level.amoeba_speed));
9182 if (MovDelay[ax][ay]) // wait some time before making new amoeba
9185 if (MovDelay[ax][ay])
9189 if (can_drop) // EL_AMOEBA_WET or EL_EMC_DRIPPER
9192 int x = ax + xy[start][0];
9193 int y = ay + xy[start][1];
9195 if (!IN_LEV_FIELD(x, y))
9198 if (IS_FREE(x, y) ||
9199 CAN_GROW_INTO(Tile[x][y]) ||
9200 Tile[x][y] == EL_QUICKSAND_EMPTY ||
9201 Tile[x][y] == EL_QUICKSAND_FAST_EMPTY)
9207 if (newax == ax && neway == ay)
9210 else // normal or "filled" (BD style) amoeba
9213 boolean waiting_for_player = FALSE;
9215 for (i = 0; i < NUM_DIRECTIONS; i++)
9217 int j = (start + i) % 4;
9218 int x = ax + xy[j][0];
9219 int y = ay + xy[j][1];
9221 if (!IN_LEV_FIELD(x, y))
9224 if (IS_FREE(x, y) ||
9225 CAN_GROW_INTO(Tile[x][y]) ||
9226 Tile[x][y] == EL_QUICKSAND_EMPTY ||
9227 Tile[x][y] == EL_QUICKSAND_FAST_EMPTY)
9233 else if (IS_PLAYER(x, y))
9234 waiting_for_player = TRUE;
9237 if (newax == ax && neway == ay) // amoeba cannot grow
9239 if (i == 4 && (!waiting_for_player || element == EL_BD_AMOEBA))
9241 Tile[ax][ay] = EL_AMOEBA_DEAD;
9242 TEST_DrawLevelField(ax, ay);
9243 AmoebaCnt[AmoebaNr[ax][ay]]--;
9245 if (AmoebaCnt[AmoebaNr[ax][ay]] <= 0) // amoeba is completely dead
9247 if (element == EL_AMOEBA_FULL)
9248 AmoebaToDiamond(ax, ay);
9249 else if (element == EL_BD_AMOEBA)
9250 AmoebaToDiamondBD(ax, ay, level.amoeba_content);
9255 else if (element == EL_AMOEBA_FULL || element == EL_BD_AMOEBA)
9257 // amoeba gets larger by growing in some direction
9259 int new_group_nr = AmoebaNr[ax][ay];
9262 if (new_group_nr == 0)
9264 Debug("game:playing:AmoebaReproduce", "newax = %d, neway = %d",
9266 Debug("game:playing:AmoebaReproduce", "This should never happen!");
9272 AmoebaNr[newax][neway] = new_group_nr;
9273 AmoebaCnt[new_group_nr]++;
9274 AmoebaCnt2[new_group_nr]++;
9276 // if amoeba touches other amoeba(s) after growing, unify them
9277 AmoebaMerge(newax, neway);
9279 if (element == EL_BD_AMOEBA && AmoebaCnt2[new_group_nr] >= 200)
9281 AmoebaToDiamondBD(newax, neway, EL_BD_ROCK);
9287 if (!can_drop || neway < ay || !IS_FREE(newax, neway) ||
9288 (neway == lev_fieldy - 1 && newax != ax))
9290 Tile[newax][neway] = EL_AMOEBA_GROWING; // creation of new amoeba
9291 Store[newax][neway] = element;
9293 else if (neway == ay || element == EL_EMC_DRIPPER)
9295 Tile[newax][neway] = EL_AMOEBA_DROP; // drop left/right of amoeba
9297 PlayLevelSoundAction(newax, neway, ACTION_GROWING);
9301 InitMovingField(ax, ay, MV_DOWN); // drop dripping from amoeba
9302 Tile[ax][ay] = EL_AMOEBA_DROPPING;
9303 Store[ax][ay] = EL_AMOEBA_DROP;
9304 ContinueMoving(ax, ay);
9308 TEST_DrawLevelField(newax, neway);
9311 static void Life(int ax, int ay)
9315 int element = Tile[ax][ay];
9316 int graphic = el2img(element);
9317 int *life_parameter = (element == EL_GAME_OF_LIFE ? level.game_of_life :
9319 boolean changed = FALSE;
9321 if (IS_ANIMATED(graphic))
9322 DrawLevelGraphicAnimationIfNeeded(ax, ay, graphic);
9327 if (!MovDelay[ax][ay]) // start new "game of life" cycle
9328 MovDelay[ax][ay] = life_time;
9330 if (MovDelay[ax][ay]) // wait some time before next cycle
9333 if (MovDelay[ax][ay])
9337 for (y1 = -1; y1 < 2; y1++) for (x1 = -1; x1 < 2; x1++)
9339 int xx = ax+x1, yy = ay+y1;
9340 int old_element = Tile[xx][yy];
9341 int num_neighbours = 0;
9343 if (!IN_LEV_FIELD(xx, yy))
9346 for (y2 = -1; y2 < 2; y2++) for (x2 = -1; x2 < 2; x2++)
9348 int x = xx+x2, y = yy+y2;
9350 if (!IN_LEV_FIELD(x, y) || (x == xx && y == yy))
9353 boolean is_player_cell = (element == EL_GAME_OF_LIFE && IS_PLAYER(x, y));
9354 boolean is_neighbour = FALSE;
9356 if (level.use_life_bugs)
9358 (((Tile[x][y] == element || is_player_cell) && !Stop[x][y]) ||
9359 (IS_FREE(x, y) && Stop[x][y]));
9362 (Last[x][y] == element || is_player_cell);
9368 boolean is_free = FALSE;
9370 if (level.use_life_bugs)
9371 is_free = (IS_FREE(xx, yy));
9373 is_free = (IS_FREE(xx, yy) && Last[xx][yy] == EL_EMPTY);
9375 if (xx == ax && yy == ay) // field in the middle
9377 if (num_neighbours < life_parameter[0] ||
9378 num_neighbours > life_parameter[1])
9380 Tile[xx][yy] = EL_EMPTY;
9381 if (Tile[xx][yy] != old_element)
9382 TEST_DrawLevelField(xx, yy);
9383 Stop[xx][yy] = TRUE;
9387 else if (is_free || CAN_GROW_INTO(Tile[xx][yy]))
9388 { // free border field
9389 if (num_neighbours >= life_parameter[2] &&
9390 num_neighbours <= life_parameter[3])
9392 Tile[xx][yy] = element;
9393 MovDelay[xx][yy] = (element == EL_GAME_OF_LIFE ? 0 : life_time-1);
9394 if (Tile[xx][yy] != old_element)
9395 TEST_DrawLevelField(xx, yy);
9396 Stop[xx][yy] = TRUE;
9403 PlayLevelSound(ax, ay, element == EL_BIOMAZE ? SND_BIOMAZE_GROWING :
9404 SND_GAME_OF_LIFE_GROWING);
9407 static void InitRobotWheel(int x, int y)
9409 ChangeDelay[x][y] = level.time_wheel * FRAMES_PER_SECOND;
9412 static void RunRobotWheel(int x, int y)
9414 PlayLevelSound(x, y, SND_ROBOT_WHEEL_ACTIVE);
9417 static void StopRobotWheel(int x, int y)
9419 if (game.robot_wheel_x == x &&
9420 game.robot_wheel_y == y)
9422 game.robot_wheel_x = -1;
9423 game.robot_wheel_y = -1;
9424 game.robot_wheel_active = FALSE;
9428 static void InitTimegateWheel(int x, int y)
9430 ChangeDelay[x][y] = level.time_timegate * FRAMES_PER_SECOND;
9433 static void RunTimegateWheel(int x, int y)
9435 PlayLevelSound(x, y, SND_CLASS_TIMEGATE_SWITCH_ACTIVE);
9438 static void InitMagicBallDelay(int x, int y)
9440 ChangeDelay[x][y] = (level.ball_time + 1) * 8 + 1;
9443 static void ActivateMagicBall(int bx, int by)
9447 if (level.ball_random)
9449 int pos_border = RND(8); // select one of the eight border elements
9450 int pos_content = (pos_border > 3 ? pos_border + 1 : pos_border);
9451 int xx = pos_content % 3;
9452 int yy = pos_content / 3;
9457 if (IN_LEV_FIELD(x, y) && Tile[x][y] == EL_EMPTY)
9458 CreateField(x, y, level.ball_content[game.ball_content_nr].e[xx][yy]);
9462 for (y = by - 1; y <= by + 1; y++) for (x = bx - 1; x <= bx + 1; x++)
9464 int xx = x - bx + 1;
9465 int yy = y - by + 1;
9467 if (IN_LEV_FIELD(x, y) && Tile[x][y] == EL_EMPTY)
9468 CreateField(x, y, level.ball_content[game.ball_content_nr].e[xx][yy]);
9472 game.ball_content_nr = (game.ball_content_nr + 1) % level.num_ball_contents;
9475 static void CheckExit(int x, int y)
9477 if (game.gems_still_needed > 0 ||
9478 game.sokoban_fields_still_needed > 0 ||
9479 game.sokoban_objects_still_needed > 0 ||
9480 game.lights_still_needed > 0)
9482 int element = Tile[x][y];
9483 int graphic = el2img(element);
9485 if (IS_ANIMATED(graphic))
9486 DrawLevelGraphicAnimationIfNeeded(x, y, graphic);
9491 // do not re-open exit door closed after last player
9492 if (game.all_players_gone)
9495 Tile[x][y] = EL_EXIT_OPENING;
9497 PlayLevelSoundNearest(x, y, SND_CLASS_EXIT_OPENING);
9500 static void CheckExitEM(int x, int y)
9502 if (game.gems_still_needed > 0 ||
9503 game.sokoban_fields_still_needed > 0 ||
9504 game.sokoban_objects_still_needed > 0 ||
9505 game.lights_still_needed > 0)
9507 int element = Tile[x][y];
9508 int graphic = el2img(element);
9510 if (IS_ANIMATED(graphic))
9511 DrawLevelGraphicAnimationIfNeeded(x, y, graphic);
9516 // do not re-open exit door closed after last player
9517 if (game.all_players_gone)
9520 Tile[x][y] = EL_EM_EXIT_OPENING;
9522 PlayLevelSoundNearest(x, y, SND_CLASS_EM_EXIT_OPENING);
9525 static void CheckExitSteel(int x, int y)
9527 if (game.gems_still_needed > 0 ||
9528 game.sokoban_fields_still_needed > 0 ||
9529 game.sokoban_objects_still_needed > 0 ||
9530 game.lights_still_needed > 0)
9532 int element = Tile[x][y];
9533 int graphic = el2img(element);
9535 if (IS_ANIMATED(graphic))
9536 DrawLevelGraphicAnimationIfNeeded(x, y, graphic);
9541 // do not re-open exit door closed after last player
9542 if (game.all_players_gone)
9545 Tile[x][y] = EL_STEEL_EXIT_OPENING;
9547 PlayLevelSoundNearest(x, y, SND_CLASS_STEEL_EXIT_OPENING);
9550 static void CheckExitSteelEM(int x, int y)
9552 if (game.gems_still_needed > 0 ||
9553 game.sokoban_fields_still_needed > 0 ||
9554 game.sokoban_objects_still_needed > 0 ||
9555 game.lights_still_needed > 0)
9557 int element = Tile[x][y];
9558 int graphic = el2img(element);
9560 if (IS_ANIMATED(graphic))
9561 DrawLevelGraphicAnimationIfNeeded(x, y, graphic);
9566 // do not re-open exit door closed after last player
9567 if (game.all_players_gone)
9570 Tile[x][y] = EL_EM_STEEL_EXIT_OPENING;
9572 PlayLevelSoundNearest(x, y, SND_CLASS_EM_STEEL_EXIT_OPENING);
9575 static void CheckExitSP(int x, int y)
9577 if (game.gems_still_needed > 0)
9579 int element = Tile[x][y];
9580 int graphic = el2img(element);
9582 if (IS_ANIMATED(graphic))
9583 DrawLevelGraphicAnimationIfNeeded(x, y, graphic);
9588 // do not re-open exit door closed after last player
9589 if (game.all_players_gone)
9592 Tile[x][y] = EL_SP_EXIT_OPENING;
9594 PlayLevelSoundNearest(x, y, SND_CLASS_SP_EXIT_OPENING);
9597 static void CloseAllOpenTimegates(void)
9601 SCAN_PLAYFIELD(x, y)
9603 int element = Tile[x][y];
9605 if (element == EL_TIMEGATE_OPEN || element == EL_TIMEGATE_OPENING)
9607 Tile[x][y] = EL_TIMEGATE_CLOSING;
9609 PlayLevelSoundAction(x, y, ACTION_CLOSING);
9614 static void DrawTwinkleOnField(int x, int y)
9616 if (!IN_SCR_FIELD(SCREENX(x), SCREENY(y)) || IS_MOVING(x, y))
9619 if (Tile[x][y] == EL_BD_DIAMOND)
9622 if (MovDelay[x][y] == 0) // next animation frame
9623 MovDelay[x][y] = 11 * !GetSimpleRandom(500);
9625 if (MovDelay[x][y] != 0) // wait some time before next frame
9629 DrawLevelElementAnimation(x, y, Tile[x][y]);
9631 if (MovDelay[x][y] != 0)
9633 int frame = getGraphicAnimationFrame(IMG_TWINKLE_WHITE,
9634 10 - MovDelay[x][y]);
9636 DrawGraphicThruMask(SCREENX(x), SCREENY(y), IMG_TWINKLE_WHITE, frame);
9641 static void MauerWaechst(int x, int y)
9645 if (!MovDelay[x][y]) // next animation frame
9646 MovDelay[x][y] = 3 * delay;
9648 if (MovDelay[x][y]) // wait some time before next frame
9652 if (IN_SCR_FIELD(SCREENX(x), SCREENY(y)))
9654 int graphic = el_dir2img(Tile[x][y], GfxDir[x][y]);
9655 int frame = getGraphicAnimationFrame(graphic, 17 - MovDelay[x][y]);
9657 DrawGraphic(SCREENX(x), SCREENY(y), graphic, frame);
9660 if (!MovDelay[x][y])
9662 if (MovDir[x][y] == MV_LEFT)
9664 if (IN_LEV_FIELD(x - 1, y) && IS_WALL(Tile[x - 1][y]))
9665 TEST_DrawLevelField(x - 1, y);
9667 else if (MovDir[x][y] == MV_RIGHT)
9669 if (IN_LEV_FIELD(x + 1, y) && IS_WALL(Tile[x + 1][y]))
9670 TEST_DrawLevelField(x + 1, y);
9672 else if (MovDir[x][y] == MV_UP)
9674 if (IN_LEV_FIELD(x, y - 1) && IS_WALL(Tile[x][y - 1]))
9675 TEST_DrawLevelField(x, y - 1);
9679 if (IN_LEV_FIELD(x, y + 1) && IS_WALL(Tile[x][y + 1]))
9680 TEST_DrawLevelField(x, y + 1);
9683 Tile[x][y] = Store[x][y];
9685 GfxDir[x][y] = MovDir[x][y] = MV_NONE;
9686 TEST_DrawLevelField(x, y);
9691 static void MauerAbleger(int ax, int ay)
9693 int element = Tile[ax][ay];
9694 int graphic = el2img(element);
9695 boolean oben_frei = FALSE, unten_frei = FALSE;
9696 boolean links_frei = FALSE, rechts_frei = FALSE;
9697 boolean oben_massiv = FALSE, unten_massiv = FALSE;
9698 boolean links_massiv = FALSE, rechts_massiv = FALSE;
9699 boolean new_wall = FALSE;
9701 if (IS_ANIMATED(graphic))
9702 DrawLevelGraphicAnimationIfNeeded(ax, ay, graphic);
9704 if (!MovDelay[ax][ay]) // start building new wall
9705 MovDelay[ax][ay] = 6;
9707 if (MovDelay[ax][ay]) // wait some time before building new wall
9710 if (MovDelay[ax][ay])
9714 if (IN_LEV_FIELD(ax, ay-1) && IS_FREE(ax, ay-1))
9716 if (IN_LEV_FIELD(ax, ay+1) && IS_FREE(ax, ay+1))
9718 if (IN_LEV_FIELD(ax-1, ay) && IS_FREE(ax-1, ay))
9720 if (IN_LEV_FIELD(ax+1, ay) && IS_FREE(ax+1, ay))
9723 if (element == EL_EXPANDABLE_WALL_VERTICAL ||
9724 element == EL_EXPANDABLE_WALL_ANY)
9728 Tile[ax][ay-1] = EL_EXPANDABLE_WALL_GROWING;
9729 Store[ax][ay-1] = element;
9730 GfxDir[ax][ay-1] = MovDir[ax][ay-1] = MV_UP;
9731 if (IN_SCR_FIELD(SCREENX(ax), SCREENY(ay-1)))
9732 DrawGraphic(SCREENX(ax), SCREENY(ay - 1),
9733 IMG_EXPANDABLE_WALL_GROWING_UP, 0);
9738 Tile[ax][ay+1] = EL_EXPANDABLE_WALL_GROWING;
9739 Store[ax][ay+1] = element;
9740 GfxDir[ax][ay+1] = MovDir[ax][ay+1] = MV_DOWN;
9741 if (IN_SCR_FIELD(SCREENX(ax), SCREENY(ay+1)))
9742 DrawGraphic(SCREENX(ax), SCREENY(ay + 1),
9743 IMG_EXPANDABLE_WALL_GROWING_DOWN, 0);
9748 if (element == EL_EXPANDABLE_WALL_HORIZONTAL ||
9749 element == EL_EXPANDABLE_WALL_ANY ||
9750 element == EL_EXPANDABLE_WALL ||
9751 element == EL_BD_EXPANDABLE_WALL)
9755 Tile[ax-1][ay] = EL_EXPANDABLE_WALL_GROWING;
9756 Store[ax-1][ay] = element;
9757 GfxDir[ax-1][ay] = MovDir[ax-1][ay] = MV_LEFT;
9758 if (IN_SCR_FIELD(SCREENX(ax-1), SCREENY(ay)))
9759 DrawGraphic(SCREENX(ax - 1), SCREENY(ay),
9760 IMG_EXPANDABLE_WALL_GROWING_LEFT, 0);
9766 Tile[ax+1][ay] = EL_EXPANDABLE_WALL_GROWING;
9767 Store[ax+1][ay] = element;
9768 GfxDir[ax+1][ay] = MovDir[ax+1][ay] = MV_RIGHT;
9769 if (IN_SCR_FIELD(SCREENX(ax+1), SCREENY(ay)))
9770 DrawGraphic(SCREENX(ax + 1), SCREENY(ay),
9771 IMG_EXPANDABLE_WALL_GROWING_RIGHT, 0);
9776 if (element == EL_EXPANDABLE_WALL && (links_frei || rechts_frei))
9777 TEST_DrawLevelField(ax, ay);
9779 if (!IN_LEV_FIELD(ax, ay-1) || IS_WALL(Tile[ax][ay-1]))
9781 if (!IN_LEV_FIELD(ax, ay+1) || IS_WALL(Tile[ax][ay+1]))
9782 unten_massiv = TRUE;
9783 if (!IN_LEV_FIELD(ax-1, ay) || IS_WALL(Tile[ax-1][ay]))
9784 links_massiv = TRUE;
9785 if (!IN_LEV_FIELD(ax+1, ay) || IS_WALL(Tile[ax+1][ay]))
9786 rechts_massiv = TRUE;
9788 if (((oben_massiv && unten_massiv) ||
9789 element == EL_EXPANDABLE_WALL_HORIZONTAL ||
9790 element == EL_EXPANDABLE_WALL) &&
9791 ((links_massiv && rechts_massiv) ||
9792 element == EL_EXPANDABLE_WALL_VERTICAL))
9793 Tile[ax][ay] = EL_WALL;
9796 PlayLevelSoundAction(ax, ay, ACTION_GROWING);
9799 static void MauerAblegerStahl(int ax, int ay)
9801 int element = Tile[ax][ay];
9802 int graphic = el2img(element);
9803 boolean oben_frei = FALSE, unten_frei = FALSE;
9804 boolean links_frei = FALSE, rechts_frei = FALSE;
9805 boolean oben_massiv = FALSE, unten_massiv = FALSE;
9806 boolean links_massiv = FALSE, rechts_massiv = FALSE;
9807 boolean new_wall = FALSE;
9809 if (IS_ANIMATED(graphic))
9810 DrawLevelGraphicAnimationIfNeeded(ax, ay, graphic);
9812 if (!MovDelay[ax][ay]) // start building new wall
9813 MovDelay[ax][ay] = 6;
9815 if (MovDelay[ax][ay]) // wait some time before building new wall
9818 if (MovDelay[ax][ay])
9822 if (IN_LEV_FIELD(ax, ay-1) && IS_FREE(ax, ay-1))
9824 if (IN_LEV_FIELD(ax, ay+1) && IS_FREE(ax, ay+1))
9826 if (IN_LEV_FIELD(ax-1, ay) && IS_FREE(ax-1, ay))
9828 if (IN_LEV_FIELD(ax+1, ay) && IS_FREE(ax+1, ay))
9831 if (element == EL_EXPANDABLE_STEELWALL_VERTICAL ||
9832 element == EL_EXPANDABLE_STEELWALL_ANY)
9836 Tile[ax][ay-1] = EL_EXPANDABLE_STEELWALL_GROWING;
9837 Store[ax][ay-1] = element;
9838 GfxDir[ax][ay-1] = MovDir[ax][ay-1] = MV_UP;
9839 if (IN_SCR_FIELD(SCREENX(ax), SCREENY(ay-1)))
9840 DrawGraphic(SCREENX(ax), SCREENY(ay - 1),
9841 IMG_EXPANDABLE_STEELWALL_GROWING_UP, 0);
9846 Tile[ax][ay+1] = EL_EXPANDABLE_STEELWALL_GROWING;
9847 Store[ax][ay+1] = element;
9848 GfxDir[ax][ay+1] = MovDir[ax][ay+1] = MV_DOWN;
9849 if (IN_SCR_FIELD(SCREENX(ax), SCREENY(ay+1)))
9850 DrawGraphic(SCREENX(ax), SCREENY(ay + 1),
9851 IMG_EXPANDABLE_STEELWALL_GROWING_DOWN, 0);
9856 if (element == EL_EXPANDABLE_STEELWALL_HORIZONTAL ||
9857 element == EL_EXPANDABLE_STEELWALL_ANY)
9861 Tile[ax-1][ay] = EL_EXPANDABLE_STEELWALL_GROWING;
9862 Store[ax-1][ay] = element;
9863 GfxDir[ax-1][ay] = MovDir[ax-1][ay] = MV_LEFT;
9864 if (IN_SCR_FIELD(SCREENX(ax-1), SCREENY(ay)))
9865 DrawGraphic(SCREENX(ax - 1), SCREENY(ay),
9866 IMG_EXPANDABLE_STEELWALL_GROWING_LEFT, 0);
9872 Tile[ax+1][ay] = EL_EXPANDABLE_STEELWALL_GROWING;
9873 Store[ax+1][ay] = element;
9874 GfxDir[ax+1][ay] = MovDir[ax+1][ay] = MV_RIGHT;
9875 if (IN_SCR_FIELD(SCREENX(ax+1), SCREENY(ay)))
9876 DrawGraphic(SCREENX(ax + 1), SCREENY(ay),
9877 IMG_EXPANDABLE_STEELWALL_GROWING_RIGHT, 0);
9882 if (!IN_LEV_FIELD(ax, ay-1) || IS_WALL(Tile[ax][ay-1]))
9884 if (!IN_LEV_FIELD(ax, ay+1) || IS_WALL(Tile[ax][ay+1]))
9885 unten_massiv = TRUE;
9886 if (!IN_LEV_FIELD(ax-1, ay) || IS_WALL(Tile[ax-1][ay]))
9887 links_massiv = TRUE;
9888 if (!IN_LEV_FIELD(ax+1, ay) || IS_WALL(Tile[ax+1][ay]))
9889 rechts_massiv = TRUE;
9891 if (((oben_massiv && unten_massiv) ||
9892 element == EL_EXPANDABLE_STEELWALL_HORIZONTAL) &&
9893 ((links_massiv && rechts_massiv) ||
9894 element == EL_EXPANDABLE_STEELWALL_VERTICAL))
9895 Tile[ax][ay] = EL_STEELWALL;
9898 PlayLevelSoundAction(ax, ay, ACTION_GROWING);
9901 static void CheckForDragon(int x, int y)
9904 boolean dragon_found = FALSE;
9905 static int xy[4][2] =
9913 for (i = 0; i < NUM_DIRECTIONS; i++)
9915 for (j = 0; j < 4; j++)
9917 int xx = x + j * xy[i][0], yy = y + j * xy[i][1];
9919 if (IN_LEV_FIELD(xx, yy) &&
9920 (Tile[xx][yy] == EL_FLAMES || Tile[xx][yy] == EL_DRAGON))
9922 if (Tile[xx][yy] == EL_DRAGON)
9923 dragon_found = TRUE;
9932 for (i = 0; i < NUM_DIRECTIONS; i++)
9934 for (j = 0; j < 3; j++)
9936 int xx = x + j * xy[i][0], yy = y + j * xy[i][1];
9938 if (IN_LEV_FIELD(xx, yy) && Tile[xx][yy] == EL_FLAMES)
9940 Tile[xx][yy] = EL_EMPTY;
9941 TEST_DrawLevelField(xx, yy);
9950 static void InitBuggyBase(int x, int y)
9952 int element = Tile[x][y];
9953 int activating_delay = FRAMES_PER_SECOND / 4;
9956 (element == EL_SP_BUGGY_BASE ?
9957 2 * FRAMES_PER_SECOND + RND(5 * FRAMES_PER_SECOND) - activating_delay :
9958 element == EL_SP_BUGGY_BASE_ACTIVATING ?
9960 element == EL_SP_BUGGY_BASE_ACTIVE ?
9961 1 * FRAMES_PER_SECOND + RND(1 * FRAMES_PER_SECOND) : 1);
9964 static void WarnBuggyBase(int x, int y)
9967 static int xy[4][2] =
9975 for (i = 0; i < NUM_DIRECTIONS; i++)
9977 int xx = x + xy[i][0];
9978 int yy = y + xy[i][1];
9980 if (IN_LEV_FIELD(xx, yy) && IS_PLAYER(xx, yy))
9982 PlayLevelSound(x, y, SND_SP_BUGGY_BASE_ACTIVE);
9989 static void InitTrap(int x, int y)
9991 ChangeDelay[x][y] = 2 * FRAMES_PER_SECOND + RND(5 * FRAMES_PER_SECOND);
9994 static void ActivateTrap(int x, int y)
9996 PlayLevelSound(x, y, SND_TRAP_ACTIVATING);
9999 static void ChangeActiveTrap(int x, int y)
10001 int graphic = IMG_TRAP_ACTIVE;
10003 // if new animation frame was drawn, correct crumbled sand border
10004 if (IS_NEW_FRAME(GfxFrame[x][y], graphic))
10005 TEST_DrawLevelFieldCrumbled(x, y);
10008 static int getSpecialActionElement(int element, int number, int base_element)
10010 return (element != EL_EMPTY ? element :
10011 number != -1 ? base_element + number - 1 :
10015 static int getModifiedActionNumber(int value_old, int operator, int operand,
10016 int value_min, int value_max)
10018 int value_new = (operator == CA_MODE_SET ? operand :
10019 operator == CA_MODE_ADD ? value_old + operand :
10020 operator == CA_MODE_SUBTRACT ? value_old - operand :
10021 operator == CA_MODE_MULTIPLY ? value_old * operand :
10022 operator == CA_MODE_DIVIDE ? value_old / MAX(1, operand) :
10023 operator == CA_MODE_MODULO ? value_old % MAX(1, operand) :
10026 return (value_new < value_min ? value_min :
10027 value_new > value_max ? value_max :
10031 static void ExecuteCustomElementAction(int x, int y, int element, int page)
10033 struct ElementInfo *ei = &element_info[element];
10034 struct ElementChangeInfo *change = &ei->change_page[page];
10035 int target_element = change->target_element;
10036 int action_type = change->action_type;
10037 int action_mode = change->action_mode;
10038 int action_arg = change->action_arg;
10039 int action_element = change->action_element;
10042 if (!change->has_action)
10045 // ---------- determine action paramater values -----------------------------
10047 int level_time_value =
10048 (level.time > 0 ? TimeLeft :
10051 int action_arg_element_raw =
10052 (action_arg == CA_ARG_PLAYER_TRIGGER ? change->actual_trigger_player :
10053 action_arg == CA_ARG_ELEMENT_TRIGGER ? change->actual_trigger_element :
10054 action_arg == CA_ARG_ELEMENT_TARGET ? change->target_element :
10055 action_arg == CA_ARG_ELEMENT_ACTION ? change->action_element :
10056 action_arg == CA_ARG_INVENTORY_RM_TRIGGER ? change->actual_trigger_element:
10057 action_arg == CA_ARG_INVENTORY_RM_TARGET ? change->target_element :
10058 action_arg == CA_ARG_INVENTORY_RM_ACTION ? change->action_element :
10060 int action_arg_element = GetElementFromGroupElement(action_arg_element_raw);
10062 int action_arg_direction =
10063 (action_arg >= CA_ARG_DIRECTION_LEFT &&
10064 action_arg <= CA_ARG_DIRECTION_DOWN ? action_arg - CA_ARG_DIRECTION :
10065 action_arg == CA_ARG_DIRECTION_TRIGGER ?
10066 change->actual_trigger_side :
10067 action_arg == CA_ARG_DIRECTION_TRIGGER_BACK ?
10068 MV_DIR_OPPOSITE(change->actual_trigger_side) :
10071 int action_arg_number_min =
10072 (action_type == CA_SET_PLAYER_SPEED ? STEPSIZE_NOT_MOVING :
10075 int action_arg_number_max =
10076 (action_type == CA_SET_PLAYER_SPEED ? STEPSIZE_EVEN_FASTER :
10077 action_type == CA_SET_LEVEL_GEMS ? 999 :
10078 action_type == CA_SET_LEVEL_TIME ? 9999 :
10079 action_type == CA_SET_LEVEL_SCORE ? 99999 :
10080 action_type == CA_SET_CE_VALUE ? 9999 :
10081 action_type == CA_SET_CE_SCORE ? 9999 :
10084 int action_arg_number_reset =
10085 (action_type == CA_SET_PLAYER_SPEED ? level.initial_player_stepsize[0] :
10086 action_type == CA_SET_LEVEL_GEMS ? level.gems_needed :
10087 action_type == CA_SET_LEVEL_TIME ? level.time :
10088 action_type == CA_SET_LEVEL_SCORE ? 0 :
10089 action_type == CA_SET_CE_VALUE ? GET_NEW_CE_VALUE(element) :
10090 action_type == CA_SET_CE_SCORE ? 0 :
10093 int action_arg_number =
10094 (action_arg <= CA_ARG_MAX ? action_arg :
10095 action_arg >= CA_ARG_SPEED_NOT_MOVING &&
10096 action_arg <= CA_ARG_SPEED_EVEN_FASTER ? (action_arg - CA_ARG_SPEED) :
10097 action_arg == CA_ARG_SPEED_RESET ? action_arg_number_reset :
10098 action_arg == CA_ARG_NUMBER_MIN ? action_arg_number_min :
10099 action_arg == CA_ARG_NUMBER_MAX ? action_arg_number_max :
10100 action_arg == CA_ARG_NUMBER_RESET ? action_arg_number_reset :
10101 action_arg == CA_ARG_NUMBER_CE_VALUE ? CustomValue[x][y] :
10102 action_arg == CA_ARG_NUMBER_CE_SCORE ? ei->collect_score :
10103 action_arg == CA_ARG_NUMBER_CE_DELAY ? GET_CE_DELAY_VALUE(change) :
10104 action_arg == CA_ARG_NUMBER_LEVEL_TIME ? level_time_value :
10105 action_arg == CA_ARG_NUMBER_LEVEL_GEMS ? game.gems_still_needed :
10106 action_arg == CA_ARG_NUMBER_LEVEL_SCORE ? game.score :
10107 action_arg == CA_ARG_ELEMENT_CV_TARGET ? GET_NEW_CE_VALUE(target_element):
10108 action_arg == CA_ARG_ELEMENT_CV_TRIGGER ? change->actual_trigger_ce_value:
10109 action_arg == CA_ARG_ELEMENT_CV_ACTION ? GET_NEW_CE_VALUE(action_element):
10110 action_arg == CA_ARG_ELEMENT_CS_TARGET ? GET_CE_SCORE(target_element) :
10111 action_arg == CA_ARG_ELEMENT_CS_TRIGGER ? change->actual_trigger_ce_score:
10112 action_arg == CA_ARG_ELEMENT_CS_ACTION ? GET_CE_SCORE(action_element) :
10113 action_arg == CA_ARG_ELEMENT_NR_TARGET ? change->target_element :
10114 action_arg == CA_ARG_ELEMENT_NR_TRIGGER ? change->actual_trigger_element :
10115 action_arg == CA_ARG_ELEMENT_NR_ACTION ? change->action_element :
10118 int action_arg_number_old =
10119 (action_type == CA_SET_LEVEL_GEMS ? game.gems_still_needed :
10120 action_type == CA_SET_LEVEL_TIME ? TimeLeft :
10121 action_type == CA_SET_LEVEL_SCORE ? game.score :
10122 action_type == CA_SET_CE_VALUE ? CustomValue[x][y] :
10123 action_type == CA_SET_CE_SCORE ? ei->collect_score :
10126 int action_arg_number_new =
10127 getModifiedActionNumber(action_arg_number_old,
10128 action_mode, action_arg_number,
10129 action_arg_number_min, action_arg_number_max);
10131 int trigger_player_bits =
10132 (change->actual_trigger_player_bits != CH_PLAYER_NONE ?
10133 change->actual_trigger_player_bits : change->trigger_player);
10135 int action_arg_player_bits =
10136 (action_arg >= CA_ARG_PLAYER_1 &&
10137 action_arg <= CA_ARG_PLAYER_4 ? action_arg - CA_ARG_PLAYER :
10138 action_arg == CA_ARG_PLAYER_TRIGGER ? trigger_player_bits :
10139 action_arg == CA_ARG_PLAYER_ACTION ? 1 << GET_PLAYER_NR(action_element) :
10142 // ---------- execute action -----------------------------------------------
10144 switch (action_type)
10151 // ---------- level actions ----------------------------------------------
10153 case CA_RESTART_LEVEL:
10155 game.restart_level = TRUE;
10160 case CA_SHOW_ENVELOPE:
10162 int element = getSpecialActionElement(action_arg_element,
10163 action_arg_number, EL_ENVELOPE_1);
10165 if (IS_ENVELOPE(element))
10166 local_player->show_envelope = element;
10171 case CA_SET_LEVEL_TIME:
10173 if (level.time > 0) // only modify limited time value
10175 TimeLeft = action_arg_number_new;
10177 game_panel_controls[GAME_PANEL_TIME].value = TimeLeft;
10179 DisplayGameControlValues();
10181 if (!TimeLeft && setup.time_limit)
10182 for (i = 0; i < MAX_PLAYERS; i++)
10183 KillPlayer(&stored_player[i]);
10189 case CA_SET_LEVEL_SCORE:
10191 game.score = action_arg_number_new;
10193 game_panel_controls[GAME_PANEL_SCORE].value = game.score;
10195 DisplayGameControlValues();
10200 case CA_SET_LEVEL_GEMS:
10202 game.gems_still_needed = action_arg_number_new;
10204 game.snapshot.collected_item = TRUE;
10206 game_panel_controls[GAME_PANEL_GEMS].value = game.gems_still_needed;
10208 DisplayGameControlValues();
10213 case CA_SET_LEVEL_WIND:
10215 game.wind_direction = action_arg_direction;
10220 case CA_SET_LEVEL_RANDOM_SEED:
10222 // ensure that setting a new random seed while playing is predictable
10223 InitRND(action_arg_number_new ? action_arg_number_new : RND(1000000) + 1);
10228 // ---------- player actions ---------------------------------------------
10230 case CA_MOVE_PLAYER:
10231 case CA_MOVE_PLAYER_NEW:
10233 // automatically move to the next field in specified direction
10234 for (i = 0; i < MAX_PLAYERS; i++)
10235 if (trigger_player_bits & (1 << i))
10236 if (action_type == CA_MOVE_PLAYER ||
10237 stored_player[i].MovPos == 0)
10238 stored_player[i].programmed_action = action_arg_direction;
10243 case CA_EXIT_PLAYER:
10245 for (i = 0; i < MAX_PLAYERS; i++)
10246 if (action_arg_player_bits & (1 << i))
10247 ExitPlayer(&stored_player[i]);
10249 if (game.players_still_needed == 0)
10255 case CA_KILL_PLAYER:
10257 for (i = 0; i < MAX_PLAYERS; i++)
10258 if (action_arg_player_bits & (1 << i))
10259 KillPlayer(&stored_player[i]);
10264 case CA_SET_PLAYER_KEYS:
10266 int key_state = (action_mode == CA_MODE_ADD ? TRUE : FALSE);
10267 int element = getSpecialActionElement(action_arg_element,
10268 action_arg_number, EL_KEY_1);
10270 if (IS_KEY(element))
10272 for (i = 0; i < MAX_PLAYERS; i++)
10274 if (trigger_player_bits & (1 << i))
10276 stored_player[i].key[KEY_NR(element)] = key_state;
10278 DrawGameDoorValues();
10286 case CA_SET_PLAYER_SPEED:
10288 for (i = 0; i < MAX_PLAYERS; i++)
10290 if (trigger_player_bits & (1 << i))
10292 int move_stepsize = TILEX / stored_player[i].move_delay_value;
10294 if (action_arg == CA_ARG_SPEED_FASTER &&
10295 stored_player[i].cannot_move)
10297 action_arg_number = STEPSIZE_VERY_SLOW;
10299 else if (action_arg == CA_ARG_SPEED_SLOWER ||
10300 action_arg == CA_ARG_SPEED_FASTER)
10302 action_arg_number = 2;
10303 action_mode = (action_arg == CA_ARG_SPEED_SLOWER ? CA_MODE_DIVIDE :
10306 else if (action_arg == CA_ARG_NUMBER_RESET)
10308 action_arg_number = level.initial_player_stepsize[i];
10312 getModifiedActionNumber(move_stepsize,
10315 action_arg_number_min,
10316 action_arg_number_max);
10318 SetPlayerMoveSpeed(&stored_player[i], move_stepsize, FALSE);
10325 case CA_SET_PLAYER_SHIELD:
10327 for (i = 0; i < MAX_PLAYERS; i++)
10329 if (trigger_player_bits & (1 << i))
10331 if (action_arg == CA_ARG_SHIELD_OFF)
10333 stored_player[i].shield_normal_time_left = 0;
10334 stored_player[i].shield_deadly_time_left = 0;
10336 else if (action_arg == CA_ARG_SHIELD_NORMAL)
10338 stored_player[i].shield_normal_time_left = 999999;
10340 else if (action_arg == CA_ARG_SHIELD_DEADLY)
10342 stored_player[i].shield_normal_time_left = 999999;
10343 stored_player[i].shield_deadly_time_left = 999999;
10351 case CA_SET_PLAYER_GRAVITY:
10353 for (i = 0; i < MAX_PLAYERS; i++)
10355 if (trigger_player_bits & (1 << i))
10357 stored_player[i].gravity =
10358 (action_arg == CA_ARG_GRAVITY_OFF ? FALSE :
10359 action_arg == CA_ARG_GRAVITY_ON ? TRUE :
10360 action_arg == CA_ARG_GRAVITY_TOGGLE ? !stored_player[i].gravity :
10361 stored_player[i].gravity);
10368 case CA_SET_PLAYER_ARTWORK:
10370 for (i = 0; i < MAX_PLAYERS; i++)
10372 if (trigger_player_bits & (1 << i))
10374 int artwork_element = action_arg_element;
10376 if (action_arg == CA_ARG_ELEMENT_RESET)
10378 (level.use_artwork_element[i] ? level.artwork_element[i] :
10379 stored_player[i].element_nr);
10381 if (stored_player[i].artwork_element != artwork_element)
10382 stored_player[i].Frame = 0;
10384 stored_player[i].artwork_element = artwork_element;
10386 SetPlayerWaiting(&stored_player[i], FALSE);
10388 // set number of special actions for bored and sleeping animation
10389 stored_player[i].num_special_action_bored =
10390 get_num_special_action(artwork_element,
10391 ACTION_BORING_1, ACTION_BORING_LAST);
10392 stored_player[i].num_special_action_sleeping =
10393 get_num_special_action(artwork_element,
10394 ACTION_SLEEPING_1, ACTION_SLEEPING_LAST);
10401 case CA_SET_PLAYER_INVENTORY:
10403 for (i = 0; i < MAX_PLAYERS; i++)
10405 struct PlayerInfo *player = &stored_player[i];
10408 if (trigger_player_bits & (1 << i))
10410 int inventory_element = action_arg_element;
10412 if (action_arg == CA_ARG_ELEMENT_TARGET ||
10413 action_arg == CA_ARG_ELEMENT_TRIGGER ||
10414 action_arg == CA_ARG_ELEMENT_ACTION)
10416 int element = inventory_element;
10417 int collect_count = element_info[element].collect_count_initial;
10419 if (!IS_CUSTOM_ELEMENT(element))
10422 if (collect_count == 0)
10423 player->inventory_infinite_element = element;
10425 for (k = 0; k < collect_count; k++)
10426 if (player->inventory_size < MAX_INVENTORY_SIZE)
10427 player->inventory_element[player->inventory_size++] =
10430 else if (action_arg == CA_ARG_INVENTORY_RM_TARGET ||
10431 action_arg == CA_ARG_INVENTORY_RM_TRIGGER ||
10432 action_arg == CA_ARG_INVENTORY_RM_ACTION)
10434 if (player->inventory_infinite_element != EL_UNDEFINED &&
10435 IS_EQUAL_OR_IN_GROUP(player->inventory_infinite_element,
10436 action_arg_element_raw))
10437 player->inventory_infinite_element = EL_UNDEFINED;
10439 for (k = 0, j = 0; j < player->inventory_size; j++)
10441 if (!IS_EQUAL_OR_IN_GROUP(player->inventory_element[j],
10442 action_arg_element_raw))
10443 player->inventory_element[k++] = player->inventory_element[j];
10446 player->inventory_size = k;
10448 else if (action_arg == CA_ARG_INVENTORY_RM_FIRST)
10450 if (player->inventory_size > 0)
10452 for (j = 0; j < player->inventory_size - 1; j++)
10453 player->inventory_element[j] = player->inventory_element[j + 1];
10455 player->inventory_size--;
10458 else if (action_arg == CA_ARG_INVENTORY_RM_LAST)
10460 if (player->inventory_size > 0)
10461 player->inventory_size--;
10463 else if (action_arg == CA_ARG_INVENTORY_RM_ALL)
10465 player->inventory_infinite_element = EL_UNDEFINED;
10466 player->inventory_size = 0;
10468 else if (action_arg == CA_ARG_INVENTORY_RESET)
10470 player->inventory_infinite_element = EL_UNDEFINED;
10471 player->inventory_size = 0;
10473 if (level.use_initial_inventory[i])
10475 for (j = 0; j < level.initial_inventory_size[i]; j++)
10477 int element = level.initial_inventory_content[i][j];
10478 int collect_count = element_info[element].collect_count_initial;
10480 if (!IS_CUSTOM_ELEMENT(element))
10483 if (collect_count == 0)
10484 player->inventory_infinite_element = element;
10486 for (k = 0; k < collect_count; k++)
10487 if (player->inventory_size < MAX_INVENTORY_SIZE)
10488 player->inventory_element[player->inventory_size++] =
10499 // ---------- CE actions -------------------------------------------------
10501 case CA_SET_CE_VALUE:
10503 int last_ce_value = CustomValue[x][y];
10505 CustomValue[x][y] = action_arg_number_new;
10507 if (CustomValue[x][y] != last_ce_value)
10509 CheckElementChange(x, y, element, EL_UNDEFINED, CE_VALUE_CHANGES);
10510 CheckTriggeredElementChange(x, y, element, CE_VALUE_CHANGES_OF_X);
10512 if (CustomValue[x][y] == 0)
10514 // reset change counter (else CE_VALUE_GETS_ZERO would not work)
10515 ChangeCount[x][y] = 0; // allow at least one more change
10517 CheckElementChange(x, y, element, EL_UNDEFINED, CE_VALUE_GETS_ZERO);
10518 CheckTriggeredElementChange(x, y, element, CE_VALUE_GETS_ZERO_OF_X);
10525 case CA_SET_CE_SCORE:
10527 int last_ce_score = ei->collect_score;
10529 ei->collect_score = action_arg_number_new;
10531 if (ei->collect_score != last_ce_score)
10533 CheckElementChange(x, y, element, EL_UNDEFINED, CE_SCORE_CHANGES);
10534 CheckTriggeredElementChange(x, y, element, CE_SCORE_CHANGES_OF_X);
10536 if (ei->collect_score == 0)
10540 // reset change counter (else CE_SCORE_GETS_ZERO would not work)
10541 ChangeCount[x][y] = 0; // allow at least one more change
10543 CheckElementChange(x, y, element, EL_UNDEFINED, CE_SCORE_GETS_ZERO);
10544 CheckTriggeredElementChange(x, y, element, CE_SCORE_GETS_ZERO_OF_X);
10547 This is a very special case that seems to be a mixture between
10548 CheckElementChange() and CheckTriggeredElementChange(): while
10549 the first one only affects single elements that are triggered
10550 directly, the second one affects multiple elements in the playfield
10551 that are triggered indirectly by another element. This is a third
10552 case: Changing the CE score always affects multiple identical CEs,
10553 so every affected CE must be checked, not only the single CE for
10554 which the CE score was changed in the first place (as every instance
10555 of that CE shares the same CE score, and therefore also can change)!
10557 SCAN_PLAYFIELD(xx, yy)
10559 if (Tile[xx][yy] == element)
10560 CheckElementChange(xx, yy, element, EL_UNDEFINED,
10561 CE_SCORE_GETS_ZERO);
10569 case CA_SET_CE_ARTWORK:
10571 int artwork_element = action_arg_element;
10572 boolean reset_frame = FALSE;
10575 if (action_arg == CA_ARG_ELEMENT_RESET)
10576 artwork_element = (ei->use_gfx_element ? ei->gfx_element_initial :
10579 if (ei->gfx_element != artwork_element)
10580 reset_frame = TRUE;
10582 ei->gfx_element = artwork_element;
10584 SCAN_PLAYFIELD(xx, yy)
10586 if (Tile[xx][yy] == element)
10590 ResetGfxAnimation(xx, yy);
10591 ResetRandomAnimationValue(xx, yy);
10594 TEST_DrawLevelField(xx, yy);
10601 // ---------- engine actions ---------------------------------------------
10603 case CA_SET_ENGINE_SCAN_MODE:
10605 InitPlayfieldScanMode(action_arg);
10615 static void CreateFieldExt(int x, int y, int element, boolean is_change)
10617 int old_element = Tile[x][y];
10618 int new_element = GetElementFromGroupElement(element);
10619 int previous_move_direction = MovDir[x][y];
10620 int last_ce_value = CustomValue[x][y];
10621 boolean player_explosion_protected = PLAYER_EXPLOSION_PROTECTED(x, y);
10622 boolean new_element_is_player = IS_PLAYER_ELEMENT(new_element);
10623 boolean add_player_onto_element = (new_element_is_player &&
10624 new_element != EL_SOKOBAN_FIELD_PLAYER &&
10625 IS_WALKABLE(old_element));
10627 if (!add_player_onto_element)
10629 if (IS_MOVING(x, y) || IS_BLOCKED(x, y))
10630 RemoveMovingField(x, y);
10634 Tile[x][y] = new_element;
10636 if (element_info[new_element].move_direction_initial == MV_START_PREVIOUS)
10637 MovDir[x][y] = previous_move_direction;
10639 if (element_info[new_element].use_last_ce_value)
10640 CustomValue[x][y] = last_ce_value;
10642 InitField_WithBug1(x, y, FALSE);
10644 new_element = Tile[x][y]; // element may have changed
10646 ResetGfxAnimation(x, y);
10647 ResetRandomAnimationValue(x, y);
10649 TEST_DrawLevelField(x, y);
10651 if (GFX_CRUMBLED(new_element))
10652 TEST_DrawLevelFieldCrumbledNeighbours(x, y);
10655 // check if element under the player changes from accessible to unaccessible
10656 // (needed for special case of dropping element which then changes)
10657 // (must be checked after creating new element for walkable group elements)
10658 if (IS_PLAYER(x, y) && !player_explosion_protected &&
10659 IS_ACCESSIBLE(old_element) && !IS_ACCESSIBLE(new_element))
10666 // "ChangeCount" not set yet to allow "entered by player" change one time
10667 if (new_element_is_player)
10668 RelocatePlayer(x, y, new_element);
10671 ChangeCount[x][y]++; // count number of changes in the same frame
10673 TestIfBadThingTouchesPlayer(x, y);
10674 TestIfPlayerTouchesCustomElement(x, y);
10675 TestIfElementTouchesCustomElement(x, y);
10678 static void CreateField(int x, int y, int element)
10680 CreateFieldExt(x, y, element, FALSE);
10683 static void CreateElementFromChange(int x, int y, int element)
10685 element = GET_VALID_RUNTIME_ELEMENT(element);
10687 if (game.engine_version >= VERSION_IDENT(3,2,0,7))
10689 int old_element = Tile[x][y];
10691 // prevent changed element from moving in same engine frame
10692 // unless both old and new element can either fall or move
10693 if ((!CAN_FALL(old_element) || !CAN_FALL(element)) &&
10694 (!CAN_MOVE(old_element) || !CAN_MOVE(element)))
10698 CreateFieldExt(x, y, element, TRUE);
10701 static boolean ChangeElement(int x, int y, int element, int page)
10703 struct ElementInfo *ei = &element_info[element];
10704 struct ElementChangeInfo *change = &ei->change_page[page];
10705 int ce_value = CustomValue[x][y];
10706 int ce_score = ei->collect_score;
10707 int target_element;
10708 int old_element = Tile[x][y];
10710 // always use default change event to prevent running into a loop
10711 if (ChangeEvent[x][y] == -1)
10712 ChangeEvent[x][y] = CE_DELAY;
10714 if (ChangeEvent[x][y] == CE_DELAY)
10716 // reset actual trigger element, trigger player and action element
10717 change->actual_trigger_element = EL_EMPTY;
10718 change->actual_trigger_player = EL_EMPTY;
10719 change->actual_trigger_player_bits = CH_PLAYER_NONE;
10720 change->actual_trigger_side = CH_SIDE_NONE;
10721 change->actual_trigger_ce_value = 0;
10722 change->actual_trigger_ce_score = 0;
10725 // do not change elements more than a specified maximum number of changes
10726 if (ChangeCount[x][y] >= game.max_num_changes_per_frame)
10729 ChangeCount[x][y]++; // count number of changes in the same frame
10731 if (change->explode)
10738 if (change->use_target_content)
10740 boolean complete_replace = TRUE;
10741 boolean can_replace[3][3];
10744 for (yy = 0; yy < 3; yy++) for (xx = 0; xx < 3 ; xx++)
10747 boolean is_walkable;
10748 boolean is_diggable;
10749 boolean is_collectible;
10750 boolean is_removable;
10751 boolean is_destructible;
10752 int ex = x + xx - 1;
10753 int ey = y + yy - 1;
10754 int content_element = change->target_content.e[xx][yy];
10757 can_replace[xx][yy] = TRUE;
10759 if (ex == x && ey == y) // do not check changing element itself
10762 if (content_element == EL_EMPTY_SPACE)
10764 can_replace[xx][yy] = FALSE; // do not replace border with space
10769 if (!IN_LEV_FIELD(ex, ey))
10771 can_replace[xx][yy] = FALSE;
10772 complete_replace = FALSE;
10779 if (IS_MOVING(ex, ey) || IS_BLOCKED(ex, ey))
10780 e = MovingOrBlocked2Element(ex, ey);
10782 is_empty = (IS_FREE(ex, ey) ||
10783 (IS_FREE_OR_PLAYER(ex, ey) && IS_WALKABLE(content_element)));
10785 is_walkable = (is_empty || IS_WALKABLE(e));
10786 is_diggable = (is_empty || IS_DIGGABLE(e));
10787 is_collectible = (is_empty || IS_COLLECTIBLE(e));
10788 is_destructible = (is_empty || !IS_INDESTRUCTIBLE(e));
10789 is_removable = (is_diggable || is_collectible);
10791 can_replace[xx][yy] =
10792 (((change->replace_when == CP_WHEN_EMPTY && is_empty) ||
10793 (change->replace_when == CP_WHEN_WALKABLE && is_walkable) ||
10794 (change->replace_when == CP_WHEN_DIGGABLE && is_diggable) ||
10795 (change->replace_when == CP_WHEN_COLLECTIBLE && is_collectible) ||
10796 (change->replace_when == CP_WHEN_REMOVABLE && is_removable) ||
10797 (change->replace_when == CP_WHEN_DESTRUCTIBLE && is_destructible)) &&
10798 !(IS_PLAYER(ex, ey) && IS_PLAYER_ELEMENT(content_element)));
10800 if (!can_replace[xx][yy])
10801 complete_replace = FALSE;
10804 if (!change->only_if_complete || complete_replace)
10806 boolean something_has_changed = FALSE;
10808 if (change->only_if_complete && change->use_random_replace &&
10809 RND(100) < change->random_percentage)
10812 for (yy = 0; yy < 3; yy++) for (xx = 0; xx < 3 ; xx++)
10814 int ex = x + xx - 1;
10815 int ey = y + yy - 1;
10816 int content_element;
10818 if (can_replace[xx][yy] && (!change->use_random_replace ||
10819 RND(100) < change->random_percentage))
10821 if (IS_MOVING(ex, ey) || IS_BLOCKED(ex, ey))
10822 RemoveMovingField(ex, ey);
10824 ChangeEvent[ex][ey] = ChangeEvent[x][y];
10826 content_element = change->target_content.e[xx][yy];
10827 target_element = GET_TARGET_ELEMENT(element, content_element, change,
10828 ce_value, ce_score);
10830 CreateElementFromChange(ex, ey, target_element);
10832 something_has_changed = TRUE;
10834 // for symmetry reasons, freeze newly created border elements
10835 if (ex != x || ey != y)
10836 Stop[ex][ey] = TRUE; // no more moving in this frame
10840 if (something_has_changed)
10842 PlayLevelSoundElementAction(x, y, element, ACTION_CHANGING);
10843 PlayLevelSoundElementAction(x, y, element, ACTION_PAGE_1 + page);
10849 target_element = GET_TARGET_ELEMENT(element, change->target_element, change,
10850 ce_value, ce_score);
10852 if (element == EL_DIAGONAL_GROWING ||
10853 element == EL_DIAGONAL_SHRINKING)
10855 target_element = Store[x][y];
10857 Store[x][y] = EL_EMPTY;
10860 // special case: element changes to player (and may be kept if walkable)
10861 if (IS_PLAYER_ELEMENT(target_element) && !level.keep_walkable_ce)
10862 CreateElementFromChange(x, y, EL_EMPTY);
10864 CreateElementFromChange(x, y, target_element);
10866 PlayLevelSoundElementAction(x, y, element, ACTION_CHANGING);
10867 PlayLevelSoundElementAction(x, y, element, ACTION_PAGE_1 + page);
10870 // this uses direct change before indirect change
10871 CheckTriggeredElementChangeByPage(x, y, old_element, CE_CHANGE_OF_X, page);
10876 static void HandleElementChange(int x, int y, int page)
10878 int element = MovingOrBlocked2Element(x, y);
10879 struct ElementInfo *ei = &element_info[element];
10880 struct ElementChangeInfo *change = &ei->change_page[page];
10881 boolean handle_action_before_change = FALSE;
10884 if (!CAN_CHANGE_OR_HAS_ACTION(element) &&
10885 !CAN_CHANGE_OR_HAS_ACTION(Back[x][y]))
10887 Debug("game:playing:HandleElementChange", "%d,%d: element = %d ('%s')",
10888 x, y, element, element_info[element].token_name);
10889 Debug("game:playing:HandleElementChange", "This should never happen!");
10893 // this can happen with classic bombs on walkable, changing elements
10894 if (!CAN_CHANGE_OR_HAS_ACTION(element))
10899 if (ChangeDelay[x][y] == 0) // initialize element change
10901 ChangeDelay[x][y] = GET_CHANGE_DELAY(change) + 1;
10903 if (change->can_change)
10905 // !!! not clear why graphic animation should be reset at all here !!!
10906 // !!! UPDATE: but is needed for correct Snake Bite tail animation !!!
10907 // !!! SOLUTION: do not reset if graphics engine set to 4 or above !!!
10910 GRAPHICAL BUG ADDRESSED BY CHECKING GRAPHICS ENGINE VERSION:
10912 When using an animation frame delay of 1 (this only happens with
10913 "sp_zonk.moving.left/right" in the classic graphics), the default
10914 (non-moving) animation shows wrong animation frames (while the
10915 moving animation, like "sp_zonk.moving.left/right", is correct,
10916 so this graphical bug never shows up with the classic graphics).
10917 For an animation with 4 frames, this causes wrong frames 0,0,1,2
10918 be drawn instead of the correct frames 0,1,2,3. This is caused by
10919 "GfxFrame[][]" being reset *twice* (in two successive frames) after
10920 an element change: First when the change delay ("ChangeDelay[][]")
10921 counter has reached zero after decrementing, then a second time in
10922 the next frame (after "GfxFrame[][]" was already incremented) when
10923 "ChangeDelay[][]" is reset to the initial delay value again.
10925 This causes frame 0 to be drawn twice, while the last frame won't
10926 be drawn anymore, resulting in the wrong frame sequence 0,0,1,2.
10928 As some animations may already be cleverly designed around this bug
10929 (at least the "Snake Bite" snake tail animation does this), it cannot
10930 simply be fixed here without breaking such existing animations.
10931 Unfortunately, it cannot easily be detected if a graphics set was
10932 designed "before" or "after" the bug was fixed. As a workaround,
10933 a new graphics set option "game.graphics_engine_version" was added
10934 to be able to specify the game's major release version for which the
10935 graphics set was designed, which can then be used to decide if the
10936 bugfix should be used (version 4 and above) or not (version 3 or
10937 below, or if no version was specified at all, as with old sets).
10939 (The wrong/fixed animation frames can be tested with the test level set
10940 "test_gfxframe" and level "000", which contains a specially prepared
10941 custom element at level position (x/y) == (11/9) which uses the zonk
10942 animation mentioned above. Using "game.graphics_engine_version: 4"
10943 fixes the wrong animation frames, showing the correct frames 0,1,2,3.
10944 This can also be seen from the debug output for this test element.)
10947 // when a custom element is about to change (for example by change delay),
10948 // do not reset graphic animation when the custom element is moving
10949 if (game.graphics_engine_version < 4 &&
10952 ResetGfxAnimation(x, y);
10953 ResetRandomAnimationValue(x, y);
10956 if (change->pre_change_function)
10957 change->pre_change_function(x, y);
10961 ChangeDelay[x][y]--;
10963 if (ChangeDelay[x][y] != 0) // continue element change
10965 if (change->can_change)
10967 int graphic = el_act_dir2img(element, GfxAction[x][y], GfxDir[x][y]);
10969 if (IS_ANIMATED(graphic))
10970 DrawLevelGraphicAnimationIfNeeded(x, y, graphic);
10972 if (change->change_function)
10973 change->change_function(x, y);
10976 else // finish element change
10978 if (ChangePage[x][y] != -1) // remember page from delayed change
10980 page = ChangePage[x][y];
10981 ChangePage[x][y] = -1;
10983 change = &ei->change_page[page];
10986 if (IS_MOVING(x, y)) // never change a running system ;-)
10988 ChangeDelay[x][y] = 1; // try change after next move step
10989 ChangePage[x][y] = page; // remember page to use for change
10994 // special case: set new level random seed before changing element
10995 if (change->has_action && change->action_type == CA_SET_LEVEL_RANDOM_SEED)
10996 handle_action_before_change = TRUE;
10998 if (change->has_action && handle_action_before_change)
10999 ExecuteCustomElementAction(x, y, element, page);
11001 if (change->can_change)
11003 if (ChangeElement(x, y, element, page))
11005 if (change->post_change_function)
11006 change->post_change_function(x, y);
11010 if (change->has_action && !handle_action_before_change)
11011 ExecuteCustomElementAction(x, y, element, page);
11015 static boolean CheckTriggeredElementChangeExt(int trigger_x, int trigger_y,
11016 int trigger_element,
11018 int trigger_player,
11022 boolean change_done_any = FALSE;
11023 int trigger_page_bits = (trigger_page < 0 ? CH_PAGE_ANY : 1 << trigger_page);
11026 if (!(trigger_events[trigger_element][trigger_event]))
11029 RECURSION_LOOP_DETECTION_START(trigger_element, FALSE);
11031 for (i = 0; i < NUM_CUSTOM_ELEMENTS; i++)
11033 int element = EL_CUSTOM_START + i;
11034 boolean change_done = FALSE;
11037 if (!CAN_CHANGE_OR_HAS_ACTION(element) ||
11038 !HAS_ANY_CHANGE_EVENT(element, trigger_event))
11041 for (p = 0; p < element_info[element].num_change_pages; p++)
11043 struct ElementChangeInfo *change = &element_info[element].change_page[p];
11045 if (change->can_change_or_has_action &&
11046 change->has_event[trigger_event] &&
11047 change->trigger_side & trigger_side &&
11048 change->trigger_player & trigger_player &&
11049 change->trigger_page & trigger_page_bits &&
11050 IS_EQUAL_OR_IN_GROUP(trigger_element, change->trigger_element))
11052 change->actual_trigger_element = trigger_element;
11053 change->actual_trigger_player = GET_PLAYER_FROM_BITS(trigger_player);
11054 change->actual_trigger_player_bits = trigger_player;
11055 change->actual_trigger_side = trigger_side;
11056 change->actual_trigger_ce_value = CustomValue[trigger_x][trigger_y];
11057 change->actual_trigger_ce_score = GET_CE_SCORE(trigger_element);
11059 if ((change->can_change && !change_done) || change->has_action)
11063 SCAN_PLAYFIELD(x, y)
11065 if (Tile[x][y] == element)
11067 if (change->can_change && !change_done)
11069 // if element already changed in this frame, not only prevent
11070 // another element change (checked in ChangeElement()), but
11071 // also prevent additional element actions for this element
11073 if (ChangeCount[x][y] >= game.max_num_changes_per_frame &&
11074 !level.use_action_after_change_bug)
11077 ChangeDelay[x][y] = 1;
11078 ChangeEvent[x][y] = trigger_event;
11080 HandleElementChange(x, y, p);
11082 else if (change->has_action)
11084 // if element already changed in this frame, not only prevent
11085 // another element change (checked in ChangeElement()), but
11086 // also prevent additional element actions for this element
11088 if (ChangeCount[x][y] >= game.max_num_changes_per_frame &&
11089 !level.use_action_after_change_bug)
11092 ExecuteCustomElementAction(x, y, element, p);
11093 PlayLevelSoundElementAction(x, y, element, ACTION_PAGE_1 + p);
11098 if (change->can_change)
11100 change_done = TRUE;
11101 change_done_any = TRUE;
11108 RECURSION_LOOP_DETECTION_END();
11110 return change_done_any;
11113 static boolean CheckElementChangeExt(int x, int y,
11115 int trigger_element,
11117 int trigger_player,
11120 boolean change_done = FALSE;
11123 if (!CAN_CHANGE_OR_HAS_ACTION(element) ||
11124 !HAS_ANY_CHANGE_EVENT(element, trigger_event))
11127 if (Tile[x][y] == EL_BLOCKED)
11129 Blocked2Moving(x, y, &x, &y);
11130 element = Tile[x][y];
11133 // check if element has already changed or is about to change after moving
11134 if ((game.engine_version < VERSION_IDENT(3,2,0,7) &&
11135 Tile[x][y] != element) ||
11137 (game.engine_version >= VERSION_IDENT(3,2,0,7) &&
11138 (ChangeCount[x][y] >= game.max_num_changes_per_frame ||
11139 ChangePage[x][y] != -1)))
11142 RECURSION_LOOP_DETECTION_START(trigger_element, FALSE);
11144 for (p = 0; p < element_info[element].num_change_pages; p++)
11146 struct ElementChangeInfo *change = &element_info[element].change_page[p];
11148 /* check trigger element for all events where the element that is checked
11149 for changing interacts with a directly adjacent element -- this is
11150 different to element changes that affect other elements to change on the
11151 whole playfield (which is handeld by CheckTriggeredElementChangeExt()) */
11152 boolean check_trigger_element =
11153 (trigger_event == CE_TOUCHING_X ||
11154 trigger_event == CE_HITTING_X ||
11155 trigger_event == CE_HIT_BY_X ||
11156 trigger_event == CE_DIGGING_X); // this one was forgotten until 3.2.3
11158 if (change->can_change_or_has_action &&
11159 change->has_event[trigger_event] &&
11160 change->trigger_side & trigger_side &&
11161 change->trigger_player & trigger_player &&
11162 (!check_trigger_element ||
11163 IS_EQUAL_OR_IN_GROUP(trigger_element, change->trigger_element)))
11165 change->actual_trigger_element = trigger_element;
11166 change->actual_trigger_player = GET_PLAYER_FROM_BITS(trigger_player);
11167 change->actual_trigger_player_bits = trigger_player;
11168 change->actual_trigger_side = trigger_side;
11169 change->actual_trigger_ce_value = CustomValue[x][y];
11170 change->actual_trigger_ce_score = GET_CE_SCORE(trigger_element);
11172 // special case: trigger element not at (x,y) position for some events
11173 if (check_trigger_element)
11185 { 0, 0 }, { 0, 0 }, { 0, 0 },
11189 int xx = x + move_xy[MV_DIR_OPPOSITE(trigger_side)].dx;
11190 int yy = y + move_xy[MV_DIR_OPPOSITE(trigger_side)].dy;
11192 change->actual_trigger_ce_value = CustomValue[xx][yy];
11193 change->actual_trigger_ce_score = GET_CE_SCORE(trigger_element);
11196 if (change->can_change && !change_done)
11198 ChangeDelay[x][y] = 1;
11199 ChangeEvent[x][y] = trigger_event;
11201 HandleElementChange(x, y, p);
11203 change_done = TRUE;
11205 else if (change->has_action)
11207 ExecuteCustomElementAction(x, y, element, p);
11208 PlayLevelSoundElementAction(x, y, element, ACTION_PAGE_1 + p);
11213 RECURSION_LOOP_DETECTION_END();
11215 return change_done;
11218 static void PlayPlayerSound(struct PlayerInfo *player)
11220 int jx = player->jx, jy = player->jy;
11221 int sound_element = player->artwork_element;
11222 int last_action = player->last_action_waiting;
11223 int action = player->action_waiting;
11225 if (player->is_waiting)
11227 if (action != last_action)
11228 PlayLevelSoundElementAction(jx, jy, sound_element, action);
11230 PlayLevelSoundElementActionIfLoop(jx, jy, sound_element, action);
11234 if (action != last_action)
11235 StopSound(element_info[sound_element].sound[last_action]);
11237 if (last_action == ACTION_SLEEPING)
11238 PlayLevelSoundElementAction(jx, jy, sound_element, ACTION_AWAKENING);
11242 static void PlayAllPlayersSound(void)
11246 for (i = 0; i < MAX_PLAYERS; i++)
11247 if (stored_player[i].active)
11248 PlayPlayerSound(&stored_player[i]);
11251 static void SetPlayerWaiting(struct PlayerInfo *player, boolean is_waiting)
11253 boolean last_waiting = player->is_waiting;
11254 int move_dir = player->MovDir;
11256 player->dir_waiting = move_dir;
11257 player->last_action_waiting = player->action_waiting;
11261 if (!last_waiting) // not waiting -> waiting
11263 player->is_waiting = TRUE;
11265 player->frame_counter_bored =
11267 game.player_boring_delay_fixed +
11268 GetSimpleRandom(game.player_boring_delay_random);
11269 player->frame_counter_sleeping =
11271 game.player_sleeping_delay_fixed +
11272 GetSimpleRandom(game.player_sleeping_delay_random);
11274 InitPlayerGfxAnimation(player, ACTION_WAITING, move_dir);
11277 if (game.player_sleeping_delay_fixed +
11278 game.player_sleeping_delay_random > 0 &&
11279 player->anim_delay_counter == 0 &&
11280 player->post_delay_counter == 0 &&
11281 FrameCounter >= player->frame_counter_sleeping)
11282 player->is_sleeping = TRUE;
11283 else if (game.player_boring_delay_fixed +
11284 game.player_boring_delay_random > 0 &&
11285 FrameCounter >= player->frame_counter_bored)
11286 player->is_bored = TRUE;
11288 player->action_waiting = (player->is_sleeping ? ACTION_SLEEPING :
11289 player->is_bored ? ACTION_BORING :
11292 if (player->is_sleeping && player->use_murphy)
11294 // special case for sleeping Murphy when leaning against non-free tile
11296 if (!IN_LEV_FIELD(player->jx - 1, player->jy) ||
11297 (Tile[player->jx - 1][player->jy] != EL_EMPTY &&
11298 !IS_MOVING(player->jx - 1, player->jy)))
11299 move_dir = MV_LEFT;
11300 else if (!IN_LEV_FIELD(player->jx + 1, player->jy) ||
11301 (Tile[player->jx + 1][player->jy] != EL_EMPTY &&
11302 !IS_MOVING(player->jx + 1, player->jy)))
11303 move_dir = MV_RIGHT;
11305 player->is_sleeping = FALSE;
11307 player->dir_waiting = move_dir;
11310 if (player->is_sleeping)
11312 if (player->num_special_action_sleeping > 0)
11314 if (player->anim_delay_counter == 0 && player->post_delay_counter == 0)
11316 int last_special_action = player->special_action_sleeping;
11317 int num_special_action = player->num_special_action_sleeping;
11318 int special_action =
11319 (last_special_action == ACTION_DEFAULT ? ACTION_SLEEPING_1 :
11320 last_special_action == ACTION_SLEEPING ? ACTION_SLEEPING :
11321 last_special_action < ACTION_SLEEPING_1 + num_special_action - 1 ?
11322 last_special_action + 1 : ACTION_SLEEPING);
11323 int special_graphic =
11324 el_act_dir2img(player->artwork_element, special_action, move_dir);
11326 player->anim_delay_counter =
11327 graphic_info[special_graphic].anim_delay_fixed +
11328 GetSimpleRandom(graphic_info[special_graphic].anim_delay_random);
11329 player->post_delay_counter =
11330 graphic_info[special_graphic].post_delay_fixed +
11331 GetSimpleRandom(graphic_info[special_graphic].post_delay_random);
11333 player->special_action_sleeping = special_action;
11336 if (player->anim_delay_counter > 0)
11338 player->action_waiting = player->special_action_sleeping;
11339 player->anim_delay_counter--;
11341 else if (player->post_delay_counter > 0)
11343 player->post_delay_counter--;
11347 else if (player->is_bored)
11349 if (player->num_special_action_bored > 0)
11351 if (player->anim_delay_counter == 0 && player->post_delay_counter == 0)
11353 int special_action =
11354 ACTION_BORING_1 + GetSimpleRandom(player->num_special_action_bored);
11355 int special_graphic =
11356 el_act_dir2img(player->artwork_element, special_action, move_dir);
11358 player->anim_delay_counter =
11359 graphic_info[special_graphic].anim_delay_fixed +
11360 GetSimpleRandom(graphic_info[special_graphic].anim_delay_random);
11361 player->post_delay_counter =
11362 graphic_info[special_graphic].post_delay_fixed +
11363 GetSimpleRandom(graphic_info[special_graphic].post_delay_random);
11365 player->special_action_bored = special_action;
11368 if (player->anim_delay_counter > 0)
11370 player->action_waiting = player->special_action_bored;
11371 player->anim_delay_counter--;
11373 else if (player->post_delay_counter > 0)
11375 player->post_delay_counter--;
11380 else if (last_waiting) // waiting -> not waiting
11382 player->is_waiting = FALSE;
11383 player->is_bored = FALSE;
11384 player->is_sleeping = FALSE;
11386 player->frame_counter_bored = -1;
11387 player->frame_counter_sleeping = -1;
11389 player->anim_delay_counter = 0;
11390 player->post_delay_counter = 0;
11392 player->dir_waiting = player->MovDir;
11393 player->action_waiting = ACTION_DEFAULT;
11395 player->special_action_bored = ACTION_DEFAULT;
11396 player->special_action_sleeping = ACTION_DEFAULT;
11400 static void CheckSaveEngineSnapshot(struct PlayerInfo *player)
11402 if ((!player->is_moving && player->was_moving) ||
11403 (player->MovPos == 0 && player->was_moving) ||
11404 (player->is_snapping && !player->was_snapping) ||
11405 (player->is_dropping && !player->was_dropping))
11407 if (!CheckSaveEngineSnapshotToList())
11410 player->was_moving = FALSE;
11411 player->was_snapping = TRUE;
11412 player->was_dropping = TRUE;
11416 if (player->is_moving)
11417 player->was_moving = TRUE;
11419 if (!player->is_snapping)
11420 player->was_snapping = FALSE;
11422 if (!player->is_dropping)
11423 player->was_dropping = FALSE;
11426 static struct MouseActionInfo mouse_action_last = { 0 };
11427 struct MouseActionInfo mouse_action = player->effective_mouse_action;
11428 boolean new_released = (!mouse_action.button && mouse_action_last.button);
11431 CheckSaveEngineSnapshotToList();
11433 mouse_action_last = mouse_action;
11436 static void CheckSingleStepMode(struct PlayerInfo *player)
11438 if (tape.single_step && tape.recording && !tape.pausing)
11440 // as it is called "single step mode", just return to pause mode when the
11441 // player stopped moving after one tile (or never starts moving at all)
11442 // (reverse logic needed here in case single step mode used in team mode)
11443 if (player->is_moving ||
11444 player->is_pushing ||
11445 player->is_dropping_pressed ||
11446 player->effective_mouse_action.button)
11447 game.enter_single_step_mode = FALSE;
11450 CheckSaveEngineSnapshot(player);
11453 static byte PlayerActions(struct PlayerInfo *player, byte player_action)
11455 int left = player_action & JOY_LEFT;
11456 int right = player_action & JOY_RIGHT;
11457 int up = player_action & JOY_UP;
11458 int down = player_action & JOY_DOWN;
11459 int button1 = player_action & JOY_BUTTON_1;
11460 int button2 = player_action & JOY_BUTTON_2;
11461 int dx = (left ? -1 : right ? 1 : 0);
11462 int dy = (up ? -1 : down ? 1 : 0);
11464 if (!player->active || tape.pausing)
11470 SnapField(player, dx, dy);
11474 DropElement(player);
11476 MovePlayer(player, dx, dy);
11479 CheckSingleStepMode(player);
11481 SetPlayerWaiting(player, FALSE);
11483 return player_action;
11487 // no actions for this player (no input at player's configured device)
11489 DigField(player, 0, 0, 0, 0, 0, 0, DF_NO_PUSH);
11490 SnapField(player, 0, 0);
11491 CheckGravityMovementWhenNotMoving(player);
11493 if (player->MovPos == 0)
11494 SetPlayerWaiting(player, TRUE);
11496 if (player->MovPos == 0) // needed for tape.playing
11497 player->is_moving = FALSE;
11499 player->is_dropping = FALSE;
11500 player->is_dropping_pressed = FALSE;
11501 player->drop_pressed_delay = 0;
11503 CheckSingleStepMode(player);
11509 static void SetMouseActionFromTapeAction(struct MouseActionInfo *mouse_action,
11512 if (!tape.use_mouse_actions)
11515 mouse_action->lx = tape_action[TAPE_ACTION_LX];
11516 mouse_action->ly = tape_action[TAPE_ACTION_LY];
11517 mouse_action->button = tape_action[TAPE_ACTION_BUTTON];
11520 static void SetTapeActionFromMouseAction(byte *tape_action,
11521 struct MouseActionInfo *mouse_action)
11523 if (!tape.use_mouse_actions)
11526 tape_action[TAPE_ACTION_LX] = mouse_action->lx;
11527 tape_action[TAPE_ACTION_LY] = mouse_action->ly;
11528 tape_action[TAPE_ACTION_BUTTON] = mouse_action->button;
11531 static void CheckLevelSolved(void)
11533 if (level.game_engine_type == GAME_ENGINE_TYPE_EM)
11535 if (game_em.level_solved &&
11536 !game_em.game_over) // game won
11540 game_em.game_over = TRUE;
11542 game.all_players_gone = TRUE;
11545 if (game_em.game_over) // game lost
11546 game.all_players_gone = TRUE;
11548 else if (level.game_engine_type == GAME_ENGINE_TYPE_SP)
11550 if (game_sp.level_solved &&
11551 !game_sp.game_over) // game won
11555 game_sp.game_over = TRUE;
11557 game.all_players_gone = TRUE;
11560 if (game_sp.game_over) // game lost
11561 game.all_players_gone = TRUE;
11563 else if (level.game_engine_type == GAME_ENGINE_TYPE_MM)
11565 if (game_mm.level_solved &&
11566 !game_mm.game_over) // game won
11570 game_mm.game_over = TRUE;
11572 game.all_players_gone = TRUE;
11575 if (game_mm.game_over) // game lost
11576 game.all_players_gone = TRUE;
11580 static void CheckLevelTime(void)
11584 if (TimeFrames >= FRAMES_PER_SECOND)
11589 for (i = 0; i < MAX_PLAYERS; i++)
11591 struct PlayerInfo *player = &stored_player[i];
11593 if (SHIELD_ON(player))
11595 player->shield_normal_time_left--;
11597 if (player->shield_deadly_time_left > 0)
11598 player->shield_deadly_time_left--;
11602 if (!game.LevelSolved && !level.use_step_counter)
11610 if (TimeLeft <= 10 && setup.time_limit)
11611 PlaySound(SND_GAME_RUNNING_OUT_OF_TIME);
11613 /* this does not make sense: game_panel_controls[GAME_PANEL_TIME].value
11614 is reset from other values in UpdateGameDoorValues() -- FIX THIS */
11616 game_panel_controls[GAME_PANEL_TIME].value = TimeLeft;
11618 if (!TimeLeft && setup.time_limit)
11620 if (level.game_engine_type == GAME_ENGINE_TYPE_EM)
11621 game_em.lev->killed_out_of_time = TRUE;
11623 for (i = 0; i < MAX_PLAYERS; i++)
11624 KillPlayer(&stored_player[i]);
11627 else if (game.no_time_limit && !game.all_players_gone)
11629 game_panel_controls[GAME_PANEL_TIME].value = TimePlayed;
11632 game_em.lev->time = (game.no_time_limit ? TimePlayed : TimeLeft);
11635 if (tape.recording || tape.playing)
11636 DrawVideoDisplay(VIDEO_STATE_TIME_ON, TapeTime);
11639 if (tape.recording || tape.playing)
11640 DrawVideoDisplay(VIDEO_STATE_FRAME_ON, FrameCounter);
11642 UpdateAndDisplayGameControlValues();
11645 void AdvanceFrameAndPlayerCounters(int player_nr)
11649 // advance frame counters (global frame counter and time frame counter)
11653 // advance player counters (counters for move delay, move animation etc.)
11654 for (i = 0; i < MAX_PLAYERS; i++)
11656 boolean advance_player_counters = (player_nr == -1 || player_nr == i);
11657 int move_delay_value = stored_player[i].move_delay_value;
11658 int move_frames = MOVE_DELAY_NORMAL_SPEED / move_delay_value;
11660 if (!advance_player_counters) // not all players may be affected
11663 if (move_frames == 0) // less than one move per game frame
11665 int stepsize = TILEX / move_delay_value;
11666 int delay = move_delay_value / MOVE_DELAY_NORMAL_SPEED;
11667 int count = (stored_player[i].is_moving ?
11668 ABS(stored_player[i].MovPos) / stepsize : FrameCounter);
11670 if (count % delay == 0)
11674 stored_player[i].Frame += move_frames;
11676 if (stored_player[i].MovPos != 0)
11677 stored_player[i].StepFrame += move_frames;
11679 if (stored_player[i].move_delay > 0)
11680 stored_player[i].move_delay--;
11682 // due to bugs in previous versions, counter must count up, not down
11683 if (stored_player[i].push_delay != -1)
11684 stored_player[i].push_delay++;
11686 if (stored_player[i].drop_delay > 0)
11687 stored_player[i].drop_delay--;
11689 if (stored_player[i].is_dropping_pressed)
11690 stored_player[i].drop_pressed_delay++;
11694 void StartGameActions(boolean init_network_game, boolean record_tape,
11697 unsigned int new_random_seed = InitRND(random_seed);
11700 TapeStartRecording(new_random_seed);
11702 if (init_network_game)
11704 SendToServer_LevelFile();
11705 SendToServer_StartPlaying();
11713 static void GameActionsExt(void)
11716 static unsigned int game_frame_delay = 0;
11718 unsigned int game_frame_delay_value;
11719 byte *recorded_player_action;
11720 byte summarized_player_action = 0;
11721 byte tape_action[MAX_TAPE_ACTIONS] = { 0 };
11724 // detect endless loops, caused by custom element programming
11725 if (recursion_loop_detected && recursion_loop_depth == 0)
11727 char *message = getStringCat3("Internal Error! Element ",
11728 EL_NAME(recursion_loop_element),
11729 " caused endless loop! Quit the game?");
11731 Warn("element '%s' caused endless loop in game engine",
11732 EL_NAME(recursion_loop_element));
11734 RequestQuitGameExt(program.headless, level_editor_test_game, message);
11736 recursion_loop_detected = FALSE; // if game should be continued
11743 if (game.restart_level)
11744 StartGameActions(network.enabled, setup.autorecord, level.random_seed);
11746 CheckLevelSolved();
11748 if (game.LevelSolved && !game.LevelSolved_GameEnd)
11751 if (game.all_players_gone && !TAPE_IS_STOPPED(tape))
11754 if (game_status != GAME_MODE_PLAYING) // status might have changed
11757 game_frame_delay_value =
11758 (tape.playing && tape.fast_forward ? FfwdFrameDelay : GameFrameDelay);
11760 if (tape.playing && tape.warp_forward && !tape.pausing)
11761 game_frame_delay_value = 0;
11763 SetVideoFrameDelay(game_frame_delay_value);
11765 // (de)activate virtual buttons depending on current game status
11766 if (strEqual(setup.touch.control_type, TOUCH_CONTROL_VIRTUAL_BUTTONS))
11768 if (game.all_players_gone) // if no players there to be controlled anymore
11769 SetOverlayActive(FALSE);
11770 else if (!tape.playing) // if game continues after tape stopped playing
11771 SetOverlayActive(TRUE);
11776 // ---------- main game synchronization point ----------
11778 int skip = WaitUntilDelayReached(&game_frame_delay, game_frame_delay_value);
11780 Debug("game:playing:skip", "skip == %d", skip);
11783 // ---------- main game synchronization point ----------
11785 WaitUntilDelayReached(&game_frame_delay, game_frame_delay_value);
11789 if (network_playing && !network_player_action_received)
11791 // try to get network player actions in time
11793 // last chance to get network player actions without main loop delay
11794 HandleNetworking();
11796 // game was quit by network peer
11797 if (game_status != GAME_MODE_PLAYING)
11800 // check if network player actions still missing and game still running
11801 if (!network_player_action_received && !checkGameEnded())
11802 return; // failed to get network player actions in time
11804 // do not yet reset "network_player_action_received" (for tape.pausing)
11810 // at this point we know that we really continue executing the game
11812 network_player_action_received = FALSE;
11814 // when playing tape, read previously recorded player input from tape data
11815 recorded_player_action = (tape.playing ? TapePlayAction() : NULL);
11817 local_player->effective_mouse_action = local_player->mouse_action;
11819 if (recorded_player_action != NULL)
11820 SetMouseActionFromTapeAction(&local_player->effective_mouse_action,
11821 recorded_player_action);
11823 // TapePlayAction() may return NULL when toggling to "pause before death"
11827 if (tape.set_centered_player)
11829 game.centered_player_nr_next = tape.centered_player_nr_next;
11830 game.set_centered_player = TRUE;
11833 for (i = 0; i < MAX_PLAYERS; i++)
11835 summarized_player_action |= stored_player[i].action;
11837 if (!network_playing && (game.team_mode || tape.playing))
11838 stored_player[i].effective_action = stored_player[i].action;
11841 if (network_playing && !checkGameEnded())
11842 SendToServer_MovePlayer(summarized_player_action);
11844 // summarize all actions at local players mapped input device position
11845 // (this allows using different input devices in single player mode)
11846 if (!network.enabled && !game.team_mode)
11847 stored_player[map_player_action[local_player->index_nr]].effective_action =
11848 summarized_player_action;
11850 // summarize all actions at centered player in local team mode
11851 if (tape.recording &&
11852 setup.team_mode && !network.enabled &&
11853 setup.input_on_focus &&
11854 game.centered_player_nr != -1)
11856 for (i = 0; i < MAX_PLAYERS; i++)
11857 stored_player[map_player_action[i]].effective_action =
11858 (i == game.centered_player_nr ? summarized_player_action : 0);
11861 if (recorded_player_action != NULL)
11862 for (i = 0; i < MAX_PLAYERS; i++)
11863 stored_player[i].effective_action = recorded_player_action[i];
11865 for (i = 0; i < MAX_PLAYERS; i++)
11867 tape_action[i] = stored_player[i].effective_action;
11869 /* (this may happen in the RND game engine if a player was not present on
11870 the playfield on level start, but appeared later from a custom element */
11871 if (setup.team_mode &&
11874 !tape.player_participates[i])
11875 tape.player_participates[i] = TRUE;
11878 SetTapeActionFromMouseAction(tape_action,
11879 &local_player->effective_mouse_action);
11881 // only record actions from input devices, but not programmed actions
11882 if (tape.recording)
11883 TapeRecordAction(tape_action);
11885 // remember if game was played (especially after tape stopped playing)
11886 if (!tape.playing && summarized_player_action)
11887 game.GamePlayed = TRUE;
11889 #if USE_NEW_PLAYER_ASSIGNMENTS
11890 // !!! also map player actions in single player mode !!!
11891 // if (game.team_mode)
11894 byte mapped_action[MAX_PLAYERS];
11896 #if DEBUG_PLAYER_ACTIONS
11897 for (i = 0; i < MAX_PLAYERS; i++)
11898 DebugContinued("", "%d, ", stored_player[i].effective_action);
11901 for (i = 0; i < MAX_PLAYERS; i++)
11902 mapped_action[i] = stored_player[map_player_action[i]].effective_action;
11904 for (i = 0; i < MAX_PLAYERS; i++)
11905 stored_player[i].effective_action = mapped_action[i];
11907 #if DEBUG_PLAYER_ACTIONS
11908 DebugContinued("", "=> ");
11909 for (i = 0; i < MAX_PLAYERS; i++)
11910 DebugContinued("", "%d, ", stored_player[i].effective_action);
11911 DebugContinued("game:playing:player", "\n");
11914 #if DEBUG_PLAYER_ACTIONS
11917 for (i = 0; i < MAX_PLAYERS; i++)
11918 DebugContinued("", "%d, ", stored_player[i].effective_action);
11919 DebugContinued("game:playing:player", "\n");
11924 for (i = 0; i < MAX_PLAYERS; i++)
11926 // allow engine snapshot in case of changed movement attempt
11927 if ((game.snapshot.last_action[i] & KEY_MOTION) !=
11928 (stored_player[i].effective_action & KEY_MOTION))
11929 game.snapshot.changed_action = TRUE;
11931 // allow engine snapshot in case of snapping/dropping attempt
11932 if ((game.snapshot.last_action[i] & KEY_BUTTON) == 0 &&
11933 (stored_player[i].effective_action & KEY_BUTTON) != 0)
11934 game.snapshot.changed_action = TRUE;
11936 game.snapshot.last_action[i] = stored_player[i].effective_action;
11939 if (level.game_engine_type == GAME_ENGINE_TYPE_EM)
11941 GameActions_EM_Main();
11943 else if (level.game_engine_type == GAME_ENGINE_TYPE_SP)
11945 GameActions_SP_Main();
11947 else if (level.game_engine_type == GAME_ENGINE_TYPE_MM)
11949 GameActions_MM_Main();
11953 GameActions_RND_Main();
11956 BlitScreenToBitmap(backbuffer);
11958 CheckLevelSolved();
11961 AdvanceFrameAndPlayerCounters(-1); // advance counters for all players
11963 if (global.show_frames_per_second)
11965 static unsigned int fps_counter = 0;
11966 static int fps_frames = 0;
11967 unsigned int fps_delay_ms = Counter() - fps_counter;
11971 if (fps_delay_ms >= 500) // calculate FPS every 0.5 seconds
11973 global.frames_per_second = 1000 * (float)fps_frames / fps_delay_ms;
11976 fps_counter = Counter();
11978 // always draw FPS to screen after FPS value was updated
11979 redraw_mask |= REDRAW_FPS;
11982 // only draw FPS if no screen areas are deactivated (invisible warp mode)
11983 if (GetDrawDeactivationMask() == REDRAW_NONE)
11984 redraw_mask |= REDRAW_FPS;
11988 static void GameActions_CheckSaveEngineSnapshot(void)
11990 if (!game.snapshot.save_snapshot)
11993 // clear flag for saving snapshot _before_ saving snapshot
11994 game.snapshot.save_snapshot = FALSE;
11996 SaveEngineSnapshotToList();
11999 void GameActions(void)
12003 GameActions_CheckSaveEngineSnapshot();
12006 void GameActions_EM_Main(void)
12008 byte effective_action[MAX_PLAYERS];
12009 boolean warp_mode = (tape.playing && tape.warp_forward && !tape.pausing);
12012 for (i = 0; i < MAX_PLAYERS; i++)
12013 effective_action[i] = stored_player[i].effective_action;
12015 GameActions_EM(effective_action, warp_mode);
12018 void GameActions_SP_Main(void)
12020 byte effective_action[MAX_PLAYERS];
12021 boolean warp_mode = (tape.playing && tape.warp_forward && !tape.pausing);
12024 for (i = 0; i < MAX_PLAYERS; i++)
12025 effective_action[i] = stored_player[i].effective_action;
12027 GameActions_SP(effective_action, warp_mode);
12029 for (i = 0; i < MAX_PLAYERS; i++)
12031 if (stored_player[i].force_dropping)
12032 stored_player[i].action |= KEY_BUTTON_DROP;
12034 stored_player[i].force_dropping = FALSE;
12038 void GameActions_MM_Main(void)
12040 boolean warp_mode = (tape.playing && tape.warp_forward && !tape.pausing);
12042 GameActions_MM(local_player->effective_mouse_action, warp_mode);
12045 void GameActions_RND_Main(void)
12050 void GameActions_RND(void)
12052 static struct MouseActionInfo mouse_action_last = { 0 };
12053 struct MouseActionInfo mouse_action = local_player->effective_mouse_action;
12054 int magic_wall_x = 0, magic_wall_y = 0;
12055 int i, x, y, element, graphic, last_gfx_frame;
12057 InitPlayfieldScanModeVars();
12059 if (game.engine_version >= VERSION_IDENT(3,2,0,7))
12061 SCAN_PLAYFIELD(x, y)
12063 ChangeCount[x][y] = 0;
12064 ChangeEvent[x][y] = -1;
12068 if (game.set_centered_player)
12070 boolean all_players_fit_to_screen = checkIfAllPlayersFitToScreen_RND();
12072 // switching to "all players" only possible if all players fit to screen
12073 if (game.centered_player_nr_next == -1 && !all_players_fit_to_screen)
12075 game.centered_player_nr_next = game.centered_player_nr;
12076 game.set_centered_player = FALSE;
12079 // do not switch focus to non-existing (or non-active) player
12080 if (game.centered_player_nr_next >= 0 &&
12081 !stored_player[game.centered_player_nr_next].active)
12083 game.centered_player_nr_next = game.centered_player_nr;
12084 game.set_centered_player = FALSE;
12088 if (game.set_centered_player &&
12089 ScreenMovPos == 0) // screen currently aligned at tile position
12093 if (game.centered_player_nr_next == -1)
12095 setScreenCenteredToAllPlayers(&sx, &sy);
12099 sx = stored_player[game.centered_player_nr_next].jx;
12100 sy = stored_player[game.centered_player_nr_next].jy;
12103 game.centered_player_nr = game.centered_player_nr_next;
12104 game.set_centered_player = FALSE;
12106 DrawRelocateScreen(0, 0, sx, sy, MV_NONE, TRUE, setup.quick_switch);
12107 DrawGameDoorValues();
12110 // check single step mode (set flag and clear again if any player is active)
12111 game.enter_single_step_mode =
12112 (tape.single_step && tape.recording && !tape.pausing);
12114 for (i = 0; i < MAX_PLAYERS; i++)
12116 int actual_player_action = stored_player[i].effective_action;
12119 /* !!! THIS BREAKS THE FOLLOWING TAPES: !!!
12120 - rnd_equinox_tetrachloride 048
12121 - rnd_equinox_tetrachloride_ii 096
12122 - rnd_emanuel_schmieg 002
12123 - doctor_sloan_ww 001, 020
12125 if (stored_player[i].MovPos == 0)
12126 CheckGravityMovement(&stored_player[i]);
12129 // overwrite programmed action with tape action
12130 if (stored_player[i].programmed_action)
12131 actual_player_action = stored_player[i].programmed_action;
12133 PlayerActions(&stored_player[i], actual_player_action);
12135 ScrollPlayer(&stored_player[i], SCROLL_GO_ON);
12138 // single step pause mode may already have been toggled by "ScrollPlayer()"
12139 if (game.enter_single_step_mode && !tape.pausing)
12140 TapeTogglePause(TAPE_TOGGLE_AUTOMATIC);
12142 ScrollScreen(NULL, SCROLL_GO_ON);
12144 /* for backwards compatibility, the following code emulates a fixed bug that
12145 occured when pushing elements (causing elements that just made their last
12146 pushing step to already (if possible) make their first falling step in the
12147 same game frame, which is bad); this code is also needed to use the famous
12148 "spring push bug" which is used in older levels and might be wanted to be
12149 used also in newer levels, but in this case the buggy pushing code is only
12150 affecting the "spring" element and no other elements */
12152 if (game.engine_version < VERSION_IDENT(2,2,0,7) || level.use_spring_bug)
12154 for (i = 0; i < MAX_PLAYERS; i++)
12156 struct PlayerInfo *player = &stored_player[i];
12157 int x = player->jx;
12158 int y = player->jy;
12160 if (player->active && player->is_pushing && player->is_moving &&
12162 (game.engine_version < VERSION_IDENT(2,2,0,7) ||
12163 Tile[x][y] == EL_SPRING))
12165 ContinueMoving(x, y);
12167 // continue moving after pushing (this is actually a bug)
12168 if (!IS_MOVING(x, y))
12169 Stop[x][y] = FALSE;
12174 SCAN_PLAYFIELD(x, y)
12176 Last[x][y] = Tile[x][y];
12178 ChangeCount[x][y] = 0;
12179 ChangeEvent[x][y] = -1;
12181 // this must be handled before main playfield loop
12182 if (Tile[x][y] == EL_PLAYER_IS_LEAVING)
12185 if (MovDelay[x][y] <= 0)
12189 if (Tile[x][y] == EL_ELEMENT_SNAPPING)
12192 if (MovDelay[x][y] <= 0)
12194 int element = Store[x][y];
12195 int move_direction = MovDir[x][y];
12196 int player_index_bit = Store2[x][y];
12202 TEST_DrawLevelField(x, y);
12204 TestFieldAfterSnapping(x, y, element, move_direction, player_index_bit);
12206 if (IS_ENVELOPE(element))
12207 local_player->show_envelope = element;
12212 if (ChangePage[x][y] != -1 && ChangeDelay[x][y] != 1)
12214 Debug("game:playing:GameActions_RND", "x = %d, y = %d: ChangePage != -1",
12216 Debug("game:playing:GameActions_RND", "This should never happen!");
12218 ChangePage[x][y] = -1;
12222 Stop[x][y] = FALSE;
12223 if (WasJustMoving[x][y] > 0)
12224 WasJustMoving[x][y]--;
12225 if (WasJustFalling[x][y] > 0)
12226 WasJustFalling[x][y]--;
12227 if (CheckCollision[x][y] > 0)
12228 CheckCollision[x][y]--;
12229 if (CheckImpact[x][y] > 0)
12230 CheckImpact[x][y]--;
12234 /* reset finished pushing action (not done in ContinueMoving() to allow
12235 continuous pushing animation for elements with zero push delay) */
12236 if (GfxAction[x][y] == ACTION_PUSHING && !IS_MOVING(x, y))
12238 ResetGfxAnimation(x, y);
12239 TEST_DrawLevelField(x, y);
12243 if (IS_BLOCKED(x, y))
12247 Blocked2Moving(x, y, &oldx, &oldy);
12248 if (!IS_MOVING(oldx, oldy))
12250 Debug("game:playing:GameActions_RND", "(BLOCKED => MOVING) context corrupted!");
12251 Debug("game:playing:GameActions_RND", "BLOCKED: x = %d, y = %d", x, y);
12252 Debug("game:playing:GameActions_RND", "!MOVING: oldx = %d, oldy = %d", oldx, oldy);
12253 Debug("game:playing:GameActions_RND", "This should never happen!");
12259 if (mouse_action.button)
12261 int new_button = (mouse_action.button && mouse_action_last.button == 0);
12262 int ch_button = CH_SIDE_FROM_BUTTON(mouse_action.button);
12264 x = mouse_action.lx;
12265 y = mouse_action.ly;
12266 element = Tile[x][y];
12270 CheckElementChangeByMouse(x, y, element, CE_CLICKED_BY_MOUSE, ch_button);
12271 CheckTriggeredElementChangeByMouse(x, y, element, CE_MOUSE_CLICKED_ON_X,
12275 CheckElementChangeByMouse(x, y, element, CE_PRESSED_BY_MOUSE, ch_button);
12276 CheckTriggeredElementChangeByMouse(x, y, element, CE_MOUSE_PRESSED_ON_X,
12280 SCAN_PLAYFIELD(x, y)
12282 element = Tile[x][y];
12283 graphic = el_act_dir2img(element, GfxAction[x][y], GfxDir[x][y]);
12284 last_gfx_frame = GfxFrame[x][y];
12286 ResetGfxFrame(x, y);
12288 if (GfxFrame[x][y] != last_gfx_frame && !Stop[x][y])
12289 DrawLevelGraphicAnimation(x, y, graphic);
12291 if (ANIM_MODE(graphic) == ANIM_RANDOM &&
12292 IS_NEXT_FRAME(GfxFrame[x][y], graphic))
12293 ResetRandomAnimationValue(x, y);
12295 SetRandomAnimationValue(x, y);
12297 PlayLevelSoundActionIfLoop(x, y, GfxAction[x][y]);
12299 if (IS_INACTIVE(element))
12301 if (IS_ANIMATED(graphic))
12302 DrawLevelGraphicAnimationIfNeeded(x, y, graphic);
12307 // this may take place after moving, so 'element' may have changed
12308 if (IS_CHANGING(x, y) &&
12309 (game.engine_version < VERSION_IDENT(3,0,7,1) || !Stop[x][y]))
12311 int page = element_info[element].event_page_nr[CE_DELAY];
12313 HandleElementChange(x, y, page);
12315 element = Tile[x][y];
12316 graphic = el_act_dir2img(element, GfxAction[x][y], GfxDir[x][y]);
12319 if (!IS_MOVING(x, y) && (CAN_FALL(element) || CAN_MOVE(element)))
12323 element = Tile[x][y];
12324 graphic = el_act_dir2img(element, GfxAction[x][y], GfxDir[x][y]);
12326 if (IS_ANIMATED(graphic) &&
12327 !IS_MOVING(x, y) &&
12329 DrawLevelGraphicAnimationIfNeeded(x, y, graphic);
12331 if (IS_GEM(element) || element == EL_SP_INFOTRON)
12332 TEST_DrawTwinkleOnField(x, y);
12334 else if (element == EL_ACID)
12337 DrawLevelGraphicAnimationIfNeeded(x, y, graphic);
12339 else if ((element == EL_EXIT_OPEN ||
12340 element == EL_EM_EXIT_OPEN ||
12341 element == EL_SP_EXIT_OPEN ||
12342 element == EL_STEEL_EXIT_OPEN ||
12343 element == EL_EM_STEEL_EXIT_OPEN ||
12344 element == EL_SP_TERMINAL ||
12345 element == EL_SP_TERMINAL_ACTIVE ||
12346 element == EL_EXTRA_TIME ||
12347 element == EL_SHIELD_NORMAL ||
12348 element == EL_SHIELD_DEADLY) &&
12349 IS_ANIMATED(graphic))
12350 DrawLevelGraphicAnimationIfNeeded(x, y, graphic);
12351 else if (IS_MOVING(x, y))
12352 ContinueMoving(x, y);
12353 else if (IS_ACTIVE_BOMB(element))
12354 CheckDynamite(x, y);
12355 else if (element == EL_AMOEBA_GROWING)
12356 AmoebaGrowing(x, y);
12357 else if (element == EL_AMOEBA_SHRINKING)
12358 AmoebaShrinking(x, y);
12360 #if !USE_NEW_AMOEBA_CODE
12361 else if (IS_AMOEBALIVE(element))
12362 AmoebaReproduce(x, y);
12365 else if (element == EL_GAME_OF_LIFE || element == EL_BIOMAZE)
12367 else if (element == EL_EXIT_CLOSED)
12369 else if (element == EL_EM_EXIT_CLOSED)
12371 else if (element == EL_STEEL_EXIT_CLOSED)
12372 CheckExitSteel(x, y);
12373 else if (element == EL_EM_STEEL_EXIT_CLOSED)
12374 CheckExitSteelEM(x, y);
12375 else if (element == EL_SP_EXIT_CLOSED)
12377 else if (element == EL_EXPANDABLE_WALL_GROWING ||
12378 element == EL_EXPANDABLE_STEELWALL_GROWING)
12379 MauerWaechst(x, y);
12380 else if (element == EL_EXPANDABLE_WALL ||
12381 element == EL_EXPANDABLE_WALL_HORIZONTAL ||
12382 element == EL_EXPANDABLE_WALL_VERTICAL ||
12383 element == EL_EXPANDABLE_WALL_ANY ||
12384 element == EL_BD_EXPANDABLE_WALL)
12385 MauerAbleger(x, y);
12386 else if (element == EL_EXPANDABLE_STEELWALL_HORIZONTAL ||
12387 element == EL_EXPANDABLE_STEELWALL_VERTICAL ||
12388 element == EL_EXPANDABLE_STEELWALL_ANY)
12389 MauerAblegerStahl(x, y);
12390 else if (element == EL_FLAMES)
12391 CheckForDragon(x, y);
12392 else if (element == EL_EXPLOSION)
12393 ; // drawing of correct explosion animation is handled separately
12394 else if (element == EL_ELEMENT_SNAPPING ||
12395 element == EL_DIAGONAL_SHRINKING ||
12396 element == EL_DIAGONAL_GROWING)
12398 graphic = el_act_dir2img(GfxElement[x][y], GfxAction[x][y],GfxDir[x][y]);
12400 DrawLevelGraphicAnimationIfNeeded(x, y, graphic);
12402 else if (IS_ANIMATED(graphic) && !IS_CHANGING(x, y))
12403 DrawLevelGraphicAnimationIfNeeded(x, y, graphic);
12405 if (IS_BELT_ACTIVE(element))
12406 PlayLevelSoundAction(x, y, ACTION_ACTIVE);
12408 if (game.magic_wall_active)
12410 int jx = local_player->jx, jy = local_player->jy;
12412 // play the element sound at the position nearest to the player
12413 if ((element == EL_MAGIC_WALL_FULL ||
12414 element == EL_MAGIC_WALL_ACTIVE ||
12415 element == EL_MAGIC_WALL_EMPTYING ||
12416 element == EL_BD_MAGIC_WALL_FULL ||
12417 element == EL_BD_MAGIC_WALL_ACTIVE ||
12418 element == EL_BD_MAGIC_WALL_EMPTYING ||
12419 element == EL_DC_MAGIC_WALL_FULL ||
12420 element == EL_DC_MAGIC_WALL_ACTIVE ||
12421 element == EL_DC_MAGIC_WALL_EMPTYING) &&
12422 ABS(x - jx) + ABS(y - jy) <
12423 ABS(magic_wall_x - jx) + ABS(magic_wall_y - jy))
12431 #if USE_NEW_AMOEBA_CODE
12432 // new experimental amoeba growth stuff
12433 if (!(FrameCounter % 8))
12435 static unsigned int random = 1684108901;
12437 for (i = 0; i < level.amoeba_speed * 28 / 8; i++)
12439 x = RND(lev_fieldx);
12440 y = RND(lev_fieldy);
12441 element = Tile[x][y];
12443 if (!IS_PLAYER(x,y) &&
12444 (element == EL_EMPTY ||
12445 CAN_GROW_INTO(element) ||
12446 element == EL_QUICKSAND_EMPTY ||
12447 element == EL_QUICKSAND_FAST_EMPTY ||
12448 element == EL_ACID_SPLASH_LEFT ||
12449 element == EL_ACID_SPLASH_RIGHT))
12451 if ((IN_LEV_FIELD(x, y-1) && Tile[x][y-1] == EL_AMOEBA_WET) ||
12452 (IN_LEV_FIELD(x-1, y) && Tile[x-1][y] == EL_AMOEBA_WET) ||
12453 (IN_LEV_FIELD(x+1, y) && Tile[x+1][y] == EL_AMOEBA_WET) ||
12454 (IN_LEV_FIELD(x, y+1) && Tile[x][y+1] == EL_AMOEBA_WET))
12455 Tile[x][y] = EL_AMOEBA_DROP;
12458 random = random * 129 + 1;
12463 game.explosions_delayed = FALSE;
12465 SCAN_PLAYFIELD(x, y)
12467 element = Tile[x][y];
12469 if (ExplodeField[x][y])
12470 Explode(x, y, EX_PHASE_START, ExplodeField[x][y]);
12471 else if (element == EL_EXPLOSION)
12472 Explode(x, y, ExplodePhase[x][y], EX_TYPE_NORMAL);
12474 ExplodeField[x][y] = EX_TYPE_NONE;
12477 game.explosions_delayed = TRUE;
12479 if (game.magic_wall_active)
12481 if (!(game.magic_wall_time_left % 4))
12483 int element = Tile[magic_wall_x][magic_wall_y];
12485 if (element == EL_BD_MAGIC_WALL_FULL ||
12486 element == EL_BD_MAGIC_WALL_ACTIVE ||
12487 element == EL_BD_MAGIC_WALL_EMPTYING)
12488 PlayLevelSound(magic_wall_x, magic_wall_y, SND_BD_MAGIC_WALL_ACTIVE);
12489 else if (element == EL_DC_MAGIC_WALL_FULL ||
12490 element == EL_DC_MAGIC_WALL_ACTIVE ||
12491 element == EL_DC_MAGIC_WALL_EMPTYING)
12492 PlayLevelSound(magic_wall_x, magic_wall_y, SND_DC_MAGIC_WALL_ACTIVE);
12494 PlayLevelSound(magic_wall_x, magic_wall_y, SND_MAGIC_WALL_ACTIVE);
12497 if (game.magic_wall_time_left > 0)
12499 game.magic_wall_time_left--;
12501 if (!game.magic_wall_time_left)
12503 SCAN_PLAYFIELD(x, y)
12505 element = Tile[x][y];
12507 if (element == EL_MAGIC_WALL_ACTIVE ||
12508 element == EL_MAGIC_WALL_FULL)
12510 Tile[x][y] = EL_MAGIC_WALL_DEAD;
12511 TEST_DrawLevelField(x, y);
12513 else if (element == EL_BD_MAGIC_WALL_ACTIVE ||
12514 element == EL_BD_MAGIC_WALL_FULL)
12516 Tile[x][y] = EL_BD_MAGIC_WALL_DEAD;
12517 TEST_DrawLevelField(x, y);
12519 else if (element == EL_DC_MAGIC_WALL_ACTIVE ||
12520 element == EL_DC_MAGIC_WALL_FULL)
12522 Tile[x][y] = EL_DC_MAGIC_WALL_DEAD;
12523 TEST_DrawLevelField(x, y);
12527 game.magic_wall_active = FALSE;
12532 if (game.light_time_left > 0)
12534 game.light_time_left--;
12536 if (game.light_time_left == 0)
12537 RedrawAllLightSwitchesAndInvisibleElements();
12540 if (game.timegate_time_left > 0)
12542 game.timegate_time_left--;
12544 if (game.timegate_time_left == 0)
12545 CloseAllOpenTimegates();
12548 if (game.lenses_time_left > 0)
12550 game.lenses_time_left--;
12552 if (game.lenses_time_left == 0)
12553 RedrawAllInvisibleElementsForLenses();
12556 if (game.magnify_time_left > 0)
12558 game.magnify_time_left--;
12560 if (game.magnify_time_left == 0)
12561 RedrawAllInvisibleElementsForMagnifier();
12564 for (i = 0; i < MAX_PLAYERS; i++)
12566 struct PlayerInfo *player = &stored_player[i];
12568 if (SHIELD_ON(player))
12570 if (player->shield_deadly_time_left)
12571 PlayLevelSound(player->jx, player->jy, SND_SHIELD_DEADLY_ACTIVE);
12572 else if (player->shield_normal_time_left)
12573 PlayLevelSound(player->jx, player->jy, SND_SHIELD_NORMAL_ACTIVE);
12577 #if USE_DELAYED_GFX_REDRAW
12578 SCAN_PLAYFIELD(x, y)
12580 if (GfxRedraw[x][y] != GFX_REDRAW_NONE)
12582 /* !!! PROBLEM: THIS REDRAWS THE PLAYFIELD _AFTER_ THE SCAN, BUT TILES
12583 !!! MAY HAVE CHANGED AFTER BEING DRAWN DURING PLAYFIELD SCAN !!! */
12585 if (GfxRedraw[x][y] & GFX_REDRAW_TILE)
12586 DrawLevelField(x, y);
12588 if (GfxRedraw[x][y] & GFX_REDRAW_TILE_CRUMBLED)
12589 DrawLevelFieldCrumbled(x, y);
12591 if (GfxRedraw[x][y] & GFX_REDRAW_TILE_CRUMBLED_NEIGHBOURS)
12592 DrawLevelFieldCrumbledNeighbours(x, y);
12594 if (GfxRedraw[x][y] & GFX_REDRAW_TILE_TWINKLED)
12595 DrawTwinkleOnField(x, y);
12598 GfxRedraw[x][y] = GFX_REDRAW_NONE;
12603 PlayAllPlayersSound();
12605 for (i = 0; i < MAX_PLAYERS; i++)
12607 struct PlayerInfo *player = &stored_player[i];
12609 if (player->show_envelope != 0 && (!player->active ||
12610 player->MovPos == 0))
12612 ShowEnvelope(player->show_envelope - EL_ENVELOPE_1);
12614 player->show_envelope = 0;
12618 // use random number generator in every frame to make it less predictable
12619 if (game.engine_version >= VERSION_IDENT(3,1,1,0))
12622 mouse_action_last = mouse_action;
12625 static boolean AllPlayersInSight(struct PlayerInfo *player, int x, int y)
12627 int min_x = x, min_y = y, max_x = x, max_y = y;
12628 int scr_fieldx = getScreenFieldSizeX();
12629 int scr_fieldy = getScreenFieldSizeY();
12632 for (i = 0; i < MAX_PLAYERS; i++)
12634 int jx = stored_player[i].jx, jy = stored_player[i].jy;
12636 if (!stored_player[i].active || &stored_player[i] == player)
12639 min_x = MIN(min_x, jx);
12640 min_y = MIN(min_y, jy);
12641 max_x = MAX(max_x, jx);
12642 max_y = MAX(max_y, jy);
12645 return (max_x - min_x < scr_fieldx && max_y - min_y < scr_fieldy);
12648 static boolean AllPlayersInVisibleScreen(void)
12652 for (i = 0; i < MAX_PLAYERS; i++)
12654 int jx = stored_player[i].jx, jy = stored_player[i].jy;
12656 if (!stored_player[i].active)
12659 if (!IN_VIS_FIELD(SCREENX(jx), SCREENY(jy)))
12666 void ScrollLevel(int dx, int dy)
12668 int scroll_offset = 2 * TILEX_VAR;
12671 BlitBitmap(drawto_field, drawto_field,
12672 FX + TILEX_VAR * (dx == -1) - scroll_offset,
12673 FY + TILEY_VAR * (dy == -1) - scroll_offset,
12674 SXSIZE - TILEX_VAR * (dx != 0) + 2 * scroll_offset,
12675 SYSIZE - TILEY_VAR * (dy != 0) + 2 * scroll_offset,
12676 FX + TILEX_VAR * (dx == 1) - scroll_offset,
12677 FY + TILEY_VAR * (dy == 1) - scroll_offset);
12681 x = (dx == 1 ? BX1 : BX2);
12682 for (y = BY1; y <= BY2; y++)
12683 DrawScreenField(x, y);
12688 y = (dy == 1 ? BY1 : BY2);
12689 for (x = BX1; x <= BX2; x++)
12690 DrawScreenField(x, y);
12693 redraw_mask |= REDRAW_FIELD;
12696 static boolean canFallDown(struct PlayerInfo *player)
12698 int jx = player->jx, jy = player->jy;
12700 return (IN_LEV_FIELD(jx, jy + 1) &&
12701 (IS_FREE(jx, jy + 1) ||
12702 (Tile[jx][jy + 1] == EL_ACID && player->can_fall_into_acid)) &&
12703 IS_WALKABLE_FROM(Tile[jx][jy], MV_DOWN) &&
12704 !IS_WALKABLE_INSIDE(Tile[jx][jy]));
12707 static boolean canPassField(int x, int y, int move_dir)
12709 int opposite_dir = MV_DIR_OPPOSITE(move_dir);
12710 int dx = (move_dir & MV_LEFT ? -1 : move_dir & MV_RIGHT ? +1 : 0);
12711 int dy = (move_dir & MV_UP ? -1 : move_dir & MV_DOWN ? +1 : 0);
12712 int nextx = x + dx;
12713 int nexty = y + dy;
12714 int element = Tile[x][y];
12716 return (IS_PASSABLE_FROM(element, opposite_dir) &&
12717 !CAN_MOVE(element) &&
12718 IN_LEV_FIELD(nextx, nexty) && !IS_PLAYER(nextx, nexty) &&
12719 IS_WALKABLE_FROM(Tile[nextx][nexty], move_dir) &&
12720 (level.can_pass_to_walkable || IS_FREE(nextx, nexty)));
12723 static boolean canMoveToValidFieldWithGravity(int x, int y, int move_dir)
12725 int opposite_dir = MV_DIR_OPPOSITE(move_dir);
12726 int dx = (move_dir & MV_LEFT ? -1 : move_dir & MV_RIGHT ? +1 : 0);
12727 int dy = (move_dir & MV_UP ? -1 : move_dir & MV_DOWN ? +1 : 0);
12731 return (IN_LEV_FIELD(newx, newy) && !IS_FREE_OR_PLAYER(newx, newy) &&
12732 IS_GRAVITY_REACHABLE(Tile[newx][newy]) &&
12733 (IS_DIGGABLE(Tile[newx][newy]) ||
12734 IS_WALKABLE_FROM(Tile[newx][newy], opposite_dir) ||
12735 canPassField(newx, newy, move_dir)));
12738 static void CheckGravityMovement(struct PlayerInfo *player)
12740 if (player->gravity && !player->programmed_action)
12742 int move_dir_horizontal = player->effective_action & MV_HORIZONTAL;
12743 int move_dir_vertical = player->effective_action & MV_VERTICAL;
12744 boolean player_is_snapping = (player->effective_action & JOY_BUTTON_1);
12745 int jx = player->jx, jy = player->jy;
12746 boolean player_is_moving_to_valid_field =
12747 (!player_is_snapping &&
12748 (canMoveToValidFieldWithGravity(jx, jy, move_dir_horizontal) ||
12749 canMoveToValidFieldWithGravity(jx, jy, move_dir_vertical)));
12750 boolean player_can_fall_down = canFallDown(player);
12752 if (player_can_fall_down &&
12753 !player_is_moving_to_valid_field)
12754 player->programmed_action = MV_DOWN;
12758 static void CheckGravityMovementWhenNotMoving(struct PlayerInfo *player)
12760 return CheckGravityMovement(player);
12762 if (player->gravity && !player->programmed_action)
12764 int jx = player->jx, jy = player->jy;
12765 boolean field_under_player_is_free =
12766 (IN_LEV_FIELD(jx, jy + 1) && IS_FREE(jx, jy + 1));
12767 boolean player_is_standing_on_valid_field =
12768 (IS_WALKABLE_INSIDE(Tile[jx][jy]) ||
12769 (IS_WALKABLE(Tile[jx][jy]) &&
12770 !(element_info[Tile[jx][jy]].access_direction & MV_DOWN)));
12772 if (field_under_player_is_free && !player_is_standing_on_valid_field)
12773 player->programmed_action = MV_DOWN;
12778 MovePlayerOneStep()
12779 -----------------------------------------------------------------------------
12780 dx, dy: direction (non-diagonal) to try to move the player to
12781 real_dx, real_dy: direction as read from input device (can be diagonal)
12784 boolean MovePlayerOneStep(struct PlayerInfo *player,
12785 int dx, int dy, int real_dx, int real_dy)
12787 int jx = player->jx, jy = player->jy;
12788 int new_jx = jx + dx, new_jy = jy + dy;
12790 boolean player_can_move = !player->cannot_move;
12792 if (!player->active || (!dx && !dy))
12793 return MP_NO_ACTION;
12795 player->MovDir = (dx < 0 ? MV_LEFT :
12796 dx > 0 ? MV_RIGHT :
12798 dy > 0 ? MV_DOWN : MV_NONE);
12800 if (!IN_LEV_FIELD(new_jx, new_jy))
12801 return MP_NO_ACTION;
12803 if (!player_can_move)
12805 if (player->MovPos == 0)
12807 player->is_moving = FALSE;
12808 player->is_digging = FALSE;
12809 player->is_collecting = FALSE;
12810 player->is_snapping = FALSE;
12811 player->is_pushing = FALSE;
12815 if (!network.enabled && game.centered_player_nr == -1 &&
12816 !AllPlayersInSight(player, new_jx, new_jy))
12817 return MP_NO_ACTION;
12819 can_move = DigField(player, jx, jy, new_jx, new_jy, real_dx,real_dy, DF_DIG);
12820 if (can_move != MP_MOVING)
12823 // check if DigField() has caused relocation of the player
12824 if (player->jx != jx || player->jy != jy)
12825 return MP_NO_ACTION; // <-- !!! CHECK THIS [-> MP_ACTION ?] !!!
12827 StorePlayer[jx][jy] = 0;
12828 player->last_jx = jx;
12829 player->last_jy = jy;
12830 player->jx = new_jx;
12831 player->jy = new_jy;
12832 StorePlayer[new_jx][new_jy] = player->element_nr;
12834 if (player->move_delay_value_next != -1)
12836 player->move_delay_value = player->move_delay_value_next;
12837 player->move_delay_value_next = -1;
12841 (dx > 0 || dy > 0 ? -1 : 1) * (TILEX - TILEX / player->move_delay_value);
12843 player->step_counter++;
12845 PlayerVisit[jx][jy] = FrameCounter;
12847 player->is_moving = TRUE;
12850 // should better be called in MovePlayer(), but this breaks some tapes
12851 ScrollPlayer(player, SCROLL_INIT);
12857 boolean MovePlayer(struct PlayerInfo *player, int dx, int dy)
12859 int jx = player->jx, jy = player->jy;
12860 int old_jx = jx, old_jy = jy;
12861 int moved = MP_NO_ACTION;
12863 if (!player->active)
12868 if (player->MovPos == 0)
12870 player->is_moving = FALSE;
12871 player->is_digging = FALSE;
12872 player->is_collecting = FALSE;
12873 player->is_snapping = FALSE;
12874 player->is_pushing = FALSE;
12880 if (player->move_delay > 0)
12883 player->move_delay = -1; // set to "uninitialized" value
12885 // store if player is automatically moved to next field
12886 player->is_auto_moving = (player->programmed_action != MV_NONE);
12888 // remove the last programmed player action
12889 player->programmed_action = 0;
12891 if (player->MovPos)
12893 // should only happen if pre-1.2 tape recordings are played
12894 // this is only for backward compatibility
12896 int original_move_delay_value = player->move_delay_value;
12899 Debug("game:playing:MovePlayer",
12900 "THIS SHOULD ONLY HAPPEN WITH PRE-1.2 LEVEL TAPES. [%d]",
12904 // scroll remaining steps with finest movement resolution
12905 player->move_delay_value = MOVE_DELAY_NORMAL_SPEED;
12907 while (player->MovPos)
12909 ScrollPlayer(player, SCROLL_GO_ON);
12910 ScrollScreen(NULL, SCROLL_GO_ON);
12912 AdvanceFrameAndPlayerCounters(player->index_nr);
12915 BackToFront_WithFrameDelay(0);
12918 player->move_delay_value = original_move_delay_value;
12921 player->is_active = FALSE;
12923 if (player->last_move_dir & MV_HORIZONTAL)
12925 if (!(moved |= MovePlayerOneStep(player, 0, dy, dx, dy)))
12926 moved |= MovePlayerOneStep(player, dx, 0, dx, dy);
12930 if (!(moved |= MovePlayerOneStep(player, dx, 0, dx, dy)))
12931 moved |= MovePlayerOneStep(player, 0, dy, dx, dy);
12934 if (!moved && !player->is_active)
12936 player->is_moving = FALSE;
12937 player->is_digging = FALSE;
12938 player->is_collecting = FALSE;
12939 player->is_snapping = FALSE;
12940 player->is_pushing = FALSE;
12946 if (moved & MP_MOVING && !ScreenMovPos &&
12947 (player->index_nr == game.centered_player_nr ||
12948 game.centered_player_nr == -1))
12950 int old_scroll_x = scroll_x, old_scroll_y = scroll_y;
12952 if (!IN_VIS_FIELD(SCREENX(jx), SCREENY(jy)))
12954 // actual player has left the screen -- scroll in that direction
12955 if (jx != old_jx) // player has moved horizontally
12956 scroll_x += (jx - old_jx);
12957 else // player has moved vertically
12958 scroll_y += (jy - old_jy);
12962 int offset_raw = game.scroll_delay_value;
12964 if (jx != old_jx) // player has moved horizontally
12966 int offset = MIN(offset_raw, (SCR_FIELDX - 2) / 2);
12967 int offset_x = offset * (player->MovDir == MV_LEFT ? +1 : -1);
12968 int new_scroll_x = jx - MIDPOSX + offset_x;
12970 if ((player->MovDir == MV_LEFT && scroll_x > new_scroll_x) ||
12971 (player->MovDir == MV_RIGHT && scroll_x < new_scroll_x))
12972 scroll_x = new_scroll_x;
12974 // don't scroll over playfield boundaries
12975 scroll_x = MIN(MAX(SBX_Left, scroll_x), SBX_Right);
12977 // don't scroll more than one field at a time
12978 scroll_x = old_scroll_x + SIGN(scroll_x - old_scroll_x);
12980 // don't scroll against the player's moving direction
12981 if ((player->MovDir == MV_LEFT && scroll_x > old_scroll_x) ||
12982 (player->MovDir == MV_RIGHT && scroll_x < old_scroll_x))
12983 scroll_x = old_scroll_x;
12985 else // player has moved vertically
12987 int offset = MIN(offset_raw, (SCR_FIELDY - 2) / 2);
12988 int offset_y = offset * (player->MovDir == MV_UP ? +1 : -1);
12989 int new_scroll_y = jy - MIDPOSY + offset_y;
12991 if ((player->MovDir == MV_UP && scroll_y > new_scroll_y) ||
12992 (player->MovDir == MV_DOWN && scroll_y < new_scroll_y))
12993 scroll_y = new_scroll_y;
12995 // don't scroll over playfield boundaries
12996 scroll_y = MIN(MAX(SBY_Upper, scroll_y), SBY_Lower);
12998 // don't scroll more than one field at a time
12999 scroll_y = old_scroll_y + SIGN(scroll_y - old_scroll_y);
13001 // don't scroll against the player's moving direction
13002 if ((player->MovDir == MV_UP && scroll_y > old_scroll_y) ||
13003 (player->MovDir == MV_DOWN && scroll_y < old_scroll_y))
13004 scroll_y = old_scroll_y;
13008 if (scroll_x != old_scroll_x || scroll_y != old_scroll_y)
13010 if (!network.enabled && game.centered_player_nr == -1 &&
13011 !AllPlayersInVisibleScreen())
13013 scroll_x = old_scroll_x;
13014 scroll_y = old_scroll_y;
13018 ScrollScreen(player, SCROLL_INIT);
13019 ScrollLevel(old_scroll_x - scroll_x, old_scroll_y - scroll_y);
13024 player->StepFrame = 0;
13026 if (moved & MP_MOVING)
13028 if (old_jx != jx && old_jy == jy)
13029 player->MovDir = (old_jx < jx ? MV_RIGHT : MV_LEFT);
13030 else if (old_jx == jx && old_jy != jy)
13031 player->MovDir = (old_jy < jy ? MV_DOWN : MV_UP);
13033 TEST_DrawLevelField(jx, jy); // for "crumbled sand"
13035 player->last_move_dir = player->MovDir;
13036 player->is_moving = TRUE;
13037 player->is_snapping = FALSE;
13038 player->is_switching = FALSE;
13039 player->is_dropping = FALSE;
13040 player->is_dropping_pressed = FALSE;
13041 player->drop_pressed_delay = 0;
13044 // should better be called here than above, but this breaks some tapes
13045 ScrollPlayer(player, SCROLL_INIT);
13050 CheckGravityMovementWhenNotMoving(player);
13052 player->is_moving = FALSE;
13054 /* at this point, the player is allowed to move, but cannot move right now
13055 (e.g. because of something blocking the way) -- ensure that the player
13056 is also allowed to move in the next frame (in old versions before 3.1.1,
13057 the player was forced to wait again for eight frames before next try) */
13059 if (game.engine_version >= VERSION_IDENT(3,1,1,0))
13060 player->move_delay = 0; // allow direct movement in the next frame
13063 if (player->move_delay == -1) // not yet initialized by DigField()
13064 player->move_delay = player->move_delay_value;
13066 if (game.engine_version < VERSION_IDENT(3,0,7,0))
13068 TestIfPlayerTouchesBadThing(jx, jy);
13069 TestIfPlayerTouchesCustomElement(jx, jy);
13072 if (!player->active)
13073 RemovePlayer(player);
13078 void ScrollPlayer(struct PlayerInfo *player, int mode)
13080 int jx = player->jx, jy = player->jy;
13081 int last_jx = player->last_jx, last_jy = player->last_jy;
13082 int move_stepsize = TILEX / player->move_delay_value;
13084 if (!player->active)
13087 if (player->MovPos == 0 && mode == SCROLL_GO_ON) // player not moving
13090 if (mode == SCROLL_INIT)
13092 player->actual_frame_counter = FrameCounter;
13093 player->GfxPos = move_stepsize * (player->MovPos / move_stepsize);
13095 if ((player->block_last_field || player->block_delay_adjustment > 0) &&
13096 Tile[last_jx][last_jy] == EL_EMPTY)
13098 int last_field_block_delay = 0; // start with no blocking at all
13099 int block_delay_adjustment = player->block_delay_adjustment;
13101 // if player blocks last field, add delay for exactly one move
13102 if (player->block_last_field)
13104 last_field_block_delay += player->move_delay_value;
13106 // when blocking enabled, prevent moving up despite gravity
13107 if (player->gravity && player->MovDir == MV_UP)
13108 block_delay_adjustment = -1;
13111 // add block delay adjustment (also possible when not blocking)
13112 last_field_block_delay += block_delay_adjustment;
13114 Tile[last_jx][last_jy] = EL_PLAYER_IS_LEAVING;
13115 MovDelay[last_jx][last_jy] = last_field_block_delay + 1;
13118 if (player->MovPos != 0) // player has not yet reached destination
13121 else if (!FrameReached(&player->actual_frame_counter, 1))
13124 if (player->MovPos != 0)
13126 player->MovPos += (player->MovPos > 0 ? -1 : 1) * move_stepsize;
13127 player->GfxPos = move_stepsize * (player->MovPos / move_stepsize);
13129 // before DrawPlayer() to draw correct player graphic for this case
13130 if (player->MovPos == 0)
13131 CheckGravityMovement(player);
13134 if (player->MovPos == 0) // player reached destination field
13136 if (player->move_delay_reset_counter > 0)
13138 player->move_delay_reset_counter--;
13140 if (player->move_delay_reset_counter == 0)
13142 // continue with normal speed after quickly moving through gate
13143 HALVE_PLAYER_SPEED(player);
13145 // be able to make the next move without delay
13146 player->move_delay = 0;
13150 player->last_jx = jx;
13151 player->last_jy = jy;
13153 if (Tile[jx][jy] == EL_EXIT_OPEN ||
13154 Tile[jx][jy] == EL_EM_EXIT_OPEN ||
13155 Tile[jx][jy] == EL_EM_EXIT_OPENING ||
13156 Tile[jx][jy] == EL_STEEL_EXIT_OPEN ||
13157 Tile[jx][jy] == EL_EM_STEEL_EXIT_OPEN ||
13158 Tile[jx][jy] == EL_EM_STEEL_EXIT_OPENING ||
13159 Tile[jx][jy] == EL_SP_EXIT_OPEN ||
13160 Tile[jx][jy] == EL_SP_EXIT_OPENING) // <-- special case
13162 ExitPlayer(player);
13164 if (game.players_still_needed == 0 &&
13165 (game.friends_still_needed == 0 ||
13166 IS_SP_ELEMENT(Tile[jx][jy])))
13170 // this breaks one level: "machine", level 000
13172 int move_direction = player->MovDir;
13173 int enter_side = MV_DIR_OPPOSITE(move_direction);
13174 int leave_side = move_direction;
13175 int old_jx = last_jx;
13176 int old_jy = last_jy;
13177 int old_element = Tile[old_jx][old_jy];
13178 int new_element = Tile[jx][jy];
13180 if (IS_CUSTOM_ELEMENT(old_element))
13181 CheckElementChangeByPlayer(old_jx, old_jy, old_element,
13183 player->index_bit, leave_side);
13185 CheckTriggeredElementChangeByPlayer(old_jx, old_jy, old_element,
13186 CE_PLAYER_LEAVES_X,
13187 player->index_bit, leave_side);
13189 if (IS_CUSTOM_ELEMENT(new_element))
13190 CheckElementChangeByPlayer(jx, jy, new_element, CE_ENTERED_BY_PLAYER,
13191 player->index_bit, enter_side);
13193 CheckTriggeredElementChangeByPlayer(jx, jy, new_element,
13194 CE_PLAYER_ENTERS_X,
13195 player->index_bit, enter_side);
13197 CheckTriggeredElementChangeBySide(jx, jy, player->initial_element,
13198 CE_MOVE_OF_X, move_direction);
13201 if (game.engine_version >= VERSION_IDENT(3,0,7,0))
13203 TestIfPlayerTouchesBadThing(jx, jy);
13204 TestIfPlayerTouchesCustomElement(jx, jy);
13206 /* needed because pushed element has not yet reached its destination,
13207 so it would trigger a change event at its previous field location */
13208 if (!player->is_pushing)
13209 TestIfElementTouchesCustomElement(jx, jy); // for empty space
13211 if (level.finish_dig_collect &&
13212 (player->is_digging || player->is_collecting))
13214 int last_element = player->last_removed_element;
13215 int move_direction = player->MovDir;
13216 int enter_side = MV_DIR_OPPOSITE(move_direction);
13217 int change_event = (player->is_digging ? CE_PLAYER_DIGS_X :
13218 CE_PLAYER_COLLECTS_X);
13220 CheckTriggeredElementChangeByPlayer(jx, jy, last_element, change_event,
13221 player->index_bit, enter_side);
13223 player->last_removed_element = EL_UNDEFINED;
13226 if (!player->active)
13227 RemovePlayer(player);
13230 if (level.use_step_counter)
13240 if (TimeLeft <= 10 && setup.time_limit && !game.LevelSolved)
13241 PlaySound(SND_GAME_RUNNING_OUT_OF_TIME);
13243 game_panel_controls[GAME_PANEL_TIME].value = TimeLeft;
13245 DisplayGameControlValues();
13247 if (!TimeLeft && setup.time_limit && !game.LevelSolved)
13248 for (i = 0; i < MAX_PLAYERS; i++)
13249 KillPlayer(&stored_player[i]);
13251 else if (game.no_time_limit && !game.all_players_gone)
13253 game_panel_controls[GAME_PANEL_TIME].value = TimePlayed;
13255 DisplayGameControlValues();
13259 if (tape.single_step && tape.recording && !tape.pausing &&
13260 !player->programmed_action)
13261 TapeTogglePause(TAPE_TOGGLE_AUTOMATIC);
13263 if (!player->programmed_action)
13264 CheckSaveEngineSnapshot(player);
13268 void ScrollScreen(struct PlayerInfo *player, int mode)
13270 static unsigned int screen_frame_counter = 0;
13272 if (mode == SCROLL_INIT)
13274 // set scrolling step size according to actual player's moving speed
13275 ScrollStepSize = TILEX / player->move_delay_value;
13277 screen_frame_counter = FrameCounter;
13278 ScreenMovDir = player->MovDir;
13279 ScreenMovPos = player->MovPos;
13280 ScreenGfxPos = ScrollStepSize * (ScreenMovPos / ScrollStepSize);
13283 else if (!FrameReached(&screen_frame_counter, 1))
13288 ScreenMovPos += (ScreenMovPos > 0 ? -1 : 1) * ScrollStepSize;
13289 ScreenGfxPos = ScrollStepSize * (ScreenMovPos / ScrollStepSize);
13290 redraw_mask |= REDRAW_FIELD;
13293 ScreenMovDir = MV_NONE;
13296 void TestIfPlayerTouchesCustomElement(int x, int y)
13298 static int xy[4][2] =
13305 static int trigger_sides[4][2] =
13307 // center side border side
13308 { CH_SIDE_TOP, CH_SIDE_BOTTOM }, // check top
13309 { CH_SIDE_LEFT, CH_SIDE_RIGHT }, // check left
13310 { CH_SIDE_RIGHT, CH_SIDE_LEFT }, // check right
13311 { CH_SIDE_BOTTOM, CH_SIDE_TOP } // check bottom
13313 static int touch_dir[4] =
13315 MV_LEFT | MV_RIGHT,
13320 int center_element = Tile[x][y]; // should always be non-moving!
13323 for (i = 0; i < NUM_DIRECTIONS; i++)
13325 int xx = x + xy[i][0];
13326 int yy = y + xy[i][1];
13327 int center_side = trigger_sides[i][0];
13328 int border_side = trigger_sides[i][1];
13329 int border_element;
13331 if (!IN_LEV_FIELD(xx, yy))
13334 if (IS_PLAYER(x, y)) // player found at center element
13336 struct PlayerInfo *player = PLAYERINFO(x, y);
13338 if (game.engine_version < VERSION_IDENT(3,0,7,0))
13339 border_element = Tile[xx][yy]; // may be moving!
13340 else if (!IS_MOVING(xx, yy) && !IS_BLOCKED(xx, yy))
13341 border_element = Tile[xx][yy];
13342 else if (MovDir[xx][yy] & touch_dir[i]) // elements are touching
13343 border_element = MovingOrBlocked2Element(xx, yy);
13345 continue; // center and border element do not touch
13347 CheckElementChangeByPlayer(xx, yy, border_element, CE_TOUCHED_BY_PLAYER,
13348 player->index_bit, border_side);
13349 CheckTriggeredElementChangeByPlayer(xx, yy, border_element,
13350 CE_PLAYER_TOUCHES_X,
13351 player->index_bit, border_side);
13354 /* use player element that is initially defined in the level playfield,
13355 not the player element that corresponds to the runtime player number
13356 (example: a level that contains EL_PLAYER_3 as the only player would
13357 incorrectly give EL_PLAYER_1 for "player->element_nr") */
13358 int player_element = PLAYERINFO(x, y)->initial_element;
13360 CheckElementChangeBySide(xx, yy, border_element, player_element,
13361 CE_TOUCHING_X, border_side);
13364 else if (IS_PLAYER(xx, yy)) // player found at border element
13366 struct PlayerInfo *player = PLAYERINFO(xx, yy);
13368 if (game.engine_version >= VERSION_IDENT(3,0,7,0))
13370 if (player->MovPos != 0 && !(player->MovDir & touch_dir[i]))
13371 continue; // center and border element do not touch
13374 CheckElementChangeByPlayer(x, y, center_element, CE_TOUCHED_BY_PLAYER,
13375 player->index_bit, center_side);
13376 CheckTriggeredElementChangeByPlayer(x, y, center_element,
13377 CE_PLAYER_TOUCHES_X,
13378 player->index_bit, center_side);
13381 /* use player element that is initially defined in the level playfield,
13382 not the player element that corresponds to the runtime player number
13383 (example: a level that contains EL_PLAYER_3 as the only player would
13384 incorrectly give EL_PLAYER_1 for "player->element_nr") */
13385 int player_element = PLAYERINFO(xx, yy)->initial_element;
13387 CheckElementChangeBySide(x, y, center_element, player_element,
13388 CE_TOUCHING_X, center_side);
13396 void TestIfElementTouchesCustomElement(int x, int y)
13398 static int xy[4][2] =
13405 static int trigger_sides[4][2] =
13407 // center side border side
13408 { CH_SIDE_TOP, CH_SIDE_BOTTOM }, // check top
13409 { CH_SIDE_LEFT, CH_SIDE_RIGHT }, // check left
13410 { CH_SIDE_RIGHT, CH_SIDE_LEFT }, // check right
13411 { CH_SIDE_BOTTOM, CH_SIDE_TOP } // check bottom
13413 static int touch_dir[4] =
13415 MV_LEFT | MV_RIGHT,
13420 boolean change_center_element = FALSE;
13421 int center_element = Tile[x][y]; // should always be non-moving!
13422 int border_element_old[NUM_DIRECTIONS];
13425 for (i = 0; i < NUM_DIRECTIONS; i++)
13427 int xx = x + xy[i][0];
13428 int yy = y + xy[i][1];
13429 int border_element;
13431 border_element_old[i] = -1;
13433 if (!IN_LEV_FIELD(xx, yy))
13436 if (game.engine_version < VERSION_IDENT(3,0,7,0))
13437 border_element = Tile[xx][yy]; // may be moving!
13438 else if (!IS_MOVING(xx, yy) && !IS_BLOCKED(xx, yy))
13439 border_element = Tile[xx][yy];
13440 else if (MovDir[xx][yy] & touch_dir[i]) // elements are touching
13441 border_element = MovingOrBlocked2Element(xx, yy);
13443 continue; // center and border element do not touch
13445 border_element_old[i] = border_element;
13448 for (i = 0; i < NUM_DIRECTIONS; i++)
13450 int xx = x + xy[i][0];
13451 int yy = y + xy[i][1];
13452 int center_side = trigger_sides[i][0];
13453 int border_element = border_element_old[i];
13455 if (border_element == -1)
13458 // check for change of border element
13459 CheckElementChangeBySide(xx, yy, border_element, center_element,
13460 CE_TOUCHING_X, center_side);
13462 // (center element cannot be player, so we dont have to check this here)
13465 for (i = 0; i < NUM_DIRECTIONS; i++)
13467 int xx = x + xy[i][0];
13468 int yy = y + xy[i][1];
13469 int border_side = trigger_sides[i][1];
13470 int border_element = border_element_old[i];
13472 if (border_element == -1)
13475 // check for change of center element (but change it only once)
13476 if (!change_center_element)
13477 change_center_element =
13478 CheckElementChangeBySide(x, y, center_element, border_element,
13479 CE_TOUCHING_X, border_side);
13481 if (IS_PLAYER(xx, yy))
13483 /* use player element that is initially defined in the level playfield,
13484 not the player element that corresponds to the runtime player number
13485 (example: a level that contains EL_PLAYER_3 as the only player would
13486 incorrectly give EL_PLAYER_1 for "player->element_nr") */
13487 int player_element = PLAYERINFO(xx, yy)->initial_element;
13489 CheckElementChangeBySide(x, y, center_element, player_element,
13490 CE_TOUCHING_X, border_side);
13495 void TestIfElementHitsCustomElement(int x, int y, int direction)
13497 int dx = (direction == MV_LEFT ? -1 : direction == MV_RIGHT ? +1 : 0);
13498 int dy = (direction == MV_UP ? -1 : direction == MV_DOWN ? +1 : 0);
13499 int hitx = x + dx, hity = y + dy;
13500 int hitting_element = Tile[x][y];
13501 int touched_element;
13503 if (IN_LEV_FIELD(hitx, hity) && IS_FREE(hitx, hity))
13506 touched_element = (IN_LEV_FIELD(hitx, hity) ?
13507 MovingOrBlocked2Element(hitx, hity) : EL_STEELWALL);
13509 if (IN_LEV_FIELD(hitx, hity))
13511 int opposite_direction = MV_DIR_OPPOSITE(direction);
13512 int hitting_side = direction;
13513 int touched_side = opposite_direction;
13514 boolean object_hit = (!IS_MOVING(hitx, hity) ||
13515 MovDir[hitx][hity] != direction ||
13516 ABS(MovPos[hitx][hity]) <= TILEY / 2);
13522 CheckElementChangeBySide(x, y, hitting_element, touched_element,
13523 CE_HITTING_X, touched_side);
13525 CheckElementChangeBySide(hitx, hity, touched_element, hitting_element,
13526 CE_HIT_BY_X, hitting_side);
13528 CheckElementChangeBySide(hitx, hity, touched_element, hitting_element,
13529 CE_HIT_BY_SOMETHING, opposite_direction);
13531 if (IS_PLAYER(hitx, hity))
13533 /* use player element that is initially defined in the level playfield,
13534 not the player element that corresponds to the runtime player number
13535 (example: a level that contains EL_PLAYER_3 as the only player would
13536 incorrectly give EL_PLAYER_1 for "player->element_nr") */
13537 int player_element = PLAYERINFO(hitx, hity)->initial_element;
13539 CheckElementChangeBySide(x, y, hitting_element, player_element,
13540 CE_HITTING_X, touched_side);
13545 // "hitting something" is also true when hitting the playfield border
13546 CheckElementChangeBySide(x, y, hitting_element, touched_element,
13547 CE_HITTING_SOMETHING, direction);
13550 void TestIfGoodThingHitsBadThing(int good_x, int good_y, int good_move_dir)
13552 int i, kill_x = -1, kill_y = -1;
13554 int bad_element = -1;
13555 static int test_xy[4][2] =
13562 static int test_dir[4] =
13570 for (i = 0; i < NUM_DIRECTIONS; i++)
13572 int test_x, test_y, test_move_dir, test_element;
13574 test_x = good_x + test_xy[i][0];
13575 test_y = good_y + test_xy[i][1];
13577 if (!IN_LEV_FIELD(test_x, test_y))
13581 (IS_MOVING(test_x, test_y) ? MovDir[test_x][test_y] : MV_NONE);
13583 test_element = MovingOrBlocked2ElementIfNotLeaving(test_x, test_y);
13585 /* 1st case: good thing is moving towards DONT_RUN_INTO style bad thing;
13586 2nd case: DONT_TOUCH style bad thing does not move away from good thing
13588 if ((DONT_RUN_INTO(test_element) && good_move_dir == test_dir[i]) ||
13589 (DONT_TOUCH(test_element) && test_move_dir != test_dir[i]))
13593 bad_element = test_element;
13599 if (kill_x != -1 || kill_y != -1)
13601 if (IS_PLAYER(good_x, good_y))
13603 struct PlayerInfo *player = PLAYERINFO(good_x, good_y);
13605 if (player->shield_deadly_time_left > 0 &&
13606 !IS_INDESTRUCTIBLE(bad_element))
13607 Bang(kill_x, kill_y);
13608 else if (!PLAYER_ENEMY_PROTECTED(good_x, good_y))
13609 KillPlayer(player);
13612 Bang(good_x, good_y);
13616 void TestIfBadThingHitsGoodThing(int bad_x, int bad_y, int bad_move_dir)
13618 int i, kill_x = -1, kill_y = -1;
13619 int bad_element = Tile[bad_x][bad_y];
13620 static int test_xy[4][2] =
13627 static int touch_dir[4] =
13629 MV_LEFT | MV_RIGHT,
13634 static int test_dir[4] =
13642 if (bad_element == EL_EXPLOSION) // skip just exploding bad things
13645 for (i = 0; i < NUM_DIRECTIONS; i++)
13647 int test_x, test_y, test_move_dir, test_element;
13649 test_x = bad_x + test_xy[i][0];
13650 test_y = bad_y + test_xy[i][1];
13652 if (!IN_LEV_FIELD(test_x, test_y))
13656 (IS_MOVING(test_x, test_y) ? MovDir[test_x][test_y] : MV_NONE);
13658 test_element = Tile[test_x][test_y];
13660 /* 1st case: good thing is moving towards DONT_RUN_INTO style bad thing;
13661 2nd case: DONT_TOUCH style bad thing does not move away from good thing
13663 if ((DONT_RUN_INTO(bad_element) && bad_move_dir == test_dir[i]) ||
13664 (DONT_TOUCH(bad_element) && test_move_dir != test_dir[i]))
13666 // good thing is player or penguin that does not move away
13667 if (IS_PLAYER(test_x, test_y))
13669 struct PlayerInfo *player = PLAYERINFO(test_x, test_y);
13671 if (bad_element == EL_ROBOT && player->is_moving)
13672 continue; // robot does not kill player if he is moving
13674 if (game.engine_version >= VERSION_IDENT(3,0,7,0))
13676 if (player->MovPos != 0 && !(player->MovDir & touch_dir[i]))
13677 continue; // center and border element do not touch
13685 else if (test_element == EL_PENGUIN)
13695 if (kill_x != -1 || kill_y != -1)
13697 if (IS_PLAYER(kill_x, kill_y))
13699 struct PlayerInfo *player = PLAYERINFO(kill_x, kill_y);
13701 if (player->shield_deadly_time_left > 0 &&
13702 !IS_INDESTRUCTIBLE(bad_element))
13703 Bang(bad_x, bad_y);
13704 else if (!PLAYER_ENEMY_PROTECTED(kill_x, kill_y))
13705 KillPlayer(player);
13708 Bang(kill_x, kill_y);
13712 void TestIfGoodThingGetsHitByBadThing(int bad_x, int bad_y, int bad_move_dir)
13714 int bad_element = Tile[bad_x][bad_y];
13715 int dx = (bad_move_dir == MV_LEFT ? -1 : bad_move_dir == MV_RIGHT ? +1 : 0);
13716 int dy = (bad_move_dir == MV_UP ? -1 : bad_move_dir == MV_DOWN ? +1 : 0);
13717 int test_x = bad_x + dx, test_y = bad_y + dy;
13718 int test_move_dir, test_element;
13719 int kill_x = -1, kill_y = -1;
13721 if (!IN_LEV_FIELD(test_x, test_y))
13725 (IS_MOVING(test_x, test_y) ? MovDir[test_x][test_y] : MV_NONE);
13727 test_element = Tile[test_x][test_y];
13729 if (test_move_dir != bad_move_dir)
13731 // good thing can be player or penguin that does not move away
13732 if (IS_PLAYER(test_x, test_y))
13734 struct PlayerInfo *player = PLAYERINFO(test_x, test_y);
13736 /* (note: in comparison to DONT_RUN_TO and DONT_TOUCH, also handle the
13737 player as being hit when he is moving towards the bad thing, because
13738 the "get hit by" condition would be lost after the player stops) */
13739 if (player->MovPos != 0 && player->MovDir == bad_move_dir)
13740 return; // player moves away from bad thing
13745 else if (test_element == EL_PENGUIN)
13752 if (kill_x != -1 || kill_y != -1)
13754 if (IS_PLAYER(kill_x, kill_y))
13756 struct PlayerInfo *player = PLAYERINFO(kill_x, kill_y);
13758 if (player->shield_deadly_time_left > 0 &&
13759 !IS_INDESTRUCTIBLE(bad_element))
13760 Bang(bad_x, bad_y);
13761 else if (!PLAYER_ENEMY_PROTECTED(kill_x, kill_y))
13762 KillPlayer(player);
13765 Bang(kill_x, kill_y);
13769 void TestIfPlayerTouchesBadThing(int x, int y)
13771 TestIfGoodThingHitsBadThing(x, y, MV_NONE);
13774 void TestIfPlayerRunsIntoBadThing(int x, int y, int move_dir)
13776 TestIfGoodThingHitsBadThing(x, y, move_dir);
13779 void TestIfBadThingTouchesPlayer(int x, int y)
13781 TestIfBadThingHitsGoodThing(x, y, MV_NONE);
13784 void TestIfBadThingRunsIntoPlayer(int x, int y, int move_dir)
13786 TestIfBadThingHitsGoodThing(x, y, move_dir);
13789 void TestIfFriendTouchesBadThing(int x, int y)
13791 TestIfGoodThingHitsBadThing(x, y, MV_NONE);
13794 void TestIfBadThingTouchesFriend(int x, int y)
13796 TestIfBadThingHitsGoodThing(x, y, MV_NONE);
13799 void TestIfBadThingTouchesOtherBadThing(int bad_x, int bad_y)
13801 int i, kill_x = bad_x, kill_y = bad_y;
13802 static int xy[4][2] =
13810 for (i = 0; i < NUM_DIRECTIONS; i++)
13814 x = bad_x + xy[i][0];
13815 y = bad_y + xy[i][1];
13816 if (!IN_LEV_FIELD(x, y))
13819 element = Tile[x][y];
13820 if (IS_AMOEBOID(element) || element == EL_GAME_OF_LIFE ||
13821 element == EL_AMOEBA_GROWING || element == EL_AMOEBA_DROP)
13829 if (kill_x != bad_x || kill_y != bad_y)
13830 Bang(bad_x, bad_y);
13833 void KillPlayer(struct PlayerInfo *player)
13835 int jx = player->jx, jy = player->jy;
13837 if (!player->active)
13841 Debug("game:playing:KillPlayer",
13842 "0: killed == %d, active == %d, reanimated == %d",
13843 player->killed, player->active, player->reanimated);
13846 /* the following code was introduced to prevent an infinite loop when calling
13848 -> CheckTriggeredElementChangeExt()
13849 -> ExecuteCustomElementAction()
13851 -> (infinitely repeating the above sequence of function calls)
13852 which occurs when killing the player while having a CE with the setting
13853 "kill player X when explosion of <player X>"; the solution using a new
13854 field "player->killed" was chosen for backwards compatibility, although
13855 clever use of the fields "player->active" etc. would probably also work */
13857 if (player->killed)
13861 player->killed = TRUE;
13863 // remove accessible field at the player's position
13864 Tile[jx][jy] = EL_EMPTY;
13866 // deactivate shield (else Bang()/Explode() would not work right)
13867 player->shield_normal_time_left = 0;
13868 player->shield_deadly_time_left = 0;
13871 Debug("game:playing:KillPlayer",
13872 "1: killed == %d, active == %d, reanimated == %d",
13873 player->killed, player->active, player->reanimated);
13879 Debug("game:playing:KillPlayer",
13880 "2: killed == %d, active == %d, reanimated == %d",
13881 player->killed, player->active, player->reanimated);
13884 if (player->reanimated) // killed player may have been reanimated
13885 player->killed = player->reanimated = FALSE;
13887 BuryPlayer(player);
13890 static void KillPlayerUnlessEnemyProtected(int x, int y)
13892 if (!PLAYER_ENEMY_PROTECTED(x, y))
13893 KillPlayer(PLAYERINFO(x, y));
13896 static void KillPlayerUnlessExplosionProtected(int x, int y)
13898 if (!PLAYER_EXPLOSION_PROTECTED(x, y))
13899 KillPlayer(PLAYERINFO(x, y));
13902 void BuryPlayer(struct PlayerInfo *player)
13904 int jx = player->jx, jy = player->jy;
13906 if (!player->active)
13909 PlayLevelSoundElementAction(jx, jy, player->artwork_element, ACTION_DYING);
13910 PlayLevelSound(jx, jy, SND_GAME_LOSING);
13912 RemovePlayer(player);
13914 player->buried = TRUE;
13916 if (game.all_players_gone)
13917 game.GameOver = TRUE;
13920 void RemovePlayer(struct PlayerInfo *player)
13922 int jx = player->jx, jy = player->jy;
13923 int i, found = FALSE;
13925 player->present = FALSE;
13926 player->active = FALSE;
13928 // required for some CE actions (even if the player is not active anymore)
13929 player->MovPos = 0;
13931 if (!ExplodeField[jx][jy])
13932 StorePlayer[jx][jy] = 0;
13934 if (player->is_moving)
13935 TEST_DrawLevelField(player->last_jx, player->last_jy);
13937 for (i = 0; i < MAX_PLAYERS; i++)
13938 if (stored_player[i].active)
13943 game.all_players_gone = TRUE;
13944 game.GameOver = TRUE;
13947 game.exit_x = game.robot_wheel_x = jx;
13948 game.exit_y = game.robot_wheel_y = jy;
13951 void ExitPlayer(struct PlayerInfo *player)
13953 DrawPlayer(player); // needed here only to cleanup last field
13954 RemovePlayer(player);
13956 if (game.players_still_needed > 0)
13957 game.players_still_needed--;
13960 static void SetFieldForSnapping(int x, int y, int element, int direction,
13961 int player_index_bit)
13963 struct ElementInfo *ei = &element_info[element];
13964 int direction_bit = MV_DIR_TO_BIT(direction);
13965 int graphic_snapping = ei->direction_graphic[ACTION_SNAPPING][direction_bit];
13966 int action = (graphic_snapping != IMG_EMPTY_SPACE ? ACTION_SNAPPING :
13967 IS_DIGGABLE(element) ? ACTION_DIGGING : ACTION_COLLECTING);
13969 Tile[x][y] = EL_ELEMENT_SNAPPING;
13970 MovDelay[x][y] = MOVE_DELAY_NORMAL_SPEED + 1 - 1;
13971 MovDir[x][y] = direction;
13972 Store[x][y] = element;
13973 Store2[x][y] = player_index_bit;
13975 ResetGfxAnimation(x, y);
13977 GfxElement[x][y] = element;
13978 GfxAction[x][y] = action;
13979 GfxDir[x][y] = direction;
13980 GfxFrame[x][y] = -1;
13983 static void TestFieldAfterSnapping(int x, int y, int element, int direction,
13984 int player_index_bit)
13986 TestIfElementTouchesCustomElement(x, y); // for empty space
13988 if (level.finish_dig_collect)
13990 int dig_side = MV_DIR_OPPOSITE(direction);
13991 int change_event = (IS_DIGGABLE(element) ? CE_PLAYER_DIGS_X :
13992 CE_PLAYER_COLLECTS_X);
13994 CheckTriggeredElementChangeByPlayer(x, y, element, change_event,
13995 player_index_bit, dig_side);
13996 CheckTriggeredElementChangeByPlayer(x, y, element, CE_PLAYER_SNAPS_X,
13997 player_index_bit, dig_side);
14002 =============================================================================
14003 checkDiagonalPushing()
14004 -----------------------------------------------------------------------------
14005 check if diagonal input device direction results in pushing of object
14006 (by checking if the alternative direction is walkable, diggable, ...)
14007 =============================================================================
14010 static boolean checkDiagonalPushing(struct PlayerInfo *player,
14011 int x, int y, int real_dx, int real_dy)
14013 int jx, jy, dx, dy, xx, yy;
14015 if (real_dx == 0 || real_dy == 0) // no diagonal direction => push
14018 // diagonal direction: check alternative direction
14023 xx = jx + (dx == 0 ? real_dx : 0);
14024 yy = jy + (dy == 0 ? real_dy : 0);
14026 return (!IN_LEV_FIELD(xx, yy) || IS_SOLID_FOR_PUSHING(Tile[xx][yy]));
14030 =============================================================================
14032 -----------------------------------------------------------------------------
14033 x, y: field next to player (non-diagonal) to try to dig to
14034 real_dx, real_dy: direction as read from input device (can be diagonal)
14035 =============================================================================
14038 static int DigField(struct PlayerInfo *player,
14039 int oldx, int oldy, int x, int y,
14040 int real_dx, int real_dy, int mode)
14042 boolean is_player = (IS_PLAYER(oldx, oldy) || mode != DF_DIG);
14043 boolean player_was_pushing = player->is_pushing;
14044 boolean player_can_move = (!player->cannot_move && mode != DF_SNAP);
14045 boolean player_can_move_or_snap = (!player->cannot_move || mode == DF_SNAP);
14046 int jx = oldx, jy = oldy;
14047 int dx = x - jx, dy = y - jy;
14048 int nextx = x + dx, nexty = y + dy;
14049 int move_direction = (dx == -1 ? MV_LEFT :
14050 dx == +1 ? MV_RIGHT :
14052 dy == +1 ? MV_DOWN : MV_NONE);
14053 int opposite_direction = MV_DIR_OPPOSITE(move_direction);
14054 int dig_side = MV_DIR_OPPOSITE(move_direction);
14055 int old_element = Tile[jx][jy];
14056 int element = MovingOrBlocked2ElementIfNotLeaving(x, y);
14059 if (is_player) // function can also be called by EL_PENGUIN
14061 if (player->MovPos == 0)
14063 player->is_digging = FALSE;
14064 player->is_collecting = FALSE;
14067 if (player->MovPos == 0) // last pushing move finished
14068 player->is_pushing = FALSE;
14070 if (mode == DF_NO_PUSH) // player just stopped pushing
14072 player->is_switching = FALSE;
14073 player->push_delay = -1;
14075 return MP_NO_ACTION;
14079 if (IS_TUBE(Back[jx][jy]) && game.engine_version >= VERSION_IDENT(2,2,0,0))
14080 old_element = Back[jx][jy];
14082 // in case of element dropped at player position, check background
14083 else if (Back[jx][jy] != EL_EMPTY &&
14084 game.engine_version >= VERSION_IDENT(2,2,0,0))
14085 old_element = Back[jx][jy];
14087 if (IS_WALKABLE(old_element) && !ACCESS_FROM(old_element, move_direction))
14088 return MP_NO_ACTION; // field has no opening in this direction
14090 if (IS_PASSABLE(old_element) && !ACCESS_FROM(old_element,opposite_direction))
14091 return MP_NO_ACTION; // field has no opening in this direction
14093 if (player_can_move && element == EL_ACID && move_direction == MV_DOWN)
14097 Tile[jx][jy] = player->artwork_element;
14098 InitMovingField(jx, jy, MV_DOWN);
14099 Store[jx][jy] = EL_ACID;
14100 ContinueMoving(jx, jy);
14101 BuryPlayer(player);
14103 return MP_DONT_RUN_INTO;
14106 if (player_can_move && DONT_RUN_INTO(element))
14108 TestIfPlayerRunsIntoBadThing(jx, jy, player->MovDir);
14110 return MP_DONT_RUN_INTO;
14113 if (IS_MOVING(x, y) || IS_PLAYER(x, y))
14114 return MP_NO_ACTION;
14116 collect_count = element_info[element].collect_count_initial;
14118 if (!is_player && !IS_COLLECTIBLE(element)) // penguin cannot collect it
14119 return MP_NO_ACTION;
14121 if (game.engine_version < VERSION_IDENT(2,2,0,0))
14122 player_can_move = player_can_move_or_snap;
14124 if (mode == DF_SNAP && !IS_SNAPPABLE(element) &&
14125 game.engine_version >= VERSION_IDENT(2,2,0,0))
14127 CheckElementChangeByPlayer(x, y, element, CE_SNAPPED_BY_PLAYER,
14128 player->index_bit, dig_side);
14129 CheckTriggeredElementChangeByPlayer(x, y, element, CE_PLAYER_SNAPS_X,
14130 player->index_bit, dig_side);
14132 if (element == EL_DC_LANDMINE)
14135 if (Tile[x][y] != element) // field changed by snapping
14138 return MP_NO_ACTION;
14141 if (player->gravity && is_player && !player->is_auto_moving &&
14142 canFallDown(player) && move_direction != MV_DOWN &&
14143 !canMoveToValidFieldWithGravity(jx, jy, move_direction))
14144 return MP_NO_ACTION; // player cannot walk here due to gravity
14146 if (player_can_move &&
14147 IS_WALKABLE(element) && ACCESS_FROM(element, opposite_direction))
14149 int sound_element = SND_ELEMENT(element);
14150 int sound_action = ACTION_WALKING;
14152 if (IS_RND_GATE(element))
14154 if (!player->key[RND_GATE_NR(element)])
14155 return MP_NO_ACTION;
14157 else if (IS_RND_GATE_GRAY(element))
14159 if (!player->key[RND_GATE_GRAY_NR(element)])
14160 return MP_NO_ACTION;
14162 else if (IS_RND_GATE_GRAY_ACTIVE(element))
14164 if (!player->key[RND_GATE_GRAY_ACTIVE_NR(element)])
14165 return MP_NO_ACTION;
14167 else if (element == EL_EXIT_OPEN ||
14168 element == EL_EM_EXIT_OPEN ||
14169 element == EL_EM_EXIT_OPENING ||
14170 element == EL_STEEL_EXIT_OPEN ||
14171 element == EL_EM_STEEL_EXIT_OPEN ||
14172 element == EL_EM_STEEL_EXIT_OPENING ||
14173 element == EL_SP_EXIT_OPEN ||
14174 element == EL_SP_EXIT_OPENING)
14176 sound_action = ACTION_PASSING; // player is passing exit
14178 else if (element == EL_EMPTY)
14180 sound_action = ACTION_MOVING; // nothing to walk on
14183 // play sound from background or player, whatever is available
14184 if (element_info[sound_element].sound[sound_action] != SND_UNDEFINED)
14185 PlayLevelSoundElementAction(x, y, sound_element, sound_action);
14187 PlayLevelSoundElementAction(x, y, player->artwork_element, sound_action);
14189 else if (player_can_move &&
14190 IS_PASSABLE(element) && canPassField(x, y, move_direction))
14192 if (!ACCESS_FROM(element, opposite_direction))
14193 return MP_NO_ACTION; // field not accessible from this direction
14195 if (CAN_MOVE(element)) // only fixed elements can be passed!
14196 return MP_NO_ACTION;
14198 if (IS_EM_GATE(element))
14200 if (!player->key[EM_GATE_NR(element)])
14201 return MP_NO_ACTION;
14203 else if (IS_EM_GATE_GRAY(element))
14205 if (!player->key[EM_GATE_GRAY_NR(element)])
14206 return MP_NO_ACTION;
14208 else if (IS_EM_GATE_GRAY_ACTIVE(element))
14210 if (!player->key[EM_GATE_GRAY_ACTIVE_NR(element)])
14211 return MP_NO_ACTION;
14213 else if (IS_EMC_GATE(element))
14215 if (!player->key[EMC_GATE_NR(element)])
14216 return MP_NO_ACTION;
14218 else if (IS_EMC_GATE_GRAY(element))
14220 if (!player->key[EMC_GATE_GRAY_NR(element)])
14221 return MP_NO_ACTION;
14223 else if (IS_EMC_GATE_GRAY_ACTIVE(element))
14225 if (!player->key[EMC_GATE_GRAY_ACTIVE_NR(element)])
14226 return MP_NO_ACTION;
14228 else if (element == EL_DC_GATE_WHITE ||
14229 element == EL_DC_GATE_WHITE_GRAY ||
14230 element == EL_DC_GATE_WHITE_GRAY_ACTIVE)
14232 if (player->num_white_keys == 0)
14233 return MP_NO_ACTION;
14235 player->num_white_keys--;
14237 else if (IS_SP_PORT(element))
14239 if (element == EL_SP_GRAVITY_PORT_LEFT ||
14240 element == EL_SP_GRAVITY_PORT_RIGHT ||
14241 element == EL_SP_GRAVITY_PORT_UP ||
14242 element == EL_SP_GRAVITY_PORT_DOWN)
14243 player->gravity = !player->gravity;
14244 else if (element == EL_SP_GRAVITY_ON_PORT_LEFT ||
14245 element == EL_SP_GRAVITY_ON_PORT_RIGHT ||
14246 element == EL_SP_GRAVITY_ON_PORT_UP ||
14247 element == EL_SP_GRAVITY_ON_PORT_DOWN)
14248 player->gravity = TRUE;
14249 else if (element == EL_SP_GRAVITY_OFF_PORT_LEFT ||
14250 element == EL_SP_GRAVITY_OFF_PORT_RIGHT ||
14251 element == EL_SP_GRAVITY_OFF_PORT_UP ||
14252 element == EL_SP_GRAVITY_OFF_PORT_DOWN)
14253 player->gravity = FALSE;
14256 // automatically move to the next field with double speed
14257 player->programmed_action = move_direction;
14259 if (player->move_delay_reset_counter == 0)
14261 player->move_delay_reset_counter = 2; // two double speed steps
14263 DOUBLE_PLAYER_SPEED(player);
14266 PlayLevelSoundAction(x, y, ACTION_PASSING);
14268 else if (player_can_move_or_snap && IS_DIGGABLE(element))
14272 if (mode != DF_SNAP)
14274 GfxElement[x][y] = GFX_ELEMENT(element);
14275 player->is_digging = TRUE;
14278 PlayLevelSoundElementAction(x, y, element, ACTION_DIGGING);
14280 // use old behaviour for old levels (digging)
14281 if (!level.finish_dig_collect)
14283 CheckTriggeredElementChangeByPlayer(x, y, element, CE_PLAYER_DIGS_X,
14284 player->index_bit, dig_side);
14286 // if digging triggered player relocation, finish digging tile
14287 if (mode == DF_DIG && (player->jx != jx || player->jy != jy))
14288 SetFieldForSnapping(x, y, element, move_direction, player->index_bit);
14291 if (mode == DF_SNAP)
14293 if (level.block_snap_field)
14294 SetFieldForSnapping(x, y, element, move_direction, player->index_bit);
14296 TestFieldAfterSnapping(x, y, element, move_direction, player->index_bit);
14298 // use old behaviour for old levels (snapping)
14299 if (!level.finish_dig_collect)
14300 CheckTriggeredElementChangeByPlayer(x, y, element, CE_PLAYER_SNAPS_X,
14301 player->index_bit, dig_side);
14304 else if (player_can_move_or_snap && IS_COLLECTIBLE(element))
14308 if (is_player && mode != DF_SNAP)
14310 GfxElement[x][y] = element;
14311 player->is_collecting = TRUE;
14314 if (element == EL_SPEED_PILL)
14316 player->move_delay_value = MOVE_DELAY_HIGH_SPEED;
14318 else if (element == EL_EXTRA_TIME && level.time > 0)
14320 TimeLeft += level.extra_time;
14322 game_panel_controls[GAME_PANEL_TIME].value = TimeLeft;
14324 DisplayGameControlValues();
14326 else if (element == EL_SHIELD_NORMAL || element == EL_SHIELD_DEADLY)
14328 player->shield_normal_time_left += level.shield_normal_time;
14329 if (element == EL_SHIELD_DEADLY)
14330 player->shield_deadly_time_left += level.shield_deadly_time;
14332 else if (element == EL_DYNAMITE ||
14333 element == EL_EM_DYNAMITE ||
14334 element == EL_SP_DISK_RED)
14336 if (player->inventory_size < MAX_INVENTORY_SIZE)
14337 player->inventory_element[player->inventory_size++] = element;
14339 DrawGameDoorValues();
14341 else if (element == EL_DYNABOMB_INCREASE_NUMBER)
14343 player->dynabomb_count++;
14344 player->dynabombs_left++;
14346 else if (element == EL_DYNABOMB_INCREASE_SIZE)
14348 player->dynabomb_size++;
14350 else if (element == EL_DYNABOMB_INCREASE_POWER)
14352 player->dynabomb_xl = TRUE;
14354 else if (IS_KEY(element))
14356 player->key[KEY_NR(element)] = TRUE;
14358 DrawGameDoorValues();
14360 else if (element == EL_DC_KEY_WHITE)
14362 player->num_white_keys++;
14364 // display white keys?
14365 // DrawGameDoorValues();
14367 else if (IS_ENVELOPE(element))
14369 boolean wait_for_snapping = (mode == DF_SNAP && level.block_snap_field);
14371 if (!wait_for_snapping)
14372 player->show_envelope = element;
14374 else if (element == EL_EMC_LENSES)
14376 game.lenses_time_left = level.lenses_time * FRAMES_PER_SECOND;
14378 RedrawAllInvisibleElementsForLenses();
14380 else if (element == EL_EMC_MAGNIFIER)
14382 game.magnify_time_left = level.magnify_time * FRAMES_PER_SECOND;
14384 RedrawAllInvisibleElementsForMagnifier();
14386 else if (IS_DROPPABLE(element) ||
14387 IS_THROWABLE(element)) // can be collected and dropped
14391 if (collect_count == 0)
14392 player->inventory_infinite_element = element;
14394 for (i = 0; i < collect_count; i++)
14395 if (player->inventory_size < MAX_INVENTORY_SIZE)
14396 player->inventory_element[player->inventory_size++] = element;
14398 DrawGameDoorValues();
14400 else if (collect_count > 0)
14402 game.gems_still_needed -= collect_count;
14403 if (game.gems_still_needed < 0)
14404 game.gems_still_needed = 0;
14406 game.snapshot.collected_item = TRUE;
14408 game_panel_controls[GAME_PANEL_GEMS].value = game.gems_still_needed;
14410 DisplayGameControlValues();
14413 RaiseScoreElement(element);
14414 PlayLevelSoundElementAction(x, y, element, ACTION_COLLECTING);
14416 // use old behaviour for old levels (collecting)
14417 if (!level.finish_dig_collect && is_player)
14419 CheckTriggeredElementChangeByPlayer(x, y, element, CE_PLAYER_COLLECTS_X,
14420 player->index_bit, dig_side);
14422 // if collecting triggered player relocation, finish collecting tile
14423 if (mode == DF_DIG && (player->jx != jx || player->jy != jy))
14424 SetFieldForSnapping(x, y, element, move_direction, player->index_bit);
14427 if (mode == DF_SNAP)
14429 if (level.block_snap_field)
14430 SetFieldForSnapping(x, y, element, move_direction, player->index_bit);
14432 TestFieldAfterSnapping(x, y, element, move_direction, player->index_bit);
14434 // use old behaviour for old levels (snapping)
14435 if (!level.finish_dig_collect)
14436 CheckTriggeredElementChangeByPlayer(x, y, element, CE_PLAYER_SNAPS_X,
14437 player->index_bit, dig_side);
14440 else if (player_can_move_or_snap && IS_PUSHABLE(element))
14442 if (mode == DF_SNAP && element != EL_BD_ROCK)
14443 return MP_NO_ACTION;
14445 if (CAN_FALL(element) && dy)
14446 return MP_NO_ACTION;
14448 if (CAN_FALL(element) && IN_LEV_FIELD(x, y + 1) && IS_FREE(x, y + 1) &&
14449 !(element == EL_SPRING && level.use_spring_bug))
14450 return MP_NO_ACTION;
14452 if (CAN_MOVE(element) && GET_MAX_MOVE_DELAY(element) == 0 &&
14453 ((move_direction & MV_VERTICAL &&
14454 ((element_info[element].move_pattern & MV_LEFT &&
14455 IN_LEV_FIELD(x - 1, y) && IS_FREE(x - 1, y)) ||
14456 (element_info[element].move_pattern & MV_RIGHT &&
14457 IN_LEV_FIELD(x + 1, y) && IS_FREE(x + 1, y)))) ||
14458 (move_direction & MV_HORIZONTAL &&
14459 ((element_info[element].move_pattern & MV_UP &&
14460 IN_LEV_FIELD(x, y - 1) && IS_FREE(x, y - 1)) ||
14461 (element_info[element].move_pattern & MV_DOWN &&
14462 IN_LEV_FIELD(x, y + 1) && IS_FREE(x, y + 1))))))
14463 return MP_NO_ACTION;
14465 // do not push elements already moving away faster than player
14466 if (CAN_MOVE(element) && MovDir[x][y] == move_direction &&
14467 ABS(getElementMoveStepsize(x, y)) > MOVE_STEPSIZE_NORMAL)
14468 return MP_NO_ACTION;
14470 if (game.engine_version >= VERSION_IDENT(3,1,0,0))
14472 if (player->push_delay_value == -1 || !player_was_pushing)
14473 player->push_delay_value = GET_NEW_PUSH_DELAY(element);
14475 else if (game.engine_version >= VERSION_IDENT(3,0,7,1))
14477 if (player->push_delay_value == -1)
14478 player->push_delay_value = GET_NEW_PUSH_DELAY(element);
14480 else if (game.engine_version >= VERSION_IDENT(2,2,0,7))
14482 if (!player->is_pushing)
14483 player->push_delay_value = GET_NEW_PUSH_DELAY(element);
14486 player->is_pushing = TRUE;
14487 player->is_active = TRUE;
14489 if (!(IN_LEV_FIELD(nextx, nexty) &&
14490 (IS_FREE(nextx, nexty) ||
14491 (IS_SB_ELEMENT(element) &&
14492 Tile[nextx][nexty] == EL_SOKOBAN_FIELD_EMPTY) ||
14493 (IS_CUSTOM_ELEMENT(element) &&
14494 CUSTOM_ELEMENT_CAN_ENTER_FIELD(element, nextx, nexty)))))
14495 return MP_NO_ACTION;
14497 if (!checkDiagonalPushing(player, x, y, real_dx, real_dy))
14498 return MP_NO_ACTION;
14500 if (player->push_delay == -1) // new pushing; restart delay
14501 player->push_delay = 0;
14503 if (player->push_delay < player->push_delay_value &&
14504 !(tape.playing && tape.file_version < FILE_VERSION_2_0) &&
14505 element != EL_SPRING && element != EL_BALLOON)
14507 // make sure that there is no move delay before next try to push
14508 if (game.engine_version >= VERSION_IDENT(3,0,7,1))
14509 player->move_delay = 0;
14511 return MP_NO_ACTION;
14514 if (IS_CUSTOM_ELEMENT(element) &&
14515 CUSTOM_ELEMENT_CAN_ENTER_FIELD(element, nextx, nexty))
14517 if (!DigFieldByCE(nextx, nexty, element))
14518 return MP_NO_ACTION;
14521 if (IS_SB_ELEMENT(element))
14523 boolean sokoban_task_solved = FALSE;
14525 if (element == EL_SOKOBAN_FIELD_FULL)
14527 Back[x][y] = EL_SOKOBAN_FIELD_EMPTY;
14529 IncrementSokobanFieldsNeeded();
14530 IncrementSokobanObjectsNeeded();
14533 if (Tile[nextx][nexty] == EL_SOKOBAN_FIELD_EMPTY)
14535 Back[nextx][nexty] = EL_SOKOBAN_FIELD_EMPTY;
14537 DecrementSokobanFieldsNeeded();
14538 DecrementSokobanObjectsNeeded();
14540 // sokoban object was pushed from empty field to sokoban field
14541 if (Back[x][y] == EL_EMPTY)
14542 sokoban_task_solved = TRUE;
14545 Tile[x][y] = EL_SOKOBAN_OBJECT;
14547 if (Back[x][y] == Back[nextx][nexty])
14548 PlayLevelSoundAction(x, y, ACTION_PUSHING);
14549 else if (Back[x][y] != 0)
14550 PlayLevelSoundElementAction(x, y, EL_SOKOBAN_FIELD_FULL,
14553 PlayLevelSoundElementAction(nextx, nexty, EL_SOKOBAN_FIELD_EMPTY,
14556 if (sokoban_task_solved &&
14557 game.sokoban_fields_still_needed == 0 &&
14558 game.sokoban_objects_still_needed == 0 &&
14559 level.auto_exit_sokoban)
14561 game.players_still_needed = 0;
14565 PlayLevelSound(x, y, SND_GAME_SOKOBAN_SOLVING);
14569 PlayLevelSoundElementAction(x, y, element, ACTION_PUSHING);
14571 InitMovingField(x, y, move_direction);
14572 GfxAction[x][y] = ACTION_PUSHING;
14574 if (mode == DF_SNAP)
14575 ContinueMoving(x, y);
14577 MovPos[x][y] = (dx != 0 ? dx : dy);
14579 Pushed[x][y] = TRUE;
14580 Pushed[nextx][nexty] = TRUE;
14582 if (game.engine_version < VERSION_IDENT(2,2,0,7))
14583 player->push_delay_value = GET_NEW_PUSH_DELAY(element);
14585 player->push_delay_value = -1; // get new value later
14587 // check for element change _after_ element has been pushed
14588 if (game.use_change_when_pushing_bug)
14590 CheckElementChangeByPlayer(x, y, element, CE_PUSHED_BY_PLAYER,
14591 player->index_bit, dig_side);
14592 CheckTriggeredElementChangeByPlayer(x, y, element, CE_PLAYER_PUSHES_X,
14593 player->index_bit, dig_side);
14596 else if (IS_SWITCHABLE(element))
14598 if (PLAYER_SWITCHING(player, x, y))
14600 CheckTriggeredElementChangeByPlayer(x, y, element, CE_PLAYER_PRESSES_X,
14601 player->index_bit, dig_side);
14606 player->is_switching = TRUE;
14607 player->switch_x = x;
14608 player->switch_y = y;
14610 PlayLevelSoundElementAction(x, y, element, ACTION_ACTIVATING);
14612 if (element == EL_ROBOT_WHEEL)
14614 Tile[x][y] = EL_ROBOT_WHEEL_ACTIVE;
14616 game.robot_wheel_x = x;
14617 game.robot_wheel_y = y;
14618 game.robot_wheel_active = TRUE;
14620 TEST_DrawLevelField(x, y);
14622 else if (element == EL_SP_TERMINAL)
14626 SCAN_PLAYFIELD(xx, yy)
14628 if (Tile[xx][yy] == EL_SP_DISK_YELLOW)
14632 else if (Tile[xx][yy] == EL_SP_TERMINAL)
14634 Tile[xx][yy] = EL_SP_TERMINAL_ACTIVE;
14636 ResetGfxAnimation(xx, yy);
14637 TEST_DrawLevelField(xx, yy);
14641 else if (IS_BELT_SWITCH(element))
14643 ToggleBeltSwitch(x, y);
14645 else if (element == EL_SWITCHGATE_SWITCH_UP ||
14646 element == EL_SWITCHGATE_SWITCH_DOWN ||
14647 element == EL_DC_SWITCHGATE_SWITCH_UP ||
14648 element == EL_DC_SWITCHGATE_SWITCH_DOWN)
14650 ToggleSwitchgateSwitch(x, y);
14652 else if (element == EL_LIGHT_SWITCH ||
14653 element == EL_LIGHT_SWITCH_ACTIVE)
14655 ToggleLightSwitch(x, y);
14657 else if (element == EL_TIMEGATE_SWITCH ||
14658 element == EL_DC_TIMEGATE_SWITCH)
14660 ActivateTimegateSwitch(x, y);
14662 else if (element == EL_BALLOON_SWITCH_LEFT ||
14663 element == EL_BALLOON_SWITCH_RIGHT ||
14664 element == EL_BALLOON_SWITCH_UP ||
14665 element == EL_BALLOON_SWITCH_DOWN ||
14666 element == EL_BALLOON_SWITCH_NONE ||
14667 element == EL_BALLOON_SWITCH_ANY)
14669 game.wind_direction = (element == EL_BALLOON_SWITCH_LEFT ? MV_LEFT :
14670 element == EL_BALLOON_SWITCH_RIGHT ? MV_RIGHT :
14671 element == EL_BALLOON_SWITCH_UP ? MV_UP :
14672 element == EL_BALLOON_SWITCH_DOWN ? MV_DOWN :
14673 element == EL_BALLOON_SWITCH_NONE ? MV_NONE :
14676 else if (element == EL_LAMP)
14678 Tile[x][y] = EL_LAMP_ACTIVE;
14679 game.lights_still_needed--;
14681 ResetGfxAnimation(x, y);
14682 TEST_DrawLevelField(x, y);
14684 else if (element == EL_TIME_ORB_FULL)
14686 Tile[x][y] = EL_TIME_ORB_EMPTY;
14688 if (level.time > 0 || level.use_time_orb_bug)
14690 TimeLeft += level.time_orb_time;
14691 game.no_time_limit = FALSE;
14693 game_panel_controls[GAME_PANEL_TIME].value = TimeLeft;
14695 DisplayGameControlValues();
14698 ResetGfxAnimation(x, y);
14699 TEST_DrawLevelField(x, y);
14701 else if (element == EL_EMC_MAGIC_BALL_SWITCH ||
14702 element == EL_EMC_MAGIC_BALL_SWITCH_ACTIVE)
14706 game.ball_active = !game.ball_active;
14708 SCAN_PLAYFIELD(xx, yy)
14710 int e = Tile[xx][yy];
14712 if (game.ball_active)
14714 if (e == EL_EMC_MAGIC_BALL)
14715 CreateField(xx, yy, EL_EMC_MAGIC_BALL_ACTIVE);
14716 else if (e == EL_EMC_MAGIC_BALL_SWITCH)
14717 CreateField(xx, yy, EL_EMC_MAGIC_BALL_SWITCH_ACTIVE);
14721 if (e == EL_EMC_MAGIC_BALL_ACTIVE)
14722 CreateField(xx, yy, EL_EMC_MAGIC_BALL);
14723 else if (e == EL_EMC_MAGIC_BALL_SWITCH_ACTIVE)
14724 CreateField(xx, yy, EL_EMC_MAGIC_BALL_SWITCH);
14729 CheckTriggeredElementChangeByPlayer(x, y, element, CE_SWITCH_OF_X,
14730 player->index_bit, dig_side);
14732 CheckTriggeredElementChangeByPlayer(x, y, element, CE_PLAYER_SWITCHES_X,
14733 player->index_bit, dig_side);
14735 CheckTriggeredElementChangeByPlayer(x, y, element, CE_PLAYER_PRESSES_X,
14736 player->index_bit, dig_side);
14742 if (!PLAYER_SWITCHING(player, x, y))
14744 player->is_switching = TRUE;
14745 player->switch_x = x;
14746 player->switch_y = y;
14748 CheckElementChangeByPlayer(x, y, element, CE_SWITCHED,
14749 player->index_bit, dig_side);
14750 CheckTriggeredElementChangeByPlayer(x, y, element, CE_SWITCH_OF_X,
14751 player->index_bit, dig_side);
14753 CheckElementChangeByPlayer(x, y, element, CE_SWITCHED_BY_PLAYER,
14754 player->index_bit, dig_side);
14755 CheckTriggeredElementChangeByPlayer(x, y, element, CE_PLAYER_SWITCHES_X,
14756 player->index_bit, dig_side);
14759 CheckElementChangeByPlayer(x, y, element, CE_PRESSED_BY_PLAYER,
14760 player->index_bit, dig_side);
14761 CheckTriggeredElementChangeByPlayer(x, y, element, CE_PLAYER_PRESSES_X,
14762 player->index_bit, dig_side);
14764 return MP_NO_ACTION;
14767 player->push_delay = -1;
14769 if (is_player) // function can also be called by EL_PENGUIN
14771 if (Tile[x][y] != element) // really digged/collected something
14773 player->is_collecting = !player->is_digging;
14774 player->is_active = TRUE;
14776 player->last_removed_element = element;
14783 static boolean DigFieldByCE(int x, int y, int digging_element)
14785 int element = Tile[x][y];
14787 if (!IS_FREE(x, y))
14789 int action = (IS_DIGGABLE(element) ? ACTION_DIGGING :
14790 IS_COLLECTIBLE(element) ? ACTION_COLLECTING :
14793 // no element can dig solid indestructible elements
14794 if (IS_INDESTRUCTIBLE(element) &&
14795 !IS_DIGGABLE(element) &&
14796 !IS_COLLECTIBLE(element))
14799 if (AmoebaNr[x][y] &&
14800 (element == EL_AMOEBA_FULL ||
14801 element == EL_BD_AMOEBA ||
14802 element == EL_AMOEBA_GROWING))
14804 AmoebaCnt[AmoebaNr[x][y]]--;
14805 AmoebaCnt2[AmoebaNr[x][y]]--;
14808 if (IS_MOVING(x, y))
14809 RemoveMovingField(x, y);
14813 TEST_DrawLevelField(x, y);
14816 // if digged element was about to explode, prevent the explosion
14817 ExplodeField[x][y] = EX_TYPE_NONE;
14819 PlayLevelSoundAction(x, y, action);
14822 Store[x][y] = EL_EMPTY;
14824 // this makes it possible to leave the removed element again
14825 if (IS_EQUAL_OR_IN_GROUP(element, MOVE_ENTER_EL(digging_element)))
14826 Store[x][y] = element;
14831 static boolean SnapField(struct PlayerInfo *player, int dx, int dy)
14833 int jx = player->jx, jy = player->jy;
14834 int x = jx + dx, y = jy + dy;
14835 int snap_direction = (dx == -1 ? MV_LEFT :
14836 dx == +1 ? MV_RIGHT :
14838 dy == +1 ? MV_DOWN : MV_NONE);
14839 boolean can_continue_snapping = (level.continuous_snapping &&
14840 WasJustFalling[x][y] < CHECK_DELAY_FALLING);
14842 if (player->MovPos != 0 && game.engine_version >= VERSION_IDENT(2,2,0,0))
14845 if (!player->active || !IN_LEV_FIELD(x, y))
14853 if (player->MovPos == 0)
14854 player->is_pushing = FALSE;
14856 player->is_snapping = FALSE;
14858 if (player->MovPos == 0)
14860 player->is_moving = FALSE;
14861 player->is_digging = FALSE;
14862 player->is_collecting = FALSE;
14868 // prevent snapping with already pressed snap key when not allowed
14869 if (player->is_snapping && !can_continue_snapping)
14872 player->MovDir = snap_direction;
14874 if (player->MovPos == 0)
14876 player->is_moving = FALSE;
14877 player->is_digging = FALSE;
14878 player->is_collecting = FALSE;
14881 player->is_dropping = FALSE;
14882 player->is_dropping_pressed = FALSE;
14883 player->drop_pressed_delay = 0;
14885 if (DigField(player, jx, jy, x, y, 0, 0, DF_SNAP) == MP_NO_ACTION)
14888 player->is_snapping = TRUE;
14889 player->is_active = TRUE;
14891 if (player->MovPos == 0)
14893 player->is_moving = FALSE;
14894 player->is_digging = FALSE;
14895 player->is_collecting = FALSE;
14898 if (player->MovPos != 0) // prevent graphic bugs in versions < 2.2.0
14899 TEST_DrawLevelField(player->last_jx, player->last_jy);
14901 TEST_DrawLevelField(x, y);
14906 static boolean DropElement(struct PlayerInfo *player)
14908 int old_element, new_element;
14909 int dropx = player->jx, dropy = player->jy;
14910 int drop_direction = player->MovDir;
14911 int drop_side = drop_direction;
14912 int drop_element = get_next_dropped_element(player);
14914 /* do not drop an element on top of another element; when holding drop key
14915 pressed without moving, dropped element must move away before the next
14916 element can be dropped (this is especially important if the next element
14917 is dynamite, which can be placed on background for historical reasons) */
14918 if (PLAYER_DROPPING(player, dropx, dropy) && Tile[dropx][dropy] != EL_EMPTY)
14921 if (IS_THROWABLE(drop_element))
14923 dropx += GET_DX_FROM_DIR(drop_direction);
14924 dropy += GET_DY_FROM_DIR(drop_direction);
14926 if (!IN_LEV_FIELD(dropx, dropy))
14930 old_element = Tile[dropx][dropy]; // old element at dropping position
14931 new_element = drop_element; // default: no change when dropping
14933 // check if player is active, not moving and ready to drop
14934 if (!player->active || player->MovPos || player->drop_delay > 0)
14937 // check if player has anything that can be dropped
14938 if (new_element == EL_UNDEFINED)
14941 // only set if player has anything that can be dropped
14942 player->is_dropping_pressed = TRUE;
14944 // check if drop key was pressed long enough for EM style dynamite
14945 if (new_element == EL_EM_DYNAMITE && player->drop_pressed_delay < 40)
14948 // check if anything can be dropped at the current position
14949 if (IS_ACTIVE_BOMB(old_element) || old_element == EL_EXPLOSION)
14952 // collected custom elements can only be dropped on empty fields
14953 if (IS_CUSTOM_ELEMENT(new_element) && old_element != EL_EMPTY)
14956 if (old_element != EL_EMPTY)
14957 Back[dropx][dropy] = old_element; // store old element on this field
14959 ResetGfxAnimation(dropx, dropy);
14960 ResetRandomAnimationValue(dropx, dropy);
14962 if (player->inventory_size > 0 ||
14963 player->inventory_infinite_element != EL_UNDEFINED)
14965 if (player->inventory_size > 0)
14967 player->inventory_size--;
14969 DrawGameDoorValues();
14971 if (new_element == EL_DYNAMITE)
14972 new_element = EL_DYNAMITE_ACTIVE;
14973 else if (new_element == EL_EM_DYNAMITE)
14974 new_element = EL_EM_DYNAMITE_ACTIVE;
14975 else if (new_element == EL_SP_DISK_RED)
14976 new_element = EL_SP_DISK_RED_ACTIVE;
14979 Tile[dropx][dropy] = new_element;
14981 if (IN_SCR_FIELD(SCREENX(dropx), SCREENY(dropy)))
14982 DrawGraphicThruMask(SCREENX(dropx), SCREENY(dropy),
14983 el2img(Tile[dropx][dropy]), 0);
14985 PlayLevelSoundAction(dropx, dropy, ACTION_DROPPING);
14987 // needed if previous element just changed to "empty" in the last frame
14988 ChangeCount[dropx][dropy] = 0; // allow at least one more change
14990 CheckElementChangeByPlayer(dropx, dropy, new_element, CE_DROPPED_BY_PLAYER,
14991 player->index_bit, drop_side);
14992 CheckTriggeredElementChangeByPlayer(dropx, dropy, new_element,
14994 player->index_bit, drop_side);
14996 TestIfElementTouchesCustomElement(dropx, dropy);
14998 else // player is dropping a dyna bomb
15000 player->dynabombs_left--;
15002 Tile[dropx][dropy] = new_element;
15004 if (IN_SCR_FIELD(SCREENX(dropx), SCREENY(dropy)))
15005 DrawGraphicThruMask(SCREENX(dropx), SCREENY(dropy),
15006 el2img(Tile[dropx][dropy]), 0);
15008 PlayLevelSoundAction(dropx, dropy, ACTION_DROPPING);
15011 if (Tile[dropx][dropy] == new_element) // uninitialized unless CE change
15012 InitField_WithBug1(dropx, dropy, FALSE);
15014 new_element = Tile[dropx][dropy]; // element might have changed
15016 if (IS_CUSTOM_ELEMENT(new_element) && CAN_MOVE(new_element) &&
15017 element_info[new_element].move_pattern == MV_WHEN_DROPPED)
15019 if (element_info[new_element].move_direction_initial == MV_START_AUTOMATIC)
15020 MovDir[dropx][dropy] = drop_direction;
15022 ChangeCount[dropx][dropy] = 0; // allow at least one more change
15024 // do not cause impact style collision by dropping elements that can fall
15025 CheckCollision[dropx][dropy] = CHECK_DELAY_COLLISION;
15028 player->drop_delay = GET_NEW_DROP_DELAY(drop_element);
15029 player->is_dropping = TRUE;
15031 player->drop_pressed_delay = 0;
15032 player->is_dropping_pressed = FALSE;
15034 player->drop_x = dropx;
15035 player->drop_y = dropy;
15040 // ----------------------------------------------------------------------------
15041 // game sound playing functions
15042 // ----------------------------------------------------------------------------
15044 static int *loop_sound_frame = NULL;
15045 static int *loop_sound_volume = NULL;
15047 void InitPlayLevelSound(void)
15049 int num_sounds = getSoundListSize();
15051 checked_free(loop_sound_frame);
15052 checked_free(loop_sound_volume);
15054 loop_sound_frame = checked_calloc(num_sounds * sizeof(int));
15055 loop_sound_volume = checked_calloc(num_sounds * sizeof(int));
15058 static void PlayLevelSound(int x, int y, int nr)
15060 int sx = SCREENX(x), sy = SCREENY(y);
15061 int volume, stereo_position;
15062 int max_distance = 8;
15063 int type = (IS_LOOP_SOUND(nr) ? SND_CTRL_PLAY_LOOP : SND_CTRL_PLAY_SOUND);
15065 if ((!setup.sound_simple && !IS_LOOP_SOUND(nr)) ||
15066 (!setup.sound_loops && IS_LOOP_SOUND(nr)))
15069 if (!IN_LEV_FIELD(x, y) ||
15070 sx < -max_distance || sx >= SCR_FIELDX + max_distance ||
15071 sy < -max_distance || sy >= SCR_FIELDY + max_distance)
15074 volume = SOUND_MAX_VOLUME;
15076 if (!IN_SCR_FIELD(sx, sy))
15078 int dx = ABS(sx - SCR_FIELDX / 2) - SCR_FIELDX / 2;
15079 int dy = ABS(sy - SCR_FIELDY / 2) - SCR_FIELDY / 2;
15081 volume -= volume * (dx > dy ? dx : dy) / max_distance;
15084 stereo_position = (SOUND_MAX_LEFT +
15085 (sx + max_distance) * SOUND_MAX_LEFT2RIGHT /
15086 (SCR_FIELDX + 2 * max_distance));
15088 if (IS_LOOP_SOUND(nr))
15090 /* This assures that quieter loop sounds do not overwrite louder ones,
15091 while restarting sound volume comparison with each new game frame. */
15093 if (loop_sound_volume[nr] > volume && loop_sound_frame[nr] == FrameCounter)
15096 loop_sound_volume[nr] = volume;
15097 loop_sound_frame[nr] = FrameCounter;
15100 PlaySoundExt(nr, volume, stereo_position, type);
15103 static void PlayLevelSoundNearest(int x, int y, int sound_action)
15105 PlayLevelSound(x < LEVELX(BX1) ? LEVELX(BX1) :
15106 x > LEVELX(BX2) ? LEVELX(BX2) : x,
15107 y < LEVELY(BY1) ? LEVELY(BY1) :
15108 y > LEVELY(BY2) ? LEVELY(BY2) : y,
15112 static void PlayLevelSoundAction(int x, int y, int action)
15114 PlayLevelSoundElementAction(x, y, Tile[x][y], action);
15117 static void PlayLevelSoundElementAction(int x, int y, int element, int action)
15119 int sound_effect = element_info[SND_ELEMENT(element)].sound[action];
15121 if (sound_effect != SND_UNDEFINED)
15122 PlayLevelSound(x, y, sound_effect);
15125 static void PlayLevelSoundElementActionIfLoop(int x, int y, int element,
15128 int sound_effect = element_info[SND_ELEMENT(element)].sound[action];
15130 if (sound_effect != SND_UNDEFINED && IS_LOOP_SOUND(sound_effect))
15131 PlayLevelSound(x, y, sound_effect);
15134 static void PlayLevelSoundActionIfLoop(int x, int y, int action)
15136 int sound_effect = element_info[SND_ELEMENT(Tile[x][y])].sound[action];
15138 if (sound_effect != SND_UNDEFINED && IS_LOOP_SOUND(sound_effect))
15139 PlayLevelSound(x, y, sound_effect);
15142 static void StopLevelSoundActionIfLoop(int x, int y, int action)
15144 int sound_effect = element_info[SND_ELEMENT(Tile[x][y])].sound[action];
15146 if (sound_effect != SND_UNDEFINED && IS_LOOP_SOUND(sound_effect))
15147 StopSound(sound_effect);
15150 static int getLevelMusicNr(void)
15152 if (levelset.music[level_nr] != MUS_UNDEFINED)
15153 return levelset.music[level_nr]; // from config file
15155 return MAP_NOCONF_MUSIC(level_nr); // from music dir
15158 static void FadeLevelSounds(void)
15163 static void FadeLevelMusic(void)
15165 int music_nr = getLevelMusicNr();
15166 char *curr_music = getCurrentlyPlayingMusicFilename();
15167 char *next_music = getMusicInfoEntryFilename(music_nr);
15169 if (!strEqual(curr_music, next_music))
15173 void FadeLevelSoundsAndMusic(void)
15179 static void PlayLevelMusic(void)
15181 int music_nr = getLevelMusicNr();
15182 char *curr_music = getCurrentlyPlayingMusicFilename();
15183 char *next_music = getMusicInfoEntryFilename(music_nr);
15185 if (!strEqual(curr_music, next_music))
15186 PlayMusicLoop(music_nr);
15189 void PlayLevelSound_EM(int xx, int yy, int element_em, int sample)
15191 int element = (element_em > -1 ? map_element_EM_to_RND_game(element_em) : 0);
15193 int x = xx - offset;
15194 int y = yy - offset;
15199 PlayLevelSoundElementAction(x, y, element, ACTION_WALKING);
15203 PlayLevelSoundElementAction(x, y, element, ACTION_PUSHING);
15207 PlayLevelSoundElementAction(x, y, element, ACTION_IMPACT);
15211 PlayLevelSoundElementAction(x, y, element, ACTION_IMPACT);
15215 PlayLevelSoundElementAction(x, y, element, ACTION_BREAKING);
15219 PlayLevelSoundElementAction(x, y, element, ACTION_MOVING);
15223 PlayLevelSoundElementAction(x, y, element, ACTION_MOVING);
15226 case SOUND_android_clone:
15227 PlayLevelSoundElementAction(x, y, element, ACTION_DROPPING);
15230 case SOUND_android_move:
15231 PlayLevelSoundElementAction(x, y, element, ACTION_MOVING);
15235 PlayLevelSoundElementAction(x, y, element, ACTION_IMPACT);
15239 PlayLevelSoundElementAction(x, y, element, ACTION_EATING);
15243 PlayLevelSoundElementAction(x, y, element, ACTION_WAITING);
15246 case SOUND_eater_eat:
15247 PlayLevelSoundElementAction(x, y, element, ACTION_DIGGING);
15251 PlayLevelSoundElementAction(x, y, element, ACTION_MOVING);
15254 case SOUND_collect:
15255 PlayLevelSoundElementAction(x, y, element, ACTION_COLLECTING);
15258 case SOUND_diamond:
15259 PlayLevelSoundElementAction(x, y, element, ACTION_IMPACT);
15263 // !!! CHECK THIS !!!
15265 PlayLevelSoundElementAction(x, y, element, ACTION_BREAKING);
15267 PlayLevelSoundElementAction(x, y, element, ACTION_SMASHED_BY_ROCK);
15271 case SOUND_wonderfall:
15272 PlayLevelSoundElementAction(x, y, element, ACTION_FILLING);
15276 PlayLevelSoundElementAction(x, y, element, ACTION_IMPACT);
15280 PlayLevelSoundElementAction(x, y, element, ACTION_PUSHING);
15284 PlayLevelSoundElementAction(x, y, element, ACTION_DIGGING);
15288 PlayLevelSoundElementAction(x, y, element, ACTION_SPLASHING);
15292 PlayLevelSoundElementAction(x, y, element, ACTION_DROPPING);
15296 PlayLevelSoundElementAction(x, y, element, ACTION_GROWING);
15300 PlayLevelSoundElementAction(x, y, element, ACTION_ACTIVE);
15304 PlayLevelSoundElementAction(x, y, element, ACTION_PASSING);
15307 case SOUND_exit_open:
15308 PlayLevelSoundElementAction(x, y, element, ACTION_OPENING);
15311 case SOUND_exit_leave:
15312 PlayLevelSoundElementAction(x, y, element, ACTION_PASSING);
15315 case SOUND_dynamite:
15316 PlayLevelSoundElementAction(x, y, element, ACTION_DROPPING);
15320 PlayLevelSoundElementAction(x, y, element, ACTION_ACTIVE);
15324 PlayLevelSoundElementAction(x, y, element, ACTION_ACTIVATING);
15328 PlayLevelSoundElementAction(x, y, element, ACTION_ACTIVE);
15332 PlayLevelSoundElementAction(x, y, element, ACTION_EXPLODING);
15336 PlayLevelSoundElementAction(x, y, element, ACTION_DYING);
15340 PlaySound(SND_GAME_RUNNING_OUT_OF_TIME);
15344 PlayLevelSoundElementAction(x, y, element, ACTION_DEFAULT);
15349 void PlayLevelSound_SP(int xx, int yy, int element_sp, int action_sp)
15351 int element = map_element_SP_to_RND(element_sp);
15352 int action = map_action_SP_to_RND(action_sp);
15353 int offset = (setup.sp_show_border_elements ? 0 : 1);
15354 int x = xx - offset;
15355 int y = yy - offset;
15357 PlayLevelSoundElementAction(x, y, element, action);
15360 void PlayLevelSound_MM(int xx, int yy, int element_mm, int action_mm)
15362 int element = map_element_MM_to_RND(element_mm);
15363 int action = map_action_MM_to_RND(action_mm);
15365 int x = xx - offset;
15366 int y = yy - offset;
15368 if (!IS_MM_ELEMENT(element))
15369 element = EL_MM_DEFAULT;
15371 PlayLevelSoundElementAction(x, y, element, action);
15374 void PlaySound_MM(int sound_mm)
15376 int sound = map_sound_MM_to_RND(sound_mm);
15378 if (sound == SND_UNDEFINED)
15384 void PlaySoundLoop_MM(int sound_mm)
15386 int sound = map_sound_MM_to_RND(sound_mm);
15388 if (sound == SND_UNDEFINED)
15391 PlaySoundLoop(sound);
15394 void StopSound_MM(int sound_mm)
15396 int sound = map_sound_MM_to_RND(sound_mm);
15398 if (sound == SND_UNDEFINED)
15404 void RaiseScore(int value)
15406 game.score += value;
15408 game_panel_controls[GAME_PANEL_SCORE].value = game.score;
15410 DisplayGameControlValues();
15413 void RaiseScoreElement(int element)
15418 case EL_BD_DIAMOND:
15419 case EL_EMERALD_YELLOW:
15420 case EL_EMERALD_RED:
15421 case EL_EMERALD_PURPLE:
15422 case EL_SP_INFOTRON:
15423 RaiseScore(level.score[SC_EMERALD]);
15426 RaiseScore(level.score[SC_DIAMOND]);
15429 RaiseScore(level.score[SC_CRYSTAL]);
15432 RaiseScore(level.score[SC_PEARL]);
15435 case EL_BD_BUTTERFLY:
15436 case EL_SP_ELECTRON:
15437 RaiseScore(level.score[SC_BUG]);
15440 case EL_BD_FIREFLY:
15441 case EL_SP_SNIKSNAK:
15442 RaiseScore(level.score[SC_SPACESHIP]);
15445 case EL_DARK_YAMYAM:
15446 RaiseScore(level.score[SC_YAMYAM]);
15449 RaiseScore(level.score[SC_ROBOT]);
15452 RaiseScore(level.score[SC_PACMAN]);
15455 RaiseScore(level.score[SC_NUT]);
15458 case EL_EM_DYNAMITE:
15459 case EL_SP_DISK_RED:
15460 case EL_DYNABOMB_INCREASE_NUMBER:
15461 case EL_DYNABOMB_INCREASE_SIZE:
15462 case EL_DYNABOMB_INCREASE_POWER:
15463 RaiseScore(level.score[SC_DYNAMITE]);
15465 case EL_SHIELD_NORMAL:
15466 case EL_SHIELD_DEADLY:
15467 RaiseScore(level.score[SC_SHIELD]);
15469 case EL_EXTRA_TIME:
15470 RaiseScore(level.extra_time_score);
15484 case EL_DC_KEY_WHITE:
15485 RaiseScore(level.score[SC_KEY]);
15488 RaiseScore(element_info[element].collect_score);
15493 void RequestQuitGameExt(boolean skip_request, boolean quick_quit, char *message)
15495 if (skip_request || Request(message, REQ_ASK | REQ_STAY_CLOSED))
15499 // prevent short reactivation of overlay buttons while closing door
15500 SetOverlayActive(FALSE);
15502 // door may still be open due to skipped or envelope style request
15503 CloseDoor(DOOR_CLOSE_1);
15506 if (network.enabled)
15507 SendToServer_StopPlaying(NETWORK_STOP_BY_PLAYER);
15511 FadeSkipNextFadeIn();
15513 SetGameStatus(GAME_MODE_MAIN);
15518 else // continue playing the game
15520 if (tape.playing && tape.deactivate_display)
15521 TapeDeactivateDisplayOff(TRUE);
15523 OpenDoor(DOOR_OPEN_1 | DOOR_COPY_BACK);
15525 if (tape.playing && tape.deactivate_display)
15526 TapeDeactivateDisplayOn();
15530 void RequestQuitGame(boolean escape_key_pressed)
15532 boolean ask_on_escape = (setup.ask_on_escape && setup.ask_on_quit_game);
15533 boolean quick_quit = ((escape_key_pressed && !ask_on_escape) ||
15534 level_editor_test_game);
15535 boolean skip_request = (game.all_players_gone || !setup.ask_on_quit_game ||
15538 RequestQuitGameExt(skip_request, quick_quit,
15539 "Do you really want to quit the game?");
15542 void RequestRestartGame(char *message)
15544 game.restart_game_message = NULL;
15546 boolean has_started_game = hasStartedNetworkGame();
15547 int request_mode = (has_started_game ? REQ_ASK : REQ_CONFIRM);
15549 if (Request(message, request_mode | REQ_STAY_CLOSED) && has_started_game)
15551 StartGameActions(network.enabled, setup.autorecord, level.random_seed);
15555 // needed in case of envelope request to close game panel
15556 CloseDoor(DOOR_CLOSE_1);
15558 SetGameStatus(GAME_MODE_MAIN);
15564 void CheckGameOver(void)
15566 static boolean last_game_over = FALSE;
15567 static int game_over_delay = 0;
15568 int game_over_delay_value = 50;
15569 boolean game_over = checkGameFailed();
15571 // do not handle game over if request dialog is already active
15572 if (game.request_active)
15575 // do not ask to play again if game was never actually played
15576 if (!game.GamePlayed)
15581 last_game_over = FALSE;
15582 game_over_delay = game_over_delay_value;
15587 if (game_over_delay > 0)
15594 if (last_game_over != game_over)
15595 game.restart_game_message = (hasStartedNetworkGame() ?
15596 "Game over! Play it again?" :
15599 last_game_over = game_over;
15602 boolean checkGameSolved(void)
15604 // set for all game engines if level was solved
15605 return game.LevelSolved_GameEnd;
15608 boolean checkGameFailed(void)
15610 if (level.game_engine_type == GAME_ENGINE_TYPE_EM)
15611 return (game_em.game_over && !game_em.level_solved);
15612 else if (level.game_engine_type == GAME_ENGINE_TYPE_SP)
15613 return (game_sp.game_over && !game_sp.level_solved);
15614 else if (level.game_engine_type == GAME_ENGINE_TYPE_MM)
15615 return (game_mm.game_over && !game_mm.level_solved);
15616 else // GAME_ENGINE_TYPE_RND
15617 return (game.GameOver && !game.LevelSolved);
15620 boolean checkGameEnded(void)
15622 return (checkGameSolved() || checkGameFailed());
15626 // ----------------------------------------------------------------------------
15627 // random generator functions
15628 // ----------------------------------------------------------------------------
15630 unsigned int InitEngineRandom_RND(int seed)
15632 game.num_random_calls = 0;
15634 return InitEngineRandom(seed);
15637 unsigned int RND(int max)
15641 game.num_random_calls++;
15643 return GetEngineRandom(max);
15650 // ----------------------------------------------------------------------------
15651 // game engine snapshot handling functions
15652 // ----------------------------------------------------------------------------
15654 struct EngineSnapshotInfo
15656 // runtime values for custom element collect score
15657 int collect_score[NUM_CUSTOM_ELEMENTS];
15659 // runtime values for group element choice position
15660 int choice_pos[NUM_GROUP_ELEMENTS];
15662 // runtime values for belt position animations
15663 int belt_graphic[4][NUM_BELT_PARTS];
15664 int belt_anim_mode[4][NUM_BELT_PARTS];
15667 static struct EngineSnapshotInfo engine_snapshot_rnd;
15668 static char *snapshot_level_identifier = NULL;
15669 static int snapshot_level_nr = -1;
15671 static void SaveEngineSnapshotValues_RND(void)
15673 static int belt_base_active_element[4] =
15675 EL_CONVEYOR_BELT_1_LEFT_ACTIVE,
15676 EL_CONVEYOR_BELT_2_LEFT_ACTIVE,
15677 EL_CONVEYOR_BELT_3_LEFT_ACTIVE,
15678 EL_CONVEYOR_BELT_4_LEFT_ACTIVE
15682 for (i = 0; i < NUM_CUSTOM_ELEMENTS; i++)
15684 int element = EL_CUSTOM_START + i;
15686 engine_snapshot_rnd.collect_score[i] = element_info[element].collect_score;
15689 for (i = 0; i < NUM_GROUP_ELEMENTS; i++)
15691 int element = EL_GROUP_START + i;
15693 engine_snapshot_rnd.choice_pos[i] = element_info[element].group->choice_pos;
15696 for (i = 0; i < 4; i++)
15698 for (j = 0; j < NUM_BELT_PARTS; j++)
15700 int element = belt_base_active_element[i] + j;
15701 int graphic = el2img(element);
15702 int anim_mode = graphic_info[graphic].anim_mode;
15704 engine_snapshot_rnd.belt_graphic[i][j] = graphic;
15705 engine_snapshot_rnd.belt_anim_mode[i][j] = anim_mode;
15710 static void LoadEngineSnapshotValues_RND(void)
15712 unsigned int num_random_calls = game.num_random_calls;
15715 for (i = 0; i < NUM_CUSTOM_ELEMENTS; i++)
15717 int element = EL_CUSTOM_START + i;
15719 element_info[element].collect_score = engine_snapshot_rnd.collect_score[i];
15722 for (i = 0; i < NUM_GROUP_ELEMENTS; i++)
15724 int element = EL_GROUP_START + i;
15726 element_info[element].group->choice_pos = engine_snapshot_rnd.choice_pos[i];
15729 for (i = 0; i < 4; i++)
15731 for (j = 0; j < NUM_BELT_PARTS; j++)
15733 int graphic = engine_snapshot_rnd.belt_graphic[i][j];
15734 int anim_mode = engine_snapshot_rnd.belt_anim_mode[i][j];
15736 graphic_info[graphic].anim_mode = anim_mode;
15740 if (level.game_engine_type == GAME_ENGINE_TYPE_RND)
15742 InitRND(tape.random_seed);
15743 for (i = 0; i < num_random_calls; i++)
15747 if (game.num_random_calls != num_random_calls)
15749 Error("number of random calls out of sync");
15750 Error("number of random calls should be %d", num_random_calls);
15751 Error("number of random calls is %d", game.num_random_calls);
15753 Fail("this should not happen -- please debug");
15757 void FreeEngineSnapshotSingle(void)
15759 FreeSnapshotSingle();
15761 setString(&snapshot_level_identifier, NULL);
15762 snapshot_level_nr = -1;
15765 void FreeEngineSnapshotList(void)
15767 FreeSnapshotList();
15770 static ListNode *SaveEngineSnapshotBuffers(void)
15772 ListNode *buffers = NULL;
15774 // copy some special values to a structure better suited for the snapshot
15776 if (level.game_engine_type == GAME_ENGINE_TYPE_RND)
15777 SaveEngineSnapshotValues_RND();
15778 if (level.game_engine_type == GAME_ENGINE_TYPE_EM)
15779 SaveEngineSnapshotValues_EM();
15780 if (level.game_engine_type == GAME_ENGINE_TYPE_SP)
15781 SaveEngineSnapshotValues_SP(&buffers);
15782 if (level.game_engine_type == GAME_ENGINE_TYPE_MM)
15783 SaveEngineSnapshotValues_MM(&buffers);
15785 // save values stored in special snapshot structure
15787 if (level.game_engine_type == GAME_ENGINE_TYPE_RND)
15788 SaveSnapshotBuffer(&buffers, ARGS_ADDRESS_AND_SIZEOF(engine_snapshot_rnd));
15789 if (level.game_engine_type == GAME_ENGINE_TYPE_EM)
15790 SaveSnapshotBuffer(&buffers, ARGS_ADDRESS_AND_SIZEOF(engine_snapshot_em));
15791 if (level.game_engine_type == GAME_ENGINE_TYPE_SP)
15792 SaveSnapshotBuffer(&buffers, ARGS_ADDRESS_AND_SIZEOF(engine_snapshot_sp));
15793 if (level.game_engine_type == GAME_ENGINE_TYPE_MM)
15794 SaveSnapshotBuffer(&buffers, ARGS_ADDRESS_AND_SIZEOF(engine_snapshot_mm));
15796 // save further RND engine values
15798 SaveSnapshotBuffer(&buffers, ARGS_ADDRESS_AND_SIZEOF(stored_player));
15799 SaveSnapshotBuffer(&buffers, ARGS_ADDRESS_AND_SIZEOF(game));
15800 SaveSnapshotBuffer(&buffers, ARGS_ADDRESS_AND_SIZEOF(tape));
15802 SaveSnapshotBuffer(&buffers, ARGS_ADDRESS_AND_SIZEOF(FrameCounter));
15803 SaveSnapshotBuffer(&buffers, ARGS_ADDRESS_AND_SIZEOF(TimeFrames));
15804 SaveSnapshotBuffer(&buffers, ARGS_ADDRESS_AND_SIZEOF(TimePlayed));
15805 SaveSnapshotBuffer(&buffers, ARGS_ADDRESS_AND_SIZEOF(TimeLeft));
15806 SaveSnapshotBuffer(&buffers, ARGS_ADDRESS_AND_SIZEOF(TapeTime));
15808 SaveSnapshotBuffer(&buffers, ARGS_ADDRESS_AND_SIZEOF(ScreenMovDir));
15809 SaveSnapshotBuffer(&buffers, ARGS_ADDRESS_AND_SIZEOF(ScreenMovPos));
15810 SaveSnapshotBuffer(&buffers, ARGS_ADDRESS_AND_SIZEOF(ScreenGfxPos));
15812 SaveSnapshotBuffer(&buffers, ARGS_ADDRESS_AND_SIZEOF(ScrollStepSize));
15814 SaveSnapshotBuffer(&buffers, ARGS_ADDRESS_AND_SIZEOF(AmoebaCnt));
15815 SaveSnapshotBuffer(&buffers, ARGS_ADDRESS_AND_SIZEOF(AmoebaCnt2));
15817 SaveSnapshotBuffer(&buffers, ARGS_ADDRESS_AND_SIZEOF(Tile));
15818 SaveSnapshotBuffer(&buffers, ARGS_ADDRESS_AND_SIZEOF(MovPos));
15819 SaveSnapshotBuffer(&buffers, ARGS_ADDRESS_AND_SIZEOF(MovDir));
15820 SaveSnapshotBuffer(&buffers, ARGS_ADDRESS_AND_SIZEOF(MovDelay));
15821 SaveSnapshotBuffer(&buffers, ARGS_ADDRESS_AND_SIZEOF(ChangeDelay));
15822 SaveSnapshotBuffer(&buffers, ARGS_ADDRESS_AND_SIZEOF(ChangePage));
15823 SaveSnapshotBuffer(&buffers, ARGS_ADDRESS_AND_SIZEOF(CustomValue));
15824 SaveSnapshotBuffer(&buffers, ARGS_ADDRESS_AND_SIZEOF(Store));
15825 SaveSnapshotBuffer(&buffers, ARGS_ADDRESS_AND_SIZEOF(Store2));
15826 SaveSnapshotBuffer(&buffers, ARGS_ADDRESS_AND_SIZEOF(StorePlayer));
15827 SaveSnapshotBuffer(&buffers, ARGS_ADDRESS_AND_SIZEOF(Back));
15828 SaveSnapshotBuffer(&buffers, ARGS_ADDRESS_AND_SIZEOF(AmoebaNr));
15829 SaveSnapshotBuffer(&buffers, ARGS_ADDRESS_AND_SIZEOF(WasJustMoving));
15830 SaveSnapshotBuffer(&buffers, ARGS_ADDRESS_AND_SIZEOF(WasJustFalling));
15831 SaveSnapshotBuffer(&buffers, ARGS_ADDRESS_AND_SIZEOF(CheckCollision));
15832 SaveSnapshotBuffer(&buffers, ARGS_ADDRESS_AND_SIZEOF(CheckImpact));
15833 SaveSnapshotBuffer(&buffers, ARGS_ADDRESS_AND_SIZEOF(Stop));
15834 SaveSnapshotBuffer(&buffers, ARGS_ADDRESS_AND_SIZEOF(Pushed));
15836 SaveSnapshotBuffer(&buffers, ARGS_ADDRESS_AND_SIZEOF(ChangeCount));
15837 SaveSnapshotBuffer(&buffers, ARGS_ADDRESS_AND_SIZEOF(ChangeEvent));
15839 SaveSnapshotBuffer(&buffers, ARGS_ADDRESS_AND_SIZEOF(ExplodePhase));
15840 SaveSnapshotBuffer(&buffers, ARGS_ADDRESS_AND_SIZEOF(ExplodeDelay));
15841 SaveSnapshotBuffer(&buffers, ARGS_ADDRESS_AND_SIZEOF(ExplodeField));
15843 SaveSnapshotBuffer(&buffers, ARGS_ADDRESS_AND_SIZEOF(RunnerVisit));
15844 SaveSnapshotBuffer(&buffers, ARGS_ADDRESS_AND_SIZEOF(PlayerVisit));
15846 SaveSnapshotBuffer(&buffers, ARGS_ADDRESS_AND_SIZEOF(GfxFrame));
15847 SaveSnapshotBuffer(&buffers, ARGS_ADDRESS_AND_SIZEOF(GfxRandom));
15848 SaveSnapshotBuffer(&buffers, ARGS_ADDRESS_AND_SIZEOF(GfxElement));
15849 SaveSnapshotBuffer(&buffers, ARGS_ADDRESS_AND_SIZEOF(GfxAction));
15850 SaveSnapshotBuffer(&buffers, ARGS_ADDRESS_AND_SIZEOF(GfxDir));
15852 SaveSnapshotBuffer(&buffers, ARGS_ADDRESS_AND_SIZEOF(scroll_x));
15853 SaveSnapshotBuffer(&buffers, ARGS_ADDRESS_AND_SIZEOF(scroll_y));
15856 ListNode *node = engine_snapshot_list_rnd;
15859 while (node != NULL)
15861 num_bytes += ((struct EngineSnapshotNodeInfo *)node->content)->size;
15866 Debug("game:playing:SaveEngineSnapshotBuffers",
15867 "size of engine snapshot: %d bytes", num_bytes);
15873 void SaveEngineSnapshotSingle(void)
15875 ListNode *buffers = SaveEngineSnapshotBuffers();
15877 // finally save all snapshot buffers to single snapshot
15878 SaveSnapshotSingle(buffers);
15880 // save level identification information
15881 setString(&snapshot_level_identifier, leveldir_current->identifier);
15882 snapshot_level_nr = level_nr;
15885 boolean CheckSaveEngineSnapshotToList(void)
15887 boolean save_snapshot =
15888 ((game.snapshot.mode == SNAPSHOT_MODE_EVERY_STEP) ||
15889 (game.snapshot.mode == SNAPSHOT_MODE_EVERY_MOVE &&
15890 game.snapshot.changed_action) ||
15891 (game.snapshot.mode == SNAPSHOT_MODE_EVERY_COLLECT &&
15892 game.snapshot.collected_item));
15894 game.snapshot.changed_action = FALSE;
15895 game.snapshot.collected_item = FALSE;
15896 game.snapshot.save_snapshot = save_snapshot;
15898 return save_snapshot;
15901 void SaveEngineSnapshotToList(void)
15903 if (game.snapshot.mode == SNAPSHOT_MODE_OFF ||
15907 ListNode *buffers = SaveEngineSnapshotBuffers();
15909 // finally save all snapshot buffers to snapshot list
15910 SaveSnapshotToList(buffers);
15913 void SaveEngineSnapshotToListInitial(void)
15915 FreeEngineSnapshotList();
15917 SaveEngineSnapshotToList();
15920 static void LoadEngineSnapshotValues(void)
15922 // restore special values from snapshot structure
15924 if (level.game_engine_type == GAME_ENGINE_TYPE_RND)
15925 LoadEngineSnapshotValues_RND();
15926 if (level.game_engine_type == GAME_ENGINE_TYPE_EM)
15927 LoadEngineSnapshotValues_EM();
15928 if (level.game_engine_type == GAME_ENGINE_TYPE_SP)
15929 LoadEngineSnapshotValues_SP();
15930 if (level.game_engine_type == GAME_ENGINE_TYPE_MM)
15931 LoadEngineSnapshotValues_MM();
15934 void LoadEngineSnapshotSingle(void)
15936 LoadSnapshotSingle();
15938 LoadEngineSnapshotValues();
15941 static void LoadEngineSnapshot_Undo(int steps)
15943 LoadSnapshotFromList_Older(steps);
15945 LoadEngineSnapshotValues();
15948 static void LoadEngineSnapshot_Redo(int steps)
15950 LoadSnapshotFromList_Newer(steps);
15952 LoadEngineSnapshotValues();
15955 boolean CheckEngineSnapshotSingle(void)
15957 return (strEqual(snapshot_level_identifier, leveldir_current->identifier) &&
15958 snapshot_level_nr == level_nr);
15961 boolean CheckEngineSnapshotList(void)
15963 return CheckSnapshotList();
15967 // ---------- new game button stuff -------------------------------------------
15974 boolean *setup_value;
15975 boolean allowed_on_tape;
15976 boolean is_touch_button;
15978 } gamebutton_info[NUM_GAME_BUTTONS] =
15981 IMG_GFX_GAME_BUTTON_STOP, &game.button.stop,
15982 GAME_CTRL_ID_STOP, NULL,
15983 TRUE, FALSE, "stop game"
15986 IMG_GFX_GAME_BUTTON_PAUSE, &game.button.pause,
15987 GAME_CTRL_ID_PAUSE, NULL,
15988 TRUE, FALSE, "pause game"
15991 IMG_GFX_GAME_BUTTON_PLAY, &game.button.play,
15992 GAME_CTRL_ID_PLAY, NULL,
15993 TRUE, FALSE, "play game"
15996 IMG_GFX_GAME_BUTTON_UNDO, &game.button.undo,
15997 GAME_CTRL_ID_UNDO, NULL,
15998 TRUE, FALSE, "undo step"
16001 IMG_GFX_GAME_BUTTON_REDO, &game.button.redo,
16002 GAME_CTRL_ID_REDO, NULL,
16003 TRUE, FALSE, "redo step"
16006 IMG_GFX_GAME_BUTTON_SAVE, &game.button.save,
16007 GAME_CTRL_ID_SAVE, NULL,
16008 TRUE, FALSE, "save game"
16011 IMG_GFX_GAME_BUTTON_PAUSE2, &game.button.pause2,
16012 GAME_CTRL_ID_PAUSE2, NULL,
16013 TRUE, FALSE, "pause game"
16016 IMG_GFX_GAME_BUTTON_LOAD, &game.button.load,
16017 GAME_CTRL_ID_LOAD, NULL,
16018 TRUE, FALSE, "load game"
16021 IMG_GFX_GAME_BUTTON_PANEL_STOP, &game.button.panel_stop,
16022 GAME_CTRL_ID_PANEL_STOP, NULL,
16023 FALSE, FALSE, "stop game"
16026 IMG_GFX_GAME_BUTTON_PANEL_PAUSE, &game.button.panel_pause,
16027 GAME_CTRL_ID_PANEL_PAUSE, NULL,
16028 FALSE, FALSE, "pause game"
16031 IMG_GFX_GAME_BUTTON_PANEL_PLAY, &game.button.panel_play,
16032 GAME_CTRL_ID_PANEL_PLAY, NULL,
16033 FALSE, FALSE, "play game"
16036 IMG_GFX_GAME_BUTTON_TOUCH_STOP, &game.button.touch_stop,
16037 GAME_CTRL_ID_TOUCH_STOP, NULL,
16038 FALSE, TRUE, "stop game"
16041 IMG_GFX_GAME_BUTTON_TOUCH_PAUSE, &game.button.touch_pause,
16042 GAME_CTRL_ID_TOUCH_PAUSE, NULL,
16043 FALSE, TRUE, "pause game"
16046 IMG_GFX_GAME_BUTTON_SOUND_MUSIC, &game.button.sound_music,
16047 SOUND_CTRL_ID_MUSIC, &setup.sound_music,
16048 TRUE, FALSE, "background music on/off"
16051 IMG_GFX_GAME_BUTTON_SOUND_LOOPS, &game.button.sound_loops,
16052 SOUND_CTRL_ID_LOOPS, &setup.sound_loops,
16053 TRUE, FALSE, "sound loops on/off"
16056 IMG_GFX_GAME_BUTTON_SOUND_SIMPLE, &game.button.sound_simple,
16057 SOUND_CTRL_ID_SIMPLE, &setup.sound_simple,
16058 TRUE, FALSE, "normal sounds on/off"
16061 IMG_GFX_GAME_BUTTON_PANEL_SOUND_MUSIC, &game.button.panel_sound_music,
16062 SOUND_CTRL_ID_PANEL_MUSIC, &setup.sound_music,
16063 FALSE, FALSE, "background music on/off"
16066 IMG_GFX_GAME_BUTTON_PANEL_SOUND_LOOPS, &game.button.panel_sound_loops,
16067 SOUND_CTRL_ID_PANEL_LOOPS, &setup.sound_loops,
16068 FALSE, FALSE, "sound loops on/off"
16071 IMG_GFX_GAME_BUTTON_PANEL_SOUND_SIMPLE, &game.button.panel_sound_simple,
16072 SOUND_CTRL_ID_PANEL_SIMPLE, &setup.sound_simple,
16073 FALSE, FALSE, "normal sounds on/off"
16077 void CreateGameButtons(void)
16081 for (i = 0; i < NUM_GAME_BUTTONS; i++)
16083 int graphic = gamebutton_info[i].graphic;
16084 struct GraphicInfo *gfx = &graphic_info[graphic];
16085 struct XY *pos = gamebutton_info[i].pos;
16086 struct GadgetInfo *gi;
16089 unsigned int event_mask;
16090 boolean is_touch_button = gamebutton_info[i].is_touch_button;
16091 boolean allowed_on_tape = gamebutton_info[i].allowed_on_tape;
16092 boolean on_tape = (tape.show_game_buttons && allowed_on_tape);
16093 int base_x = (is_touch_button ? 0 : on_tape ? VX : DX);
16094 int base_y = (is_touch_button ? 0 : on_tape ? VY : DY);
16095 int gd_x = gfx->src_x;
16096 int gd_y = gfx->src_y;
16097 int gd_xp = gfx->src_x + gfx->pressed_xoffset;
16098 int gd_yp = gfx->src_y + gfx->pressed_yoffset;
16099 int gd_xa = gfx->src_x + gfx->active_xoffset;
16100 int gd_ya = gfx->src_y + gfx->active_yoffset;
16101 int gd_xap = gfx->src_x + gfx->active_xoffset + gfx->pressed_xoffset;
16102 int gd_yap = gfx->src_y + gfx->active_yoffset + gfx->pressed_yoffset;
16103 int x = (is_touch_button ? pos->x : GDI_ACTIVE_POS(pos->x));
16104 int y = (is_touch_button ? pos->y : GDI_ACTIVE_POS(pos->y));
16107 if (gfx->bitmap == NULL)
16109 game_gadget[id] = NULL;
16114 if (id == GAME_CTRL_ID_STOP ||
16115 id == GAME_CTRL_ID_PANEL_STOP ||
16116 id == GAME_CTRL_ID_TOUCH_STOP ||
16117 id == GAME_CTRL_ID_PLAY ||
16118 id == GAME_CTRL_ID_PANEL_PLAY ||
16119 id == GAME_CTRL_ID_SAVE ||
16120 id == GAME_CTRL_ID_LOAD)
16122 button_type = GD_TYPE_NORMAL_BUTTON;
16124 event_mask = GD_EVENT_RELEASED;
16126 else if (id == GAME_CTRL_ID_UNDO ||
16127 id == GAME_CTRL_ID_REDO)
16129 button_type = GD_TYPE_NORMAL_BUTTON;
16131 event_mask = GD_EVENT_PRESSED | GD_EVENT_REPEATED;
16135 button_type = GD_TYPE_CHECK_BUTTON;
16136 checked = (gamebutton_info[i].setup_value != NULL ?
16137 *gamebutton_info[i].setup_value : FALSE);
16138 event_mask = GD_EVENT_PRESSED;
16141 gi = CreateGadget(GDI_CUSTOM_ID, id,
16142 GDI_IMAGE_ID, graphic,
16143 GDI_INFO_TEXT, gamebutton_info[i].infotext,
16146 GDI_WIDTH, gfx->width,
16147 GDI_HEIGHT, gfx->height,
16148 GDI_TYPE, button_type,
16149 GDI_STATE, GD_BUTTON_UNPRESSED,
16150 GDI_CHECKED, checked,
16151 GDI_DESIGN_UNPRESSED, gfx->bitmap, gd_x, gd_y,
16152 GDI_DESIGN_PRESSED, gfx->bitmap, gd_xp, gd_yp,
16153 GDI_ALT_DESIGN_UNPRESSED, gfx->bitmap, gd_xa, gd_ya,
16154 GDI_ALT_DESIGN_PRESSED, gfx->bitmap, gd_xap, gd_yap,
16155 GDI_DIRECT_DRAW, FALSE,
16156 GDI_OVERLAY_TOUCH_BUTTON, is_touch_button,
16157 GDI_EVENT_MASK, event_mask,
16158 GDI_CALLBACK_ACTION, HandleGameButtons,
16162 Fail("cannot create gadget");
16164 game_gadget[id] = gi;
16168 void FreeGameButtons(void)
16172 for (i = 0; i < NUM_GAME_BUTTONS; i++)
16173 FreeGadget(game_gadget[i]);
16176 static void UnmapGameButtonsAtSamePosition(int id)
16180 for (i = 0; i < NUM_GAME_BUTTONS; i++)
16182 gamebutton_info[i].pos->x == gamebutton_info[id].pos->x &&
16183 gamebutton_info[i].pos->y == gamebutton_info[id].pos->y)
16184 UnmapGadget(game_gadget[i]);
16187 static void UnmapGameButtonsAtSamePosition_All(void)
16189 if (setup.show_load_save_buttons)
16191 UnmapGameButtonsAtSamePosition(GAME_CTRL_ID_SAVE);
16192 UnmapGameButtonsAtSamePosition(GAME_CTRL_ID_PAUSE2);
16193 UnmapGameButtonsAtSamePosition(GAME_CTRL_ID_LOAD);
16195 else if (setup.show_undo_redo_buttons)
16197 UnmapGameButtonsAtSamePosition(GAME_CTRL_ID_UNDO);
16198 UnmapGameButtonsAtSamePosition(GAME_CTRL_ID_PAUSE2);
16199 UnmapGameButtonsAtSamePosition(GAME_CTRL_ID_REDO);
16203 UnmapGameButtonsAtSamePosition(GAME_CTRL_ID_STOP);
16204 UnmapGameButtonsAtSamePosition(GAME_CTRL_ID_PAUSE);
16205 UnmapGameButtonsAtSamePosition(GAME_CTRL_ID_PLAY);
16207 UnmapGameButtonsAtSamePosition(GAME_CTRL_ID_PANEL_STOP);
16208 UnmapGameButtonsAtSamePosition(GAME_CTRL_ID_PANEL_PAUSE);
16209 UnmapGameButtonsAtSamePosition(GAME_CTRL_ID_PANEL_PLAY);
16213 void MapLoadSaveButtons(void)
16215 UnmapGameButtonsAtSamePosition(GAME_CTRL_ID_LOAD);
16216 UnmapGameButtonsAtSamePosition(GAME_CTRL_ID_SAVE);
16218 MapGadget(game_gadget[GAME_CTRL_ID_LOAD]);
16219 MapGadget(game_gadget[GAME_CTRL_ID_SAVE]);
16222 void MapUndoRedoButtons(void)
16224 UnmapGameButtonsAtSamePosition(GAME_CTRL_ID_UNDO);
16225 UnmapGameButtonsAtSamePosition(GAME_CTRL_ID_REDO);
16227 MapGadget(game_gadget[GAME_CTRL_ID_UNDO]);
16228 MapGadget(game_gadget[GAME_CTRL_ID_REDO]);
16231 void ModifyPauseButtons(void)
16235 GAME_CTRL_ID_PAUSE,
16236 GAME_CTRL_ID_PAUSE2,
16237 GAME_CTRL_ID_PANEL_PAUSE,
16238 GAME_CTRL_ID_TOUCH_PAUSE,
16243 for (i = 0; ids[i] > -1; i++)
16244 ModifyGadget(game_gadget[ids[i]], GDI_CHECKED, tape.pausing, GDI_END);
16247 static void MapGameButtonsExt(boolean on_tape)
16251 for (i = 0; i < NUM_GAME_BUTTONS; i++)
16252 if (!on_tape || gamebutton_info[i].allowed_on_tape)
16253 MapGadget(game_gadget[i]);
16255 UnmapGameButtonsAtSamePosition_All();
16257 RedrawGameButtons();
16260 static void UnmapGameButtonsExt(boolean on_tape)
16264 for (i = 0; i < NUM_GAME_BUTTONS; i++)
16265 if (!on_tape || gamebutton_info[i].allowed_on_tape)
16266 UnmapGadget(game_gadget[i]);
16269 static void RedrawGameButtonsExt(boolean on_tape)
16273 for (i = 0; i < NUM_GAME_BUTTONS; i++)
16274 if (!on_tape || gamebutton_info[i].allowed_on_tape)
16275 RedrawGadget(game_gadget[i]);
16278 static void SetGadgetState(struct GadgetInfo *gi, boolean state)
16283 gi->checked = state;
16286 static void RedrawSoundButtonGadget(int id)
16288 int id2 = (id == SOUND_CTRL_ID_MUSIC ? SOUND_CTRL_ID_PANEL_MUSIC :
16289 id == SOUND_CTRL_ID_LOOPS ? SOUND_CTRL_ID_PANEL_LOOPS :
16290 id == SOUND_CTRL_ID_SIMPLE ? SOUND_CTRL_ID_PANEL_SIMPLE :
16291 id == SOUND_CTRL_ID_PANEL_MUSIC ? SOUND_CTRL_ID_MUSIC :
16292 id == SOUND_CTRL_ID_PANEL_LOOPS ? SOUND_CTRL_ID_LOOPS :
16293 id == SOUND_CTRL_ID_PANEL_SIMPLE ? SOUND_CTRL_ID_SIMPLE :
16296 SetGadgetState(game_gadget[id2], *gamebutton_info[id2].setup_value);
16297 RedrawGadget(game_gadget[id2]);
16300 void MapGameButtons(void)
16302 MapGameButtonsExt(FALSE);
16305 void UnmapGameButtons(void)
16307 UnmapGameButtonsExt(FALSE);
16310 void RedrawGameButtons(void)
16312 RedrawGameButtonsExt(FALSE);
16315 void MapGameButtonsOnTape(void)
16317 MapGameButtonsExt(TRUE);
16320 void UnmapGameButtonsOnTape(void)
16322 UnmapGameButtonsExt(TRUE);
16325 void RedrawGameButtonsOnTape(void)
16327 RedrawGameButtonsExt(TRUE);
16330 static void GameUndoRedoExt(void)
16332 ClearPlayerAction();
16334 tape.pausing = TRUE;
16337 UpdateAndDisplayGameControlValues();
16339 DrawCompleteVideoDisplay();
16340 DrawVideoDisplay(VIDEO_STATE_TIME_ON, TapeTime);
16341 DrawVideoDisplay(VIDEO_STATE_FRAME_ON, FrameCounter);
16342 DrawVideoDisplay(VIDEO_STATE_1STEP(tape.single_step), 0);
16344 ModifyPauseButtons();
16349 static void GameUndo(int steps)
16351 if (!CheckEngineSnapshotList())
16354 int tape_property_bits = tape.property_bits;
16356 LoadEngineSnapshot_Undo(steps);
16358 tape.property_bits |= tape_property_bits | TAPE_PROPERTY_SNAPSHOT;
16363 static void GameRedo(int steps)
16365 if (!CheckEngineSnapshotList())
16368 int tape_property_bits = tape.property_bits;
16370 LoadEngineSnapshot_Redo(steps);
16372 tape.property_bits |= tape_property_bits | TAPE_PROPERTY_SNAPSHOT;
16377 static void HandleGameButtonsExt(int id, int button)
16379 static boolean game_undo_executed = FALSE;
16380 int steps = BUTTON_STEPSIZE(button);
16381 boolean handle_game_buttons =
16382 (game_status == GAME_MODE_PLAYING ||
16383 (game_status == GAME_MODE_MAIN && tape.show_game_buttons));
16385 if (!handle_game_buttons)
16390 case GAME_CTRL_ID_STOP:
16391 case GAME_CTRL_ID_PANEL_STOP:
16392 case GAME_CTRL_ID_TOUCH_STOP:
16393 if (game_status == GAME_MODE_MAIN)
16399 RequestQuitGame(FALSE);
16403 case GAME_CTRL_ID_PAUSE:
16404 case GAME_CTRL_ID_PAUSE2:
16405 case GAME_CTRL_ID_PANEL_PAUSE:
16406 case GAME_CTRL_ID_TOUCH_PAUSE:
16407 if (network.enabled && game_status == GAME_MODE_PLAYING)
16410 SendToServer_ContinuePlaying();
16412 SendToServer_PausePlaying();
16415 TapeTogglePause(TAPE_TOGGLE_MANUAL);
16417 game_undo_executed = FALSE;
16421 case GAME_CTRL_ID_PLAY:
16422 case GAME_CTRL_ID_PANEL_PLAY:
16423 if (game_status == GAME_MODE_MAIN)
16425 StartGameActions(network.enabled, setup.autorecord, level.random_seed);
16427 else if (tape.pausing)
16429 if (network.enabled)
16430 SendToServer_ContinuePlaying();
16432 TapeTogglePause(TAPE_TOGGLE_MANUAL | TAPE_TOGGLE_PLAY_PAUSE);
16436 case GAME_CTRL_ID_UNDO:
16437 // Important: When using "save snapshot when collecting an item" mode,
16438 // load last (current) snapshot for first "undo" after pressing "pause"
16439 // (else the last-but-one snapshot would be loaded, because the snapshot
16440 // pointer already points to the last snapshot when pressing "pause",
16441 // which is fine for "every step/move" mode, but not for "every collect")
16442 if (game.snapshot.mode == SNAPSHOT_MODE_EVERY_COLLECT &&
16443 !game_undo_executed)
16446 game_undo_executed = TRUE;
16451 case GAME_CTRL_ID_REDO:
16455 case GAME_CTRL_ID_SAVE:
16459 case GAME_CTRL_ID_LOAD:
16463 case SOUND_CTRL_ID_MUSIC:
16464 case SOUND_CTRL_ID_PANEL_MUSIC:
16465 if (setup.sound_music)
16467 setup.sound_music = FALSE;
16471 else if (audio.music_available)
16473 setup.sound = setup.sound_music = TRUE;
16475 SetAudioMode(setup.sound);
16477 if (game_status == GAME_MODE_PLAYING)
16481 RedrawSoundButtonGadget(id);
16485 case SOUND_CTRL_ID_LOOPS:
16486 case SOUND_CTRL_ID_PANEL_LOOPS:
16487 if (setup.sound_loops)
16488 setup.sound_loops = FALSE;
16489 else if (audio.loops_available)
16491 setup.sound = setup.sound_loops = TRUE;
16493 SetAudioMode(setup.sound);
16496 RedrawSoundButtonGadget(id);
16500 case SOUND_CTRL_ID_SIMPLE:
16501 case SOUND_CTRL_ID_PANEL_SIMPLE:
16502 if (setup.sound_simple)
16503 setup.sound_simple = FALSE;
16504 else if (audio.sound_available)
16506 setup.sound = setup.sound_simple = TRUE;
16508 SetAudioMode(setup.sound);
16511 RedrawSoundButtonGadget(id);
16520 static void HandleGameButtons(struct GadgetInfo *gi)
16522 HandleGameButtonsExt(gi->custom_id, gi->event.button);
16525 void HandleSoundButtonKeys(Key key)
16527 if (key == setup.shortcut.sound_simple)
16528 ClickOnGadget(game_gadget[SOUND_CTRL_ID_SIMPLE], MB_LEFTBUTTON);
16529 else if (key == setup.shortcut.sound_loops)
16530 ClickOnGadget(game_gadget[SOUND_CTRL_ID_LOOPS], MB_LEFTBUTTON);
16531 else if (key == setup.shortcut.sound_music)
16532 ClickOnGadget(game_gadget[SOUND_CTRL_ID_MUSIC], MB_LEFTBUTTON);