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);
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;
4969 game.LevelSolved_GameEnd = TRUE;
4971 if (game.LevelSolved_SaveTape)
4973 // make sure that request dialog to save tape does not open door again
4974 if (!global.use_envelope_request)
4975 CloseDoor(DOOR_CLOSE_1);
4977 SaveTapeChecked_LevelSolved(tape.level_nr); // ask to save tape
4979 // set unique basename for score tape (also saved in high score table)
4980 strcpy(tape.score_tape_basename, getScoreTapeBasename(setup.player_name));
4983 // if no tape is to be saved, close both doors simultaneously
4984 CloseDoor(DOOR_CLOSE_ALL);
4986 if (level_editor_test_game)
4988 SetGameStatus(GAME_MODE_MAIN);
4995 if (!game.LevelSolved_SaveScore)
4997 SetGameStatus(GAME_MODE_MAIN);
5004 if (level_nr == leveldir_current->handicap_level)
5006 leveldir_current->handicap_level++;
5008 SaveLevelSetup_SeriesInfo();
5011 // save score and score tape before potentially erasing tape below
5012 NewHighScore(last_level_nr);
5014 if (setup.increment_levels &&
5015 level_nr < leveldir_current->last_level &&
5018 level_nr++; // advance to next level
5019 TapeErase(); // start with empty tape
5021 if (setup.auto_play_next_level)
5023 LoadLevel(level_nr);
5025 SaveLevelSetup_SeriesInfo();
5029 if (scores.last_added >= 0 && setup.show_scores_after_game)
5031 SetGameStatus(GAME_MODE_SCORES);
5033 DrawHallOfFame(last_level_nr);
5035 else if (setup.auto_play_next_level && setup.increment_levels &&
5036 last_level_nr < leveldir_current->last_level &&
5039 StartGameActions(network.enabled, setup.autorecord, level.random_seed);
5043 SetGameStatus(GAME_MODE_MAIN);
5049 static int addScoreEntry(struct ScoreInfo *list, struct ScoreEntry *new_entry,
5050 boolean one_score_entry_per_name)
5054 if (strEqual(new_entry->name, EMPTY_PLAYER_NAME))
5057 for (i = 0; i < MAX_SCORE_ENTRIES; i++)
5059 struct ScoreEntry *entry = &list->entry[i];
5060 boolean score_is_better = (new_entry->score > entry->score);
5061 boolean score_is_equal = (new_entry->score == entry->score);
5062 boolean time_is_better = (new_entry->time < entry->time);
5063 boolean time_is_equal = (new_entry->time == entry->time);
5064 boolean better_by_score = (score_is_better ||
5065 (score_is_equal && time_is_better));
5066 boolean better_by_time = (time_is_better ||
5067 (time_is_equal && score_is_better));
5068 boolean is_better = (level.rate_time_over_score ? better_by_time :
5070 boolean entry_is_empty = (entry->score == 0 &&
5073 // prevent adding server score entries if also existing in local score file
5074 // (special case: historic score entries have an empty tape basename entry)
5075 if (strEqual(new_entry->tape_basename, entry->tape_basename) &&
5076 !strEqual(new_entry->tape_basename, UNDEFINED_FILENAME))
5079 if (is_better || entry_is_empty)
5081 // player has made it to the hall of fame
5083 if (i < MAX_SCORE_ENTRIES - 1)
5085 int m = MAX_SCORE_ENTRIES - 1;
5088 if (one_score_entry_per_name)
5090 for (l = i; l < MAX_SCORE_ENTRIES; l++)
5091 if (strEqual(list->entry[l].name, new_entry->name))
5094 if (m == i) // player's new highscore overwrites his old one
5098 for (l = m; l > i; l--)
5099 list->entry[l] = list->entry[l - 1];
5104 *entry = *new_entry;
5108 else if (one_score_entry_per_name &&
5109 strEqual(entry->name, new_entry->name))
5111 // player already in high score list with better score or time
5120 void NewHighScore(int level_nr)
5122 struct ScoreEntry new_entry = {{ 0 }}; // (prevent warning from GCC bug 53119)
5123 boolean one_per_name = FALSE;
5125 strncpy(new_entry.tape_basename, tape.score_tape_basename, MAX_FILENAME_LEN);
5126 strncpy(new_entry.name, setup.player_name, MAX_PLAYER_NAME_LEN);
5128 new_entry.score = game.score_final;
5129 new_entry.time = game.score_time_final;
5131 LoadScore(level_nr);
5133 scores.last_added = addScoreEntry(&scores, &new_entry, one_per_name);
5135 if (scores.last_added >= 0)
5137 SaveScore(level_nr);
5139 // store last added local score entry (before merging server scores)
5140 scores.last_added_local = scores.last_added;
5143 if (game.LevelSolved_SaveTape)
5145 SaveScoreTape(level_nr);
5146 SaveServerScore(level_nr);
5150 void MergeServerScore(void)
5152 struct ScoreEntry last_added_entry;
5153 boolean one_per_name = FALSE;
5156 if (scores.last_added >= 0)
5157 last_added_entry = scores.entry[scores.last_added];
5159 for (i = 0; i < server_scores.num_entries; i++)
5161 int pos = addScoreEntry(&scores, &server_scores.entry[i], one_per_name);
5163 if (pos >= 0 && pos <= scores.last_added)
5164 scores.last_added++;
5167 if (scores.last_added >= MAX_SCORE_ENTRIES)
5169 scores.last_added = MAX_SCORE_ENTRIES - 1;
5170 scores.force_last_added = TRUE;
5172 scores.entry[scores.last_added] = last_added_entry;
5176 static int getElementMoveStepsizeExt(int x, int y, int direction)
5178 int element = Tile[x][y];
5179 int dx = (direction == MV_LEFT ? -1 : direction == MV_RIGHT ? +1 : 0);
5180 int dy = (direction == MV_UP ? -1 : direction == MV_DOWN ? +1 : 0);
5181 int horiz_move = (dx != 0);
5182 int sign = (horiz_move ? dx : dy);
5183 int step = sign * element_info[element].move_stepsize;
5185 // special values for move stepsize for spring and things on conveyor belt
5188 if (CAN_FALL(element) &&
5189 y < lev_fieldy - 1 && IS_BELT_ACTIVE(Tile[x][y + 1]))
5190 step = sign * MOVE_STEPSIZE_NORMAL / 2;
5191 else if (element == EL_SPRING)
5192 step = sign * MOVE_STEPSIZE_NORMAL * 2;
5198 static int getElementMoveStepsize(int x, int y)
5200 return getElementMoveStepsizeExt(x, y, MovDir[x][y]);
5203 void InitPlayerGfxAnimation(struct PlayerInfo *player, int action, int dir)
5205 if (player->GfxAction != action || player->GfxDir != dir)
5207 player->GfxAction = action;
5208 player->GfxDir = dir;
5210 player->StepFrame = 0;
5214 static void ResetGfxFrame(int x, int y)
5216 // profiling showed that "autotest" spends 10~20% of its time in this function
5217 if (DrawingDeactivatedField())
5220 int element = Tile[x][y];
5221 int graphic = el_act_dir2img(element, GfxAction[x][y], GfxDir[x][y]);
5223 if (graphic_info[graphic].anim_global_sync)
5224 GfxFrame[x][y] = FrameCounter;
5225 else if (ANIM_MODE(graphic) == ANIM_CE_VALUE)
5226 GfxFrame[x][y] = CustomValue[x][y];
5227 else if (ANIM_MODE(graphic) == ANIM_CE_SCORE)
5228 GfxFrame[x][y] = element_info[element].collect_score;
5229 else if (ANIM_MODE(graphic) == ANIM_CE_DELAY)
5230 GfxFrame[x][y] = ChangeDelay[x][y];
5233 static void ResetGfxAnimation(int x, int y)
5235 GfxAction[x][y] = ACTION_DEFAULT;
5236 GfxDir[x][y] = MovDir[x][y];
5239 ResetGfxFrame(x, y);
5242 static void ResetRandomAnimationValue(int x, int y)
5244 GfxRandom[x][y] = INIT_GFX_RANDOM();
5247 static void InitMovingField(int x, int y, int direction)
5249 int element = Tile[x][y];
5250 int dx = (direction == MV_LEFT ? -1 : direction == MV_RIGHT ? +1 : 0);
5251 int dy = (direction == MV_UP ? -1 : direction == MV_DOWN ? +1 : 0);
5254 boolean is_moving_before, is_moving_after;
5256 // check if element was/is moving or being moved before/after mode change
5257 is_moving_before = (WasJustMoving[x][y] != 0);
5258 is_moving_after = (getElementMoveStepsizeExt(x, y, direction) != 0);
5260 // reset animation only for moving elements which change direction of moving
5261 // or which just started or stopped moving
5262 // (else CEs with property "can move" / "not moving" are reset each frame)
5263 if (is_moving_before != is_moving_after ||
5264 direction != MovDir[x][y])
5265 ResetGfxAnimation(x, y);
5267 MovDir[x][y] = direction;
5268 GfxDir[x][y] = direction;
5270 GfxAction[x][y] = (!is_moving_after ? ACTION_WAITING :
5271 direction == MV_DOWN && CAN_FALL(element) ?
5272 ACTION_FALLING : ACTION_MOVING);
5274 // this is needed for CEs with property "can move" / "not moving"
5276 if (is_moving_after)
5278 if (Tile[newx][newy] == EL_EMPTY)
5279 Tile[newx][newy] = EL_BLOCKED;
5281 MovDir[newx][newy] = MovDir[x][y];
5283 CustomValue[newx][newy] = CustomValue[x][y];
5285 GfxFrame[newx][newy] = GfxFrame[x][y];
5286 GfxRandom[newx][newy] = GfxRandom[x][y];
5287 GfxAction[newx][newy] = GfxAction[x][y];
5288 GfxDir[newx][newy] = GfxDir[x][y];
5292 void Moving2Blocked(int x, int y, int *goes_to_x, int *goes_to_y)
5294 int direction = MovDir[x][y];
5295 int newx = x + (direction & MV_LEFT ? -1 : direction & MV_RIGHT ? +1 : 0);
5296 int newy = y + (direction & MV_UP ? -1 : direction & MV_DOWN ? +1 : 0);
5302 void Blocked2Moving(int x, int y, int *comes_from_x, int *comes_from_y)
5304 int oldx = x, oldy = y;
5305 int direction = MovDir[x][y];
5307 if (direction == MV_LEFT)
5309 else if (direction == MV_RIGHT)
5311 else if (direction == MV_UP)
5313 else if (direction == MV_DOWN)
5316 *comes_from_x = oldx;
5317 *comes_from_y = oldy;
5320 static int MovingOrBlocked2Element(int x, int y)
5322 int element = Tile[x][y];
5324 if (element == EL_BLOCKED)
5328 Blocked2Moving(x, y, &oldx, &oldy);
5329 return Tile[oldx][oldy];
5335 static int MovingOrBlocked2ElementIfNotLeaving(int x, int y)
5337 // like MovingOrBlocked2Element(), but if element is moving
5338 // and (x,y) is the field the moving element is just leaving,
5339 // return EL_BLOCKED instead of the element value
5340 int element = Tile[x][y];
5342 if (IS_MOVING(x, y))
5344 if (element == EL_BLOCKED)
5348 Blocked2Moving(x, y, &oldx, &oldy);
5349 return Tile[oldx][oldy];
5358 static void RemoveField(int x, int y)
5360 Tile[x][y] = EL_EMPTY;
5366 CustomValue[x][y] = 0;
5369 ChangeDelay[x][y] = 0;
5370 ChangePage[x][y] = -1;
5371 Pushed[x][y] = FALSE;
5373 GfxElement[x][y] = EL_UNDEFINED;
5374 GfxAction[x][y] = ACTION_DEFAULT;
5375 GfxDir[x][y] = MV_NONE;
5378 static void RemoveMovingField(int x, int y)
5380 int oldx = x, oldy = y, newx = x, newy = y;
5381 int element = Tile[x][y];
5382 int next_element = EL_UNDEFINED;
5384 if (element != EL_BLOCKED && !IS_MOVING(x, y))
5387 if (IS_MOVING(x, y))
5389 Moving2Blocked(x, y, &newx, &newy);
5391 if (Tile[newx][newy] != EL_BLOCKED)
5393 // element is moving, but target field is not free (blocked), but
5394 // already occupied by something different (example: acid pool);
5395 // in this case, only remove the moving field, but not the target
5397 RemoveField(oldx, oldy);
5399 Store[oldx][oldy] = Store2[oldx][oldy] = 0;
5401 TEST_DrawLevelField(oldx, oldy);
5406 else if (element == EL_BLOCKED)
5408 Blocked2Moving(x, y, &oldx, &oldy);
5409 if (!IS_MOVING(oldx, oldy))
5413 if (element == EL_BLOCKED &&
5414 (Tile[oldx][oldy] == EL_QUICKSAND_EMPTYING ||
5415 Tile[oldx][oldy] == EL_QUICKSAND_FAST_EMPTYING ||
5416 Tile[oldx][oldy] == EL_MAGIC_WALL_EMPTYING ||
5417 Tile[oldx][oldy] == EL_BD_MAGIC_WALL_EMPTYING ||
5418 Tile[oldx][oldy] == EL_DC_MAGIC_WALL_EMPTYING ||
5419 Tile[oldx][oldy] == EL_AMOEBA_DROPPING))
5420 next_element = get_next_element(Tile[oldx][oldy]);
5422 RemoveField(oldx, oldy);
5423 RemoveField(newx, newy);
5425 Store[oldx][oldy] = Store2[oldx][oldy] = 0;
5427 if (next_element != EL_UNDEFINED)
5428 Tile[oldx][oldy] = next_element;
5430 TEST_DrawLevelField(oldx, oldy);
5431 TEST_DrawLevelField(newx, newy);
5434 void DrawDynamite(int x, int y)
5436 int sx = SCREENX(x), sy = SCREENY(y);
5437 int graphic = el2img(Tile[x][y]);
5440 if (!IN_SCR_FIELD(sx, sy) || IS_PLAYER(x, y))
5443 if (IS_WALKABLE_INSIDE(Back[x][y]))
5447 DrawLevelElement(x, y, Back[x][y]);
5448 else if (Store[x][y])
5449 DrawLevelElement(x, y, Store[x][y]);
5450 else if (game.use_masked_elements)
5451 DrawLevelElement(x, y, EL_EMPTY);
5453 frame = getGraphicAnimationFrame(graphic, GfxFrame[x][y]);
5455 if (Back[x][y] || Store[x][y] || game.use_masked_elements)
5456 DrawGraphicThruMask(sx, sy, graphic, frame);
5458 DrawGraphic(sx, sy, graphic, frame);
5461 static void CheckDynamite(int x, int y)
5463 if (MovDelay[x][y] != 0) // dynamite is still waiting to explode
5467 if (MovDelay[x][y] != 0)
5470 PlayLevelSoundActionIfLoop(x, y, ACTION_ACTIVE);
5476 StopLevelSoundActionIfLoop(x, y, ACTION_ACTIVE);
5481 static void setMinimalPlayerBoundaries(int *sx1, int *sy1, int *sx2, int *sy2)
5483 boolean num_checked_players = 0;
5486 for (i = 0; i < MAX_PLAYERS; i++)
5488 if (stored_player[i].active)
5490 int sx = stored_player[i].jx;
5491 int sy = stored_player[i].jy;
5493 if (num_checked_players == 0)
5500 *sx1 = MIN(*sx1, sx);
5501 *sy1 = MIN(*sy1, sy);
5502 *sx2 = MAX(*sx2, sx);
5503 *sy2 = MAX(*sy2, sy);
5506 num_checked_players++;
5511 static boolean checkIfAllPlayersFitToScreen_RND(void)
5513 int sx1 = 0, sy1 = 0, sx2 = 0, sy2 = 0;
5515 setMinimalPlayerBoundaries(&sx1, &sy1, &sx2, &sy2);
5517 return (sx2 - sx1 < SCR_FIELDX &&
5518 sy2 - sy1 < SCR_FIELDY);
5521 static void setScreenCenteredToAllPlayers(int *sx, int *sy)
5523 int sx1 = scroll_x, sy1 = scroll_y, sx2 = scroll_x, sy2 = scroll_y;
5525 setMinimalPlayerBoundaries(&sx1, &sy1, &sx2, &sy2);
5527 *sx = (sx1 + sx2) / 2;
5528 *sy = (sy1 + sy2) / 2;
5531 static void DrawRelocateScreen(int old_x, int old_y, int x, int y, int move_dir,
5532 boolean center_screen, boolean quick_relocation)
5534 unsigned int frame_delay_value_old = GetVideoFrameDelay();
5535 boolean ffwd_delay = (tape.playing && tape.fast_forward);
5536 boolean no_delay = (tape.warp_forward);
5537 int frame_delay_value = (ffwd_delay ? FfwdFrameDelay : GameFrameDelay);
5538 int wait_delay_value = (no_delay ? 0 : frame_delay_value);
5539 int new_scroll_x, new_scroll_y;
5541 if (level.lazy_relocation && IN_VIS_FIELD(SCREENX(x), SCREENY(y)))
5543 // case 1: quick relocation inside visible screen (without scrolling)
5550 if (!level.shifted_relocation || center_screen)
5552 // relocation _with_ centering of screen
5554 new_scroll_x = SCROLL_POSITION_X(x);
5555 new_scroll_y = SCROLL_POSITION_Y(y);
5559 // relocation _without_ centering of screen
5561 int center_scroll_x = SCROLL_POSITION_X(old_x);
5562 int center_scroll_y = SCROLL_POSITION_Y(old_y);
5563 int offset_x = x + (scroll_x - center_scroll_x);
5564 int offset_y = y + (scroll_y - center_scroll_y);
5566 // for new screen position, apply previous offset to center position
5567 new_scroll_x = SCROLL_POSITION_X(offset_x);
5568 new_scroll_y = SCROLL_POSITION_Y(offset_y);
5571 if (quick_relocation)
5573 // case 2: quick relocation (redraw without visible scrolling)
5575 scroll_x = new_scroll_x;
5576 scroll_y = new_scroll_y;
5583 // case 3: visible relocation (with scrolling to new position)
5585 ScrollScreen(NULL, SCROLL_GO_ON); // scroll last frame to full tile
5587 SetVideoFrameDelay(wait_delay_value);
5589 while (scroll_x != new_scroll_x || scroll_y != new_scroll_y)
5591 int dx = (new_scroll_x < scroll_x ? +1 : new_scroll_x > scroll_x ? -1 : 0);
5592 int dy = (new_scroll_y < scroll_y ? +1 : new_scroll_y > scroll_y ? -1 : 0);
5594 if (dx == 0 && dy == 0) // no scrolling needed at all
5600 // set values for horizontal/vertical screen scrolling (half tile size)
5601 int dir_x = (dx != 0 ? MV_HORIZONTAL : 0);
5602 int dir_y = (dy != 0 ? MV_VERTICAL : 0);
5603 int pos_x = dx * TILEX / 2;
5604 int pos_y = dy * TILEY / 2;
5605 int fx = getFieldbufferOffsetX_RND(dir_x, pos_x);
5606 int fy = getFieldbufferOffsetY_RND(dir_y, pos_y);
5608 ScrollLevel(dx, dy);
5611 // scroll in two steps of half tile size to make things smoother
5612 BlitScreenToBitmapExt_RND(window, fx, fy);
5614 // scroll second step to align at full tile size
5615 BlitScreenToBitmap(window);
5621 SetVideoFrameDelay(frame_delay_value_old);
5624 static void RelocatePlayer(int jx, int jy, int el_player_raw)
5626 int el_player = GET_PLAYER_ELEMENT(el_player_raw);
5627 int player_nr = GET_PLAYER_NR(el_player);
5628 struct PlayerInfo *player = &stored_player[player_nr];
5629 boolean ffwd_delay = (tape.playing && tape.fast_forward);
5630 boolean no_delay = (tape.warp_forward);
5631 int frame_delay_value = (ffwd_delay ? FfwdFrameDelay : GameFrameDelay);
5632 int wait_delay_value = (no_delay ? 0 : frame_delay_value);
5633 int old_jx = player->jx;
5634 int old_jy = player->jy;
5635 int old_element = Tile[old_jx][old_jy];
5636 int element = Tile[jx][jy];
5637 boolean player_relocated = (old_jx != jx || old_jy != jy);
5639 int move_dir_horiz = (jx < old_jx ? MV_LEFT : jx > old_jx ? MV_RIGHT : 0);
5640 int move_dir_vert = (jy < old_jy ? MV_UP : jy > old_jy ? MV_DOWN : 0);
5641 int enter_side_horiz = MV_DIR_OPPOSITE(move_dir_horiz);
5642 int enter_side_vert = MV_DIR_OPPOSITE(move_dir_vert);
5643 int leave_side_horiz = move_dir_horiz;
5644 int leave_side_vert = move_dir_vert;
5645 int enter_side = enter_side_horiz | enter_side_vert;
5646 int leave_side = leave_side_horiz | leave_side_vert;
5648 if (player->buried) // do not reanimate dead player
5651 if (!player_relocated) // no need to relocate the player
5654 if (IS_PLAYER(jx, jy)) // player already placed at new position
5656 RemoveField(jx, jy); // temporarily remove newly placed player
5657 DrawLevelField(jx, jy);
5660 if (player->present)
5662 while (player->MovPos)
5664 ScrollPlayer(player, SCROLL_GO_ON);
5665 ScrollScreen(NULL, SCROLL_GO_ON);
5667 AdvanceFrameAndPlayerCounters(player->index_nr);
5671 BackToFront_WithFrameDelay(wait_delay_value);
5674 DrawPlayer(player); // needed here only to cleanup last field
5675 DrawLevelField(player->jx, player->jy); // remove player graphic
5677 player->is_moving = FALSE;
5680 if (IS_CUSTOM_ELEMENT(old_element))
5681 CheckElementChangeByPlayer(old_jx, old_jy, old_element,
5683 player->index_bit, leave_side);
5685 CheckTriggeredElementChangeByPlayer(old_jx, old_jy, old_element,
5687 player->index_bit, leave_side);
5689 Tile[jx][jy] = el_player;
5690 InitPlayerField(jx, jy, el_player, TRUE);
5692 /* "InitPlayerField()" above sets Tile[jx][jy] to EL_EMPTY, but it may be
5693 possible that the relocation target field did not contain a player element,
5694 but a walkable element, to which the new player was relocated -- in this
5695 case, restore that (already initialized!) element on the player field */
5696 if (!IS_PLAYER_ELEMENT(element)) // player may be set on walkable element
5698 Tile[jx][jy] = element; // restore previously existing element
5701 // only visually relocate centered player
5702 DrawRelocateScreen(old_jx, old_jy, player->jx, player->jy, player->MovDir,
5703 FALSE, level.instant_relocation);
5705 TestIfPlayerTouchesBadThing(jx, jy);
5706 TestIfPlayerTouchesCustomElement(jx, jy);
5708 if (IS_CUSTOM_ELEMENT(element))
5709 CheckElementChangeByPlayer(jx, jy, element, CE_ENTERED_BY_PLAYER,
5710 player->index_bit, enter_side);
5712 CheckTriggeredElementChangeByPlayer(jx, jy, element, CE_PLAYER_ENTERS_X,
5713 player->index_bit, enter_side);
5715 if (player->is_switching)
5717 /* ensure that relocation while still switching an element does not cause
5718 a new element to be treated as also switched directly after relocation
5719 (this is important for teleporter switches that teleport the player to
5720 a place where another teleporter switch is in the same direction, which
5721 would then incorrectly be treated as immediately switched before the
5722 direction key that caused the switch was released) */
5724 player->switch_x += jx - old_jx;
5725 player->switch_y += jy - old_jy;
5729 static void Explode(int ex, int ey, int phase, int mode)
5735 // !!! eliminate this variable !!!
5736 int delay = (game.emulation == EMU_SUPAPLEX ? 3 : 2);
5738 if (game.explosions_delayed)
5740 ExplodeField[ex][ey] = mode;
5744 if (phase == EX_PHASE_START) // initialize 'Store[][]' field
5746 int center_element = Tile[ex][ey];
5747 int artwork_element, explosion_element; // set these values later
5749 // remove things displayed in background while burning dynamite
5750 if (Back[ex][ey] != EL_EMPTY && !IS_INDESTRUCTIBLE(Back[ex][ey]))
5753 if (IS_MOVING(ex, ey) || IS_BLOCKED(ex, ey))
5755 // put moving element to center field (and let it explode there)
5756 center_element = MovingOrBlocked2Element(ex, ey);
5757 RemoveMovingField(ex, ey);
5758 Tile[ex][ey] = center_element;
5761 // now "center_element" is finally determined -- set related values now
5762 artwork_element = center_element; // for custom player artwork
5763 explosion_element = center_element; // for custom player artwork
5765 if (IS_PLAYER(ex, ey))
5767 int player_nr = GET_PLAYER_NR(StorePlayer[ex][ey]);
5769 artwork_element = stored_player[player_nr].artwork_element;
5771 if (level.use_explosion_element[player_nr])
5773 explosion_element = level.explosion_element[player_nr];
5774 artwork_element = explosion_element;
5778 if (mode == EX_TYPE_NORMAL ||
5779 mode == EX_TYPE_CENTER ||
5780 mode == EX_TYPE_CROSS)
5781 PlayLevelSoundElementAction(ex, ey, artwork_element, ACTION_EXPLODING);
5783 last_phase = element_info[explosion_element].explosion_delay + 1;
5785 for (y = ey - 1; y <= ey + 1; y++) for (x = ex - 1; x <= ex + 1; x++)
5787 int xx = x - ex + 1;
5788 int yy = y - ey + 1;
5791 if (!IN_LEV_FIELD(x, y) ||
5792 (mode & EX_TYPE_SINGLE_TILE && (x != ex || y != ey)) ||
5793 (mode == EX_TYPE_CROSS && (x != ex && y != ey)))
5796 element = Tile[x][y];
5798 if (IS_MOVING(x, y) || IS_BLOCKED(x, y))
5800 element = MovingOrBlocked2Element(x, y);
5802 if (!IS_EXPLOSION_PROOF(element))
5803 RemoveMovingField(x, y);
5806 // indestructible elements can only explode in center (but not flames)
5807 if ((IS_EXPLOSION_PROOF(element) && (x != ex || y != ey ||
5808 mode == EX_TYPE_BORDER)) ||
5809 element == EL_FLAMES)
5812 /* no idea why this was changed from 3.0.8 to 3.1.0 -- this causes buggy
5813 behaviour, for example when touching a yamyam that explodes to rocks
5814 with active deadly shield, a rock is created under the player !!! */
5815 // (case 1 (surely buggy): >= 3.1.0, case 2 (maybe buggy): <= 3.0.8)
5817 if (IS_PLAYER(x, y) && SHIELD_ON(PLAYERINFO(x, y)) &&
5818 (game.engine_version < VERSION_IDENT(3,1,0,0) ||
5819 (x == ex && y == ey && mode != EX_TYPE_BORDER)))
5821 if (IS_PLAYER(x, y) && SHIELD_ON(PLAYERINFO(x, y)))
5824 if (IS_ACTIVE_BOMB(element))
5826 // re-activate things under the bomb like gate or penguin
5827 Tile[x][y] = (Back[x][y] ? Back[x][y] : EL_EMPTY);
5834 // save walkable background elements while explosion on same tile
5835 if (IS_WALKABLE(element) && IS_INDESTRUCTIBLE(element) &&
5836 (x != ex || y != ey || mode == EX_TYPE_BORDER))
5837 Back[x][y] = element;
5839 // ignite explodable elements reached by other explosion
5840 if (element == EL_EXPLOSION)
5841 element = Store2[x][y];
5843 if (AmoebaNr[x][y] &&
5844 (element == EL_AMOEBA_FULL ||
5845 element == EL_BD_AMOEBA ||
5846 element == EL_AMOEBA_GROWING))
5848 AmoebaCnt[AmoebaNr[x][y]]--;
5849 AmoebaCnt2[AmoebaNr[x][y]]--;
5854 if (IS_PLAYER(ex, ey) && !PLAYER_EXPLOSION_PROTECTED(ex, ey))
5856 int player_nr = StorePlayer[ex][ey] - EL_PLAYER_1;
5858 Store[x][y] = EL_PLAYER_IS_EXPLODING_1 + player_nr;
5860 if (PLAYERINFO(ex, ey)->use_murphy)
5861 Store[x][y] = EL_EMPTY;
5864 // !!! check this case -- currently needed for rnd_rado_negundo_v,
5865 // !!! levels 015 018 019 020 021 022 023 026 027 028 !!!
5866 else if (IS_PLAYER_ELEMENT(center_element))
5867 Store[x][y] = EL_EMPTY;
5868 else if (center_element == EL_YAMYAM)
5869 Store[x][y] = level.yamyam_content[game.yamyam_content_nr].e[xx][yy];
5870 else if (element_info[center_element].content.e[xx][yy] != EL_EMPTY)
5871 Store[x][y] = element_info[center_element].content.e[xx][yy];
5873 // needed because EL_BD_BUTTERFLY is not defined as "CAN_EXPLODE"
5874 // (killing EL_BD_BUTTERFLY with dynamite would result in BD diamond
5875 // otherwise) -- FIX THIS !!!
5876 else if (!CAN_EXPLODE(element) && element != EL_BD_BUTTERFLY)
5877 Store[x][y] = element_info[element].content.e[1][1];
5879 else if (!CAN_EXPLODE(element))
5880 Store[x][y] = element_info[element].content.e[1][1];
5883 Store[x][y] = EL_EMPTY;
5885 if (x != ex || y != ey || mode == EX_TYPE_BORDER ||
5886 center_element == EL_AMOEBA_TO_DIAMOND)
5887 Store2[x][y] = element;
5889 Tile[x][y] = EL_EXPLOSION;
5890 GfxElement[x][y] = artwork_element;
5892 ExplodePhase[x][y] = 1;
5893 ExplodeDelay[x][y] = last_phase;
5898 if (center_element == EL_YAMYAM)
5899 game.yamyam_content_nr =
5900 (game.yamyam_content_nr + 1) % level.num_yamyam_contents;
5912 GfxFrame[x][y] = 0; // restart explosion animation
5914 last_phase = ExplodeDelay[x][y];
5916 ExplodePhase[x][y] = (phase < last_phase ? phase + 1 : 0);
5918 // this can happen if the player leaves an explosion just in time
5919 if (GfxElement[x][y] == EL_UNDEFINED)
5920 GfxElement[x][y] = EL_EMPTY;
5922 border_element = Store2[x][y];
5923 if (IS_PLAYER(x, y) && !PLAYER_EXPLOSION_PROTECTED(x, y))
5924 border_element = StorePlayer[x][y];
5926 if (phase == element_info[border_element].ignition_delay ||
5927 phase == last_phase)
5929 boolean border_explosion = FALSE;
5931 if (IS_PLAYER(x, y) && PLAYERINFO(x, y)->present &&
5932 !PLAYER_EXPLOSION_PROTECTED(x, y))
5934 KillPlayerUnlessExplosionProtected(x, y);
5935 border_explosion = TRUE;
5937 else if (CAN_EXPLODE_BY_EXPLOSION(border_element))
5939 Tile[x][y] = Store2[x][y];
5942 border_explosion = TRUE;
5944 else if (border_element == EL_AMOEBA_TO_DIAMOND)
5946 AmoebaToDiamond(x, y);
5948 border_explosion = TRUE;
5951 // if an element just explodes due to another explosion (chain-reaction),
5952 // do not immediately end the new explosion when it was the last frame of
5953 // the explosion (as it would be done in the following "if"-statement!)
5954 if (border_explosion && phase == last_phase)
5958 if (phase == last_phase)
5962 element = Tile[x][y] = Store[x][y];
5963 Store[x][y] = Store2[x][y] = 0;
5964 GfxElement[x][y] = EL_UNDEFINED;
5966 // player can escape from explosions and might therefore be still alive
5967 if (element >= EL_PLAYER_IS_EXPLODING_1 &&
5968 element <= EL_PLAYER_IS_EXPLODING_4)
5970 int player_nr = element - EL_PLAYER_IS_EXPLODING_1;
5971 int explosion_element = EL_PLAYER_1 + player_nr;
5972 int xx = MIN(MAX(0, x - stored_player[player_nr].jx + 1), 2);
5973 int yy = MIN(MAX(0, y - stored_player[player_nr].jy + 1), 2);
5975 if (level.use_explosion_element[player_nr])
5976 explosion_element = level.explosion_element[player_nr];
5978 Tile[x][y] = (stored_player[player_nr].active ? EL_EMPTY :
5979 element_info[explosion_element].content.e[xx][yy]);
5982 // restore probably existing indestructible background element
5983 if (Back[x][y] && IS_INDESTRUCTIBLE(Back[x][y]))
5984 element = Tile[x][y] = Back[x][y];
5987 MovDir[x][y] = MovPos[x][y] = MovDelay[x][y] = 0;
5988 GfxDir[x][y] = MV_NONE;
5989 ChangeDelay[x][y] = 0;
5990 ChangePage[x][y] = -1;
5992 CustomValue[x][y] = 0;
5994 InitField_WithBug2(x, y, FALSE);
5996 TEST_DrawLevelField(x, y);
5998 TestIfElementTouchesCustomElement(x, y);
6000 if (GFX_CRUMBLED(element))
6001 TEST_DrawLevelFieldCrumbledNeighbours(x, y);
6003 if (IS_PLAYER(x, y) && !PLAYERINFO(x, y)->present)
6004 StorePlayer[x][y] = 0;
6006 if (IS_PLAYER_ELEMENT(element))
6007 RelocatePlayer(x, y, element);
6009 else if (IN_SCR_FIELD(SCREENX(x), SCREENY(y)))
6011 int graphic = el_act2img(GfxElement[x][y], ACTION_EXPLODING);
6012 int frame = getGraphicAnimationFrame(graphic, GfxFrame[x][y]);
6015 TEST_DrawLevelFieldCrumbled(x, y);
6017 if (IS_WALKABLE_OVER(Back[x][y]) && Back[x][y] != EL_EMPTY)
6019 DrawLevelElement(x, y, Back[x][y]);
6020 DrawGraphicThruMask(SCREENX(x), SCREENY(y), graphic, frame);
6022 else if (IS_WALKABLE_UNDER(Back[x][y]))
6024 DrawGraphic(SCREENX(x), SCREENY(y), graphic, frame);
6025 DrawLevelElementThruMask(x, y, Back[x][y]);
6027 else if (!IS_WALKABLE_INSIDE(Back[x][y]))
6028 DrawScreenGraphic(SCREENX(x), SCREENY(y), graphic, frame);
6032 static void DynaExplode(int ex, int ey)
6035 int dynabomb_element = Tile[ex][ey];
6036 int dynabomb_size = 1;
6037 boolean dynabomb_xl = FALSE;
6038 struct PlayerInfo *player;
6039 static int xy[4][2] =
6047 if (IS_ACTIVE_BOMB(dynabomb_element))
6049 player = &stored_player[dynabomb_element - EL_DYNABOMB_PLAYER_1_ACTIVE];
6050 dynabomb_size = player->dynabomb_size;
6051 dynabomb_xl = player->dynabomb_xl;
6052 player->dynabombs_left++;
6055 Explode(ex, ey, EX_PHASE_START, EX_TYPE_CENTER);
6057 for (i = 0; i < NUM_DIRECTIONS; i++)
6059 for (j = 1; j <= dynabomb_size; j++)
6061 int x = ex + j * xy[i][0];
6062 int y = ey + j * xy[i][1];
6065 if (!IN_LEV_FIELD(x, y) || IS_INDESTRUCTIBLE(Tile[x][y]))
6068 element = Tile[x][y];
6070 // do not restart explosions of fields with active bombs
6071 if (element == EL_EXPLOSION && IS_ACTIVE_BOMB(Store2[x][y]))
6074 Explode(x, y, EX_PHASE_START, EX_TYPE_BORDER);
6076 if (element != EL_EMPTY && element != EL_EXPLOSION &&
6077 !IS_DIGGABLE(element) && !dynabomb_xl)
6083 void Bang(int x, int y)
6085 int element = MovingOrBlocked2Element(x, y);
6086 int explosion_type = EX_TYPE_NORMAL;
6088 if (IS_PLAYER(x, y) && !PLAYER_EXPLOSION_PROTECTED(x, y))
6090 struct PlayerInfo *player = PLAYERINFO(x, y);
6092 element = Tile[x][y] = player->initial_element;
6094 if (level.use_explosion_element[player->index_nr])
6096 int explosion_element = level.explosion_element[player->index_nr];
6098 if (element_info[explosion_element].explosion_type == EXPLODES_CROSS)
6099 explosion_type = EX_TYPE_CROSS;
6100 else if (element_info[explosion_element].explosion_type == EXPLODES_1X1)
6101 explosion_type = EX_TYPE_CENTER;
6109 case EL_BD_BUTTERFLY:
6112 case EL_DARK_YAMYAM:
6116 RaiseScoreElement(element);
6119 case EL_DYNABOMB_PLAYER_1_ACTIVE:
6120 case EL_DYNABOMB_PLAYER_2_ACTIVE:
6121 case EL_DYNABOMB_PLAYER_3_ACTIVE:
6122 case EL_DYNABOMB_PLAYER_4_ACTIVE:
6123 case EL_DYNABOMB_INCREASE_NUMBER:
6124 case EL_DYNABOMB_INCREASE_SIZE:
6125 case EL_DYNABOMB_INCREASE_POWER:
6126 explosion_type = EX_TYPE_DYNA;
6129 case EL_DC_LANDMINE:
6130 explosion_type = EX_TYPE_CENTER;
6135 case EL_LAMP_ACTIVE:
6136 case EL_AMOEBA_TO_DIAMOND:
6137 if (!IS_PLAYER(x, y)) // penguin and player may be at same field
6138 explosion_type = EX_TYPE_CENTER;
6142 if (element_info[element].explosion_type == EXPLODES_CROSS)
6143 explosion_type = EX_TYPE_CROSS;
6144 else if (element_info[element].explosion_type == EXPLODES_1X1)
6145 explosion_type = EX_TYPE_CENTER;
6149 if (explosion_type == EX_TYPE_DYNA)
6152 Explode(x, y, EX_PHASE_START, explosion_type);
6154 CheckTriggeredElementChange(x, y, element, CE_EXPLOSION_OF_X);
6157 static void SplashAcid(int x, int y)
6159 if (IN_LEV_FIELD(x - 1, y - 1) && IS_FREE(x - 1, y - 1) &&
6160 (!IN_LEV_FIELD(x - 1, y - 2) ||
6161 !CAN_FALL(MovingOrBlocked2Element(x - 1, y - 2))))
6162 Tile[x - 1][y - 1] = EL_ACID_SPLASH_LEFT;
6164 if (IN_LEV_FIELD(x + 1, y - 1) && IS_FREE(x + 1, y - 1) &&
6165 (!IN_LEV_FIELD(x + 1, y - 2) ||
6166 !CAN_FALL(MovingOrBlocked2Element(x + 1, y - 2))))
6167 Tile[x + 1][y - 1] = EL_ACID_SPLASH_RIGHT;
6169 PlayLevelSound(x, y, SND_ACID_SPLASHING);
6172 static void InitBeltMovement(void)
6174 static int belt_base_element[4] =
6176 EL_CONVEYOR_BELT_1_LEFT,
6177 EL_CONVEYOR_BELT_2_LEFT,
6178 EL_CONVEYOR_BELT_3_LEFT,
6179 EL_CONVEYOR_BELT_4_LEFT
6181 static int belt_base_active_element[4] =
6183 EL_CONVEYOR_BELT_1_LEFT_ACTIVE,
6184 EL_CONVEYOR_BELT_2_LEFT_ACTIVE,
6185 EL_CONVEYOR_BELT_3_LEFT_ACTIVE,
6186 EL_CONVEYOR_BELT_4_LEFT_ACTIVE
6191 // set frame order for belt animation graphic according to belt direction
6192 for (i = 0; i < NUM_BELTS; i++)
6196 for (j = 0; j < NUM_BELT_PARTS; j++)
6198 int element = belt_base_active_element[belt_nr] + j;
6199 int graphic_1 = el2img(element);
6200 int graphic_2 = el2panelimg(element);
6202 if (game.belt_dir[i] == MV_LEFT)
6204 graphic_info[graphic_1].anim_mode &= ~ANIM_REVERSE;
6205 graphic_info[graphic_2].anim_mode &= ~ANIM_REVERSE;
6209 graphic_info[graphic_1].anim_mode |= ANIM_REVERSE;
6210 graphic_info[graphic_2].anim_mode |= ANIM_REVERSE;
6215 SCAN_PLAYFIELD(x, y)
6217 int element = Tile[x][y];
6219 for (i = 0; i < NUM_BELTS; i++)
6221 if (IS_BELT(element) && game.belt_dir[i] != MV_NONE)
6223 int e_belt_nr = getBeltNrFromBeltElement(element);
6226 if (e_belt_nr == belt_nr)
6228 int belt_part = Tile[x][y] - belt_base_element[belt_nr];
6230 Tile[x][y] = belt_base_active_element[belt_nr] + belt_part;
6237 static void ToggleBeltSwitch(int x, int y)
6239 static int belt_base_element[4] =
6241 EL_CONVEYOR_BELT_1_LEFT,
6242 EL_CONVEYOR_BELT_2_LEFT,
6243 EL_CONVEYOR_BELT_3_LEFT,
6244 EL_CONVEYOR_BELT_4_LEFT
6246 static int belt_base_active_element[4] =
6248 EL_CONVEYOR_BELT_1_LEFT_ACTIVE,
6249 EL_CONVEYOR_BELT_2_LEFT_ACTIVE,
6250 EL_CONVEYOR_BELT_3_LEFT_ACTIVE,
6251 EL_CONVEYOR_BELT_4_LEFT_ACTIVE
6253 static int belt_base_switch_element[4] =
6255 EL_CONVEYOR_BELT_1_SWITCH_LEFT,
6256 EL_CONVEYOR_BELT_2_SWITCH_LEFT,
6257 EL_CONVEYOR_BELT_3_SWITCH_LEFT,
6258 EL_CONVEYOR_BELT_4_SWITCH_LEFT
6260 static int belt_move_dir[4] =
6268 int element = Tile[x][y];
6269 int belt_nr = getBeltNrFromBeltSwitchElement(element);
6270 int belt_dir_nr = (game.belt_dir_nr[belt_nr] + 1) % 4;
6271 int belt_dir = belt_move_dir[belt_dir_nr];
6274 if (!IS_BELT_SWITCH(element))
6277 game.belt_dir_nr[belt_nr] = belt_dir_nr;
6278 game.belt_dir[belt_nr] = belt_dir;
6280 if (belt_dir_nr == 3)
6283 // set frame order for belt animation graphic according to belt direction
6284 for (i = 0; i < NUM_BELT_PARTS; i++)
6286 int element = belt_base_active_element[belt_nr] + i;
6287 int graphic_1 = el2img(element);
6288 int graphic_2 = el2panelimg(element);
6290 if (belt_dir == MV_LEFT)
6292 graphic_info[graphic_1].anim_mode &= ~ANIM_REVERSE;
6293 graphic_info[graphic_2].anim_mode &= ~ANIM_REVERSE;
6297 graphic_info[graphic_1].anim_mode |= ANIM_REVERSE;
6298 graphic_info[graphic_2].anim_mode |= ANIM_REVERSE;
6302 SCAN_PLAYFIELD(xx, yy)
6304 int element = Tile[xx][yy];
6306 if (IS_BELT_SWITCH(element))
6308 int e_belt_nr = getBeltNrFromBeltSwitchElement(element);
6310 if (e_belt_nr == belt_nr)
6312 Tile[xx][yy] = belt_base_switch_element[belt_nr] + belt_dir_nr;
6313 TEST_DrawLevelField(xx, yy);
6316 else if (IS_BELT(element) && belt_dir != MV_NONE)
6318 int e_belt_nr = getBeltNrFromBeltElement(element);
6320 if (e_belt_nr == belt_nr)
6322 int belt_part = Tile[xx][yy] - belt_base_element[belt_nr];
6324 Tile[xx][yy] = belt_base_active_element[belt_nr] + belt_part;
6325 TEST_DrawLevelField(xx, yy);
6328 else if (IS_BELT_ACTIVE(element) && belt_dir == MV_NONE)
6330 int e_belt_nr = getBeltNrFromBeltActiveElement(element);
6332 if (e_belt_nr == belt_nr)
6334 int belt_part = Tile[xx][yy] - belt_base_active_element[belt_nr];
6336 Tile[xx][yy] = belt_base_element[belt_nr] + belt_part;
6337 TEST_DrawLevelField(xx, yy);
6343 static void ToggleSwitchgateSwitch(int x, int y)
6347 game.switchgate_pos = !game.switchgate_pos;
6349 SCAN_PLAYFIELD(xx, yy)
6351 int element = Tile[xx][yy];
6353 if (element == EL_SWITCHGATE_SWITCH_UP)
6355 Tile[xx][yy] = EL_SWITCHGATE_SWITCH_DOWN;
6356 TEST_DrawLevelField(xx, yy);
6358 else if (element == EL_SWITCHGATE_SWITCH_DOWN)
6360 Tile[xx][yy] = EL_SWITCHGATE_SWITCH_UP;
6361 TEST_DrawLevelField(xx, yy);
6363 else if (element == EL_DC_SWITCHGATE_SWITCH_UP)
6365 Tile[xx][yy] = EL_DC_SWITCHGATE_SWITCH_DOWN;
6366 TEST_DrawLevelField(xx, yy);
6368 else if (element == EL_DC_SWITCHGATE_SWITCH_DOWN)
6370 Tile[xx][yy] = EL_DC_SWITCHGATE_SWITCH_UP;
6371 TEST_DrawLevelField(xx, yy);
6373 else if (element == EL_SWITCHGATE_OPEN ||
6374 element == EL_SWITCHGATE_OPENING)
6376 Tile[xx][yy] = EL_SWITCHGATE_CLOSING;
6378 PlayLevelSoundAction(xx, yy, ACTION_CLOSING);
6380 else if (element == EL_SWITCHGATE_CLOSED ||
6381 element == EL_SWITCHGATE_CLOSING)
6383 Tile[xx][yy] = EL_SWITCHGATE_OPENING;
6385 PlayLevelSoundAction(xx, yy, ACTION_OPENING);
6390 static int getInvisibleActiveFromInvisibleElement(int element)
6392 return (element == EL_INVISIBLE_STEELWALL ? EL_INVISIBLE_STEELWALL_ACTIVE :
6393 element == EL_INVISIBLE_WALL ? EL_INVISIBLE_WALL_ACTIVE :
6394 element == EL_INVISIBLE_SAND ? EL_INVISIBLE_SAND_ACTIVE :
6398 static int getInvisibleFromInvisibleActiveElement(int element)
6400 return (element == EL_INVISIBLE_STEELWALL_ACTIVE ? EL_INVISIBLE_STEELWALL :
6401 element == EL_INVISIBLE_WALL_ACTIVE ? EL_INVISIBLE_WALL :
6402 element == EL_INVISIBLE_SAND_ACTIVE ? EL_INVISIBLE_SAND :
6406 static void RedrawAllLightSwitchesAndInvisibleElements(void)
6410 SCAN_PLAYFIELD(x, y)
6412 int element = Tile[x][y];
6414 if (element == EL_LIGHT_SWITCH &&
6415 game.light_time_left > 0)
6417 Tile[x][y] = EL_LIGHT_SWITCH_ACTIVE;
6418 TEST_DrawLevelField(x, y);
6420 else if (element == EL_LIGHT_SWITCH_ACTIVE &&
6421 game.light_time_left == 0)
6423 Tile[x][y] = EL_LIGHT_SWITCH;
6424 TEST_DrawLevelField(x, y);
6426 else if (element == EL_EMC_DRIPPER &&
6427 game.light_time_left > 0)
6429 Tile[x][y] = EL_EMC_DRIPPER_ACTIVE;
6430 TEST_DrawLevelField(x, y);
6432 else if (element == EL_EMC_DRIPPER_ACTIVE &&
6433 game.light_time_left == 0)
6435 Tile[x][y] = EL_EMC_DRIPPER;
6436 TEST_DrawLevelField(x, y);
6438 else if (element == EL_INVISIBLE_STEELWALL ||
6439 element == EL_INVISIBLE_WALL ||
6440 element == EL_INVISIBLE_SAND)
6442 if (game.light_time_left > 0)
6443 Tile[x][y] = getInvisibleActiveFromInvisibleElement(element);
6445 TEST_DrawLevelField(x, y);
6447 // uncrumble neighbour fields, if needed
6448 if (element == EL_INVISIBLE_SAND)
6449 TEST_DrawLevelFieldCrumbledNeighbours(x, y);
6451 else if (element == EL_INVISIBLE_STEELWALL_ACTIVE ||
6452 element == EL_INVISIBLE_WALL_ACTIVE ||
6453 element == EL_INVISIBLE_SAND_ACTIVE)
6455 if (game.light_time_left == 0)
6456 Tile[x][y] = getInvisibleFromInvisibleActiveElement(element);
6458 TEST_DrawLevelField(x, y);
6460 // re-crumble neighbour fields, if needed
6461 if (element == EL_INVISIBLE_SAND)
6462 TEST_DrawLevelFieldCrumbledNeighbours(x, y);
6467 static void RedrawAllInvisibleElementsForLenses(void)
6471 SCAN_PLAYFIELD(x, y)
6473 int element = Tile[x][y];
6475 if (element == EL_EMC_DRIPPER &&
6476 game.lenses_time_left > 0)
6478 Tile[x][y] = EL_EMC_DRIPPER_ACTIVE;
6479 TEST_DrawLevelField(x, y);
6481 else if (element == EL_EMC_DRIPPER_ACTIVE &&
6482 game.lenses_time_left == 0)
6484 Tile[x][y] = EL_EMC_DRIPPER;
6485 TEST_DrawLevelField(x, y);
6487 else if (element == EL_INVISIBLE_STEELWALL ||
6488 element == EL_INVISIBLE_WALL ||
6489 element == EL_INVISIBLE_SAND)
6491 if (game.lenses_time_left > 0)
6492 Tile[x][y] = getInvisibleActiveFromInvisibleElement(element);
6494 TEST_DrawLevelField(x, y);
6496 // uncrumble neighbour fields, if needed
6497 if (element == EL_INVISIBLE_SAND)
6498 TEST_DrawLevelFieldCrumbledNeighbours(x, y);
6500 else if (element == EL_INVISIBLE_STEELWALL_ACTIVE ||
6501 element == EL_INVISIBLE_WALL_ACTIVE ||
6502 element == EL_INVISIBLE_SAND_ACTIVE)
6504 if (game.lenses_time_left == 0)
6505 Tile[x][y] = getInvisibleFromInvisibleActiveElement(element);
6507 TEST_DrawLevelField(x, y);
6509 // re-crumble neighbour fields, if needed
6510 if (element == EL_INVISIBLE_SAND)
6511 TEST_DrawLevelFieldCrumbledNeighbours(x, y);
6516 static void RedrawAllInvisibleElementsForMagnifier(void)
6520 SCAN_PLAYFIELD(x, y)
6522 int element = Tile[x][y];
6524 if (element == EL_EMC_FAKE_GRASS &&
6525 game.magnify_time_left > 0)
6527 Tile[x][y] = EL_EMC_FAKE_GRASS_ACTIVE;
6528 TEST_DrawLevelField(x, y);
6530 else if (element == EL_EMC_FAKE_GRASS_ACTIVE &&
6531 game.magnify_time_left == 0)
6533 Tile[x][y] = EL_EMC_FAKE_GRASS;
6534 TEST_DrawLevelField(x, y);
6536 else if (IS_GATE_GRAY(element) &&
6537 game.magnify_time_left > 0)
6539 Tile[x][y] = (IS_RND_GATE_GRAY(element) ?
6540 element - EL_GATE_1_GRAY + EL_GATE_1_GRAY_ACTIVE :
6541 IS_EM_GATE_GRAY(element) ?
6542 element - EL_EM_GATE_1_GRAY + EL_EM_GATE_1_GRAY_ACTIVE :
6543 IS_EMC_GATE_GRAY(element) ?
6544 element - EL_EMC_GATE_5_GRAY + EL_EMC_GATE_5_GRAY_ACTIVE :
6545 IS_DC_GATE_GRAY(element) ?
6546 EL_DC_GATE_WHITE_GRAY_ACTIVE :
6548 TEST_DrawLevelField(x, y);
6550 else if (IS_GATE_GRAY_ACTIVE(element) &&
6551 game.magnify_time_left == 0)
6553 Tile[x][y] = (IS_RND_GATE_GRAY_ACTIVE(element) ?
6554 element - EL_GATE_1_GRAY_ACTIVE + EL_GATE_1_GRAY :
6555 IS_EM_GATE_GRAY_ACTIVE(element) ?
6556 element - EL_EM_GATE_1_GRAY_ACTIVE + EL_EM_GATE_1_GRAY :
6557 IS_EMC_GATE_GRAY_ACTIVE(element) ?
6558 element - EL_EMC_GATE_5_GRAY_ACTIVE + EL_EMC_GATE_5_GRAY :
6559 IS_DC_GATE_GRAY_ACTIVE(element) ?
6560 EL_DC_GATE_WHITE_GRAY :
6562 TEST_DrawLevelField(x, y);
6567 static void ToggleLightSwitch(int x, int y)
6569 int element = Tile[x][y];
6571 game.light_time_left =
6572 (element == EL_LIGHT_SWITCH ?
6573 level.time_light * FRAMES_PER_SECOND : 0);
6575 RedrawAllLightSwitchesAndInvisibleElements();
6578 static void ActivateTimegateSwitch(int x, int y)
6582 game.timegate_time_left = level.time_timegate * FRAMES_PER_SECOND;
6584 SCAN_PLAYFIELD(xx, yy)
6586 int element = Tile[xx][yy];
6588 if (element == EL_TIMEGATE_CLOSED ||
6589 element == EL_TIMEGATE_CLOSING)
6591 Tile[xx][yy] = EL_TIMEGATE_OPENING;
6592 PlayLevelSound(xx, yy, SND_CLASS_TIMEGATE_OPENING);
6596 else if (element == EL_TIMEGATE_SWITCH_ACTIVE)
6598 Tile[xx][yy] = EL_TIMEGATE_SWITCH;
6599 TEST_DrawLevelField(xx, yy);
6605 Tile[x][y] = (Tile[x][y] == EL_TIMEGATE_SWITCH ? EL_TIMEGATE_SWITCH_ACTIVE :
6606 EL_DC_TIMEGATE_SWITCH_ACTIVE);
6609 static void Impact(int x, int y)
6611 boolean last_line = (y == lev_fieldy - 1);
6612 boolean object_hit = FALSE;
6613 boolean impact = (last_line || object_hit);
6614 int element = Tile[x][y];
6615 int smashed = EL_STEELWALL;
6617 if (!last_line) // check if element below was hit
6619 if (Tile[x][y + 1] == EL_PLAYER_IS_LEAVING)
6622 object_hit = (!IS_FREE(x, y + 1) && (!IS_MOVING(x, y + 1) ||
6623 MovDir[x][y + 1] != MV_DOWN ||
6624 MovPos[x][y + 1] <= TILEY / 2));
6626 // do not smash moving elements that left the smashed field in time
6627 if (game.engine_version >= VERSION_IDENT(2,2,0,7) && IS_MOVING(x, y + 1) &&
6628 ABS(MovPos[x][y + 1] + getElementMoveStepsize(x, y + 1)) >= TILEX)
6631 #if USE_QUICKSAND_IMPACT_BUGFIX
6632 if (Tile[x][y + 1] == EL_QUICKSAND_EMPTYING && object_hit == FALSE)
6634 RemoveMovingField(x, y + 1);
6635 Tile[x][y + 1] = EL_QUICKSAND_EMPTY;
6636 Tile[x][y + 2] = EL_ROCK;
6637 TEST_DrawLevelField(x, y + 2);
6642 if (Tile[x][y + 1] == EL_QUICKSAND_FAST_EMPTYING && object_hit == FALSE)
6644 RemoveMovingField(x, y + 1);
6645 Tile[x][y + 1] = EL_QUICKSAND_FAST_EMPTY;
6646 Tile[x][y + 2] = EL_ROCK;
6647 TEST_DrawLevelField(x, y + 2);
6654 smashed = MovingOrBlocked2Element(x, y + 1);
6656 impact = (last_line || object_hit);
6659 if (!last_line && smashed == EL_ACID) // element falls into acid
6661 SplashAcid(x, y + 1);
6665 // !!! not sufficient for all cases -- see EL_PEARL below !!!
6666 // only reset graphic animation if graphic really changes after impact
6668 el_act_dir2img(element, GfxAction[x][y], MV_DOWN) != el2img(element))
6670 ResetGfxAnimation(x, y);
6671 TEST_DrawLevelField(x, y);
6674 if (impact && CAN_EXPLODE_IMPACT(element))
6679 else if (impact && element == EL_PEARL &&
6680 smashed != EL_DC_MAGIC_WALL && smashed != EL_DC_MAGIC_WALL_ACTIVE)
6682 ResetGfxAnimation(x, y);
6684 Tile[x][y] = EL_PEARL_BREAKING;
6685 PlayLevelSound(x, y, SND_PEARL_BREAKING);
6688 else if (impact && CheckElementChange(x, y, element, smashed, CE_IMPACT))
6690 PlayLevelSoundElementAction(x, y, element, ACTION_IMPACT);
6695 if (impact && element == EL_AMOEBA_DROP)
6697 if (object_hit && IS_PLAYER(x, y + 1))
6698 KillPlayerUnlessEnemyProtected(x, y + 1);
6699 else if (object_hit && smashed == EL_PENGUIN)
6703 Tile[x][y] = EL_AMOEBA_GROWING;
6704 Store[x][y] = EL_AMOEBA_WET;
6706 ResetRandomAnimationValue(x, y);
6711 if (object_hit) // check which object was hit
6713 if ((CAN_PASS_MAGIC_WALL(element) &&
6714 (smashed == EL_MAGIC_WALL ||
6715 smashed == EL_BD_MAGIC_WALL)) ||
6716 (CAN_PASS_DC_MAGIC_WALL(element) &&
6717 smashed == EL_DC_MAGIC_WALL))
6720 int activated_magic_wall =
6721 (smashed == EL_MAGIC_WALL ? EL_MAGIC_WALL_ACTIVE :
6722 smashed == EL_BD_MAGIC_WALL ? EL_BD_MAGIC_WALL_ACTIVE :
6723 EL_DC_MAGIC_WALL_ACTIVE);
6725 // activate magic wall / mill
6726 SCAN_PLAYFIELD(xx, yy)
6728 if (Tile[xx][yy] == smashed)
6729 Tile[xx][yy] = activated_magic_wall;
6732 game.magic_wall_time_left = level.time_magic_wall * FRAMES_PER_SECOND;
6733 game.magic_wall_active = TRUE;
6735 PlayLevelSound(x, y, (smashed == EL_MAGIC_WALL ?
6736 SND_MAGIC_WALL_ACTIVATING :
6737 smashed == EL_BD_MAGIC_WALL ?
6738 SND_BD_MAGIC_WALL_ACTIVATING :
6739 SND_DC_MAGIC_WALL_ACTIVATING));
6742 if (IS_PLAYER(x, y + 1))
6744 if (CAN_SMASH_PLAYER(element))
6746 KillPlayerUnlessEnemyProtected(x, y + 1);
6750 else if (smashed == EL_PENGUIN)
6752 if (CAN_SMASH_PLAYER(element))
6758 else if (element == EL_BD_DIAMOND)
6760 if (IS_CLASSIC_ENEMY(smashed) && IS_BD_ELEMENT(smashed))
6766 else if (((element == EL_SP_INFOTRON ||
6767 element == EL_SP_ZONK) &&
6768 (smashed == EL_SP_SNIKSNAK ||
6769 smashed == EL_SP_ELECTRON ||
6770 smashed == EL_SP_DISK_ORANGE)) ||
6771 (element == EL_SP_INFOTRON &&
6772 smashed == EL_SP_DISK_YELLOW))
6777 else if (CAN_SMASH_EVERYTHING(element))
6779 if (IS_CLASSIC_ENEMY(smashed) ||
6780 CAN_EXPLODE_SMASHED(smashed))
6785 else if (!IS_MOVING(x, y + 1) && !IS_BLOCKED(x, y + 1))
6787 if (smashed == EL_LAMP ||
6788 smashed == EL_LAMP_ACTIVE)
6793 else if (smashed == EL_NUT)
6795 Tile[x][y + 1] = EL_NUT_BREAKING;
6796 PlayLevelSound(x, y, SND_NUT_BREAKING);
6797 RaiseScoreElement(EL_NUT);
6800 else if (smashed == EL_PEARL)
6802 ResetGfxAnimation(x, y);
6804 Tile[x][y + 1] = EL_PEARL_BREAKING;
6805 PlayLevelSound(x, y, SND_PEARL_BREAKING);
6808 else if (smashed == EL_DIAMOND)
6810 Tile[x][y + 1] = EL_DIAMOND_BREAKING;
6811 PlayLevelSound(x, y, SND_DIAMOND_BREAKING);
6814 else if (IS_BELT_SWITCH(smashed))
6816 ToggleBeltSwitch(x, y + 1);
6818 else if (smashed == EL_SWITCHGATE_SWITCH_UP ||
6819 smashed == EL_SWITCHGATE_SWITCH_DOWN ||
6820 smashed == EL_DC_SWITCHGATE_SWITCH_UP ||
6821 smashed == EL_DC_SWITCHGATE_SWITCH_DOWN)
6823 ToggleSwitchgateSwitch(x, y + 1);
6825 else if (smashed == EL_LIGHT_SWITCH ||
6826 smashed == EL_LIGHT_SWITCH_ACTIVE)
6828 ToggleLightSwitch(x, y + 1);
6832 CheckElementChange(x, y + 1, smashed, element, CE_SMASHED);
6834 CheckElementChangeBySide(x, y + 1, smashed, element,
6835 CE_SWITCHED, CH_SIDE_TOP);
6836 CheckTriggeredElementChangeBySide(x, y + 1, smashed, CE_SWITCH_OF_X,
6842 CheckElementChange(x, y + 1, smashed, element, CE_SMASHED);
6847 // play sound of magic wall / mill
6849 (Tile[x][y + 1] == EL_MAGIC_WALL_ACTIVE ||
6850 Tile[x][y + 1] == EL_BD_MAGIC_WALL_ACTIVE ||
6851 Tile[x][y + 1] == EL_DC_MAGIC_WALL_ACTIVE))
6853 if (Tile[x][y + 1] == EL_MAGIC_WALL_ACTIVE)
6854 PlayLevelSound(x, y, SND_MAGIC_WALL_FILLING);
6855 else if (Tile[x][y + 1] == EL_BD_MAGIC_WALL_ACTIVE)
6856 PlayLevelSound(x, y, SND_BD_MAGIC_WALL_FILLING);
6857 else if (Tile[x][y + 1] == EL_DC_MAGIC_WALL_ACTIVE)
6858 PlayLevelSound(x, y, SND_DC_MAGIC_WALL_FILLING);
6863 // play sound of object that hits the ground
6864 if (last_line || object_hit)
6865 PlayLevelSoundElementAction(x, y, element, ACTION_IMPACT);
6868 static void TurnRoundExt(int x, int y)
6880 { 0, 0 }, { 0, 0 }, { 0, 0 },
6885 int left, right, back;
6889 { MV_DOWN, MV_UP, MV_RIGHT },
6890 { MV_UP, MV_DOWN, MV_LEFT },
6892 { MV_LEFT, MV_RIGHT, MV_DOWN },
6896 { MV_RIGHT, MV_LEFT, MV_UP }
6899 int element = Tile[x][y];
6900 int move_pattern = element_info[element].move_pattern;
6902 int old_move_dir = MovDir[x][y];
6903 int left_dir = turn[old_move_dir].left;
6904 int right_dir = turn[old_move_dir].right;
6905 int back_dir = turn[old_move_dir].back;
6907 int left_dx = move_xy[left_dir].dx, left_dy = move_xy[left_dir].dy;
6908 int right_dx = move_xy[right_dir].dx, right_dy = move_xy[right_dir].dy;
6909 int move_dx = move_xy[old_move_dir].dx, move_dy = move_xy[old_move_dir].dy;
6910 int back_dx = move_xy[back_dir].dx, back_dy = move_xy[back_dir].dy;
6912 int left_x = x + left_dx, left_y = y + left_dy;
6913 int right_x = x + right_dx, right_y = y + right_dy;
6914 int move_x = x + move_dx, move_y = y + move_dy;
6918 if (element == EL_BUG || element == EL_BD_BUTTERFLY)
6920 TestIfBadThingTouchesOtherBadThing(x, y);
6922 if (ENEMY_CAN_ENTER_FIELD(element, right_x, right_y))
6923 MovDir[x][y] = right_dir;
6924 else if (!ENEMY_CAN_ENTER_FIELD(element, move_x, move_y))
6925 MovDir[x][y] = left_dir;
6927 if (element == EL_BUG && MovDir[x][y] != old_move_dir)
6929 else if (element == EL_BD_BUTTERFLY) // && MovDir[x][y] == left_dir)
6932 else if (element == EL_SPACESHIP || element == EL_BD_FIREFLY)
6934 TestIfBadThingTouchesOtherBadThing(x, y);
6936 if (ENEMY_CAN_ENTER_FIELD(element, left_x, left_y))
6937 MovDir[x][y] = left_dir;
6938 else if (!ENEMY_CAN_ENTER_FIELD(element, move_x, move_y))
6939 MovDir[x][y] = right_dir;
6941 if (element == EL_SPACESHIP && MovDir[x][y] != old_move_dir)
6943 else if (element == EL_BD_FIREFLY) // && MovDir[x][y] == right_dir)
6946 else if (element == EL_SP_SNIKSNAK || element == EL_SP_ELECTRON)
6948 TestIfBadThingTouchesOtherBadThing(x, y);
6950 if (ELEMENT_CAN_ENTER_FIELD_BASE_4(element, left_x, left_y, 0))
6951 MovDir[x][y] = left_dir;
6952 else if (!ELEMENT_CAN_ENTER_FIELD_BASE_4(element, move_x, move_y, 0))
6953 MovDir[x][y] = right_dir;
6955 if (MovDir[x][y] != old_move_dir)
6958 else if (element == EL_YAMYAM)
6960 boolean can_turn_left = YAMYAM_CAN_ENTER_FIELD(element, left_x, left_y);
6961 boolean can_turn_right = YAMYAM_CAN_ENTER_FIELD(element, right_x, right_y);
6963 if (can_turn_left && can_turn_right)
6964 MovDir[x][y] = (RND(3) ? (RND(2) ? left_dir : right_dir) : back_dir);
6965 else if (can_turn_left)
6966 MovDir[x][y] = (RND(2) ? left_dir : back_dir);
6967 else if (can_turn_right)
6968 MovDir[x][y] = (RND(2) ? right_dir : back_dir);
6970 MovDir[x][y] = back_dir;
6972 MovDelay[x][y] = 16 + 16 * RND(3);
6974 else if (element == EL_DARK_YAMYAM)
6976 boolean can_turn_left = DARK_YAMYAM_CAN_ENTER_FIELD(element,
6978 boolean can_turn_right = DARK_YAMYAM_CAN_ENTER_FIELD(element,
6981 if (can_turn_left && can_turn_right)
6982 MovDir[x][y] = (RND(3) ? (RND(2) ? left_dir : right_dir) : back_dir);
6983 else if (can_turn_left)
6984 MovDir[x][y] = (RND(2) ? left_dir : back_dir);
6985 else if (can_turn_right)
6986 MovDir[x][y] = (RND(2) ? right_dir : back_dir);
6988 MovDir[x][y] = back_dir;
6990 MovDelay[x][y] = 16 + 16 * RND(3);
6992 else if (element == EL_PACMAN)
6994 boolean can_turn_left = PACMAN_CAN_ENTER_FIELD(element, left_x, left_y);
6995 boolean can_turn_right = PACMAN_CAN_ENTER_FIELD(element, right_x, right_y);
6997 if (can_turn_left && can_turn_right)
6998 MovDir[x][y] = (RND(3) ? (RND(2) ? left_dir : right_dir) : back_dir);
6999 else if (can_turn_left)
7000 MovDir[x][y] = (RND(2) ? left_dir : back_dir);
7001 else if (can_turn_right)
7002 MovDir[x][y] = (RND(2) ? right_dir : back_dir);
7004 MovDir[x][y] = back_dir;
7006 MovDelay[x][y] = 6 + RND(40);
7008 else if (element == EL_PIG)
7010 boolean can_turn_left = PIG_CAN_ENTER_FIELD(element, left_x, left_y);
7011 boolean can_turn_right = PIG_CAN_ENTER_FIELD(element, right_x, right_y);
7012 boolean can_move_on = PIG_CAN_ENTER_FIELD(element, move_x, move_y);
7013 boolean should_turn_left, should_turn_right, should_move_on;
7015 int rnd = RND(rnd_value);
7017 should_turn_left = (can_turn_left &&
7019 IN_LEV_FIELD_AND_NOT_FREE(x + back_dx + left_dx,
7020 y + back_dy + left_dy)));
7021 should_turn_right = (can_turn_right &&
7023 IN_LEV_FIELD_AND_NOT_FREE(x + back_dx + right_dx,
7024 y + back_dy + right_dy)));
7025 should_move_on = (can_move_on &&
7028 IN_LEV_FIELD_AND_NOT_FREE(x + move_dx + left_dx,
7029 y + move_dy + left_dy) ||
7030 IN_LEV_FIELD_AND_NOT_FREE(x + move_dx + right_dx,
7031 y + move_dy + right_dy)));
7033 if (should_turn_left || should_turn_right || should_move_on)
7035 if (should_turn_left && should_turn_right && should_move_on)
7036 MovDir[x][y] = (rnd < rnd_value / 3 ? left_dir :
7037 rnd < 2 * rnd_value / 3 ? right_dir :
7039 else if (should_turn_left && should_turn_right)
7040 MovDir[x][y] = (rnd < rnd_value / 2 ? left_dir : right_dir);
7041 else if (should_turn_left && should_move_on)
7042 MovDir[x][y] = (rnd < rnd_value / 2 ? left_dir : old_move_dir);
7043 else if (should_turn_right && should_move_on)
7044 MovDir[x][y] = (rnd < rnd_value / 2 ? right_dir : old_move_dir);
7045 else if (should_turn_left)
7046 MovDir[x][y] = left_dir;
7047 else if (should_turn_right)
7048 MovDir[x][y] = right_dir;
7049 else if (should_move_on)
7050 MovDir[x][y] = old_move_dir;
7052 else if (can_move_on && rnd > rnd_value / 8)
7053 MovDir[x][y] = old_move_dir;
7054 else if (can_turn_left && can_turn_right)
7055 MovDir[x][y] = (rnd < rnd_value / 2 ? left_dir : right_dir);
7056 else if (can_turn_left && rnd > rnd_value / 8)
7057 MovDir[x][y] = left_dir;
7058 else if (can_turn_right && rnd > rnd_value/8)
7059 MovDir[x][y] = right_dir;
7061 MovDir[x][y] = back_dir;
7063 xx = x + move_xy[MovDir[x][y]].dx;
7064 yy = y + move_xy[MovDir[x][y]].dy;
7066 if (!IN_LEV_FIELD(xx, yy) ||
7067 (!IS_FREE(xx, yy) && !IS_FOOD_PIG(Tile[xx][yy])))
7068 MovDir[x][y] = old_move_dir;
7072 else if (element == EL_DRAGON)
7074 boolean can_turn_left = DRAGON_CAN_ENTER_FIELD(element, left_x, left_y);
7075 boolean can_turn_right = DRAGON_CAN_ENTER_FIELD(element, right_x, right_y);
7076 boolean can_move_on = DRAGON_CAN_ENTER_FIELD(element, move_x, move_y);
7078 int rnd = RND(rnd_value);
7080 if (can_move_on && rnd > rnd_value / 8)
7081 MovDir[x][y] = old_move_dir;
7082 else if (can_turn_left && can_turn_right)
7083 MovDir[x][y] = (rnd < rnd_value / 2 ? left_dir : right_dir);
7084 else if (can_turn_left && rnd > rnd_value / 8)
7085 MovDir[x][y] = left_dir;
7086 else if (can_turn_right && rnd > rnd_value / 8)
7087 MovDir[x][y] = right_dir;
7089 MovDir[x][y] = back_dir;
7091 xx = x + move_xy[MovDir[x][y]].dx;
7092 yy = y + move_xy[MovDir[x][y]].dy;
7094 if (!IN_LEV_FIELD_AND_IS_FREE(xx, yy))
7095 MovDir[x][y] = old_move_dir;
7099 else if (element == EL_MOLE)
7101 boolean can_move_on =
7102 (MOLE_CAN_ENTER_FIELD(element, move_x, move_y,
7103 IS_AMOEBOID(Tile[move_x][move_y]) ||
7104 Tile[move_x][move_y] == EL_AMOEBA_SHRINKING));
7107 boolean can_turn_left =
7108 (MOLE_CAN_ENTER_FIELD(element, left_x, left_y,
7109 IS_AMOEBOID(Tile[left_x][left_y])));
7111 boolean can_turn_right =
7112 (MOLE_CAN_ENTER_FIELD(element, right_x, right_y,
7113 IS_AMOEBOID(Tile[right_x][right_y])));
7115 if (can_turn_left && can_turn_right)
7116 MovDir[x][y] = (RND(2) ? left_dir : right_dir);
7117 else if (can_turn_left)
7118 MovDir[x][y] = left_dir;
7120 MovDir[x][y] = right_dir;
7123 if (MovDir[x][y] != old_move_dir)
7126 else if (element == EL_BALLOON)
7128 MovDir[x][y] = game.wind_direction;
7131 else if (element == EL_SPRING)
7133 if (MovDir[x][y] & MV_HORIZONTAL)
7135 if (SPRING_CAN_BUMP_FROM_FIELD(move_x, move_y) &&
7136 !SPRING_CAN_ENTER_FIELD(element, x, y + 1))
7138 Tile[move_x][move_y] = EL_EMC_SPRING_BUMPER_ACTIVE;
7139 ResetGfxAnimation(move_x, move_y);
7140 TEST_DrawLevelField(move_x, move_y);
7142 MovDir[x][y] = back_dir;
7144 else if (!SPRING_CAN_ENTER_FIELD(element, move_x, move_y) ||
7145 SPRING_CAN_ENTER_FIELD(element, x, y + 1))
7146 MovDir[x][y] = MV_NONE;
7151 else if (element == EL_ROBOT ||
7152 element == EL_SATELLITE ||
7153 element == EL_PENGUIN ||
7154 element == EL_EMC_ANDROID)
7156 int attr_x = -1, attr_y = -1;
7158 if (game.all_players_gone)
7160 attr_x = game.exit_x;
7161 attr_y = game.exit_y;
7167 for (i = 0; i < MAX_PLAYERS; i++)
7169 struct PlayerInfo *player = &stored_player[i];
7170 int jx = player->jx, jy = player->jy;
7172 if (!player->active)
7176 ABS(jx - x) + ABS(jy - y) < ABS(attr_x - x) + ABS(attr_y - y))
7184 if (element == EL_ROBOT &&
7185 game.robot_wheel_x >= 0 &&
7186 game.robot_wheel_y >= 0 &&
7187 (Tile[game.robot_wheel_x][game.robot_wheel_y] == EL_ROBOT_WHEEL_ACTIVE ||
7188 game.engine_version < VERSION_IDENT(3,1,0,0)))
7190 attr_x = game.robot_wheel_x;
7191 attr_y = game.robot_wheel_y;
7194 if (element == EL_PENGUIN)
7197 static int xy[4][2] =
7205 for (i = 0; i < NUM_DIRECTIONS; i++)
7207 int ex = x + xy[i][0];
7208 int ey = y + xy[i][1];
7210 if (IN_LEV_FIELD(ex, ey) && (Tile[ex][ey] == EL_EXIT_OPEN ||
7211 Tile[ex][ey] == EL_EM_EXIT_OPEN ||
7212 Tile[ex][ey] == EL_STEEL_EXIT_OPEN ||
7213 Tile[ex][ey] == EL_EM_STEEL_EXIT_OPEN))
7222 MovDir[x][y] = MV_NONE;
7224 MovDir[x][y] |= (game.all_players_gone ? MV_RIGHT : MV_LEFT);
7225 else if (attr_x > x)
7226 MovDir[x][y] |= (game.all_players_gone ? MV_LEFT : MV_RIGHT);
7228 MovDir[x][y] |= (game.all_players_gone ? MV_DOWN : MV_UP);
7229 else if (attr_y > y)
7230 MovDir[x][y] |= (game.all_players_gone ? MV_UP : MV_DOWN);
7232 if (element == EL_ROBOT)
7236 if (MovDir[x][y] & MV_HORIZONTAL && MovDir[x][y] & MV_VERTICAL)
7237 MovDir[x][y] &= (RND(2) ? MV_HORIZONTAL : MV_VERTICAL);
7238 Moving2Blocked(x, y, &newx, &newy);
7240 if (IN_LEV_FIELD(newx, newy) && IS_FREE_OR_PLAYER(newx, newy))
7241 MovDelay[x][y] = 8 + 8 * !RND(3);
7243 MovDelay[x][y] = 16;
7245 else if (element == EL_PENGUIN)
7251 if (MovDir[x][y] & MV_HORIZONTAL && MovDir[x][y] & MV_VERTICAL)
7253 boolean first_horiz = RND(2);
7254 int new_move_dir = MovDir[x][y];
7257 new_move_dir & (first_horiz ? MV_HORIZONTAL : MV_VERTICAL);
7258 Moving2Blocked(x, y, &newx, &newy);
7260 if (PENGUIN_CAN_ENTER_FIELD(element, newx, newy))
7264 new_move_dir & (!first_horiz ? MV_HORIZONTAL : MV_VERTICAL);
7265 Moving2Blocked(x, y, &newx, &newy);
7267 if (PENGUIN_CAN_ENTER_FIELD(element, newx, newy))
7270 MovDir[x][y] = old_move_dir;
7274 else if (element == EL_SATELLITE)
7280 if (MovDir[x][y] & MV_HORIZONTAL && MovDir[x][y] & MV_VERTICAL)
7282 boolean first_horiz = RND(2);
7283 int new_move_dir = MovDir[x][y];
7286 new_move_dir & (first_horiz ? MV_HORIZONTAL : MV_VERTICAL);
7287 Moving2Blocked(x, y, &newx, &newy);
7289 if (SATELLITE_CAN_ENTER_FIELD(newx, newy))
7293 new_move_dir & (!first_horiz ? MV_HORIZONTAL : MV_VERTICAL);
7294 Moving2Blocked(x, y, &newx, &newy);
7296 if (SATELLITE_CAN_ENTER_FIELD(newx, newy))
7299 MovDir[x][y] = old_move_dir;
7303 else if (element == EL_EMC_ANDROID)
7305 static int check_pos[16] =
7307 -1, // 0 => (invalid)
7310 -1, // 3 => (invalid)
7312 0, // 5 => MV_LEFT | MV_UP
7313 2, // 6 => MV_RIGHT | MV_UP
7314 -1, // 7 => (invalid)
7316 6, // 9 => MV_LEFT | MV_DOWN
7317 4, // 10 => MV_RIGHT | MV_DOWN
7318 -1, // 11 => (invalid)
7319 -1, // 12 => (invalid)
7320 -1, // 13 => (invalid)
7321 -1, // 14 => (invalid)
7322 -1, // 15 => (invalid)
7330 { -1, -1, MV_LEFT | MV_UP },
7332 { +1, -1, MV_RIGHT | MV_UP },
7333 { +1, 0, MV_RIGHT },
7334 { +1, +1, MV_RIGHT | MV_DOWN },
7336 { -1, +1, MV_LEFT | MV_DOWN },
7339 int start_pos, check_order;
7340 boolean can_clone = FALSE;
7343 // check if there is any free field around current position
7344 for (i = 0; i < 8; i++)
7346 int newx = x + check_xy[i].dx;
7347 int newy = y + check_xy[i].dy;
7349 if (IN_LEV_FIELD_AND_IS_FREE(newx, newy))
7357 if (can_clone) // randomly find an element to clone
7361 start_pos = check_pos[RND(8)];
7362 check_order = (RND(2) ? -1 : +1);
7364 for (i = 0; i < 8; i++)
7366 int pos_raw = start_pos + i * check_order;
7367 int pos = (pos_raw + 8) % 8;
7368 int newx = x + check_xy[pos].dx;
7369 int newy = y + check_xy[pos].dy;
7371 if (ANDROID_CAN_CLONE_FIELD(newx, newy))
7373 element_info[element].move_leave_type = LEAVE_TYPE_LIMITED;
7374 element_info[element].move_leave_element = EL_TRIGGER_ELEMENT;
7376 Store[x][y] = Tile[newx][newy];
7385 if (can_clone) // randomly find a direction to move
7389 start_pos = check_pos[RND(8)];
7390 check_order = (RND(2) ? -1 : +1);
7392 for (i = 0; i < 8; i++)
7394 int pos_raw = start_pos + i * check_order;
7395 int pos = (pos_raw + 8) % 8;
7396 int newx = x + check_xy[pos].dx;
7397 int newy = y + check_xy[pos].dy;
7398 int new_move_dir = check_xy[pos].dir;
7400 if (IN_LEV_FIELD_AND_IS_FREE(newx, newy))
7402 MovDir[x][y] = new_move_dir;
7403 MovDelay[x][y] = level.android_clone_time * 8 + 1;
7412 if (can_clone) // cloning and moving successful
7415 // cannot clone -- try to move towards player
7417 start_pos = check_pos[MovDir[x][y] & 0x0f];
7418 check_order = (RND(2) ? -1 : +1);
7420 for (i = 0; i < 3; i++)
7422 // first check start_pos, then previous/next or (next/previous) pos
7423 int pos_raw = start_pos + (i < 2 ? i : -1) * check_order;
7424 int pos = (pos_raw + 8) % 8;
7425 int newx = x + check_xy[pos].dx;
7426 int newy = y + check_xy[pos].dy;
7427 int new_move_dir = check_xy[pos].dir;
7429 if (IS_PLAYER(newx, newy))
7432 if (ANDROID_CAN_ENTER_FIELD(element, newx, newy))
7434 MovDir[x][y] = new_move_dir;
7435 MovDelay[x][y] = level.android_move_time * 8 + 1;
7442 else if (move_pattern == MV_TURNING_LEFT ||
7443 move_pattern == MV_TURNING_RIGHT ||
7444 move_pattern == MV_TURNING_LEFT_RIGHT ||
7445 move_pattern == MV_TURNING_RIGHT_LEFT ||
7446 move_pattern == MV_TURNING_RANDOM ||
7447 move_pattern == MV_ALL_DIRECTIONS)
7449 boolean can_turn_left =
7450 CUSTOM_ELEMENT_CAN_ENTER_FIELD(element, left_x, left_y);
7451 boolean can_turn_right =
7452 CUSTOM_ELEMENT_CAN_ENTER_FIELD(element, right_x,right_y);
7454 if (element_info[element].move_stepsize == 0) // "not moving"
7457 if (move_pattern == MV_TURNING_LEFT)
7458 MovDir[x][y] = left_dir;
7459 else if (move_pattern == MV_TURNING_RIGHT)
7460 MovDir[x][y] = right_dir;
7461 else if (move_pattern == MV_TURNING_LEFT_RIGHT)
7462 MovDir[x][y] = (can_turn_left || !can_turn_right ? left_dir : right_dir);
7463 else if (move_pattern == MV_TURNING_RIGHT_LEFT)
7464 MovDir[x][y] = (can_turn_right || !can_turn_left ? right_dir : left_dir);
7465 else if (move_pattern == MV_TURNING_RANDOM)
7466 MovDir[x][y] = (can_turn_left && !can_turn_right ? left_dir :
7467 can_turn_right && !can_turn_left ? right_dir :
7468 RND(2) ? left_dir : right_dir);
7469 else if (can_turn_left && can_turn_right)
7470 MovDir[x][y] = (RND(3) ? (RND(2) ? left_dir : right_dir) : back_dir);
7471 else if (can_turn_left)
7472 MovDir[x][y] = (RND(2) ? left_dir : back_dir);
7473 else if (can_turn_right)
7474 MovDir[x][y] = (RND(2) ? right_dir : back_dir);
7476 MovDir[x][y] = back_dir;
7478 MovDelay[x][y] = GET_NEW_MOVE_DELAY(element);
7480 else if (move_pattern == MV_HORIZONTAL ||
7481 move_pattern == MV_VERTICAL)
7483 if (move_pattern & old_move_dir)
7484 MovDir[x][y] = back_dir;
7485 else if (move_pattern == MV_HORIZONTAL)
7486 MovDir[x][y] = (RND(2) ? MV_LEFT : MV_RIGHT);
7487 else if (move_pattern == MV_VERTICAL)
7488 MovDir[x][y] = (RND(2) ? MV_UP : MV_DOWN);
7490 MovDelay[x][y] = GET_NEW_MOVE_DELAY(element);
7492 else if (move_pattern & MV_ANY_DIRECTION)
7494 MovDir[x][y] = move_pattern;
7495 MovDelay[x][y] = GET_NEW_MOVE_DELAY(element);
7497 else if (move_pattern & MV_WIND_DIRECTION)
7499 MovDir[x][y] = game.wind_direction;
7500 MovDelay[x][y] = GET_NEW_MOVE_DELAY(element);
7502 else if (move_pattern == MV_ALONG_LEFT_SIDE)
7504 if (CUSTOM_ELEMENT_CAN_ENTER_FIELD(element, left_x, left_y))
7505 MovDir[x][y] = left_dir;
7506 else if (!CUSTOM_ELEMENT_CAN_ENTER_FIELD(element, move_x, move_y))
7507 MovDir[x][y] = right_dir;
7509 if (MovDir[x][y] != old_move_dir)
7510 MovDelay[x][y] = GET_NEW_MOVE_DELAY(element);
7512 else if (move_pattern == MV_ALONG_RIGHT_SIDE)
7514 if (CUSTOM_ELEMENT_CAN_ENTER_FIELD(element, right_x, right_y))
7515 MovDir[x][y] = right_dir;
7516 else if (!CUSTOM_ELEMENT_CAN_ENTER_FIELD(element, move_x, move_y))
7517 MovDir[x][y] = left_dir;
7519 if (MovDir[x][y] != old_move_dir)
7520 MovDelay[x][y] = GET_NEW_MOVE_DELAY(element);
7522 else if (move_pattern == MV_TOWARDS_PLAYER ||
7523 move_pattern == MV_AWAY_FROM_PLAYER)
7525 int attr_x = -1, attr_y = -1;
7527 boolean move_away = (move_pattern == MV_AWAY_FROM_PLAYER);
7529 if (game.all_players_gone)
7531 attr_x = game.exit_x;
7532 attr_y = game.exit_y;
7538 for (i = 0; i < MAX_PLAYERS; i++)
7540 struct PlayerInfo *player = &stored_player[i];
7541 int jx = player->jx, jy = player->jy;
7543 if (!player->active)
7547 ABS(jx - x) + ABS(jy - y) < ABS(attr_x - x) + ABS(attr_y - y))
7555 MovDir[x][y] = MV_NONE;
7557 MovDir[x][y] |= (move_away ? MV_RIGHT : MV_LEFT);
7558 else if (attr_x > x)
7559 MovDir[x][y] |= (move_away ? MV_LEFT : MV_RIGHT);
7561 MovDir[x][y] |= (move_away ? MV_DOWN : MV_UP);
7562 else if (attr_y > y)
7563 MovDir[x][y] |= (move_away ? MV_UP : MV_DOWN);
7565 MovDelay[x][y] = GET_NEW_MOVE_DELAY(element);
7567 if (MovDir[x][y] & MV_HORIZONTAL && MovDir[x][y] & MV_VERTICAL)
7569 boolean first_horiz = RND(2);
7570 int new_move_dir = MovDir[x][y];
7572 if (element_info[element].move_stepsize == 0) // "not moving"
7574 first_horiz = (ABS(attr_x - x) >= ABS(attr_y - y));
7575 MovDir[x][y] &= (first_horiz ? MV_HORIZONTAL : MV_VERTICAL);
7581 new_move_dir & (first_horiz ? MV_HORIZONTAL : MV_VERTICAL);
7582 Moving2Blocked(x, y, &newx, &newy);
7584 if (CUSTOM_ELEMENT_CAN_ENTER_FIELD(element, newx, newy))
7588 new_move_dir & (!first_horiz ? MV_HORIZONTAL : MV_VERTICAL);
7589 Moving2Blocked(x, y, &newx, &newy);
7591 if (CUSTOM_ELEMENT_CAN_ENTER_FIELD(element, newx, newy))
7594 MovDir[x][y] = old_move_dir;
7597 else if (move_pattern == MV_WHEN_PUSHED ||
7598 move_pattern == MV_WHEN_DROPPED)
7600 if (!CUSTOM_ELEMENT_CAN_ENTER_FIELD(element, move_x, move_y))
7601 MovDir[x][y] = MV_NONE;
7605 else if (move_pattern & MV_MAZE_RUNNER_STYLE)
7607 static int test_xy[7][2] =
7617 static int test_dir[7] =
7627 boolean hunter_mode = (move_pattern == MV_MAZE_HUNTER);
7628 int move_preference = -1000000; // start with very low preference
7629 int new_move_dir = MV_NONE;
7630 int start_test = RND(4);
7633 for (i = 0; i < NUM_DIRECTIONS; i++)
7635 int move_dir = test_dir[start_test + i];
7636 int move_dir_preference;
7638 xx = x + test_xy[start_test + i][0];
7639 yy = y + test_xy[start_test + i][1];
7641 if (hunter_mode && IN_LEV_FIELD(xx, yy) &&
7642 (IS_PLAYER(xx, yy) || Tile[xx][yy] == EL_PLAYER_IS_LEAVING))
7644 new_move_dir = move_dir;
7649 if (!CUSTOM_ELEMENT_CAN_ENTER_FIELD(element, xx, yy))
7652 move_dir_preference = -1 * RunnerVisit[xx][yy];
7653 if (hunter_mode && PlayerVisit[xx][yy] > 0)
7654 move_dir_preference = PlayerVisit[xx][yy];
7656 if (move_dir_preference > move_preference)
7658 // prefer field that has not been visited for the longest time
7659 move_preference = move_dir_preference;
7660 new_move_dir = move_dir;
7662 else if (move_dir_preference == move_preference &&
7663 move_dir == old_move_dir)
7665 // prefer last direction when all directions are preferred equally
7666 move_preference = move_dir_preference;
7667 new_move_dir = move_dir;
7671 MovDir[x][y] = new_move_dir;
7672 if (old_move_dir != new_move_dir)
7673 MovDelay[x][y] = GET_NEW_MOVE_DELAY(element);
7677 static void TurnRound(int x, int y)
7679 int direction = MovDir[x][y];
7683 GfxDir[x][y] = MovDir[x][y];
7685 if (direction != MovDir[x][y])
7689 GfxAction[x][y] = ACTION_TURNING_FROM_LEFT + MV_DIR_TO_BIT(direction);
7691 ResetGfxFrame(x, y);
7694 static boolean JustBeingPushed(int x, int y)
7698 for (i = 0; i < MAX_PLAYERS; i++)
7700 struct PlayerInfo *player = &stored_player[i];
7702 if (player->active && player->is_pushing && player->MovPos)
7704 int next_jx = player->jx + (player->jx - player->last_jx);
7705 int next_jy = player->jy + (player->jy - player->last_jy);
7707 if (x == next_jx && y == next_jy)
7715 static void StartMoving(int x, int y)
7717 boolean started_moving = FALSE; // some elements can fall _and_ move
7718 int element = Tile[x][y];
7723 if (MovDelay[x][y] == 0)
7724 GfxAction[x][y] = ACTION_DEFAULT;
7726 if (CAN_FALL(element) && y < lev_fieldy - 1)
7728 if ((x > 0 && IS_PLAYER(x - 1, y)) ||
7729 (x < lev_fieldx - 1 && IS_PLAYER(x + 1, y)))
7730 if (JustBeingPushed(x, y))
7733 if (element == EL_QUICKSAND_FULL)
7735 if (IS_FREE(x, y + 1))
7737 InitMovingField(x, y, MV_DOWN);
7738 started_moving = TRUE;
7740 Tile[x][y] = EL_QUICKSAND_EMPTYING;
7741 #if USE_QUICKSAND_BD_ROCK_BUGFIX
7742 if (Store[x][y] != EL_ROCK && Store[x][y] != EL_BD_ROCK)
7743 Store[x][y] = EL_ROCK;
7745 Store[x][y] = EL_ROCK;
7748 PlayLevelSoundAction(x, y, ACTION_EMPTYING);
7750 else if (Tile[x][y + 1] == EL_QUICKSAND_EMPTY)
7752 if (!MovDelay[x][y])
7754 MovDelay[x][y] = TILEY + 1;
7756 ResetGfxAnimation(x, y);
7757 ResetGfxAnimation(x, y + 1);
7762 DrawLevelElement(x, y, EL_QUICKSAND_EMPTYING);
7763 DrawLevelElement(x, y + 1, EL_QUICKSAND_FILLING);
7770 Tile[x][y] = EL_QUICKSAND_EMPTY;
7771 Tile[x][y + 1] = EL_QUICKSAND_FULL;
7772 Store[x][y + 1] = Store[x][y];
7775 PlayLevelSoundAction(x, y, ACTION_FILLING);
7777 else if (Tile[x][y + 1] == EL_QUICKSAND_FAST_EMPTY)
7779 if (!MovDelay[x][y])
7781 MovDelay[x][y] = TILEY + 1;
7783 ResetGfxAnimation(x, y);
7784 ResetGfxAnimation(x, y + 1);
7789 DrawLevelElement(x, y, EL_QUICKSAND_EMPTYING);
7790 DrawLevelElement(x, y + 1, EL_QUICKSAND_FAST_FILLING);
7797 Tile[x][y] = EL_QUICKSAND_EMPTY;
7798 Tile[x][y + 1] = EL_QUICKSAND_FAST_FULL;
7799 Store[x][y + 1] = Store[x][y];
7802 PlayLevelSoundAction(x, y, ACTION_FILLING);
7805 else if (element == EL_QUICKSAND_FAST_FULL)
7807 if (IS_FREE(x, y + 1))
7809 InitMovingField(x, y, MV_DOWN);
7810 started_moving = TRUE;
7812 Tile[x][y] = EL_QUICKSAND_FAST_EMPTYING;
7813 #if USE_QUICKSAND_BD_ROCK_BUGFIX
7814 if (Store[x][y] != EL_ROCK && Store[x][y] != EL_BD_ROCK)
7815 Store[x][y] = EL_ROCK;
7817 Store[x][y] = EL_ROCK;
7820 PlayLevelSoundAction(x, y, ACTION_EMPTYING);
7822 else if (Tile[x][y + 1] == EL_QUICKSAND_FAST_EMPTY)
7824 if (!MovDelay[x][y])
7826 MovDelay[x][y] = TILEY + 1;
7828 ResetGfxAnimation(x, y);
7829 ResetGfxAnimation(x, y + 1);
7834 DrawLevelElement(x, y, EL_QUICKSAND_FAST_EMPTYING);
7835 DrawLevelElement(x, y + 1, EL_QUICKSAND_FAST_FILLING);
7842 Tile[x][y] = EL_QUICKSAND_FAST_EMPTY;
7843 Tile[x][y + 1] = EL_QUICKSAND_FAST_FULL;
7844 Store[x][y + 1] = Store[x][y];
7847 PlayLevelSoundAction(x, y, ACTION_FILLING);
7849 else if (Tile[x][y + 1] == EL_QUICKSAND_EMPTY)
7851 if (!MovDelay[x][y])
7853 MovDelay[x][y] = TILEY + 1;
7855 ResetGfxAnimation(x, y);
7856 ResetGfxAnimation(x, y + 1);
7861 DrawLevelElement(x, y, EL_QUICKSAND_FAST_EMPTYING);
7862 DrawLevelElement(x, y + 1, EL_QUICKSAND_FILLING);
7869 Tile[x][y] = EL_QUICKSAND_FAST_EMPTY;
7870 Tile[x][y + 1] = EL_QUICKSAND_FULL;
7871 Store[x][y + 1] = Store[x][y];
7874 PlayLevelSoundAction(x, y, ACTION_FILLING);
7877 else if ((element == EL_ROCK || element == EL_BD_ROCK) &&
7878 Tile[x][y + 1] == EL_QUICKSAND_EMPTY)
7880 InitMovingField(x, y, MV_DOWN);
7881 started_moving = TRUE;
7883 Tile[x][y] = EL_QUICKSAND_FILLING;
7884 Store[x][y] = element;
7886 PlayLevelSoundAction(x, y, ACTION_FILLING);
7888 else if ((element == EL_ROCK || element == EL_BD_ROCK) &&
7889 Tile[x][y + 1] == EL_QUICKSAND_FAST_EMPTY)
7891 InitMovingField(x, y, MV_DOWN);
7892 started_moving = TRUE;
7894 Tile[x][y] = EL_QUICKSAND_FAST_FILLING;
7895 Store[x][y] = element;
7897 PlayLevelSoundAction(x, y, ACTION_FILLING);
7899 else if (element == EL_MAGIC_WALL_FULL)
7901 if (IS_FREE(x, y + 1))
7903 InitMovingField(x, y, MV_DOWN);
7904 started_moving = TRUE;
7906 Tile[x][y] = EL_MAGIC_WALL_EMPTYING;
7907 Store[x][y] = EL_CHANGED(Store[x][y]);
7909 else if (Tile[x][y + 1] == EL_MAGIC_WALL_ACTIVE)
7911 if (!MovDelay[x][y])
7912 MovDelay[x][y] = TILEY / 4 + 1;
7921 Tile[x][y] = EL_MAGIC_WALL_ACTIVE;
7922 Tile[x][y + 1] = EL_MAGIC_WALL_FULL;
7923 Store[x][y + 1] = EL_CHANGED(Store[x][y]);
7927 else if (element == EL_BD_MAGIC_WALL_FULL)
7929 if (IS_FREE(x, y + 1))
7931 InitMovingField(x, y, MV_DOWN);
7932 started_moving = TRUE;
7934 Tile[x][y] = EL_BD_MAGIC_WALL_EMPTYING;
7935 Store[x][y] = EL_CHANGED_BD(Store[x][y]);
7937 else if (Tile[x][y + 1] == EL_BD_MAGIC_WALL_ACTIVE)
7939 if (!MovDelay[x][y])
7940 MovDelay[x][y] = TILEY / 4 + 1;
7949 Tile[x][y] = EL_BD_MAGIC_WALL_ACTIVE;
7950 Tile[x][y + 1] = EL_BD_MAGIC_WALL_FULL;
7951 Store[x][y + 1] = EL_CHANGED_BD(Store[x][y]);
7955 else if (element == EL_DC_MAGIC_WALL_FULL)
7957 if (IS_FREE(x, y + 1))
7959 InitMovingField(x, y, MV_DOWN);
7960 started_moving = TRUE;
7962 Tile[x][y] = EL_DC_MAGIC_WALL_EMPTYING;
7963 Store[x][y] = EL_CHANGED_DC(Store[x][y]);
7965 else if (Tile[x][y + 1] == EL_DC_MAGIC_WALL_ACTIVE)
7967 if (!MovDelay[x][y])
7968 MovDelay[x][y] = TILEY / 4 + 1;
7977 Tile[x][y] = EL_DC_MAGIC_WALL_ACTIVE;
7978 Tile[x][y + 1] = EL_DC_MAGIC_WALL_FULL;
7979 Store[x][y + 1] = EL_CHANGED_DC(Store[x][y]);
7983 else if ((CAN_PASS_MAGIC_WALL(element) &&
7984 (Tile[x][y + 1] == EL_MAGIC_WALL_ACTIVE ||
7985 Tile[x][y + 1] == EL_BD_MAGIC_WALL_ACTIVE)) ||
7986 (CAN_PASS_DC_MAGIC_WALL(element) &&
7987 (Tile[x][y + 1] == EL_DC_MAGIC_WALL_ACTIVE)))
7990 InitMovingField(x, y, MV_DOWN);
7991 started_moving = TRUE;
7994 (Tile[x][y + 1] == EL_MAGIC_WALL_ACTIVE ? EL_MAGIC_WALL_FILLING :
7995 Tile[x][y + 1] == EL_BD_MAGIC_WALL_ACTIVE ? EL_BD_MAGIC_WALL_FILLING :
7996 EL_DC_MAGIC_WALL_FILLING);
7997 Store[x][y] = element;
7999 else if (CAN_FALL(element) && Tile[x][y + 1] == EL_ACID)
8001 SplashAcid(x, y + 1);
8003 InitMovingField(x, y, MV_DOWN);
8004 started_moving = TRUE;
8006 Store[x][y] = EL_ACID;
8009 (game.engine_version >= VERSION_IDENT(3,1,0,0) &&
8010 CheckImpact[x][y] && !IS_FREE(x, y + 1)) ||
8011 (game.engine_version >= VERSION_IDENT(3,0,7,0) &&
8012 CAN_FALL(element) && WasJustFalling[x][y] &&
8013 (Tile[x][y + 1] == EL_BLOCKED || IS_PLAYER(x, y + 1))) ||
8015 (game.engine_version < VERSION_IDENT(2,2,0,7) &&
8016 CAN_FALL(element) && WasJustMoving[x][y] && !Pushed[x][y + 1] &&
8017 (Tile[x][y + 1] == EL_BLOCKED)))
8019 /* this is needed for a special case not covered by calling "Impact()"
8020 from "ContinueMoving()": if an element moves to a tile directly below
8021 another element which was just falling on that tile (which was empty
8022 in the previous frame), the falling element above would just stop
8023 instead of smashing the element below (in previous version, the above
8024 element was just checked for "moving" instead of "falling", resulting
8025 in incorrect smashes caused by horizontal movement of the above
8026 element; also, the case of the player being the element to smash was
8027 simply not covered here... :-/ ) */
8029 CheckCollision[x][y] = 0;
8030 CheckImpact[x][y] = 0;
8034 else if (IS_FREE(x, y + 1) && element == EL_SPRING && level.use_spring_bug)
8036 if (MovDir[x][y] == MV_NONE)
8038 InitMovingField(x, y, MV_DOWN);
8039 started_moving = TRUE;
8042 else if (IS_FREE(x, y + 1) || Tile[x][y + 1] == EL_DIAMOND_BREAKING)
8044 if (WasJustFalling[x][y]) // prevent animation from being restarted
8045 MovDir[x][y] = MV_DOWN;
8047 InitMovingField(x, y, MV_DOWN);
8048 started_moving = TRUE;
8050 else if (element == EL_AMOEBA_DROP)
8052 Tile[x][y] = EL_AMOEBA_GROWING;
8053 Store[x][y] = EL_AMOEBA_WET;
8055 else if (((IS_SLIPPERY(Tile[x][y + 1]) && !IS_PLAYER(x, y + 1)) ||
8056 (IS_EM_SLIPPERY_WALL(Tile[x][y + 1]) && IS_GEM(element))) &&
8057 !IS_FALLING(x, y + 1) && !WasJustMoving[x][y + 1] &&
8058 element != EL_DX_SUPABOMB && element != EL_SP_DISK_ORANGE)
8060 boolean can_fall_left = (x > 0 && IS_FREE(x - 1, y) &&
8061 (IS_FREE(x - 1, y + 1) ||
8062 Tile[x - 1][y + 1] == EL_ACID));
8063 boolean can_fall_right = (x < lev_fieldx - 1 && IS_FREE(x + 1, y) &&
8064 (IS_FREE(x + 1, y + 1) ||
8065 Tile[x + 1][y + 1] == EL_ACID));
8066 boolean can_fall_any = (can_fall_left || can_fall_right);
8067 boolean can_fall_both = (can_fall_left && can_fall_right);
8068 int slippery_type = element_info[Tile[x][y + 1]].slippery_type;
8070 if (can_fall_any && slippery_type != SLIPPERY_ANY_RANDOM)
8072 if (slippery_type == SLIPPERY_ANY_LEFT_RIGHT && can_fall_both)
8073 can_fall_right = FALSE;
8074 else if (slippery_type == SLIPPERY_ANY_RIGHT_LEFT && can_fall_both)
8075 can_fall_left = FALSE;
8076 else if (slippery_type == SLIPPERY_ONLY_LEFT)
8077 can_fall_right = FALSE;
8078 else if (slippery_type == SLIPPERY_ONLY_RIGHT)
8079 can_fall_left = FALSE;
8081 can_fall_any = (can_fall_left || can_fall_right);
8082 can_fall_both = FALSE;
8087 if (element == EL_BD_ROCK || element == EL_BD_DIAMOND)
8088 can_fall_right = FALSE; // slip down on left side
8090 can_fall_left = !(can_fall_right = RND(2));
8092 can_fall_both = FALSE;
8097 // if not determined otherwise, prefer left side for slipping down
8098 InitMovingField(x, y, can_fall_left ? MV_LEFT : MV_RIGHT);
8099 started_moving = TRUE;
8102 else if (IS_BELT_ACTIVE(Tile[x][y + 1]))
8104 boolean left_is_free = (x > 0 && IS_FREE(x - 1, y));
8105 boolean right_is_free = (x < lev_fieldx - 1 && IS_FREE(x + 1, y));
8106 int belt_nr = getBeltNrFromBeltActiveElement(Tile[x][y + 1]);
8107 int belt_dir = game.belt_dir[belt_nr];
8109 if ((belt_dir == MV_LEFT && left_is_free) ||
8110 (belt_dir == MV_RIGHT && right_is_free))
8112 int nextx = (belt_dir == MV_LEFT ? x - 1 : x + 1);
8114 InitMovingField(x, y, belt_dir);
8115 started_moving = TRUE;
8117 Pushed[x][y] = TRUE;
8118 Pushed[nextx][y] = TRUE;
8120 GfxAction[x][y] = ACTION_DEFAULT;
8124 MovDir[x][y] = 0; // if element was moving, stop it
8129 // not "else if" because of elements that can fall and move (EL_SPRING)
8130 if (CAN_MOVE(element) && !started_moving)
8132 int move_pattern = element_info[element].move_pattern;
8135 Moving2Blocked(x, y, &newx, &newy);
8137 if (IS_PUSHABLE(element) && JustBeingPushed(x, y))
8140 if (game.engine_version >= VERSION_IDENT(3,1,0,0) &&
8141 CheckCollision[x][y] && !IN_LEV_FIELD_AND_IS_FREE(newx, newy))
8143 WasJustMoving[x][y] = 0;
8144 CheckCollision[x][y] = 0;
8146 TestIfElementHitsCustomElement(x, y, MovDir[x][y]);
8148 if (Tile[x][y] != element) // element has changed
8152 if (!MovDelay[x][y]) // start new movement phase
8154 // all objects that can change their move direction after each step
8155 // (YAMYAM, DARK_YAMYAM and PACMAN go straight until they hit a wall
8157 if (element != EL_YAMYAM &&
8158 element != EL_DARK_YAMYAM &&
8159 element != EL_PACMAN &&
8160 !(move_pattern & MV_ANY_DIRECTION) &&
8161 move_pattern != MV_TURNING_LEFT &&
8162 move_pattern != MV_TURNING_RIGHT &&
8163 move_pattern != MV_TURNING_LEFT_RIGHT &&
8164 move_pattern != MV_TURNING_RIGHT_LEFT &&
8165 move_pattern != MV_TURNING_RANDOM)
8169 if (MovDelay[x][y] && (element == EL_BUG ||
8170 element == EL_SPACESHIP ||
8171 element == EL_SP_SNIKSNAK ||
8172 element == EL_SP_ELECTRON ||
8173 element == EL_MOLE))
8174 TEST_DrawLevelField(x, y);
8178 if (MovDelay[x][y]) // wait some time before next movement
8182 if (element == EL_ROBOT ||
8183 element == EL_YAMYAM ||
8184 element == EL_DARK_YAMYAM)
8186 DrawLevelElementAnimationIfNeeded(x, y, element);
8187 PlayLevelSoundAction(x, y, ACTION_WAITING);
8189 else if (element == EL_SP_ELECTRON)
8190 DrawLevelElementAnimationIfNeeded(x, y, element);
8191 else if (element == EL_DRAGON)
8194 int dir = MovDir[x][y];
8195 int dx = (dir == MV_LEFT ? -1 : dir == MV_RIGHT ? +1 : 0);
8196 int dy = (dir == MV_UP ? -1 : dir == MV_DOWN ? +1 : 0);
8197 int graphic = (dir == MV_LEFT ? IMG_FLAMES_1_LEFT :
8198 dir == MV_RIGHT ? IMG_FLAMES_1_RIGHT :
8199 dir == MV_UP ? IMG_FLAMES_1_UP :
8200 dir == MV_DOWN ? IMG_FLAMES_1_DOWN : IMG_EMPTY);
8201 int frame = getGraphicAnimationFrame(graphic, GfxFrame[x][y]);
8203 GfxAction[x][y] = ACTION_ATTACKING;
8205 if (IS_PLAYER(x, y))
8206 DrawPlayerField(x, y);
8208 TEST_DrawLevelField(x, y);
8210 PlayLevelSoundActionIfLoop(x, y, ACTION_ATTACKING);
8212 for (i = 1; i <= 3; i++)
8214 int xx = x + i * dx;
8215 int yy = y + i * dy;
8216 int sx = SCREENX(xx);
8217 int sy = SCREENY(yy);
8218 int flame_graphic = graphic + (i - 1);
8220 if (!IN_LEV_FIELD(xx, yy) || IS_DRAGONFIRE_PROOF(Tile[xx][yy]))
8225 int flamed = MovingOrBlocked2Element(xx, yy);
8227 if (IS_CLASSIC_ENEMY(flamed) || CAN_EXPLODE_BY_DRAGONFIRE(flamed))
8230 RemoveMovingField(xx, yy);
8232 ChangeDelay[xx][yy] = 0;
8234 Tile[xx][yy] = EL_FLAMES;
8236 if (IN_SCR_FIELD(sx, sy))
8238 TEST_DrawLevelFieldCrumbled(xx, yy);
8239 DrawGraphic(sx, sy, flame_graphic, frame);
8244 if (Tile[xx][yy] == EL_FLAMES)
8245 Tile[xx][yy] = EL_EMPTY;
8246 TEST_DrawLevelField(xx, yy);
8251 if (MovDelay[x][y]) // element still has to wait some time
8253 PlayLevelSoundAction(x, y, ACTION_WAITING);
8259 // now make next step
8261 Moving2Blocked(x, y, &newx, &newy); // get next screen position
8263 if (DONT_COLLIDE_WITH(element) &&
8264 IN_LEV_FIELD(newx, newy) && IS_PLAYER(newx, newy) &&
8265 !PLAYER_ENEMY_PROTECTED(newx, newy))
8267 TestIfBadThingRunsIntoPlayer(x, y, MovDir[x][y]);
8272 else if (CAN_MOVE_INTO_ACID(element) &&
8273 IN_LEV_FIELD(newx, newy) && Tile[newx][newy] == EL_ACID &&
8274 !IS_MV_DIAGONAL(MovDir[x][y]) &&
8275 (MovDir[x][y] == MV_DOWN ||
8276 game.engine_version >= VERSION_IDENT(3,1,0,0)))
8278 SplashAcid(newx, newy);
8279 Store[x][y] = EL_ACID;
8281 else if (element == EL_PENGUIN && IN_LEV_FIELD(newx, newy))
8283 if (Tile[newx][newy] == EL_EXIT_OPEN ||
8284 Tile[newx][newy] == EL_EM_EXIT_OPEN ||
8285 Tile[newx][newy] == EL_STEEL_EXIT_OPEN ||
8286 Tile[newx][newy] == EL_EM_STEEL_EXIT_OPEN)
8289 TEST_DrawLevelField(x, y);
8291 PlayLevelSound(newx, newy, SND_PENGUIN_PASSING);
8292 if (IN_SCR_FIELD(SCREENX(newx), SCREENY(newy)))
8293 DrawGraphicThruMask(SCREENX(newx),SCREENY(newy), el2img(element), 0);
8295 game.friends_still_needed--;
8296 if (!game.friends_still_needed &&
8298 game.all_players_gone)
8303 else if (IS_FOOD_PENGUIN(Tile[newx][newy]))
8305 if (DigField(local_player, x, y, newx, newy, 0,0, DF_DIG) == MP_MOVING)
8306 TEST_DrawLevelField(newx, newy);
8308 GfxDir[x][y] = MovDir[x][y] = MV_NONE;
8310 else if (!IS_FREE(newx, newy))
8312 GfxAction[x][y] = ACTION_WAITING;
8314 if (IS_PLAYER(x, y))
8315 DrawPlayerField(x, y);
8317 TEST_DrawLevelField(x, y);
8322 else if (element == EL_PIG && IN_LEV_FIELD(newx, newy))
8324 if (IS_FOOD_PIG(Tile[newx][newy]))
8326 if (IS_MOVING(newx, newy))
8327 RemoveMovingField(newx, newy);
8330 Tile[newx][newy] = EL_EMPTY;
8331 TEST_DrawLevelField(newx, newy);
8334 PlayLevelSound(x, y, SND_PIG_DIGGING);
8336 else if (!IS_FREE(newx, newy))
8338 if (IS_PLAYER(x, y))
8339 DrawPlayerField(x, y);
8341 TEST_DrawLevelField(x, y);
8346 else if (element == EL_EMC_ANDROID && IN_LEV_FIELD(newx, newy))
8348 if (Store[x][y] != EL_EMPTY)
8350 boolean can_clone = FALSE;
8353 // check if element to clone is still there
8354 for (yy = y - 1; yy <= y + 1; yy++) for (xx = x - 1; xx <= x + 1; xx++)
8356 if (IN_LEV_FIELD(xx, yy) && Tile[xx][yy] == Store[x][y])
8364 // cannot clone or target field not free anymore -- do not clone
8365 if (!can_clone || !ANDROID_CAN_ENTER_FIELD(element, newx, newy))
8366 Store[x][y] = EL_EMPTY;
8369 if (ANDROID_CAN_ENTER_FIELD(element, newx, newy))
8371 if (IS_MV_DIAGONAL(MovDir[x][y]))
8373 int diagonal_move_dir = MovDir[x][y];
8374 int stored = Store[x][y];
8375 int change_delay = 8;
8378 // android is moving diagonally
8380 CreateField(x, y, EL_DIAGONAL_SHRINKING);
8382 Store[x][y] = (stored == EL_ACID ? EL_EMPTY : stored);
8383 GfxElement[x][y] = EL_EMC_ANDROID;
8384 GfxAction[x][y] = ACTION_SHRINKING;
8385 GfxDir[x][y] = diagonal_move_dir;
8386 ChangeDelay[x][y] = change_delay;
8388 graphic = el_act_dir2img(GfxElement[x][y], GfxAction[x][y],
8391 DrawLevelGraphicAnimation(x, y, graphic);
8392 PlayLevelSoundAction(x, y, ACTION_SHRINKING);
8394 if (Tile[newx][newy] == EL_ACID)
8396 SplashAcid(newx, newy);
8401 CreateField(newx, newy, EL_DIAGONAL_GROWING);
8403 Store[newx][newy] = EL_EMC_ANDROID;
8404 GfxElement[newx][newy] = EL_EMC_ANDROID;
8405 GfxAction[newx][newy] = ACTION_GROWING;
8406 GfxDir[newx][newy] = diagonal_move_dir;
8407 ChangeDelay[newx][newy] = change_delay;
8409 graphic = el_act_dir2img(GfxElement[newx][newy],
8410 GfxAction[newx][newy], GfxDir[newx][newy]);
8412 DrawLevelGraphicAnimation(newx, newy, graphic);
8413 PlayLevelSoundAction(newx, newy, ACTION_GROWING);
8419 Tile[newx][newy] = EL_EMPTY;
8420 TEST_DrawLevelField(newx, newy);
8422 PlayLevelSoundAction(x, y, ACTION_DIGGING);
8425 else if (!IS_FREE(newx, newy))
8430 else if (IS_CUSTOM_ELEMENT(element) &&
8431 CUSTOM_ELEMENT_CAN_ENTER_FIELD(element, newx, newy))
8433 if (!DigFieldByCE(newx, newy, element))
8436 if (move_pattern & MV_MAZE_RUNNER_STYLE)
8438 RunnerVisit[x][y] = FrameCounter;
8439 PlayerVisit[x][y] /= 8; // expire player visit path
8442 else if (element == EL_DRAGON && IN_LEV_FIELD(newx, newy))
8444 if (!IS_FREE(newx, newy))
8446 if (IS_PLAYER(x, y))
8447 DrawPlayerField(x, y);
8449 TEST_DrawLevelField(x, y);
8455 boolean wanna_flame = !RND(10);
8456 int dx = newx - x, dy = newy - y;
8457 int newx1 = newx + 1 * dx, newy1 = newy + 1 * dy;
8458 int newx2 = newx + 2 * dx, newy2 = newy + 2 * dy;
8459 int element1 = (IN_LEV_FIELD(newx1, newy1) ?
8460 MovingOrBlocked2Element(newx1, newy1) : EL_STEELWALL);
8461 int element2 = (IN_LEV_FIELD(newx2, newy2) ?
8462 MovingOrBlocked2Element(newx2, newy2) : EL_STEELWALL);
8465 IS_CLASSIC_ENEMY(element1) ||
8466 IS_CLASSIC_ENEMY(element2)) &&
8467 element1 != EL_DRAGON && element2 != EL_DRAGON &&
8468 element1 != EL_FLAMES && element2 != EL_FLAMES)
8470 ResetGfxAnimation(x, y);
8471 GfxAction[x][y] = ACTION_ATTACKING;
8473 if (IS_PLAYER(x, y))
8474 DrawPlayerField(x, y);
8476 TEST_DrawLevelField(x, y);
8478 PlayLevelSound(x, y, SND_DRAGON_ATTACKING);
8480 MovDelay[x][y] = 50;
8482 Tile[newx][newy] = EL_FLAMES;
8483 if (IN_LEV_FIELD(newx1, newy1) && Tile[newx1][newy1] == EL_EMPTY)
8484 Tile[newx1][newy1] = EL_FLAMES;
8485 if (IN_LEV_FIELD(newx2, newy2) && Tile[newx2][newy2] == EL_EMPTY)
8486 Tile[newx2][newy2] = EL_FLAMES;
8492 else if (element == EL_YAMYAM && IN_LEV_FIELD(newx, newy) &&
8493 Tile[newx][newy] == EL_DIAMOND)
8495 if (IS_MOVING(newx, newy))
8496 RemoveMovingField(newx, newy);
8499 Tile[newx][newy] = EL_EMPTY;
8500 TEST_DrawLevelField(newx, newy);
8503 PlayLevelSound(x, y, SND_YAMYAM_DIGGING);
8505 else if (element == EL_DARK_YAMYAM && IN_LEV_FIELD(newx, newy) &&
8506 IS_FOOD_DARK_YAMYAM(Tile[newx][newy]))
8508 if (AmoebaNr[newx][newy])
8510 AmoebaCnt2[AmoebaNr[newx][newy]]--;
8511 if (Tile[newx][newy] == EL_AMOEBA_FULL ||
8512 Tile[newx][newy] == EL_BD_AMOEBA)
8513 AmoebaCnt[AmoebaNr[newx][newy]]--;
8516 if (IS_MOVING(newx, newy))
8518 RemoveMovingField(newx, newy);
8522 Tile[newx][newy] = EL_EMPTY;
8523 TEST_DrawLevelField(newx, newy);
8526 PlayLevelSound(x, y, SND_DARK_YAMYAM_DIGGING);
8528 else if ((element == EL_PACMAN || element == EL_MOLE)
8529 && IN_LEV_FIELD(newx, newy) && IS_AMOEBOID(Tile[newx][newy]))
8531 if (AmoebaNr[newx][newy])
8533 AmoebaCnt2[AmoebaNr[newx][newy]]--;
8534 if (Tile[newx][newy] == EL_AMOEBA_FULL ||
8535 Tile[newx][newy] == EL_BD_AMOEBA)
8536 AmoebaCnt[AmoebaNr[newx][newy]]--;
8539 if (element == EL_MOLE)
8541 Tile[newx][newy] = EL_AMOEBA_SHRINKING;
8542 PlayLevelSound(x, y, SND_MOLE_DIGGING);
8544 ResetGfxAnimation(x, y);
8545 GfxAction[x][y] = ACTION_DIGGING;
8546 TEST_DrawLevelField(x, y);
8548 MovDelay[newx][newy] = 0; // start amoeba shrinking delay
8550 return; // wait for shrinking amoeba
8552 else // element == EL_PACMAN
8554 Tile[newx][newy] = EL_EMPTY;
8555 TEST_DrawLevelField(newx, newy);
8556 PlayLevelSound(x, y, SND_PACMAN_DIGGING);
8559 else if (element == EL_MOLE && IN_LEV_FIELD(newx, newy) &&
8560 (Tile[newx][newy] == EL_AMOEBA_SHRINKING ||
8561 (Tile[newx][newy] == EL_EMPTY && Stop[newx][newy])))
8563 // wait for shrinking amoeba to completely disappear
8566 else if (!IN_LEV_FIELD(newx, newy) || !IS_FREE(newx, newy))
8568 // object was running against a wall
8572 if (GFX_ELEMENT(element) != EL_SAND) // !!! FIX THIS (crumble) !!!
8573 DrawLevelElementAnimation(x, y, element);
8575 if (DONT_TOUCH(element))
8576 TestIfBadThingTouchesPlayer(x, y);
8581 InitMovingField(x, y, MovDir[x][y]);
8583 PlayLevelSoundAction(x, y, ACTION_MOVING);
8587 ContinueMoving(x, y);
8590 void ContinueMoving(int x, int y)
8592 int element = Tile[x][y];
8593 struct ElementInfo *ei = &element_info[element];
8594 int direction = MovDir[x][y];
8595 int dx = (direction == MV_LEFT ? -1 : direction == MV_RIGHT ? +1 : 0);
8596 int dy = (direction == MV_UP ? -1 : direction == MV_DOWN ? +1 : 0);
8597 int newx = x + dx, newy = y + dy;
8598 int stored = Store[x][y];
8599 int stored_new = Store[newx][newy];
8600 boolean pushed_by_player = (Pushed[x][y] && IS_PLAYER(x, y));
8601 boolean pushed_by_conveyor = (Pushed[x][y] && !IS_PLAYER(x, y));
8602 boolean last_line = (newy == lev_fieldy - 1);
8603 boolean use_step_delay = (GET_MAX_STEP_DELAY(element) != 0);
8605 if (pushed_by_player) // special case: moving object pushed by player
8607 MovPos[x][y] = SIGN(MovPos[x][y]) * (TILEX - ABS(PLAYERINFO(x,y)->MovPos));
8609 else if (use_step_delay) // special case: moving object has step delay
8611 if (!MovDelay[x][y])
8612 MovPos[x][y] += getElementMoveStepsize(x, y);
8617 MovDelay[x][y] = GET_NEW_STEP_DELAY(element);
8621 TEST_DrawLevelField(x, y);
8623 return; // element is still waiting
8626 else // normal case: generically moving object
8628 MovPos[x][y] += getElementMoveStepsize(x, y);
8631 if (ABS(MovPos[x][y]) < TILEX)
8633 TEST_DrawLevelField(x, y);
8635 return; // element is still moving
8638 // element reached destination field
8640 Tile[x][y] = EL_EMPTY;
8641 Tile[newx][newy] = element;
8642 MovPos[x][y] = 0; // force "not moving" for "crumbled sand"
8644 if (Store[x][y] == EL_ACID) // element is moving into acid pool
8646 element = Tile[newx][newy] = EL_ACID;
8648 else if (element == EL_MOLE)
8650 Tile[x][y] = EL_SAND;
8652 TEST_DrawLevelFieldCrumbledNeighbours(x, y);
8654 else if (element == EL_QUICKSAND_FILLING)
8656 element = Tile[newx][newy] = get_next_element(element);
8657 Store[newx][newy] = Store[x][y];
8659 else if (element == EL_QUICKSAND_EMPTYING)
8661 Tile[x][y] = get_next_element(element);
8662 element = Tile[newx][newy] = Store[x][y];
8664 else if (element == EL_QUICKSAND_FAST_FILLING)
8666 element = Tile[newx][newy] = get_next_element(element);
8667 Store[newx][newy] = Store[x][y];
8669 else if (element == EL_QUICKSAND_FAST_EMPTYING)
8671 Tile[x][y] = get_next_element(element);
8672 element = Tile[newx][newy] = Store[x][y];
8674 else if (element == EL_MAGIC_WALL_FILLING)
8676 element = Tile[newx][newy] = get_next_element(element);
8677 if (!game.magic_wall_active)
8678 element = Tile[newx][newy] = EL_MAGIC_WALL_DEAD;
8679 Store[newx][newy] = Store[x][y];
8681 else if (element == EL_MAGIC_WALL_EMPTYING)
8683 Tile[x][y] = get_next_element(element);
8684 if (!game.magic_wall_active)
8685 Tile[x][y] = EL_MAGIC_WALL_DEAD;
8686 element = Tile[newx][newy] = Store[x][y];
8688 InitField(newx, newy, FALSE);
8690 else if (element == EL_BD_MAGIC_WALL_FILLING)
8692 element = Tile[newx][newy] = get_next_element(element);
8693 if (!game.magic_wall_active)
8694 element = Tile[newx][newy] = EL_BD_MAGIC_WALL_DEAD;
8695 Store[newx][newy] = Store[x][y];
8697 else if (element == EL_BD_MAGIC_WALL_EMPTYING)
8699 Tile[x][y] = get_next_element(element);
8700 if (!game.magic_wall_active)
8701 Tile[x][y] = EL_BD_MAGIC_WALL_DEAD;
8702 element = Tile[newx][newy] = Store[x][y];
8704 InitField(newx, newy, FALSE);
8706 else if (element == EL_DC_MAGIC_WALL_FILLING)
8708 element = Tile[newx][newy] = get_next_element(element);
8709 if (!game.magic_wall_active)
8710 element = Tile[newx][newy] = EL_DC_MAGIC_WALL_DEAD;
8711 Store[newx][newy] = Store[x][y];
8713 else if (element == EL_DC_MAGIC_WALL_EMPTYING)
8715 Tile[x][y] = get_next_element(element);
8716 if (!game.magic_wall_active)
8717 Tile[x][y] = EL_DC_MAGIC_WALL_DEAD;
8718 element = Tile[newx][newy] = Store[x][y];
8720 InitField(newx, newy, FALSE);
8722 else if (element == EL_AMOEBA_DROPPING)
8724 Tile[x][y] = get_next_element(element);
8725 element = Tile[newx][newy] = Store[x][y];
8727 else if (element == EL_SOKOBAN_OBJECT)
8730 Tile[x][y] = Back[x][y];
8732 if (Back[newx][newy])
8733 Tile[newx][newy] = EL_SOKOBAN_FIELD_FULL;
8735 Back[x][y] = Back[newx][newy] = 0;
8738 Store[x][y] = EL_EMPTY;
8743 MovDelay[newx][newy] = 0;
8745 if (CAN_CHANGE_OR_HAS_ACTION(element))
8747 // copy element change control values to new field
8748 ChangeDelay[newx][newy] = ChangeDelay[x][y];
8749 ChangePage[newx][newy] = ChangePage[x][y];
8750 ChangeCount[newx][newy] = ChangeCount[x][y];
8751 ChangeEvent[newx][newy] = ChangeEvent[x][y];
8754 CustomValue[newx][newy] = CustomValue[x][y];
8756 ChangeDelay[x][y] = 0;
8757 ChangePage[x][y] = -1;
8758 ChangeCount[x][y] = 0;
8759 ChangeEvent[x][y] = -1;
8761 CustomValue[x][y] = 0;
8763 // copy animation control values to new field
8764 GfxFrame[newx][newy] = GfxFrame[x][y];
8765 GfxRandom[newx][newy] = GfxRandom[x][y]; // keep same random value
8766 GfxAction[newx][newy] = GfxAction[x][y]; // keep action one frame
8767 GfxDir[newx][newy] = GfxDir[x][y]; // keep element direction
8769 Pushed[x][y] = Pushed[newx][newy] = FALSE;
8771 // some elements can leave other elements behind after moving
8772 if (ei->move_leave_element != EL_EMPTY &&
8773 (ei->move_leave_type == LEAVE_TYPE_UNLIMITED || stored != EL_EMPTY) &&
8774 (!IS_PLAYER(x, y) || IS_WALKABLE(ei->move_leave_element)))
8776 int move_leave_element = ei->move_leave_element;
8778 // this makes it possible to leave the removed element again
8779 if (ei->move_leave_element == EL_TRIGGER_ELEMENT)
8780 move_leave_element = (stored == EL_ACID ? EL_EMPTY : stored);
8782 Tile[x][y] = move_leave_element;
8784 if (element_info[Tile[x][y]].move_direction_initial == MV_START_PREVIOUS)
8785 MovDir[x][y] = direction;
8787 InitField(x, y, FALSE);
8789 if (GFX_CRUMBLED(Tile[x][y]))
8790 TEST_DrawLevelFieldCrumbledNeighbours(x, y);
8792 if (IS_PLAYER_ELEMENT(move_leave_element))
8793 RelocatePlayer(x, y, move_leave_element);
8796 // do this after checking for left-behind element
8797 ResetGfxAnimation(x, y); // reset animation values for old field
8799 if (!CAN_MOVE(element) ||
8800 (CAN_FALL(element) && direction == MV_DOWN &&
8801 (element == EL_SPRING ||
8802 element_info[element].move_pattern == MV_WHEN_PUSHED ||
8803 element_info[element].move_pattern == MV_WHEN_DROPPED)))
8804 GfxDir[x][y] = MovDir[newx][newy] = 0;
8806 TEST_DrawLevelField(x, y);
8807 TEST_DrawLevelField(newx, newy);
8809 Stop[newx][newy] = TRUE; // ignore this element until the next frame
8811 // prevent pushed element from moving on in pushed direction
8812 if (pushed_by_player && CAN_MOVE(element) &&
8813 element_info[element].move_pattern & MV_ANY_DIRECTION &&
8814 !(element_info[element].move_pattern & direction))
8815 TurnRound(newx, newy);
8817 // prevent elements on conveyor belt from moving on in last direction
8818 if (pushed_by_conveyor && CAN_FALL(element) &&
8819 direction & MV_HORIZONTAL)
8820 MovDir[newx][newy] = 0;
8822 if (!pushed_by_player)
8824 int nextx = newx + dx, nexty = newy + dy;
8825 boolean check_collision_again = IN_LEV_FIELD_AND_IS_FREE(nextx, nexty);
8827 WasJustMoving[newx][newy] = CHECK_DELAY_MOVING;
8829 if (CAN_FALL(element) && direction == MV_DOWN)
8830 WasJustFalling[newx][newy] = CHECK_DELAY_FALLING;
8832 if ((!CAN_FALL(element) || direction == MV_DOWN) && check_collision_again)
8833 CheckCollision[newx][newy] = CHECK_DELAY_COLLISION;
8835 if (CAN_FALL(element) && direction == MV_DOWN && check_collision_again)
8836 CheckImpact[newx][newy] = CHECK_DELAY_IMPACT;
8839 if (DONT_TOUCH(element)) // object may be nasty to player or others
8841 TestIfBadThingTouchesPlayer(newx, newy);
8842 TestIfBadThingTouchesFriend(newx, newy);
8844 if (!IS_CUSTOM_ELEMENT(element))
8845 TestIfBadThingTouchesOtherBadThing(newx, newy);
8847 else if (element == EL_PENGUIN)
8848 TestIfFriendTouchesBadThing(newx, newy);
8850 if (DONT_GET_HIT_BY(element))
8852 TestIfGoodThingGetsHitByBadThing(newx, newy, direction);
8855 // give the player one last chance (one more frame) to move away
8856 if (CAN_FALL(element) && direction == MV_DOWN &&
8857 (last_line || (!IS_FREE(x, newy + 1) &&
8858 (!IS_PLAYER(x, newy + 1) ||
8859 game.engine_version < VERSION_IDENT(3,1,1,0)))))
8862 if (pushed_by_player && !game.use_change_when_pushing_bug)
8864 int push_side = MV_DIR_OPPOSITE(direction);
8865 struct PlayerInfo *player = PLAYERINFO(x, y);
8867 CheckElementChangeByPlayer(newx, newy, element, CE_PUSHED_BY_PLAYER,
8868 player->index_bit, push_side);
8869 CheckTriggeredElementChangeByPlayer(newx,newy, element, CE_PLAYER_PUSHES_X,
8870 player->index_bit, push_side);
8873 if (element == EL_EMC_ANDROID && pushed_by_player) // make another move
8874 MovDelay[newx][newy] = 1;
8876 CheckTriggeredElementChangeBySide(x, y, element, CE_MOVE_OF_X, direction);
8878 TestIfElementTouchesCustomElement(x, y); // empty or new element
8879 TestIfElementHitsCustomElement(newx, newy, direction);
8880 TestIfPlayerTouchesCustomElement(newx, newy);
8881 TestIfElementTouchesCustomElement(newx, newy);
8883 if (IS_CUSTOM_ELEMENT(element) && ei->move_enter_element != EL_EMPTY &&
8884 IS_EQUAL_OR_IN_GROUP(stored_new, ei->move_enter_element))
8885 CheckElementChangeBySide(newx, newy, element, stored_new, CE_DIGGING_X,
8886 MV_DIR_OPPOSITE(direction));
8889 int AmoebaNeighbourNr(int ax, int ay)
8892 int element = Tile[ax][ay];
8894 static int xy[4][2] =
8902 for (i = 0; i < NUM_DIRECTIONS; i++)
8904 int x = ax + xy[i][0];
8905 int y = ay + xy[i][1];
8907 if (!IN_LEV_FIELD(x, y))
8910 if (Tile[x][y] == element && AmoebaNr[x][y] > 0)
8911 group_nr = AmoebaNr[x][y];
8917 static void AmoebaMerge(int ax, int ay)
8919 int i, x, y, xx, yy;
8920 int new_group_nr = AmoebaNr[ax][ay];
8921 static int xy[4][2] =
8929 if (new_group_nr == 0)
8932 for (i = 0; i < NUM_DIRECTIONS; i++)
8937 if (!IN_LEV_FIELD(x, y))
8940 if ((Tile[x][y] == EL_AMOEBA_FULL ||
8941 Tile[x][y] == EL_BD_AMOEBA ||
8942 Tile[x][y] == EL_AMOEBA_DEAD) &&
8943 AmoebaNr[x][y] != new_group_nr)
8945 int old_group_nr = AmoebaNr[x][y];
8947 if (old_group_nr == 0)
8950 AmoebaCnt[new_group_nr] += AmoebaCnt[old_group_nr];
8951 AmoebaCnt[old_group_nr] = 0;
8952 AmoebaCnt2[new_group_nr] += AmoebaCnt2[old_group_nr];
8953 AmoebaCnt2[old_group_nr] = 0;
8955 SCAN_PLAYFIELD(xx, yy)
8957 if (AmoebaNr[xx][yy] == old_group_nr)
8958 AmoebaNr[xx][yy] = new_group_nr;
8964 void AmoebaToDiamond(int ax, int ay)
8968 if (Tile[ax][ay] == EL_AMOEBA_DEAD)
8970 int group_nr = AmoebaNr[ax][ay];
8975 Debug("game:playing:AmoebaToDiamond", "ax = %d, ay = %d", ax, ay);
8976 Debug("game:playing:AmoebaToDiamond", "This should never happen!");
8982 SCAN_PLAYFIELD(x, y)
8984 if (Tile[x][y] == EL_AMOEBA_DEAD && AmoebaNr[x][y] == group_nr)
8987 Tile[x][y] = EL_AMOEBA_TO_DIAMOND;
8991 PlayLevelSound(ax, ay, (IS_GEM(level.amoeba_content) ?
8992 SND_AMOEBA_TURNING_TO_GEM :
8993 SND_AMOEBA_TURNING_TO_ROCK));
8998 static int xy[4][2] =
9006 for (i = 0; i < NUM_DIRECTIONS; i++)
9011 if (!IN_LEV_FIELD(x, y))
9014 if (Tile[x][y] == EL_AMOEBA_TO_DIAMOND)
9016 PlayLevelSound(x, y, (IS_GEM(level.amoeba_content) ?
9017 SND_AMOEBA_TURNING_TO_GEM :
9018 SND_AMOEBA_TURNING_TO_ROCK));
9025 static void AmoebaToDiamondBD(int ax, int ay, int new_element)
9028 int group_nr = AmoebaNr[ax][ay];
9029 boolean done = FALSE;
9034 Debug("game:playing:AmoebaToDiamondBD", "ax = %d, ay = %d", ax, ay);
9035 Debug("game:playing:AmoebaToDiamondBD", "This should never happen!");
9041 SCAN_PLAYFIELD(x, y)
9043 if (AmoebaNr[x][y] == group_nr &&
9044 (Tile[x][y] == EL_AMOEBA_DEAD ||
9045 Tile[x][y] == EL_BD_AMOEBA ||
9046 Tile[x][y] == EL_AMOEBA_GROWING))
9049 Tile[x][y] = new_element;
9050 InitField(x, y, FALSE);
9051 TEST_DrawLevelField(x, y);
9057 PlayLevelSound(ax, ay, (new_element == EL_BD_ROCK ?
9058 SND_BD_AMOEBA_TURNING_TO_ROCK :
9059 SND_BD_AMOEBA_TURNING_TO_GEM));
9062 static void AmoebaGrowing(int x, int y)
9064 static unsigned int sound_delay = 0;
9065 static unsigned int sound_delay_value = 0;
9067 if (!MovDelay[x][y]) // start new growing cycle
9071 if (DelayReached(&sound_delay, sound_delay_value))
9073 PlayLevelSoundElementAction(x, y, Store[x][y], ACTION_GROWING);
9074 sound_delay_value = 30;
9078 if (MovDelay[x][y]) // wait some time before growing bigger
9081 if (MovDelay[x][y]/2 && IN_SCR_FIELD(SCREENX(x), SCREENY(y)))
9083 int frame = getGraphicAnimationFrame(IMG_AMOEBA_GROWING,
9084 6 - MovDelay[x][y]);
9086 DrawGraphic(SCREENX(x), SCREENY(y), IMG_AMOEBA_GROWING, frame);
9089 if (!MovDelay[x][y])
9091 Tile[x][y] = Store[x][y];
9093 TEST_DrawLevelField(x, y);
9098 static void AmoebaShrinking(int x, int y)
9100 static unsigned int sound_delay = 0;
9101 static unsigned int sound_delay_value = 0;
9103 if (!MovDelay[x][y]) // start new shrinking cycle
9107 if (DelayReached(&sound_delay, sound_delay_value))
9108 sound_delay_value = 30;
9111 if (MovDelay[x][y]) // wait some time before shrinking
9114 if (MovDelay[x][y]/2 && IN_SCR_FIELD(SCREENX(x), SCREENY(y)))
9116 int frame = getGraphicAnimationFrame(IMG_AMOEBA_SHRINKING,
9117 6 - MovDelay[x][y]);
9119 DrawGraphic(SCREENX(x), SCREENY(y), IMG_AMOEBA_SHRINKING, frame);
9122 if (!MovDelay[x][y])
9124 Tile[x][y] = EL_EMPTY;
9125 TEST_DrawLevelField(x, y);
9127 // don't let mole enter this field in this cycle;
9128 // (give priority to objects falling to this field from above)
9134 static void AmoebaReproduce(int ax, int ay)
9137 int element = Tile[ax][ay];
9138 int graphic = el2img(element);
9139 int newax = ax, neway = ay;
9140 boolean can_drop = (element == EL_AMOEBA_WET || element == EL_EMC_DRIPPER);
9141 static int xy[4][2] =
9149 if (!level.amoeba_speed && element != EL_EMC_DRIPPER)
9151 Tile[ax][ay] = EL_AMOEBA_DEAD;
9152 TEST_DrawLevelField(ax, ay);
9156 if (IS_ANIMATED(graphic))
9157 DrawLevelGraphicAnimationIfNeeded(ax, ay, graphic);
9159 if (!MovDelay[ax][ay]) // start making new amoeba field
9160 MovDelay[ax][ay] = RND(FRAMES_PER_SECOND * 25 / (1 + level.amoeba_speed));
9162 if (MovDelay[ax][ay]) // wait some time before making new amoeba
9165 if (MovDelay[ax][ay])
9169 if (can_drop) // EL_AMOEBA_WET or EL_EMC_DRIPPER
9172 int x = ax + xy[start][0];
9173 int y = ay + xy[start][1];
9175 if (!IN_LEV_FIELD(x, y))
9178 if (IS_FREE(x, y) ||
9179 CAN_GROW_INTO(Tile[x][y]) ||
9180 Tile[x][y] == EL_QUICKSAND_EMPTY ||
9181 Tile[x][y] == EL_QUICKSAND_FAST_EMPTY)
9187 if (newax == ax && neway == ay)
9190 else // normal or "filled" (BD style) amoeba
9193 boolean waiting_for_player = FALSE;
9195 for (i = 0; i < NUM_DIRECTIONS; i++)
9197 int j = (start + i) % 4;
9198 int x = ax + xy[j][0];
9199 int y = ay + xy[j][1];
9201 if (!IN_LEV_FIELD(x, y))
9204 if (IS_FREE(x, y) ||
9205 CAN_GROW_INTO(Tile[x][y]) ||
9206 Tile[x][y] == EL_QUICKSAND_EMPTY ||
9207 Tile[x][y] == EL_QUICKSAND_FAST_EMPTY)
9213 else if (IS_PLAYER(x, y))
9214 waiting_for_player = TRUE;
9217 if (newax == ax && neway == ay) // amoeba cannot grow
9219 if (i == 4 && (!waiting_for_player || element == EL_BD_AMOEBA))
9221 Tile[ax][ay] = EL_AMOEBA_DEAD;
9222 TEST_DrawLevelField(ax, ay);
9223 AmoebaCnt[AmoebaNr[ax][ay]]--;
9225 if (AmoebaCnt[AmoebaNr[ax][ay]] <= 0) // amoeba is completely dead
9227 if (element == EL_AMOEBA_FULL)
9228 AmoebaToDiamond(ax, ay);
9229 else if (element == EL_BD_AMOEBA)
9230 AmoebaToDiamondBD(ax, ay, level.amoeba_content);
9235 else if (element == EL_AMOEBA_FULL || element == EL_BD_AMOEBA)
9237 // amoeba gets larger by growing in some direction
9239 int new_group_nr = AmoebaNr[ax][ay];
9242 if (new_group_nr == 0)
9244 Debug("game:playing:AmoebaReproduce", "newax = %d, neway = %d",
9246 Debug("game:playing:AmoebaReproduce", "This should never happen!");
9252 AmoebaNr[newax][neway] = new_group_nr;
9253 AmoebaCnt[new_group_nr]++;
9254 AmoebaCnt2[new_group_nr]++;
9256 // if amoeba touches other amoeba(s) after growing, unify them
9257 AmoebaMerge(newax, neway);
9259 if (element == EL_BD_AMOEBA && AmoebaCnt2[new_group_nr] >= 200)
9261 AmoebaToDiamondBD(newax, neway, EL_BD_ROCK);
9267 if (!can_drop || neway < ay || !IS_FREE(newax, neway) ||
9268 (neway == lev_fieldy - 1 && newax != ax))
9270 Tile[newax][neway] = EL_AMOEBA_GROWING; // creation of new amoeba
9271 Store[newax][neway] = element;
9273 else if (neway == ay || element == EL_EMC_DRIPPER)
9275 Tile[newax][neway] = EL_AMOEBA_DROP; // drop left/right of amoeba
9277 PlayLevelSoundAction(newax, neway, ACTION_GROWING);
9281 InitMovingField(ax, ay, MV_DOWN); // drop dripping from amoeba
9282 Tile[ax][ay] = EL_AMOEBA_DROPPING;
9283 Store[ax][ay] = EL_AMOEBA_DROP;
9284 ContinueMoving(ax, ay);
9288 TEST_DrawLevelField(newax, neway);
9291 static void Life(int ax, int ay)
9295 int element = Tile[ax][ay];
9296 int graphic = el2img(element);
9297 int *life_parameter = (element == EL_GAME_OF_LIFE ? level.game_of_life :
9299 boolean changed = FALSE;
9301 if (IS_ANIMATED(graphic))
9302 DrawLevelGraphicAnimationIfNeeded(ax, ay, graphic);
9307 if (!MovDelay[ax][ay]) // start new "game of life" cycle
9308 MovDelay[ax][ay] = life_time;
9310 if (MovDelay[ax][ay]) // wait some time before next cycle
9313 if (MovDelay[ax][ay])
9317 for (y1 = -1; y1 < 2; y1++) for (x1 = -1; x1 < 2; x1++)
9319 int xx = ax+x1, yy = ay+y1;
9320 int old_element = Tile[xx][yy];
9321 int num_neighbours = 0;
9323 if (!IN_LEV_FIELD(xx, yy))
9326 for (y2 = -1; y2 < 2; y2++) for (x2 = -1; x2 < 2; x2++)
9328 int x = xx+x2, y = yy+y2;
9330 if (!IN_LEV_FIELD(x, y) || (x == xx && y == yy))
9333 boolean is_player_cell = (element == EL_GAME_OF_LIFE && IS_PLAYER(x, y));
9334 boolean is_neighbour = FALSE;
9336 if (level.use_life_bugs)
9338 (((Tile[x][y] == element || is_player_cell) && !Stop[x][y]) ||
9339 (IS_FREE(x, y) && Stop[x][y]));
9342 (Last[x][y] == element || is_player_cell);
9348 boolean is_free = FALSE;
9350 if (level.use_life_bugs)
9351 is_free = (IS_FREE(xx, yy));
9353 is_free = (IS_FREE(xx, yy) && Last[xx][yy] == EL_EMPTY);
9355 if (xx == ax && yy == ay) // field in the middle
9357 if (num_neighbours < life_parameter[0] ||
9358 num_neighbours > life_parameter[1])
9360 Tile[xx][yy] = EL_EMPTY;
9361 if (Tile[xx][yy] != old_element)
9362 TEST_DrawLevelField(xx, yy);
9363 Stop[xx][yy] = TRUE;
9367 else if (is_free || CAN_GROW_INTO(Tile[xx][yy]))
9368 { // free border field
9369 if (num_neighbours >= life_parameter[2] &&
9370 num_neighbours <= life_parameter[3])
9372 Tile[xx][yy] = element;
9373 MovDelay[xx][yy] = (element == EL_GAME_OF_LIFE ? 0 : life_time-1);
9374 if (Tile[xx][yy] != old_element)
9375 TEST_DrawLevelField(xx, yy);
9376 Stop[xx][yy] = TRUE;
9383 PlayLevelSound(ax, ay, element == EL_BIOMAZE ? SND_BIOMAZE_GROWING :
9384 SND_GAME_OF_LIFE_GROWING);
9387 static void InitRobotWheel(int x, int y)
9389 ChangeDelay[x][y] = level.time_wheel * FRAMES_PER_SECOND;
9392 static void RunRobotWheel(int x, int y)
9394 PlayLevelSound(x, y, SND_ROBOT_WHEEL_ACTIVE);
9397 static void StopRobotWheel(int x, int y)
9399 if (game.robot_wheel_x == x &&
9400 game.robot_wheel_y == y)
9402 game.robot_wheel_x = -1;
9403 game.robot_wheel_y = -1;
9404 game.robot_wheel_active = FALSE;
9408 static void InitTimegateWheel(int x, int y)
9410 ChangeDelay[x][y] = level.time_timegate * FRAMES_PER_SECOND;
9413 static void RunTimegateWheel(int x, int y)
9415 PlayLevelSound(x, y, SND_CLASS_TIMEGATE_SWITCH_ACTIVE);
9418 static void InitMagicBallDelay(int x, int y)
9420 ChangeDelay[x][y] = (level.ball_time + 1) * 8 + 1;
9423 static void ActivateMagicBall(int bx, int by)
9427 if (level.ball_random)
9429 int pos_border = RND(8); // select one of the eight border elements
9430 int pos_content = (pos_border > 3 ? pos_border + 1 : pos_border);
9431 int xx = pos_content % 3;
9432 int yy = pos_content / 3;
9437 if (IN_LEV_FIELD(x, y) && Tile[x][y] == EL_EMPTY)
9438 CreateField(x, y, level.ball_content[game.ball_content_nr].e[xx][yy]);
9442 for (y = by - 1; y <= by + 1; y++) for (x = bx - 1; x <= bx + 1; x++)
9444 int xx = x - bx + 1;
9445 int yy = y - by + 1;
9447 if (IN_LEV_FIELD(x, y) && Tile[x][y] == EL_EMPTY)
9448 CreateField(x, y, level.ball_content[game.ball_content_nr].e[xx][yy]);
9452 game.ball_content_nr = (game.ball_content_nr + 1) % level.num_ball_contents;
9455 static void CheckExit(int x, int y)
9457 if (game.gems_still_needed > 0 ||
9458 game.sokoban_fields_still_needed > 0 ||
9459 game.sokoban_objects_still_needed > 0 ||
9460 game.lights_still_needed > 0)
9462 int element = Tile[x][y];
9463 int graphic = el2img(element);
9465 if (IS_ANIMATED(graphic))
9466 DrawLevelGraphicAnimationIfNeeded(x, y, graphic);
9471 // do not re-open exit door closed after last player
9472 if (game.all_players_gone)
9475 Tile[x][y] = EL_EXIT_OPENING;
9477 PlayLevelSoundNearest(x, y, SND_CLASS_EXIT_OPENING);
9480 static void CheckExitEM(int x, int y)
9482 if (game.gems_still_needed > 0 ||
9483 game.sokoban_fields_still_needed > 0 ||
9484 game.sokoban_objects_still_needed > 0 ||
9485 game.lights_still_needed > 0)
9487 int element = Tile[x][y];
9488 int graphic = el2img(element);
9490 if (IS_ANIMATED(graphic))
9491 DrawLevelGraphicAnimationIfNeeded(x, y, graphic);
9496 // do not re-open exit door closed after last player
9497 if (game.all_players_gone)
9500 Tile[x][y] = EL_EM_EXIT_OPENING;
9502 PlayLevelSoundNearest(x, y, SND_CLASS_EM_EXIT_OPENING);
9505 static void CheckExitSteel(int x, int y)
9507 if (game.gems_still_needed > 0 ||
9508 game.sokoban_fields_still_needed > 0 ||
9509 game.sokoban_objects_still_needed > 0 ||
9510 game.lights_still_needed > 0)
9512 int element = Tile[x][y];
9513 int graphic = el2img(element);
9515 if (IS_ANIMATED(graphic))
9516 DrawLevelGraphicAnimationIfNeeded(x, y, graphic);
9521 // do not re-open exit door closed after last player
9522 if (game.all_players_gone)
9525 Tile[x][y] = EL_STEEL_EXIT_OPENING;
9527 PlayLevelSoundNearest(x, y, SND_CLASS_STEEL_EXIT_OPENING);
9530 static void CheckExitSteelEM(int x, int y)
9532 if (game.gems_still_needed > 0 ||
9533 game.sokoban_fields_still_needed > 0 ||
9534 game.sokoban_objects_still_needed > 0 ||
9535 game.lights_still_needed > 0)
9537 int element = Tile[x][y];
9538 int graphic = el2img(element);
9540 if (IS_ANIMATED(graphic))
9541 DrawLevelGraphicAnimationIfNeeded(x, y, graphic);
9546 // do not re-open exit door closed after last player
9547 if (game.all_players_gone)
9550 Tile[x][y] = EL_EM_STEEL_EXIT_OPENING;
9552 PlayLevelSoundNearest(x, y, SND_CLASS_EM_STEEL_EXIT_OPENING);
9555 static void CheckExitSP(int x, int y)
9557 if (game.gems_still_needed > 0)
9559 int element = Tile[x][y];
9560 int graphic = el2img(element);
9562 if (IS_ANIMATED(graphic))
9563 DrawLevelGraphicAnimationIfNeeded(x, y, graphic);
9568 // do not re-open exit door closed after last player
9569 if (game.all_players_gone)
9572 Tile[x][y] = EL_SP_EXIT_OPENING;
9574 PlayLevelSoundNearest(x, y, SND_CLASS_SP_EXIT_OPENING);
9577 static void CloseAllOpenTimegates(void)
9581 SCAN_PLAYFIELD(x, y)
9583 int element = Tile[x][y];
9585 if (element == EL_TIMEGATE_OPEN || element == EL_TIMEGATE_OPENING)
9587 Tile[x][y] = EL_TIMEGATE_CLOSING;
9589 PlayLevelSoundAction(x, y, ACTION_CLOSING);
9594 static void DrawTwinkleOnField(int x, int y)
9596 if (!IN_SCR_FIELD(SCREENX(x), SCREENY(y)) || IS_MOVING(x, y))
9599 if (Tile[x][y] == EL_BD_DIAMOND)
9602 if (MovDelay[x][y] == 0) // next animation frame
9603 MovDelay[x][y] = 11 * !GetSimpleRandom(500);
9605 if (MovDelay[x][y] != 0) // wait some time before next frame
9609 DrawLevelElementAnimation(x, y, Tile[x][y]);
9611 if (MovDelay[x][y] != 0)
9613 int frame = getGraphicAnimationFrame(IMG_TWINKLE_WHITE,
9614 10 - MovDelay[x][y]);
9616 DrawGraphicThruMask(SCREENX(x), SCREENY(y), IMG_TWINKLE_WHITE, frame);
9621 static void MauerWaechst(int x, int y)
9625 if (!MovDelay[x][y]) // next animation frame
9626 MovDelay[x][y] = 3 * delay;
9628 if (MovDelay[x][y]) // wait some time before next frame
9632 if (IN_SCR_FIELD(SCREENX(x), SCREENY(y)))
9634 int graphic = el_dir2img(Tile[x][y], GfxDir[x][y]);
9635 int frame = getGraphicAnimationFrame(graphic, 17 - MovDelay[x][y]);
9637 DrawGraphic(SCREENX(x), SCREENY(y), graphic, frame);
9640 if (!MovDelay[x][y])
9642 if (MovDir[x][y] == MV_LEFT)
9644 if (IN_LEV_FIELD(x - 1, y) && IS_WALL(Tile[x - 1][y]))
9645 TEST_DrawLevelField(x - 1, y);
9647 else if (MovDir[x][y] == MV_RIGHT)
9649 if (IN_LEV_FIELD(x + 1, y) && IS_WALL(Tile[x + 1][y]))
9650 TEST_DrawLevelField(x + 1, y);
9652 else if (MovDir[x][y] == MV_UP)
9654 if (IN_LEV_FIELD(x, y - 1) && IS_WALL(Tile[x][y - 1]))
9655 TEST_DrawLevelField(x, y - 1);
9659 if (IN_LEV_FIELD(x, y + 1) && IS_WALL(Tile[x][y + 1]))
9660 TEST_DrawLevelField(x, y + 1);
9663 Tile[x][y] = Store[x][y];
9665 GfxDir[x][y] = MovDir[x][y] = MV_NONE;
9666 TEST_DrawLevelField(x, y);
9671 static void MauerAbleger(int ax, int ay)
9673 int element = Tile[ax][ay];
9674 int graphic = el2img(element);
9675 boolean oben_frei = FALSE, unten_frei = FALSE;
9676 boolean links_frei = FALSE, rechts_frei = FALSE;
9677 boolean oben_massiv = FALSE, unten_massiv = FALSE;
9678 boolean links_massiv = FALSE, rechts_massiv = FALSE;
9679 boolean new_wall = FALSE;
9681 if (IS_ANIMATED(graphic))
9682 DrawLevelGraphicAnimationIfNeeded(ax, ay, graphic);
9684 if (!MovDelay[ax][ay]) // start building new wall
9685 MovDelay[ax][ay] = 6;
9687 if (MovDelay[ax][ay]) // wait some time before building new wall
9690 if (MovDelay[ax][ay])
9694 if (IN_LEV_FIELD(ax, ay-1) && IS_FREE(ax, ay-1))
9696 if (IN_LEV_FIELD(ax, ay+1) && IS_FREE(ax, ay+1))
9698 if (IN_LEV_FIELD(ax-1, ay) && IS_FREE(ax-1, ay))
9700 if (IN_LEV_FIELD(ax+1, ay) && IS_FREE(ax+1, ay))
9703 if (element == EL_EXPANDABLE_WALL_VERTICAL ||
9704 element == EL_EXPANDABLE_WALL_ANY)
9708 Tile[ax][ay-1] = EL_EXPANDABLE_WALL_GROWING;
9709 Store[ax][ay-1] = element;
9710 GfxDir[ax][ay-1] = MovDir[ax][ay-1] = MV_UP;
9711 if (IN_SCR_FIELD(SCREENX(ax), SCREENY(ay-1)))
9712 DrawGraphic(SCREENX(ax), SCREENY(ay - 1),
9713 IMG_EXPANDABLE_WALL_GROWING_UP, 0);
9718 Tile[ax][ay+1] = EL_EXPANDABLE_WALL_GROWING;
9719 Store[ax][ay+1] = element;
9720 GfxDir[ax][ay+1] = MovDir[ax][ay+1] = MV_DOWN;
9721 if (IN_SCR_FIELD(SCREENX(ax), SCREENY(ay+1)))
9722 DrawGraphic(SCREENX(ax), SCREENY(ay + 1),
9723 IMG_EXPANDABLE_WALL_GROWING_DOWN, 0);
9728 if (element == EL_EXPANDABLE_WALL_HORIZONTAL ||
9729 element == EL_EXPANDABLE_WALL_ANY ||
9730 element == EL_EXPANDABLE_WALL ||
9731 element == EL_BD_EXPANDABLE_WALL)
9735 Tile[ax-1][ay] = EL_EXPANDABLE_WALL_GROWING;
9736 Store[ax-1][ay] = element;
9737 GfxDir[ax-1][ay] = MovDir[ax-1][ay] = MV_LEFT;
9738 if (IN_SCR_FIELD(SCREENX(ax-1), SCREENY(ay)))
9739 DrawGraphic(SCREENX(ax - 1), SCREENY(ay),
9740 IMG_EXPANDABLE_WALL_GROWING_LEFT, 0);
9746 Tile[ax+1][ay] = EL_EXPANDABLE_WALL_GROWING;
9747 Store[ax+1][ay] = element;
9748 GfxDir[ax+1][ay] = MovDir[ax+1][ay] = MV_RIGHT;
9749 if (IN_SCR_FIELD(SCREENX(ax+1), SCREENY(ay)))
9750 DrawGraphic(SCREENX(ax + 1), SCREENY(ay),
9751 IMG_EXPANDABLE_WALL_GROWING_RIGHT, 0);
9756 if (element == EL_EXPANDABLE_WALL && (links_frei || rechts_frei))
9757 TEST_DrawLevelField(ax, ay);
9759 if (!IN_LEV_FIELD(ax, ay-1) || IS_WALL(Tile[ax][ay-1]))
9761 if (!IN_LEV_FIELD(ax, ay+1) || IS_WALL(Tile[ax][ay+1]))
9762 unten_massiv = TRUE;
9763 if (!IN_LEV_FIELD(ax-1, ay) || IS_WALL(Tile[ax-1][ay]))
9764 links_massiv = TRUE;
9765 if (!IN_LEV_FIELD(ax+1, ay) || IS_WALL(Tile[ax+1][ay]))
9766 rechts_massiv = TRUE;
9768 if (((oben_massiv && unten_massiv) ||
9769 element == EL_EXPANDABLE_WALL_HORIZONTAL ||
9770 element == EL_EXPANDABLE_WALL) &&
9771 ((links_massiv && rechts_massiv) ||
9772 element == EL_EXPANDABLE_WALL_VERTICAL))
9773 Tile[ax][ay] = EL_WALL;
9776 PlayLevelSoundAction(ax, ay, ACTION_GROWING);
9779 static void MauerAblegerStahl(int ax, int ay)
9781 int element = Tile[ax][ay];
9782 int graphic = el2img(element);
9783 boolean oben_frei = FALSE, unten_frei = FALSE;
9784 boolean links_frei = FALSE, rechts_frei = FALSE;
9785 boolean oben_massiv = FALSE, unten_massiv = FALSE;
9786 boolean links_massiv = FALSE, rechts_massiv = FALSE;
9787 boolean new_wall = FALSE;
9789 if (IS_ANIMATED(graphic))
9790 DrawLevelGraphicAnimationIfNeeded(ax, ay, graphic);
9792 if (!MovDelay[ax][ay]) // start building new wall
9793 MovDelay[ax][ay] = 6;
9795 if (MovDelay[ax][ay]) // wait some time before building new wall
9798 if (MovDelay[ax][ay])
9802 if (IN_LEV_FIELD(ax, ay-1) && IS_FREE(ax, ay-1))
9804 if (IN_LEV_FIELD(ax, ay+1) && IS_FREE(ax, ay+1))
9806 if (IN_LEV_FIELD(ax-1, ay) && IS_FREE(ax-1, ay))
9808 if (IN_LEV_FIELD(ax+1, ay) && IS_FREE(ax+1, ay))
9811 if (element == EL_EXPANDABLE_STEELWALL_VERTICAL ||
9812 element == EL_EXPANDABLE_STEELWALL_ANY)
9816 Tile[ax][ay-1] = EL_EXPANDABLE_STEELWALL_GROWING;
9817 Store[ax][ay-1] = element;
9818 GfxDir[ax][ay-1] = MovDir[ax][ay-1] = MV_UP;
9819 if (IN_SCR_FIELD(SCREENX(ax), SCREENY(ay-1)))
9820 DrawGraphic(SCREENX(ax), SCREENY(ay - 1),
9821 IMG_EXPANDABLE_STEELWALL_GROWING_UP, 0);
9826 Tile[ax][ay+1] = EL_EXPANDABLE_STEELWALL_GROWING;
9827 Store[ax][ay+1] = element;
9828 GfxDir[ax][ay+1] = MovDir[ax][ay+1] = MV_DOWN;
9829 if (IN_SCR_FIELD(SCREENX(ax), SCREENY(ay+1)))
9830 DrawGraphic(SCREENX(ax), SCREENY(ay + 1),
9831 IMG_EXPANDABLE_STEELWALL_GROWING_DOWN, 0);
9836 if (element == EL_EXPANDABLE_STEELWALL_HORIZONTAL ||
9837 element == EL_EXPANDABLE_STEELWALL_ANY)
9841 Tile[ax-1][ay] = EL_EXPANDABLE_STEELWALL_GROWING;
9842 Store[ax-1][ay] = element;
9843 GfxDir[ax-1][ay] = MovDir[ax-1][ay] = MV_LEFT;
9844 if (IN_SCR_FIELD(SCREENX(ax-1), SCREENY(ay)))
9845 DrawGraphic(SCREENX(ax - 1), SCREENY(ay),
9846 IMG_EXPANDABLE_STEELWALL_GROWING_LEFT, 0);
9852 Tile[ax+1][ay] = EL_EXPANDABLE_STEELWALL_GROWING;
9853 Store[ax+1][ay] = element;
9854 GfxDir[ax+1][ay] = MovDir[ax+1][ay] = MV_RIGHT;
9855 if (IN_SCR_FIELD(SCREENX(ax+1), SCREENY(ay)))
9856 DrawGraphic(SCREENX(ax + 1), SCREENY(ay),
9857 IMG_EXPANDABLE_STEELWALL_GROWING_RIGHT, 0);
9862 if (!IN_LEV_FIELD(ax, ay-1) || IS_WALL(Tile[ax][ay-1]))
9864 if (!IN_LEV_FIELD(ax, ay+1) || IS_WALL(Tile[ax][ay+1]))
9865 unten_massiv = TRUE;
9866 if (!IN_LEV_FIELD(ax-1, ay) || IS_WALL(Tile[ax-1][ay]))
9867 links_massiv = TRUE;
9868 if (!IN_LEV_FIELD(ax+1, ay) || IS_WALL(Tile[ax+1][ay]))
9869 rechts_massiv = TRUE;
9871 if (((oben_massiv && unten_massiv) ||
9872 element == EL_EXPANDABLE_STEELWALL_HORIZONTAL) &&
9873 ((links_massiv && rechts_massiv) ||
9874 element == EL_EXPANDABLE_STEELWALL_VERTICAL))
9875 Tile[ax][ay] = EL_STEELWALL;
9878 PlayLevelSoundAction(ax, ay, ACTION_GROWING);
9881 static void CheckForDragon(int x, int y)
9884 boolean dragon_found = FALSE;
9885 static int xy[4][2] =
9893 for (i = 0; i < NUM_DIRECTIONS; i++)
9895 for (j = 0; j < 4; j++)
9897 int xx = x + j * xy[i][0], yy = y + j * xy[i][1];
9899 if (IN_LEV_FIELD(xx, yy) &&
9900 (Tile[xx][yy] == EL_FLAMES || Tile[xx][yy] == EL_DRAGON))
9902 if (Tile[xx][yy] == EL_DRAGON)
9903 dragon_found = TRUE;
9912 for (i = 0; i < NUM_DIRECTIONS; i++)
9914 for (j = 0; j < 3; j++)
9916 int xx = x + j * xy[i][0], yy = y + j * xy[i][1];
9918 if (IN_LEV_FIELD(xx, yy) && Tile[xx][yy] == EL_FLAMES)
9920 Tile[xx][yy] = EL_EMPTY;
9921 TEST_DrawLevelField(xx, yy);
9930 static void InitBuggyBase(int x, int y)
9932 int element = Tile[x][y];
9933 int activating_delay = FRAMES_PER_SECOND / 4;
9936 (element == EL_SP_BUGGY_BASE ?
9937 2 * FRAMES_PER_SECOND + RND(5 * FRAMES_PER_SECOND) - activating_delay :
9938 element == EL_SP_BUGGY_BASE_ACTIVATING ?
9940 element == EL_SP_BUGGY_BASE_ACTIVE ?
9941 1 * FRAMES_PER_SECOND + RND(1 * FRAMES_PER_SECOND) : 1);
9944 static void WarnBuggyBase(int x, int y)
9947 static int xy[4][2] =
9955 for (i = 0; i < NUM_DIRECTIONS; i++)
9957 int xx = x + xy[i][0];
9958 int yy = y + xy[i][1];
9960 if (IN_LEV_FIELD(xx, yy) && IS_PLAYER(xx, yy))
9962 PlayLevelSound(x, y, SND_SP_BUGGY_BASE_ACTIVE);
9969 static void InitTrap(int x, int y)
9971 ChangeDelay[x][y] = 2 * FRAMES_PER_SECOND + RND(5 * FRAMES_PER_SECOND);
9974 static void ActivateTrap(int x, int y)
9976 PlayLevelSound(x, y, SND_TRAP_ACTIVATING);
9979 static void ChangeActiveTrap(int x, int y)
9981 int graphic = IMG_TRAP_ACTIVE;
9983 // if new animation frame was drawn, correct crumbled sand border
9984 if (IS_NEW_FRAME(GfxFrame[x][y], graphic))
9985 TEST_DrawLevelFieldCrumbled(x, y);
9988 static int getSpecialActionElement(int element, int number, int base_element)
9990 return (element != EL_EMPTY ? element :
9991 number != -1 ? base_element + number - 1 :
9995 static int getModifiedActionNumber(int value_old, int operator, int operand,
9996 int value_min, int value_max)
9998 int value_new = (operator == CA_MODE_SET ? operand :
9999 operator == CA_MODE_ADD ? value_old + operand :
10000 operator == CA_MODE_SUBTRACT ? value_old - operand :
10001 operator == CA_MODE_MULTIPLY ? value_old * operand :
10002 operator == CA_MODE_DIVIDE ? value_old / MAX(1, operand) :
10003 operator == CA_MODE_MODULO ? value_old % MAX(1, operand) :
10006 return (value_new < value_min ? value_min :
10007 value_new > value_max ? value_max :
10011 static void ExecuteCustomElementAction(int x, int y, int element, int page)
10013 struct ElementInfo *ei = &element_info[element];
10014 struct ElementChangeInfo *change = &ei->change_page[page];
10015 int target_element = change->target_element;
10016 int action_type = change->action_type;
10017 int action_mode = change->action_mode;
10018 int action_arg = change->action_arg;
10019 int action_element = change->action_element;
10022 if (!change->has_action)
10025 // ---------- determine action paramater values -----------------------------
10027 int level_time_value =
10028 (level.time > 0 ? TimeLeft :
10031 int action_arg_element_raw =
10032 (action_arg == CA_ARG_PLAYER_TRIGGER ? change->actual_trigger_player :
10033 action_arg == CA_ARG_ELEMENT_TRIGGER ? change->actual_trigger_element :
10034 action_arg == CA_ARG_ELEMENT_TARGET ? change->target_element :
10035 action_arg == CA_ARG_ELEMENT_ACTION ? change->action_element :
10036 action_arg == CA_ARG_INVENTORY_RM_TRIGGER ? change->actual_trigger_element:
10037 action_arg == CA_ARG_INVENTORY_RM_TARGET ? change->target_element :
10038 action_arg == CA_ARG_INVENTORY_RM_ACTION ? change->action_element :
10040 int action_arg_element = GetElementFromGroupElement(action_arg_element_raw);
10042 int action_arg_direction =
10043 (action_arg >= CA_ARG_DIRECTION_LEFT &&
10044 action_arg <= CA_ARG_DIRECTION_DOWN ? action_arg - CA_ARG_DIRECTION :
10045 action_arg == CA_ARG_DIRECTION_TRIGGER ?
10046 change->actual_trigger_side :
10047 action_arg == CA_ARG_DIRECTION_TRIGGER_BACK ?
10048 MV_DIR_OPPOSITE(change->actual_trigger_side) :
10051 int action_arg_number_min =
10052 (action_type == CA_SET_PLAYER_SPEED ? STEPSIZE_NOT_MOVING :
10055 int action_arg_number_max =
10056 (action_type == CA_SET_PLAYER_SPEED ? STEPSIZE_EVEN_FASTER :
10057 action_type == CA_SET_LEVEL_GEMS ? 999 :
10058 action_type == CA_SET_LEVEL_TIME ? 9999 :
10059 action_type == CA_SET_LEVEL_SCORE ? 99999 :
10060 action_type == CA_SET_CE_VALUE ? 9999 :
10061 action_type == CA_SET_CE_SCORE ? 9999 :
10064 int action_arg_number_reset =
10065 (action_type == CA_SET_PLAYER_SPEED ? level.initial_player_stepsize[0] :
10066 action_type == CA_SET_LEVEL_GEMS ? level.gems_needed :
10067 action_type == CA_SET_LEVEL_TIME ? level.time :
10068 action_type == CA_SET_LEVEL_SCORE ? 0 :
10069 action_type == CA_SET_CE_VALUE ? GET_NEW_CE_VALUE(element) :
10070 action_type == CA_SET_CE_SCORE ? 0 :
10073 int action_arg_number =
10074 (action_arg <= CA_ARG_MAX ? action_arg :
10075 action_arg >= CA_ARG_SPEED_NOT_MOVING &&
10076 action_arg <= CA_ARG_SPEED_EVEN_FASTER ? (action_arg - CA_ARG_SPEED) :
10077 action_arg == CA_ARG_SPEED_RESET ? action_arg_number_reset :
10078 action_arg == CA_ARG_NUMBER_MIN ? action_arg_number_min :
10079 action_arg == CA_ARG_NUMBER_MAX ? action_arg_number_max :
10080 action_arg == CA_ARG_NUMBER_RESET ? action_arg_number_reset :
10081 action_arg == CA_ARG_NUMBER_CE_VALUE ? CustomValue[x][y] :
10082 action_arg == CA_ARG_NUMBER_CE_SCORE ? ei->collect_score :
10083 action_arg == CA_ARG_NUMBER_CE_DELAY ? GET_CE_DELAY_VALUE(change) :
10084 action_arg == CA_ARG_NUMBER_LEVEL_TIME ? level_time_value :
10085 action_arg == CA_ARG_NUMBER_LEVEL_GEMS ? game.gems_still_needed :
10086 action_arg == CA_ARG_NUMBER_LEVEL_SCORE ? game.score :
10087 action_arg == CA_ARG_ELEMENT_CV_TARGET ? GET_NEW_CE_VALUE(target_element):
10088 action_arg == CA_ARG_ELEMENT_CV_TRIGGER ? change->actual_trigger_ce_value:
10089 action_arg == CA_ARG_ELEMENT_CV_ACTION ? GET_NEW_CE_VALUE(action_element):
10090 action_arg == CA_ARG_ELEMENT_CS_TARGET ? GET_CE_SCORE(target_element) :
10091 action_arg == CA_ARG_ELEMENT_CS_TRIGGER ? change->actual_trigger_ce_score:
10092 action_arg == CA_ARG_ELEMENT_CS_ACTION ? GET_CE_SCORE(action_element) :
10093 action_arg == CA_ARG_ELEMENT_NR_TARGET ? change->target_element :
10094 action_arg == CA_ARG_ELEMENT_NR_TRIGGER ? change->actual_trigger_element :
10095 action_arg == CA_ARG_ELEMENT_NR_ACTION ? change->action_element :
10098 int action_arg_number_old =
10099 (action_type == CA_SET_LEVEL_GEMS ? game.gems_still_needed :
10100 action_type == CA_SET_LEVEL_TIME ? TimeLeft :
10101 action_type == CA_SET_LEVEL_SCORE ? game.score :
10102 action_type == CA_SET_CE_VALUE ? CustomValue[x][y] :
10103 action_type == CA_SET_CE_SCORE ? ei->collect_score :
10106 int action_arg_number_new =
10107 getModifiedActionNumber(action_arg_number_old,
10108 action_mode, action_arg_number,
10109 action_arg_number_min, action_arg_number_max);
10111 int trigger_player_bits =
10112 (change->actual_trigger_player_bits != CH_PLAYER_NONE ?
10113 change->actual_trigger_player_bits : change->trigger_player);
10115 int action_arg_player_bits =
10116 (action_arg >= CA_ARG_PLAYER_1 &&
10117 action_arg <= CA_ARG_PLAYER_4 ? action_arg - CA_ARG_PLAYER :
10118 action_arg == CA_ARG_PLAYER_TRIGGER ? trigger_player_bits :
10119 action_arg == CA_ARG_PLAYER_ACTION ? 1 << GET_PLAYER_NR(action_element) :
10122 // ---------- execute action -----------------------------------------------
10124 switch (action_type)
10131 // ---------- level actions ----------------------------------------------
10133 case CA_RESTART_LEVEL:
10135 game.restart_level = TRUE;
10140 case CA_SHOW_ENVELOPE:
10142 int element = getSpecialActionElement(action_arg_element,
10143 action_arg_number, EL_ENVELOPE_1);
10145 if (IS_ENVELOPE(element))
10146 local_player->show_envelope = element;
10151 case CA_SET_LEVEL_TIME:
10153 if (level.time > 0) // only modify limited time value
10155 TimeLeft = action_arg_number_new;
10157 game_panel_controls[GAME_PANEL_TIME].value = TimeLeft;
10159 DisplayGameControlValues();
10161 if (!TimeLeft && setup.time_limit)
10162 for (i = 0; i < MAX_PLAYERS; i++)
10163 KillPlayer(&stored_player[i]);
10169 case CA_SET_LEVEL_SCORE:
10171 game.score = action_arg_number_new;
10173 game_panel_controls[GAME_PANEL_SCORE].value = game.score;
10175 DisplayGameControlValues();
10180 case CA_SET_LEVEL_GEMS:
10182 game.gems_still_needed = action_arg_number_new;
10184 game.snapshot.collected_item = TRUE;
10186 game_panel_controls[GAME_PANEL_GEMS].value = game.gems_still_needed;
10188 DisplayGameControlValues();
10193 case CA_SET_LEVEL_WIND:
10195 game.wind_direction = action_arg_direction;
10200 case CA_SET_LEVEL_RANDOM_SEED:
10202 // ensure that setting a new random seed while playing is predictable
10203 InitRND(action_arg_number_new ? action_arg_number_new : RND(1000000) + 1);
10208 // ---------- player actions ---------------------------------------------
10210 case CA_MOVE_PLAYER:
10211 case CA_MOVE_PLAYER_NEW:
10213 // automatically move to the next field in specified direction
10214 for (i = 0; i < MAX_PLAYERS; i++)
10215 if (trigger_player_bits & (1 << i))
10216 if (action_type == CA_MOVE_PLAYER ||
10217 stored_player[i].MovPos == 0)
10218 stored_player[i].programmed_action = action_arg_direction;
10223 case CA_EXIT_PLAYER:
10225 for (i = 0; i < MAX_PLAYERS; i++)
10226 if (action_arg_player_bits & (1 << i))
10227 ExitPlayer(&stored_player[i]);
10229 if (game.players_still_needed == 0)
10235 case CA_KILL_PLAYER:
10237 for (i = 0; i < MAX_PLAYERS; i++)
10238 if (action_arg_player_bits & (1 << i))
10239 KillPlayer(&stored_player[i]);
10244 case CA_SET_PLAYER_KEYS:
10246 int key_state = (action_mode == CA_MODE_ADD ? TRUE : FALSE);
10247 int element = getSpecialActionElement(action_arg_element,
10248 action_arg_number, EL_KEY_1);
10250 if (IS_KEY(element))
10252 for (i = 0; i < MAX_PLAYERS; i++)
10254 if (trigger_player_bits & (1 << i))
10256 stored_player[i].key[KEY_NR(element)] = key_state;
10258 DrawGameDoorValues();
10266 case CA_SET_PLAYER_SPEED:
10268 for (i = 0; i < MAX_PLAYERS; i++)
10270 if (trigger_player_bits & (1 << i))
10272 int move_stepsize = TILEX / stored_player[i].move_delay_value;
10274 if (action_arg == CA_ARG_SPEED_FASTER &&
10275 stored_player[i].cannot_move)
10277 action_arg_number = STEPSIZE_VERY_SLOW;
10279 else if (action_arg == CA_ARG_SPEED_SLOWER ||
10280 action_arg == CA_ARG_SPEED_FASTER)
10282 action_arg_number = 2;
10283 action_mode = (action_arg == CA_ARG_SPEED_SLOWER ? CA_MODE_DIVIDE :
10286 else if (action_arg == CA_ARG_NUMBER_RESET)
10288 action_arg_number = level.initial_player_stepsize[i];
10292 getModifiedActionNumber(move_stepsize,
10295 action_arg_number_min,
10296 action_arg_number_max);
10298 SetPlayerMoveSpeed(&stored_player[i], move_stepsize, FALSE);
10305 case CA_SET_PLAYER_SHIELD:
10307 for (i = 0; i < MAX_PLAYERS; i++)
10309 if (trigger_player_bits & (1 << i))
10311 if (action_arg == CA_ARG_SHIELD_OFF)
10313 stored_player[i].shield_normal_time_left = 0;
10314 stored_player[i].shield_deadly_time_left = 0;
10316 else if (action_arg == CA_ARG_SHIELD_NORMAL)
10318 stored_player[i].shield_normal_time_left = 999999;
10320 else if (action_arg == CA_ARG_SHIELD_DEADLY)
10322 stored_player[i].shield_normal_time_left = 999999;
10323 stored_player[i].shield_deadly_time_left = 999999;
10331 case CA_SET_PLAYER_GRAVITY:
10333 for (i = 0; i < MAX_PLAYERS; i++)
10335 if (trigger_player_bits & (1 << i))
10337 stored_player[i].gravity =
10338 (action_arg == CA_ARG_GRAVITY_OFF ? FALSE :
10339 action_arg == CA_ARG_GRAVITY_ON ? TRUE :
10340 action_arg == CA_ARG_GRAVITY_TOGGLE ? !stored_player[i].gravity :
10341 stored_player[i].gravity);
10348 case CA_SET_PLAYER_ARTWORK:
10350 for (i = 0; i < MAX_PLAYERS; i++)
10352 if (trigger_player_bits & (1 << i))
10354 int artwork_element = action_arg_element;
10356 if (action_arg == CA_ARG_ELEMENT_RESET)
10358 (level.use_artwork_element[i] ? level.artwork_element[i] :
10359 stored_player[i].element_nr);
10361 if (stored_player[i].artwork_element != artwork_element)
10362 stored_player[i].Frame = 0;
10364 stored_player[i].artwork_element = artwork_element;
10366 SetPlayerWaiting(&stored_player[i], FALSE);
10368 // set number of special actions for bored and sleeping animation
10369 stored_player[i].num_special_action_bored =
10370 get_num_special_action(artwork_element,
10371 ACTION_BORING_1, ACTION_BORING_LAST);
10372 stored_player[i].num_special_action_sleeping =
10373 get_num_special_action(artwork_element,
10374 ACTION_SLEEPING_1, ACTION_SLEEPING_LAST);
10381 case CA_SET_PLAYER_INVENTORY:
10383 for (i = 0; i < MAX_PLAYERS; i++)
10385 struct PlayerInfo *player = &stored_player[i];
10388 if (trigger_player_bits & (1 << i))
10390 int inventory_element = action_arg_element;
10392 if (action_arg == CA_ARG_ELEMENT_TARGET ||
10393 action_arg == CA_ARG_ELEMENT_TRIGGER ||
10394 action_arg == CA_ARG_ELEMENT_ACTION)
10396 int element = inventory_element;
10397 int collect_count = element_info[element].collect_count_initial;
10399 if (!IS_CUSTOM_ELEMENT(element))
10402 if (collect_count == 0)
10403 player->inventory_infinite_element = element;
10405 for (k = 0; k < collect_count; k++)
10406 if (player->inventory_size < MAX_INVENTORY_SIZE)
10407 player->inventory_element[player->inventory_size++] =
10410 else if (action_arg == CA_ARG_INVENTORY_RM_TARGET ||
10411 action_arg == CA_ARG_INVENTORY_RM_TRIGGER ||
10412 action_arg == CA_ARG_INVENTORY_RM_ACTION)
10414 if (player->inventory_infinite_element != EL_UNDEFINED &&
10415 IS_EQUAL_OR_IN_GROUP(player->inventory_infinite_element,
10416 action_arg_element_raw))
10417 player->inventory_infinite_element = EL_UNDEFINED;
10419 for (k = 0, j = 0; j < player->inventory_size; j++)
10421 if (!IS_EQUAL_OR_IN_GROUP(player->inventory_element[j],
10422 action_arg_element_raw))
10423 player->inventory_element[k++] = player->inventory_element[j];
10426 player->inventory_size = k;
10428 else if (action_arg == CA_ARG_INVENTORY_RM_FIRST)
10430 if (player->inventory_size > 0)
10432 for (j = 0; j < player->inventory_size - 1; j++)
10433 player->inventory_element[j] = player->inventory_element[j + 1];
10435 player->inventory_size--;
10438 else if (action_arg == CA_ARG_INVENTORY_RM_LAST)
10440 if (player->inventory_size > 0)
10441 player->inventory_size--;
10443 else if (action_arg == CA_ARG_INVENTORY_RM_ALL)
10445 player->inventory_infinite_element = EL_UNDEFINED;
10446 player->inventory_size = 0;
10448 else if (action_arg == CA_ARG_INVENTORY_RESET)
10450 player->inventory_infinite_element = EL_UNDEFINED;
10451 player->inventory_size = 0;
10453 if (level.use_initial_inventory[i])
10455 for (j = 0; j < level.initial_inventory_size[i]; j++)
10457 int element = level.initial_inventory_content[i][j];
10458 int collect_count = element_info[element].collect_count_initial;
10460 if (!IS_CUSTOM_ELEMENT(element))
10463 if (collect_count == 0)
10464 player->inventory_infinite_element = element;
10466 for (k = 0; k < collect_count; k++)
10467 if (player->inventory_size < MAX_INVENTORY_SIZE)
10468 player->inventory_element[player->inventory_size++] =
10479 // ---------- CE actions -------------------------------------------------
10481 case CA_SET_CE_VALUE:
10483 int last_ce_value = CustomValue[x][y];
10485 CustomValue[x][y] = action_arg_number_new;
10487 if (CustomValue[x][y] != last_ce_value)
10489 CheckElementChange(x, y, element, EL_UNDEFINED, CE_VALUE_CHANGES);
10490 CheckTriggeredElementChange(x, y, element, CE_VALUE_CHANGES_OF_X);
10492 if (CustomValue[x][y] == 0)
10494 // reset change counter (else CE_VALUE_GETS_ZERO would not work)
10495 ChangeCount[x][y] = 0; // allow at least one more change
10497 CheckElementChange(x, y, element, EL_UNDEFINED, CE_VALUE_GETS_ZERO);
10498 CheckTriggeredElementChange(x, y, element, CE_VALUE_GETS_ZERO_OF_X);
10505 case CA_SET_CE_SCORE:
10507 int last_ce_score = ei->collect_score;
10509 ei->collect_score = action_arg_number_new;
10511 if (ei->collect_score != last_ce_score)
10513 CheckElementChange(x, y, element, EL_UNDEFINED, CE_SCORE_CHANGES);
10514 CheckTriggeredElementChange(x, y, element, CE_SCORE_CHANGES_OF_X);
10516 if (ei->collect_score == 0)
10520 // reset change counter (else CE_SCORE_GETS_ZERO would not work)
10521 ChangeCount[x][y] = 0; // allow at least one more change
10523 CheckElementChange(x, y, element, EL_UNDEFINED, CE_SCORE_GETS_ZERO);
10524 CheckTriggeredElementChange(x, y, element, CE_SCORE_GETS_ZERO_OF_X);
10527 This is a very special case that seems to be a mixture between
10528 CheckElementChange() and CheckTriggeredElementChange(): while
10529 the first one only affects single elements that are triggered
10530 directly, the second one affects multiple elements in the playfield
10531 that are triggered indirectly by another element. This is a third
10532 case: Changing the CE score always affects multiple identical CEs,
10533 so every affected CE must be checked, not only the single CE for
10534 which the CE score was changed in the first place (as every instance
10535 of that CE shares the same CE score, and therefore also can change)!
10537 SCAN_PLAYFIELD(xx, yy)
10539 if (Tile[xx][yy] == element)
10540 CheckElementChange(xx, yy, element, EL_UNDEFINED,
10541 CE_SCORE_GETS_ZERO);
10549 case CA_SET_CE_ARTWORK:
10551 int artwork_element = action_arg_element;
10552 boolean reset_frame = FALSE;
10555 if (action_arg == CA_ARG_ELEMENT_RESET)
10556 artwork_element = (ei->use_gfx_element ? ei->gfx_element_initial :
10559 if (ei->gfx_element != artwork_element)
10560 reset_frame = TRUE;
10562 ei->gfx_element = artwork_element;
10564 SCAN_PLAYFIELD(xx, yy)
10566 if (Tile[xx][yy] == element)
10570 ResetGfxAnimation(xx, yy);
10571 ResetRandomAnimationValue(xx, yy);
10574 TEST_DrawLevelField(xx, yy);
10581 // ---------- engine actions ---------------------------------------------
10583 case CA_SET_ENGINE_SCAN_MODE:
10585 InitPlayfieldScanMode(action_arg);
10595 static void CreateFieldExt(int x, int y, int element, boolean is_change)
10597 int old_element = Tile[x][y];
10598 int new_element = GetElementFromGroupElement(element);
10599 int previous_move_direction = MovDir[x][y];
10600 int last_ce_value = CustomValue[x][y];
10601 boolean player_explosion_protected = PLAYER_EXPLOSION_PROTECTED(x, y);
10602 boolean new_element_is_player = IS_PLAYER_ELEMENT(new_element);
10603 boolean add_player_onto_element = (new_element_is_player &&
10604 new_element != EL_SOKOBAN_FIELD_PLAYER &&
10605 IS_WALKABLE(old_element));
10607 if (!add_player_onto_element)
10609 if (IS_MOVING(x, y) || IS_BLOCKED(x, y))
10610 RemoveMovingField(x, y);
10614 Tile[x][y] = new_element;
10616 if (element_info[new_element].move_direction_initial == MV_START_PREVIOUS)
10617 MovDir[x][y] = previous_move_direction;
10619 if (element_info[new_element].use_last_ce_value)
10620 CustomValue[x][y] = last_ce_value;
10622 InitField_WithBug1(x, y, FALSE);
10624 new_element = Tile[x][y]; // element may have changed
10626 ResetGfxAnimation(x, y);
10627 ResetRandomAnimationValue(x, y);
10629 TEST_DrawLevelField(x, y);
10631 if (GFX_CRUMBLED(new_element))
10632 TEST_DrawLevelFieldCrumbledNeighbours(x, y);
10635 // check if element under the player changes from accessible to unaccessible
10636 // (needed for special case of dropping element which then changes)
10637 // (must be checked after creating new element for walkable group elements)
10638 if (IS_PLAYER(x, y) && !player_explosion_protected &&
10639 IS_ACCESSIBLE(old_element) && !IS_ACCESSIBLE(new_element))
10646 // "ChangeCount" not set yet to allow "entered by player" change one time
10647 if (new_element_is_player)
10648 RelocatePlayer(x, y, new_element);
10651 ChangeCount[x][y]++; // count number of changes in the same frame
10653 TestIfBadThingTouchesPlayer(x, y);
10654 TestIfPlayerTouchesCustomElement(x, y);
10655 TestIfElementTouchesCustomElement(x, y);
10658 static void CreateField(int x, int y, int element)
10660 CreateFieldExt(x, y, element, FALSE);
10663 static void CreateElementFromChange(int x, int y, int element)
10665 element = GET_VALID_RUNTIME_ELEMENT(element);
10667 if (game.engine_version >= VERSION_IDENT(3,2,0,7))
10669 int old_element = Tile[x][y];
10671 // prevent changed element from moving in same engine frame
10672 // unless both old and new element can either fall or move
10673 if ((!CAN_FALL(old_element) || !CAN_FALL(element)) &&
10674 (!CAN_MOVE(old_element) || !CAN_MOVE(element)))
10678 CreateFieldExt(x, y, element, TRUE);
10681 static boolean ChangeElement(int x, int y, int element, int page)
10683 struct ElementInfo *ei = &element_info[element];
10684 struct ElementChangeInfo *change = &ei->change_page[page];
10685 int ce_value = CustomValue[x][y];
10686 int ce_score = ei->collect_score;
10687 int target_element;
10688 int old_element = Tile[x][y];
10690 // always use default change event to prevent running into a loop
10691 if (ChangeEvent[x][y] == -1)
10692 ChangeEvent[x][y] = CE_DELAY;
10694 if (ChangeEvent[x][y] == CE_DELAY)
10696 // reset actual trigger element, trigger player and action element
10697 change->actual_trigger_element = EL_EMPTY;
10698 change->actual_trigger_player = EL_EMPTY;
10699 change->actual_trigger_player_bits = CH_PLAYER_NONE;
10700 change->actual_trigger_side = CH_SIDE_NONE;
10701 change->actual_trigger_ce_value = 0;
10702 change->actual_trigger_ce_score = 0;
10705 // do not change elements more than a specified maximum number of changes
10706 if (ChangeCount[x][y] >= game.max_num_changes_per_frame)
10709 ChangeCount[x][y]++; // count number of changes in the same frame
10711 if (change->explode)
10718 if (change->use_target_content)
10720 boolean complete_replace = TRUE;
10721 boolean can_replace[3][3];
10724 for (yy = 0; yy < 3; yy++) for (xx = 0; xx < 3 ; xx++)
10727 boolean is_walkable;
10728 boolean is_diggable;
10729 boolean is_collectible;
10730 boolean is_removable;
10731 boolean is_destructible;
10732 int ex = x + xx - 1;
10733 int ey = y + yy - 1;
10734 int content_element = change->target_content.e[xx][yy];
10737 can_replace[xx][yy] = TRUE;
10739 if (ex == x && ey == y) // do not check changing element itself
10742 if (content_element == EL_EMPTY_SPACE)
10744 can_replace[xx][yy] = FALSE; // do not replace border with space
10749 if (!IN_LEV_FIELD(ex, ey))
10751 can_replace[xx][yy] = FALSE;
10752 complete_replace = FALSE;
10759 if (IS_MOVING(ex, ey) || IS_BLOCKED(ex, ey))
10760 e = MovingOrBlocked2Element(ex, ey);
10762 is_empty = (IS_FREE(ex, ey) ||
10763 (IS_FREE_OR_PLAYER(ex, ey) && IS_WALKABLE(content_element)));
10765 is_walkable = (is_empty || IS_WALKABLE(e));
10766 is_diggable = (is_empty || IS_DIGGABLE(e));
10767 is_collectible = (is_empty || IS_COLLECTIBLE(e));
10768 is_destructible = (is_empty || !IS_INDESTRUCTIBLE(e));
10769 is_removable = (is_diggable || is_collectible);
10771 can_replace[xx][yy] =
10772 (((change->replace_when == CP_WHEN_EMPTY && is_empty) ||
10773 (change->replace_when == CP_WHEN_WALKABLE && is_walkable) ||
10774 (change->replace_when == CP_WHEN_DIGGABLE && is_diggable) ||
10775 (change->replace_when == CP_WHEN_COLLECTIBLE && is_collectible) ||
10776 (change->replace_when == CP_WHEN_REMOVABLE && is_removable) ||
10777 (change->replace_when == CP_WHEN_DESTRUCTIBLE && is_destructible)) &&
10778 !(IS_PLAYER(ex, ey) && IS_PLAYER_ELEMENT(content_element)));
10780 if (!can_replace[xx][yy])
10781 complete_replace = FALSE;
10784 if (!change->only_if_complete || complete_replace)
10786 boolean something_has_changed = FALSE;
10788 if (change->only_if_complete && change->use_random_replace &&
10789 RND(100) < change->random_percentage)
10792 for (yy = 0; yy < 3; yy++) for (xx = 0; xx < 3 ; xx++)
10794 int ex = x + xx - 1;
10795 int ey = y + yy - 1;
10796 int content_element;
10798 if (can_replace[xx][yy] && (!change->use_random_replace ||
10799 RND(100) < change->random_percentage))
10801 if (IS_MOVING(ex, ey) || IS_BLOCKED(ex, ey))
10802 RemoveMovingField(ex, ey);
10804 ChangeEvent[ex][ey] = ChangeEvent[x][y];
10806 content_element = change->target_content.e[xx][yy];
10807 target_element = GET_TARGET_ELEMENT(element, content_element, change,
10808 ce_value, ce_score);
10810 CreateElementFromChange(ex, ey, target_element);
10812 something_has_changed = TRUE;
10814 // for symmetry reasons, freeze newly created border elements
10815 if (ex != x || ey != y)
10816 Stop[ex][ey] = TRUE; // no more moving in this frame
10820 if (something_has_changed)
10822 PlayLevelSoundElementAction(x, y, element, ACTION_CHANGING);
10823 PlayLevelSoundElementAction(x, y, element, ACTION_PAGE_1 + page);
10829 target_element = GET_TARGET_ELEMENT(element, change->target_element, change,
10830 ce_value, ce_score);
10832 if (element == EL_DIAGONAL_GROWING ||
10833 element == EL_DIAGONAL_SHRINKING)
10835 target_element = Store[x][y];
10837 Store[x][y] = EL_EMPTY;
10840 // special case: element changes to player (and may be kept if walkable)
10841 if (IS_PLAYER_ELEMENT(target_element) && !level.keep_walkable_ce)
10842 CreateElementFromChange(x, y, EL_EMPTY);
10844 CreateElementFromChange(x, y, target_element);
10846 PlayLevelSoundElementAction(x, y, element, ACTION_CHANGING);
10847 PlayLevelSoundElementAction(x, y, element, ACTION_PAGE_1 + page);
10850 // this uses direct change before indirect change
10851 CheckTriggeredElementChangeByPage(x, y, old_element, CE_CHANGE_OF_X, page);
10856 static void HandleElementChange(int x, int y, int page)
10858 int element = MovingOrBlocked2Element(x, y);
10859 struct ElementInfo *ei = &element_info[element];
10860 struct ElementChangeInfo *change = &ei->change_page[page];
10861 boolean handle_action_before_change = FALSE;
10864 if (!CAN_CHANGE_OR_HAS_ACTION(element) &&
10865 !CAN_CHANGE_OR_HAS_ACTION(Back[x][y]))
10867 Debug("game:playing:HandleElementChange", "%d,%d: element = %d ('%s')",
10868 x, y, element, element_info[element].token_name);
10869 Debug("game:playing:HandleElementChange", "This should never happen!");
10873 // this can happen with classic bombs on walkable, changing elements
10874 if (!CAN_CHANGE_OR_HAS_ACTION(element))
10879 if (ChangeDelay[x][y] == 0) // initialize element change
10881 ChangeDelay[x][y] = GET_CHANGE_DELAY(change) + 1;
10883 if (change->can_change)
10885 // !!! not clear why graphic animation should be reset at all here !!!
10886 // !!! UPDATE: but is needed for correct Snake Bite tail animation !!!
10887 // !!! SOLUTION: do not reset if graphics engine set to 4 or above !!!
10890 GRAPHICAL BUG ADDRESSED BY CHECKING GRAPHICS ENGINE VERSION:
10892 When using an animation frame delay of 1 (this only happens with
10893 "sp_zonk.moving.left/right" in the classic graphics), the default
10894 (non-moving) animation shows wrong animation frames (while the
10895 moving animation, like "sp_zonk.moving.left/right", is correct,
10896 so this graphical bug never shows up with the classic graphics).
10897 For an animation with 4 frames, this causes wrong frames 0,0,1,2
10898 be drawn instead of the correct frames 0,1,2,3. This is caused by
10899 "GfxFrame[][]" being reset *twice* (in two successive frames) after
10900 an element change: First when the change delay ("ChangeDelay[][]")
10901 counter has reached zero after decrementing, then a second time in
10902 the next frame (after "GfxFrame[][]" was already incremented) when
10903 "ChangeDelay[][]" is reset to the initial delay value again.
10905 This causes frame 0 to be drawn twice, while the last frame won't
10906 be drawn anymore, resulting in the wrong frame sequence 0,0,1,2.
10908 As some animations may already be cleverly designed around this bug
10909 (at least the "Snake Bite" snake tail animation does this), it cannot
10910 simply be fixed here without breaking such existing animations.
10911 Unfortunately, it cannot easily be detected if a graphics set was
10912 designed "before" or "after" the bug was fixed. As a workaround,
10913 a new graphics set option "game.graphics_engine_version" was added
10914 to be able to specify the game's major release version for which the
10915 graphics set was designed, which can then be used to decide if the
10916 bugfix should be used (version 4 and above) or not (version 3 or
10917 below, or if no version was specified at all, as with old sets).
10919 (The wrong/fixed animation frames can be tested with the test level set
10920 "test_gfxframe" and level "000", which contains a specially prepared
10921 custom element at level position (x/y) == (11/9) which uses the zonk
10922 animation mentioned above. Using "game.graphics_engine_version: 4"
10923 fixes the wrong animation frames, showing the correct frames 0,1,2,3.
10924 This can also be seen from the debug output for this test element.)
10927 // when a custom element is about to change (for example by change delay),
10928 // do not reset graphic animation when the custom element is moving
10929 if (game.graphics_engine_version < 4 &&
10932 ResetGfxAnimation(x, y);
10933 ResetRandomAnimationValue(x, y);
10936 if (change->pre_change_function)
10937 change->pre_change_function(x, y);
10941 ChangeDelay[x][y]--;
10943 if (ChangeDelay[x][y] != 0) // continue element change
10945 if (change->can_change)
10947 int graphic = el_act_dir2img(element, GfxAction[x][y], GfxDir[x][y]);
10949 if (IS_ANIMATED(graphic))
10950 DrawLevelGraphicAnimationIfNeeded(x, y, graphic);
10952 if (change->change_function)
10953 change->change_function(x, y);
10956 else // finish element change
10958 if (ChangePage[x][y] != -1) // remember page from delayed change
10960 page = ChangePage[x][y];
10961 ChangePage[x][y] = -1;
10963 change = &ei->change_page[page];
10966 if (IS_MOVING(x, y)) // never change a running system ;-)
10968 ChangeDelay[x][y] = 1; // try change after next move step
10969 ChangePage[x][y] = page; // remember page to use for change
10974 // special case: set new level random seed before changing element
10975 if (change->has_action && change->action_type == CA_SET_LEVEL_RANDOM_SEED)
10976 handle_action_before_change = TRUE;
10978 if (change->has_action && handle_action_before_change)
10979 ExecuteCustomElementAction(x, y, element, page);
10981 if (change->can_change)
10983 if (ChangeElement(x, y, element, page))
10985 if (change->post_change_function)
10986 change->post_change_function(x, y);
10990 if (change->has_action && !handle_action_before_change)
10991 ExecuteCustomElementAction(x, y, element, page);
10995 static boolean CheckTriggeredElementChangeExt(int trigger_x, int trigger_y,
10996 int trigger_element,
10998 int trigger_player,
11002 boolean change_done_any = FALSE;
11003 int trigger_page_bits = (trigger_page < 0 ? CH_PAGE_ANY : 1 << trigger_page);
11006 if (!(trigger_events[trigger_element][trigger_event]))
11009 RECURSION_LOOP_DETECTION_START(trigger_element, FALSE);
11011 for (i = 0; i < NUM_CUSTOM_ELEMENTS; i++)
11013 int element = EL_CUSTOM_START + i;
11014 boolean change_done = FALSE;
11017 if (!CAN_CHANGE_OR_HAS_ACTION(element) ||
11018 !HAS_ANY_CHANGE_EVENT(element, trigger_event))
11021 for (p = 0; p < element_info[element].num_change_pages; p++)
11023 struct ElementChangeInfo *change = &element_info[element].change_page[p];
11025 if (change->can_change_or_has_action &&
11026 change->has_event[trigger_event] &&
11027 change->trigger_side & trigger_side &&
11028 change->trigger_player & trigger_player &&
11029 change->trigger_page & trigger_page_bits &&
11030 IS_EQUAL_OR_IN_GROUP(trigger_element, change->trigger_element))
11032 change->actual_trigger_element = trigger_element;
11033 change->actual_trigger_player = GET_PLAYER_FROM_BITS(trigger_player);
11034 change->actual_trigger_player_bits = trigger_player;
11035 change->actual_trigger_side = trigger_side;
11036 change->actual_trigger_ce_value = CustomValue[trigger_x][trigger_y];
11037 change->actual_trigger_ce_score = GET_CE_SCORE(trigger_element);
11039 if ((change->can_change && !change_done) || change->has_action)
11043 SCAN_PLAYFIELD(x, y)
11045 if (Tile[x][y] == element)
11047 if (change->can_change && !change_done)
11049 // if element already changed in this frame, not only prevent
11050 // another element change (checked in ChangeElement()), but
11051 // also prevent additional element actions for this element
11053 if (ChangeCount[x][y] >= game.max_num_changes_per_frame &&
11054 !level.use_action_after_change_bug)
11057 ChangeDelay[x][y] = 1;
11058 ChangeEvent[x][y] = trigger_event;
11060 HandleElementChange(x, y, p);
11062 else if (change->has_action)
11064 // if element already changed in this frame, not only prevent
11065 // another element change (checked in ChangeElement()), but
11066 // also prevent additional element actions for this element
11068 if (ChangeCount[x][y] >= game.max_num_changes_per_frame &&
11069 !level.use_action_after_change_bug)
11072 ExecuteCustomElementAction(x, y, element, p);
11073 PlayLevelSoundElementAction(x, y, element, ACTION_PAGE_1 + p);
11078 if (change->can_change)
11080 change_done = TRUE;
11081 change_done_any = TRUE;
11088 RECURSION_LOOP_DETECTION_END();
11090 return change_done_any;
11093 static boolean CheckElementChangeExt(int x, int y,
11095 int trigger_element,
11097 int trigger_player,
11100 boolean change_done = FALSE;
11103 if (!CAN_CHANGE_OR_HAS_ACTION(element) ||
11104 !HAS_ANY_CHANGE_EVENT(element, trigger_event))
11107 if (Tile[x][y] == EL_BLOCKED)
11109 Blocked2Moving(x, y, &x, &y);
11110 element = Tile[x][y];
11113 // check if element has already changed or is about to change after moving
11114 if ((game.engine_version < VERSION_IDENT(3,2,0,7) &&
11115 Tile[x][y] != element) ||
11117 (game.engine_version >= VERSION_IDENT(3,2,0,7) &&
11118 (ChangeCount[x][y] >= game.max_num_changes_per_frame ||
11119 ChangePage[x][y] != -1)))
11122 RECURSION_LOOP_DETECTION_START(trigger_element, FALSE);
11124 for (p = 0; p < element_info[element].num_change_pages; p++)
11126 struct ElementChangeInfo *change = &element_info[element].change_page[p];
11128 /* check trigger element for all events where the element that is checked
11129 for changing interacts with a directly adjacent element -- this is
11130 different to element changes that affect other elements to change on the
11131 whole playfield (which is handeld by CheckTriggeredElementChangeExt()) */
11132 boolean check_trigger_element =
11133 (trigger_event == CE_TOUCHING_X ||
11134 trigger_event == CE_HITTING_X ||
11135 trigger_event == CE_HIT_BY_X ||
11136 trigger_event == CE_DIGGING_X); // this one was forgotten until 3.2.3
11138 if (change->can_change_or_has_action &&
11139 change->has_event[trigger_event] &&
11140 change->trigger_side & trigger_side &&
11141 change->trigger_player & trigger_player &&
11142 (!check_trigger_element ||
11143 IS_EQUAL_OR_IN_GROUP(trigger_element, change->trigger_element)))
11145 change->actual_trigger_element = trigger_element;
11146 change->actual_trigger_player = GET_PLAYER_FROM_BITS(trigger_player);
11147 change->actual_trigger_player_bits = trigger_player;
11148 change->actual_trigger_side = trigger_side;
11149 change->actual_trigger_ce_value = CustomValue[x][y];
11150 change->actual_trigger_ce_score = GET_CE_SCORE(trigger_element);
11152 // special case: trigger element not at (x,y) position for some events
11153 if (check_trigger_element)
11165 { 0, 0 }, { 0, 0 }, { 0, 0 },
11169 int xx = x + move_xy[MV_DIR_OPPOSITE(trigger_side)].dx;
11170 int yy = y + move_xy[MV_DIR_OPPOSITE(trigger_side)].dy;
11172 change->actual_trigger_ce_value = CustomValue[xx][yy];
11173 change->actual_trigger_ce_score = GET_CE_SCORE(trigger_element);
11176 if (change->can_change && !change_done)
11178 ChangeDelay[x][y] = 1;
11179 ChangeEvent[x][y] = trigger_event;
11181 HandleElementChange(x, y, p);
11183 change_done = TRUE;
11185 else if (change->has_action)
11187 ExecuteCustomElementAction(x, y, element, p);
11188 PlayLevelSoundElementAction(x, y, element, ACTION_PAGE_1 + p);
11193 RECURSION_LOOP_DETECTION_END();
11195 return change_done;
11198 static void PlayPlayerSound(struct PlayerInfo *player)
11200 int jx = player->jx, jy = player->jy;
11201 int sound_element = player->artwork_element;
11202 int last_action = player->last_action_waiting;
11203 int action = player->action_waiting;
11205 if (player->is_waiting)
11207 if (action != last_action)
11208 PlayLevelSoundElementAction(jx, jy, sound_element, action);
11210 PlayLevelSoundElementActionIfLoop(jx, jy, sound_element, action);
11214 if (action != last_action)
11215 StopSound(element_info[sound_element].sound[last_action]);
11217 if (last_action == ACTION_SLEEPING)
11218 PlayLevelSoundElementAction(jx, jy, sound_element, ACTION_AWAKENING);
11222 static void PlayAllPlayersSound(void)
11226 for (i = 0; i < MAX_PLAYERS; i++)
11227 if (stored_player[i].active)
11228 PlayPlayerSound(&stored_player[i]);
11231 static void SetPlayerWaiting(struct PlayerInfo *player, boolean is_waiting)
11233 boolean last_waiting = player->is_waiting;
11234 int move_dir = player->MovDir;
11236 player->dir_waiting = move_dir;
11237 player->last_action_waiting = player->action_waiting;
11241 if (!last_waiting) // not waiting -> waiting
11243 player->is_waiting = TRUE;
11245 player->frame_counter_bored =
11247 game.player_boring_delay_fixed +
11248 GetSimpleRandom(game.player_boring_delay_random);
11249 player->frame_counter_sleeping =
11251 game.player_sleeping_delay_fixed +
11252 GetSimpleRandom(game.player_sleeping_delay_random);
11254 InitPlayerGfxAnimation(player, ACTION_WAITING, move_dir);
11257 if (game.player_sleeping_delay_fixed +
11258 game.player_sleeping_delay_random > 0 &&
11259 player->anim_delay_counter == 0 &&
11260 player->post_delay_counter == 0 &&
11261 FrameCounter >= player->frame_counter_sleeping)
11262 player->is_sleeping = TRUE;
11263 else if (game.player_boring_delay_fixed +
11264 game.player_boring_delay_random > 0 &&
11265 FrameCounter >= player->frame_counter_bored)
11266 player->is_bored = TRUE;
11268 player->action_waiting = (player->is_sleeping ? ACTION_SLEEPING :
11269 player->is_bored ? ACTION_BORING :
11272 if (player->is_sleeping && player->use_murphy)
11274 // special case for sleeping Murphy when leaning against non-free tile
11276 if (!IN_LEV_FIELD(player->jx - 1, player->jy) ||
11277 (Tile[player->jx - 1][player->jy] != EL_EMPTY &&
11278 !IS_MOVING(player->jx - 1, player->jy)))
11279 move_dir = MV_LEFT;
11280 else if (!IN_LEV_FIELD(player->jx + 1, player->jy) ||
11281 (Tile[player->jx + 1][player->jy] != EL_EMPTY &&
11282 !IS_MOVING(player->jx + 1, player->jy)))
11283 move_dir = MV_RIGHT;
11285 player->is_sleeping = FALSE;
11287 player->dir_waiting = move_dir;
11290 if (player->is_sleeping)
11292 if (player->num_special_action_sleeping > 0)
11294 if (player->anim_delay_counter == 0 && player->post_delay_counter == 0)
11296 int last_special_action = player->special_action_sleeping;
11297 int num_special_action = player->num_special_action_sleeping;
11298 int special_action =
11299 (last_special_action == ACTION_DEFAULT ? ACTION_SLEEPING_1 :
11300 last_special_action == ACTION_SLEEPING ? ACTION_SLEEPING :
11301 last_special_action < ACTION_SLEEPING_1 + num_special_action - 1 ?
11302 last_special_action + 1 : ACTION_SLEEPING);
11303 int special_graphic =
11304 el_act_dir2img(player->artwork_element, special_action, move_dir);
11306 player->anim_delay_counter =
11307 graphic_info[special_graphic].anim_delay_fixed +
11308 GetSimpleRandom(graphic_info[special_graphic].anim_delay_random);
11309 player->post_delay_counter =
11310 graphic_info[special_graphic].post_delay_fixed +
11311 GetSimpleRandom(graphic_info[special_graphic].post_delay_random);
11313 player->special_action_sleeping = special_action;
11316 if (player->anim_delay_counter > 0)
11318 player->action_waiting = player->special_action_sleeping;
11319 player->anim_delay_counter--;
11321 else if (player->post_delay_counter > 0)
11323 player->post_delay_counter--;
11327 else if (player->is_bored)
11329 if (player->num_special_action_bored > 0)
11331 if (player->anim_delay_counter == 0 && player->post_delay_counter == 0)
11333 int special_action =
11334 ACTION_BORING_1 + GetSimpleRandom(player->num_special_action_bored);
11335 int special_graphic =
11336 el_act_dir2img(player->artwork_element, special_action, move_dir);
11338 player->anim_delay_counter =
11339 graphic_info[special_graphic].anim_delay_fixed +
11340 GetSimpleRandom(graphic_info[special_graphic].anim_delay_random);
11341 player->post_delay_counter =
11342 graphic_info[special_graphic].post_delay_fixed +
11343 GetSimpleRandom(graphic_info[special_graphic].post_delay_random);
11345 player->special_action_bored = special_action;
11348 if (player->anim_delay_counter > 0)
11350 player->action_waiting = player->special_action_bored;
11351 player->anim_delay_counter--;
11353 else if (player->post_delay_counter > 0)
11355 player->post_delay_counter--;
11360 else if (last_waiting) // waiting -> not waiting
11362 player->is_waiting = FALSE;
11363 player->is_bored = FALSE;
11364 player->is_sleeping = FALSE;
11366 player->frame_counter_bored = -1;
11367 player->frame_counter_sleeping = -1;
11369 player->anim_delay_counter = 0;
11370 player->post_delay_counter = 0;
11372 player->dir_waiting = player->MovDir;
11373 player->action_waiting = ACTION_DEFAULT;
11375 player->special_action_bored = ACTION_DEFAULT;
11376 player->special_action_sleeping = ACTION_DEFAULT;
11380 static void CheckSaveEngineSnapshot(struct PlayerInfo *player)
11382 if ((!player->is_moving && player->was_moving) ||
11383 (player->MovPos == 0 && player->was_moving) ||
11384 (player->is_snapping && !player->was_snapping) ||
11385 (player->is_dropping && !player->was_dropping))
11387 if (!CheckSaveEngineSnapshotToList())
11390 player->was_moving = FALSE;
11391 player->was_snapping = TRUE;
11392 player->was_dropping = TRUE;
11396 if (player->is_moving)
11397 player->was_moving = TRUE;
11399 if (!player->is_snapping)
11400 player->was_snapping = FALSE;
11402 if (!player->is_dropping)
11403 player->was_dropping = FALSE;
11406 static struct MouseActionInfo mouse_action_last = { 0 };
11407 struct MouseActionInfo mouse_action = player->effective_mouse_action;
11408 boolean new_released = (!mouse_action.button && mouse_action_last.button);
11411 CheckSaveEngineSnapshotToList();
11413 mouse_action_last = mouse_action;
11416 static void CheckSingleStepMode(struct PlayerInfo *player)
11418 if (tape.single_step && tape.recording && !tape.pausing)
11420 // as it is called "single step mode", just return to pause mode when the
11421 // player stopped moving after one tile (or never starts moving at all)
11422 // (reverse logic needed here in case single step mode used in team mode)
11423 if (player->is_moving ||
11424 player->is_pushing ||
11425 player->is_dropping_pressed ||
11426 player->effective_mouse_action.button)
11427 game.enter_single_step_mode = FALSE;
11430 CheckSaveEngineSnapshot(player);
11433 static byte PlayerActions(struct PlayerInfo *player, byte player_action)
11435 int left = player_action & JOY_LEFT;
11436 int right = player_action & JOY_RIGHT;
11437 int up = player_action & JOY_UP;
11438 int down = player_action & JOY_DOWN;
11439 int button1 = player_action & JOY_BUTTON_1;
11440 int button2 = player_action & JOY_BUTTON_2;
11441 int dx = (left ? -1 : right ? 1 : 0);
11442 int dy = (up ? -1 : down ? 1 : 0);
11444 if (!player->active || tape.pausing)
11450 SnapField(player, dx, dy);
11454 DropElement(player);
11456 MovePlayer(player, dx, dy);
11459 CheckSingleStepMode(player);
11461 SetPlayerWaiting(player, FALSE);
11463 return player_action;
11467 // no actions for this player (no input at player's configured device)
11469 DigField(player, 0, 0, 0, 0, 0, 0, DF_NO_PUSH);
11470 SnapField(player, 0, 0);
11471 CheckGravityMovementWhenNotMoving(player);
11473 if (player->MovPos == 0)
11474 SetPlayerWaiting(player, TRUE);
11476 if (player->MovPos == 0) // needed for tape.playing
11477 player->is_moving = FALSE;
11479 player->is_dropping = FALSE;
11480 player->is_dropping_pressed = FALSE;
11481 player->drop_pressed_delay = 0;
11483 CheckSingleStepMode(player);
11489 static void SetMouseActionFromTapeAction(struct MouseActionInfo *mouse_action,
11492 if (!tape.use_mouse_actions)
11495 mouse_action->lx = tape_action[TAPE_ACTION_LX];
11496 mouse_action->ly = tape_action[TAPE_ACTION_LY];
11497 mouse_action->button = tape_action[TAPE_ACTION_BUTTON];
11500 static void SetTapeActionFromMouseAction(byte *tape_action,
11501 struct MouseActionInfo *mouse_action)
11503 if (!tape.use_mouse_actions)
11506 tape_action[TAPE_ACTION_LX] = mouse_action->lx;
11507 tape_action[TAPE_ACTION_LY] = mouse_action->ly;
11508 tape_action[TAPE_ACTION_BUTTON] = mouse_action->button;
11511 static void CheckLevelSolved(void)
11513 if (level.game_engine_type == GAME_ENGINE_TYPE_EM)
11515 if (game_em.level_solved &&
11516 !game_em.game_over) // game won
11520 game_em.game_over = TRUE;
11522 game.all_players_gone = TRUE;
11525 if (game_em.game_over) // game lost
11526 game.all_players_gone = TRUE;
11528 else if (level.game_engine_type == GAME_ENGINE_TYPE_SP)
11530 if (game_sp.level_solved &&
11531 !game_sp.game_over) // game won
11535 game_sp.game_over = TRUE;
11537 game.all_players_gone = TRUE;
11540 if (game_sp.game_over) // game lost
11541 game.all_players_gone = TRUE;
11543 else if (level.game_engine_type == GAME_ENGINE_TYPE_MM)
11545 if (game_mm.level_solved &&
11546 !game_mm.game_over) // game won
11550 game_mm.game_over = TRUE;
11552 game.all_players_gone = TRUE;
11555 if (game_mm.game_over) // game lost
11556 game.all_players_gone = TRUE;
11560 static void CheckLevelTime(void)
11564 if (TimeFrames >= FRAMES_PER_SECOND)
11569 for (i = 0; i < MAX_PLAYERS; i++)
11571 struct PlayerInfo *player = &stored_player[i];
11573 if (SHIELD_ON(player))
11575 player->shield_normal_time_left--;
11577 if (player->shield_deadly_time_left > 0)
11578 player->shield_deadly_time_left--;
11582 if (!game.LevelSolved && !level.use_step_counter)
11590 if (TimeLeft <= 10 && setup.time_limit)
11591 PlaySound(SND_GAME_RUNNING_OUT_OF_TIME);
11593 /* this does not make sense: game_panel_controls[GAME_PANEL_TIME].value
11594 is reset from other values in UpdateGameDoorValues() -- FIX THIS */
11596 game_panel_controls[GAME_PANEL_TIME].value = TimeLeft;
11598 if (!TimeLeft && setup.time_limit)
11600 if (level.game_engine_type == GAME_ENGINE_TYPE_EM)
11601 game_em.lev->killed_out_of_time = TRUE;
11603 for (i = 0; i < MAX_PLAYERS; i++)
11604 KillPlayer(&stored_player[i]);
11607 else if (game.no_time_limit && !game.all_players_gone)
11609 game_panel_controls[GAME_PANEL_TIME].value = TimePlayed;
11612 game_em.lev->time = (game.no_time_limit ? TimePlayed : TimeLeft);
11615 if (tape.recording || tape.playing)
11616 DrawVideoDisplay(VIDEO_STATE_TIME_ON, TapeTime);
11619 if (tape.recording || tape.playing)
11620 DrawVideoDisplay(VIDEO_STATE_FRAME_ON, FrameCounter);
11622 UpdateAndDisplayGameControlValues();
11625 void AdvanceFrameAndPlayerCounters(int player_nr)
11629 // advance frame counters (global frame counter and time frame counter)
11633 // advance player counters (counters for move delay, move animation etc.)
11634 for (i = 0; i < MAX_PLAYERS; i++)
11636 boolean advance_player_counters = (player_nr == -1 || player_nr == i);
11637 int move_delay_value = stored_player[i].move_delay_value;
11638 int move_frames = MOVE_DELAY_NORMAL_SPEED / move_delay_value;
11640 if (!advance_player_counters) // not all players may be affected
11643 if (move_frames == 0) // less than one move per game frame
11645 int stepsize = TILEX / move_delay_value;
11646 int delay = move_delay_value / MOVE_DELAY_NORMAL_SPEED;
11647 int count = (stored_player[i].is_moving ?
11648 ABS(stored_player[i].MovPos) / stepsize : FrameCounter);
11650 if (count % delay == 0)
11654 stored_player[i].Frame += move_frames;
11656 if (stored_player[i].MovPos != 0)
11657 stored_player[i].StepFrame += move_frames;
11659 if (stored_player[i].move_delay > 0)
11660 stored_player[i].move_delay--;
11662 // due to bugs in previous versions, counter must count up, not down
11663 if (stored_player[i].push_delay != -1)
11664 stored_player[i].push_delay++;
11666 if (stored_player[i].drop_delay > 0)
11667 stored_player[i].drop_delay--;
11669 if (stored_player[i].is_dropping_pressed)
11670 stored_player[i].drop_pressed_delay++;
11674 void StartGameActions(boolean init_network_game, boolean record_tape,
11677 unsigned int new_random_seed = InitRND(random_seed);
11680 TapeStartRecording(new_random_seed);
11682 if (init_network_game)
11684 SendToServer_LevelFile();
11685 SendToServer_StartPlaying();
11693 static void GameActionsExt(void)
11696 static unsigned int game_frame_delay = 0;
11698 unsigned int game_frame_delay_value;
11699 byte *recorded_player_action;
11700 byte summarized_player_action = 0;
11701 byte tape_action[MAX_TAPE_ACTIONS] = { 0 };
11704 // detect endless loops, caused by custom element programming
11705 if (recursion_loop_detected && recursion_loop_depth == 0)
11707 char *message = getStringCat3("Internal Error! Element ",
11708 EL_NAME(recursion_loop_element),
11709 " caused endless loop! Quit the game?");
11711 Warn("element '%s' caused endless loop in game engine",
11712 EL_NAME(recursion_loop_element));
11714 RequestQuitGameExt(FALSE, level_editor_test_game, message);
11716 recursion_loop_detected = FALSE; // if game should be continued
11723 if (game.restart_level)
11724 StartGameActions(network.enabled, setup.autorecord, level.random_seed);
11726 CheckLevelSolved();
11728 if (game.LevelSolved && !game.LevelSolved_GameEnd)
11731 if (game.all_players_gone && !TAPE_IS_STOPPED(tape))
11734 if (game_status != GAME_MODE_PLAYING) // status might have changed
11737 game_frame_delay_value =
11738 (tape.playing && tape.fast_forward ? FfwdFrameDelay : GameFrameDelay);
11740 if (tape.playing && tape.warp_forward && !tape.pausing)
11741 game_frame_delay_value = 0;
11743 SetVideoFrameDelay(game_frame_delay_value);
11745 // (de)activate virtual buttons depending on current game status
11746 if (strEqual(setup.touch.control_type, TOUCH_CONTROL_VIRTUAL_BUTTONS))
11748 if (game.all_players_gone) // if no players there to be controlled anymore
11749 SetOverlayActive(FALSE);
11750 else if (!tape.playing) // if game continues after tape stopped playing
11751 SetOverlayActive(TRUE);
11756 // ---------- main game synchronization point ----------
11758 int skip = WaitUntilDelayReached(&game_frame_delay, game_frame_delay_value);
11760 Debug("game:playing:skip", "skip == %d", skip);
11763 // ---------- main game synchronization point ----------
11765 WaitUntilDelayReached(&game_frame_delay, game_frame_delay_value);
11769 if (network_playing && !network_player_action_received)
11771 // try to get network player actions in time
11773 // last chance to get network player actions without main loop delay
11774 HandleNetworking();
11776 // game was quit by network peer
11777 if (game_status != GAME_MODE_PLAYING)
11780 // check if network player actions still missing and game still running
11781 if (!network_player_action_received && !checkGameEnded())
11782 return; // failed to get network player actions in time
11784 // do not yet reset "network_player_action_received" (for tape.pausing)
11790 // at this point we know that we really continue executing the game
11792 network_player_action_received = FALSE;
11794 // when playing tape, read previously recorded player input from tape data
11795 recorded_player_action = (tape.playing ? TapePlayAction() : NULL);
11797 local_player->effective_mouse_action = local_player->mouse_action;
11799 if (recorded_player_action != NULL)
11800 SetMouseActionFromTapeAction(&local_player->effective_mouse_action,
11801 recorded_player_action);
11803 // TapePlayAction() may return NULL when toggling to "pause before death"
11807 if (tape.set_centered_player)
11809 game.centered_player_nr_next = tape.centered_player_nr_next;
11810 game.set_centered_player = TRUE;
11813 for (i = 0; i < MAX_PLAYERS; i++)
11815 summarized_player_action |= stored_player[i].action;
11817 if (!network_playing && (game.team_mode || tape.playing))
11818 stored_player[i].effective_action = stored_player[i].action;
11821 if (network_playing && !checkGameEnded())
11822 SendToServer_MovePlayer(summarized_player_action);
11824 // summarize all actions at local players mapped input device position
11825 // (this allows using different input devices in single player mode)
11826 if (!network.enabled && !game.team_mode)
11827 stored_player[map_player_action[local_player->index_nr]].effective_action =
11828 summarized_player_action;
11830 // summarize all actions at centered player in local team mode
11831 if (tape.recording &&
11832 setup.team_mode && !network.enabled &&
11833 setup.input_on_focus &&
11834 game.centered_player_nr != -1)
11836 for (i = 0; i < MAX_PLAYERS; i++)
11837 stored_player[map_player_action[i]].effective_action =
11838 (i == game.centered_player_nr ? summarized_player_action : 0);
11841 if (recorded_player_action != NULL)
11842 for (i = 0; i < MAX_PLAYERS; i++)
11843 stored_player[i].effective_action = recorded_player_action[i];
11845 for (i = 0; i < MAX_PLAYERS; i++)
11847 tape_action[i] = stored_player[i].effective_action;
11849 /* (this may happen in the RND game engine if a player was not present on
11850 the playfield on level start, but appeared later from a custom element */
11851 if (setup.team_mode &&
11854 !tape.player_participates[i])
11855 tape.player_participates[i] = TRUE;
11858 SetTapeActionFromMouseAction(tape_action,
11859 &local_player->effective_mouse_action);
11861 // only record actions from input devices, but not programmed actions
11862 if (tape.recording)
11863 TapeRecordAction(tape_action);
11865 // remember if game was played (especially after tape stopped playing)
11866 if (!tape.playing && summarized_player_action)
11867 game.GamePlayed = TRUE;
11869 #if USE_NEW_PLAYER_ASSIGNMENTS
11870 // !!! also map player actions in single player mode !!!
11871 // if (game.team_mode)
11874 byte mapped_action[MAX_PLAYERS];
11876 #if DEBUG_PLAYER_ACTIONS
11877 for (i = 0; i < MAX_PLAYERS; i++)
11878 DebugContinued("", "%d, ", stored_player[i].effective_action);
11881 for (i = 0; i < MAX_PLAYERS; i++)
11882 mapped_action[i] = stored_player[map_player_action[i]].effective_action;
11884 for (i = 0; i < MAX_PLAYERS; i++)
11885 stored_player[i].effective_action = mapped_action[i];
11887 #if DEBUG_PLAYER_ACTIONS
11888 DebugContinued("", "=> ");
11889 for (i = 0; i < MAX_PLAYERS; i++)
11890 DebugContinued("", "%d, ", stored_player[i].effective_action);
11891 DebugContinued("game:playing:player", "\n");
11894 #if DEBUG_PLAYER_ACTIONS
11897 for (i = 0; i < MAX_PLAYERS; i++)
11898 DebugContinued("", "%d, ", stored_player[i].effective_action);
11899 DebugContinued("game:playing:player", "\n");
11904 for (i = 0; i < MAX_PLAYERS; i++)
11906 // allow engine snapshot in case of changed movement attempt
11907 if ((game.snapshot.last_action[i] & KEY_MOTION) !=
11908 (stored_player[i].effective_action & KEY_MOTION))
11909 game.snapshot.changed_action = TRUE;
11911 // allow engine snapshot in case of snapping/dropping attempt
11912 if ((game.snapshot.last_action[i] & KEY_BUTTON) == 0 &&
11913 (stored_player[i].effective_action & KEY_BUTTON) != 0)
11914 game.snapshot.changed_action = TRUE;
11916 game.snapshot.last_action[i] = stored_player[i].effective_action;
11919 if (level.game_engine_type == GAME_ENGINE_TYPE_EM)
11921 GameActions_EM_Main();
11923 else if (level.game_engine_type == GAME_ENGINE_TYPE_SP)
11925 GameActions_SP_Main();
11927 else if (level.game_engine_type == GAME_ENGINE_TYPE_MM)
11929 GameActions_MM_Main();
11933 GameActions_RND_Main();
11936 BlitScreenToBitmap(backbuffer);
11938 CheckLevelSolved();
11941 AdvanceFrameAndPlayerCounters(-1); // advance counters for all players
11943 if (global.show_frames_per_second)
11945 static unsigned int fps_counter = 0;
11946 static int fps_frames = 0;
11947 unsigned int fps_delay_ms = Counter() - fps_counter;
11951 if (fps_delay_ms >= 500) // calculate FPS every 0.5 seconds
11953 global.frames_per_second = 1000 * (float)fps_frames / fps_delay_ms;
11956 fps_counter = Counter();
11958 // always draw FPS to screen after FPS value was updated
11959 redraw_mask |= REDRAW_FPS;
11962 // only draw FPS if no screen areas are deactivated (invisible warp mode)
11963 if (GetDrawDeactivationMask() == REDRAW_NONE)
11964 redraw_mask |= REDRAW_FPS;
11968 static void GameActions_CheckSaveEngineSnapshot(void)
11970 if (!game.snapshot.save_snapshot)
11973 // clear flag for saving snapshot _before_ saving snapshot
11974 game.snapshot.save_snapshot = FALSE;
11976 SaveEngineSnapshotToList();
11979 void GameActions(void)
11983 GameActions_CheckSaveEngineSnapshot();
11986 void GameActions_EM_Main(void)
11988 byte effective_action[MAX_PLAYERS];
11989 boolean warp_mode = (tape.playing && tape.warp_forward && !tape.pausing);
11992 for (i = 0; i < MAX_PLAYERS; i++)
11993 effective_action[i] = stored_player[i].effective_action;
11995 GameActions_EM(effective_action, warp_mode);
11998 void GameActions_SP_Main(void)
12000 byte effective_action[MAX_PLAYERS];
12001 boolean warp_mode = (tape.playing && tape.warp_forward && !tape.pausing);
12004 for (i = 0; i < MAX_PLAYERS; i++)
12005 effective_action[i] = stored_player[i].effective_action;
12007 GameActions_SP(effective_action, warp_mode);
12009 for (i = 0; i < MAX_PLAYERS; i++)
12011 if (stored_player[i].force_dropping)
12012 stored_player[i].action |= KEY_BUTTON_DROP;
12014 stored_player[i].force_dropping = FALSE;
12018 void GameActions_MM_Main(void)
12020 boolean warp_mode = (tape.playing && tape.warp_forward && !tape.pausing);
12022 GameActions_MM(local_player->effective_mouse_action, warp_mode);
12025 void GameActions_RND_Main(void)
12030 void GameActions_RND(void)
12032 static struct MouseActionInfo mouse_action_last = { 0 };
12033 struct MouseActionInfo mouse_action = local_player->effective_mouse_action;
12034 int magic_wall_x = 0, magic_wall_y = 0;
12035 int i, x, y, element, graphic, last_gfx_frame;
12037 InitPlayfieldScanModeVars();
12039 if (game.engine_version >= VERSION_IDENT(3,2,0,7))
12041 SCAN_PLAYFIELD(x, y)
12043 ChangeCount[x][y] = 0;
12044 ChangeEvent[x][y] = -1;
12048 if (game.set_centered_player)
12050 boolean all_players_fit_to_screen = checkIfAllPlayersFitToScreen_RND();
12052 // switching to "all players" only possible if all players fit to screen
12053 if (game.centered_player_nr_next == -1 && !all_players_fit_to_screen)
12055 game.centered_player_nr_next = game.centered_player_nr;
12056 game.set_centered_player = FALSE;
12059 // do not switch focus to non-existing (or non-active) player
12060 if (game.centered_player_nr_next >= 0 &&
12061 !stored_player[game.centered_player_nr_next].active)
12063 game.centered_player_nr_next = game.centered_player_nr;
12064 game.set_centered_player = FALSE;
12068 if (game.set_centered_player &&
12069 ScreenMovPos == 0) // screen currently aligned at tile position
12073 if (game.centered_player_nr_next == -1)
12075 setScreenCenteredToAllPlayers(&sx, &sy);
12079 sx = stored_player[game.centered_player_nr_next].jx;
12080 sy = stored_player[game.centered_player_nr_next].jy;
12083 game.centered_player_nr = game.centered_player_nr_next;
12084 game.set_centered_player = FALSE;
12086 DrawRelocateScreen(0, 0, sx, sy, MV_NONE, TRUE, setup.quick_switch);
12087 DrawGameDoorValues();
12090 // check single step mode (set flag and clear again if any player is active)
12091 game.enter_single_step_mode =
12092 (tape.single_step && tape.recording && !tape.pausing);
12094 for (i = 0; i < MAX_PLAYERS; i++)
12096 int actual_player_action = stored_player[i].effective_action;
12099 /* !!! THIS BREAKS THE FOLLOWING TAPES: !!!
12100 - rnd_equinox_tetrachloride 048
12101 - rnd_equinox_tetrachloride_ii 096
12102 - rnd_emanuel_schmieg 002
12103 - doctor_sloan_ww 001, 020
12105 if (stored_player[i].MovPos == 0)
12106 CheckGravityMovement(&stored_player[i]);
12109 // overwrite programmed action with tape action
12110 if (stored_player[i].programmed_action)
12111 actual_player_action = stored_player[i].programmed_action;
12113 PlayerActions(&stored_player[i], actual_player_action);
12115 ScrollPlayer(&stored_player[i], SCROLL_GO_ON);
12118 // single step pause mode may already have been toggled by "ScrollPlayer()"
12119 if (game.enter_single_step_mode && !tape.pausing)
12120 TapeTogglePause(TAPE_TOGGLE_AUTOMATIC);
12122 ScrollScreen(NULL, SCROLL_GO_ON);
12124 /* for backwards compatibility, the following code emulates a fixed bug that
12125 occured when pushing elements (causing elements that just made their last
12126 pushing step to already (if possible) make their first falling step in the
12127 same game frame, which is bad); this code is also needed to use the famous
12128 "spring push bug" which is used in older levels and might be wanted to be
12129 used also in newer levels, but in this case the buggy pushing code is only
12130 affecting the "spring" element and no other elements */
12132 if (game.engine_version < VERSION_IDENT(2,2,0,7) || level.use_spring_bug)
12134 for (i = 0; i < MAX_PLAYERS; i++)
12136 struct PlayerInfo *player = &stored_player[i];
12137 int x = player->jx;
12138 int y = player->jy;
12140 if (player->active && player->is_pushing && player->is_moving &&
12142 (game.engine_version < VERSION_IDENT(2,2,0,7) ||
12143 Tile[x][y] == EL_SPRING))
12145 ContinueMoving(x, y);
12147 // continue moving after pushing (this is actually a bug)
12148 if (!IS_MOVING(x, y))
12149 Stop[x][y] = FALSE;
12154 SCAN_PLAYFIELD(x, y)
12156 Last[x][y] = Tile[x][y];
12158 ChangeCount[x][y] = 0;
12159 ChangeEvent[x][y] = -1;
12161 // this must be handled before main playfield loop
12162 if (Tile[x][y] == EL_PLAYER_IS_LEAVING)
12165 if (MovDelay[x][y] <= 0)
12169 if (Tile[x][y] == EL_ELEMENT_SNAPPING)
12172 if (MovDelay[x][y] <= 0)
12174 int element = Store[x][y];
12175 int move_direction = MovDir[x][y];
12176 int player_index_bit = Store2[x][y];
12182 TEST_DrawLevelField(x, y);
12184 TestFieldAfterSnapping(x, y, element, move_direction, player_index_bit);
12186 if (IS_ENVELOPE(element))
12187 local_player->show_envelope = element;
12192 if (ChangePage[x][y] != -1 && ChangeDelay[x][y] != 1)
12194 Debug("game:playing:GameActions_RND", "x = %d, y = %d: ChangePage != -1",
12196 Debug("game:playing:GameActions_RND", "This should never happen!");
12198 ChangePage[x][y] = -1;
12202 Stop[x][y] = FALSE;
12203 if (WasJustMoving[x][y] > 0)
12204 WasJustMoving[x][y]--;
12205 if (WasJustFalling[x][y] > 0)
12206 WasJustFalling[x][y]--;
12207 if (CheckCollision[x][y] > 0)
12208 CheckCollision[x][y]--;
12209 if (CheckImpact[x][y] > 0)
12210 CheckImpact[x][y]--;
12214 /* reset finished pushing action (not done in ContinueMoving() to allow
12215 continuous pushing animation for elements with zero push delay) */
12216 if (GfxAction[x][y] == ACTION_PUSHING && !IS_MOVING(x, y))
12218 ResetGfxAnimation(x, y);
12219 TEST_DrawLevelField(x, y);
12223 if (IS_BLOCKED(x, y))
12227 Blocked2Moving(x, y, &oldx, &oldy);
12228 if (!IS_MOVING(oldx, oldy))
12230 Debug("game:playing:GameActions_RND", "(BLOCKED => MOVING) context corrupted!");
12231 Debug("game:playing:GameActions_RND", "BLOCKED: x = %d, y = %d", x, y);
12232 Debug("game:playing:GameActions_RND", "!MOVING: oldx = %d, oldy = %d", oldx, oldy);
12233 Debug("game:playing:GameActions_RND", "This should never happen!");
12239 if (mouse_action.button)
12241 int new_button = (mouse_action.button && mouse_action_last.button == 0);
12242 int ch_button = CH_SIDE_FROM_BUTTON(mouse_action.button);
12244 x = mouse_action.lx;
12245 y = mouse_action.ly;
12246 element = Tile[x][y];
12250 CheckElementChangeByMouse(x, y, element, CE_CLICKED_BY_MOUSE, ch_button);
12251 CheckTriggeredElementChangeByMouse(x, y, element, CE_MOUSE_CLICKED_ON_X,
12255 CheckElementChangeByMouse(x, y, element, CE_PRESSED_BY_MOUSE, ch_button);
12256 CheckTriggeredElementChangeByMouse(x, y, element, CE_MOUSE_PRESSED_ON_X,
12260 SCAN_PLAYFIELD(x, y)
12262 element = Tile[x][y];
12263 graphic = el_act_dir2img(element, GfxAction[x][y], GfxDir[x][y]);
12264 last_gfx_frame = GfxFrame[x][y];
12266 ResetGfxFrame(x, y);
12268 if (GfxFrame[x][y] != last_gfx_frame && !Stop[x][y])
12269 DrawLevelGraphicAnimation(x, y, graphic);
12271 if (ANIM_MODE(graphic) == ANIM_RANDOM &&
12272 IS_NEXT_FRAME(GfxFrame[x][y], graphic))
12273 ResetRandomAnimationValue(x, y);
12275 SetRandomAnimationValue(x, y);
12277 PlayLevelSoundActionIfLoop(x, y, GfxAction[x][y]);
12279 if (IS_INACTIVE(element))
12281 if (IS_ANIMATED(graphic))
12282 DrawLevelGraphicAnimationIfNeeded(x, y, graphic);
12287 // this may take place after moving, so 'element' may have changed
12288 if (IS_CHANGING(x, y) &&
12289 (game.engine_version < VERSION_IDENT(3,0,7,1) || !Stop[x][y]))
12291 int page = element_info[element].event_page_nr[CE_DELAY];
12293 HandleElementChange(x, y, page);
12295 element = Tile[x][y];
12296 graphic = el_act_dir2img(element, GfxAction[x][y], GfxDir[x][y]);
12299 if (!IS_MOVING(x, y) && (CAN_FALL(element) || CAN_MOVE(element)))
12303 element = Tile[x][y];
12304 graphic = el_act_dir2img(element, GfxAction[x][y], GfxDir[x][y]);
12306 if (IS_ANIMATED(graphic) &&
12307 !IS_MOVING(x, y) &&
12309 DrawLevelGraphicAnimationIfNeeded(x, y, graphic);
12311 if (IS_GEM(element) || element == EL_SP_INFOTRON)
12312 TEST_DrawTwinkleOnField(x, y);
12314 else if (element == EL_ACID)
12317 DrawLevelGraphicAnimationIfNeeded(x, y, graphic);
12319 else if ((element == EL_EXIT_OPEN ||
12320 element == EL_EM_EXIT_OPEN ||
12321 element == EL_SP_EXIT_OPEN ||
12322 element == EL_STEEL_EXIT_OPEN ||
12323 element == EL_EM_STEEL_EXIT_OPEN ||
12324 element == EL_SP_TERMINAL ||
12325 element == EL_SP_TERMINAL_ACTIVE ||
12326 element == EL_EXTRA_TIME ||
12327 element == EL_SHIELD_NORMAL ||
12328 element == EL_SHIELD_DEADLY) &&
12329 IS_ANIMATED(graphic))
12330 DrawLevelGraphicAnimationIfNeeded(x, y, graphic);
12331 else if (IS_MOVING(x, y))
12332 ContinueMoving(x, y);
12333 else if (IS_ACTIVE_BOMB(element))
12334 CheckDynamite(x, y);
12335 else if (element == EL_AMOEBA_GROWING)
12336 AmoebaGrowing(x, y);
12337 else if (element == EL_AMOEBA_SHRINKING)
12338 AmoebaShrinking(x, y);
12340 #if !USE_NEW_AMOEBA_CODE
12341 else if (IS_AMOEBALIVE(element))
12342 AmoebaReproduce(x, y);
12345 else if (element == EL_GAME_OF_LIFE || element == EL_BIOMAZE)
12347 else if (element == EL_EXIT_CLOSED)
12349 else if (element == EL_EM_EXIT_CLOSED)
12351 else if (element == EL_STEEL_EXIT_CLOSED)
12352 CheckExitSteel(x, y);
12353 else if (element == EL_EM_STEEL_EXIT_CLOSED)
12354 CheckExitSteelEM(x, y);
12355 else if (element == EL_SP_EXIT_CLOSED)
12357 else if (element == EL_EXPANDABLE_WALL_GROWING ||
12358 element == EL_EXPANDABLE_STEELWALL_GROWING)
12359 MauerWaechst(x, y);
12360 else if (element == EL_EXPANDABLE_WALL ||
12361 element == EL_EXPANDABLE_WALL_HORIZONTAL ||
12362 element == EL_EXPANDABLE_WALL_VERTICAL ||
12363 element == EL_EXPANDABLE_WALL_ANY ||
12364 element == EL_BD_EXPANDABLE_WALL)
12365 MauerAbleger(x, y);
12366 else if (element == EL_EXPANDABLE_STEELWALL_HORIZONTAL ||
12367 element == EL_EXPANDABLE_STEELWALL_VERTICAL ||
12368 element == EL_EXPANDABLE_STEELWALL_ANY)
12369 MauerAblegerStahl(x, y);
12370 else if (element == EL_FLAMES)
12371 CheckForDragon(x, y);
12372 else if (element == EL_EXPLOSION)
12373 ; // drawing of correct explosion animation is handled separately
12374 else if (element == EL_ELEMENT_SNAPPING ||
12375 element == EL_DIAGONAL_SHRINKING ||
12376 element == EL_DIAGONAL_GROWING)
12378 graphic = el_act_dir2img(GfxElement[x][y], GfxAction[x][y],GfxDir[x][y]);
12380 DrawLevelGraphicAnimationIfNeeded(x, y, graphic);
12382 else if (IS_ANIMATED(graphic) && !IS_CHANGING(x, y))
12383 DrawLevelGraphicAnimationIfNeeded(x, y, graphic);
12385 if (IS_BELT_ACTIVE(element))
12386 PlayLevelSoundAction(x, y, ACTION_ACTIVE);
12388 if (game.magic_wall_active)
12390 int jx = local_player->jx, jy = local_player->jy;
12392 // play the element sound at the position nearest to the player
12393 if ((element == EL_MAGIC_WALL_FULL ||
12394 element == EL_MAGIC_WALL_ACTIVE ||
12395 element == EL_MAGIC_WALL_EMPTYING ||
12396 element == EL_BD_MAGIC_WALL_FULL ||
12397 element == EL_BD_MAGIC_WALL_ACTIVE ||
12398 element == EL_BD_MAGIC_WALL_EMPTYING ||
12399 element == EL_DC_MAGIC_WALL_FULL ||
12400 element == EL_DC_MAGIC_WALL_ACTIVE ||
12401 element == EL_DC_MAGIC_WALL_EMPTYING) &&
12402 ABS(x - jx) + ABS(y - jy) <
12403 ABS(magic_wall_x - jx) + ABS(magic_wall_y - jy))
12411 #if USE_NEW_AMOEBA_CODE
12412 // new experimental amoeba growth stuff
12413 if (!(FrameCounter % 8))
12415 static unsigned int random = 1684108901;
12417 for (i = 0; i < level.amoeba_speed * 28 / 8; i++)
12419 x = RND(lev_fieldx);
12420 y = RND(lev_fieldy);
12421 element = Tile[x][y];
12423 if (!IS_PLAYER(x,y) &&
12424 (element == EL_EMPTY ||
12425 CAN_GROW_INTO(element) ||
12426 element == EL_QUICKSAND_EMPTY ||
12427 element == EL_QUICKSAND_FAST_EMPTY ||
12428 element == EL_ACID_SPLASH_LEFT ||
12429 element == EL_ACID_SPLASH_RIGHT))
12431 if ((IN_LEV_FIELD(x, y-1) && Tile[x][y-1] == EL_AMOEBA_WET) ||
12432 (IN_LEV_FIELD(x-1, y) && Tile[x-1][y] == EL_AMOEBA_WET) ||
12433 (IN_LEV_FIELD(x+1, y) && Tile[x+1][y] == EL_AMOEBA_WET) ||
12434 (IN_LEV_FIELD(x, y+1) && Tile[x][y+1] == EL_AMOEBA_WET))
12435 Tile[x][y] = EL_AMOEBA_DROP;
12438 random = random * 129 + 1;
12443 game.explosions_delayed = FALSE;
12445 SCAN_PLAYFIELD(x, y)
12447 element = Tile[x][y];
12449 if (ExplodeField[x][y])
12450 Explode(x, y, EX_PHASE_START, ExplodeField[x][y]);
12451 else if (element == EL_EXPLOSION)
12452 Explode(x, y, ExplodePhase[x][y], EX_TYPE_NORMAL);
12454 ExplodeField[x][y] = EX_TYPE_NONE;
12457 game.explosions_delayed = TRUE;
12459 if (game.magic_wall_active)
12461 if (!(game.magic_wall_time_left % 4))
12463 int element = Tile[magic_wall_x][magic_wall_y];
12465 if (element == EL_BD_MAGIC_WALL_FULL ||
12466 element == EL_BD_MAGIC_WALL_ACTIVE ||
12467 element == EL_BD_MAGIC_WALL_EMPTYING)
12468 PlayLevelSound(magic_wall_x, magic_wall_y, SND_BD_MAGIC_WALL_ACTIVE);
12469 else if (element == EL_DC_MAGIC_WALL_FULL ||
12470 element == EL_DC_MAGIC_WALL_ACTIVE ||
12471 element == EL_DC_MAGIC_WALL_EMPTYING)
12472 PlayLevelSound(magic_wall_x, magic_wall_y, SND_DC_MAGIC_WALL_ACTIVE);
12474 PlayLevelSound(magic_wall_x, magic_wall_y, SND_MAGIC_WALL_ACTIVE);
12477 if (game.magic_wall_time_left > 0)
12479 game.magic_wall_time_left--;
12481 if (!game.magic_wall_time_left)
12483 SCAN_PLAYFIELD(x, y)
12485 element = Tile[x][y];
12487 if (element == EL_MAGIC_WALL_ACTIVE ||
12488 element == EL_MAGIC_WALL_FULL)
12490 Tile[x][y] = EL_MAGIC_WALL_DEAD;
12491 TEST_DrawLevelField(x, y);
12493 else if (element == EL_BD_MAGIC_WALL_ACTIVE ||
12494 element == EL_BD_MAGIC_WALL_FULL)
12496 Tile[x][y] = EL_BD_MAGIC_WALL_DEAD;
12497 TEST_DrawLevelField(x, y);
12499 else if (element == EL_DC_MAGIC_WALL_ACTIVE ||
12500 element == EL_DC_MAGIC_WALL_FULL)
12502 Tile[x][y] = EL_DC_MAGIC_WALL_DEAD;
12503 TEST_DrawLevelField(x, y);
12507 game.magic_wall_active = FALSE;
12512 if (game.light_time_left > 0)
12514 game.light_time_left--;
12516 if (game.light_time_left == 0)
12517 RedrawAllLightSwitchesAndInvisibleElements();
12520 if (game.timegate_time_left > 0)
12522 game.timegate_time_left--;
12524 if (game.timegate_time_left == 0)
12525 CloseAllOpenTimegates();
12528 if (game.lenses_time_left > 0)
12530 game.lenses_time_left--;
12532 if (game.lenses_time_left == 0)
12533 RedrawAllInvisibleElementsForLenses();
12536 if (game.magnify_time_left > 0)
12538 game.magnify_time_left--;
12540 if (game.magnify_time_left == 0)
12541 RedrawAllInvisibleElementsForMagnifier();
12544 for (i = 0; i < MAX_PLAYERS; i++)
12546 struct PlayerInfo *player = &stored_player[i];
12548 if (SHIELD_ON(player))
12550 if (player->shield_deadly_time_left)
12551 PlayLevelSound(player->jx, player->jy, SND_SHIELD_DEADLY_ACTIVE);
12552 else if (player->shield_normal_time_left)
12553 PlayLevelSound(player->jx, player->jy, SND_SHIELD_NORMAL_ACTIVE);
12557 #if USE_DELAYED_GFX_REDRAW
12558 SCAN_PLAYFIELD(x, y)
12560 if (GfxRedraw[x][y] != GFX_REDRAW_NONE)
12562 /* !!! PROBLEM: THIS REDRAWS THE PLAYFIELD _AFTER_ THE SCAN, BUT TILES
12563 !!! MAY HAVE CHANGED AFTER BEING DRAWN DURING PLAYFIELD SCAN !!! */
12565 if (GfxRedraw[x][y] & GFX_REDRAW_TILE)
12566 DrawLevelField(x, y);
12568 if (GfxRedraw[x][y] & GFX_REDRAW_TILE_CRUMBLED)
12569 DrawLevelFieldCrumbled(x, y);
12571 if (GfxRedraw[x][y] & GFX_REDRAW_TILE_CRUMBLED_NEIGHBOURS)
12572 DrawLevelFieldCrumbledNeighbours(x, y);
12574 if (GfxRedraw[x][y] & GFX_REDRAW_TILE_TWINKLED)
12575 DrawTwinkleOnField(x, y);
12578 GfxRedraw[x][y] = GFX_REDRAW_NONE;
12583 PlayAllPlayersSound();
12585 for (i = 0; i < MAX_PLAYERS; i++)
12587 struct PlayerInfo *player = &stored_player[i];
12589 if (player->show_envelope != 0 && (!player->active ||
12590 player->MovPos == 0))
12592 ShowEnvelope(player->show_envelope - EL_ENVELOPE_1);
12594 player->show_envelope = 0;
12598 // use random number generator in every frame to make it less predictable
12599 if (game.engine_version >= VERSION_IDENT(3,1,1,0))
12602 mouse_action_last = mouse_action;
12605 static boolean AllPlayersInSight(struct PlayerInfo *player, int x, int y)
12607 int min_x = x, min_y = y, max_x = x, max_y = y;
12608 int scr_fieldx = getScreenFieldSizeX();
12609 int scr_fieldy = getScreenFieldSizeY();
12612 for (i = 0; i < MAX_PLAYERS; i++)
12614 int jx = stored_player[i].jx, jy = stored_player[i].jy;
12616 if (!stored_player[i].active || &stored_player[i] == player)
12619 min_x = MIN(min_x, jx);
12620 min_y = MIN(min_y, jy);
12621 max_x = MAX(max_x, jx);
12622 max_y = MAX(max_y, jy);
12625 return (max_x - min_x < scr_fieldx && max_y - min_y < scr_fieldy);
12628 static boolean AllPlayersInVisibleScreen(void)
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)
12639 if (!IN_VIS_FIELD(SCREENX(jx), SCREENY(jy)))
12646 void ScrollLevel(int dx, int dy)
12648 int scroll_offset = 2 * TILEX_VAR;
12651 BlitBitmap(drawto_field, drawto_field,
12652 FX + TILEX_VAR * (dx == -1) - scroll_offset,
12653 FY + TILEY_VAR * (dy == -1) - scroll_offset,
12654 SXSIZE - TILEX_VAR * (dx != 0) + 2 * scroll_offset,
12655 SYSIZE - TILEY_VAR * (dy != 0) + 2 * scroll_offset,
12656 FX + TILEX_VAR * (dx == 1) - scroll_offset,
12657 FY + TILEY_VAR * (dy == 1) - scroll_offset);
12661 x = (dx == 1 ? BX1 : BX2);
12662 for (y = BY1; y <= BY2; y++)
12663 DrawScreenField(x, y);
12668 y = (dy == 1 ? BY1 : BY2);
12669 for (x = BX1; x <= BX2; x++)
12670 DrawScreenField(x, y);
12673 redraw_mask |= REDRAW_FIELD;
12676 static boolean canFallDown(struct PlayerInfo *player)
12678 int jx = player->jx, jy = player->jy;
12680 return (IN_LEV_FIELD(jx, jy + 1) &&
12681 (IS_FREE(jx, jy + 1) ||
12682 (Tile[jx][jy + 1] == EL_ACID && player->can_fall_into_acid)) &&
12683 IS_WALKABLE_FROM(Tile[jx][jy], MV_DOWN) &&
12684 !IS_WALKABLE_INSIDE(Tile[jx][jy]));
12687 static boolean canPassField(int x, int y, int move_dir)
12689 int opposite_dir = MV_DIR_OPPOSITE(move_dir);
12690 int dx = (move_dir & MV_LEFT ? -1 : move_dir & MV_RIGHT ? +1 : 0);
12691 int dy = (move_dir & MV_UP ? -1 : move_dir & MV_DOWN ? +1 : 0);
12692 int nextx = x + dx;
12693 int nexty = y + dy;
12694 int element = Tile[x][y];
12696 return (IS_PASSABLE_FROM(element, opposite_dir) &&
12697 !CAN_MOVE(element) &&
12698 IN_LEV_FIELD(nextx, nexty) && !IS_PLAYER(nextx, nexty) &&
12699 IS_WALKABLE_FROM(Tile[nextx][nexty], move_dir) &&
12700 (level.can_pass_to_walkable || IS_FREE(nextx, nexty)));
12703 static boolean canMoveToValidFieldWithGravity(int x, int y, int move_dir)
12705 int opposite_dir = MV_DIR_OPPOSITE(move_dir);
12706 int dx = (move_dir & MV_LEFT ? -1 : move_dir & MV_RIGHT ? +1 : 0);
12707 int dy = (move_dir & MV_UP ? -1 : move_dir & MV_DOWN ? +1 : 0);
12711 return (IN_LEV_FIELD(newx, newy) && !IS_FREE_OR_PLAYER(newx, newy) &&
12712 IS_GRAVITY_REACHABLE(Tile[newx][newy]) &&
12713 (IS_DIGGABLE(Tile[newx][newy]) ||
12714 IS_WALKABLE_FROM(Tile[newx][newy], opposite_dir) ||
12715 canPassField(newx, newy, move_dir)));
12718 static void CheckGravityMovement(struct PlayerInfo *player)
12720 if (player->gravity && !player->programmed_action)
12722 int move_dir_horizontal = player->effective_action & MV_HORIZONTAL;
12723 int move_dir_vertical = player->effective_action & MV_VERTICAL;
12724 boolean player_is_snapping = (player->effective_action & JOY_BUTTON_1);
12725 int jx = player->jx, jy = player->jy;
12726 boolean player_is_moving_to_valid_field =
12727 (!player_is_snapping &&
12728 (canMoveToValidFieldWithGravity(jx, jy, move_dir_horizontal) ||
12729 canMoveToValidFieldWithGravity(jx, jy, move_dir_vertical)));
12730 boolean player_can_fall_down = canFallDown(player);
12732 if (player_can_fall_down &&
12733 !player_is_moving_to_valid_field)
12734 player->programmed_action = MV_DOWN;
12738 static void CheckGravityMovementWhenNotMoving(struct PlayerInfo *player)
12740 return CheckGravityMovement(player);
12742 if (player->gravity && !player->programmed_action)
12744 int jx = player->jx, jy = player->jy;
12745 boolean field_under_player_is_free =
12746 (IN_LEV_FIELD(jx, jy + 1) && IS_FREE(jx, jy + 1));
12747 boolean player_is_standing_on_valid_field =
12748 (IS_WALKABLE_INSIDE(Tile[jx][jy]) ||
12749 (IS_WALKABLE(Tile[jx][jy]) &&
12750 !(element_info[Tile[jx][jy]].access_direction & MV_DOWN)));
12752 if (field_under_player_is_free && !player_is_standing_on_valid_field)
12753 player->programmed_action = MV_DOWN;
12758 MovePlayerOneStep()
12759 -----------------------------------------------------------------------------
12760 dx, dy: direction (non-diagonal) to try to move the player to
12761 real_dx, real_dy: direction as read from input device (can be diagonal)
12764 boolean MovePlayerOneStep(struct PlayerInfo *player,
12765 int dx, int dy, int real_dx, int real_dy)
12767 int jx = player->jx, jy = player->jy;
12768 int new_jx = jx + dx, new_jy = jy + dy;
12770 boolean player_can_move = !player->cannot_move;
12772 if (!player->active || (!dx && !dy))
12773 return MP_NO_ACTION;
12775 player->MovDir = (dx < 0 ? MV_LEFT :
12776 dx > 0 ? MV_RIGHT :
12778 dy > 0 ? MV_DOWN : MV_NONE);
12780 if (!IN_LEV_FIELD(new_jx, new_jy))
12781 return MP_NO_ACTION;
12783 if (!player_can_move)
12785 if (player->MovPos == 0)
12787 player->is_moving = FALSE;
12788 player->is_digging = FALSE;
12789 player->is_collecting = FALSE;
12790 player->is_snapping = FALSE;
12791 player->is_pushing = FALSE;
12795 if (!network.enabled && game.centered_player_nr == -1 &&
12796 !AllPlayersInSight(player, new_jx, new_jy))
12797 return MP_NO_ACTION;
12799 can_move = DigField(player, jx, jy, new_jx, new_jy, real_dx,real_dy, DF_DIG);
12800 if (can_move != MP_MOVING)
12803 // check if DigField() has caused relocation of the player
12804 if (player->jx != jx || player->jy != jy)
12805 return MP_NO_ACTION; // <-- !!! CHECK THIS [-> MP_ACTION ?] !!!
12807 StorePlayer[jx][jy] = 0;
12808 player->last_jx = jx;
12809 player->last_jy = jy;
12810 player->jx = new_jx;
12811 player->jy = new_jy;
12812 StorePlayer[new_jx][new_jy] = player->element_nr;
12814 if (player->move_delay_value_next != -1)
12816 player->move_delay_value = player->move_delay_value_next;
12817 player->move_delay_value_next = -1;
12821 (dx > 0 || dy > 0 ? -1 : 1) * (TILEX - TILEX / player->move_delay_value);
12823 player->step_counter++;
12825 PlayerVisit[jx][jy] = FrameCounter;
12827 player->is_moving = TRUE;
12830 // should better be called in MovePlayer(), but this breaks some tapes
12831 ScrollPlayer(player, SCROLL_INIT);
12837 boolean MovePlayer(struct PlayerInfo *player, int dx, int dy)
12839 int jx = player->jx, jy = player->jy;
12840 int old_jx = jx, old_jy = jy;
12841 int moved = MP_NO_ACTION;
12843 if (!player->active)
12848 if (player->MovPos == 0)
12850 player->is_moving = FALSE;
12851 player->is_digging = FALSE;
12852 player->is_collecting = FALSE;
12853 player->is_snapping = FALSE;
12854 player->is_pushing = FALSE;
12860 if (player->move_delay > 0)
12863 player->move_delay = -1; // set to "uninitialized" value
12865 // store if player is automatically moved to next field
12866 player->is_auto_moving = (player->programmed_action != MV_NONE);
12868 // remove the last programmed player action
12869 player->programmed_action = 0;
12871 if (player->MovPos)
12873 // should only happen if pre-1.2 tape recordings are played
12874 // this is only for backward compatibility
12876 int original_move_delay_value = player->move_delay_value;
12879 Debug("game:playing:MovePlayer",
12880 "THIS SHOULD ONLY HAPPEN WITH PRE-1.2 LEVEL TAPES. [%d]",
12884 // scroll remaining steps with finest movement resolution
12885 player->move_delay_value = MOVE_DELAY_NORMAL_SPEED;
12887 while (player->MovPos)
12889 ScrollPlayer(player, SCROLL_GO_ON);
12890 ScrollScreen(NULL, SCROLL_GO_ON);
12892 AdvanceFrameAndPlayerCounters(player->index_nr);
12895 BackToFront_WithFrameDelay(0);
12898 player->move_delay_value = original_move_delay_value;
12901 player->is_active = FALSE;
12903 if (player->last_move_dir & MV_HORIZONTAL)
12905 if (!(moved |= MovePlayerOneStep(player, 0, dy, dx, dy)))
12906 moved |= MovePlayerOneStep(player, dx, 0, dx, dy);
12910 if (!(moved |= MovePlayerOneStep(player, dx, 0, dx, dy)))
12911 moved |= MovePlayerOneStep(player, 0, dy, dx, dy);
12914 if (!moved && !player->is_active)
12916 player->is_moving = FALSE;
12917 player->is_digging = FALSE;
12918 player->is_collecting = FALSE;
12919 player->is_snapping = FALSE;
12920 player->is_pushing = FALSE;
12926 if (moved & MP_MOVING && !ScreenMovPos &&
12927 (player->index_nr == game.centered_player_nr ||
12928 game.centered_player_nr == -1))
12930 int old_scroll_x = scroll_x, old_scroll_y = scroll_y;
12932 if (!IN_VIS_FIELD(SCREENX(jx), SCREENY(jy)))
12934 // actual player has left the screen -- scroll in that direction
12935 if (jx != old_jx) // player has moved horizontally
12936 scroll_x += (jx - old_jx);
12937 else // player has moved vertically
12938 scroll_y += (jy - old_jy);
12942 int offset_raw = game.scroll_delay_value;
12944 if (jx != old_jx) // player has moved horizontally
12946 int offset = MIN(offset_raw, (SCR_FIELDX - 2) / 2);
12947 int offset_x = offset * (player->MovDir == MV_LEFT ? +1 : -1);
12948 int new_scroll_x = jx - MIDPOSX + offset_x;
12950 if ((player->MovDir == MV_LEFT && scroll_x > new_scroll_x) ||
12951 (player->MovDir == MV_RIGHT && scroll_x < new_scroll_x))
12952 scroll_x = new_scroll_x;
12954 // don't scroll over playfield boundaries
12955 scroll_x = MIN(MAX(SBX_Left, scroll_x), SBX_Right);
12957 // don't scroll more than one field at a time
12958 scroll_x = old_scroll_x + SIGN(scroll_x - old_scroll_x);
12960 // don't scroll against the player's moving direction
12961 if ((player->MovDir == MV_LEFT && scroll_x > old_scroll_x) ||
12962 (player->MovDir == MV_RIGHT && scroll_x < old_scroll_x))
12963 scroll_x = old_scroll_x;
12965 else // player has moved vertically
12967 int offset = MIN(offset_raw, (SCR_FIELDY - 2) / 2);
12968 int offset_y = offset * (player->MovDir == MV_UP ? +1 : -1);
12969 int new_scroll_y = jy - MIDPOSY + offset_y;
12971 if ((player->MovDir == MV_UP && scroll_y > new_scroll_y) ||
12972 (player->MovDir == MV_DOWN && scroll_y < new_scroll_y))
12973 scroll_y = new_scroll_y;
12975 // don't scroll over playfield boundaries
12976 scroll_y = MIN(MAX(SBY_Upper, scroll_y), SBY_Lower);
12978 // don't scroll more than one field at a time
12979 scroll_y = old_scroll_y + SIGN(scroll_y - old_scroll_y);
12981 // don't scroll against the player's moving direction
12982 if ((player->MovDir == MV_UP && scroll_y > old_scroll_y) ||
12983 (player->MovDir == MV_DOWN && scroll_y < old_scroll_y))
12984 scroll_y = old_scroll_y;
12988 if (scroll_x != old_scroll_x || scroll_y != old_scroll_y)
12990 if (!network.enabled && game.centered_player_nr == -1 &&
12991 !AllPlayersInVisibleScreen())
12993 scroll_x = old_scroll_x;
12994 scroll_y = old_scroll_y;
12998 ScrollScreen(player, SCROLL_INIT);
12999 ScrollLevel(old_scroll_x - scroll_x, old_scroll_y - scroll_y);
13004 player->StepFrame = 0;
13006 if (moved & MP_MOVING)
13008 if (old_jx != jx && old_jy == jy)
13009 player->MovDir = (old_jx < jx ? MV_RIGHT : MV_LEFT);
13010 else if (old_jx == jx && old_jy != jy)
13011 player->MovDir = (old_jy < jy ? MV_DOWN : MV_UP);
13013 TEST_DrawLevelField(jx, jy); // for "crumbled sand"
13015 player->last_move_dir = player->MovDir;
13016 player->is_moving = TRUE;
13017 player->is_snapping = FALSE;
13018 player->is_switching = FALSE;
13019 player->is_dropping = FALSE;
13020 player->is_dropping_pressed = FALSE;
13021 player->drop_pressed_delay = 0;
13024 // should better be called here than above, but this breaks some tapes
13025 ScrollPlayer(player, SCROLL_INIT);
13030 CheckGravityMovementWhenNotMoving(player);
13032 player->is_moving = FALSE;
13034 /* at this point, the player is allowed to move, but cannot move right now
13035 (e.g. because of something blocking the way) -- ensure that the player
13036 is also allowed to move in the next frame (in old versions before 3.1.1,
13037 the player was forced to wait again for eight frames before next try) */
13039 if (game.engine_version >= VERSION_IDENT(3,1,1,0))
13040 player->move_delay = 0; // allow direct movement in the next frame
13043 if (player->move_delay == -1) // not yet initialized by DigField()
13044 player->move_delay = player->move_delay_value;
13046 if (game.engine_version < VERSION_IDENT(3,0,7,0))
13048 TestIfPlayerTouchesBadThing(jx, jy);
13049 TestIfPlayerTouchesCustomElement(jx, jy);
13052 if (!player->active)
13053 RemovePlayer(player);
13058 void ScrollPlayer(struct PlayerInfo *player, int mode)
13060 int jx = player->jx, jy = player->jy;
13061 int last_jx = player->last_jx, last_jy = player->last_jy;
13062 int move_stepsize = TILEX / player->move_delay_value;
13064 if (!player->active)
13067 if (player->MovPos == 0 && mode == SCROLL_GO_ON) // player not moving
13070 if (mode == SCROLL_INIT)
13072 player->actual_frame_counter = FrameCounter;
13073 player->GfxPos = move_stepsize * (player->MovPos / move_stepsize);
13075 if ((player->block_last_field || player->block_delay_adjustment > 0) &&
13076 Tile[last_jx][last_jy] == EL_EMPTY)
13078 int last_field_block_delay = 0; // start with no blocking at all
13079 int block_delay_adjustment = player->block_delay_adjustment;
13081 // if player blocks last field, add delay for exactly one move
13082 if (player->block_last_field)
13084 last_field_block_delay += player->move_delay_value;
13086 // when blocking enabled, prevent moving up despite gravity
13087 if (player->gravity && player->MovDir == MV_UP)
13088 block_delay_adjustment = -1;
13091 // add block delay adjustment (also possible when not blocking)
13092 last_field_block_delay += block_delay_adjustment;
13094 Tile[last_jx][last_jy] = EL_PLAYER_IS_LEAVING;
13095 MovDelay[last_jx][last_jy] = last_field_block_delay + 1;
13098 if (player->MovPos != 0) // player has not yet reached destination
13101 else if (!FrameReached(&player->actual_frame_counter, 1))
13104 if (player->MovPos != 0)
13106 player->MovPos += (player->MovPos > 0 ? -1 : 1) * move_stepsize;
13107 player->GfxPos = move_stepsize * (player->MovPos / move_stepsize);
13109 // before DrawPlayer() to draw correct player graphic for this case
13110 if (player->MovPos == 0)
13111 CheckGravityMovement(player);
13114 if (player->MovPos == 0) // player reached destination field
13116 if (player->move_delay_reset_counter > 0)
13118 player->move_delay_reset_counter--;
13120 if (player->move_delay_reset_counter == 0)
13122 // continue with normal speed after quickly moving through gate
13123 HALVE_PLAYER_SPEED(player);
13125 // be able to make the next move without delay
13126 player->move_delay = 0;
13130 player->last_jx = jx;
13131 player->last_jy = jy;
13133 if (Tile[jx][jy] == EL_EXIT_OPEN ||
13134 Tile[jx][jy] == EL_EM_EXIT_OPEN ||
13135 Tile[jx][jy] == EL_EM_EXIT_OPENING ||
13136 Tile[jx][jy] == EL_STEEL_EXIT_OPEN ||
13137 Tile[jx][jy] == EL_EM_STEEL_EXIT_OPEN ||
13138 Tile[jx][jy] == EL_EM_STEEL_EXIT_OPENING ||
13139 Tile[jx][jy] == EL_SP_EXIT_OPEN ||
13140 Tile[jx][jy] == EL_SP_EXIT_OPENING) // <-- special case
13142 ExitPlayer(player);
13144 if (game.players_still_needed == 0 &&
13145 (game.friends_still_needed == 0 ||
13146 IS_SP_ELEMENT(Tile[jx][jy])))
13150 // this breaks one level: "machine", level 000
13152 int move_direction = player->MovDir;
13153 int enter_side = MV_DIR_OPPOSITE(move_direction);
13154 int leave_side = move_direction;
13155 int old_jx = last_jx;
13156 int old_jy = last_jy;
13157 int old_element = Tile[old_jx][old_jy];
13158 int new_element = Tile[jx][jy];
13160 if (IS_CUSTOM_ELEMENT(old_element))
13161 CheckElementChangeByPlayer(old_jx, old_jy, old_element,
13163 player->index_bit, leave_side);
13165 CheckTriggeredElementChangeByPlayer(old_jx, old_jy, old_element,
13166 CE_PLAYER_LEAVES_X,
13167 player->index_bit, leave_side);
13169 if (IS_CUSTOM_ELEMENT(new_element))
13170 CheckElementChangeByPlayer(jx, jy, new_element, CE_ENTERED_BY_PLAYER,
13171 player->index_bit, enter_side);
13173 CheckTriggeredElementChangeByPlayer(jx, jy, new_element,
13174 CE_PLAYER_ENTERS_X,
13175 player->index_bit, enter_side);
13177 CheckTriggeredElementChangeBySide(jx, jy, player->initial_element,
13178 CE_MOVE_OF_X, move_direction);
13181 if (game.engine_version >= VERSION_IDENT(3,0,7,0))
13183 TestIfPlayerTouchesBadThing(jx, jy);
13184 TestIfPlayerTouchesCustomElement(jx, jy);
13186 /* needed because pushed element has not yet reached its destination,
13187 so it would trigger a change event at its previous field location */
13188 if (!player->is_pushing)
13189 TestIfElementTouchesCustomElement(jx, jy); // for empty space
13191 if (level.finish_dig_collect &&
13192 (player->is_digging || player->is_collecting))
13194 int last_element = player->last_removed_element;
13195 int move_direction = player->MovDir;
13196 int enter_side = MV_DIR_OPPOSITE(move_direction);
13197 int change_event = (player->is_digging ? CE_PLAYER_DIGS_X :
13198 CE_PLAYER_COLLECTS_X);
13200 CheckTriggeredElementChangeByPlayer(jx, jy, last_element, change_event,
13201 player->index_bit, enter_side);
13203 player->last_removed_element = EL_UNDEFINED;
13206 if (!player->active)
13207 RemovePlayer(player);
13210 if (level.use_step_counter)
13220 if (TimeLeft <= 10 && setup.time_limit && !game.LevelSolved)
13221 PlaySound(SND_GAME_RUNNING_OUT_OF_TIME);
13223 game_panel_controls[GAME_PANEL_TIME].value = TimeLeft;
13225 DisplayGameControlValues();
13227 if (!TimeLeft && setup.time_limit && !game.LevelSolved)
13228 for (i = 0; i < MAX_PLAYERS; i++)
13229 KillPlayer(&stored_player[i]);
13231 else if (game.no_time_limit && !game.all_players_gone)
13233 game_panel_controls[GAME_PANEL_TIME].value = TimePlayed;
13235 DisplayGameControlValues();
13239 if (tape.single_step && tape.recording && !tape.pausing &&
13240 !player->programmed_action)
13241 TapeTogglePause(TAPE_TOGGLE_AUTOMATIC);
13243 if (!player->programmed_action)
13244 CheckSaveEngineSnapshot(player);
13248 void ScrollScreen(struct PlayerInfo *player, int mode)
13250 static unsigned int screen_frame_counter = 0;
13252 if (mode == SCROLL_INIT)
13254 // set scrolling step size according to actual player's moving speed
13255 ScrollStepSize = TILEX / player->move_delay_value;
13257 screen_frame_counter = FrameCounter;
13258 ScreenMovDir = player->MovDir;
13259 ScreenMovPos = player->MovPos;
13260 ScreenGfxPos = ScrollStepSize * (ScreenMovPos / ScrollStepSize);
13263 else if (!FrameReached(&screen_frame_counter, 1))
13268 ScreenMovPos += (ScreenMovPos > 0 ? -1 : 1) * ScrollStepSize;
13269 ScreenGfxPos = ScrollStepSize * (ScreenMovPos / ScrollStepSize);
13270 redraw_mask |= REDRAW_FIELD;
13273 ScreenMovDir = MV_NONE;
13276 void TestIfPlayerTouchesCustomElement(int x, int y)
13278 static int xy[4][2] =
13285 static int trigger_sides[4][2] =
13287 // center side border side
13288 { CH_SIDE_TOP, CH_SIDE_BOTTOM }, // check top
13289 { CH_SIDE_LEFT, CH_SIDE_RIGHT }, // check left
13290 { CH_SIDE_RIGHT, CH_SIDE_LEFT }, // check right
13291 { CH_SIDE_BOTTOM, CH_SIDE_TOP } // check bottom
13293 static int touch_dir[4] =
13295 MV_LEFT | MV_RIGHT,
13300 int center_element = Tile[x][y]; // should always be non-moving!
13303 for (i = 0; i < NUM_DIRECTIONS; i++)
13305 int xx = x + xy[i][0];
13306 int yy = y + xy[i][1];
13307 int center_side = trigger_sides[i][0];
13308 int border_side = trigger_sides[i][1];
13309 int border_element;
13311 if (!IN_LEV_FIELD(xx, yy))
13314 if (IS_PLAYER(x, y)) // player found at center element
13316 struct PlayerInfo *player = PLAYERINFO(x, y);
13318 if (game.engine_version < VERSION_IDENT(3,0,7,0))
13319 border_element = Tile[xx][yy]; // may be moving!
13320 else if (!IS_MOVING(xx, yy) && !IS_BLOCKED(xx, yy))
13321 border_element = Tile[xx][yy];
13322 else if (MovDir[xx][yy] & touch_dir[i]) // elements are touching
13323 border_element = MovingOrBlocked2Element(xx, yy);
13325 continue; // center and border element do not touch
13327 CheckElementChangeByPlayer(xx, yy, border_element, CE_TOUCHED_BY_PLAYER,
13328 player->index_bit, border_side);
13329 CheckTriggeredElementChangeByPlayer(xx, yy, border_element,
13330 CE_PLAYER_TOUCHES_X,
13331 player->index_bit, border_side);
13334 /* use player element that is initially defined in the level playfield,
13335 not the player element that corresponds to the runtime player number
13336 (example: a level that contains EL_PLAYER_3 as the only player would
13337 incorrectly give EL_PLAYER_1 for "player->element_nr") */
13338 int player_element = PLAYERINFO(x, y)->initial_element;
13340 CheckElementChangeBySide(xx, yy, border_element, player_element,
13341 CE_TOUCHING_X, border_side);
13344 else if (IS_PLAYER(xx, yy)) // player found at border element
13346 struct PlayerInfo *player = PLAYERINFO(xx, yy);
13348 if (game.engine_version >= VERSION_IDENT(3,0,7,0))
13350 if (player->MovPos != 0 && !(player->MovDir & touch_dir[i]))
13351 continue; // center and border element do not touch
13354 CheckElementChangeByPlayer(x, y, center_element, CE_TOUCHED_BY_PLAYER,
13355 player->index_bit, center_side);
13356 CheckTriggeredElementChangeByPlayer(x, y, center_element,
13357 CE_PLAYER_TOUCHES_X,
13358 player->index_bit, center_side);
13361 /* use player element that is initially defined in the level playfield,
13362 not the player element that corresponds to the runtime player number
13363 (example: a level that contains EL_PLAYER_3 as the only player would
13364 incorrectly give EL_PLAYER_1 for "player->element_nr") */
13365 int player_element = PLAYERINFO(xx, yy)->initial_element;
13367 CheckElementChangeBySide(x, y, center_element, player_element,
13368 CE_TOUCHING_X, center_side);
13376 void TestIfElementTouchesCustomElement(int x, int y)
13378 static int xy[4][2] =
13385 static int trigger_sides[4][2] =
13387 // center side border side
13388 { CH_SIDE_TOP, CH_SIDE_BOTTOM }, // check top
13389 { CH_SIDE_LEFT, CH_SIDE_RIGHT }, // check left
13390 { CH_SIDE_RIGHT, CH_SIDE_LEFT }, // check right
13391 { CH_SIDE_BOTTOM, CH_SIDE_TOP } // check bottom
13393 static int touch_dir[4] =
13395 MV_LEFT | MV_RIGHT,
13400 boolean change_center_element = FALSE;
13401 int center_element = Tile[x][y]; // should always be non-moving!
13402 int border_element_old[NUM_DIRECTIONS];
13405 for (i = 0; i < NUM_DIRECTIONS; i++)
13407 int xx = x + xy[i][0];
13408 int yy = y + xy[i][1];
13409 int border_element;
13411 border_element_old[i] = -1;
13413 if (!IN_LEV_FIELD(xx, yy))
13416 if (game.engine_version < VERSION_IDENT(3,0,7,0))
13417 border_element = Tile[xx][yy]; // may be moving!
13418 else if (!IS_MOVING(xx, yy) && !IS_BLOCKED(xx, yy))
13419 border_element = Tile[xx][yy];
13420 else if (MovDir[xx][yy] & touch_dir[i]) // elements are touching
13421 border_element = MovingOrBlocked2Element(xx, yy);
13423 continue; // center and border element do not touch
13425 border_element_old[i] = border_element;
13428 for (i = 0; i < NUM_DIRECTIONS; i++)
13430 int xx = x + xy[i][0];
13431 int yy = y + xy[i][1];
13432 int center_side = trigger_sides[i][0];
13433 int border_element = border_element_old[i];
13435 if (border_element == -1)
13438 // check for change of border element
13439 CheckElementChangeBySide(xx, yy, border_element, center_element,
13440 CE_TOUCHING_X, center_side);
13442 // (center element cannot be player, so we dont have to check this here)
13445 for (i = 0; i < NUM_DIRECTIONS; i++)
13447 int xx = x + xy[i][0];
13448 int yy = y + xy[i][1];
13449 int border_side = trigger_sides[i][1];
13450 int border_element = border_element_old[i];
13452 if (border_element == -1)
13455 // check for change of center element (but change it only once)
13456 if (!change_center_element)
13457 change_center_element =
13458 CheckElementChangeBySide(x, y, center_element, border_element,
13459 CE_TOUCHING_X, border_side);
13461 if (IS_PLAYER(xx, yy))
13463 /* use player element that is initially defined in the level playfield,
13464 not the player element that corresponds to the runtime player number
13465 (example: a level that contains EL_PLAYER_3 as the only player would
13466 incorrectly give EL_PLAYER_1 for "player->element_nr") */
13467 int player_element = PLAYERINFO(xx, yy)->initial_element;
13469 CheckElementChangeBySide(x, y, center_element, player_element,
13470 CE_TOUCHING_X, border_side);
13475 void TestIfElementHitsCustomElement(int x, int y, int direction)
13477 int dx = (direction == MV_LEFT ? -1 : direction == MV_RIGHT ? +1 : 0);
13478 int dy = (direction == MV_UP ? -1 : direction == MV_DOWN ? +1 : 0);
13479 int hitx = x + dx, hity = y + dy;
13480 int hitting_element = Tile[x][y];
13481 int touched_element;
13483 if (IN_LEV_FIELD(hitx, hity) && IS_FREE(hitx, hity))
13486 touched_element = (IN_LEV_FIELD(hitx, hity) ?
13487 MovingOrBlocked2Element(hitx, hity) : EL_STEELWALL);
13489 if (IN_LEV_FIELD(hitx, hity))
13491 int opposite_direction = MV_DIR_OPPOSITE(direction);
13492 int hitting_side = direction;
13493 int touched_side = opposite_direction;
13494 boolean object_hit = (!IS_MOVING(hitx, hity) ||
13495 MovDir[hitx][hity] != direction ||
13496 ABS(MovPos[hitx][hity]) <= TILEY / 2);
13502 CheckElementChangeBySide(x, y, hitting_element, touched_element,
13503 CE_HITTING_X, touched_side);
13505 CheckElementChangeBySide(hitx, hity, touched_element, hitting_element,
13506 CE_HIT_BY_X, hitting_side);
13508 CheckElementChangeBySide(hitx, hity, touched_element, hitting_element,
13509 CE_HIT_BY_SOMETHING, opposite_direction);
13511 if (IS_PLAYER(hitx, hity))
13513 /* use player element that is initially defined in the level playfield,
13514 not the player element that corresponds to the runtime player number
13515 (example: a level that contains EL_PLAYER_3 as the only player would
13516 incorrectly give EL_PLAYER_1 for "player->element_nr") */
13517 int player_element = PLAYERINFO(hitx, hity)->initial_element;
13519 CheckElementChangeBySide(x, y, hitting_element, player_element,
13520 CE_HITTING_X, touched_side);
13525 // "hitting something" is also true when hitting the playfield border
13526 CheckElementChangeBySide(x, y, hitting_element, touched_element,
13527 CE_HITTING_SOMETHING, direction);
13530 void TestIfGoodThingHitsBadThing(int good_x, int good_y, int good_move_dir)
13532 int i, kill_x = -1, kill_y = -1;
13534 int bad_element = -1;
13535 static int test_xy[4][2] =
13542 static int test_dir[4] =
13550 for (i = 0; i < NUM_DIRECTIONS; i++)
13552 int test_x, test_y, test_move_dir, test_element;
13554 test_x = good_x + test_xy[i][0];
13555 test_y = good_y + test_xy[i][1];
13557 if (!IN_LEV_FIELD(test_x, test_y))
13561 (IS_MOVING(test_x, test_y) ? MovDir[test_x][test_y] : MV_NONE);
13563 test_element = MovingOrBlocked2ElementIfNotLeaving(test_x, test_y);
13565 /* 1st case: good thing is moving towards DONT_RUN_INTO style bad thing;
13566 2nd case: DONT_TOUCH style bad thing does not move away from good thing
13568 if ((DONT_RUN_INTO(test_element) && good_move_dir == test_dir[i]) ||
13569 (DONT_TOUCH(test_element) && test_move_dir != test_dir[i]))
13573 bad_element = test_element;
13579 if (kill_x != -1 || kill_y != -1)
13581 if (IS_PLAYER(good_x, good_y))
13583 struct PlayerInfo *player = PLAYERINFO(good_x, good_y);
13585 if (player->shield_deadly_time_left > 0 &&
13586 !IS_INDESTRUCTIBLE(bad_element))
13587 Bang(kill_x, kill_y);
13588 else if (!PLAYER_ENEMY_PROTECTED(good_x, good_y))
13589 KillPlayer(player);
13592 Bang(good_x, good_y);
13596 void TestIfBadThingHitsGoodThing(int bad_x, int bad_y, int bad_move_dir)
13598 int i, kill_x = -1, kill_y = -1;
13599 int bad_element = Tile[bad_x][bad_y];
13600 static int test_xy[4][2] =
13607 static int touch_dir[4] =
13609 MV_LEFT | MV_RIGHT,
13614 static int test_dir[4] =
13622 if (bad_element == EL_EXPLOSION) // skip just exploding bad things
13625 for (i = 0; i < NUM_DIRECTIONS; i++)
13627 int test_x, test_y, test_move_dir, test_element;
13629 test_x = bad_x + test_xy[i][0];
13630 test_y = bad_y + test_xy[i][1];
13632 if (!IN_LEV_FIELD(test_x, test_y))
13636 (IS_MOVING(test_x, test_y) ? MovDir[test_x][test_y] : MV_NONE);
13638 test_element = Tile[test_x][test_y];
13640 /* 1st case: good thing is moving towards DONT_RUN_INTO style bad thing;
13641 2nd case: DONT_TOUCH style bad thing does not move away from good thing
13643 if ((DONT_RUN_INTO(bad_element) && bad_move_dir == test_dir[i]) ||
13644 (DONT_TOUCH(bad_element) && test_move_dir != test_dir[i]))
13646 // good thing is player or penguin that does not move away
13647 if (IS_PLAYER(test_x, test_y))
13649 struct PlayerInfo *player = PLAYERINFO(test_x, test_y);
13651 if (bad_element == EL_ROBOT && player->is_moving)
13652 continue; // robot does not kill player if he is moving
13654 if (game.engine_version >= VERSION_IDENT(3,0,7,0))
13656 if (player->MovPos != 0 && !(player->MovDir & touch_dir[i]))
13657 continue; // center and border element do not touch
13665 else if (test_element == EL_PENGUIN)
13675 if (kill_x != -1 || kill_y != -1)
13677 if (IS_PLAYER(kill_x, kill_y))
13679 struct PlayerInfo *player = PLAYERINFO(kill_x, kill_y);
13681 if (player->shield_deadly_time_left > 0 &&
13682 !IS_INDESTRUCTIBLE(bad_element))
13683 Bang(bad_x, bad_y);
13684 else if (!PLAYER_ENEMY_PROTECTED(kill_x, kill_y))
13685 KillPlayer(player);
13688 Bang(kill_x, kill_y);
13692 void TestIfGoodThingGetsHitByBadThing(int bad_x, int bad_y, int bad_move_dir)
13694 int bad_element = Tile[bad_x][bad_y];
13695 int dx = (bad_move_dir == MV_LEFT ? -1 : bad_move_dir == MV_RIGHT ? +1 : 0);
13696 int dy = (bad_move_dir == MV_UP ? -1 : bad_move_dir == MV_DOWN ? +1 : 0);
13697 int test_x = bad_x + dx, test_y = bad_y + dy;
13698 int test_move_dir, test_element;
13699 int kill_x = -1, kill_y = -1;
13701 if (!IN_LEV_FIELD(test_x, test_y))
13705 (IS_MOVING(test_x, test_y) ? MovDir[test_x][test_y] : MV_NONE);
13707 test_element = Tile[test_x][test_y];
13709 if (test_move_dir != bad_move_dir)
13711 // good thing can be player or penguin that does not move away
13712 if (IS_PLAYER(test_x, test_y))
13714 struct PlayerInfo *player = PLAYERINFO(test_x, test_y);
13716 /* (note: in comparison to DONT_RUN_TO and DONT_TOUCH, also handle the
13717 player as being hit when he is moving towards the bad thing, because
13718 the "get hit by" condition would be lost after the player stops) */
13719 if (player->MovPos != 0 && player->MovDir == bad_move_dir)
13720 return; // player moves away from bad thing
13725 else if (test_element == EL_PENGUIN)
13732 if (kill_x != -1 || kill_y != -1)
13734 if (IS_PLAYER(kill_x, kill_y))
13736 struct PlayerInfo *player = PLAYERINFO(kill_x, kill_y);
13738 if (player->shield_deadly_time_left > 0 &&
13739 !IS_INDESTRUCTIBLE(bad_element))
13740 Bang(bad_x, bad_y);
13741 else if (!PLAYER_ENEMY_PROTECTED(kill_x, kill_y))
13742 KillPlayer(player);
13745 Bang(kill_x, kill_y);
13749 void TestIfPlayerTouchesBadThing(int x, int y)
13751 TestIfGoodThingHitsBadThing(x, y, MV_NONE);
13754 void TestIfPlayerRunsIntoBadThing(int x, int y, int move_dir)
13756 TestIfGoodThingHitsBadThing(x, y, move_dir);
13759 void TestIfBadThingTouchesPlayer(int x, int y)
13761 TestIfBadThingHitsGoodThing(x, y, MV_NONE);
13764 void TestIfBadThingRunsIntoPlayer(int x, int y, int move_dir)
13766 TestIfBadThingHitsGoodThing(x, y, move_dir);
13769 void TestIfFriendTouchesBadThing(int x, int y)
13771 TestIfGoodThingHitsBadThing(x, y, MV_NONE);
13774 void TestIfBadThingTouchesFriend(int x, int y)
13776 TestIfBadThingHitsGoodThing(x, y, MV_NONE);
13779 void TestIfBadThingTouchesOtherBadThing(int bad_x, int bad_y)
13781 int i, kill_x = bad_x, kill_y = bad_y;
13782 static int xy[4][2] =
13790 for (i = 0; i < NUM_DIRECTIONS; i++)
13794 x = bad_x + xy[i][0];
13795 y = bad_y + xy[i][1];
13796 if (!IN_LEV_FIELD(x, y))
13799 element = Tile[x][y];
13800 if (IS_AMOEBOID(element) || element == EL_GAME_OF_LIFE ||
13801 element == EL_AMOEBA_GROWING || element == EL_AMOEBA_DROP)
13809 if (kill_x != bad_x || kill_y != bad_y)
13810 Bang(bad_x, bad_y);
13813 void KillPlayer(struct PlayerInfo *player)
13815 int jx = player->jx, jy = player->jy;
13817 if (!player->active)
13821 Debug("game:playing:KillPlayer",
13822 "0: killed == %d, active == %d, reanimated == %d",
13823 player->killed, player->active, player->reanimated);
13826 /* the following code was introduced to prevent an infinite loop when calling
13828 -> CheckTriggeredElementChangeExt()
13829 -> ExecuteCustomElementAction()
13831 -> (infinitely repeating the above sequence of function calls)
13832 which occurs when killing the player while having a CE with the setting
13833 "kill player X when explosion of <player X>"; the solution using a new
13834 field "player->killed" was chosen for backwards compatibility, although
13835 clever use of the fields "player->active" etc. would probably also work */
13837 if (player->killed)
13841 player->killed = TRUE;
13843 // remove accessible field at the player's position
13844 Tile[jx][jy] = EL_EMPTY;
13846 // deactivate shield (else Bang()/Explode() would not work right)
13847 player->shield_normal_time_left = 0;
13848 player->shield_deadly_time_left = 0;
13851 Debug("game:playing:KillPlayer",
13852 "1: killed == %d, active == %d, reanimated == %d",
13853 player->killed, player->active, player->reanimated);
13859 Debug("game:playing:KillPlayer",
13860 "2: killed == %d, active == %d, reanimated == %d",
13861 player->killed, player->active, player->reanimated);
13864 if (player->reanimated) // killed player may have been reanimated
13865 player->killed = player->reanimated = FALSE;
13867 BuryPlayer(player);
13870 static void KillPlayerUnlessEnemyProtected(int x, int y)
13872 if (!PLAYER_ENEMY_PROTECTED(x, y))
13873 KillPlayer(PLAYERINFO(x, y));
13876 static void KillPlayerUnlessExplosionProtected(int x, int y)
13878 if (!PLAYER_EXPLOSION_PROTECTED(x, y))
13879 KillPlayer(PLAYERINFO(x, y));
13882 void BuryPlayer(struct PlayerInfo *player)
13884 int jx = player->jx, jy = player->jy;
13886 if (!player->active)
13889 PlayLevelSoundElementAction(jx, jy, player->artwork_element, ACTION_DYING);
13890 PlayLevelSound(jx, jy, SND_GAME_LOSING);
13892 RemovePlayer(player);
13894 player->buried = TRUE;
13896 if (game.all_players_gone)
13897 game.GameOver = TRUE;
13900 void RemovePlayer(struct PlayerInfo *player)
13902 int jx = player->jx, jy = player->jy;
13903 int i, found = FALSE;
13905 player->present = FALSE;
13906 player->active = FALSE;
13908 // required for some CE actions (even if the player is not active anymore)
13909 player->MovPos = 0;
13911 if (!ExplodeField[jx][jy])
13912 StorePlayer[jx][jy] = 0;
13914 if (player->is_moving)
13915 TEST_DrawLevelField(player->last_jx, player->last_jy);
13917 for (i = 0; i < MAX_PLAYERS; i++)
13918 if (stored_player[i].active)
13923 game.all_players_gone = TRUE;
13924 game.GameOver = TRUE;
13927 game.exit_x = game.robot_wheel_x = jx;
13928 game.exit_y = game.robot_wheel_y = jy;
13931 void ExitPlayer(struct PlayerInfo *player)
13933 DrawPlayer(player); // needed here only to cleanup last field
13934 RemovePlayer(player);
13936 if (game.players_still_needed > 0)
13937 game.players_still_needed--;
13940 static void SetFieldForSnapping(int x, int y, int element, int direction,
13941 int player_index_bit)
13943 struct ElementInfo *ei = &element_info[element];
13944 int direction_bit = MV_DIR_TO_BIT(direction);
13945 int graphic_snapping = ei->direction_graphic[ACTION_SNAPPING][direction_bit];
13946 int action = (graphic_snapping != IMG_EMPTY_SPACE ? ACTION_SNAPPING :
13947 IS_DIGGABLE(element) ? ACTION_DIGGING : ACTION_COLLECTING);
13949 Tile[x][y] = EL_ELEMENT_SNAPPING;
13950 MovDelay[x][y] = MOVE_DELAY_NORMAL_SPEED + 1 - 1;
13951 MovDir[x][y] = direction;
13952 Store[x][y] = element;
13953 Store2[x][y] = player_index_bit;
13955 ResetGfxAnimation(x, y);
13957 GfxElement[x][y] = element;
13958 GfxAction[x][y] = action;
13959 GfxDir[x][y] = direction;
13960 GfxFrame[x][y] = -1;
13963 static void TestFieldAfterSnapping(int x, int y, int element, int direction,
13964 int player_index_bit)
13966 TestIfElementTouchesCustomElement(x, y); // for empty space
13968 if (level.finish_dig_collect)
13970 int dig_side = MV_DIR_OPPOSITE(direction);
13972 CheckTriggeredElementChangeByPlayer(x, y, element, CE_PLAYER_SNAPS_X,
13973 player_index_bit, dig_side);
13978 =============================================================================
13979 checkDiagonalPushing()
13980 -----------------------------------------------------------------------------
13981 check if diagonal input device direction results in pushing of object
13982 (by checking if the alternative direction is walkable, diggable, ...)
13983 =============================================================================
13986 static boolean checkDiagonalPushing(struct PlayerInfo *player,
13987 int x, int y, int real_dx, int real_dy)
13989 int jx, jy, dx, dy, xx, yy;
13991 if (real_dx == 0 || real_dy == 0) // no diagonal direction => push
13994 // diagonal direction: check alternative direction
13999 xx = jx + (dx == 0 ? real_dx : 0);
14000 yy = jy + (dy == 0 ? real_dy : 0);
14002 return (!IN_LEV_FIELD(xx, yy) || IS_SOLID_FOR_PUSHING(Tile[xx][yy]));
14006 =============================================================================
14008 -----------------------------------------------------------------------------
14009 x, y: field next to player (non-diagonal) to try to dig to
14010 real_dx, real_dy: direction as read from input device (can be diagonal)
14011 =============================================================================
14014 static int DigField(struct PlayerInfo *player,
14015 int oldx, int oldy, int x, int y,
14016 int real_dx, int real_dy, int mode)
14018 boolean is_player = (IS_PLAYER(oldx, oldy) || mode != DF_DIG);
14019 boolean player_was_pushing = player->is_pushing;
14020 boolean player_can_move = (!player->cannot_move && mode != DF_SNAP);
14021 boolean player_can_move_or_snap = (!player->cannot_move || mode == DF_SNAP);
14022 int jx = oldx, jy = oldy;
14023 int dx = x - jx, dy = y - jy;
14024 int nextx = x + dx, nexty = y + dy;
14025 int move_direction = (dx == -1 ? MV_LEFT :
14026 dx == +1 ? MV_RIGHT :
14028 dy == +1 ? MV_DOWN : MV_NONE);
14029 int opposite_direction = MV_DIR_OPPOSITE(move_direction);
14030 int dig_side = MV_DIR_OPPOSITE(move_direction);
14031 int old_element = Tile[jx][jy];
14032 int element = MovingOrBlocked2ElementIfNotLeaving(x, y);
14035 if (is_player) // function can also be called by EL_PENGUIN
14037 if (player->MovPos == 0)
14039 player->is_digging = FALSE;
14040 player->is_collecting = FALSE;
14043 if (player->MovPos == 0) // last pushing move finished
14044 player->is_pushing = FALSE;
14046 if (mode == DF_NO_PUSH) // player just stopped pushing
14048 player->is_switching = FALSE;
14049 player->push_delay = -1;
14051 return MP_NO_ACTION;
14055 if (IS_TUBE(Back[jx][jy]) && game.engine_version >= VERSION_IDENT(2,2,0,0))
14056 old_element = Back[jx][jy];
14058 // in case of element dropped at player position, check background
14059 else if (Back[jx][jy] != EL_EMPTY &&
14060 game.engine_version >= VERSION_IDENT(2,2,0,0))
14061 old_element = Back[jx][jy];
14063 if (IS_WALKABLE(old_element) && !ACCESS_FROM(old_element, move_direction))
14064 return MP_NO_ACTION; // field has no opening in this direction
14066 if (IS_PASSABLE(old_element) && !ACCESS_FROM(old_element,opposite_direction))
14067 return MP_NO_ACTION; // field has no opening in this direction
14069 if (player_can_move && element == EL_ACID && move_direction == MV_DOWN)
14073 Tile[jx][jy] = player->artwork_element;
14074 InitMovingField(jx, jy, MV_DOWN);
14075 Store[jx][jy] = EL_ACID;
14076 ContinueMoving(jx, jy);
14077 BuryPlayer(player);
14079 return MP_DONT_RUN_INTO;
14082 if (player_can_move && DONT_RUN_INTO(element))
14084 TestIfPlayerRunsIntoBadThing(jx, jy, player->MovDir);
14086 return MP_DONT_RUN_INTO;
14089 if (IS_MOVING(x, y) || IS_PLAYER(x, y))
14090 return MP_NO_ACTION;
14092 collect_count = element_info[element].collect_count_initial;
14094 if (!is_player && !IS_COLLECTIBLE(element)) // penguin cannot collect it
14095 return MP_NO_ACTION;
14097 if (game.engine_version < VERSION_IDENT(2,2,0,0))
14098 player_can_move = player_can_move_or_snap;
14100 if (mode == DF_SNAP && !IS_SNAPPABLE(element) &&
14101 game.engine_version >= VERSION_IDENT(2,2,0,0))
14103 CheckElementChangeByPlayer(x, y, element, CE_SNAPPED_BY_PLAYER,
14104 player->index_bit, dig_side);
14105 CheckTriggeredElementChangeByPlayer(x, y, element, CE_PLAYER_SNAPS_X,
14106 player->index_bit, dig_side);
14108 if (element == EL_DC_LANDMINE)
14111 if (Tile[x][y] != element) // field changed by snapping
14114 return MP_NO_ACTION;
14117 if (player->gravity && is_player && !player->is_auto_moving &&
14118 canFallDown(player) && move_direction != MV_DOWN &&
14119 !canMoveToValidFieldWithGravity(jx, jy, move_direction))
14120 return MP_NO_ACTION; // player cannot walk here due to gravity
14122 if (player_can_move &&
14123 IS_WALKABLE(element) && ACCESS_FROM(element, opposite_direction))
14125 int sound_element = SND_ELEMENT(element);
14126 int sound_action = ACTION_WALKING;
14128 if (IS_RND_GATE(element))
14130 if (!player->key[RND_GATE_NR(element)])
14131 return MP_NO_ACTION;
14133 else if (IS_RND_GATE_GRAY(element))
14135 if (!player->key[RND_GATE_GRAY_NR(element)])
14136 return MP_NO_ACTION;
14138 else if (IS_RND_GATE_GRAY_ACTIVE(element))
14140 if (!player->key[RND_GATE_GRAY_ACTIVE_NR(element)])
14141 return MP_NO_ACTION;
14143 else if (element == EL_EXIT_OPEN ||
14144 element == EL_EM_EXIT_OPEN ||
14145 element == EL_EM_EXIT_OPENING ||
14146 element == EL_STEEL_EXIT_OPEN ||
14147 element == EL_EM_STEEL_EXIT_OPEN ||
14148 element == EL_EM_STEEL_EXIT_OPENING ||
14149 element == EL_SP_EXIT_OPEN ||
14150 element == EL_SP_EXIT_OPENING)
14152 sound_action = ACTION_PASSING; // player is passing exit
14154 else if (element == EL_EMPTY)
14156 sound_action = ACTION_MOVING; // nothing to walk on
14159 // play sound from background or player, whatever is available
14160 if (element_info[sound_element].sound[sound_action] != SND_UNDEFINED)
14161 PlayLevelSoundElementAction(x, y, sound_element, sound_action);
14163 PlayLevelSoundElementAction(x, y, player->artwork_element, sound_action);
14165 else if (player_can_move &&
14166 IS_PASSABLE(element) && canPassField(x, y, move_direction))
14168 if (!ACCESS_FROM(element, opposite_direction))
14169 return MP_NO_ACTION; // field not accessible from this direction
14171 if (CAN_MOVE(element)) // only fixed elements can be passed!
14172 return MP_NO_ACTION;
14174 if (IS_EM_GATE(element))
14176 if (!player->key[EM_GATE_NR(element)])
14177 return MP_NO_ACTION;
14179 else if (IS_EM_GATE_GRAY(element))
14181 if (!player->key[EM_GATE_GRAY_NR(element)])
14182 return MP_NO_ACTION;
14184 else if (IS_EM_GATE_GRAY_ACTIVE(element))
14186 if (!player->key[EM_GATE_GRAY_ACTIVE_NR(element)])
14187 return MP_NO_ACTION;
14189 else if (IS_EMC_GATE(element))
14191 if (!player->key[EMC_GATE_NR(element)])
14192 return MP_NO_ACTION;
14194 else if (IS_EMC_GATE_GRAY(element))
14196 if (!player->key[EMC_GATE_GRAY_NR(element)])
14197 return MP_NO_ACTION;
14199 else if (IS_EMC_GATE_GRAY_ACTIVE(element))
14201 if (!player->key[EMC_GATE_GRAY_ACTIVE_NR(element)])
14202 return MP_NO_ACTION;
14204 else if (element == EL_DC_GATE_WHITE ||
14205 element == EL_DC_GATE_WHITE_GRAY ||
14206 element == EL_DC_GATE_WHITE_GRAY_ACTIVE)
14208 if (player->num_white_keys == 0)
14209 return MP_NO_ACTION;
14211 player->num_white_keys--;
14213 else if (IS_SP_PORT(element))
14215 if (element == EL_SP_GRAVITY_PORT_LEFT ||
14216 element == EL_SP_GRAVITY_PORT_RIGHT ||
14217 element == EL_SP_GRAVITY_PORT_UP ||
14218 element == EL_SP_GRAVITY_PORT_DOWN)
14219 player->gravity = !player->gravity;
14220 else if (element == EL_SP_GRAVITY_ON_PORT_LEFT ||
14221 element == EL_SP_GRAVITY_ON_PORT_RIGHT ||
14222 element == EL_SP_GRAVITY_ON_PORT_UP ||
14223 element == EL_SP_GRAVITY_ON_PORT_DOWN)
14224 player->gravity = TRUE;
14225 else if (element == EL_SP_GRAVITY_OFF_PORT_LEFT ||
14226 element == EL_SP_GRAVITY_OFF_PORT_RIGHT ||
14227 element == EL_SP_GRAVITY_OFF_PORT_UP ||
14228 element == EL_SP_GRAVITY_OFF_PORT_DOWN)
14229 player->gravity = FALSE;
14232 // automatically move to the next field with double speed
14233 player->programmed_action = move_direction;
14235 if (player->move_delay_reset_counter == 0)
14237 player->move_delay_reset_counter = 2; // two double speed steps
14239 DOUBLE_PLAYER_SPEED(player);
14242 PlayLevelSoundAction(x, y, ACTION_PASSING);
14244 else if (player_can_move_or_snap && IS_DIGGABLE(element))
14248 if (mode != DF_SNAP)
14250 GfxElement[x][y] = GFX_ELEMENT(element);
14251 player->is_digging = TRUE;
14254 PlayLevelSoundElementAction(x, y, element, ACTION_DIGGING);
14256 // use old behaviour for old levels (digging)
14257 if (!level.finish_dig_collect)
14259 CheckTriggeredElementChangeByPlayer(x, y, element, CE_PLAYER_DIGS_X,
14260 player->index_bit, dig_side);
14262 // if digging triggered player relocation, finish digging tile
14263 if (mode == DF_DIG && (player->jx != jx || player->jy != jy))
14264 SetFieldForSnapping(x, y, element, move_direction, player->index_bit);
14267 if (mode == DF_SNAP)
14269 if (level.block_snap_field)
14270 SetFieldForSnapping(x, y, element, move_direction, player->index_bit);
14272 TestFieldAfterSnapping(x, y, element, move_direction, player->index_bit);
14274 // use old behaviour for old levels (snapping)
14275 if (!level.finish_dig_collect)
14276 CheckTriggeredElementChangeByPlayer(x, y, element, CE_PLAYER_SNAPS_X,
14277 player->index_bit, dig_side);
14280 else if (player_can_move_or_snap && IS_COLLECTIBLE(element))
14284 if (is_player && mode != DF_SNAP)
14286 GfxElement[x][y] = element;
14287 player->is_collecting = TRUE;
14290 if (element == EL_SPEED_PILL)
14292 player->move_delay_value = MOVE_DELAY_HIGH_SPEED;
14294 else if (element == EL_EXTRA_TIME && level.time > 0)
14296 TimeLeft += level.extra_time;
14298 game_panel_controls[GAME_PANEL_TIME].value = TimeLeft;
14300 DisplayGameControlValues();
14302 else if (element == EL_SHIELD_NORMAL || element == EL_SHIELD_DEADLY)
14304 player->shield_normal_time_left += level.shield_normal_time;
14305 if (element == EL_SHIELD_DEADLY)
14306 player->shield_deadly_time_left += level.shield_deadly_time;
14308 else if (element == EL_DYNAMITE ||
14309 element == EL_EM_DYNAMITE ||
14310 element == EL_SP_DISK_RED)
14312 if (player->inventory_size < MAX_INVENTORY_SIZE)
14313 player->inventory_element[player->inventory_size++] = element;
14315 DrawGameDoorValues();
14317 else if (element == EL_DYNABOMB_INCREASE_NUMBER)
14319 player->dynabomb_count++;
14320 player->dynabombs_left++;
14322 else if (element == EL_DYNABOMB_INCREASE_SIZE)
14324 player->dynabomb_size++;
14326 else if (element == EL_DYNABOMB_INCREASE_POWER)
14328 player->dynabomb_xl = TRUE;
14330 else if (IS_KEY(element))
14332 player->key[KEY_NR(element)] = TRUE;
14334 DrawGameDoorValues();
14336 else if (element == EL_DC_KEY_WHITE)
14338 player->num_white_keys++;
14340 // display white keys?
14341 // DrawGameDoorValues();
14343 else if (IS_ENVELOPE(element))
14345 boolean wait_for_snapping = (mode == DF_SNAP && level.block_snap_field);
14347 if (!wait_for_snapping)
14348 player->show_envelope = element;
14350 else if (element == EL_EMC_LENSES)
14352 game.lenses_time_left = level.lenses_time * FRAMES_PER_SECOND;
14354 RedrawAllInvisibleElementsForLenses();
14356 else if (element == EL_EMC_MAGNIFIER)
14358 game.magnify_time_left = level.magnify_time * FRAMES_PER_SECOND;
14360 RedrawAllInvisibleElementsForMagnifier();
14362 else if (IS_DROPPABLE(element) ||
14363 IS_THROWABLE(element)) // can be collected and dropped
14367 if (collect_count == 0)
14368 player->inventory_infinite_element = element;
14370 for (i = 0; i < collect_count; i++)
14371 if (player->inventory_size < MAX_INVENTORY_SIZE)
14372 player->inventory_element[player->inventory_size++] = element;
14374 DrawGameDoorValues();
14376 else if (collect_count > 0)
14378 game.gems_still_needed -= collect_count;
14379 if (game.gems_still_needed < 0)
14380 game.gems_still_needed = 0;
14382 game.snapshot.collected_item = TRUE;
14384 game_panel_controls[GAME_PANEL_GEMS].value = game.gems_still_needed;
14386 DisplayGameControlValues();
14389 RaiseScoreElement(element);
14390 PlayLevelSoundElementAction(x, y, element, ACTION_COLLECTING);
14392 // use old behaviour for old levels (collecting)
14393 if (!level.finish_dig_collect && is_player)
14395 CheckTriggeredElementChangeByPlayer(x, y, element, CE_PLAYER_COLLECTS_X,
14396 player->index_bit, dig_side);
14398 // if collecting triggered player relocation, finish collecting tile
14399 if (mode == DF_DIG && (player->jx != jx || player->jy != jy))
14400 SetFieldForSnapping(x, y, element, move_direction, player->index_bit);
14403 if (mode == DF_SNAP)
14405 if (level.block_snap_field)
14406 SetFieldForSnapping(x, y, element, move_direction, player->index_bit);
14408 TestFieldAfterSnapping(x, y, element, move_direction, player->index_bit);
14410 // use old behaviour for old levels (snapping)
14411 if (!level.finish_dig_collect)
14412 CheckTriggeredElementChangeByPlayer(x, y, element, CE_PLAYER_SNAPS_X,
14413 player->index_bit, dig_side);
14416 else if (player_can_move_or_snap && IS_PUSHABLE(element))
14418 if (mode == DF_SNAP && element != EL_BD_ROCK)
14419 return MP_NO_ACTION;
14421 if (CAN_FALL(element) && dy)
14422 return MP_NO_ACTION;
14424 if (CAN_FALL(element) && IN_LEV_FIELD(x, y + 1) && IS_FREE(x, y + 1) &&
14425 !(element == EL_SPRING && level.use_spring_bug))
14426 return MP_NO_ACTION;
14428 if (CAN_MOVE(element) && GET_MAX_MOVE_DELAY(element) == 0 &&
14429 ((move_direction & MV_VERTICAL &&
14430 ((element_info[element].move_pattern & MV_LEFT &&
14431 IN_LEV_FIELD(x - 1, y) && IS_FREE(x - 1, y)) ||
14432 (element_info[element].move_pattern & MV_RIGHT &&
14433 IN_LEV_FIELD(x + 1, y) && IS_FREE(x + 1, y)))) ||
14434 (move_direction & MV_HORIZONTAL &&
14435 ((element_info[element].move_pattern & MV_UP &&
14436 IN_LEV_FIELD(x, y - 1) && IS_FREE(x, y - 1)) ||
14437 (element_info[element].move_pattern & MV_DOWN &&
14438 IN_LEV_FIELD(x, y + 1) && IS_FREE(x, y + 1))))))
14439 return MP_NO_ACTION;
14441 // do not push elements already moving away faster than player
14442 if (CAN_MOVE(element) && MovDir[x][y] == move_direction &&
14443 ABS(getElementMoveStepsize(x, y)) > MOVE_STEPSIZE_NORMAL)
14444 return MP_NO_ACTION;
14446 if (game.engine_version >= VERSION_IDENT(3,1,0,0))
14448 if (player->push_delay_value == -1 || !player_was_pushing)
14449 player->push_delay_value = GET_NEW_PUSH_DELAY(element);
14451 else if (game.engine_version >= VERSION_IDENT(3,0,7,1))
14453 if (player->push_delay_value == -1)
14454 player->push_delay_value = GET_NEW_PUSH_DELAY(element);
14456 else if (game.engine_version >= VERSION_IDENT(2,2,0,7))
14458 if (!player->is_pushing)
14459 player->push_delay_value = GET_NEW_PUSH_DELAY(element);
14462 player->is_pushing = TRUE;
14463 player->is_active = TRUE;
14465 if (!(IN_LEV_FIELD(nextx, nexty) &&
14466 (IS_FREE(nextx, nexty) ||
14467 (IS_SB_ELEMENT(element) &&
14468 Tile[nextx][nexty] == EL_SOKOBAN_FIELD_EMPTY) ||
14469 (IS_CUSTOM_ELEMENT(element) &&
14470 CUSTOM_ELEMENT_CAN_ENTER_FIELD(element, nextx, nexty)))))
14471 return MP_NO_ACTION;
14473 if (!checkDiagonalPushing(player, x, y, real_dx, real_dy))
14474 return MP_NO_ACTION;
14476 if (player->push_delay == -1) // new pushing; restart delay
14477 player->push_delay = 0;
14479 if (player->push_delay < player->push_delay_value &&
14480 !(tape.playing && tape.file_version < FILE_VERSION_2_0) &&
14481 element != EL_SPRING && element != EL_BALLOON)
14483 // make sure that there is no move delay before next try to push
14484 if (game.engine_version >= VERSION_IDENT(3,0,7,1))
14485 player->move_delay = 0;
14487 return MP_NO_ACTION;
14490 if (IS_CUSTOM_ELEMENT(element) &&
14491 CUSTOM_ELEMENT_CAN_ENTER_FIELD(element, nextx, nexty))
14493 if (!DigFieldByCE(nextx, nexty, element))
14494 return MP_NO_ACTION;
14497 if (IS_SB_ELEMENT(element))
14499 boolean sokoban_task_solved = FALSE;
14501 if (element == EL_SOKOBAN_FIELD_FULL)
14503 Back[x][y] = EL_SOKOBAN_FIELD_EMPTY;
14505 IncrementSokobanFieldsNeeded();
14506 IncrementSokobanObjectsNeeded();
14509 if (Tile[nextx][nexty] == EL_SOKOBAN_FIELD_EMPTY)
14511 Back[nextx][nexty] = EL_SOKOBAN_FIELD_EMPTY;
14513 DecrementSokobanFieldsNeeded();
14514 DecrementSokobanObjectsNeeded();
14516 // sokoban object was pushed from empty field to sokoban field
14517 if (Back[x][y] == EL_EMPTY)
14518 sokoban_task_solved = TRUE;
14521 Tile[x][y] = EL_SOKOBAN_OBJECT;
14523 if (Back[x][y] == Back[nextx][nexty])
14524 PlayLevelSoundAction(x, y, ACTION_PUSHING);
14525 else if (Back[x][y] != 0)
14526 PlayLevelSoundElementAction(x, y, EL_SOKOBAN_FIELD_FULL,
14529 PlayLevelSoundElementAction(nextx, nexty, EL_SOKOBAN_FIELD_EMPTY,
14532 if (sokoban_task_solved &&
14533 game.sokoban_fields_still_needed == 0 &&
14534 game.sokoban_objects_still_needed == 0 &&
14535 level.auto_exit_sokoban)
14537 game.players_still_needed = 0;
14541 PlayLevelSound(x, y, SND_GAME_SOKOBAN_SOLVING);
14545 PlayLevelSoundElementAction(x, y, element, ACTION_PUSHING);
14547 InitMovingField(x, y, move_direction);
14548 GfxAction[x][y] = ACTION_PUSHING;
14550 if (mode == DF_SNAP)
14551 ContinueMoving(x, y);
14553 MovPos[x][y] = (dx != 0 ? dx : dy);
14555 Pushed[x][y] = TRUE;
14556 Pushed[nextx][nexty] = TRUE;
14558 if (game.engine_version < VERSION_IDENT(2,2,0,7))
14559 player->push_delay_value = GET_NEW_PUSH_DELAY(element);
14561 player->push_delay_value = -1; // get new value later
14563 // check for element change _after_ element has been pushed
14564 if (game.use_change_when_pushing_bug)
14566 CheckElementChangeByPlayer(x, y, element, CE_PUSHED_BY_PLAYER,
14567 player->index_bit, dig_side);
14568 CheckTriggeredElementChangeByPlayer(x, y, element, CE_PLAYER_PUSHES_X,
14569 player->index_bit, dig_side);
14572 else if (IS_SWITCHABLE(element))
14574 if (PLAYER_SWITCHING(player, x, y))
14576 CheckTriggeredElementChangeByPlayer(x, y, element, CE_PLAYER_PRESSES_X,
14577 player->index_bit, dig_side);
14582 player->is_switching = TRUE;
14583 player->switch_x = x;
14584 player->switch_y = y;
14586 PlayLevelSoundElementAction(x, y, element, ACTION_ACTIVATING);
14588 if (element == EL_ROBOT_WHEEL)
14590 Tile[x][y] = EL_ROBOT_WHEEL_ACTIVE;
14592 game.robot_wheel_x = x;
14593 game.robot_wheel_y = y;
14594 game.robot_wheel_active = TRUE;
14596 TEST_DrawLevelField(x, y);
14598 else if (element == EL_SP_TERMINAL)
14602 SCAN_PLAYFIELD(xx, yy)
14604 if (Tile[xx][yy] == EL_SP_DISK_YELLOW)
14608 else if (Tile[xx][yy] == EL_SP_TERMINAL)
14610 Tile[xx][yy] = EL_SP_TERMINAL_ACTIVE;
14612 ResetGfxAnimation(xx, yy);
14613 TEST_DrawLevelField(xx, yy);
14617 else if (IS_BELT_SWITCH(element))
14619 ToggleBeltSwitch(x, y);
14621 else if (element == EL_SWITCHGATE_SWITCH_UP ||
14622 element == EL_SWITCHGATE_SWITCH_DOWN ||
14623 element == EL_DC_SWITCHGATE_SWITCH_UP ||
14624 element == EL_DC_SWITCHGATE_SWITCH_DOWN)
14626 ToggleSwitchgateSwitch(x, y);
14628 else if (element == EL_LIGHT_SWITCH ||
14629 element == EL_LIGHT_SWITCH_ACTIVE)
14631 ToggleLightSwitch(x, y);
14633 else if (element == EL_TIMEGATE_SWITCH ||
14634 element == EL_DC_TIMEGATE_SWITCH)
14636 ActivateTimegateSwitch(x, y);
14638 else if (element == EL_BALLOON_SWITCH_LEFT ||
14639 element == EL_BALLOON_SWITCH_RIGHT ||
14640 element == EL_BALLOON_SWITCH_UP ||
14641 element == EL_BALLOON_SWITCH_DOWN ||
14642 element == EL_BALLOON_SWITCH_NONE ||
14643 element == EL_BALLOON_SWITCH_ANY)
14645 game.wind_direction = (element == EL_BALLOON_SWITCH_LEFT ? MV_LEFT :
14646 element == EL_BALLOON_SWITCH_RIGHT ? MV_RIGHT :
14647 element == EL_BALLOON_SWITCH_UP ? MV_UP :
14648 element == EL_BALLOON_SWITCH_DOWN ? MV_DOWN :
14649 element == EL_BALLOON_SWITCH_NONE ? MV_NONE :
14652 else if (element == EL_LAMP)
14654 Tile[x][y] = EL_LAMP_ACTIVE;
14655 game.lights_still_needed--;
14657 ResetGfxAnimation(x, y);
14658 TEST_DrawLevelField(x, y);
14660 else if (element == EL_TIME_ORB_FULL)
14662 Tile[x][y] = EL_TIME_ORB_EMPTY;
14664 if (level.time > 0 || level.use_time_orb_bug)
14666 TimeLeft += level.time_orb_time;
14667 game.no_time_limit = FALSE;
14669 game_panel_controls[GAME_PANEL_TIME].value = TimeLeft;
14671 DisplayGameControlValues();
14674 ResetGfxAnimation(x, y);
14675 TEST_DrawLevelField(x, y);
14677 else if (element == EL_EMC_MAGIC_BALL_SWITCH ||
14678 element == EL_EMC_MAGIC_BALL_SWITCH_ACTIVE)
14682 game.ball_active = !game.ball_active;
14684 SCAN_PLAYFIELD(xx, yy)
14686 int e = Tile[xx][yy];
14688 if (game.ball_active)
14690 if (e == EL_EMC_MAGIC_BALL)
14691 CreateField(xx, yy, EL_EMC_MAGIC_BALL_ACTIVE);
14692 else if (e == EL_EMC_MAGIC_BALL_SWITCH)
14693 CreateField(xx, yy, EL_EMC_MAGIC_BALL_SWITCH_ACTIVE);
14697 if (e == EL_EMC_MAGIC_BALL_ACTIVE)
14698 CreateField(xx, yy, EL_EMC_MAGIC_BALL);
14699 else if (e == EL_EMC_MAGIC_BALL_SWITCH_ACTIVE)
14700 CreateField(xx, yy, EL_EMC_MAGIC_BALL_SWITCH);
14705 CheckTriggeredElementChangeByPlayer(x, y, element, CE_SWITCH_OF_X,
14706 player->index_bit, dig_side);
14708 CheckTriggeredElementChangeByPlayer(x, y, element, CE_PLAYER_SWITCHES_X,
14709 player->index_bit, dig_side);
14711 CheckTriggeredElementChangeByPlayer(x, y, element, CE_PLAYER_PRESSES_X,
14712 player->index_bit, dig_side);
14718 if (!PLAYER_SWITCHING(player, x, y))
14720 player->is_switching = TRUE;
14721 player->switch_x = x;
14722 player->switch_y = y;
14724 CheckElementChangeByPlayer(x, y, element, CE_SWITCHED,
14725 player->index_bit, dig_side);
14726 CheckTriggeredElementChangeByPlayer(x, y, element, CE_SWITCH_OF_X,
14727 player->index_bit, dig_side);
14729 CheckElementChangeByPlayer(x, y, element, CE_SWITCHED_BY_PLAYER,
14730 player->index_bit, dig_side);
14731 CheckTriggeredElementChangeByPlayer(x, y, element, CE_PLAYER_SWITCHES_X,
14732 player->index_bit, dig_side);
14735 CheckElementChangeByPlayer(x, y, element, CE_PRESSED_BY_PLAYER,
14736 player->index_bit, dig_side);
14737 CheckTriggeredElementChangeByPlayer(x, y, element, CE_PLAYER_PRESSES_X,
14738 player->index_bit, dig_side);
14740 return MP_NO_ACTION;
14743 player->push_delay = -1;
14745 if (is_player) // function can also be called by EL_PENGUIN
14747 if (Tile[x][y] != element) // really digged/collected something
14749 player->is_collecting = !player->is_digging;
14750 player->is_active = TRUE;
14752 player->last_removed_element = element;
14759 static boolean DigFieldByCE(int x, int y, int digging_element)
14761 int element = Tile[x][y];
14763 if (!IS_FREE(x, y))
14765 int action = (IS_DIGGABLE(element) ? ACTION_DIGGING :
14766 IS_COLLECTIBLE(element) ? ACTION_COLLECTING :
14769 // no element can dig solid indestructible elements
14770 if (IS_INDESTRUCTIBLE(element) &&
14771 !IS_DIGGABLE(element) &&
14772 !IS_COLLECTIBLE(element))
14775 if (AmoebaNr[x][y] &&
14776 (element == EL_AMOEBA_FULL ||
14777 element == EL_BD_AMOEBA ||
14778 element == EL_AMOEBA_GROWING))
14780 AmoebaCnt[AmoebaNr[x][y]]--;
14781 AmoebaCnt2[AmoebaNr[x][y]]--;
14784 if (IS_MOVING(x, y))
14785 RemoveMovingField(x, y);
14789 TEST_DrawLevelField(x, y);
14792 // if digged element was about to explode, prevent the explosion
14793 ExplodeField[x][y] = EX_TYPE_NONE;
14795 PlayLevelSoundAction(x, y, action);
14798 Store[x][y] = EL_EMPTY;
14800 // this makes it possible to leave the removed element again
14801 if (IS_EQUAL_OR_IN_GROUP(element, MOVE_ENTER_EL(digging_element)))
14802 Store[x][y] = element;
14807 static boolean SnapField(struct PlayerInfo *player, int dx, int dy)
14809 int jx = player->jx, jy = player->jy;
14810 int x = jx + dx, y = jy + dy;
14811 int snap_direction = (dx == -1 ? MV_LEFT :
14812 dx == +1 ? MV_RIGHT :
14814 dy == +1 ? MV_DOWN : MV_NONE);
14815 boolean can_continue_snapping = (level.continuous_snapping &&
14816 WasJustFalling[x][y] < CHECK_DELAY_FALLING);
14818 if (player->MovPos != 0 && game.engine_version >= VERSION_IDENT(2,2,0,0))
14821 if (!player->active || !IN_LEV_FIELD(x, y))
14829 if (player->MovPos == 0)
14830 player->is_pushing = FALSE;
14832 player->is_snapping = FALSE;
14834 if (player->MovPos == 0)
14836 player->is_moving = FALSE;
14837 player->is_digging = FALSE;
14838 player->is_collecting = FALSE;
14844 // prevent snapping with already pressed snap key when not allowed
14845 if (player->is_snapping && !can_continue_snapping)
14848 player->MovDir = snap_direction;
14850 if (player->MovPos == 0)
14852 player->is_moving = FALSE;
14853 player->is_digging = FALSE;
14854 player->is_collecting = FALSE;
14857 player->is_dropping = FALSE;
14858 player->is_dropping_pressed = FALSE;
14859 player->drop_pressed_delay = 0;
14861 if (DigField(player, jx, jy, x, y, 0, 0, DF_SNAP) == MP_NO_ACTION)
14864 player->is_snapping = TRUE;
14865 player->is_active = TRUE;
14867 if (player->MovPos == 0)
14869 player->is_moving = FALSE;
14870 player->is_digging = FALSE;
14871 player->is_collecting = FALSE;
14874 if (player->MovPos != 0) // prevent graphic bugs in versions < 2.2.0
14875 TEST_DrawLevelField(player->last_jx, player->last_jy);
14877 TEST_DrawLevelField(x, y);
14882 static boolean DropElement(struct PlayerInfo *player)
14884 int old_element, new_element;
14885 int dropx = player->jx, dropy = player->jy;
14886 int drop_direction = player->MovDir;
14887 int drop_side = drop_direction;
14888 int drop_element = get_next_dropped_element(player);
14890 /* do not drop an element on top of another element; when holding drop key
14891 pressed without moving, dropped element must move away before the next
14892 element can be dropped (this is especially important if the next element
14893 is dynamite, which can be placed on background for historical reasons) */
14894 if (PLAYER_DROPPING(player, dropx, dropy) && Tile[dropx][dropy] != EL_EMPTY)
14897 if (IS_THROWABLE(drop_element))
14899 dropx += GET_DX_FROM_DIR(drop_direction);
14900 dropy += GET_DY_FROM_DIR(drop_direction);
14902 if (!IN_LEV_FIELD(dropx, dropy))
14906 old_element = Tile[dropx][dropy]; // old element at dropping position
14907 new_element = drop_element; // default: no change when dropping
14909 // check if player is active, not moving and ready to drop
14910 if (!player->active || player->MovPos || player->drop_delay > 0)
14913 // check if player has anything that can be dropped
14914 if (new_element == EL_UNDEFINED)
14917 // only set if player has anything that can be dropped
14918 player->is_dropping_pressed = TRUE;
14920 // check if drop key was pressed long enough for EM style dynamite
14921 if (new_element == EL_EM_DYNAMITE && player->drop_pressed_delay < 40)
14924 // check if anything can be dropped at the current position
14925 if (IS_ACTIVE_BOMB(old_element) || old_element == EL_EXPLOSION)
14928 // collected custom elements can only be dropped on empty fields
14929 if (IS_CUSTOM_ELEMENT(new_element) && old_element != EL_EMPTY)
14932 if (old_element != EL_EMPTY)
14933 Back[dropx][dropy] = old_element; // store old element on this field
14935 ResetGfxAnimation(dropx, dropy);
14936 ResetRandomAnimationValue(dropx, dropy);
14938 if (player->inventory_size > 0 ||
14939 player->inventory_infinite_element != EL_UNDEFINED)
14941 if (player->inventory_size > 0)
14943 player->inventory_size--;
14945 DrawGameDoorValues();
14947 if (new_element == EL_DYNAMITE)
14948 new_element = EL_DYNAMITE_ACTIVE;
14949 else if (new_element == EL_EM_DYNAMITE)
14950 new_element = EL_EM_DYNAMITE_ACTIVE;
14951 else if (new_element == EL_SP_DISK_RED)
14952 new_element = EL_SP_DISK_RED_ACTIVE;
14955 Tile[dropx][dropy] = new_element;
14957 if (IN_SCR_FIELD(SCREENX(dropx), SCREENY(dropy)))
14958 DrawGraphicThruMask(SCREENX(dropx), SCREENY(dropy),
14959 el2img(Tile[dropx][dropy]), 0);
14961 PlayLevelSoundAction(dropx, dropy, ACTION_DROPPING);
14963 // needed if previous element just changed to "empty" in the last frame
14964 ChangeCount[dropx][dropy] = 0; // allow at least one more change
14966 CheckElementChangeByPlayer(dropx, dropy, new_element, CE_DROPPED_BY_PLAYER,
14967 player->index_bit, drop_side);
14968 CheckTriggeredElementChangeByPlayer(dropx, dropy, new_element,
14970 player->index_bit, drop_side);
14972 TestIfElementTouchesCustomElement(dropx, dropy);
14974 else // player is dropping a dyna bomb
14976 player->dynabombs_left--;
14978 Tile[dropx][dropy] = new_element;
14980 if (IN_SCR_FIELD(SCREENX(dropx), SCREENY(dropy)))
14981 DrawGraphicThruMask(SCREENX(dropx), SCREENY(dropy),
14982 el2img(Tile[dropx][dropy]), 0);
14984 PlayLevelSoundAction(dropx, dropy, ACTION_DROPPING);
14987 if (Tile[dropx][dropy] == new_element) // uninitialized unless CE change
14988 InitField_WithBug1(dropx, dropy, FALSE);
14990 new_element = Tile[dropx][dropy]; // element might have changed
14992 if (IS_CUSTOM_ELEMENT(new_element) && CAN_MOVE(new_element) &&
14993 element_info[new_element].move_pattern == MV_WHEN_DROPPED)
14995 if (element_info[new_element].move_direction_initial == MV_START_AUTOMATIC)
14996 MovDir[dropx][dropy] = drop_direction;
14998 ChangeCount[dropx][dropy] = 0; // allow at least one more change
15000 // do not cause impact style collision by dropping elements that can fall
15001 CheckCollision[dropx][dropy] = CHECK_DELAY_COLLISION;
15004 player->drop_delay = GET_NEW_DROP_DELAY(drop_element);
15005 player->is_dropping = TRUE;
15007 player->drop_pressed_delay = 0;
15008 player->is_dropping_pressed = FALSE;
15010 player->drop_x = dropx;
15011 player->drop_y = dropy;
15016 // ----------------------------------------------------------------------------
15017 // game sound playing functions
15018 // ----------------------------------------------------------------------------
15020 static int *loop_sound_frame = NULL;
15021 static int *loop_sound_volume = NULL;
15023 void InitPlayLevelSound(void)
15025 int num_sounds = getSoundListSize();
15027 checked_free(loop_sound_frame);
15028 checked_free(loop_sound_volume);
15030 loop_sound_frame = checked_calloc(num_sounds * sizeof(int));
15031 loop_sound_volume = checked_calloc(num_sounds * sizeof(int));
15034 static void PlayLevelSound(int x, int y, int nr)
15036 int sx = SCREENX(x), sy = SCREENY(y);
15037 int volume, stereo_position;
15038 int max_distance = 8;
15039 int type = (IS_LOOP_SOUND(nr) ? SND_CTRL_PLAY_LOOP : SND_CTRL_PLAY_SOUND);
15041 if ((!setup.sound_simple && !IS_LOOP_SOUND(nr)) ||
15042 (!setup.sound_loops && IS_LOOP_SOUND(nr)))
15045 if (!IN_LEV_FIELD(x, y) ||
15046 sx < -max_distance || sx >= SCR_FIELDX + max_distance ||
15047 sy < -max_distance || sy >= SCR_FIELDY + max_distance)
15050 volume = SOUND_MAX_VOLUME;
15052 if (!IN_SCR_FIELD(sx, sy))
15054 int dx = ABS(sx - SCR_FIELDX / 2) - SCR_FIELDX / 2;
15055 int dy = ABS(sy - SCR_FIELDY / 2) - SCR_FIELDY / 2;
15057 volume -= volume * (dx > dy ? dx : dy) / max_distance;
15060 stereo_position = (SOUND_MAX_LEFT +
15061 (sx + max_distance) * SOUND_MAX_LEFT2RIGHT /
15062 (SCR_FIELDX + 2 * max_distance));
15064 if (IS_LOOP_SOUND(nr))
15066 /* This assures that quieter loop sounds do not overwrite louder ones,
15067 while restarting sound volume comparison with each new game frame. */
15069 if (loop_sound_volume[nr] > volume && loop_sound_frame[nr] == FrameCounter)
15072 loop_sound_volume[nr] = volume;
15073 loop_sound_frame[nr] = FrameCounter;
15076 PlaySoundExt(nr, volume, stereo_position, type);
15079 static void PlayLevelSoundNearest(int x, int y, int sound_action)
15081 PlayLevelSound(x < LEVELX(BX1) ? LEVELX(BX1) :
15082 x > LEVELX(BX2) ? LEVELX(BX2) : x,
15083 y < LEVELY(BY1) ? LEVELY(BY1) :
15084 y > LEVELY(BY2) ? LEVELY(BY2) : y,
15088 static void PlayLevelSoundAction(int x, int y, int action)
15090 PlayLevelSoundElementAction(x, y, Tile[x][y], action);
15093 static void PlayLevelSoundElementAction(int x, int y, int element, int action)
15095 int sound_effect = element_info[SND_ELEMENT(element)].sound[action];
15097 if (sound_effect != SND_UNDEFINED)
15098 PlayLevelSound(x, y, sound_effect);
15101 static void PlayLevelSoundElementActionIfLoop(int x, int y, int element,
15104 int sound_effect = element_info[SND_ELEMENT(element)].sound[action];
15106 if (sound_effect != SND_UNDEFINED && IS_LOOP_SOUND(sound_effect))
15107 PlayLevelSound(x, y, sound_effect);
15110 static void PlayLevelSoundActionIfLoop(int x, int y, int action)
15112 int sound_effect = element_info[SND_ELEMENT(Tile[x][y])].sound[action];
15114 if (sound_effect != SND_UNDEFINED && IS_LOOP_SOUND(sound_effect))
15115 PlayLevelSound(x, y, sound_effect);
15118 static void StopLevelSoundActionIfLoop(int x, int y, int action)
15120 int sound_effect = element_info[SND_ELEMENT(Tile[x][y])].sound[action];
15122 if (sound_effect != SND_UNDEFINED && IS_LOOP_SOUND(sound_effect))
15123 StopSound(sound_effect);
15126 static int getLevelMusicNr(void)
15128 if (levelset.music[level_nr] != MUS_UNDEFINED)
15129 return levelset.music[level_nr]; // from config file
15131 return MAP_NOCONF_MUSIC(level_nr); // from music dir
15134 static void FadeLevelSounds(void)
15139 static void FadeLevelMusic(void)
15141 int music_nr = getLevelMusicNr();
15142 char *curr_music = getCurrentlyPlayingMusicFilename();
15143 char *next_music = getMusicInfoEntryFilename(music_nr);
15145 if (!strEqual(curr_music, next_music))
15149 void FadeLevelSoundsAndMusic(void)
15155 static void PlayLevelMusic(void)
15157 int music_nr = getLevelMusicNr();
15158 char *curr_music = getCurrentlyPlayingMusicFilename();
15159 char *next_music = getMusicInfoEntryFilename(music_nr);
15161 if (!strEqual(curr_music, next_music))
15162 PlayMusicLoop(music_nr);
15165 void PlayLevelSound_EM(int xx, int yy, int element_em, int sample)
15167 int element = (element_em > -1 ? map_element_EM_to_RND_game(element_em) : 0);
15169 int x = xx - offset;
15170 int y = yy - offset;
15175 PlayLevelSoundElementAction(x, y, element, ACTION_WALKING);
15179 PlayLevelSoundElementAction(x, y, element, ACTION_PUSHING);
15183 PlayLevelSoundElementAction(x, y, element, ACTION_IMPACT);
15187 PlayLevelSoundElementAction(x, y, element, ACTION_IMPACT);
15191 PlayLevelSoundElementAction(x, y, element, ACTION_BREAKING);
15195 PlayLevelSoundElementAction(x, y, element, ACTION_MOVING);
15199 PlayLevelSoundElementAction(x, y, element, ACTION_MOVING);
15202 case SOUND_android_clone:
15203 PlayLevelSoundElementAction(x, y, element, ACTION_DROPPING);
15206 case SOUND_android_move:
15207 PlayLevelSoundElementAction(x, y, element, ACTION_MOVING);
15211 PlayLevelSoundElementAction(x, y, element, ACTION_IMPACT);
15215 PlayLevelSoundElementAction(x, y, element, ACTION_EATING);
15219 PlayLevelSoundElementAction(x, y, element, ACTION_WAITING);
15222 case SOUND_eater_eat:
15223 PlayLevelSoundElementAction(x, y, element, ACTION_DIGGING);
15227 PlayLevelSoundElementAction(x, y, element, ACTION_MOVING);
15230 case SOUND_collect:
15231 PlayLevelSoundElementAction(x, y, element, ACTION_COLLECTING);
15234 case SOUND_diamond:
15235 PlayLevelSoundElementAction(x, y, element, ACTION_IMPACT);
15239 // !!! CHECK THIS !!!
15241 PlayLevelSoundElementAction(x, y, element, ACTION_BREAKING);
15243 PlayLevelSoundElementAction(x, y, element, ACTION_SMASHED_BY_ROCK);
15247 case SOUND_wonderfall:
15248 PlayLevelSoundElementAction(x, y, element, ACTION_FILLING);
15252 PlayLevelSoundElementAction(x, y, element, ACTION_IMPACT);
15256 PlayLevelSoundElementAction(x, y, element, ACTION_PUSHING);
15260 PlayLevelSoundElementAction(x, y, element, ACTION_DIGGING);
15264 PlayLevelSoundElementAction(x, y, element, ACTION_SPLASHING);
15268 PlayLevelSoundElementAction(x, y, element, ACTION_DROPPING);
15272 PlayLevelSoundElementAction(x, y, element, ACTION_GROWING);
15276 PlayLevelSoundElementAction(x, y, element, ACTION_ACTIVE);
15280 PlayLevelSoundElementAction(x, y, element, ACTION_PASSING);
15283 case SOUND_exit_open:
15284 PlayLevelSoundElementAction(x, y, element, ACTION_OPENING);
15287 case SOUND_exit_leave:
15288 PlayLevelSoundElementAction(x, y, element, ACTION_PASSING);
15291 case SOUND_dynamite:
15292 PlayLevelSoundElementAction(x, y, element, ACTION_DROPPING);
15296 PlayLevelSoundElementAction(x, y, element, ACTION_ACTIVE);
15300 PlayLevelSoundElementAction(x, y, element, ACTION_ACTIVATING);
15304 PlayLevelSoundElementAction(x, y, element, ACTION_ACTIVE);
15308 PlayLevelSoundElementAction(x, y, element, ACTION_EXPLODING);
15312 PlayLevelSoundElementAction(x, y, element, ACTION_DYING);
15316 PlaySound(SND_GAME_RUNNING_OUT_OF_TIME);
15320 PlayLevelSoundElementAction(x, y, element, ACTION_DEFAULT);
15325 void PlayLevelSound_SP(int xx, int yy, int element_sp, int action_sp)
15327 int element = map_element_SP_to_RND(element_sp);
15328 int action = map_action_SP_to_RND(action_sp);
15329 int offset = (setup.sp_show_border_elements ? 0 : 1);
15330 int x = xx - offset;
15331 int y = yy - offset;
15333 PlayLevelSoundElementAction(x, y, element, action);
15336 void PlayLevelSound_MM(int xx, int yy, int element_mm, int action_mm)
15338 int element = map_element_MM_to_RND(element_mm);
15339 int action = map_action_MM_to_RND(action_mm);
15341 int x = xx - offset;
15342 int y = yy - offset;
15344 if (!IS_MM_ELEMENT(element))
15345 element = EL_MM_DEFAULT;
15347 PlayLevelSoundElementAction(x, y, element, action);
15350 void PlaySound_MM(int sound_mm)
15352 int sound = map_sound_MM_to_RND(sound_mm);
15354 if (sound == SND_UNDEFINED)
15360 void PlaySoundLoop_MM(int sound_mm)
15362 int sound = map_sound_MM_to_RND(sound_mm);
15364 if (sound == SND_UNDEFINED)
15367 PlaySoundLoop(sound);
15370 void StopSound_MM(int sound_mm)
15372 int sound = map_sound_MM_to_RND(sound_mm);
15374 if (sound == SND_UNDEFINED)
15380 void RaiseScore(int value)
15382 game.score += value;
15384 game_panel_controls[GAME_PANEL_SCORE].value = game.score;
15386 DisplayGameControlValues();
15389 void RaiseScoreElement(int element)
15394 case EL_BD_DIAMOND:
15395 case EL_EMERALD_YELLOW:
15396 case EL_EMERALD_RED:
15397 case EL_EMERALD_PURPLE:
15398 case EL_SP_INFOTRON:
15399 RaiseScore(level.score[SC_EMERALD]);
15402 RaiseScore(level.score[SC_DIAMOND]);
15405 RaiseScore(level.score[SC_CRYSTAL]);
15408 RaiseScore(level.score[SC_PEARL]);
15411 case EL_BD_BUTTERFLY:
15412 case EL_SP_ELECTRON:
15413 RaiseScore(level.score[SC_BUG]);
15416 case EL_BD_FIREFLY:
15417 case EL_SP_SNIKSNAK:
15418 RaiseScore(level.score[SC_SPACESHIP]);
15421 case EL_DARK_YAMYAM:
15422 RaiseScore(level.score[SC_YAMYAM]);
15425 RaiseScore(level.score[SC_ROBOT]);
15428 RaiseScore(level.score[SC_PACMAN]);
15431 RaiseScore(level.score[SC_NUT]);
15434 case EL_EM_DYNAMITE:
15435 case EL_SP_DISK_RED:
15436 case EL_DYNABOMB_INCREASE_NUMBER:
15437 case EL_DYNABOMB_INCREASE_SIZE:
15438 case EL_DYNABOMB_INCREASE_POWER:
15439 RaiseScore(level.score[SC_DYNAMITE]);
15441 case EL_SHIELD_NORMAL:
15442 case EL_SHIELD_DEADLY:
15443 RaiseScore(level.score[SC_SHIELD]);
15445 case EL_EXTRA_TIME:
15446 RaiseScore(level.extra_time_score);
15460 case EL_DC_KEY_WHITE:
15461 RaiseScore(level.score[SC_KEY]);
15464 RaiseScore(element_info[element].collect_score);
15469 void RequestQuitGameExt(boolean skip_request, boolean quick_quit, char *message)
15471 if (skip_request || Request(message, REQ_ASK | REQ_STAY_CLOSED))
15475 // prevent short reactivation of overlay buttons while closing door
15476 SetOverlayActive(FALSE);
15478 // door may still be open due to skipped or envelope style request
15479 CloseDoor(DOOR_CLOSE_1);
15482 if (network.enabled)
15483 SendToServer_StopPlaying(NETWORK_STOP_BY_PLAYER);
15487 FadeSkipNextFadeIn();
15489 SetGameStatus(GAME_MODE_MAIN);
15494 else // continue playing the game
15496 if (tape.playing && tape.deactivate_display)
15497 TapeDeactivateDisplayOff(TRUE);
15499 OpenDoor(DOOR_OPEN_1 | DOOR_COPY_BACK);
15501 if (tape.playing && tape.deactivate_display)
15502 TapeDeactivateDisplayOn();
15506 void RequestQuitGame(boolean escape_key_pressed)
15508 boolean ask_on_escape = (setup.ask_on_escape && setup.ask_on_quit_game);
15509 boolean quick_quit = ((escape_key_pressed && !ask_on_escape) ||
15510 level_editor_test_game);
15511 boolean skip_request = (game.all_players_gone || !setup.ask_on_quit_game ||
15514 RequestQuitGameExt(skip_request, quick_quit,
15515 "Do you really want to quit the game?");
15518 void RequestRestartGame(char *message)
15520 game.restart_game_message = NULL;
15522 boolean has_started_game = hasStartedNetworkGame();
15523 int request_mode = (has_started_game ? REQ_ASK : REQ_CONFIRM);
15525 if (Request(message, request_mode | REQ_STAY_CLOSED) && has_started_game)
15527 StartGameActions(network.enabled, setup.autorecord, level.random_seed);
15531 // needed in case of envelope request to close game panel
15532 CloseDoor(DOOR_CLOSE_1);
15534 SetGameStatus(GAME_MODE_MAIN);
15540 void CheckGameOver(void)
15542 static boolean last_game_over = FALSE;
15543 static int game_over_delay = 0;
15544 int game_over_delay_value = 50;
15545 boolean game_over = checkGameFailed();
15547 // do not handle game over if request dialog is already active
15548 if (game.request_active)
15551 // do not ask to play again if game was never actually played
15552 if (!game.GamePlayed)
15557 last_game_over = FALSE;
15558 game_over_delay = game_over_delay_value;
15563 if (game_over_delay > 0)
15570 if (last_game_over != game_over)
15571 game.restart_game_message = (hasStartedNetworkGame() ?
15572 "Game over! Play it again?" :
15575 last_game_over = game_over;
15578 boolean checkGameSolved(void)
15580 // set for all game engines if level was solved
15581 return game.LevelSolved_GameEnd;
15584 boolean checkGameFailed(void)
15586 if (level.game_engine_type == GAME_ENGINE_TYPE_EM)
15587 return (game_em.game_over && !game_em.level_solved);
15588 else if (level.game_engine_type == GAME_ENGINE_TYPE_SP)
15589 return (game_sp.game_over && !game_sp.level_solved);
15590 else if (level.game_engine_type == GAME_ENGINE_TYPE_MM)
15591 return (game_mm.game_over && !game_mm.level_solved);
15592 else // GAME_ENGINE_TYPE_RND
15593 return (game.GameOver && !game.LevelSolved);
15596 boolean checkGameEnded(void)
15598 return (checkGameSolved() || checkGameFailed());
15602 // ----------------------------------------------------------------------------
15603 // random generator functions
15604 // ----------------------------------------------------------------------------
15606 unsigned int InitEngineRandom_RND(int seed)
15608 game.num_random_calls = 0;
15610 return InitEngineRandom(seed);
15613 unsigned int RND(int max)
15617 game.num_random_calls++;
15619 return GetEngineRandom(max);
15626 // ----------------------------------------------------------------------------
15627 // game engine snapshot handling functions
15628 // ----------------------------------------------------------------------------
15630 struct EngineSnapshotInfo
15632 // runtime values for custom element collect score
15633 int collect_score[NUM_CUSTOM_ELEMENTS];
15635 // runtime values for group element choice position
15636 int choice_pos[NUM_GROUP_ELEMENTS];
15638 // runtime values for belt position animations
15639 int belt_graphic[4][NUM_BELT_PARTS];
15640 int belt_anim_mode[4][NUM_BELT_PARTS];
15643 static struct EngineSnapshotInfo engine_snapshot_rnd;
15644 static char *snapshot_level_identifier = NULL;
15645 static int snapshot_level_nr = -1;
15647 static void SaveEngineSnapshotValues_RND(void)
15649 static int belt_base_active_element[4] =
15651 EL_CONVEYOR_BELT_1_LEFT_ACTIVE,
15652 EL_CONVEYOR_BELT_2_LEFT_ACTIVE,
15653 EL_CONVEYOR_BELT_3_LEFT_ACTIVE,
15654 EL_CONVEYOR_BELT_4_LEFT_ACTIVE
15658 for (i = 0; i < NUM_CUSTOM_ELEMENTS; i++)
15660 int element = EL_CUSTOM_START + i;
15662 engine_snapshot_rnd.collect_score[i] = element_info[element].collect_score;
15665 for (i = 0; i < NUM_GROUP_ELEMENTS; i++)
15667 int element = EL_GROUP_START + i;
15669 engine_snapshot_rnd.choice_pos[i] = element_info[element].group->choice_pos;
15672 for (i = 0; i < 4; i++)
15674 for (j = 0; j < NUM_BELT_PARTS; j++)
15676 int element = belt_base_active_element[i] + j;
15677 int graphic = el2img(element);
15678 int anim_mode = graphic_info[graphic].anim_mode;
15680 engine_snapshot_rnd.belt_graphic[i][j] = graphic;
15681 engine_snapshot_rnd.belt_anim_mode[i][j] = anim_mode;
15686 static void LoadEngineSnapshotValues_RND(void)
15688 unsigned int num_random_calls = game.num_random_calls;
15691 for (i = 0; i < NUM_CUSTOM_ELEMENTS; i++)
15693 int element = EL_CUSTOM_START + i;
15695 element_info[element].collect_score = engine_snapshot_rnd.collect_score[i];
15698 for (i = 0; i < NUM_GROUP_ELEMENTS; i++)
15700 int element = EL_GROUP_START + i;
15702 element_info[element].group->choice_pos = engine_snapshot_rnd.choice_pos[i];
15705 for (i = 0; i < 4; i++)
15707 for (j = 0; j < NUM_BELT_PARTS; j++)
15709 int graphic = engine_snapshot_rnd.belt_graphic[i][j];
15710 int anim_mode = engine_snapshot_rnd.belt_anim_mode[i][j];
15712 graphic_info[graphic].anim_mode = anim_mode;
15716 if (level.game_engine_type == GAME_ENGINE_TYPE_RND)
15718 InitRND(tape.random_seed);
15719 for (i = 0; i < num_random_calls; i++)
15723 if (game.num_random_calls != num_random_calls)
15725 Error("number of random calls out of sync");
15726 Error("number of random calls should be %d", num_random_calls);
15727 Error("number of random calls is %d", game.num_random_calls);
15729 Fail("this should not happen -- please debug");
15733 void FreeEngineSnapshotSingle(void)
15735 FreeSnapshotSingle();
15737 setString(&snapshot_level_identifier, NULL);
15738 snapshot_level_nr = -1;
15741 void FreeEngineSnapshotList(void)
15743 FreeSnapshotList();
15746 static ListNode *SaveEngineSnapshotBuffers(void)
15748 ListNode *buffers = NULL;
15750 // copy some special values to a structure better suited for the snapshot
15752 if (level.game_engine_type == GAME_ENGINE_TYPE_RND)
15753 SaveEngineSnapshotValues_RND();
15754 if (level.game_engine_type == GAME_ENGINE_TYPE_EM)
15755 SaveEngineSnapshotValues_EM();
15756 if (level.game_engine_type == GAME_ENGINE_TYPE_SP)
15757 SaveEngineSnapshotValues_SP(&buffers);
15758 if (level.game_engine_type == GAME_ENGINE_TYPE_MM)
15759 SaveEngineSnapshotValues_MM(&buffers);
15761 // save values stored in special snapshot structure
15763 if (level.game_engine_type == GAME_ENGINE_TYPE_RND)
15764 SaveSnapshotBuffer(&buffers, ARGS_ADDRESS_AND_SIZEOF(engine_snapshot_rnd));
15765 if (level.game_engine_type == GAME_ENGINE_TYPE_EM)
15766 SaveSnapshotBuffer(&buffers, ARGS_ADDRESS_AND_SIZEOF(engine_snapshot_em));
15767 if (level.game_engine_type == GAME_ENGINE_TYPE_SP)
15768 SaveSnapshotBuffer(&buffers, ARGS_ADDRESS_AND_SIZEOF(engine_snapshot_sp));
15769 if (level.game_engine_type == GAME_ENGINE_TYPE_MM)
15770 SaveSnapshotBuffer(&buffers, ARGS_ADDRESS_AND_SIZEOF(engine_snapshot_mm));
15772 // save further RND engine values
15774 SaveSnapshotBuffer(&buffers, ARGS_ADDRESS_AND_SIZEOF(stored_player));
15775 SaveSnapshotBuffer(&buffers, ARGS_ADDRESS_AND_SIZEOF(game));
15776 SaveSnapshotBuffer(&buffers, ARGS_ADDRESS_AND_SIZEOF(tape));
15778 SaveSnapshotBuffer(&buffers, ARGS_ADDRESS_AND_SIZEOF(FrameCounter));
15779 SaveSnapshotBuffer(&buffers, ARGS_ADDRESS_AND_SIZEOF(TimeFrames));
15780 SaveSnapshotBuffer(&buffers, ARGS_ADDRESS_AND_SIZEOF(TimePlayed));
15781 SaveSnapshotBuffer(&buffers, ARGS_ADDRESS_AND_SIZEOF(TimeLeft));
15782 SaveSnapshotBuffer(&buffers, ARGS_ADDRESS_AND_SIZEOF(TapeTime));
15784 SaveSnapshotBuffer(&buffers, ARGS_ADDRESS_AND_SIZEOF(ScreenMovDir));
15785 SaveSnapshotBuffer(&buffers, ARGS_ADDRESS_AND_SIZEOF(ScreenMovPos));
15786 SaveSnapshotBuffer(&buffers, ARGS_ADDRESS_AND_SIZEOF(ScreenGfxPos));
15788 SaveSnapshotBuffer(&buffers, ARGS_ADDRESS_AND_SIZEOF(ScrollStepSize));
15790 SaveSnapshotBuffer(&buffers, ARGS_ADDRESS_AND_SIZEOF(AmoebaCnt));
15791 SaveSnapshotBuffer(&buffers, ARGS_ADDRESS_AND_SIZEOF(AmoebaCnt2));
15793 SaveSnapshotBuffer(&buffers, ARGS_ADDRESS_AND_SIZEOF(Tile));
15794 SaveSnapshotBuffer(&buffers, ARGS_ADDRESS_AND_SIZEOF(MovPos));
15795 SaveSnapshotBuffer(&buffers, ARGS_ADDRESS_AND_SIZEOF(MovDir));
15796 SaveSnapshotBuffer(&buffers, ARGS_ADDRESS_AND_SIZEOF(MovDelay));
15797 SaveSnapshotBuffer(&buffers, ARGS_ADDRESS_AND_SIZEOF(ChangeDelay));
15798 SaveSnapshotBuffer(&buffers, ARGS_ADDRESS_AND_SIZEOF(ChangePage));
15799 SaveSnapshotBuffer(&buffers, ARGS_ADDRESS_AND_SIZEOF(CustomValue));
15800 SaveSnapshotBuffer(&buffers, ARGS_ADDRESS_AND_SIZEOF(Store));
15801 SaveSnapshotBuffer(&buffers, ARGS_ADDRESS_AND_SIZEOF(Store2));
15802 SaveSnapshotBuffer(&buffers, ARGS_ADDRESS_AND_SIZEOF(StorePlayer));
15803 SaveSnapshotBuffer(&buffers, ARGS_ADDRESS_AND_SIZEOF(Back));
15804 SaveSnapshotBuffer(&buffers, ARGS_ADDRESS_AND_SIZEOF(AmoebaNr));
15805 SaveSnapshotBuffer(&buffers, ARGS_ADDRESS_AND_SIZEOF(WasJustMoving));
15806 SaveSnapshotBuffer(&buffers, ARGS_ADDRESS_AND_SIZEOF(WasJustFalling));
15807 SaveSnapshotBuffer(&buffers, ARGS_ADDRESS_AND_SIZEOF(CheckCollision));
15808 SaveSnapshotBuffer(&buffers, ARGS_ADDRESS_AND_SIZEOF(CheckImpact));
15809 SaveSnapshotBuffer(&buffers, ARGS_ADDRESS_AND_SIZEOF(Stop));
15810 SaveSnapshotBuffer(&buffers, ARGS_ADDRESS_AND_SIZEOF(Pushed));
15812 SaveSnapshotBuffer(&buffers, ARGS_ADDRESS_AND_SIZEOF(ChangeCount));
15813 SaveSnapshotBuffer(&buffers, ARGS_ADDRESS_AND_SIZEOF(ChangeEvent));
15815 SaveSnapshotBuffer(&buffers, ARGS_ADDRESS_AND_SIZEOF(ExplodePhase));
15816 SaveSnapshotBuffer(&buffers, ARGS_ADDRESS_AND_SIZEOF(ExplodeDelay));
15817 SaveSnapshotBuffer(&buffers, ARGS_ADDRESS_AND_SIZEOF(ExplodeField));
15819 SaveSnapshotBuffer(&buffers, ARGS_ADDRESS_AND_SIZEOF(RunnerVisit));
15820 SaveSnapshotBuffer(&buffers, ARGS_ADDRESS_AND_SIZEOF(PlayerVisit));
15822 SaveSnapshotBuffer(&buffers, ARGS_ADDRESS_AND_SIZEOF(GfxFrame));
15823 SaveSnapshotBuffer(&buffers, ARGS_ADDRESS_AND_SIZEOF(GfxRandom));
15824 SaveSnapshotBuffer(&buffers, ARGS_ADDRESS_AND_SIZEOF(GfxElement));
15825 SaveSnapshotBuffer(&buffers, ARGS_ADDRESS_AND_SIZEOF(GfxAction));
15826 SaveSnapshotBuffer(&buffers, ARGS_ADDRESS_AND_SIZEOF(GfxDir));
15828 SaveSnapshotBuffer(&buffers, ARGS_ADDRESS_AND_SIZEOF(scroll_x));
15829 SaveSnapshotBuffer(&buffers, ARGS_ADDRESS_AND_SIZEOF(scroll_y));
15832 ListNode *node = engine_snapshot_list_rnd;
15835 while (node != NULL)
15837 num_bytes += ((struct EngineSnapshotNodeInfo *)node->content)->size;
15842 Debug("game:playing:SaveEngineSnapshotBuffers",
15843 "size of engine snapshot: %d bytes", num_bytes);
15849 void SaveEngineSnapshotSingle(void)
15851 ListNode *buffers = SaveEngineSnapshotBuffers();
15853 // finally save all snapshot buffers to single snapshot
15854 SaveSnapshotSingle(buffers);
15856 // save level identification information
15857 setString(&snapshot_level_identifier, leveldir_current->identifier);
15858 snapshot_level_nr = level_nr;
15861 boolean CheckSaveEngineSnapshotToList(void)
15863 boolean save_snapshot =
15864 ((game.snapshot.mode == SNAPSHOT_MODE_EVERY_STEP) ||
15865 (game.snapshot.mode == SNAPSHOT_MODE_EVERY_MOVE &&
15866 game.snapshot.changed_action) ||
15867 (game.snapshot.mode == SNAPSHOT_MODE_EVERY_COLLECT &&
15868 game.snapshot.collected_item));
15870 game.snapshot.changed_action = FALSE;
15871 game.snapshot.collected_item = FALSE;
15872 game.snapshot.save_snapshot = save_snapshot;
15874 return save_snapshot;
15877 void SaveEngineSnapshotToList(void)
15879 if (game.snapshot.mode == SNAPSHOT_MODE_OFF ||
15883 ListNode *buffers = SaveEngineSnapshotBuffers();
15885 // finally save all snapshot buffers to snapshot list
15886 SaveSnapshotToList(buffers);
15889 void SaveEngineSnapshotToListInitial(void)
15891 FreeEngineSnapshotList();
15893 SaveEngineSnapshotToList();
15896 static void LoadEngineSnapshotValues(void)
15898 // restore special values from snapshot structure
15900 if (level.game_engine_type == GAME_ENGINE_TYPE_RND)
15901 LoadEngineSnapshotValues_RND();
15902 if (level.game_engine_type == GAME_ENGINE_TYPE_EM)
15903 LoadEngineSnapshotValues_EM();
15904 if (level.game_engine_type == GAME_ENGINE_TYPE_SP)
15905 LoadEngineSnapshotValues_SP();
15906 if (level.game_engine_type == GAME_ENGINE_TYPE_MM)
15907 LoadEngineSnapshotValues_MM();
15910 void LoadEngineSnapshotSingle(void)
15912 LoadSnapshotSingle();
15914 LoadEngineSnapshotValues();
15917 static void LoadEngineSnapshot_Undo(int steps)
15919 LoadSnapshotFromList_Older(steps);
15921 LoadEngineSnapshotValues();
15924 static void LoadEngineSnapshot_Redo(int steps)
15926 LoadSnapshotFromList_Newer(steps);
15928 LoadEngineSnapshotValues();
15931 boolean CheckEngineSnapshotSingle(void)
15933 return (strEqual(snapshot_level_identifier, leveldir_current->identifier) &&
15934 snapshot_level_nr == level_nr);
15937 boolean CheckEngineSnapshotList(void)
15939 return CheckSnapshotList();
15943 // ---------- new game button stuff -------------------------------------------
15950 boolean *setup_value;
15951 boolean allowed_on_tape;
15952 boolean is_touch_button;
15954 } gamebutton_info[NUM_GAME_BUTTONS] =
15957 IMG_GFX_GAME_BUTTON_STOP, &game.button.stop,
15958 GAME_CTRL_ID_STOP, NULL,
15959 TRUE, FALSE, "stop game"
15962 IMG_GFX_GAME_BUTTON_PAUSE, &game.button.pause,
15963 GAME_CTRL_ID_PAUSE, NULL,
15964 TRUE, FALSE, "pause game"
15967 IMG_GFX_GAME_BUTTON_PLAY, &game.button.play,
15968 GAME_CTRL_ID_PLAY, NULL,
15969 TRUE, FALSE, "play game"
15972 IMG_GFX_GAME_BUTTON_UNDO, &game.button.undo,
15973 GAME_CTRL_ID_UNDO, NULL,
15974 TRUE, FALSE, "undo step"
15977 IMG_GFX_GAME_BUTTON_REDO, &game.button.redo,
15978 GAME_CTRL_ID_REDO, NULL,
15979 TRUE, FALSE, "redo step"
15982 IMG_GFX_GAME_BUTTON_SAVE, &game.button.save,
15983 GAME_CTRL_ID_SAVE, NULL,
15984 TRUE, FALSE, "save game"
15987 IMG_GFX_GAME_BUTTON_PAUSE2, &game.button.pause2,
15988 GAME_CTRL_ID_PAUSE2, NULL,
15989 TRUE, FALSE, "pause game"
15992 IMG_GFX_GAME_BUTTON_LOAD, &game.button.load,
15993 GAME_CTRL_ID_LOAD, NULL,
15994 TRUE, FALSE, "load game"
15997 IMG_GFX_GAME_BUTTON_PANEL_STOP, &game.button.panel_stop,
15998 GAME_CTRL_ID_PANEL_STOP, NULL,
15999 FALSE, FALSE, "stop game"
16002 IMG_GFX_GAME_BUTTON_PANEL_PAUSE, &game.button.panel_pause,
16003 GAME_CTRL_ID_PANEL_PAUSE, NULL,
16004 FALSE, FALSE, "pause game"
16007 IMG_GFX_GAME_BUTTON_PANEL_PLAY, &game.button.panel_play,
16008 GAME_CTRL_ID_PANEL_PLAY, NULL,
16009 FALSE, FALSE, "play game"
16012 IMG_GFX_GAME_BUTTON_TOUCH_STOP, &game.button.touch_stop,
16013 GAME_CTRL_ID_TOUCH_STOP, NULL,
16014 FALSE, TRUE, "stop game"
16017 IMG_GFX_GAME_BUTTON_TOUCH_PAUSE, &game.button.touch_pause,
16018 GAME_CTRL_ID_TOUCH_PAUSE, NULL,
16019 FALSE, TRUE, "pause game"
16022 IMG_GFX_GAME_BUTTON_SOUND_MUSIC, &game.button.sound_music,
16023 SOUND_CTRL_ID_MUSIC, &setup.sound_music,
16024 TRUE, FALSE, "background music on/off"
16027 IMG_GFX_GAME_BUTTON_SOUND_LOOPS, &game.button.sound_loops,
16028 SOUND_CTRL_ID_LOOPS, &setup.sound_loops,
16029 TRUE, FALSE, "sound loops on/off"
16032 IMG_GFX_GAME_BUTTON_SOUND_SIMPLE, &game.button.sound_simple,
16033 SOUND_CTRL_ID_SIMPLE, &setup.sound_simple,
16034 TRUE, FALSE, "normal sounds on/off"
16037 IMG_GFX_GAME_BUTTON_PANEL_SOUND_MUSIC, &game.button.panel_sound_music,
16038 SOUND_CTRL_ID_PANEL_MUSIC, &setup.sound_music,
16039 FALSE, FALSE, "background music on/off"
16042 IMG_GFX_GAME_BUTTON_PANEL_SOUND_LOOPS, &game.button.panel_sound_loops,
16043 SOUND_CTRL_ID_PANEL_LOOPS, &setup.sound_loops,
16044 FALSE, FALSE, "sound loops on/off"
16047 IMG_GFX_GAME_BUTTON_PANEL_SOUND_SIMPLE, &game.button.panel_sound_simple,
16048 SOUND_CTRL_ID_PANEL_SIMPLE, &setup.sound_simple,
16049 FALSE, FALSE, "normal sounds on/off"
16053 void CreateGameButtons(void)
16057 for (i = 0; i < NUM_GAME_BUTTONS; i++)
16059 int graphic = gamebutton_info[i].graphic;
16060 struct GraphicInfo *gfx = &graphic_info[graphic];
16061 struct XY *pos = gamebutton_info[i].pos;
16062 struct GadgetInfo *gi;
16065 unsigned int event_mask;
16066 boolean is_touch_button = gamebutton_info[i].is_touch_button;
16067 boolean allowed_on_tape = gamebutton_info[i].allowed_on_tape;
16068 boolean on_tape = (tape.show_game_buttons && allowed_on_tape);
16069 int base_x = (is_touch_button ? 0 : on_tape ? VX : DX);
16070 int base_y = (is_touch_button ? 0 : on_tape ? VY : DY);
16071 int gd_x = gfx->src_x;
16072 int gd_y = gfx->src_y;
16073 int gd_xp = gfx->src_x + gfx->pressed_xoffset;
16074 int gd_yp = gfx->src_y + gfx->pressed_yoffset;
16075 int gd_xa = gfx->src_x + gfx->active_xoffset;
16076 int gd_ya = gfx->src_y + gfx->active_yoffset;
16077 int gd_xap = gfx->src_x + gfx->active_xoffset + gfx->pressed_xoffset;
16078 int gd_yap = gfx->src_y + gfx->active_yoffset + gfx->pressed_yoffset;
16079 int x = (is_touch_button ? pos->x : GDI_ACTIVE_POS(pos->x));
16080 int y = (is_touch_button ? pos->y : GDI_ACTIVE_POS(pos->y));
16083 if (gfx->bitmap == NULL)
16085 game_gadget[id] = NULL;
16090 if (id == GAME_CTRL_ID_STOP ||
16091 id == GAME_CTRL_ID_PANEL_STOP ||
16092 id == GAME_CTRL_ID_TOUCH_STOP ||
16093 id == GAME_CTRL_ID_PLAY ||
16094 id == GAME_CTRL_ID_PANEL_PLAY ||
16095 id == GAME_CTRL_ID_SAVE ||
16096 id == GAME_CTRL_ID_LOAD)
16098 button_type = GD_TYPE_NORMAL_BUTTON;
16100 event_mask = GD_EVENT_RELEASED;
16102 else if (id == GAME_CTRL_ID_UNDO ||
16103 id == GAME_CTRL_ID_REDO)
16105 button_type = GD_TYPE_NORMAL_BUTTON;
16107 event_mask = GD_EVENT_PRESSED | GD_EVENT_REPEATED;
16111 button_type = GD_TYPE_CHECK_BUTTON;
16112 checked = (gamebutton_info[i].setup_value != NULL ?
16113 *gamebutton_info[i].setup_value : FALSE);
16114 event_mask = GD_EVENT_PRESSED;
16117 gi = CreateGadget(GDI_CUSTOM_ID, id,
16118 GDI_IMAGE_ID, graphic,
16119 GDI_INFO_TEXT, gamebutton_info[i].infotext,
16122 GDI_WIDTH, gfx->width,
16123 GDI_HEIGHT, gfx->height,
16124 GDI_TYPE, button_type,
16125 GDI_STATE, GD_BUTTON_UNPRESSED,
16126 GDI_CHECKED, checked,
16127 GDI_DESIGN_UNPRESSED, gfx->bitmap, gd_x, gd_y,
16128 GDI_DESIGN_PRESSED, gfx->bitmap, gd_xp, gd_yp,
16129 GDI_ALT_DESIGN_UNPRESSED, gfx->bitmap, gd_xa, gd_ya,
16130 GDI_ALT_DESIGN_PRESSED, gfx->bitmap, gd_xap, gd_yap,
16131 GDI_DIRECT_DRAW, FALSE,
16132 GDI_OVERLAY_TOUCH_BUTTON, is_touch_button,
16133 GDI_EVENT_MASK, event_mask,
16134 GDI_CALLBACK_ACTION, HandleGameButtons,
16138 Fail("cannot create gadget");
16140 game_gadget[id] = gi;
16144 void FreeGameButtons(void)
16148 for (i = 0; i < NUM_GAME_BUTTONS; i++)
16149 FreeGadget(game_gadget[i]);
16152 static void UnmapGameButtonsAtSamePosition(int id)
16156 for (i = 0; i < NUM_GAME_BUTTONS; i++)
16158 gamebutton_info[i].pos->x == gamebutton_info[id].pos->x &&
16159 gamebutton_info[i].pos->y == gamebutton_info[id].pos->y)
16160 UnmapGadget(game_gadget[i]);
16163 static void UnmapGameButtonsAtSamePosition_All(void)
16165 if (setup.show_snapshot_buttons)
16167 UnmapGameButtonsAtSamePosition(GAME_CTRL_ID_SAVE);
16168 UnmapGameButtonsAtSamePosition(GAME_CTRL_ID_PAUSE2);
16169 UnmapGameButtonsAtSamePosition(GAME_CTRL_ID_LOAD);
16173 UnmapGameButtonsAtSamePosition(GAME_CTRL_ID_STOP);
16174 UnmapGameButtonsAtSamePosition(GAME_CTRL_ID_PAUSE);
16175 UnmapGameButtonsAtSamePosition(GAME_CTRL_ID_PLAY);
16177 UnmapGameButtonsAtSamePosition(GAME_CTRL_ID_PANEL_STOP);
16178 UnmapGameButtonsAtSamePosition(GAME_CTRL_ID_PANEL_PAUSE);
16179 UnmapGameButtonsAtSamePosition(GAME_CTRL_ID_PANEL_PLAY);
16183 static void MapGameButtonsAtSamePosition(int id)
16187 for (i = 0; i < NUM_GAME_BUTTONS; i++)
16189 gamebutton_info[i].pos->x == gamebutton_info[id].pos->x &&
16190 gamebutton_info[i].pos->y == gamebutton_info[id].pos->y)
16191 MapGadget(game_gadget[i]);
16193 UnmapGameButtonsAtSamePosition_All();
16196 void MapUndoRedoButtons(void)
16198 UnmapGameButtonsAtSamePosition(GAME_CTRL_ID_UNDO);
16199 UnmapGameButtonsAtSamePosition(GAME_CTRL_ID_REDO);
16201 MapGadget(game_gadget[GAME_CTRL_ID_UNDO]);
16202 MapGadget(game_gadget[GAME_CTRL_ID_REDO]);
16205 void UnmapUndoRedoButtons(void)
16207 UnmapGadget(game_gadget[GAME_CTRL_ID_UNDO]);
16208 UnmapGadget(game_gadget[GAME_CTRL_ID_REDO]);
16210 MapGameButtonsAtSamePosition(GAME_CTRL_ID_UNDO);
16211 MapGameButtonsAtSamePosition(GAME_CTRL_ID_REDO);
16214 void ModifyPauseButtons(void)
16218 GAME_CTRL_ID_PAUSE,
16219 GAME_CTRL_ID_PAUSE2,
16220 GAME_CTRL_ID_PANEL_PAUSE,
16221 GAME_CTRL_ID_TOUCH_PAUSE,
16226 for (i = 0; ids[i] > -1; i++)
16227 ModifyGadget(game_gadget[ids[i]], GDI_CHECKED, tape.pausing, GDI_END);
16230 static void MapGameButtonsExt(boolean on_tape)
16234 for (i = 0; i < NUM_GAME_BUTTONS; i++)
16235 if ((!on_tape || gamebutton_info[i].allowed_on_tape) &&
16236 i != GAME_CTRL_ID_UNDO &&
16237 i != GAME_CTRL_ID_REDO)
16238 MapGadget(game_gadget[i]);
16240 UnmapGameButtonsAtSamePosition_All();
16242 RedrawGameButtons();
16245 static void UnmapGameButtonsExt(boolean on_tape)
16249 for (i = 0; i < NUM_GAME_BUTTONS; i++)
16250 if (!on_tape || gamebutton_info[i].allowed_on_tape)
16251 UnmapGadget(game_gadget[i]);
16254 static void RedrawGameButtonsExt(boolean on_tape)
16258 for (i = 0; i < NUM_GAME_BUTTONS; i++)
16259 if (!on_tape || gamebutton_info[i].allowed_on_tape)
16260 RedrawGadget(game_gadget[i]);
16263 static void SetGadgetState(struct GadgetInfo *gi, boolean state)
16268 gi->checked = state;
16271 static void RedrawSoundButtonGadget(int id)
16273 int id2 = (id == SOUND_CTRL_ID_MUSIC ? SOUND_CTRL_ID_PANEL_MUSIC :
16274 id == SOUND_CTRL_ID_LOOPS ? SOUND_CTRL_ID_PANEL_LOOPS :
16275 id == SOUND_CTRL_ID_SIMPLE ? SOUND_CTRL_ID_PANEL_SIMPLE :
16276 id == SOUND_CTRL_ID_PANEL_MUSIC ? SOUND_CTRL_ID_MUSIC :
16277 id == SOUND_CTRL_ID_PANEL_LOOPS ? SOUND_CTRL_ID_LOOPS :
16278 id == SOUND_CTRL_ID_PANEL_SIMPLE ? SOUND_CTRL_ID_SIMPLE :
16281 SetGadgetState(game_gadget[id2], *gamebutton_info[id2].setup_value);
16282 RedrawGadget(game_gadget[id2]);
16285 void MapGameButtons(void)
16287 MapGameButtonsExt(FALSE);
16290 void UnmapGameButtons(void)
16292 UnmapGameButtonsExt(FALSE);
16295 void RedrawGameButtons(void)
16297 RedrawGameButtonsExt(FALSE);
16300 void MapGameButtonsOnTape(void)
16302 MapGameButtonsExt(TRUE);
16305 void UnmapGameButtonsOnTape(void)
16307 UnmapGameButtonsExt(TRUE);
16310 void RedrawGameButtonsOnTape(void)
16312 RedrawGameButtonsExt(TRUE);
16315 static void GameUndoRedoExt(void)
16317 ClearPlayerAction();
16319 tape.pausing = TRUE;
16322 UpdateAndDisplayGameControlValues();
16324 DrawCompleteVideoDisplay();
16325 DrawVideoDisplay(VIDEO_STATE_TIME_ON, TapeTime);
16326 DrawVideoDisplay(VIDEO_STATE_FRAME_ON, FrameCounter);
16327 DrawVideoDisplay(VIDEO_STATE_1STEP(tape.single_step), 0);
16332 static void GameUndo(int steps)
16334 if (!CheckEngineSnapshotList())
16337 LoadEngineSnapshot_Undo(steps);
16342 static void GameRedo(int steps)
16344 if (!CheckEngineSnapshotList())
16347 LoadEngineSnapshot_Redo(steps);
16352 static void HandleGameButtonsExt(int id, int button)
16354 static boolean game_undo_executed = FALSE;
16355 int steps = BUTTON_STEPSIZE(button);
16356 boolean handle_game_buttons =
16357 (game_status == GAME_MODE_PLAYING ||
16358 (game_status == GAME_MODE_MAIN && tape.show_game_buttons));
16360 if (!handle_game_buttons)
16365 case GAME_CTRL_ID_STOP:
16366 case GAME_CTRL_ID_PANEL_STOP:
16367 case GAME_CTRL_ID_TOUCH_STOP:
16368 if (game_status == GAME_MODE_MAIN)
16374 RequestQuitGame(FALSE);
16378 case GAME_CTRL_ID_PAUSE:
16379 case GAME_CTRL_ID_PAUSE2:
16380 case GAME_CTRL_ID_PANEL_PAUSE:
16381 case GAME_CTRL_ID_TOUCH_PAUSE:
16382 if (network.enabled && game_status == GAME_MODE_PLAYING)
16385 SendToServer_ContinuePlaying();
16387 SendToServer_PausePlaying();
16390 TapeTogglePause(TAPE_TOGGLE_MANUAL);
16392 game_undo_executed = FALSE;
16396 case GAME_CTRL_ID_PLAY:
16397 case GAME_CTRL_ID_PANEL_PLAY:
16398 if (game_status == GAME_MODE_MAIN)
16400 StartGameActions(network.enabled, setup.autorecord, level.random_seed);
16402 else if (tape.pausing)
16404 if (network.enabled)
16405 SendToServer_ContinuePlaying();
16407 TapeTogglePause(TAPE_TOGGLE_MANUAL | TAPE_TOGGLE_PLAY_PAUSE);
16411 case GAME_CTRL_ID_UNDO:
16412 // Important: When using "save snapshot when collecting an item" mode,
16413 // load last (current) snapshot for first "undo" after pressing "pause"
16414 // (else the last-but-one snapshot would be loaded, because the snapshot
16415 // pointer already points to the last snapshot when pressing "pause",
16416 // which is fine for "every step/move" mode, but not for "every collect")
16417 if (game.snapshot.mode == SNAPSHOT_MODE_EVERY_COLLECT &&
16418 !game_undo_executed)
16421 game_undo_executed = TRUE;
16426 case GAME_CTRL_ID_REDO:
16430 case GAME_CTRL_ID_SAVE:
16434 case GAME_CTRL_ID_LOAD:
16438 case SOUND_CTRL_ID_MUSIC:
16439 case SOUND_CTRL_ID_PANEL_MUSIC:
16440 if (setup.sound_music)
16442 setup.sound_music = FALSE;
16446 else if (audio.music_available)
16448 setup.sound = setup.sound_music = TRUE;
16450 SetAudioMode(setup.sound);
16452 if (game_status == GAME_MODE_PLAYING)
16456 RedrawSoundButtonGadget(id);
16460 case SOUND_CTRL_ID_LOOPS:
16461 case SOUND_CTRL_ID_PANEL_LOOPS:
16462 if (setup.sound_loops)
16463 setup.sound_loops = FALSE;
16464 else if (audio.loops_available)
16466 setup.sound = setup.sound_loops = TRUE;
16468 SetAudioMode(setup.sound);
16471 RedrawSoundButtonGadget(id);
16475 case SOUND_CTRL_ID_SIMPLE:
16476 case SOUND_CTRL_ID_PANEL_SIMPLE:
16477 if (setup.sound_simple)
16478 setup.sound_simple = FALSE;
16479 else if (audio.sound_available)
16481 setup.sound = setup.sound_simple = TRUE;
16483 SetAudioMode(setup.sound);
16486 RedrawSoundButtonGadget(id);
16495 static void HandleGameButtons(struct GadgetInfo *gi)
16497 HandleGameButtonsExt(gi->custom_id, gi->event.button);
16500 void HandleSoundButtonKeys(Key key)
16502 if (key == setup.shortcut.sound_simple)
16503 ClickOnGadget(game_gadget[SOUND_CTRL_ID_SIMPLE], MB_LEFTBUTTON);
16504 else if (key == setup.shortcut.sound_loops)
16505 ClickOnGadget(game_gadget[SOUND_CTRL_ID_LOOPS], MB_LEFTBUTTON);
16506 else if (key == setup.shortcut.sound_music)
16507 ClickOnGadget(game_gadget[SOUND_CTRL_ID_MUSIC], MB_LEFTBUTTON);