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_sb = TRUE; // unless non-SOKOBAN elements found
3546 boolean emulate_sp = TRUE; // unless non-SUPAPLEX elements found
3547 int initial_move_dir = MV_DOWN;
3550 // required here to update video display before fading (FIX THIS)
3551 DrawMaskedBorder(REDRAW_DOOR_2);
3553 if (!game.restart_level)
3554 CloseDoor(DOOR_CLOSE_1);
3556 SetGameStatus(GAME_MODE_PLAYING);
3558 if (level_editor_test_game)
3559 FadeSkipNextFadeOut();
3561 FadeSetEnterScreen();
3564 fade_mask = REDRAW_ALL;
3566 FadeLevelSoundsAndMusic();
3568 ExpireSoundLoops(TRUE);
3572 if (level_editor_test_game)
3573 FadeSkipNextFadeIn();
3575 // needed if different viewport properties defined for playing
3576 ChangeViewportPropertiesIfNeeded();
3580 DrawCompleteVideoDisplay();
3582 OpenDoor(GetDoorState() | DOOR_NO_DELAY | DOOR_FORCE_REDRAW);
3585 InitGameControlValues();
3589 // initialize tape actions from game when recording tape
3590 tape.use_key_actions = game.use_key_actions;
3591 tape.use_mouse_actions = game.use_mouse_actions;
3593 // initialize visible playfield size when recording tape (for team mode)
3594 tape.scr_fieldx = SCR_FIELDX;
3595 tape.scr_fieldy = SCR_FIELDY;
3598 // don't play tapes over network
3599 network_playing = (network.enabled && !tape.playing);
3601 for (i = 0; i < MAX_PLAYERS; i++)
3603 struct PlayerInfo *player = &stored_player[i];
3605 player->index_nr = i;
3606 player->index_bit = (1 << i);
3607 player->element_nr = EL_PLAYER_1 + i;
3609 player->present = FALSE;
3610 player->active = FALSE;
3611 player->mapped = FALSE;
3613 player->killed = FALSE;
3614 player->reanimated = FALSE;
3615 player->buried = FALSE;
3618 player->effective_action = 0;
3619 player->programmed_action = 0;
3620 player->snap_action = 0;
3622 player->mouse_action.lx = 0;
3623 player->mouse_action.ly = 0;
3624 player->mouse_action.button = 0;
3625 player->mouse_action.button_hint = 0;
3627 player->effective_mouse_action.lx = 0;
3628 player->effective_mouse_action.ly = 0;
3629 player->effective_mouse_action.button = 0;
3630 player->effective_mouse_action.button_hint = 0;
3632 for (j = 0; j < MAX_NUM_KEYS; j++)
3633 player->key[j] = FALSE;
3635 player->num_white_keys = 0;
3637 player->dynabomb_count = 0;
3638 player->dynabomb_size = 1;
3639 player->dynabombs_left = 0;
3640 player->dynabomb_xl = FALSE;
3642 player->MovDir = initial_move_dir;
3645 player->GfxDir = initial_move_dir;
3646 player->GfxAction = ACTION_DEFAULT;
3648 player->StepFrame = 0;
3650 player->initial_element = player->element_nr;
3651 player->artwork_element =
3652 (level.use_artwork_element[i] ? level.artwork_element[i] :
3653 player->element_nr);
3654 player->use_murphy = FALSE;
3656 player->block_last_field = FALSE; // initialized in InitPlayerField()
3657 player->block_delay_adjustment = 0; // initialized in InitPlayerField()
3659 player->gravity = level.initial_player_gravity[i];
3661 player->can_fall_into_acid = CAN_MOVE_INTO_ACID(player->element_nr);
3663 player->actual_frame_counter = 0;
3665 player->step_counter = 0;
3667 player->last_move_dir = initial_move_dir;
3669 player->is_active = FALSE;
3671 player->is_waiting = FALSE;
3672 player->is_moving = FALSE;
3673 player->is_auto_moving = FALSE;
3674 player->is_digging = FALSE;
3675 player->is_snapping = FALSE;
3676 player->is_collecting = FALSE;
3677 player->is_pushing = FALSE;
3678 player->is_switching = FALSE;
3679 player->is_dropping = FALSE;
3680 player->is_dropping_pressed = FALSE;
3682 player->is_bored = FALSE;
3683 player->is_sleeping = FALSE;
3685 player->was_waiting = TRUE;
3686 player->was_moving = FALSE;
3687 player->was_snapping = FALSE;
3688 player->was_dropping = FALSE;
3690 player->force_dropping = FALSE;
3692 player->frame_counter_bored = -1;
3693 player->frame_counter_sleeping = -1;
3695 player->anim_delay_counter = 0;
3696 player->post_delay_counter = 0;
3698 player->dir_waiting = initial_move_dir;
3699 player->action_waiting = ACTION_DEFAULT;
3700 player->last_action_waiting = ACTION_DEFAULT;
3701 player->special_action_bored = ACTION_DEFAULT;
3702 player->special_action_sleeping = ACTION_DEFAULT;
3704 player->switch_x = -1;
3705 player->switch_y = -1;
3707 player->drop_x = -1;
3708 player->drop_y = -1;
3710 player->show_envelope = 0;
3712 SetPlayerMoveSpeed(player, level.initial_player_stepsize[i], TRUE);
3714 player->push_delay = -1; // initialized when pushing starts
3715 player->push_delay_value = game.initial_push_delay_value;
3717 player->drop_delay = 0;
3718 player->drop_pressed_delay = 0;
3720 player->last_jx = -1;
3721 player->last_jy = -1;
3725 player->shield_normal_time_left = 0;
3726 player->shield_deadly_time_left = 0;
3728 player->last_removed_element = EL_UNDEFINED;
3730 player->inventory_infinite_element = EL_UNDEFINED;
3731 player->inventory_size = 0;
3733 if (level.use_initial_inventory[i])
3735 for (j = 0; j < level.initial_inventory_size[i]; j++)
3737 int element = level.initial_inventory_content[i][j];
3738 int collect_count = element_info[element].collect_count_initial;
3741 if (!IS_CUSTOM_ELEMENT(element))
3744 if (collect_count == 0)
3745 player->inventory_infinite_element = element;
3747 for (k = 0; k < collect_count; k++)
3748 if (player->inventory_size < MAX_INVENTORY_SIZE)
3749 player->inventory_element[player->inventory_size++] = element;
3753 DigField(player, 0, 0, 0, 0, 0, 0, DF_NO_PUSH);
3754 SnapField(player, 0, 0);
3756 map_player_action[i] = i;
3759 network_player_action_received = FALSE;
3761 // initial null action
3762 if (network_playing)
3763 SendToServer_MovePlayer(MV_NONE);
3768 TimeLeft = level.time;
3771 ScreenMovDir = MV_NONE;
3775 ScrollStepSize = 0; // will be correctly initialized by ScrollScreen()
3777 game.robot_wheel_x = -1;
3778 game.robot_wheel_y = -1;
3783 game.all_players_gone = FALSE;
3785 game.LevelSolved = FALSE;
3786 game.GameOver = FALSE;
3788 game.GamePlayed = !tape.playing;
3790 game.LevelSolved_GameWon = FALSE;
3791 game.LevelSolved_GameEnd = FALSE;
3792 game.LevelSolved_SaveTape = FALSE;
3793 game.LevelSolved_SaveScore = FALSE;
3795 game.LevelSolved_CountingTime = 0;
3796 game.LevelSolved_CountingScore = 0;
3797 game.LevelSolved_CountingHealth = 0;
3799 game.panel.active = TRUE;
3801 game.no_time_limit = (level.time == 0);
3803 game.yamyam_content_nr = 0;
3804 game.robot_wheel_active = FALSE;
3805 game.magic_wall_active = FALSE;
3806 game.magic_wall_time_left = 0;
3807 game.light_time_left = 0;
3808 game.timegate_time_left = 0;
3809 game.switchgate_pos = 0;
3810 game.wind_direction = level.wind_direction_initial;
3812 game.time_final = 0;
3813 game.score_time_final = 0;
3816 game.score_final = 0;
3818 game.health = MAX_HEALTH;
3819 game.health_final = MAX_HEALTH;
3821 game.gems_still_needed = level.gems_needed;
3822 game.sokoban_fields_still_needed = 0;
3823 game.sokoban_objects_still_needed = 0;
3824 game.lights_still_needed = 0;
3825 game.players_still_needed = 0;
3826 game.friends_still_needed = 0;
3828 game.lenses_time_left = 0;
3829 game.magnify_time_left = 0;
3831 game.ball_active = level.ball_active_initial;
3832 game.ball_content_nr = 0;
3834 game.explosions_delayed = TRUE;
3836 game.envelope_active = FALSE;
3838 for (i = 0; i < NUM_BELTS; i++)
3840 game.belt_dir[i] = MV_NONE;
3841 game.belt_dir_nr[i] = 3; // not moving, next moving left
3844 for (i = 0; i < MAX_NUM_AMOEBA; i++)
3845 AmoebaCnt[i] = AmoebaCnt2[i] = 0;
3847 #if DEBUG_INIT_PLAYER
3848 DebugPrintPlayerStatus("Player status at level initialization");
3851 SCAN_PLAYFIELD(x, y)
3853 Tile[x][y] = Last[x][y] = level.field[x][y];
3854 MovPos[x][y] = MovDir[x][y] = MovDelay[x][y] = 0;
3855 ChangeDelay[x][y] = 0;
3856 ChangePage[x][y] = -1;
3857 CustomValue[x][y] = 0; // initialized in InitField()
3858 Store[x][y] = Store2[x][y] = StorePlayer[x][y] = Back[x][y] = 0;
3860 WasJustMoving[x][y] = 0;
3861 WasJustFalling[x][y] = 0;
3862 CheckCollision[x][y] = 0;
3863 CheckImpact[x][y] = 0;
3865 Pushed[x][y] = FALSE;
3867 ChangeCount[x][y] = 0;
3868 ChangeEvent[x][y] = -1;
3870 ExplodePhase[x][y] = 0;
3871 ExplodeDelay[x][y] = 0;
3872 ExplodeField[x][y] = EX_TYPE_NONE;
3874 RunnerVisit[x][y] = 0;
3875 PlayerVisit[x][y] = 0;
3878 GfxRandom[x][y] = INIT_GFX_RANDOM();
3879 GfxElement[x][y] = EL_UNDEFINED;
3880 GfxAction[x][y] = ACTION_DEFAULT;
3881 GfxDir[x][y] = MV_NONE;
3882 GfxRedraw[x][y] = GFX_REDRAW_NONE;
3885 SCAN_PLAYFIELD(x, y)
3887 if (emulate_bd && !IS_BD_ELEMENT(Tile[x][y]))
3889 if (emulate_sb && !IS_SB_ELEMENT(Tile[x][y]))
3891 if (emulate_sp && !IS_SP_ELEMENT(Tile[x][y]))
3894 InitField(x, y, TRUE);
3896 ResetGfxAnimation(x, y);
3901 for (i = 0; i < MAX_PLAYERS; i++)
3903 struct PlayerInfo *player = &stored_player[i];
3905 // set number of special actions for bored and sleeping animation
3906 player->num_special_action_bored =
3907 get_num_special_action(player->artwork_element,
3908 ACTION_BORING_1, ACTION_BORING_LAST);
3909 player->num_special_action_sleeping =
3910 get_num_special_action(player->artwork_element,
3911 ACTION_SLEEPING_1, ACTION_SLEEPING_LAST);
3914 game.emulation = (emulate_bd ? EMU_BOULDERDASH :
3915 emulate_sb ? EMU_SOKOBAN :
3916 emulate_sp ? EMU_SUPAPLEX : EMU_NONE);
3918 // initialize type of slippery elements
3919 for (i = 0; i < MAX_NUM_ELEMENTS; i++)
3921 if (!IS_CUSTOM_ELEMENT(i))
3923 // default: elements slip down either to the left or right randomly
3924 element_info[i].slippery_type = SLIPPERY_ANY_RANDOM;
3926 // SP style elements prefer to slip down on the left side
3927 if (game.engine_version >= VERSION_IDENT(3,1,1,0) && IS_SP_ELEMENT(i))
3928 element_info[i].slippery_type = SLIPPERY_ANY_LEFT_RIGHT;
3930 // BD style elements prefer to slip down on the left side
3931 if (game.emulation == EMU_BOULDERDASH)
3932 element_info[i].slippery_type = SLIPPERY_ANY_LEFT_RIGHT;
3936 // initialize explosion and ignition delay
3937 for (i = 0; i < MAX_NUM_ELEMENTS; i++)
3939 if (!IS_CUSTOM_ELEMENT(i))
3942 int delay = (((IS_SP_ELEMENT(i) && i != EL_EMPTY_SPACE) &&
3943 game.engine_version >= VERSION_IDENT(3,1,0,0)) ||
3944 game.emulation == EMU_SUPAPLEX ? 3 : 2);
3945 int last_phase = (num_phase + 1) * delay;
3946 int half_phase = (num_phase / 2) * delay;
3948 element_info[i].explosion_delay = last_phase - 1;
3949 element_info[i].ignition_delay = half_phase;
3951 if (i == EL_BLACK_ORB)
3952 element_info[i].ignition_delay = 1;
3956 // correct non-moving belts to start moving left
3957 for (i = 0; i < NUM_BELTS; i++)
3958 if (game.belt_dir[i] == MV_NONE)
3959 game.belt_dir_nr[i] = 3; // not moving, next moving left
3961 #if USE_NEW_PLAYER_ASSIGNMENTS
3962 // use preferred player also in local single-player mode
3963 if (!network.enabled && !game.team_mode)
3965 int new_index_nr = setup.network_player_nr;
3967 if (new_index_nr >= 0 && new_index_nr < MAX_PLAYERS)
3969 for (i = 0; i < MAX_PLAYERS; i++)
3970 stored_player[i].connected_locally = FALSE;
3972 stored_player[new_index_nr].connected_locally = TRUE;
3976 for (i = 0; i < MAX_PLAYERS; i++)
3978 stored_player[i].connected = FALSE;
3980 // in network game mode, the local player might not be the first player
3981 if (stored_player[i].connected_locally)
3982 local_player = &stored_player[i];
3985 if (!network.enabled)
3986 local_player->connected = TRUE;
3990 for (i = 0; i < MAX_PLAYERS; i++)
3991 stored_player[i].connected = tape.player_participates[i];
3993 else if (network.enabled)
3995 // add team mode players connected over the network (needed for correct
3996 // assignment of player figures from level to locally playing players)
3998 for (i = 0; i < MAX_PLAYERS; i++)
3999 if (stored_player[i].connected_network)
4000 stored_player[i].connected = TRUE;
4002 else if (game.team_mode)
4004 // try to guess locally connected team mode players (needed for correct
4005 // assignment of player figures from level to locally playing players)
4007 for (i = 0; i < MAX_PLAYERS; i++)
4008 if (setup.input[i].use_joystick ||
4009 setup.input[i].key.left != KSYM_UNDEFINED)
4010 stored_player[i].connected = TRUE;
4013 #if DEBUG_INIT_PLAYER
4014 DebugPrintPlayerStatus("Player status after level initialization");
4017 #if DEBUG_INIT_PLAYER
4018 Debug("game:init:player", "Reassigning players ...");
4021 // check if any connected player was not found in playfield
4022 for (i = 0; i < MAX_PLAYERS; i++)
4024 struct PlayerInfo *player = &stored_player[i];
4026 if (player->connected && !player->present)
4028 struct PlayerInfo *field_player = NULL;
4030 #if DEBUG_INIT_PLAYER
4031 Debug("game:init:player",
4032 "- looking for field player for player %d ...", i + 1);
4035 // assign first free player found that is present in the playfield
4037 // first try: look for unmapped playfield player that is not connected
4038 for (j = 0; j < MAX_PLAYERS; j++)
4039 if (field_player == NULL &&
4040 stored_player[j].present &&
4041 !stored_player[j].mapped &&
4042 !stored_player[j].connected)
4043 field_player = &stored_player[j];
4045 // second try: look for *any* unmapped playfield player
4046 for (j = 0; j < MAX_PLAYERS; j++)
4047 if (field_player == NULL &&
4048 stored_player[j].present &&
4049 !stored_player[j].mapped)
4050 field_player = &stored_player[j];
4052 if (field_player != NULL)
4054 int jx = field_player->jx, jy = field_player->jy;
4056 #if DEBUG_INIT_PLAYER
4057 Debug("game:init:player", "- found player %d",
4058 field_player->index_nr + 1);
4061 player->present = FALSE;
4062 player->active = FALSE;
4064 field_player->present = TRUE;
4065 field_player->active = TRUE;
4068 player->initial_element = field_player->initial_element;
4069 player->artwork_element = field_player->artwork_element;
4071 player->block_last_field = field_player->block_last_field;
4072 player->block_delay_adjustment = field_player->block_delay_adjustment;
4075 StorePlayer[jx][jy] = field_player->element_nr;
4077 field_player->jx = field_player->last_jx = jx;
4078 field_player->jy = field_player->last_jy = jy;
4080 if (local_player == player)
4081 local_player = field_player;
4083 map_player_action[field_player->index_nr] = i;
4085 field_player->mapped = TRUE;
4087 #if DEBUG_INIT_PLAYER
4088 Debug("game:init:player", "- map_player_action[%d] == %d",
4089 field_player->index_nr + 1, i + 1);
4094 if (player->connected && player->present)
4095 player->mapped = TRUE;
4098 #if DEBUG_INIT_PLAYER
4099 DebugPrintPlayerStatus("Player status after player assignment (first stage)");
4104 // check if any connected player was not found in playfield
4105 for (i = 0; i < MAX_PLAYERS; i++)
4107 struct PlayerInfo *player = &stored_player[i];
4109 if (player->connected && !player->present)
4111 for (j = 0; j < MAX_PLAYERS; j++)
4113 struct PlayerInfo *field_player = &stored_player[j];
4114 int jx = field_player->jx, jy = field_player->jy;
4116 // assign first free player found that is present in the playfield
4117 if (field_player->present && !field_player->connected)
4119 player->present = TRUE;
4120 player->active = TRUE;
4122 field_player->present = FALSE;
4123 field_player->active = FALSE;
4125 player->initial_element = field_player->initial_element;
4126 player->artwork_element = field_player->artwork_element;
4128 player->block_last_field = field_player->block_last_field;
4129 player->block_delay_adjustment = field_player->block_delay_adjustment;
4131 StorePlayer[jx][jy] = player->element_nr;
4133 player->jx = player->last_jx = jx;
4134 player->jy = player->last_jy = jy;
4144 Debug("game:init:player", "local_player->present == %d",
4145 local_player->present);
4148 // set focus to local player for network games, else to all players
4149 game.centered_player_nr = (network_playing ? local_player->index_nr : -1);
4150 game.centered_player_nr_next = game.centered_player_nr;
4151 game.set_centered_player = FALSE;
4152 game.set_centered_player_wrap = FALSE;
4154 if (network_playing && tape.recording)
4156 // store client dependent player focus when recording network games
4157 tape.centered_player_nr_next = game.centered_player_nr_next;
4158 tape.set_centered_player = TRUE;
4163 // when playing a tape, eliminate all players who do not participate
4165 #if USE_NEW_PLAYER_ASSIGNMENTS
4167 if (!game.team_mode)
4169 for (i = 0; i < MAX_PLAYERS; i++)
4171 if (stored_player[i].active &&
4172 !tape.player_participates[map_player_action[i]])
4174 struct PlayerInfo *player = &stored_player[i];
4175 int jx = player->jx, jy = player->jy;
4177 #if DEBUG_INIT_PLAYER
4178 Debug("game:init:player", "Removing player %d at (%d, %d)",
4182 player->active = FALSE;
4183 StorePlayer[jx][jy] = 0;
4184 Tile[jx][jy] = EL_EMPTY;
4191 for (i = 0; i < MAX_PLAYERS; i++)
4193 if (stored_player[i].active &&
4194 !tape.player_participates[i])
4196 struct PlayerInfo *player = &stored_player[i];
4197 int jx = player->jx, jy = player->jy;
4199 player->active = FALSE;
4200 StorePlayer[jx][jy] = 0;
4201 Tile[jx][jy] = EL_EMPTY;
4206 else if (!network.enabled && !game.team_mode) // && !tape.playing
4208 // when in single player mode, eliminate all but the local player
4210 for (i = 0; i < MAX_PLAYERS; i++)
4212 struct PlayerInfo *player = &stored_player[i];
4214 if (player->active && player != local_player)
4216 int jx = player->jx, jy = player->jy;
4218 player->active = FALSE;
4219 player->present = FALSE;
4221 StorePlayer[jx][jy] = 0;
4222 Tile[jx][jy] = EL_EMPTY;
4227 for (i = 0; i < MAX_PLAYERS; i++)
4228 if (stored_player[i].active)
4229 game.players_still_needed++;
4231 if (level.solved_by_one_player)
4232 game.players_still_needed = 1;
4234 // when recording the game, store which players take part in the game
4237 #if USE_NEW_PLAYER_ASSIGNMENTS
4238 for (i = 0; i < MAX_PLAYERS; i++)
4239 if (stored_player[i].connected)
4240 tape.player_participates[i] = TRUE;
4242 for (i = 0; i < MAX_PLAYERS; i++)
4243 if (stored_player[i].active)
4244 tape.player_participates[i] = TRUE;
4248 #if DEBUG_INIT_PLAYER
4249 DebugPrintPlayerStatus("Player status after player assignment (final stage)");
4252 if (BorderElement == EL_EMPTY)
4255 SBX_Right = lev_fieldx - SCR_FIELDX;
4257 SBY_Lower = lev_fieldy - SCR_FIELDY;
4262 SBX_Right = lev_fieldx - SCR_FIELDX + 1;
4264 SBY_Lower = lev_fieldy - SCR_FIELDY + 1;
4267 if (full_lev_fieldx <= SCR_FIELDX)
4268 SBX_Left = SBX_Right = -1 * (SCR_FIELDX - lev_fieldx) / 2;
4269 if (full_lev_fieldy <= SCR_FIELDY)
4270 SBY_Upper = SBY_Lower = -1 * (SCR_FIELDY - lev_fieldy) / 2;
4272 if (EVEN(SCR_FIELDX) && full_lev_fieldx > SCR_FIELDX)
4274 if (EVEN(SCR_FIELDY) && full_lev_fieldy > SCR_FIELDY)
4277 // if local player not found, look for custom element that might create
4278 // the player (make some assumptions about the right custom element)
4279 if (!local_player->present)
4281 int start_x = 0, start_y = 0;
4282 int found_rating = 0;
4283 int found_element = EL_UNDEFINED;
4284 int player_nr = local_player->index_nr;
4286 SCAN_PLAYFIELD(x, y)
4288 int element = Tile[x][y];
4293 if (level.use_start_element[player_nr] &&
4294 level.start_element[player_nr] == element &&
4301 found_element = element;
4304 if (!IS_CUSTOM_ELEMENT(element))
4307 if (CAN_CHANGE(element))
4309 for (i = 0; i < element_info[element].num_change_pages; i++)
4311 // check for player created from custom element as single target
4312 content = element_info[element].change_page[i].target_element;
4313 is_player = ELEM_IS_PLAYER(content);
4315 if (is_player && (found_rating < 3 ||
4316 (found_rating == 3 && element < found_element)))
4322 found_element = element;
4327 for (yy = 0; yy < 3; yy++) for (xx = 0; xx < 3; xx++)
4329 // check for player created from custom element as explosion content
4330 content = element_info[element].content.e[xx][yy];
4331 is_player = ELEM_IS_PLAYER(content);
4333 if (is_player && (found_rating < 2 ||
4334 (found_rating == 2 && element < found_element)))
4336 start_x = x + xx - 1;
4337 start_y = y + yy - 1;
4340 found_element = element;
4343 if (!CAN_CHANGE(element))
4346 for (i = 0; i < element_info[element].num_change_pages; i++)
4348 // check for player created from custom element as extended target
4350 element_info[element].change_page[i].target_content.e[xx][yy];
4352 is_player = ELEM_IS_PLAYER(content);
4354 if (is_player && (found_rating < 1 ||
4355 (found_rating == 1 && element < found_element)))
4357 start_x = x + xx - 1;
4358 start_y = y + yy - 1;
4361 found_element = element;
4367 scroll_x = SCROLL_POSITION_X(start_x);
4368 scroll_y = SCROLL_POSITION_Y(start_y);
4372 scroll_x = SCROLL_POSITION_X(local_player->jx);
4373 scroll_y = SCROLL_POSITION_Y(local_player->jy);
4376 // !!! FIX THIS (START) !!!
4377 if (level.game_engine_type == GAME_ENGINE_TYPE_EM)
4379 InitGameEngine_EM();
4381 else if (level.game_engine_type == GAME_ENGINE_TYPE_SP)
4383 InitGameEngine_SP();
4385 else if (level.game_engine_type == GAME_ENGINE_TYPE_MM)
4387 InitGameEngine_MM();
4391 DrawLevel(REDRAW_FIELD);
4394 // after drawing the level, correct some elements
4395 if (game.timegate_time_left == 0)
4396 CloseAllOpenTimegates();
4399 // blit playfield from scroll buffer to normal back buffer for fading in
4400 BlitScreenToBitmap(backbuffer);
4401 // !!! FIX THIS (END) !!!
4403 DrawMaskedBorder(fade_mask);
4408 // full screen redraw is required at this point in the following cases:
4409 // - special editor door undrawn when game was started from level editor
4410 // - drawing area (playfield) was changed and has to be removed completely
4411 redraw_mask = REDRAW_ALL;
4415 if (!game.restart_level)
4417 // copy default game door content to main double buffer
4419 // !!! CHECK AGAIN !!!
4420 SetPanelBackground();
4421 // SetDoorBackgroundImage(IMG_BACKGROUND_PANEL);
4422 DrawBackground(DX, DY, DXSIZE, DYSIZE);
4425 SetPanelBackground();
4426 SetDrawBackgroundMask(REDRAW_DOOR_1);
4428 UpdateAndDisplayGameControlValues();
4430 if (!game.restart_level)
4436 CreateGameButtons();
4441 // copy actual game door content to door double buffer for OpenDoor()
4442 BlitBitmap(drawto, bitmap_db_door_1, DX, DY, DXSIZE, DYSIZE, 0, 0);
4444 OpenDoor(DOOR_OPEN_ALL);
4446 KeyboardAutoRepeatOffUnlessAutoplay();
4448 #if DEBUG_INIT_PLAYER
4449 DebugPrintPlayerStatus("Player status (final)");
4458 if (!game.restart_level && !tape.playing)
4460 LevelStats_incPlayed(level_nr);
4462 SaveLevelSetup_SeriesInfo();
4465 game.restart_level = FALSE;
4466 game.restart_game_message = NULL;
4468 game.request_active = FALSE;
4469 game.request_active_or_moving = FALSE;
4471 if (level.game_engine_type == GAME_ENGINE_TYPE_MM)
4472 InitGameActions_MM();
4474 SaveEngineSnapshotToListInitial();
4476 if (!game.restart_level)
4478 PlaySound(SND_GAME_STARTING);
4480 if (setup.sound_music)
4485 void UpdateEngineValues(int actual_scroll_x, int actual_scroll_y,
4486 int actual_player_x, int actual_player_y)
4488 // this is used for non-R'n'D game engines to update certain engine values
4490 // needed to determine if sounds are played within the visible screen area
4491 scroll_x = actual_scroll_x;
4492 scroll_y = actual_scroll_y;
4494 // needed to get player position for "follow finger" playing input method
4495 local_player->jx = actual_player_x;
4496 local_player->jy = actual_player_y;
4499 void InitMovDir(int x, int y)
4501 int i, element = Tile[x][y];
4502 static int xy[4][2] =
4509 static int direction[3][4] =
4511 { MV_RIGHT, MV_UP, MV_LEFT, MV_DOWN },
4512 { MV_LEFT, MV_DOWN, MV_RIGHT, MV_UP },
4513 { MV_LEFT, MV_RIGHT, MV_UP, MV_DOWN }
4522 Tile[x][y] = EL_BUG;
4523 MovDir[x][y] = direction[0][element - EL_BUG_RIGHT];
4526 case EL_SPACESHIP_RIGHT:
4527 case EL_SPACESHIP_UP:
4528 case EL_SPACESHIP_LEFT:
4529 case EL_SPACESHIP_DOWN:
4530 Tile[x][y] = EL_SPACESHIP;
4531 MovDir[x][y] = direction[0][element - EL_SPACESHIP_RIGHT];
4534 case EL_BD_BUTTERFLY_RIGHT:
4535 case EL_BD_BUTTERFLY_UP:
4536 case EL_BD_BUTTERFLY_LEFT:
4537 case EL_BD_BUTTERFLY_DOWN:
4538 Tile[x][y] = EL_BD_BUTTERFLY;
4539 MovDir[x][y] = direction[0][element - EL_BD_BUTTERFLY_RIGHT];
4542 case EL_BD_FIREFLY_RIGHT:
4543 case EL_BD_FIREFLY_UP:
4544 case EL_BD_FIREFLY_LEFT:
4545 case EL_BD_FIREFLY_DOWN:
4546 Tile[x][y] = EL_BD_FIREFLY;
4547 MovDir[x][y] = direction[0][element - EL_BD_FIREFLY_RIGHT];
4550 case EL_PACMAN_RIGHT:
4552 case EL_PACMAN_LEFT:
4553 case EL_PACMAN_DOWN:
4554 Tile[x][y] = EL_PACMAN;
4555 MovDir[x][y] = direction[0][element - EL_PACMAN_RIGHT];
4558 case EL_YAMYAM_LEFT:
4559 case EL_YAMYAM_RIGHT:
4561 case EL_YAMYAM_DOWN:
4562 Tile[x][y] = EL_YAMYAM;
4563 MovDir[x][y] = direction[2][element - EL_YAMYAM_LEFT];
4566 case EL_SP_SNIKSNAK:
4567 MovDir[x][y] = MV_UP;
4570 case EL_SP_ELECTRON:
4571 MovDir[x][y] = MV_LEFT;
4578 Tile[x][y] = EL_MOLE;
4579 MovDir[x][y] = direction[2][element - EL_MOLE_LEFT];
4582 case EL_SPRING_LEFT:
4583 case EL_SPRING_RIGHT:
4584 Tile[x][y] = EL_SPRING;
4585 MovDir[x][y] = direction[2][element - EL_SPRING_LEFT];
4589 if (IS_CUSTOM_ELEMENT(element))
4591 struct ElementInfo *ei = &element_info[element];
4592 int move_direction_initial = ei->move_direction_initial;
4593 int move_pattern = ei->move_pattern;
4595 if (move_direction_initial == MV_START_PREVIOUS)
4597 if (MovDir[x][y] != MV_NONE)
4600 move_direction_initial = MV_START_AUTOMATIC;
4603 if (move_direction_initial == MV_START_RANDOM)
4604 MovDir[x][y] = 1 << RND(4);
4605 else if (move_direction_initial & MV_ANY_DIRECTION)
4606 MovDir[x][y] = move_direction_initial;
4607 else if (move_pattern == MV_ALL_DIRECTIONS ||
4608 move_pattern == MV_TURNING_LEFT ||
4609 move_pattern == MV_TURNING_RIGHT ||
4610 move_pattern == MV_TURNING_LEFT_RIGHT ||
4611 move_pattern == MV_TURNING_RIGHT_LEFT ||
4612 move_pattern == MV_TURNING_RANDOM)
4613 MovDir[x][y] = 1 << RND(4);
4614 else if (move_pattern == MV_HORIZONTAL)
4615 MovDir[x][y] = (RND(2) ? MV_LEFT : MV_RIGHT);
4616 else if (move_pattern == MV_VERTICAL)
4617 MovDir[x][y] = (RND(2) ? MV_UP : MV_DOWN);
4618 else if (move_pattern & MV_ANY_DIRECTION)
4619 MovDir[x][y] = element_info[element].move_pattern;
4620 else if (move_pattern == MV_ALONG_LEFT_SIDE ||
4621 move_pattern == MV_ALONG_RIGHT_SIDE)
4623 // use random direction as default start direction
4624 if (game.engine_version >= VERSION_IDENT(3,1,0,0))
4625 MovDir[x][y] = 1 << RND(4);
4627 for (i = 0; i < NUM_DIRECTIONS; i++)
4629 int x1 = x + xy[i][0];
4630 int y1 = y + xy[i][1];
4632 if (!IN_LEV_FIELD(x1, y1) || !IS_FREE(x1, y1))
4634 if (move_pattern == MV_ALONG_RIGHT_SIDE)
4635 MovDir[x][y] = direction[0][i];
4637 MovDir[x][y] = direction[1][i];
4646 MovDir[x][y] = 1 << RND(4);
4648 if (element != EL_BUG &&
4649 element != EL_SPACESHIP &&
4650 element != EL_BD_BUTTERFLY &&
4651 element != EL_BD_FIREFLY)
4654 for (i = 0; i < NUM_DIRECTIONS; i++)
4656 int x1 = x + xy[i][0];
4657 int y1 = y + xy[i][1];
4659 if (!IN_LEV_FIELD(x1, y1) || !IS_FREE(x1, y1))
4661 if (element == EL_BUG || element == EL_BD_BUTTERFLY)
4663 MovDir[x][y] = direction[0][i];
4666 else if (element == EL_SPACESHIP || element == EL_BD_FIREFLY ||
4667 element == EL_SP_SNIKSNAK || element == EL_SP_ELECTRON)
4669 MovDir[x][y] = direction[1][i];
4678 GfxDir[x][y] = MovDir[x][y];
4681 void InitAmoebaNr(int x, int y)
4684 int group_nr = AmoebaNeighbourNr(x, y);
4688 for (i = 1; i < MAX_NUM_AMOEBA; i++)
4690 if (AmoebaCnt[i] == 0)
4698 AmoebaNr[x][y] = group_nr;
4699 AmoebaCnt[group_nr]++;
4700 AmoebaCnt2[group_nr]++;
4703 static void LevelSolved(void)
4705 if (level.game_engine_type == GAME_ENGINE_TYPE_RND &&
4706 game.players_still_needed > 0)
4709 game.LevelSolved = TRUE;
4710 game.GameOver = TRUE;
4715 static int time_count_steps;
4716 static int time, time_final;
4717 static float score, score_final; // needed for time score < 10 for 10 seconds
4718 static int health, health_final;
4719 static int game_over_delay_1 = 0;
4720 static int game_over_delay_2 = 0;
4721 static int game_over_delay_3 = 0;
4722 int time_score_base = MIN(MAX(1, level.time_score_base), 10);
4723 float time_score = (float)level.score[SC_TIME_BONUS] / time_score_base;
4725 if (!game.LevelSolved_GameWon)
4729 // do not start end game actions before the player stops moving (to exit)
4730 if (local_player->active && local_player->MovPos)
4733 game.time_final = (game.no_time_limit ? TimePlayed : TimeLeft);
4734 game.score_time_final = (level.use_step_counter ? TimePlayed :
4735 TimePlayed * FRAMES_PER_SECOND + TimeFrames);
4737 game.score_final = (level.game_engine_type == GAME_ENGINE_TYPE_EM ?
4738 game_em.lev->score :
4739 level.game_engine_type == GAME_ENGINE_TYPE_MM ?
4743 game.health_final = (level.game_engine_type == GAME_ENGINE_TYPE_MM ?
4744 MM_HEALTH(game_mm.laser_overload_value) :
4747 game.LevelSolved_CountingTime = game.time_final;
4748 game.LevelSolved_CountingScore = game.score_final;
4749 game.LevelSolved_CountingHealth = game.health_final;
4751 game.LevelSolved_GameWon = TRUE;
4752 game.LevelSolved_SaveTape = tape.recording;
4753 game.LevelSolved_SaveScore = !tape.playing;
4757 LevelStats_incSolved(level_nr);
4759 SaveLevelSetup_SeriesInfo();
4762 if (tape.auto_play) // tape might already be stopped here
4763 tape.auto_play_level_solved = TRUE;
4767 game_over_delay_1 = FRAMES_PER_SECOND; // delay before counting time
4768 game_over_delay_2 = FRAMES_PER_SECOND / 2; // delay before counting health
4769 game_over_delay_3 = FRAMES_PER_SECOND; // delay before ending the game
4771 time = time_final = game.time_final;
4772 score = score_final = game.score_final;
4773 health = health_final = game.health_final;
4777 int time_final_max = 999;
4778 int time_frames_final_max = time_final_max * FRAMES_PER_SECOND;
4779 int time_frames = 0;
4780 int time_frames_left = TimeLeft * FRAMES_PER_SECOND - TimeFrames;
4781 int time_frames_played = TimePlayed * FRAMES_PER_SECOND + TimeFrames;
4786 time_frames = time_frames_left;
4788 else if (game.no_time_limit && TimePlayed < time_final_max)
4790 time_final = time_final_max;
4791 time_frames = time_frames_final_max - time_frames_played;
4794 score_final += time_score * time_frames / FRAMES_PER_SECOND + 0.5;
4796 time_count_steps = MAX(1, ABS(time_final - time) / 100);
4798 if (level.game_engine_type == GAME_ENGINE_TYPE_MM)
4801 score_final += health * time_score;
4804 game.score_final = score_final;
4805 game.health_final = health_final;
4808 if (level_editor_test_game || !setup.count_score_after_game)
4811 score = score_final;
4813 game.LevelSolved_CountingTime = time;
4814 game.LevelSolved_CountingScore = score;
4816 game_panel_controls[GAME_PANEL_TIME].value = time;
4817 game_panel_controls[GAME_PANEL_SCORE].value = score;
4819 DisplayGameControlValues();
4822 if (level.game_engine_type == GAME_ENGINE_TYPE_RND)
4824 // check if last player has left the level
4825 if (game.exit_x >= 0 &&
4828 int x = game.exit_x;
4829 int y = game.exit_y;
4830 int element = Tile[x][y];
4832 // close exit door after last player
4833 if ((game.all_players_gone &&
4834 (element == EL_EXIT_OPEN ||
4835 element == EL_SP_EXIT_OPEN ||
4836 element == EL_STEEL_EXIT_OPEN)) ||
4837 element == EL_EM_EXIT_OPEN ||
4838 element == EL_EM_STEEL_EXIT_OPEN)
4842 (element == EL_EXIT_OPEN ? EL_EXIT_CLOSING :
4843 element == EL_EM_EXIT_OPEN ? EL_EM_EXIT_CLOSING :
4844 element == EL_SP_EXIT_OPEN ? EL_SP_EXIT_CLOSING:
4845 element == EL_STEEL_EXIT_OPEN ? EL_STEEL_EXIT_CLOSING:
4846 EL_EM_STEEL_EXIT_CLOSING);
4848 PlayLevelSoundElementAction(x, y, element, ACTION_CLOSING);
4851 // player disappears
4852 DrawLevelField(x, y);
4855 for (i = 0; i < MAX_PLAYERS; i++)
4857 struct PlayerInfo *player = &stored_player[i];
4859 if (player->present)
4861 RemovePlayer(player);
4863 // player disappears
4864 DrawLevelField(player->jx, player->jy);
4869 PlaySound(SND_GAME_WINNING);
4872 if (setup.count_score_after_game)
4874 if (time != time_final)
4876 if (game_over_delay_1 > 0)
4878 game_over_delay_1--;
4883 int time_to_go = ABS(time_final - time);
4884 int time_count_dir = (time < time_final ? +1 : -1);
4886 if (time_to_go < time_count_steps)
4887 time_count_steps = 1;
4889 time += time_count_steps * time_count_dir;
4890 score += time_count_steps * time_score;
4892 // set final score to correct rounding differences after counting score
4893 if (time == time_final)
4894 score = score_final;
4896 game.LevelSolved_CountingTime = time;
4897 game.LevelSolved_CountingScore = score;
4899 game_panel_controls[GAME_PANEL_TIME].value = time;
4900 game_panel_controls[GAME_PANEL_SCORE].value = score;
4902 DisplayGameControlValues();
4904 if (time == time_final)
4905 StopSound(SND_GAME_LEVELTIME_BONUS);
4906 else if (setup.sound_loops)
4907 PlaySoundLoop(SND_GAME_LEVELTIME_BONUS);
4909 PlaySound(SND_GAME_LEVELTIME_BONUS);
4914 if (health != health_final)
4916 if (game_over_delay_2 > 0)
4918 game_over_delay_2--;
4923 int health_count_dir = (health < health_final ? +1 : -1);
4925 health += health_count_dir;
4926 score += time_score;
4928 game.LevelSolved_CountingHealth = health;
4929 game.LevelSolved_CountingScore = score;
4931 game_panel_controls[GAME_PANEL_HEALTH].value = health;
4932 game_panel_controls[GAME_PANEL_SCORE].value = score;
4934 DisplayGameControlValues();
4936 if (health == health_final)
4937 StopSound(SND_GAME_LEVELTIME_BONUS);
4938 else if (setup.sound_loops)
4939 PlaySoundLoop(SND_GAME_LEVELTIME_BONUS);
4941 PlaySound(SND_GAME_LEVELTIME_BONUS);
4947 game.panel.active = FALSE;
4949 if (game_over_delay_3 > 0)
4951 game_over_delay_3--;
4961 // used instead of "level_nr" (needed for network games)
4962 int last_level_nr = levelset.level_nr;
4964 game.LevelSolved_GameEnd = TRUE;
4966 if (game.LevelSolved_SaveTape)
4968 // make sure that request dialog to save tape does not open door again
4969 if (!global.use_envelope_request)
4970 CloseDoor(DOOR_CLOSE_1);
4972 SaveTapeChecked_LevelSolved(tape.level_nr); // ask to save tape
4974 // set unique basename for score tape (also saved in high score table)
4975 strcpy(tape.score_tape_basename, getScoreTapeBasename(setup.player_name));
4978 // if no tape is to be saved, close both doors simultaneously
4979 CloseDoor(DOOR_CLOSE_ALL);
4981 if (level_editor_test_game)
4983 SetGameStatus(GAME_MODE_MAIN);
4990 if (!game.LevelSolved_SaveScore)
4992 SetGameStatus(GAME_MODE_MAIN);
4999 if (level_nr == leveldir_current->handicap_level)
5001 leveldir_current->handicap_level++;
5003 SaveLevelSetup_SeriesInfo();
5006 // save score and score tape before potentially erasing tape below
5007 NewHighScore(last_level_nr);
5009 if (setup.increment_levels &&
5010 level_nr < leveldir_current->last_level &&
5013 level_nr++; // advance to next level
5014 TapeErase(); // start with empty tape
5016 if (setup.auto_play_next_level)
5018 LoadLevel(level_nr);
5020 SaveLevelSetup_SeriesInfo();
5024 if (scores.last_added >= 0 && setup.show_scores_after_game)
5026 SetGameStatus(GAME_MODE_SCORES);
5028 DrawHallOfFame(last_level_nr);
5030 else if (setup.auto_play_next_level && setup.increment_levels &&
5031 last_level_nr < leveldir_current->last_level &&
5034 StartGameActions(network.enabled, setup.autorecord, level.random_seed);
5038 SetGameStatus(GAME_MODE_MAIN);
5044 static int addScoreEntry(struct ScoreInfo *list, struct ScoreEntry *new_entry)
5046 boolean one_score_entry_per_name = !program.many_scores_per_name;
5049 if (strEqual(setup.player_name, EMPTY_PLAYER_NAME))
5052 for (i = 0; i < MAX_SCORE_ENTRIES; i++)
5054 struct ScoreEntry *entry = &list->entry[i];
5055 boolean score_is_better = (new_entry->score > entry->score);
5056 boolean score_is_equal = (new_entry->score == entry->score);
5057 boolean time_is_better = (new_entry->time < entry->time);
5058 boolean time_is_equal = (new_entry->time == entry->time);
5059 boolean better_by_score = (score_is_better ||
5060 (score_is_equal && time_is_better));
5061 boolean better_by_time = (time_is_better ||
5062 (time_is_equal && score_is_better));
5063 boolean is_better = (level.rate_time_over_score ? better_by_time :
5065 boolean entry_is_empty = (entry->score == 0 &&
5068 // prevent adding server score entries if also existing in local score file
5069 if (strEqual(new_entry->tape_basename, entry->tape_basename))
5072 if (is_better || entry_is_empty)
5074 // player has made it to the hall of fame
5076 if (i < MAX_SCORE_ENTRIES - 1)
5078 int m = MAX_SCORE_ENTRIES - 1;
5081 if (one_score_entry_per_name)
5083 for (l = i; l < MAX_SCORE_ENTRIES; l++)
5084 if (strEqual(list->entry[l].name, setup.player_name))
5087 if (m == i) // player's new highscore overwrites his old one
5091 for (l = m; l > i; l--)
5092 list->entry[l] = list->entry[l - 1];
5097 *entry = *new_entry;
5101 else if (one_score_entry_per_name &&
5102 strEqual(entry->name, setup.player_name))
5104 // player already in high score list with better score or time
5113 void NewHighScore(int level_nr)
5115 struct ScoreEntry new_entry = {{ 0 }}; // (prevent warning from GCC bug 53119)
5117 strncpy(new_entry.tape_basename, tape.score_tape_basename, MAX_FILENAME_LEN);
5118 strncpy(new_entry.name, setup.player_name, MAX_PLAYER_NAME_LEN);
5120 new_entry.score = game.score_final;
5121 new_entry.time = game.score_time_final;
5123 LoadScore(level_nr);
5125 scores.last_added = addScoreEntry(&scores, &new_entry);
5127 if (scores.last_added >= 0)
5129 SaveScore(level_nr);
5131 if (game.LevelSolved_SaveTape)
5133 SaveScoreTape(level_nr);
5134 SaveServerScore(level_nr);
5137 // store last added local score entry (before merging server scores)
5138 scores.last_added_local = scores.last_added;
5142 void MergeServerScore(void)
5146 for (i = 0; i < server_scores.num_entries; i++)
5148 int pos = addScoreEntry(&scores, &server_scores.entry[i]);
5150 if (pos >= 0 && pos <= scores.last_added)
5151 scores.last_added++;
5154 if (scores.last_added >= MAX_SCORE_ENTRIES)
5155 scores.last_added = -1;
5158 static int getElementMoveStepsizeExt(int x, int y, int direction)
5160 int element = Tile[x][y];
5161 int dx = (direction == MV_LEFT ? -1 : direction == MV_RIGHT ? +1 : 0);
5162 int dy = (direction == MV_UP ? -1 : direction == MV_DOWN ? +1 : 0);
5163 int horiz_move = (dx != 0);
5164 int sign = (horiz_move ? dx : dy);
5165 int step = sign * element_info[element].move_stepsize;
5167 // special values for move stepsize for spring and things on conveyor belt
5170 if (CAN_FALL(element) &&
5171 y < lev_fieldy - 1 && IS_BELT_ACTIVE(Tile[x][y + 1]))
5172 step = sign * MOVE_STEPSIZE_NORMAL / 2;
5173 else if (element == EL_SPRING)
5174 step = sign * MOVE_STEPSIZE_NORMAL * 2;
5180 static int getElementMoveStepsize(int x, int y)
5182 return getElementMoveStepsizeExt(x, y, MovDir[x][y]);
5185 void InitPlayerGfxAnimation(struct PlayerInfo *player, int action, int dir)
5187 if (player->GfxAction != action || player->GfxDir != dir)
5189 player->GfxAction = action;
5190 player->GfxDir = dir;
5192 player->StepFrame = 0;
5196 static void ResetGfxFrame(int x, int y)
5198 // profiling showed that "autotest" spends 10~20% of its time in this function
5199 if (DrawingDeactivatedField())
5202 int element = Tile[x][y];
5203 int graphic = el_act_dir2img(element, GfxAction[x][y], GfxDir[x][y]);
5205 if (graphic_info[graphic].anim_global_sync)
5206 GfxFrame[x][y] = FrameCounter;
5207 else if (ANIM_MODE(graphic) == ANIM_CE_VALUE)
5208 GfxFrame[x][y] = CustomValue[x][y];
5209 else if (ANIM_MODE(graphic) == ANIM_CE_SCORE)
5210 GfxFrame[x][y] = element_info[element].collect_score;
5211 else if (ANIM_MODE(graphic) == ANIM_CE_DELAY)
5212 GfxFrame[x][y] = ChangeDelay[x][y];
5215 static void ResetGfxAnimation(int x, int y)
5217 GfxAction[x][y] = ACTION_DEFAULT;
5218 GfxDir[x][y] = MovDir[x][y];
5221 ResetGfxFrame(x, y);
5224 static void ResetRandomAnimationValue(int x, int y)
5226 GfxRandom[x][y] = INIT_GFX_RANDOM();
5229 static void InitMovingField(int x, int y, int direction)
5231 int element = Tile[x][y];
5232 int dx = (direction == MV_LEFT ? -1 : direction == MV_RIGHT ? +1 : 0);
5233 int dy = (direction == MV_UP ? -1 : direction == MV_DOWN ? +1 : 0);
5236 boolean is_moving_before, is_moving_after;
5238 // check if element was/is moving or being moved before/after mode change
5239 is_moving_before = (WasJustMoving[x][y] != 0);
5240 is_moving_after = (getElementMoveStepsizeExt(x, y, direction) != 0);
5242 // reset animation only for moving elements which change direction of moving
5243 // or which just started or stopped moving
5244 // (else CEs with property "can move" / "not moving" are reset each frame)
5245 if (is_moving_before != is_moving_after ||
5246 direction != MovDir[x][y])
5247 ResetGfxAnimation(x, y);
5249 MovDir[x][y] = direction;
5250 GfxDir[x][y] = direction;
5252 GfxAction[x][y] = (!is_moving_after ? ACTION_WAITING :
5253 direction == MV_DOWN && CAN_FALL(element) ?
5254 ACTION_FALLING : ACTION_MOVING);
5256 // this is needed for CEs with property "can move" / "not moving"
5258 if (is_moving_after)
5260 if (Tile[newx][newy] == EL_EMPTY)
5261 Tile[newx][newy] = EL_BLOCKED;
5263 MovDir[newx][newy] = MovDir[x][y];
5265 CustomValue[newx][newy] = CustomValue[x][y];
5267 GfxFrame[newx][newy] = GfxFrame[x][y];
5268 GfxRandom[newx][newy] = GfxRandom[x][y];
5269 GfxAction[newx][newy] = GfxAction[x][y];
5270 GfxDir[newx][newy] = GfxDir[x][y];
5274 void Moving2Blocked(int x, int y, int *goes_to_x, int *goes_to_y)
5276 int direction = MovDir[x][y];
5277 int newx = x + (direction & MV_LEFT ? -1 : direction & MV_RIGHT ? +1 : 0);
5278 int newy = y + (direction & MV_UP ? -1 : direction & MV_DOWN ? +1 : 0);
5284 void Blocked2Moving(int x, int y, int *comes_from_x, int *comes_from_y)
5286 int oldx = x, oldy = y;
5287 int direction = MovDir[x][y];
5289 if (direction == MV_LEFT)
5291 else if (direction == MV_RIGHT)
5293 else if (direction == MV_UP)
5295 else if (direction == MV_DOWN)
5298 *comes_from_x = oldx;
5299 *comes_from_y = oldy;
5302 static int MovingOrBlocked2Element(int x, int y)
5304 int element = Tile[x][y];
5306 if (element == EL_BLOCKED)
5310 Blocked2Moving(x, y, &oldx, &oldy);
5311 return Tile[oldx][oldy];
5317 static int MovingOrBlocked2ElementIfNotLeaving(int x, int y)
5319 // like MovingOrBlocked2Element(), but if element is moving
5320 // and (x,y) is the field the moving element is just leaving,
5321 // return EL_BLOCKED instead of the element value
5322 int element = Tile[x][y];
5324 if (IS_MOVING(x, y))
5326 if (element == EL_BLOCKED)
5330 Blocked2Moving(x, y, &oldx, &oldy);
5331 return Tile[oldx][oldy];
5340 static void RemoveField(int x, int y)
5342 Tile[x][y] = EL_EMPTY;
5348 CustomValue[x][y] = 0;
5351 ChangeDelay[x][y] = 0;
5352 ChangePage[x][y] = -1;
5353 Pushed[x][y] = FALSE;
5355 GfxElement[x][y] = EL_UNDEFINED;
5356 GfxAction[x][y] = ACTION_DEFAULT;
5357 GfxDir[x][y] = MV_NONE;
5360 static void RemoveMovingField(int x, int y)
5362 int oldx = x, oldy = y, newx = x, newy = y;
5363 int element = Tile[x][y];
5364 int next_element = EL_UNDEFINED;
5366 if (element != EL_BLOCKED && !IS_MOVING(x, y))
5369 if (IS_MOVING(x, y))
5371 Moving2Blocked(x, y, &newx, &newy);
5373 if (Tile[newx][newy] != EL_BLOCKED)
5375 // element is moving, but target field is not free (blocked), but
5376 // already occupied by something different (example: acid pool);
5377 // in this case, only remove the moving field, but not the target
5379 RemoveField(oldx, oldy);
5381 Store[oldx][oldy] = Store2[oldx][oldy] = 0;
5383 TEST_DrawLevelField(oldx, oldy);
5388 else if (element == EL_BLOCKED)
5390 Blocked2Moving(x, y, &oldx, &oldy);
5391 if (!IS_MOVING(oldx, oldy))
5395 if (element == EL_BLOCKED &&
5396 (Tile[oldx][oldy] == EL_QUICKSAND_EMPTYING ||
5397 Tile[oldx][oldy] == EL_QUICKSAND_FAST_EMPTYING ||
5398 Tile[oldx][oldy] == EL_MAGIC_WALL_EMPTYING ||
5399 Tile[oldx][oldy] == EL_BD_MAGIC_WALL_EMPTYING ||
5400 Tile[oldx][oldy] == EL_DC_MAGIC_WALL_EMPTYING ||
5401 Tile[oldx][oldy] == EL_AMOEBA_DROPPING))
5402 next_element = get_next_element(Tile[oldx][oldy]);
5404 RemoveField(oldx, oldy);
5405 RemoveField(newx, newy);
5407 Store[oldx][oldy] = Store2[oldx][oldy] = 0;
5409 if (next_element != EL_UNDEFINED)
5410 Tile[oldx][oldy] = next_element;
5412 TEST_DrawLevelField(oldx, oldy);
5413 TEST_DrawLevelField(newx, newy);
5416 void DrawDynamite(int x, int y)
5418 int sx = SCREENX(x), sy = SCREENY(y);
5419 int graphic = el2img(Tile[x][y]);
5422 if (!IN_SCR_FIELD(sx, sy) || IS_PLAYER(x, y))
5425 if (IS_WALKABLE_INSIDE(Back[x][y]))
5429 DrawLevelElement(x, y, Back[x][y]);
5430 else if (Store[x][y])
5431 DrawLevelElement(x, y, Store[x][y]);
5432 else if (game.use_masked_elements)
5433 DrawLevelElement(x, y, EL_EMPTY);
5435 frame = getGraphicAnimationFrame(graphic, GfxFrame[x][y]);
5437 if (Back[x][y] || Store[x][y] || game.use_masked_elements)
5438 DrawGraphicThruMask(sx, sy, graphic, frame);
5440 DrawGraphic(sx, sy, graphic, frame);
5443 static void CheckDynamite(int x, int y)
5445 if (MovDelay[x][y] != 0) // dynamite is still waiting to explode
5449 if (MovDelay[x][y] != 0)
5452 PlayLevelSoundActionIfLoop(x, y, ACTION_ACTIVE);
5458 StopLevelSoundActionIfLoop(x, y, ACTION_ACTIVE);
5463 static void setMinimalPlayerBoundaries(int *sx1, int *sy1, int *sx2, int *sy2)
5465 boolean num_checked_players = 0;
5468 for (i = 0; i < MAX_PLAYERS; i++)
5470 if (stored_player[i].active)
5472 int sx = stored_player[i].jx;
5473 int sy = stored_player[i].jy;
5475 if (num_checked_players == 0)
5482 *sx1 = MIN(*sx1, sx);
5483 *sy1 = MIN(*sy1, sy);
5484 *sx2 = MAX(*sx2, sx);
5485 *sy2 = MAX(*sy2, sy);
5488 num_checked_players++;
5493 static boolean checkIfAllPlayersFitToScreen_RND(void)
5495 int sx1 = 0, sy1 = 0, sx2 = 0, sy2 = 0;
5497 setMinimalPlayerBoundaries(&sx1, &sy1, &sx2, &sy2);
5499 return (sx2 - sx1 < SCR_FIELDX &&
5500 sy2 - sy1 < SCR_FIELDY);
5503 static void setScreenCenteredToAllPlayers(int *sx, int *sy)
5505 int sx1 = scroll_x, sy1 = scroll_y, sx2 = scroll_x, sy2 = scroll_y;
5507 setMinimalPlayerBoundaries(&sx1, &sy1, &sx2, &sy2);
5509 *sx = (sx1 + sx2) / 2;
5510 *sy = (sy1 + sy2) / 2;
5513 static void DrawRelocateScreen(int old_x, int old_y, int x, int y, int move_dir,
5514 boolean center_screen, boolean quick_relocation)
5516 unsigned int frame_delay_value_old = GetVideoFrameDelay();
5517 boolean ffwd_delay = (tape.playing && tape.fast_forward);
5518 boolean no_delay = (tape.warp_forward);
5519 int frame_delay_value = (ffwd_delay ? FfwdFrameDelay : GameFrameDelay);
5520 int wait_delay_value = (no_delay ? 0 : frame_delay_value);
5521 int new_scroll_x, new_scroll_y;
5523 if (level.lazy_relocation && IN_VIS_FIELD(SCREENX(x), SCREENY(y)))
5525 // case 1: quick relocation inside visible screen (without scrolling)
5532 if (!level.shifted_relocation || center_screen)
5534 // relocation _with_ centering of screen
5536 new_scroll_x = SCROLL_POSITION_X(x);
5537 new_scroll_y = SCROLL_POSITION_Y(y);
5541 // relocation _without_ centering of screen
5543 int center_scroll_x = SCROLL_POSITION_X(old_x);
5544 int center_scroll_y = SCROLL_POSITION_Y(old_y);
5545 int offset_x = x + (scroll_x - center_scroll_x);
5546 int offset_y = y + (scroll_y - center_scroll_y);
5548 // for new screen position, apply previous offset to center position
5549 new_scroll_x = SCROLL_POSITION_X(offset_x);
5550 new_scroll_y = SCROLL_POSITION_Y(offset_y);
5553 if (quick_relocation)
5555 // case 2: quick relocation (redraw without visible scrolling)
5557 scroll_x = new_scroll_x;
5558 scroll_y = new_scroll_y;
5565 // case 3: visible relocation (with scrolling to new position)
5567 ScrollScreen(NULL, SCROLL_GO_ON); // scroll last frame to full tile
5569 SetVideoFrameDelay(wait_delay_value);
5571 while (scroll_x != new_scroll_x || scroll_y != new_scroll_y)
5573 int dx = (new_scroll_x < scroll_x ? +1 : new_scroll_x > scroll_x ? -1 : 0);
5574 int dy = (new_scroll_y < scroll_y ? +1 : new_scroll_y > scroll_y ? -1 : 0);
5576 if (dx == 0 && dy == 0) // no scrolling needed at all
5582 // set values for horizontal/vertical screen scrolling (half tile size)
5583 int dir_x = (dx != 0 ? MV_HORIZONTAL : 0);
5584 int dir_y = (dy != 0 ? MV_VERTICAL : 0);
5585 int pos_x = dx * TILEX / 2;
5586 int pos_y = dy * TILEY / 2;
5587 int fx = getFieldbufferOffsetX_RND(dir_x, pos_x);
5588 int fy = getFieldbufferOffsetY_RND(dir_y, pos_y);
5590 ScrollLevel(dx, dy);
5593 // scroll in two steps of half tile size to make things smoother
5594 BlitScreenToBitmapExt_RND(window, fx, fy);
5596 // scroll second step to align at full tile size
5597 BlitScreenToBitmap(window);
5603 SetVideoFrameDelay(frame_delay_value_old);
5606 static void RelocatePlayer(int jx, int jy, int el_player_raw)
5608 int el_player = GET_PLAYER_ELEMENT(el_player_raw);
5609 int player_nr = GET_PLAYER_NR(el_player);
5610 struct PlayerInfo *player = &stored_player[player_nr];
5611 boolean ffwd_delay = (tape.playing && tape.fast_forward);
5612 boolean no_delay = (tape.warp_forward);
5613 int frame_delay_value = (ffwd_delay ? FfwdFrameDelay : GameFrameDelay);
5614 int wait_delay_value = (no_delay ? 0 : frame_delay_value);
5615 int old_jx = player->jx;
5616 int old_jy = player->jy;
5617 int old_element = Tile[old_jx][old_jy];
5618 int element = Tile[jx][jy];
5619 boolean player_relocated = (old_jx != jx || old_jy != jy);
5621 int move_dir_horiz = (jx < old_jx ? MV_LEFT : jx > old_jx ? MV_RIGHT : 0);
5622 int move_dir_vert = (jy < old_jy ? MV_UP : jy > old_jy ? MV_DOWN : 0);
5623 int enter_side_horiz = MV_DIR_OPPOSITE(move_dir_horiz);
5624 int enter_side_vert = MV_DIR_OPPOSITE(move_dir_vert);
5625 int leave_side_horiz = move_dir_horiz;
5626 int leave_side_vert = move_dir_vert;
5627 int enter_side = enter_side_horiz | enter_side_vert;
5628 int leave_side = leave_side_horiz | leave_side_vert;
5630 if (player->buried) // do not reanimate dead player
5633 if (!player_relocated) // no need to relocate the player
5636 if (IS_PLAYER(jx, jy)) // player already placed at new position
5638 RemoveField(jx, jy); // temporarily remove newly placed player
5639 DrawLevelField(jx, jy);
5642 if (player->present)
5644 while (player->MovPos)
5646 ScrollPlayer(player, SCROLL_GO_ON);
5647 ScrollScreen(NULL, SCROLL_GO_ON);
5649 AdvanceFrameAndPlayerCounters(player->index_nr);
5653 BackToFront_WithFrameDelay(wait_delay_value);
5656 DrawPlayer(player); // needed here only to cleanup last field
5657 DrawLevelField(player->jx, player->jy); // remove player graphic
5659 player->is_moving = FALSE;
5662 if (IS_CUSTOM_ELEMENT(old_element))
5663 CheckElementChangeByPlayer(old_jx, old_jy, old_element,
5665 player->index_bit, leave_side);
5667 CheckTriggeredElementChangeByPlayer(old_jx, old_jy, old_element,
5669 player->index_bit, leave_side);
5671 Tile[jx][jy] = el_player;
5672 InitPlayerField(jx, jy, el_player, TRUE);
5674 /* "InitPlayerField()" above sets Tile[jx][jy] to EL_EMPTY, but it may be
5675 possible that the relocation target field did not contain a player element,
5676 but a walkable element, to which the new player was relocated -- in this
5677 case, restore that (already initialized!) element on the player field */
5678 if (!ELEM_IS_PLAYER(element)) // player may be set on walkable element
5680 Tile[jx][jy] = element; // restore previously existing element
5683 // only visually relocate centered player
5684 DrawRelocateScreen(old_jx, old_jy, player->jx, player->jy, player->MovDir,
5685 FALSE, level.instant_relocation);
5687 TestIfPlayerTouchesBadThing(jx, jy);
5688 TestIfPlayerTouchesCustomElement(jx, jy);
5690 if (IS_CUSTOM_ELEMENT(element))
5691 CheckElementChangeByPlayer(jx, jy, element, CE_ENTERED_BY_PLAYER,
5692 player->index_bit, enter_side);
5694 CheckTriggeredElementChangeByPlayer(jx, jy, element, CE_PLAYER_ENTERS_X,
5695 player->index_bit, enter_side);
5697 if (player->is_switching)
5699 /* ensure that relocation while still switching an element does not cause
5700 a new element to be treated as also switched directly after relocation
5701 (this is important for teleporter switches that teleport the player to
5702 a place where another teleporter switch is in the same direction, which
5703 would then incorrectly be treated as immediately switched before the
5704 direction key that caused the switch was released) */
5706 player->switch_x += jx - old_jx;
5707 player->switch_y += jy - old_jy;
5711 static void Explode(int ex, int ey, int phase, int mode)
5717 // !!! eliminate this variable !!!
5718 int delay = (game.emulation == EMU_SUPAPLEX ? 3 : 2);
5720 if (game.explosions_delayed)
5722 ExplodeField[ex][ey] = mode;
5726 if (phase == EX_PHASE_START) // initialize 'Store[][]' field
5728 int center_element = Tile[ex][ey];
5729 int artwork_element, explosion_element; // set these values later
5731 // remove things displayed in background while burning dynamite
5732 if (Back[ex][ey] != EL_EMPTY && !IS_INDESTRUCTIBLE(Back[ex][ey]))
5735 if (IS_MOVING(ex, ey) || IS_BLOCKED(ex, ey))
5737 // put moving element to center field (and let it explode there)
5738 center_element = MovingOrBlocked2Element(ex, ey);
5739 RemoveMovingField(ex, ey);
5740 Tile[ex][ey] = center_element;
5743 // now "center_element" is finally determined -- set related values now
5744 artwork_element = center_element; // for custom player artwork
5745 explosion_element = center_element; // for custom player artwork
5747 if (IS_PLAYER(ex, ey))
5749 int player_nr = GET_PLAYER_NR(StorePlayer[ex][ey]);
5751 artwork_element = stored_player[player_nr].artwork_element;
5753 if (level.use_explosion_element[player_nr])
5755 explosion_element = level.explosion_element[player_nr];
5756 artwork_element = explosion_element;
5760 if (mode == EX_TYPE_NORMAL ||
5761 mode == EX_TYPE_CENTER ||
5762 mode == EX_TYPE_CROSS)
5763 PlayLevelSoundElementAction(ex, ey, artwork_element, ACTION_EXPLODING);
5765 last_phase = element_info[explosion_element].explosion_delay + 1;
5767 for (y = ey - 1; y <= ey + 1; y++) for (x = ex - 1; x <= ex + 1; x++)
5769 int xx = x - ex + 1;
5770 int yy = y - ey + 1;
5773 if (!IN_LEV_FIELD(x, y) ||
5774 (mode & EX_TYPE_SINGLE_TILE && (x != ex || y != ey)) ||
5775 (mode == EX_TYPE_CROSS && (x != ex && y != ey)))
5778 element = Tile[x][y];
5780 if (IS_MOVING(x, y) || IS_BLOCKED(x, y))
5782 element = MovingOrBlocked2Element(x, y);
5784 if (!IS_EXPLOSION_PROOF(element))
5785 RemoveMovingField(x, y);
5788 // indestructible elements can only explode in center (but not flames)
5789 if ((IS_EXPLOSION_PROOF(element) && (x != ex || y != ey ||
5790 mode == EX_TYPE_BORDER)) ||
5791 element == EL_FLAMES)
5794 /* no idea why this was changed from 3.0.8 to 3.1.0 -- this causes buggy
5795 behaviour, for example when touching a yamyam that explodes to rocks
5796 with active deadly shield, a rock is created under the player !!! */
5797 // (case 1 (surely buggy): >= 3.1.0, case 2 (maybe buggy): <= 3.0.8)
5799 if (IS_PLAYER(x, y) && SHIELD_ON(PLAYERINFO(x, y)) &&
5800 (game.engine_version < VERSION_IDENT(3,1,0,0) ||
5801 (x == ex && y == ey && mode != EX_TYPE_BORDER)))
5803 if (IS_PLAYER(x, y) && SHIELD_ON(PLAYERINFO(x, y)))
5806 if (IS_ACTIVE_BOMB(element))
5808 // re-activate things under the bomb like gate or penguin
5809 Tile[x][y] = (Back[x][y] ? Back[x][y] : EL_EMPTY);
5816 // save walkable background elements while explosion on same tile
5817 if (IS_WALKABLE(element) && IS_INDESTRUCTIBLE(element) &&
5818 (x != ex || y != ey || mode == EX_TYPE_BORDER))
5819 Back[x][y] = element;
5821 // ignite explodable elements reached by other explosion
5822 if (element == EL_EXPLOSION)
5823 element = Store2[x][y];
5825 if (AmoebaNr[x][y] &&
5826 (element == EL_AMOEBA_FULL ||
5827 element == EL_BD_AMOEBA ||
5828 element == EL_AMOEBA_GROWING))
5830 AmoebaCnt[AmoebaNr[x][y]]--;
5831 AmoebaCnt2[AmoebaNr[x][y]]--;
5836 if (IS_PLAYER(ex, ey) && !PLAYER_EXPLOSION_PROTECTED(ex, ey))
5838 int player_nr = StorePlayer[ex][ey] - EL_PLAYER_1;
5840 Store[x][y] = EL_PLAYER_IS_EXPLODING_1 + player_nr;
5842 if (PLAYERINFO(ex, ey)->use_murphy)
5843 Store[x][y] = EL_EMPTY;
5846 // !!! check this case -- currently needed for rnd_rado_negundo_v,
5847 // !!! levels 015 018 019 020 021 022 023 026 027 028 !!!
5848 else if (ELEM_IS_PLAYER(center_element))
5849 Store[x][y] = EL_EMPTY;
5850 else if (center_element == EL_YAMYAM)
5851 Store[x][y] = level.yamyam_content[game.yamyam_content_nr].e[xx][yy];
5852 else if (element_info[center_element].content.e[xx][yy] != EL_EMPTY)
5853 Store[x][y] = element_info[center_element].content.e[xx][yy];
5855 // needed because EL_BD_BUTTERFLY is not defined as "CAN_EXPLODE"
5856 // (killing EL_BD_BUTTERFLY with dynamite would result in BD diamond
5857 // otherwise) -- FIX THIS !!!
5858 else if (!CAN_EXPLODE(element) && element != EL_BD_BUTTERFLY)
5859 Store[x][y] = element_info[element].content.e[1][1];
5861 else if (!CAN_EXPLODE(element))
5862 Store[x][y] = element_info[element].content.e[1][1];
5865 Store[x][y] = EL_EMPTY;
5867 if (x != ex || y != ey || mode == EX_TYPE_BORDER ||
5868 center_element == EL_AMOEBA_TO_DIAMOND)
5869 Store2[x][y] = element;
5871 Tile[x][y] = EL_EXPLOSION;
5872 GfxElement[x][y] = artwork_element;
5874 ExplodePhase[x][y] = 1;
5875 ExplodeDelay[x][y] = last_phase;
5880 if (center_element == EL_YAMYAM)
5881 game.yamyam_content_nr =
5882 (game.yamyam_content_nr + 1) % level.num_yamyam_contents;
5894 GfxFrame[x][y] = 0; // restart explosion animation
5896 last_phase = ExplodeDelay[x][y];
5898 ExplodePhase[x][y] = (phase < last_phase ? phase + 1 : 0);
5900 // this can happen if the player leaves an explosion just in time
5901 if (GfxElement[x][y] == EL_UNDEFINED)
5902 GfxElement[x][y] = EL_EMPTY;
5904 border_element = Store2[x][y];
5905 if (IS_PLAYER(x, y) && !PLAYER_EXPLOSION_PROTECTED(x, y))
5906 border_element = StorePlayer[x][y];
5908 if (phase == element_info[border_element].ignition_delay ||
5909 phase == last_phase)
5911 boolean border_explosion = FALSE;
5913 if (IS_PLAYER(x, y) && PLAYERINFO(x, y)->present &&
5914 !PLAYER_EXPLOSION_PROTECTED(x, y))
5916 KillPlayerUnlessExplosionProtected(x, y);
5917 border_explosion = TRUE;
5919 else if (CAN_EXPLODE_BY_EXPLOSION(border_element))
5921 Tile[x][y] = Store2[x][y];
5924 border_explosion = TRUE;
5926 else if (border_element == EL_AMOEBA_TO_DIAMOND)
5928 AmoebaToDiamond(x, y);
5930 border_explosion = TRUE;
5933 // if an element just explodes due to another explosion (chain-reaction),
5934 // do not immediately end the new explosion when it was the last frame of
5935 // the explosion (as it would be done in the following "if"-statement!)
5936 if (border_explosion && phase == last_phase)
5940 if (phase == last_phase)
5944 element = Tile[x][y] = Store[x][y];
5945 Store[x][y] = Store2[x][y] = 0;
5946 GfxElement[x][y] = EL_UNDEFINED;
5948 // player can escape from explosions and might therefore be still alive
5949 if (element >= EL_PLAYER_IS_EXPLODING_1 &&
5950 element <= EL_PLAYER_IS_EXPLODING_4)
5952 int player_nr = element - EL_PLAYER_IS_EXPLODING_1;
5953 int explosion_element = EL_PLAYER_1 + player_nr;
5954 int xx = MIN(MAX(0, x - stored_player[player_nr].jx + 1), 2);
5955 int yy = MIN(MAX(0, y - stored_player[player_nr].jy + 1), 2);
5957 if (level.use_explosion_element[player_nr])
5958 explosion_element = level.explosion_element[player_nr];
5960 Tile[x][y] = (stored_player[player_nr].active ? EL_EMPTY :
5961 element_info[explosion_element].content.e[xx][yy]);
5964 // restore probably existing indestructible background element
5965 if (Back[x][y] && IS_INDESTRUCTIBLE(Back[x][y]))
5966 element = Tile[x][y] = Back[x][y];
5969 MovDir[x][y] = MovPos[x][y] = MovDelay[x][y] = 0;
5970 GfxDir[x][y] = MV_NONE;
5971 ChangeDelay[x][y] = 0;
5972 ChangePage[x][y] = -1;
5974 CustomValue[x][y] = 0;
5976 InitField_WithBug2(x, y, FALSE);
5978 TEST_DrawLevelField(x, y);
5980 TestIfElementTouchesCustomElement(x, y);
5982 if (GFX_CRUMBLED(element))
5983 TEST_DrawLevelFieldCrumbledNeighbours(x, y);
5985 if (IS_PLAYER(x, y) && !PLAYERINFO(x, y)->present)
5986 StorePlayer[x][y] = 0;
5988 if (ELEM_IS_PLAYER(element))
5989 RelocatePlayer(x, y, element);
5991 else if (IN_SCR_FIELD(SCREENX(x), SCREENY(y)))
5993 int graphic = el_act2img(GfxElement[x][y], ACTION_EXPLODING);
5994 int frame = getGraphicAnimationFrame(graphic, GfxFrame[x][y]);
5997 TEST_DrawLevelFieldCrumbled(x, y);
5999 if (IS_WALKABLE_OVER(Back[x][y]) && Back[x][y] != EL_EMPTY)
6001 DrawLevelElement(x, y, Back[x][y]);
6002 DrawGraphicThruMask(SCREENX(x), SCREENY(y), graphic, frame);
6004 else if (IS_WALKABLE_UNDER(Back[x][y]))
6006 DrawGraphic(SCREENX(x), SCREENY(y), graphic, frame);
6007 DrawLevelElementThruMask(x, y, Back[x][y]);
6009 else if (!IS_WALKABLE_INSIDE(Back[x][y]))
6010 DrawScreenGraphic(SCREENX(x), SCREENY(y), graphic, frame);
6014 static void DynaExplode(int ex, int ey)
6017 int dynabomb_element = Tile[ex][ey];
6018 int dynabomb_size = 1;
6019 boolean dynabomb_xl = FALSE;
6020 struct PlayerInfo *player;
6021 static int xy[4][2] =
6029 if (IS_ACTIVE_BOMB(dynabomb_element))
6031 player = &stored_player[dynabomb_element - EL_DYNABOMB_PLAYER_1_ACTIVE];
6032 dynabomb_size = player->dynabomb_size;
6033 dynabomb_xl = player->dynabomb_xl;
6034 player->dynabombs_left++;
6037 Explode(ex, ey, EX_PHASE_START, EX_TYPE_CENTER);
6039 for (i = 0; i < NUM_DIRECTIONS; i++)
6041 for (j = 1; j <= dynabomb_size; j++)
6043 int x = ex + j * xy[i][0];
6044 int y = ey + j * xy[i][1];
6047 if (!IN_LEV_FIELD(x, y) || IS_INDESTRUCTIBLE(Tile[x][y]))
6050 element = Tile[x][y];
6052 // do not restart explosions of fields with active bombs
6053 if (element == EL_EXPLOSION && IS_ACTIVE_BOMB(Store2[x][y]))
6056 Explode(x, y, EX_PHASE_START, EX_TYPE_BORDER);
6058 if (element != EL_EMPTY && element != EL_EXPLOSION &&
6059 !IS_DIGGABLE(element) && !dynabomb_xl)
6065 void Bang(int x, int y)
6067 int element = MovingOrBlocked2Element(x, y);
6068 int explosion_type = EX_TYPE_NORMAL;
6070 if (IS_PLAYER(x, y) && !PLAYER_EXPLOSION_PROTECTED(x, y))
6072 struct PlayerInfo *player = PLAYERINFO(x, y);
6074 element = Tile[x][y] = player->initial_element;
6076 if (level.use_explosion_element[player->index_nr])
6078 int explosion_element = level.explosion_element[player->index_nr];
6080 if (element_info[explosion_element].explosion_type == EXPLODES_CROSS)
6081 explosion_type = EX_TYPE_CROSS;
6082 else if (element_info[explosion_element].explosion_type == EXPLODES_1X1)
6083 explosion_type = EX_TYPE_CENTER;
6091 case EL_BD_BUTTERFLY:
6094 case EL_DARK_YAMYAM:
6098 RaiseScoreElement(element);
6101 case EL_DYNABOMB_PLAYER_1_ACTIVE:
6102 case EL_DYNABOMB_PLAYER_2_ACTIVE:
6103 case EL_DYNABOMB_PLAYER_3_ACTIVE:
6104 case EL_DYNABOMB_PLAYER_4_ACTIVE:
6105 case EL_DYNABOMB_INCREASE_NUMBER:
6106 case EL_DYNABOMB_INCREASE_SIZE:
6107 case EL_DYNABOMB_INCREASE_POWER:
6108 explosion_type = EX_TYPE_DYNA;
6111 case EL_DC_LANDMINE:
6112 explosion_type = EX_TYPE_CENTER;
6117 case EL_LAMP_ACTIVE:
6118 case EL_AMOEBA_TO_DIAMOND:
6119 if (!IS_PLAYER(x, y)) // penguin and player may be at same field
6120 explosion_type = EX_TYPE_CENTER;
6124 if (element_info[element].explosion_type == EXPLODES_CROSS)
6125 explosion_type = EX_TYPE_CROSS;
6126 else if (element_info[element].explosion_type == EXPLODES_1X1)
6127 explosion_type = EX_TYPE_CENTER;
6131 if (explosion_type == EX_TYPE_DYNA)
6134 Explode(x, y, EX_PHASE_START, explosion_type);
6136 CheckTriggeredElementChange(x, y, element, CE_EXPLOSION_OF_X);
6139 static void SplashAcid(int x, int y)
6141 if (IN_LEV_FIELD(x - 1, y - 1) && IS_FREE(x - 1, y - 1) &&
6142 (!IN_LEV_FIELD(x - 1, y - 2) ||
6143 !CAN_FALL(MovingOrBlocked2Element(x - 1, y - 2))))
6144 Tile[x - 1][y - 1] = EL_ACID_SPLASH_LEFT;
6146 if (IN_LEV_FIELD(x + 1, y - 1) && IS_FREE(x + 1, y - 1) &&
6147 (!IN_LEV_FIELD(x + 1, y - 2) ||
6148 !CAN_FALL(MovingOrBlocked2Element(x + 1, y - 2))))
6149 Tile[x + 1][y - 1] = EL_ACID_SPLASH_RIGHT;
6151 PlayLevelSound(x, y, SND_ACID_SPLASHING);
6154 static void InitBeltMovement(void)
6156 static int belt_base_element[4] =
6158 EL_CONVEYOR_BELT_1_LEFT,
6159 EL_CONVEYOR_BELT_2_LEFT,
6160 EL_CONVEYOR_BELT_3_LEFT,
6161 EL_CONVEYOR_BELT_4_LEFT
6163 static int belt_base_active_element[4] =
6165 EL_CONVEYOR_BELT_1_LEFT_ACTIVE,
6166 EL_CONVEYOR_BELT_2_LEFT_ACTIVE,
6167 EL_CONVEYOR_BELT_3_LEFT_ACTIVE,
6168 EL_CONVEYOR_BELT_4_LEFT_ACTIVE
6173 // set frame order for belt animation graphic according to belt direction
6174 for (i = 0; i < NUM_BELTS; i++)
6178 for (j = 0; j < NUM_BELT_PARTS; j++)
6180 int element = belt_base_active_element[belt_nr] + j;
6181 int graphic_1 = el2img(element);
6182 int graphic_2 = el2panelimg(element);
6184 if (game.belt_dir[i] == MV_LEFT)
6186 graphic_info[graphic_1].anim_mode &= ~ANIM_REVERSE;
6187 graphic_info[graphic_2].anim_mode &= ~ANIM_REVERSE;
6191 graphic_info[graphic_1].anim_mode |= ANIM_REVERSE;
6192 graphic_info[graphic_2].anim_mode |= ANIM_REVERSE;
6197 SCAN_PLAYFIELD(x, y)
6199 int element = Tile[x][y];
6201 for (i = 0; i < NUM_BELTS; i++)
6203 if (IS_BELT(element) && game.belt_dir[i] != MV_NONE)
6205 int e_belt_nr = getBeltNrFromBeltElement(element);
6208 if (e_belt_nr == belt_nr)
6210 int belt_part = Tile[x][y] - belt_base_element[belt_nr];
6212 Tile[x][y] = belt_base_active_element[belt_nr] + belt_part;
6219 static void ToggleBeltSwitch(int x, int y)
6221 static int belt_base_element[4] =
6223 EL_CONVEYOR_BELT_1_LEFT,
6224 EL_CONVEYOR_BELT_2_LEFT,
6225 EL_CONVEYOR_BELT_3_LEFT,
6226 EL_CONVEYOR_BELT_4_LEFT
6228 static int belt_base_active_element[4] =
6230 EL_CONVEYOR_BELT_1_LEFT_ACTIVE,
6231 EL_CONVEYOR_BELT_2_LEFT_ACTIVE,
6232 EL_CONVEYOR_BELT_3_LEFT_ACTIVE,
6233 EL_CONVEYOR_BELT_4_LEFT_ACTIVE
6235 static int belt_base_switch_element[4] =
6237 EL_CONVEYOR_BELT_1_SWITCH_LEFT,
6238 EL_CONVEYOR_BELT_2_SWITCH_LEFT,
6239 EL_CONVEYOR_BELT_3_SWITCH_LEFT,
6240 EL_CONVEYOR_BELT_4_SWITCH_LEFT
6242 static int belt_move_dir[4] =
6250 int element = Tile[x][y];
6251 int belt_nr = getBeltNrFromBeltSwitchElement(element);
6252 int belt_dir_nr = (game.belt_dir_nr[belt_nr] + 1) % 4;
6253 int belt_dir = belt_move_dir[belt_dir_nr];
6256 if (!IS_BELT_SWITCH(element))
6259 game.belt_dir_nr[belt_nr] = belt_dir_nr;
6260 game.belt_dir[belt_nr] = belt_dir;
6262 if (belt_dir_nr == 3)
6265 // set frame order for belt animation graphic according to belt direction
6266 for (i = 0; i < NUM_BELT_PARTS; i++)
6268 int element = belt_base_active_element[belt_nr] + i;
6269 int graphic_1 = el2img(element);
6270 int graphic_2 = el2panelimg(element);
6272 if (belt_dir == MV_LEFT)
6274 graphic_info[graphic_1].anim_mode &= ~ANIM_REVERSE;
6275 graphic_info[graphic_2].anim_mode &= ~ANIM_REVERSE;
6279 graphic_info[graphic_1].anim_mode |= ANIM_REVERSE;
6280 graphic_info[graphic_2].anim_mode |= ANIM_REVERSE;
6284 SCAN_PLAYFIELD(xx, yy)
6286 int element = Tile[xx][yy];
6288 if (IS_BELT_SWITCH(element))
6290 int e_belt_nr = getBeltNrFromBeltSwitchElement(element);
6292 if (e_belt_nr == belt_nr)
6294 Tile[xx][yy] = belt_base_switch_element[belt_nr] + belt_dir_nr;
6295 TEST_DrawLevelField(xx, yy);
6298 else if (IS_BELT(element) && belt_dir != MV_NONE)
6300 int e_belt_nr = getBeltNrFromBeltElement(element);
6302 if (e_belt_nr == belt_nr)
6304 int belt_part = Tile[xx][yy] - belt_base_element[belt_nr];
6306 Tile[xx][yy] = belt_base_active_element[belt_nr] + belt_part;
6307 TEST_DrawLevelField(xx, yy);
6310 else if (IS_BELT_ACTIVE(element) && belt_dir == MV_NONE)
6312 int e_belt_nr = getBeltNrFromBeltActiveElement(element);
6314 if (e_belt_nr == belt_nr)
6316 int belt_part = Tile[xx][yy] - belt_base_active_element[belt_nr];
6318 Tile[xx][yy] = belt_base_element[belt_nr] + belt_part;
6319 TEST_DrawLevelField(xx, yy);
6325 static void ToggleSwitchgateSwitch(int x, int y)
6329 game.switchgate_pos = !game.switchgate_pos;
6331 SCAN_PLAYFIELD(xx, yy)
6333 int element = Tile[xx][yy];
6335 if (element == EL_SWITCHGATE_SWITCH_UP)
6337 Tile[xx][yy] = EL_SWITCHGATE_SWITCH_DOWN;
6338 TEST_DrawLevelField(xx, yy);
6340 else if (element == EL_SWITCHGATE_SWITCH_DOWN)
6342 Tile[xx][yy] = EL_SWITCHGATE_SWITCH_UP;
6343 TEST_DrawLevelField(xx, yy);
6345 else if (element == EL_DC_SWITCHGATE_SWITCH_UP)
6347 Tile[xx][yy] = EL_DC_SWITCHGATE_SWITCH_DOWN;
6348 TEST_DrawLevelField(xx, yy);
6350 else if (element == EL_DC_SWITCHGATE_SWITCH_DOWN)
6352 Tile[xx][yy] = EL_DC_SWITCHGATE_SWITCH_UP;
6353 TEST_DrawLevelField(xx, yy);
6355 else if (element == EL_SWITCHGATE_OPEN ||
6356 element == EL_SWITCHGATE_OPENING)
6358 Tile[xx][yy] = EL_SWITCHGATE_CLOSING;
6360 PlayLevelSoundAction(xx, yy, ACTION_CLOSING);
6362 else if (element == EL_SWITCHGATE_CLOSED ||
6363 element == EL_SWITCHGATE_CLOSING)
6365 Tile[xx][yy] = EL_SWITCHGATE_OPENING;
6367 PlayLevelSoundAction(xx, yy, ACTION_OPENING);
6372 static int getInvisibleActiveFromInvisibleElement(int element)
6374 return (element == EL_INVISIBLE_STEELWALL ? EL_INVISIBLE_STEELWALL_ACTIVE :
6375 element == EL_INVISIBLE_WALL ? EL_INVISIBLE_WALL_ACTIVE :
6376 element == EL_INVISIBLE_SAND ? EL_INVISIBLE_SAND_ACTIVE :
6380 static int getInvisibleFromInvisibleActiveElement(int element)
6382 return (element == EL_INVISIBLE_STEELWALL_ACTIVE ? EL_INVISIBLE_STEELWALL :
6383 element == EL_INVISIBLE_WALL_ACTIVE ? EL_INVISIBLE_WALL :
6384 element == EL_INVISIBLE_SAND_ACTIVE ? EL_INVISIBLE_SAND :
6388 static void RedrawAllLightSwitchesAndInvisibleElements(void)
6392 SCAN_PLAYFIELD(x, y)
6394 int element = Tile[x][y];
6396 if (element == EL_LIGHT_SWITCH &&
6397 game.light_time_left > 0)
6399 Tile[x][y] = EL_LIGHT_SWITCH_ACTIVE;
6400 TEST_DrawLevelField(x, y);
6402 else if (element == EL_LIGHT_SWITCH_ACTIVE &&
6403 game.light_time_left == 0)
6405 Tile[x][y] = EL_LIGHT_SWITCH;
6406 TEST_DrawLevelField(x, y);
6408 else if (element == EL_EMC_DRIPPER &&
6409 game.light_time_left > 0)
6411 Tile[x][y] = EL_EMC_DRIPPER_ACTIVE;
6412 TEST_DrawLevelField(x, y);
6414 else if (element == EL_EMC_DRIPPER_ACTIVE &&
6415 game.light_time_left == 0)
6417 Tile[x][y] = EL_EMC_DRIPPER;
6418 TEST_DrawLevelField(x, y);
6420 else if (element == EL_INVISIBLE_STEELWALL ||
6421 element == EL_INVISIBLE_WALL ||
6422 element == EL_INVISIBLE_SAND)
6424 if (game.light_time_left > 0)
6425 Tile[x][y] = getInvisibleActiveFromInvisibleElement(element);
6427 TEST_DrawLevelField(x, y);
6429 // uncrumble neighbour fields, if needed
6430 if (element == EL_INVISIBLE_SAND)
6431 TEST_DrawLevelFieldCrumbledNeighbours(x, y);
6433 else if (element == EL_INVISIBLE_STEELWALL_ACTIVE ||
6434 element == EL_INVISIBLE_WALL_ACTIVE ||
6435 element == EL_INVISIBLE_SAND_ACTIVE)
6437 if (game.light_time_left == 0)
6438 Tile[x][y] = getInvisibleFromInvisibleActiveElement(element);
6440 TEST_DrawLevelField(x, y);
6442 // re-crumble neighbour fields, if needed
6443 if (element == EL_INVISIBLE_SAND)
6444 TEST_DrawLevelFieldCrumbledNeighbours(x, y);
6449 static void RedrawAllInvisibleElementsForLenses(void)
6453 SCAN_PLAYFIELD(x, y)
6455 int element = Tile[x][y];
6457 if (element == EL_EMC_DRIPPER &&
6458 game.lenses_time_left > 0)
6460 Tile[x][y] = EL_EMC_DRIPPER_ACTIVE;
6461 TEST_DrawLevelField(x, y);
6463 else if (element == EL_EMC_DRIPPER_ACTIVE &&
6464 game.lenses_time_left == 0)
6466 Tile[x][y] = EL_EMC_DRIPPER;
6467 TEST_DrawLevelField(x, y);
6469 else if (element == EL_INVISIBLE_STEELWALL ||
6470 element == EL_INVISIBLE_WALL ||
6471 element == EL_INVISIBLE_SAND)
6473 if (game.lenses_time_left > 0)
6474 Tile[x][y] = getInvisibleActiveFromInvisibleElement(element);
6476 TEST_DrawLevelField(x, y);
6478 // uncrumble neighbour fields, if needed
6479 if (element == EL_INVISIBLE_SAND)
6480 TEST_DrawLevelFieldCrumbledNeighbours(x, y);
6482 else if (element == EL_INVISIBLE_STEELWALL_ACTIVE ||
6483 element == EL_INVISIBLE_WALL_ACTIVE ||
6484 element == EL_INVISIBLE_SAND_ACTIVE)
6486 if (game.lenses_time_left == 0)
6487 Tile[x][y] = getInvisibleFromInvisibleActiveElement(element);
6489 TEST_DrawLevelField(x, y);
6491 // re-crumble neighbour fields, if needed
6492 if (element == EL_INVISIBLE_SAND)
6493 TEST_DrawLevelFieldCrumbledNeighbours(x, y);
6498 static void RedrawAllInvisibleElementsForMagnifier(void)
6502 SCAN_PLAYFIELD(x, y)
6504 int element = Tile[x][y];
6506 if (element == EL_EMC_FAKE_GRASS &&
6507 game.magnify_time_left > 0)
6509 Tile[x][y] = EL_EMC_FAKE_GRASS_ACTIVE;
6510 TEST_DrawLevelField(x, y);
6512 else if (element == EL_EMC_FAKE_GRASS_ACTIVE &&
6513 game.magnify_time_left == 0)
6515 Tile[x][y] = EL_EMC_FAKE_GRASS;
6516 TEST_DrawLevelField(x, y);
6518 else if (IS_GATE_GRAY(element) &&
6519 game.magnify_time_left > 0)
6521 Tile[x][y] = (IS_RND_GATE_GRAY(element) ?
6522 element - EL_GATE_1_GRAY + EL_GATE_1_GRAY_ACTIVE :
6523 IS_EM_GATE_GRAY(element) ?
6524 element - EL_EM_GATE_1_GRAY + EL_EM_GATE_1_GRAY_ACTIVE :
6525 IS_EMC_GATE_GRAY(element) ?
6526 element - EL_EMC_GATE_5_GRAY + EL_EMC_GATE_5_GRAY_ACTIVE :
6527 IS_DC_GATE_GRAY(element) ?
6528 EL_DC_GATE_WHITE_GRAY_ACTIVE :
6530 TEST_DrawLevelField(x, y);
6532 else if (IS_GATE_GRAY_ACTIVE(element) &&
6533 game.magnify_time_left == 0)
6535 Tile[x][y] = (IS_RND_GATE_GRAY_ACTIVE(element) ?
6536 element - EL_GATE_1_GRAY_ACTIVE + EL_GATE_1_GRAY :
6537 IS_EM_GATE_GRAY_ACTIVE(element) ?
6538 element - EL_EM_GATE_1_GRAY_ACTIVE + EL_EM_GATE_1_GRAY :
6539 IS_EMC_GATE_GRAY_ACTIVE(element) ?
6540 element - EL_EMC_GATE_5_GRAY_ACTIVE + EL_EMC_GATE_5_GRAY :
6541 IS_DC_GATE_GRAY_ACTIVE(element) ?
6542 EL_DC_GATE_WHITE_GRAY :
6544 TEST_DrawLevelField(x, y);
6549 static void ToggleLightSwitch(int x, int y)
6551 int element = Tile[x][y];
6553 game.light_time_left =
6554 (element == EL_LIGHT_SWITCH ?
6555 level.time_light * FRAMES_PER_SECOND : 0);
6557 RedrawAllLightSwitchesAndInvisibleElements();
6560 static void ActivateTimegateSwitch(int x, int y)
6564 game.timegate_time_left = level.time_timegate * FRAMES_PER_SECOND;
6566 SCAN_PLAYFIELD(xx, yy)
6568 int element = Tile[xx][yy];
6570 if (element == EL_TIMEGATE_CLOSED ||
6571 element == EL_TIMEGATE_CLOSING)
6573 Tile[xx][yy] = EL_TIMEGATE_OPENING;
6574 PlayLevelSound(xx, yy, SND_CLASS_TIMEGATE_OPENING);
6578 else if (element == EL_TIMEGATE_SWITCH_ACTIVE)
6580 Tile[xx][yy] = EL_TIMEGATE_SWITCH;
6581 TEST_DrawLevelField(xx, yy);
6587 Tile[x][y] = (Tile[x][y] == EL_TIMEGATE_SWITCH ? EL_TIMEGATE_SWITCH_ACTIVE :
6588 EL_DC_TIMEGATE_SWITCH_ACTIVE);
6591 static void Impact(int x, int y)
6593 boolean last_line = (y == lev_fieldy - 1);
6594 boolean object_hit = FALSE;
6595 boolean impact = (last_line || object_hit);
6596 int element = Tile[x][y];
6597 int smashed = EL_STEELWALL;
6599 if (!last_line) // check if element below was hit
6601 if (Tile[x][y + 1] == EL_PLAYER_IS_LEAVING)
6604 object_hit = (!IS_FREE(x, y + 1) && (!IS_MOVING(x, y + 1) ||
6605 MovDir[x][y + 1] != MV_DOWN ||
6606 MovPos[x][y + 1] <= TILEY / 2));
6608 // do not smash moving elements that left the smashed field in time
6609 if (game.engine_version >= VERSION_IDENT(2,2,0,7) && IS_MOVING(x, y + 1) &&
6610 ABS(MovPos[x][y + 1] + getElementMoveStepsize(x, y + 1)) >= TILEX)
6613 #if USE_QUICKSAND_IMPACT_BUGFIX
6614 if (Tile[x][y + 1] == EL_QUICKSAND_EMPTYING && object_hit == FALSE)
6616 RemoveMovingField(x, y + 1);
6617 Tile[x][y + 1] = EL_QUICKSAND_EMPTY;
6618 Tile[x][y + 2] = EL_ROCK;
6619 TEST_DrawLevelField(x, y + 2);
6624 if (Tile[x][y + 1] == EL_QUICKSAND_FAST_EMPTYING && object_hit == FALSE)
6626 RemoveMovingField(x, y + 1);
6627 Tile[x][y + 1] = EL_QUICKSAND_FAST_EMPTY;
6628 Tile[x][y + 2] = EL_ROCK;
6629 TEST_DrawLevelField(x, y + 2);
6636 smashed = MovingOrBlocked2Element(x, y + 1);
6638 impact = (last_line || object_hit);
6641 if (!last_line && smashed == EL_ACID) // element falls into acid
6643 SplashAcid(x, y + 1);
6647 // !!! not sufficient for all cases -- see EL_PEARL below !!!
6648 // only reset graphic animation if graphic really changes after impact
6650 el_act_dir2img(element, GfxAction[x][y], MV_DOWN) != el2img(element))
6652 ResetGfxAnimation(x, y);
6653 TEST_DrawLevelField(x, y);
6656 if (impact && CAN_EXPLODE_IMPACT(element))
6661 else if (impact && element == EL_PEARL &&
6662 smashed != EL_DC_MAGIC_WALL && smashed != EL_DC_MAGIC_WALL_ACTIVE)
6664 ResetGfxAnimation(x, y);
6666 Tile[x][y] = EL_PEARL_BREAKING;
6667 PlayLevelSound(x, y, SND_PEARL_BREAKING);
6670 else if (impact && CheckElementChange(x, y, element, smashed, CE_IMPACT))
6672 PlayLevelSoundElementAction(x, y, element, ACTION_IMPACT);
6677 if (impact && element == EL_AMOEBA_DROP)
6679 if (object_hit && IS_PLAYER(x, y + 1))
6680 KillPlayerUnlessEnemyProtected(x, y + 1);
6681 else if (object_hit && smashed == EL_PENGUIN)
6685 Tile[x][y] = EL_AMOEBA_GROWING;
6686 Store[x][y] = EL_AMOEBA_WET;
6688 ResetRandomAnimationValue(x, y);
6693 if (object_hit) // check which object was hit
6695 if ((CAN_PASS_MAGIC_WALL(element) &&
6696 (smashed == EL_MAGIC_WALL ||
6697 smashed == EL_BD_MAGIC_WALL)) ||
6698 (CAN_PASS_DC_MAGIC_WALL(element) &&
6699 smashed == EL_DC_MAGIC_WALL))
6702 int activated_magic_wall =
6703 (smashed == EL_MAGIC_WALL ? EL_MAGIC_WALL_ACTIVE :
6704 smashed == EL_BD_MAGIC_WALL ? EL_BD_MAGIC_WALL_ACTIVE :
6705 EL_DC_MAGIC_WALL_ACTIVE);
6707 // activate magic wall / mill
6708 SCAN_PLAYFIELD(xx, yy)
6710 if (Tile[xx][yy] == smashed)
6711 Tile[xx][yy] = activated_magic_wall;
6714 game.magic_wall_time_left = level.time_magic_wall * FRAMES_PER_SECOND;
6715 game.magic_wall_active = TRUE;
6717 PlayLevelSound(x, y, (smashed == EL_MAGIC_WALL ?
6718 SND_MAGIC_WALL_ACTIVATING :
6719 smashed == EL_BD_MAGIC_WALL ?
6720 SND_BD_MAGIC_WALL_ACTIVATING :
6721 SND_DC_MAGIC_WALL_ACTIVATING));
6724 if (IS_PLAYER(x, y + 1))
6726 if (CAN_SMASH_PLAYER(element))
6728 KillPlayerUnlessEnemyProtected(x, y + 1);
6732 else if (smashed == EL_PENGUIN)
6734 if (CAN_SMASH_PLAYER(element))
6740 else if (element == EL_BD_DIAMOND)
6742 if (IS_CLASSIC_ENEMY(smashed) && IS_BD_ELEMENT(smashed))
6748 else if (((element == EL_SP_INFOTRON ||
6749 element == EL_SP_ZONK) &&
6750 (smashed == EL_SP_SNIKSNAK ||
6751 smashed == EL_SP_ELECTRON ||
6752 smashed == EL_SP_DISK_ORANGE)) ||
6753 (element == EL_SP_INFOTRON &&
6754 smashed == EL_SP_DISK_YELLOW))
6759 else if (CAN_SMASH_EVERYTHING(element))
6761 if (IS_CLASSIC_ENEMY(smashed) ||
6762 CAN_EXPLODE_SMASHED(smashed))
6767 else if (!IS_MOVING(x, y + 1) && !IS_BLOCKED(x, y + 1))
6769 if (smashed == EL_LAMP ||
6770 smashed == EL_LAMP_ACTIVE)
6775 else if (smashed == EL_NUT)
6777 Tile[x][y + 1] = EL_NUT_BREAKING;
6778 PlayLevelSound(x, y, SND_NUT_BREAKING);
6779 RaiseScoreElement(EL_NUT);
6782 else if (smashed == EL_PEARL)
6784 ResetGfxAnimation(x, y);
6786 Tile[x][y + 1] = EL_PEARL_BREAKING;
6787 PlayLevelSound(x, y, SND_PEARL_BREAKING);
6790 else if (smashed == EL_DIAMOND)
6792 Tile[x][y + 1] = EL_DIAMOND_BREAKING;
6793 PlayLevelSound(x, y, SND_DIAMOND_BREAKING);
6796 else if (IS_BELT_SWITCH(smashed))
6798 ToggleBeltSwitch(x, y + 1);
6800 else if (smashed == EL_SWITCHGATE_SWITCH_UP ||
6801 smashed == EL_SWITCHGATE_SWITCH_DOWN ||
6802 smashed == EL_DC_SWITCHGATE_SWITCH_UP ||
6803 smashed == EL_DC_SWITCHGATE_SWITCH_DOWN)
6805 ToggleSwitchgateSwitch(x, y + 1);
6807 else if (smashed == EL_LIGHT_SWITCH ||
6808 smashed == EL_LIGHT_SWITCH_ACTIVE)
6810 ToggleLightSwitch(x, y + 1);
6814 CheckElementChange(x, y + 1, smashed, element, CE_SMASHED);
6816 CheckElementChangeBySide(x, y + 1, smashed, element,
6817 CE_SWITCHED, CH_SIDE_TOP);
6818 CheckTriggeredElementChangeBySide(x, y + 1, smashed, CE_SWITCH_OF_X,
6824 CheckElementChange(x, y + 1, smashed, element, CE_SMASHED);
6829 // play sound of magic wall / mill
6831 (Tile[x][y + 1] == EL_MAGIC_WALL_ACTIVE ||
6832 Tile[x][y + 1] == EL_BD_MAGIC_WALL_ACTIVE ||
6833 Tile[x][y + 1] == EL_DC_MAGIC_WALL_ACTIVE))
6835 if (Tile[x][y + 1] == EL_MAGIC_WALL_ACTIVE)
6836 PlayLevelSound(x, y, SND_MAGIC_WALL_FILLING);
6837 else if (Tile[x][y + 1] == EL_BD_MAGIC_WALL_ACTIVE)
6838 PlayLevelSound(x, y, SND_BD_MAGIC_WALL_FILLING);
6839 else if (Tile[x][y + 1] == EL_DC_MAGIC_WALL_ACTIVE)
6840 PlayLevelSound(x, y, SND_DC_MAGIC_WALL_FILLING);
6845 // play sound of object that hits the ground
6846 if (last_line || object_hit)
6847 PlayLevelSoundElementAction(x, y, element, ACTION_IMPACT);
6850 static void TurnRoundExt(int x, int y)
6862 { 0, 0 }, { 0, 0 }, { 0, 0 },
6867 int left, right, back;
6871 { MV_DOWN, MV_UP, MV_RIGHT },
6872 { MV_UP, MV_DOWN, MV_LEFT },
6874 { MV_LEFT, MV_RIGHT, MV_DOWN },
6878 { MV_RIGHT, MV_LEFT, MV_UP }
6881 int element = Tile[x][y];
6882 int move_pattern = element_info[element].move_pattern;
6884 int old_move_dir = MovDir[x][y];
6885 int left_dir = turn[old_move_dir].left;
6886 int right_dir = turn[old_move_dir].right;
6887 int back_dir = turn[old_move_dir].back;
6889 int left_dx = move_xy[left_dir].dx, left_dy = move_xy[left_dir].dy;
6890 int right_dx = move_xy[right_dir].dx, right_dy = move_xy[right_dir].dy;
6891 int move_dx = move_xy[old_move_dir].dx, move_dy = move_xy[old_move_dir].dy;
6892 int back_dx = move_xy[back_dir].dx, back_dy = move_xy[back_dir].dy;
6894 int left_x = x + left_dx, left_y = y + left_dy;
6895 int right_x = x + right_dx, right_y = y + right_dy;
6896 int move_x = x + move_dx, move_y = y + move_dy;
6900 if (element == EL_BUG || element == EL_BD_BUTTERFLY)
6902 TestIfBadThingTouchesOtherBadThing(x, y);
6904 if (ENEMY_CAN_ENTER_FIELD(element, right_x, right_y))
6905 MovDir[x][y] = right_dir;
6906 else if (!ENEMY_CAN_ENTER_FIELD(element, move_x, move_y))
6907 MovDir[x][y] = left_dir;
6909 if (element == EL_BUG && MovDir[x][y] != old_move_dir)
6911 else if (element == EL_BD_BUTTERFLY) // && MovDir[x][y] == left_dir)
6914 else if (element == EL_SPACESHIP || element == EL_BD_FIREFLY)
6916 TestIfBadThingTouchesOtherBadThing(x, y);
6918 if (ENEMY_CAN_ENTER_FIELD(element, left_x, left_y))
6919 MovDir[x][y] = left_dir;
6920 else if (!ENEMY_CAN_ENTER_FIELD(element, move_x, move_y))
6921 MovDir[x][y] = right_dir;
6923 if (element == EL_SPACESHIP && MovDir[x][y] != old_move_dir)
6925 else if (element == EL_BD_FIREFLY) // && MovDir[x][y] == right_dir)
6928 else if (element == EL_SP_SNIKSNAK || element == EL_SP_ELECTRON)
6930 TestIfBadThingTouchesOtherBadThing(x, y);
6932 if (ELEMENT_CAN_ENTER_FIELD_BASE_4(element, left_x, left_y, 0))
6933 MovDir[x][y] = left_dir;
6934 else if (!ELEMENT_CAN_ENTER_FIELD_BASE_4(element, move_x, move_y, 0))
6935 MovDir[x][y] = right_dir;
6937 if (MovDir[x][y] != old_move_dir)
6940 else if (element == EL_YAMYAM)
6942 boolean can_turn_left = YAMYAM_CAN_ENTER_FIELD(element, left_x, left_y);
6943 boolean can_turn_right = YAMYAM_CAN_ENTER_FIELD(element, right_x, right_y);
6945 if (can_turn_left && can_turn_right)
6946 MovDir[x][y] = (RND(3) ? (RND(2) ? left_dir : right_dir) : back_dir);
6947 else if (can_turn_left)
6948 MovDir[x][y] = (RND(2) ? left_dir : back_dir);
6949 else if (can_turn_right)
6950 MovDir[x][y] = (RND(2) ? right_dir : back_dir);
6952 MovDir[x][y] = back_dir;
6954 MovDelay[x][y] = 16 + 16 * RND(3);
6956 else if (element == EL_DARK_YAMYAM)
6958 boolean can_turn_left = DARK_YAMYAM_CAN_ENTER_FIELD(element,
6960 boolean can_turn_right = DARK_YAMYAM_CAN_ENTER_FIELD(element,
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_PACMAN)
6976 boolean can_turn_left = PACMAN_CAN_ENTER_FIELD(element, left_x, left_y);
6977 boolean can_turn_right = PACMAN_CAN_ENTER_FIELD(element, right_x, right_y);
6979 if (can_turn_left && can_turn_right)
6980 MovDir[x][y] = (RND(3) ? (RND(2) ? left_dir : right_dir) : back_dir);
6981 else if (can_turn_left)
6982 MovDir[x][y] = (RND(2) ? left_dir : back_dir);
6983 else if (can_turn_right)
6984 MovDir[x][y] = (RND(2) ? right_dir : back_dir);
6986 MovDir[x][y] = back_dir;
6988 MovDelay[x][y] = 6 + RND(40);
6990 else if (element == EL_PIG)
6992 boolean can_turn_left = PIG_CAN_ENTER_FIELD(element, left_x, left_y);
6993 boolean can_turn_right = PIG_CAN_ENTER_FIELD(element, right_x, right_y);
6994 boolean can_move_on = PIG_CAN_ENTER_FIELD(element, move_x, move_y);
6995 boolean should_turn_left, should_turn_right, should_move_on;
6997 int rnd = RND(rnd_value);
6999 should_turn_left = (can_turn_left &&
7001 IN_LEV_FIELD_AND_NOT_FREE(x + back_dx + left_dx,
7002 y + back_dy + left_dy)));
7003 should_turn_right = (can_turn_right &&
7005 IN_LEV_FIELD_AND_NOT_FREE(x + back_dx + right_dx,
7006 y + back_dy + right_dy)));
7007 should_move_on = (can_move_on &&
7010 IN_LEV_FIELD_AND_NOT_FREE(x + move_dx + left_dx,
7011 y + move_dy + left_dy) ||
7012 IN_LEV_FIELD_AND_NOT_FREE(x + move_dx + right_dx,
7013 y + move_dy + right_dy)));
7015 if (should_turn_left || should_turn_right || should_move_on)
7017 if (should_turn_left && should_turn_right && should_move_on)
7018 MovDir[x][y] = (rnd < rnd_value / 3 ? left_dir :
7019 rnd < 2 * rnd_value / 3 ? right_dir :
7021 else if (should_turn_left && should_turn_right)
7022 MovDir[x][y] = (rnd < rnd_value / 2 ? left_dir : right_dir);
7023 else if (should_turn_left && should_move_on)
7024 MovDir[x][y] = (rnd < rnd_value / 2 ? left_dir : old_move_dir);
7025 else if (should_turn_right && should_move_on)
7026 MovDir[x][y] = (rnd < rnd_value / 2 ? right_dir : old_move_dir);
7027 else if (should_turn_left)
7028 MovDir[x][y] = left_dir;
7029 else if (should_turn_right)
7030 MovDir[x][y] = right_dir;
7031 else if (should_move_on)
7032 MovDir[x][y] = old_move_dir;
7034 else if (can_move_on && rnd > rnd_value / 8)
7035 MovDir[x][y] = old_move_dir;
7036 else if (can_turn_left && can_turn_right)
7037 MovDir[x][y] = (rnd < rnd_value / 2 ? left_dir : right_dir);
7038 else if (can_turn_left && rnd > rnd_value / 8)
7039 MovDir[x][y] = left_dir;
7040 else if (can_turn_right && rnd > rnd_value/8)
7041 MovDir[x][y] = right_dir;
7043 MovDir[x][y] = back_dir;
7045 xx = x + move_xy[MovDir[x][y]].dx;
7046 yy = y + move_xy[MovDir[x][y]].dy;
7048 if (!IN_LEV_FIELD(xx, yy) ||
7049 (!IS_FREE(xx, yy) && !IS_FOOD_PIG(Tile[xx][yy])))
7050 MovDir[x][y] = old_move_dir;
7054 else if (element == EL_DRAGON)
7056 boolean can_turn_left = DRAGON_CAN_ENTER_FIELD(element, left_x, left_y);
7057 boolean can_turn_right = DRAGON_CAN_ENTER_FIELD(element, right_x, right_y);
7058 boolean can_move_on = DRAGON_CAN_ENTER_FIELD(element, move_x, move_y);
7060 int rnd = RND(rnd_value);
7062 if (can_move_on && rnd > rnd_value / 8)
7063 MovDir[x][y] = old_move_dir;
7064 else if (can_turn_left && can_turn_right)
7065 MovDir[x][y] = (rnd < rnd_value / 2 ? left_dir : right_dir);
7066 else if (can_turn_left && rnd > rnd_value / 8)
7067 MovDir[x][y] = left_dir;
7068 else if (can_turn_right && rnd > rnd_value / 8)
7069 MovDir[x][y] = right_dir;
7071 MovDir[x][y] = back_dir;
7073 xx = x + move_xy[MovDir[x][y]].dx;
7074 yy = y + move_xy[MovDir[x][y]].dy;
7076 if (!IN_LEV_FIELD_AND_IS_FREE(xx, yy))
7077 MovDir[x][y] = old_move_dir;
7081 else if (element == EL_MOLE)
7083 boolean can_move_on =
7084 (MOLE_CAN_ENTER_FIELD(element, move_x, move_y,
7085 IS_AMOEBOID(Tile[move_x][move_y]) ||
7086 Tile[move_x][move_y] == EL_AMOEBA_SHRINKING));
7089 boolean can_turn_left =
7090 (MOLE_CAN_ENTER_FIELD(element, left_x, left_y,
7091 IS_AMOEBOID(Tile[left_x][left_y])));
7093 boolean can_turn_right =
7094 (MOLE_CAN_ENTER_FIELD(element, right_x, right_y,
7095 IS_AMOEBOID(Tile[right_x][right_y])));
7097 if (can_turn_left && can_turn_right)
7098 MovDir[x][y] = (RND(2) ? left_dir : right_dir);
7099 else if (can_turn_left)
7100 MovDir[x][y] = left_dir;
7102 MovDir[x][y] = right_dir;
7105 if (MovDir[x][y] != old_move_dir)
7108 else if (element == EL_BALLOON)
7110 MovDir[x][y] = game.wind_direction;
7113 else if (element == EL_SPRING)
7115 if (MovDir[x][y] & MV_HORIZONTAL)
7117 if (SPRING_CAN_BUMP_FROM_FIELD(move_x, move_y) &&
7118 !SPRING_CAN_ENTER_FIELD(element, x, y + 1))
7120 Tile[move_x][move_y] = EL_EMC_SPRING_BUMPER_ACTIVE;
7121 ResetGfxAnimation(move_x, move_y);
7122 TEST_DrawLevelField(move_x, move_y);
7124 MovDir[x][y] = back_dir;
7126 else if (!SPRING_CAN_ENTER_FIELD(element, move_x, move_y) ||
7127 SPRING_CAN_ENTER_FIELD(element, x, y + 1))
7128 MovDir[x][y] = MV_NONE;
7133 else if (element == EL_ROBOT ||
7134 element == EL_SATELLITE ||
7135 element == EL_PENGUIN ||
7136 element == EL_EMC_ANDROID)
7138 int attr_x = -1, attr_y = -1;
7140 if (game.all_players_gone)
7142 attr_x = game.exit_x;
7143 attr_y = game.exit_y;
7149 for (i = 0; i < MAX_PLAYERS; i++)
7151 struct PlayerInfo *player = &stored_player[i];
7152 int jx = player->jx, jy = player->jy;
7154 if (!player->active)
7158 ABS(jx - x) + ABS(jy - y) < ABS(attr_x - x) + ABS(attr_y - y))
7166 if (element == EL_ROBOT &&
7167 game.robot_wheel_x >= 0 &&
7168 game.robot_wheel_y >= 0 &&
7169 (Tile[game.robot_wheel_x][game.robot_wheel_y] == EL_ROBOT_WHEEL_ACTIVE ||
7170 game.engine_version < VERSION_IDENT(3,1,0,0)))
7172 attr_x = game.robot_wheel_x;
7173 attr_y = game.robot_wheel_y;
7176 if (element == EL_PENGUIN)
7179 static int xy[4][2] =
7187 for (i = 0; i < NUM_DIRECTIONS; i++)
7189 int ex = x + xy[i][0];
7190 int ey = y + xy[i][1];
7192 if (IN_LEV_FIELD(ex, ey) && (Tile[ex][ey] == EL_EXIT_OPEN ||
7193 Tile[ex][ey] == EL_EM_EXIT_OPEN ||
7194 Tile[ex][ey] == EL_STEEL_EXIT_OPEN ||
7195 Tile[ex][ey] == EL_EM_STEEL_EXIT_OPEN))
7204 MovDir[x][y] = MV_NONE;
7206 MovDir[x][y] |= (game.all_players_gone ? MV_RIGHT : MV_LEFT);
7207 else if (attr_x > x)
7208 MovDir[x][y] |= (game.all_players_gone ? MV_LEFT : MV_RIGHT);
7210 MovDir[x][y] |= (game.all_players_gone ? MV_DOWN : MV_UP);
7211 else if (attr_y > y)
7212 MovDir[x][y] |= (game.all_players_gone ? MV_UP : MV_DOWN);
7214 if (element == EL_ROBOT)
7218 if (MovDir[x][y] & MV_HORIZONTAL && MovDir[x][y] & MV_VERTICAL)
7219 MovDir[x][y] &= (RND(2) ? MV_HORIZONTAL : MV_VERTICAL);
7220 Moving2Blocked(x, y, &newx, &newy);
7222 if (IN_LEV_FIELD(newx, newy) && IS_FREE_OR_PLAYER(newx, newy))
7223 MovDelay[x][y] = 8 + 8 * !RND(3);
7225 MovDelay[x][y] = 16;
7227 else if (element == EL_PENGUIN)
7233 if (MovDir[x][y] & MV_HORIZONTAL && MovDir[x][y] & MV_VERTICAL)
7235 boolean first_horiz = RND(2);
7236 int new_move_dir = MovDir[x][y];
7239 new_move_dir & (first_horiz ? MV_HORIZONTAL : MV_VERTICAL);
7240 Moving2Blocked(x, y, &newx, &newy);
7242 if (PENGUIN_CAN_ENTER_FIELD(element, newx, newy))
7246 new_move_dir & (!first_horiz ? MV_HORIZONTAL : MV_VERTICAL);
7247 Moving2Blocked(x, y, &newx, &newy);
7249 if (PENGUIN_CAN_ENTER_FIELD(element, newx, newy))
7252 MovDir[x][y] = old_move_dir;
7256 else if (element == EL_SATELLITE)
7262 if (MovDir[x][y] & MV_HORIZONTAL && MovDir[x][y] & MV_VERTICAL)
7264 boolean first_horiz = RND(2);
7265 int new_move_dir = MovDir[x][y];
7268 new_move_dir & (first_horiz ? MV_HORIZONTAL : MV_VERTICAL);
7269 Moving2Blocked(x, y, &newx, &newy);
7271 if (SATELLITE_CAN_ENTER_FIELD(newx, newy))
7275 new_move_dir & (!first_horiz ? MV_HORIZONTAL : MV_VERTICAL);
7276 Moving2Blocked(x, y, &newx, &newy);
7278 if (SATELLITE_CAN_ENTER_FIELD(newx, newy))
7281 MovDir[x][y] = old_move_dir;
7285 else if (element == EL_EMC_ANDROID)
7287 static int check_pos[16] =
7289 -1, // 0 => (invalid)
7292 -1, // 3 => (invalid)
7294 0, // 5 => MV_LEFT | MV_UP
7295 2, // 6 => MV_RIGHT | MV_UP
7296 -1, // 7 => (invalid)
7298 6, // 9 => MV_LEFT | MV_DOWN
7299 4, // 10 => MV_RIGHT | MV_DOWN
7300 -1, // 11 => (invalid)
7301 -1, // 12 => (invalid)
7302 -1, // 13 => (invalid)
7303 -1, // 14 => (invalid)
7304 -1, // 15 => (invalid)
7312 { -1, -1, MV_LEFT | MV_UP },
7314 { +1, -1, MV_RIGHT | MV_UP },
7315 { +1, 0, MV_RIGHT },
7316 { +1, +1, MV_RIGHT | MV_DOWN },
7318 { -1, +1, MV_LEFT | MV_DOWN },
7321 int start_pos, check_order;
7322 boolean can_clone = FALSE;
7325 // check if there is any free field around current position
7326 for (i = 0; i < 8; i++)
7328 int newx = x + check_xy[i].dx;
7329 int newy = y + check_xy[i].dy;
7331 if (IN_LEV_FIELD_AND_IS_FREE(newx, newy))
7339 if (can_clone) // randomly find an element to clone
7343 start_pos = check_pos[RND(8)];
7344 check_order = (RND(2) ? -1 : +1);
7346 for (i = 0; i < 8; i++)
7348 int pos_raw = start_pos + i * check_order;
7349 int pos = (pos_raw + 8) % 8;
7350 int newx = x + check_xy[pos].dx;
7351 int newy = y + check_xy[pos].dy;
7353 if (ANDROID_CAN_CLONE_FIELD(newx, newy))
7355 element_info[element].move_leave_type = LEAVE_TYPE_LIMITED;
7356 element_info[element].move_leave_element = EL_TRIGGER_ELEMENT;
7358 Store[x][y] = Tile[newx][newy];
7367 if (can_clone) // randomly find a direction to move
7371 start_pos = check_pos[RND(8)];
7372 check_order = (RND(2) ? -1 : +1);
7374 for (i = 0; i < 8; i++)
7376 int pos_raw = start_pos + i * check_order;
7377 int pos = (pos_raw + 8) % 8;
7378 int newx = x + check_xy[pos].dx;
7379 int newy = y + check_xy[pos].dy;
7380 int new_move_dir = check_xy[pos].dir;
7382 if (IN_LEV_FIELD_AND_IS_FREE(newx, newy))
7384 MovDir[x][y] = new_move_dir;
7385 MovDelay[x][y] = level.android_clone_time * 8 + 1;
7394 if (can_clone) // cloning and moving successful
7397 // cannot clone -- try to move towards player
7399 start_pos = check_pos[MovDir[x][y] & 0x0f];
7400 check_order = (RND(2) ? -1 : +1);
7402 for (i = 0; i < 3; i++)
7404 // first check start_pos, then previous/next or (next/previous) pos
7405 int pos_raw = start_pos + (i < 2 ? i : -1) * check_order;
7406 int pos = (pos_raw + 8) % 8;
7407 int newx = x + check_xy[pos].dx;
7408 int newy = y + check_xy[pos].dy;
7409 int new_move_dir = check_xy[pos].dir;
7411 if (IS_PLAYER(newx, newy))
7414 if (ANDROID_CAN_ENTER_FIELD(element, newx, newy))
7416 MovDir[x][y] = new_move_dir;
7417 MovDelay[x][y] = level.android_move_time * 8 + 1;
7424 else if (move_pattern == MV_TURNING_LEFT ||
7425 move_pattern == MV_TURNING_RIGHT ||
7426 move_pattern == MV_TURNING_LEFT_RIGHT ||
7427 move_pattern == MV_TURNING_RIGHT_LEFT ||
7428 move_pattern == MV_TURNING_RANDOM ||
7429 move_pattern == MV_ALL_DIRECTIONS)
7431 boolean can_turn_left =
7432 CUSTOM_ELEMENT_CAN_ENTER_FIELD(element, left_x, left_y);
7433 boolean can_turn_right =
7434 CUSTOM_ELEMENT_CAN_ENTER_FIELD(element, right_x,right_y);
7436 if (element_info[element].move_stepsize == 0) // "not moving"
7439 if (move_pattern == MV_TURNING_LEFT)
7440 MovDir[x][y] = left_dir;
7441 else if (move_pattern == MV_TURNING_RIGHT)
7442 MovDir[x][y] = right_dir;
7443 else if (move_pattern == MV_TURNING_LEFT_RIGHT)
7444 MovDir[x][y] = (can_turn_left || !can_turn_right ? left_dir : right_dir);
7445 else if (move_pattern == MV_TURNING_RIGHT_LEFT)
7446 MovDir[x][y] = (can_turn_right || !can_turn_left ? right_dir : left_dir);
7447 else if (move_pattern == MV_TURNING_RANDOM)
7448 MovDir[x][y] = (can_turn_left && !can_turn_right ? left_dir :
7449 can_turn_right && !can_turn_left ? right_dir :
7450 RND(2) ? left_dir : right_dir);
7451 else if (can_turn_left && can_turn_right)
7452 MovDir[x][y] = (RND(3) ? (RND(2) ? left_dir : right_dir) : back_dir);
7453 else if (can_turn_left)
7454 MovDir[x][y] = (RND(2) ? left_dir : back_dir);
7455 else if (can_turn_right)
7456 MovDir[x][y] = (RND(2) ? right_dir : back_dir);
7458 MovDir[x][y] = back_dir;
7460 MovDelay[x][y] = GET_NEW_MOVE_DELAY(element);
7462 else if (move_pattern == MV_HORIZONTAL ||
7463 move_pattern == MV_VERTICAL)
7465 if (move_pattern & old_move_dir)
7466 MovDir[x][y] = back_dir;
7467 else if (move_pattern == MV_HORIZONTAL)
7468 MovDir[x][y] = (RND(2) ? MV_LEFT : MV_RIGHT);
7469 else if (move_pattern == MV_VERTICAL)
7470 MovDir[x][y] = (RND(2) ? MV_UP : MV_DOWN);
7472 MovDelay[x][y] = GET_NEW_MOVE_DELAY(element);
7474 else if (move_pattern & MV_ANY_DIRECTION)
7476 MovDir[x][y] = move_pattern;
7477 MovDelay[x][y] = GET_NEW_MOVE_DELAY(element);
7479 else if (move_pattern & MV_WIND_DIRECTION)
7481 MovDir[x][y] = game.wind_direction;
7482 MovDelay[x][y] = GET_NEW_MOVE_DELAY(element);
7484 else if (move_pattern == MV_ALONG_LEFT_SIDE)
7486 if (CUSTOM_ELEMENT_CAN_ENTER_FIELD(element, left_x, left_y))
7487 MovDir[x][y] = left_dir;
7488 else if (!CUSTOM_ELEMENT_CAN_ENTER_FIELD(element, move_x, move_y))
7489 MovDir[x][y] = right_dir;
7491 if (MovDir[x][y] != old_move_dir)
7492 MovDelay[x][y] = GET_NEW_MOVE_DELAY(element);
7494 else if (move_pattern == MV_ALONG_RIGHT_SIDE)
7496 if (CUSTOM_ELEMENT_CAN_ENTER_FIELD(element, right_x, right_y))
7497 MovDir[x][y] = right_dir;
7498 else if (!CUSTOM_ELEMENT_CAN_ENTER_FIELD(element, move_x, move_y))
7499 MovDir[x][y] = left_dir;
7501 if (MovDir[x][y] != old_move_dir)
7502 MovDelay[x][y] = GET_NEW_MOVE_DELAY(element);
7504 else if (move_pattern == MV_TOWARDS_PLAYER ||
7505 move_pattern == MV_AWAY_FROM_PLAYER)
7507 int attr_x = -1, attr_y = -1;
7509 boolean move_away = (move_pattern == MV_AWAY_FROM_PLAYER);
7511 if (game.all_players_gone)
7513 attr_x = game.exit_x;
7514 attr_y = game.exit_y;
7520 for (i = 0; i < MAX_PLAYERS; i++)
7522 struct PlayerInfo *player = &stored_player[i];
7523 int jx = player->jx, jy = player->jy;
7525 if (!player->active)
7529 ABS(jx - x) + ABS(jy - y) < ABS(attr_x - x) + ABS(attr_y - y))
7537 MovDir[x][y] = MV_NONE;
7539 MovDir[x][y] |= (move_away ? MV_RIGHT : MV_LEFT);
7540 else if (attr_x > x)
7541 MovDir[x][y] |= (move_away ? MV_LEFT : MV_RIGHT);
7543 MovDir[x][y] |= (move_away ? MV_DOWN : MV_UP);
7544 else if (attr_y > y)
7545 MovDir[x][y] |= (move_away ? MV_UP : MV_DOWN);
7547 MovDelay[x][y] = GET_NEW_MOVE_DELAY(element);
7549 if (MovDir[x][y] & MV_HORIZONTAL && MovDir[x][y] & MV_VERTICAL)
7551 boolean first_horiz = RND(2);
7552 int new_move_dir = MovDir[x][y];
7554 if (element_info[element].move_stepsize == 0) // "not moving"
7556 first_horiz = (ABS(attr_x - x) >= ABS(attr_y - y));
7557 MovDir[x][y] &= (first_horiz ? MV_HORIZONTAL : MV_VERTICAL);
7563 new_move_dir & (first_horiz ? MV_HORIZONTAL : MV_VERTICAL);
7564 Moving2Blocked(x, y, &newx, &newy);
7566 if (CUSTOM_ELEMENT_CAN_ENTER_FIELD(element, newx, newy))
7570 new_move_dir & (!first_horiz ? MV_HORIZONTAL : MV_VERTICAL);
7571 Moving2Blocked(x, y, &newx, &newy);
7573 if (CUSTOM_ELEMENT_CAN_ENTER_FIELD(element, newx, newy))
7576 MovDir[x][y] = old_move_dir;
7579 else if (move_pattern == MV_WHEN_PUSHED ||
7580 move_pattern == MV_WHEN_DROPPED)
7582 if (!CUSTOM_ELEMENT_CAN_ENTER_FIELD(element, move_x, move_y))
7583 MovDir[x][y] = MV_NONE;
7587 else if (move_pattern & MV_MAZE_RUNNER_STYLE)
7589 static int test_xy[7][2] =
7599 static int test_dir[7] =
7609 boolean hunter_mode = (move_pattern == MV_MAZE_HUNTER);
7610 int move_preference = -1000000; // start with very low preference
7611 int new_move_dir = MV_NONE;
7612 int start_test = RND(4);
7615 for (i = 0; i < NUM_DIRECTIONS; i++)
7617 int move_dir = test_dir[start_test + i];
7618 int move_dir_preference;
7620 xx = x + test_xy[start_test + i][0];
7621 yy = y + test_xy[start_test + i][1];
7623 if (hunter_mode && IN_LEV_FIELD(xx, yy) &&
7624 (IS_PLAYER(xx, yy) || Tile[xx][yy] == EL_PLAYER_IS_LEAVING))
7626 new_move_dir = move_dir;
7631 if (!CUSTOM_ELEMENT_CAN_ENTER_FIELD(element, xx, yy))
7634 move_dir_preference = -1 * RunnerVisit[xx][yy];
7635 if (hunter_mode && PlayerVisit[xx][yy] > 0)
7636 move_dir_preference = PlayerVisit[xx][yy];
7638 if (move_dir_preference > move_preference)
7640 // prefer field that has not been visited for the longest time
7641 move_preference = move_dir_preference;
7642 new_move_dir = move_dir;
7644 else if (move_dir_preference == move_preference &&
7645 move_dir == old_move_dir)
7647 // prefer last direction when all directions are preferred equally
7648 move_preference = move_dir_preference;
7649 new_move_dir = move_dir;
7653 MovDir[x][y] = new_move_dir;
7654 if (old_move_dir != new_move_dir)
7655 MovDelay[x][y] = GET_NEW_MOVE_DELAY(element);
7659 static void TurnRound(int x, int y)
7661 int direction = MovDir[x][y];
7665 GfxDir[x][y] = MovDir[x][y];
7667 if (direction != MovDir[x][y])
7671 GfxAction[x][y] = ACTION_TURNING_FROM_LEFT + MV_DIR_TO_BIT(direction);
7673 ResetGfxFrame(x, y);
7676 static boolean JustBeingPushed(int x, int y)
7680 for (i = 0; i < MAX_PLAYERS; i++)
7682 struct PlayerInfo *player = &stored_player[i];
7684 if (player->active && player->is_pushing && player->MovPos)
7686 int next_jx = player->jx + (player->jx - player->last_jx);
7687 int next_jy = player->jy + (player->jy - player->last_jy);
7689 if (x == next_jx && y == next_jy)
7697 static void StartMoving(int x, int y)
7699 boolean started_moving = FALSE; // some elements can fall _and_ move
7700 int element = Tile[x][y];
7705 if (MovDelay[x][y] == 0)
7706 GfxAction[x][y] = ACTION_DEFAULT;
7708 if (CAN_FALL(element) && y < lev_fieldy - 1)
7710 if ((x > 0 && IS_PLAYER(x - 1, y)) ||
7711 (x < lev_fieldx - 1 && IS_PLAYER(x + 1, y)))
7712 if (JustBeingPushed(x, y))
7715 if (element == EL_QUICKSAND_FULL)
7717 if (IS_FREE(x, y + 1))
7719 InitMovingField(x, y, MV_DOWN);
7720 started_moving = TRUE;
7722 Tile[x][y] = EL_QUICKSAND_EMPTYING;
7723 #if USE_QUICKSAND_BD_ROCK_BUGFIX
7724 if (Store[x][y] != EL_ROCK && Store[x][y] != EL_BD_ROCK)
7725 Store[x][y] = EL_ROCK;
7727 Store[x][y] = EL_ROCK;
7730 PlayLevelSoundAction(x, y, ACTION_EMPTYING);
7732 else if (Tile[x][y + 1] == EL_QUICKSAND_EMPTY)
7734 if (!MovDelay[x][y])
7736 MovDelay[x][y] = TILEY + 1;
7738 ResetGfxAnimation(x, y);
7739 ResetGfxAnimation(x, y + 1);
7744 DrawLevelElement(x, y, EL_QUICKSAND_EMPTYING);
7745 DrawLevelElement(x, y + 1, EL_QUICKSAND_FILLING);
7752 Tile[x][y] = EL_QUICKSAND_EMPTY;
7753 Tile[x][y + 1] = EL_QUICKSAND_FULL;
7754 Store[x][y + 1] = Store[x][y];
7757 PlayLevelSoundAction(x, y, ACTION_FILLING);
7759 else if (Tile[x][y + 1] == EL_QUICKSAND_FAST_EMPTY)
7761 if (!MovDelay[x][y])
7763 MovDelay[x][y] = TILEY + 1;
7765 ResetGfxAnimation(x, y);
7766 ResetGfxAnimation(x, y + 1);
7771 DrawLevelElement(x, y, EL_QUICKSAND_EMPTYING);
7772 DrawLevelElement(x, y + 1, EL_QUICKSAND_FAST_FILLING);
7779 Tile[x][y] = EL_QUICKSAND_EMPTY;
7780 Tile[x][y + 1] = EL_QUICKSAND_FAST_FULL;
7781 Store[x][y + 1] = Store[x][y];
7784 PlayLevelSoundAction(x, y, ACTION_FILLING);
7787 else if (element == EL_QUICKSAND_FAST_FULL)
7789 if (IS_FREE(x, y + 1))
7791 InitMovingField(x, y, MV_DOWN);
7792 started_moving = TRUE;
7794 Tile[x][y] = EL_QUICKSAND_FAST_EMPTYING;
7795 #if USE_QUICKSAND_BD_ROCK_BUGFIX
7796 if (Store[x][y] != EL_ROCK && Store[x][y] != EL_BD_ROCK)
7797 Store[x][y] = EL_ROCK;
7799 Store[x][y] = EL_ROCK;
7802 PlayLevelSoundAction(x, y, ACTION_EMPTYING);
7804 else if (Tile[x][y + 1] == EL_QUICKSAND_FAST_EMPTY)
7806 if (!MovDelay[x][y])
7808 MovDelay[x][y] = TILEY + 1;
7810 ResetGfxAnimation(x, y);
7811 ResetGfxAnimation(x, y + 1);
7816 DrawLevelElement(x, y, EL_QUICKSAND_FAST_EMPTYING);
7817 DrawLevelElement(x, y + 1, EL_QUICKSAND_FAST_FILLING);
7824 Tile[x][y] = EL_QUICKSAND_FAST_EMPTY;
7825 Tile[x][y + 1] = EL_QUICKSAND_FAST_FULL;
7826 Store[x][y + 1] = Store[x][y];
7829 PlayLevelSoundAction(x, y, ACTION_FILLING);
7831 else if (Tile[x][y + 1] == EL_QUICKSAND_EMPTY)
7833 if (!MovDelay[x][y])
7835 MovDelay[x][y] = TILEY + 1;
7837 ResetGfxAnimation(x, y);
7838 ResetGfxAnimation(x, y + 1);
7843 DrawLevelElement(x, y, EL_QUICKSAND_FAST_EMPTYING);
7844 DrawLevelElement(x, y + 1, EL_QUICKSAND_FILLING);
7851 Tile[x][y] = EL_QUICKSAND_FAST_EMPTY;
7852 Tile[x][y + 1] = EL_QUICKSAND_FULL;
7853 Store[x][y + 1] = Store[x][y];
7856 PlayLevelSoundAction(x, y, ACTION_FILLING);
7859 else if ((element == EL_ROCK || element == EL_BD_ROCK) &&
7860 Tile[x][y + 1] == EL_QUICKSAND_EMPTY)
7862 InitMovingField(x, y, MV_DOWN);
7863 started_moving = TRUE;
7865 Tile[x][y] = EL_QUICKSAND_FILLING;
7866 Store[x][y] = element;
7868 PlayLevelSoundAction(x, y, ACTION_FILLING);
7870 else if ((element == EL_ROCK || element == EL_BD_ROCK) &&
7871 Tile[x][y + 1] == EL_QUICKSAND_FAST_EMPTY)
7873 InitMovingField(x, y, MV_DOWN);
7874 started_moving = TRUE;
7876 Tile[x][y] = EL_QUICKSAND_FAST_FILLING;
7877 Store[x][y] = element;
7879 PlayLevelSoundAction(x, y, ACTION_FILLING);
7881 else if (element == EL_MAGIC_WALL_FULL)
7883 if (IS_FREE(x, y + 1))
7885 InitMovingField(x, y, MV_DOWN);
7886 started_moving = TRUE;
7888 Tile[x][y] = EL_MAGIC_WALL_EMPTYING;
7889 Store[x][y] = EL_CHANGED(Store[x][y]);
7891 else if (Tile[x][y + 1] == EL_MAGIC_WALL_ACTIVE)
7893 if (!MovDelay[x][y])
7894 MovDelay[x][y] = TILEY / 4 + 1;
7903 Tile[x][y] = EL_MAGIC_WALL_ACTIVE;
7904 Tile[x][y + 1] = EL_MAGIC_WALL_FULL;
7905 Store[x][y + 1] = EL_CHANGED(Store[x][y]);
7909 else if (element == EL_BD_MAGIC_WALL_FULL)
7911 if (IS_FREE(x, y + 1))
7913 InitMovingField(x, y, MV_DOWN);
7914 started_moving = TRUE;
7916 Tile[x][y] = EL_BD_MAGIC_WALL_EMPTYING;
7917 Store[x][y] = EL_CHANGED_BD(Store[x][y]);
7919 else if (Tile[x][y + 1] == EL_BD_MAGIC_WALL_ACTIVE)
7921 if (!MovDelay[x][y])
7922 MovDelay[x][y] = TILEY / 4 + 1;
7931 Tile[x][y] = EL_BD_MAGIC_WALL_ACTIVE;
7932 Tile[x][y + 1] = EL_BD_MAGIC_WALL_FULL;
7933 Store[x][y + 1] = EL_CHANGED_BD(Store[x][y]);
7937 else if (element == EL_DC_MAGIC_WALL_FULL)
7939 if (IS_FREE(x, y + 1))
7941 InitMovingField(x, y, MV_DOWN);
7942 started_moving = TRUE;
7944 Tile[x][y] = EL_DC_MAGIC_WALL_EMPTYING;
7945 Store[x][y] = EL_CHANGED_DC(Store[x][y]);
7947 else if (Tile[x][y + 1] == EL_DC_MAGIC_WALL_ACTIVE)
7949 if (!MovDelay[x][y])
7950 MovDelay[x][y] = TILEY / 4 + 1;
7959 Tile[x][y] = EL_DC_MAGIC_WALL_ACTIVE;
7960 Tile[x][y + 1] = EL_DC_MAGIC_WALL_FULL;
7961 Store[x][y + 1] = EL_CHANGED_DC(Store[x][y]);
7965 else if ((CAN_PASS_MAGIC_WALL(element) &&
7966 (Tile[x][y + 1] == EL_MAGIC_WALL_ACTIVE ||
7967 Tile[x][y + 1] == EL_BD_MAGIC_WALL_ACTIVE)) ||
7968 (CAN_PASS_DC_MAGIC_WALL(element) &&
7969 (Tile[x][y + 1] == EL_DC_MAGIC_WALL_ACTIVE)))
7972 InitMovingField(x, y, MV_DOWN);
7973 started_moving = TRUE;
7976 (Tile[x][y + 1] == EL_MAGIC_WALL_ACTIVE ? EL_MAGIC_WALL_FILLING :
7977 Tile[x][y + 1] == EL_BD_MAGIC_WALL_ACTIVE ? EL_BD_MAGIC_WALL_FILLING :
7978 EL_DC_MAGIC_WALL_FILLING);
7979 Store[x][y] = element;
7981 else if (CAN_FALL(element) && Tile[x][y + 1] == EL_ACID)
7983 SplashAcid(x, y + 1);
7985 InitMovingField(x, y, MV_DOWN);
7986 started_moving = TRUE;
7988 Store[x][y] = EL_ACID;
7991 (game.engine_version >= VERSION_IDENT(3,1,0,0) &&
7992 CheckImpact[x][y] && !IS_FREE(x, y + 1)) ||
7993 (game.engine_version >= VERSION_IDENT(3,0,7,0) &&
7994 CAN_FALL(element) && WasJustFalling[x][y] &&
7995 (Tile[x][y + 1] == EL_BLOCKED || IS_PLAYER(x, y + 1))) ||
7997 (game.engine_version < VERSION_IDENT(2,2,0,7) &&
7998 CAN_FALL(element) && WasJustMoving[x][y] && !Pushed[x][y + 1] &&
7999 (Tile[x][y + 1] == EL_BLOCKED)))
8001 /* this is needed for a special case not covered by calling "Impact()"
8002 from "ContinueMoving()": if an element moves to a tile directly below
8003 another element which was just falling on that tile (which was empty
8004 in the previous frame), the falling element above would just stop
8005 instead of smashing the element below (in previous version, the above
8006 element was just checked for "moving" instead of "falling", resulting
8007 in incorrect smashes caused by horizontal movement of the above
8008 element; also, the case of the player being the element to smash was
8009 simply not covered here... :-/ ) */
8011 CheckCollision[x][y] = 0;
8012 CheckImpact[x][y] = 0;
8016 else if (IS_FREE(x, y + 1) && element == EL_SPRING && level.use_spring_bug)
8018 if (MovDir[x][y] == MV_NONE)
8020 InitMovingField(x, y, MV_DOWN);
8021 started_moving = TRUE;
8024 else if (IS_FREE(x, y + 1) || Tile[x][y + 1] == EL_DIAMOND_BREAKING)
8026 if (WasJustFalling[x][y]) // prevent animation from being restarted
8027 MovDir[x][y] = MV_DOWN;
8029 InitMovingField(x, y, MV_DOWN);
8030 started_moving = TRUE;
8032 else if (element == EL_AMOEBA_DROP)
8034 Tile[x][y] = EL_AMOEBA_GROWING;
8035 Store[x][y] = EL_AMOEBA_WET;
8037 else if (((IS_SLIPPERY(Tile[x][y + 1]) && !IS_PLAYER(x, y + 1)) ||
8038 (IS_EM_SLIPPERY_WALL(Tile[x][y + 1]) && IS_GEM(element))) &&
8039 !IS_FALLING(x, y + 1) && !WasJustMoving[x][y + 1] &&
8040 element != EL_DX_SUPABOMB && element != EL_SP_DISK_ORANGE)
8042 boolean can_fall_left = (x > 0 && IS_FREE(x - 1, y) &&
8043 (IS_FREE(x - 1, y + 1) ||
8044 Tile[x - 1][y + 1] == EL_ACID));
8045 boolean can_fall_right = (x < lev_fieldx - 1 && IS_FREE(x + 1, y) &&
8046 (IS_FREE(x + 1, y + 1) ||
8047 Tile[x + 1][y + 1] == EL_ACID));
8048 boolean can_fall_any = (can_fall_left || can_fall_right);
8049 boolean can_fall_both = (can_fall_left && can_fall_right);
8050 int slippery_type = element_info[Tile[x][y + 1]].slippery_type;
8052 if (can_fall_any && slippery_type != SLIPPERY_ANY_RANDOM)
8054 if (slippery_type == SLIPPERY_ANY_LEFT_RIGHT && can_fall_both)
8055 can_fall_right = FALSE;
8056 else if (slippery_type == SLIPPERY_ANY_RIGHT_LEFT && can_fall_both)
8057 can_fall_left = FALSE;
8058 else if (slippery_type == SLIPPERY_ONLY_LEFT)
8059 can_fall_right = FALSE;
8060 else if (slippery_type == SLIPPERY_ONLY_RIGHT)
8061 can_fall_left = FALSE;
8063 can_fall_any = (can_fall_left || can_fall_right);
8064 can_fall_both = FALSE;
8069 if (element == EL_BD_ROCK || element == EL_BD_DIAMOND)
8070 can_fall_right = FALSE; // slip down on left side
8072 can_fall_left = !(can_fall_right = RND(2));
8074 can_fall_both = FALSE;
8079 // if not determined otherwise, prefer left side for slipping down
8080 InitMovingField(x, y, can_fall_left ? MV_LEFT : MV_RIGHT);
8081 started_moving = TRUE;
8084 else if (IS_BELT_ACTIVE(Tile[x][y + 1]))
8086 boolean left_is_free = (x > 0 && IS_FREE(x - 1, y));
8087 boolean right_is_free = (x < lev_fieldx - 1 && IS_FREE(x + 1, y));
8088 int belt_nr = getBeltNrFromBeltActiveElement(Tile[x][y + 1]);
8089 int belt_dir = game.belt_dir[belt_nr];
8091 if ((belt_dir == MV_LEFT && left_is_free) ||
8092 (belt_dir == MV_RIGHT && right_is_free))
8094 int nextx = (belt_dir == MV_LEFT ? x - 1 : x + 1);
8096 InitMovingField(x, y, belt_dir);
8097 started_moving = TRUE;
8099 Pushed[x][y] = TRUE;
8100 Pushed[nextx][y] = TRUE;
8102 GfxAction[x][y] = ACTION_DEFAULT;
8106 MovDir[x][y] = 0; // if element was moving, stop it
8111 // not "else if" because of elements that can fall and move (EL_SPRING)
8112 if (CAN_MOVE(element) && !started_moving)
8114 int move_pattern = element_info[element].move_pattern;
8117 Moving2Blocked(x, y, &newx, &newy);
8119 if (IS_PUSHABLE(element) && JustBeingPushed(x, y))
8122 if (game.engine_version >= VERSION_IDENT(3,1,0,0) &&
8123 CheckCollision[x][y] && !IN_LEV_FIELD_AND_IS_FREE(newx, newy))
8125 WasJustMoving[x][y] = 0;
8126 CheckCollision[x][y] = 0;
8128 TestIfElementHitsCustomElement(x, y, MovDir[x][y]);
8130 if (Tile[x][y] != element) // element has changed
8134 if (!MovDelay[x][y]) // start new movement phase
8136 // all objects that can change their move direction after each step
8137 // (YAMYAM, DARK_YAMYAM and PACMAN go straight until they hit a wall
8139 if (element != EL_YAMYAM &&
8140 element != EL_DARK_YAMYAM &&
8141 element != EL_PACMAN &&
8142 !(move_pattern & MV_ANY_DIRECTION) &&
8143 move_pattern != MV_TURNING_LEFT &&
8144 move_pattern != MV_TURNING_RIGHT &&
8145 move_pattern != MV_TURNING_LEFT_RIGHT &&
8146 move_pattern != MV_TURNING_RIGHT_LEFT &&
8147 move_pattern != MV_TURNING_RANDOM)
8151 if (MovDelay[x][y] && (element == EL_BUG ||
8152 element == EL_SPACESHIP ||
8153 element == EL_SP_SNIKSNAK ||
8154 element == EL_SP_ELECTRON ||
8155 element == EL_MOLE))
8156 TEST_DrawLevelField(x, y);
8160 if (MovDelay[x][y]) // wait some time before next movement
8164 if (element == EL_ROBOT ||
8165 element == EL_YAMYAM ||
8166 element == EL_DARK_YAMYAM)
8168 DrawLevelElementAnimationIfNeeded(x, y, element);
8169 PlayLevelSoundAction(x, y, ACTION_WAITING);
8171 else if (element == EL_SP_ELECTRON)
8172 DrawLevelElementAnimationIfNeeded(x, y, element);
8173 else if (element == EL_DRAGON)
8176 int dir = MovDir[x][y];
8177 int dx = (dir == MV_LEFT ? -1 : dir == MV_RIGHT ? +1 : 0);
8178 int dy = (dir == MV_UP ? -1 : dir == MV_DOWN ? +1 : 0);
8179 int graphic = (dir == MV_LEFT ? IMG_FLAMES_1_LEFT :
8180 dir == MV_RIGHT ? IMG_FLAMES_1_RIGHT :
8181 dir == MV_UP ? IMG_FLAMES_1_UP :
8182 dir == MV_DOWN ? IMG_FLAMES_1_DOWN : IMG_EMPTY);
8183 int frame = getGraphicAnimationFrame(graphic, GfxFrame[x][y]);
8185 GfxAction[x][y] = ACTION_ATTACKING;
8187 if (IS_PLAYER(x, y))
8188 DrawPlayerField(x, y);
8190 TEST_DrawLevelField(x, y);
8192 PlayLevelSoundActionIfLoop(x, y, ACTION_ATTACKING);
8194 for (i = 1; i <= 3; i++)
8196 int xx = x + i * dx;
8197 int yy = y + i * dy;
8198 int sx = SCREENX(xx);
8199 int sy = SCREENY(yy);
8200 int flame_graphic = graphic + (i - 1);
8202 if (!IN_LEV_FIELD(xx, yy) || IS_DRAGONFIRE_PROOF(Tile[xx][yy]))
8207 int flamed = MovingOrBlocked2Element(xx, yy);
8209 if (IS_CLASSIC_ENEMY(flamed) || CAN_EXPLODE_BY_DRAGONFIRE(flamed))
8212 RemoveMovingField(xx, yy);
8214 ChangeDelay[xx][yy] = 0;
8216 Tile[xx][yy] = EL_FLAMES;
8218 if (IN_SCR_FIELD(sx, sy))
8220 TEST_DrawLevelFieldCrumbled(xx, yy);
8221 DrawGraphic(sx, sy, flame_graphic, frame);
8226 if (Tile[xx][yy] == EL_FLAMES)
8227 Tile[xx][yy] = EL_EMPTY;
8228 TEST_DrawLevelField(xx, yy);
8233 if (MovDelay[x][y]) // element still has to wait some time
8235 PlayLevelSoundAction(x, y, ACTION_WAITING);
8241 // now make next step
8243 Moving2Blocked(x, y, &newx, &newy); // get next screen position
8245 if (DONT_COLLIDE_WITH(element) &&
8246 IN_LEV_FIELD(newx, newy) && IS_PLAYER(newx, newy) &&
8247 !PLAYER_ENEMY_PROTECTED(newx, newy))
8249 TestIfBadThingRunsIntoPlayer(x, y, MovDir[x][y]);
8254 else if (CAN_MOVE_INTO_ACID(element) &&
8255 IN_LEV_FIELD(newx, newy) && Tile[newx][newy] == EL_ACID &&
8256 !IS_MV_DIAGONAL(MovDir[x][y]) &&
8257 (MovDir[x][y] == MV_DOWN ||
8258 game.engine_version >= VERSION_IDENT(3,1,0,0)))
8260 SplashAcid(newx, newy);
8261 Store[x][y] = EL_ACID;
8263 else if (element == EL_PENGUIN && IN_LEV_FIELD(newx, newy))
8265 if (Tile[newx][newy] == EL_EXIT_OPEN ||
8266 Tile[newx][newy] == EL_EM_EXIT_OPEN ||
8267 Tile[newx][newy] == EL_STEEL_EXIT_OPEN ||
8268 Tile[newx][newy] == EL_EM_STEEL_EXIT_OPEN)
8271 TEST_DrawLevelField(x, y);
8273 PlayLevelSound(newx, newy, SND_PENGUIN_PASSING);
8274 if (IN_SCR_FIELD(SCREENX(newx), SCREENY(newy)))
8275 DrawGraphicThruMask(SCREENX(newx),SCREENY(newy), el2img(element), 0);
8277 game.friends_still_needed--;
8278 if (!game.friends_still_needed &&
8280 game.all_players_gone)
8285 else if (IS_FOOD_PENGUIN(Tile[newx][newy]))
8287 if (DigField(local_player, x, y, newx, newy, 0,0, DF_DIG) == MP_MOVING)
8288 TEST_DrawLevelField(newx, newy);
8290 GfxDir[x][y] = MovDir[x][y] = MV_NONE;
8292 else if (!IS_FREE(newx, newy))
8294 GfxAction[x][y] = ACTION_WAITING;
8296 if (IS_PLAYER(x, y))
8297 DrawPlayerField(x, y);
8299 TEST_DrawLevelField(x, y);
8304 else if (element == EL_PIG && IN_LEV_FIELD(newx, newy))
8306 if (IS_FOOD_PIG(Tile[newx][newy]))
8308 if (IS_MOVING(newx, newy))
8309 RemoveMovingField(newx, newy);
8312 Tile[newx][newy] = EL_EMPTY;
8313 TEST_DrawLevelField(newx, newy);
8316 PlayLevelSound(x, y, SND_PIG_DIGGING);
8318 else if (!IS_FREE(newx, newy))
8320 if (IS_PLAYER(x, y))
8321 DrawPlayerField(x, y);
8323 TEST_DrawLevelField(x, y);
8328 else if (element == EL_EMC_ANDROID && IN_LEV_FIELD(newx, newy))
8330 if (Store[x][y] != EL_EMPTY)
8332 boolean can_clone = FALSE;
8335 // check if element to clone is still there
8336 for (yy = y - 1; yy <= y + 1; yy++) for (xx = x - 1; xx <= x + 1; xx++)
8338 if (IN_LEV_FIELD(xx, yy) && Tile[xx][yy] == Store[x][y])
8346 // cannot clone or target field not free anymore -- do not clone
8347 if (!can_clone || !ANDROID_CAN_ENTER_FIELD(element, newx, newy))
8348 Store[x][y] = EL_EMPTY;
8351 if (ANDROID_CAN_ENTER_FIELD(element, newx, newy))
8353 if (IS_MV_DIAGONAL(MovDir[x][y]))
8355 int diagonal_move_dir = MovDir[x][y];
8356 int stored = Store[x][y];
8357 int change_delay = 8;
8360 // android is moving diagonally
8362 CreateField(x, y, EL_DIAGONAL_SHRINKING);
8364 Store[x][y] = (stored == EL_ACID ? EL_EMPTY : stored);
8365 GfxElement[x][y] = EL_EMC_ANDROID;
8366 GfxAction[x][y] = ACTION_SHRINKING;
8367 GfxDir[x][y] = diagonal_move_dir;
8368 ChangeDelay[x][y] = change_delay;
8370 graphic = el_act_dir2img(GfxElement[x][y], GfxAction[x][y],
8373 DrawLevelGraphicAnimation(x, y, graphic);
8374 PlayLevelSoundAction(x, y, ACTION_SHRINKING);
8376 if (Tile[newx][newy] == EL_ACID)
8378 SplashAcid(newx, newy);
8383 CreateField(newx, newy, EL_DIAGONAL_GROWING);
8385 Store[newx][newy] = EL_EMC_ANDROID;
8386 GfxElement[newx][newy] = EL_EMC_ANDROID;
8387 GfxAction[newx][newy] = ACTION_GROWING;
8388 GfxDir[newx][newy] = diagonal_move_dir;
8389 ChangeDelay[newx][newy] = change_delay;
8391 graphic = el_act_dir2img(GfxElement[newx][newy],
8392 GfxAction[newx][newy], GfxDir[newx][newy]);
8394 DrawLevelGraphicAnimation(newx, newy, graphic);
8395 PlayLevelSoundAction(newx, newy, ACTION_GROWING);
8401 Tile[newx][newy] = EL_EMPTY;
8402 TEST_DrawLevelField(newx, newy);
8404 PlayLevelSoundAction(x, y, ACTION_DIGGING);
8407 else if (!IS_FREE(newx, newy))
8412 else if (IS_CUSTOM_ELEMENT(element) &&
8413 CUSTOM_ELEMENT_CAN_ENTER_FIELD(element, newx, newy))
8415 if (!DigFieldByCE(newx, newy, element))
8418 if (move_pattern & MV_MAZE_RUNNER_STYLE)
8420 RunnerVisit[x][y] = FrameCounter;
8421 PlayerVisit[x][y] /= 8; // expire player visit path
8424 else if (element == EL_DRAGON && IN_LEV_FIELD(newx, newy))
8426 if (!IS_FREE(newx, newy))
8428 if (IS_PLAYER(x, y))
8429 DrawPlayerField(x, y);
8431 TEST_DrawLevelField(x, y);
8437 boolean wanna_flame = !RND(10);
8438 int dx = newx - x, dy = newy - y;
8439 int newx1 = newx + 1 * dx, newy1 = newy + 1 * dy;
8440 int newx2 = newx + 2 * dx, newy2 = newy + 2 * dy;
8441 int element1 = (IN_LEV_FIELD(newx1, newy1) ?
8442 MovingOrBlocked2Element(newx1, newy1) : EL_STEELWALL);
8443 int element2 = (IN_LEV_FIELD(newx2, newy2) ?
8444 MovingOrBlocked2Element(newx2, newy2) : EL_STEELWALL);
8447 IS_CLASSIC_ENEMY(element1) ||
8448 IS_CLASSIC_ENEMY(element2)) &&
8449 element1 != EL_DRAGON && element2 != EL_DRAGON &&
8450 element1 != EL_FLAMES && element2 != EL_FLAMES)
8452 ResetGfxAnimation(x, y);
8453 GfxAction[x][y] = ACTION_ATTACKING;
8455 if (IS_PLAYER(x, y))
8456 DrawPlayerField(x, y);
8458 TEST_DrawLevelField(x, y);
8460 PlayLevelSound(x, y, SND_DRAGON_ATTACKING);
8462 MovDelay[x][y] = 50;
8464 Tile[newx][newy] = EL_FLAMES;
8465 if (IN_LEV_FIELD(newx1, newy1) && Tile[newx1][newy1] == EL_EMPTY)
8466 Tile[newx1][newy1] = EL_FLAMES;
8467 if (IN_LEV_FIELD(newx2, newy2) && Tile[newx2][newy2] == EL_EMPTY)
8468 Tile[newx2][newy2] = EL_FLAMES;
8474 else if (element == EL_YAMYAM && IN_LEV_FIELD(newx, newy) &&
8475 Tile[newx][newy] == EL_DIAMOND)
8477 if (IS_MOVING(newx, newy))
8478 RemoveMovingField(newx, newy);
8481 Tile[newx][newy] = EL_EMPTY;
8482 TEST_DrawLevelField(newx, newy);
8485 PlayLevelSound(x, y, SND_YAMYAM_DIGGING);
8487 else if (element == EL_DARK_YAMYAM && IN_LEV_FIELD(newx, newy) &&
8488 IS_FOOD_DARK_YAMYAM(Tile[newx][newy]))
8490 if (AmoebaNr[newx][newy])
8492 AmoebaCnt2[AmoebaNr[newx][newy]]--;
8493 if (Tile[newx][newy] == EL_AMOEBA_FULL ||
8494 Tile[newx][newy] == EL_BD_AMOEBA)
8495 AmoebaCnt[AmoebaNr[newx][newy]]--;
8498 if (IS_MOVING(newx, newy))
8500 RemoveMovingField(newx, newy);
8504 Tile[newx][newy] = EL_EMPTY;
8505 TEST_DrawLevelField(newx, newy);
8508 PlayLevelSound(x, y, SND_DARK_YAMYAM_DIGGING);
8510 else if ((element == EL_PACMAN || element == EL_MOLE)
8511 && IN_LEV_FIELD(newx, newy) && IS_AMOEBOID(Tile[newx][newy]))
8513 if (AmoebaNr[newx][newy])
8515 AmoebaCnt2[AmoebaNr[newx][newy]]--;
8516 if (Tile[newx][newy] == EL_AMOEBA_FULL ||
8517 Tile[newx][newy] == EL_BD_AMOEBA)
8518 AmoebaCnt[AmoebaNr[newx][newy]]--;
8521 if (element == EL_MOLE)
8523 Tile[newx][newy] = EL_AMOEBA_SHRINKING;
8524 PlayLevelSound(x, y, SND_MOLE_DIGGING);
8526 ResetGfxAnimation(x, y);
8527 GfxAction[x][y] = ACTION_DIGGING;
8528 TEST_DrawLevelField(x, y);
8530 MovDelay[newx][newy] = 0; // start amoeba shrinking delay
8532 return; // wait for shrinking amoeba
8534 else // element == EL_PACMAN
8536 Tile[newx][newy] = EL_EMPTY;
8537 TEST_DrawLevelField(newx, newy);
8538 PlayLevelSound(x, y, SND_PACMAN_DIGGING);
8541 else if (element == EL_MOLE && IN_LEV_FIELD(newx, newy) &&
8542 (Tile[newx][newy] == EL_AMOEBA_SHRINKING ||
8543 (Tile[newx][newy] == EL_EMPTY && Stop[newx][newy])))
8545 // wait for shrinking amoeba to completely disappear
8548 else if (!IN_LEV_FIELD(newx, newy) || !IS_FREE(newx, newy))
8550 // object was running against a wall
8554 if (GFX_ELEMENT(element) != EL_SAND) // !!! FIX THIS (crumble) !!!
8555 DrawLevelElementAnimation(x, y, element);
8557 if (DONT_TOUCH(element))
8558 TestIfBadThingTouchesPlayer(x, y);
8563 InitMovingField(x, y, MovDir[x][y]);
8565 PlayLevelSoundAction(x, y, ACTION_MOVING);
8569 ContinueMoving(x, y);
8572 void ContinueMoving(int x, int y)
8574 int element = Tile[x][y];
8575 struct ElementInfo *ei = &element_info[element];
8576 int direction = MovDir[x][y];
8577 int dx = (direction == MV_LEFT ? -1 : direction == MV_RIGHT ? +1 : 0);
8578 int dy = (direction == MV_UP ? -1 : direction == MV_DOWN ? +1 : 0);
8579 int newx = x + dx, newy = y + dy;
8580 int stored = Store[x][y];
8581 int stored_new = Store[newx][newy];
8582 boolean pushed_by_player = (Pushed[x][y] && IS_PLAYER(x, y));
8583 boolean pushed_by_conveyor = (Pushed[x][y] && !IS_PLAYER(x, y));
8584 boolean last_line = (newy == lev_fieldy - 1);
8585 boolean use_step_delay = (GET_MAX_STEP_DELAY(element) != 0);
8587 if (pushed_by_player) // special case: moving object pushed by player
8589 MovPos[x][y] = SIGN(MovPos[x][y]) * (TILEX - ABS(PLAYERINFO(x,y)->MovPos));
8591 else if (use_step_delay) // special case: moving object has step delay
8593 if (!MovDelay[x][y])
8594 MovPos[x][y] += getElementMoveStepsize(x, y);
8599 MovDelay[x][y] = GET_NEW_STEP_DELAY(element);
8603 TEST_DrawLevelField(x, y);
8605 return; // element is still waiting
8608 else // normal case: generically moving object
8610 MovPos[x][y] += getElementMoveStepsize(x, y);
8613 if (ABS(MovPos[x][y]) < TILEX)
8615 TEST_DrawLevelField(x, y);
8617 return; // element is still moving
8620 // element reached destination field
8622 Tile[x][y] = EL_EMPTY;
8623 Tile[newx][newy] = element;
8624 MovPos[x][y] = 0; // force "not moving" for "crumbled sand"
8626 if (Store[x][y] == EL_ACID) // element is moving into acid pool
8628 element = Tile[newx][newy] = EL_ACID;
8630 else if (element == EL_MOLE)
8632 Tile[x][y] = EL_SAND;
8634 TEST_DrawLevelFieldCrumbledNeighbours(x, y);
8636 else if (element == EL_QUICKSAND_FILLING)
8638 element = Tile[newx][newy] = get_next_element(element);
8639 Store[newx][newy] = Store[x][y];
8641 else if (element == EL_QUICKSAND_EMPTYING)
8643 Tile[x][y] = get_next_element(element);
8644 element = Tile[newx][newy] = Store[x][y];
8646 else if (element == EL_QUICKSAND_FAST_FILLING)
8648 element = Tile[newx][newy] = get_next_element(element);
8649 Store[newx][newy] = Store[x][y];
8651 else if (element == EL_QUICKSAND_FAST_EMPTYING)
8653 Tile[x][y] = get_next_element(element);
8654 element = Tile[newx][newy] = Store[x][y];
8656 else if (element == EL_MAGIC_WALL_FILLING)
8658 element = Tile[newx][newy] = get_next_element(element);
8659 if (!game.magic_wall_active)
8660 element = Tile[newx][newy] = EL_MAGIC_WALL_DEAD;
8661 Store[newx][newy] = Store[x][y];
8663 else if (element == EL_MAGIC_WALL_EMPTYING)
8665 Tile[x][y] = get_next_element(element);
8666 if (!game.magic_wall_active)
8667 Tile[x][y] = EL_MAGIC_WALL_DEAD;
8668 element = Tile[newx][newy] = Store[x][y];
8670 InitField(newx, newy, FALSE);
8672 else if (element == EL_BD_MAGIC_WALL_FILLING)
8674 element = Tile[newx][newy] = get_next_element(element);
8675 if (!game.magic_wall_active)
8676 element = Tile[newx][newy] = EL_BD_MAGIC_WALL_DEAD;
8677 Store[newx][newy] = Store[x][y];
8679 else if (element == EL_BD_MAGIC_WALL_EMPTYING)
8681 Tile[x][y] = get_next_element(element);
8682 if (!game.magic_wall_active)
8683 Tile[x][y] = EL_BD_MAGIC_WALL_DEAD;
8684 element = Tile[newx][newy] = Store[x][y];
8686 InitField(newx, newy, FALSE);
8688 else if (element == EL_DC_MAGIC_WALL_FILLING)
8690 element = Tile[newx][newy] = get_next_element(element);
8691 if (!game.magic_wall_active)
8692 element = Tile[newx][newy] = EL_DC_MAGIC_WALL_DEAD;
8693 Store[newx][newy] = Store[x][y];
8695 else if (element == EL_DC_MAGIC_WALL_EMPTYING)
8697 Tile[x][y] = get_next_element(element);
8698 if (!game.magic_wall_active)
8699 Tile[x][y] = EL_DC_MAGIC_WALL_DEAD;
8700 element = Tile[newx][newy] = Store[x][y];
8702 InitField(newx, newy, FALSE);
8704 else if (element == EL_AMOEBA_DROPPING)
8706 Tile[x][y] = get_next_element(element);
8707 element = Tile[newx][newy] = Store[x][y];
8709 else if (element == EL_SOKOBAN_OBJECT)
8712 Tile[x][y] = Back[x][y];
8714 if (Back[newx][newy])
8715 Tile[newx][newy] = EL_SOKOBAN_FIELD_FULL;
8717 Back[x][y] = Back[newx][newy] = 0;
8720 Store[x][y] = EL_EMPTY;
8725 MovDelay[newx][newy] = 0;
8727 if (CAN_CHANGE_OR_HAS_ACTION(element))
8729 // copy element change control values to new field
8730 ChangeDelay[newx][newy] = ChangeDelay[x][y];
8731 ChangePage[newx][newy] = ChangePage[x][y];
8732 ChangeCount[newx][newy] = ChangeCount[x][y];
8733 ChangeEvent[newx][newy] = ChangeEvent[x][y];
8736 CustomValue[newx][newy] = CustomValue[x][y];
8738 ChangeDelay[x][y] = 0;
8739 ChangePage[x][y] = -1;
8740 ChangeCount[x][y] = 0;
8741 ChangeEvent[x][y] = -1;
8743 CustomValue[x][y] = 0;
8745 // copy animation control values to new field
8746 GfxFrame[newx][newy] = GfxFrame[x][y];
8747 GfxRandom[newx][newy] = GfxRandom[x][y]; // keep same random value
8748 GfxAction[newx][newy] = GfxAction[x][y]; // keep action one frame
8749 GfxDir[newx][newy] = GfxDir[x][y]; // keep element direction
8751 Pushed[x][y] = Pushed[newx][newy] = FALSE;
8753 // some elements can leave other elements behind after moving
8754 if (ei->move_leave_element != EL_EMPTY &&
8755 (ei->move_leave_type == LEAVE_TYPE_UNLIMITED || stored != EL_EMPTY) &&
8756 (!IS_PLAYER(x, y) || IS_WALKABLE(ei->move_leave_element)))
8758 int move_leave_element = ei->move_leave_element;
8760 // this makes it possible to leave the removed element again
8761 if (ei->move_leave_element == EL_TRIGGER_ELEMENT)
8762 move_leave_element = (stored == EL_ACID ? EL_EMPTY : stored);
8764 Tile[x][y] = move_leave_element;
8766 if (element_info[Tile[x][y]].move_direction_initial == MV_START_PREVIOUS)
8767 MovDir[x][y] = direction;
8769 InitField(x, y, FALSE);
8771 if (GFX_CRUMBLED(Tile[x][y]))
8772 TEST_DrawLevelFieldCrumbledNeighbours(x, y);
8774 if (ELEM_IS_PLAYER(move_leave_element))
8775 RelocatePlayer(x, y, move_leave_element);
8778 // do this after checking for left-behind element
8779 ResetGfxAnimation(x, y); // reset animation values for old field
8781 if (!CAN_MOVE(element) ||
8782 (CAN_FALL(element) && direction == MV_DOWN &&
8783 (element == EL_SPRING ||
8784 element_info[element].move_pattern == MV_WHEN_PUSHED ||
8785 element_info[element].move_pattern == MV_WHEN_DROPPED)))
8786 GfxDir[x][y] = MovDir[newx][newy] = 0;
8788 TEST_DrawLevelField(x, y);
8789 TEST_DrawLevelField(newx, newy);
8791 Stop[newx][newy] = TRUE; // ignore this element until the next frame
8793 // prevent pushed element from moving on in pushed direction
8794 if (pushed_by_player && CAN_MOVE(element) &&
8795 element_info[element].move_pattern & MV_ANY_DIRECTION &&
8796 !(element_info[element].move_pattern & direction))
8797 TurnRound(newx, newy);
8799 // prevent elements on conveyor belt from moving on in last direction
8800 if (pushed_by_conveyor && CAN_FALL(element) &&
8801 direction & MV_HORIZONTAL)
8802 MovDir[newx][newy] = 0;
8804 if (!pushed_by_player)
8806 int nextx = newx + dx, nexty = newy + dy;
8807 boolean check_collision_again = IN_LEV_FIELD_AND_IS_FREE(nextx, nexty);
8809 WasJustMoving[newx][newy] = CHECK_DELAY_MOVING;
8811 if (CAN_FALL(element) && direction == MV_DOWN)
8812 WasJustFalling[newx][newy] = CHECK_DELAY_FALLING;
8814 if ((!CAN_FALL(element) || direction == MV_DOWN) && check_collision_again)
8815 CheckCollision[newx][newy] = CHECK_DELAY_COLLISION;
8817 if (CAN_FALL(element) && direction == MV_DOWN && check_collision_again)
8818 CheckImpact[newx][newy] = CHECK_DELAY_IMPACT;
8821 if (DONT_TOUCH(element)) // object may be nasty to player or others
8823 TestIfBadThingTouchesPlayer(newx, newy);
8824 TestIfBadThingTouchesFriend(newx, newy);
8826 if (!IS_CUSTOM_ELEMENT(element))
8827 TestIfBadThingTouchesOtherBadThing(newx, newy);
8829 else if (element == EL_PENGUIN)
8830 TestIfFriendTouchesBadThing(newx, newy);
8832 if (DONT_GET_HIT_BY(element))
8834 TestIfGoodThingGetsHitByBadThing(newx, newy, direction);
8837 // give the player one last chance (one more frame) to move away
8838 if (CAN_FALL(element) && direction == MV_DOWN &&
8839 (last_line || (!IS_FREE(x, newy + 1) &&
8840 (!IS_PLAYER(x, newy + 1) ||
8841 game.engine_version < VERSION_IDENT(3,1,1,0)))))
8844 if (pushed_by_player && !game.use_change_when_pushing_bug)
8846 int push_side = MV_DIR_OPPOSITE(direction);
8847 struct PlayerInfo *player = PLAYERINFO(x, y);
8849 CheckElementChangeByPlayer(newx, newy, element, CE_PUSHED_BY_PLAYER,
8850 player->index_bit, push_side);
8851 CheckTriggeredElementChangeByPlayer(newx,newy, element, CE_PLAYER_PUSHES_X,
8852 player->index_bit, push_side);
8855 if (element == EL_EMC_ANDROID && pushed_by_player) // make another move
8856 MovDelay[newx][newy] = 1;
8858 CheckTriggeredElementChangeBySide(x, y, element, CE_MOVE_OF_X, direction);
8860 TestIfElementTouchesCustomElement(x, y); // empty or new element
8861 TestIfElementHitsCustomElement(newx, newy, direction);
8862 TestIfPlayerTouchesCustomElement(newx, newy);
8863 TestIfElementTouchesCustomElement(newx, newy);
8865 if (IS_CUSTOM_ELEMENT(element) && ei->move_enter_element != EL_EMPTY &&
8866 IS_EQUAL_OR_IN_GROUP(stored_new, ei->move_enter_element))
8867 CheckElementChangeBySide(newx, newy, element, stored_new, CE_DIGGING_X,
8868 MV_DIR_OPPOSITE(direction));
8871 int AmoebaNeighbourNr(int ax, int ay)
8874 int element = Tile[ax][ay];
8876 static int xy[4][2] =
8884 for (i = 0; i < NUM_DIRECTIONS; i++)
8886 int x = ax + xy[i][0];
8887 int y = ay + xy[i][1];
8889 if (!IN_LEV_FIELD(x, y))
8892 if (Tile[x][y] == element && AmoebaNr[x][y] > 0)
8893 group_nr = AmoebaNr[x][y];
8899 static void AmoebaMerge(int ax, int ay)
8901 int i, x, y, xx, yy;
8902 int new_group_nr = AmoebaNr[ax][ay];
8903 static int xy[4][2] =
8911 if (new_group_nr == 0)
8914 for (i = 0; i < NUM_DIRECTIONS; i++)
8919 if (!IN_LEV_FIELD(x, y))
8922 if ((Tile[x][y] == EL_AMOEBA_FULL ||
8923 Tile[x][y] == EL_BD_AMOEBA ||
8924 Tile[x][y] == EL_AMOEBA_DEAD) &&
8925 AmoebaNr[x][y] != new_group_nr)
8927 int old_group_nr = AmoebaNr[x][y];
8929 if (old_group_nr == 0)
8932 AmoebaCnt[new_group_nr] += AmoebaCnt[old_group_nr];
8933 AmoebaCnt[old_group_nr] = 0;
8934 AmoebaCnt2[new_group_nr] += AmoebaCnt2[old_group_nr];
8935 AmoebaCnt2[old_group_nr] = 0;
8937 SCAN_PLAYFIELD(xx, yy)
8939 if (AmoebaNr[xx][yy] == old_group_nr)
8940 AmoebaNr[xx][yy] = new_group_nr;
8946 void AmoebaToDiamond(int ax, int ay)
8950 if (Tile[ax][ay] == EL_AMOEBA_DEAD)
8952 int group_nr = AmoebaNr[ax][ay];
8957 Debug("game:playing:AmoebaToDiamond", "ax = %d, ay = %d", ax, ay);
8958 Debug("game:playing:AmoebaToDiamond", "This should never happen!");
8964 SCAN_PLAYFIELD(x, y)
8966 if (Tile[x][y] == EL_AMOEBA_DEAD && AmoebaNr[x][y] == group_nr)
8969 Tile[x][y] = EL_AMOEBA_TO_DIAMOND;
8973 PlayLevelSound(ax, ay, (IS_GEM(level.amoeba_content) ?
8974 SND_AMOEBA_TURNING_TO_GEM :
8975 SND_AMOEBA_TURNING_TO_ROCK));
8980 static int xy[4][2] =
8988 for (i = 0; i < NUM_DIRECTIONS; i++)
8993 if (!IN_LEV_FIELD(x, y))
8996 if (Tile[x][y] == EL_AMOEBA_TO_DIAMOND)
8998 PlayLevelSound(x, y, (IS_GEM(level.amoeba_content) ?
8999 SND_AMOEBA_TURNING_TO_GEM :
9000 SND_AMOEBA_TURNING_TO_ROCK));
9007 static void AmoebaToDiamondBD(int ax, int ay, int new_element)
9010 int group_nr = AmoebaNr[ax][ay];
9011 boolean done = FALSE;
9016 Debug("game:playing:AmoebaToDiamondBD", "ax = %d, ay = %d", ax, ay);
9017 Debug("game:playing:AmoebaToDiamondBD", "This should never happen!");
9023 SCAN_PLAYFIELD(x, y)
9025 if (AmoebaNr[x][y] == group_nr &&
9026 (Tile[x][y] == EL_AMOEBA_DEAD ||
9027 Tile[x][y] == EL_BD_AMOEBA ||
9028 Tile[x][y] == EL_AMOEBA_GROWING))
9031 Tile[x][y] = new_element;
9032 InitField(x, y, FALSE);
9033 TEST_DrawLevelField(x, y);
9039 PlayLevelSound(ax, ay, (new_element == EL_BD_ROCK ?
9040 SND_BD_AMOEBA_TURNING_TO_ROCK :
9041 SND_BD_AMOEBA_TURNING_TO_GEM));
9044 static void AmoebaGrowing(int x, int y)
9046 static unsigned int sound_delay = 0;
9047 static unsigned int sound_delay_value = 0;
9049 if (!MovDelay[x][y]) // start new growing cycle
9053 if (DelayReached(&sound_delay, sound_delay_value))
9055 PlayLevelSoundElementAction(x, y, Store[x][y], ACTION_GROWING);
9056 sound_delay_value = 30;
9060 if (MovDelay[x][y]) // wait some time before growing bigger
9063 if (MovDelay[x][y]/2 && IN_SCR_FIELD(SCREENX(x), SCREENY(y)))
9065 int frame = getGraphicAnimationFrame(IMG_AMOEBA_GROWING,
9066 6 - MovDelay[x][y]);
9068 DrawGraphic(SCREENX(x), SCREENY(y), IMG_AMOEBA_GROWING, frame);
9071 if (!MovDelay[x][y])
9073 Tile[x][y] = Store[x][y];
9075 TEST_DrawLevelField(x, y);
9080 static void AmoebaShrinking(int x, int y)
9082 static unsigned int sound_delay = 0;
9083 static unsigned int sound_delay_value = 0;
9085 if (!MovDelay[x][y]) // start new shrinking cycle
9089 if (DelayReached(&sound_delay, sound_delay_value))
9090 sound_delay_value = 30;
9093 if (MovDelay[x][y]) // wait some time before shrinking
9096 if (MovDelay[x][y]/2 && IN_SCR_FIELD(SCREENX(x), SCREENY(y)))
9098 int frame = getGraphicAnimationFrame(IMG_AMOEBA_SHRINKING,
9099 6 - MovDelay[x][y]);
9101 DrawGraphic(SCREENX(x), SCREENY(y), IMG_AMOEBA_SHRINKING, frame);
9104 if (!MovDelay[x][y])
9106 Tile[x][y] = EL_EMPTY;
9107 TEST_DrawLevelField(x, y);
9109 // don't let mole enter this field in this cycle;
9110 // (give priority to objects falling to this field from above)
9116 static void AmoebaReproduce(int ax, int ay)
9119 int element = Tile[ax][ay];
9120 int graphic = el2img(element);
9121 int newax = ax, neway = ay;
9122 boolean can_drop = (element == EL_AMOEBA_WET || element == EL_EMC_DRIPPER);
9123 static int xy[4][2] =
9131 if (!level.amoeba_speed && element != EL_EMC_DRIPPER)
9133 Tile[ax][ay] = EL_AMOEBA_DEAD;
9134 TEST_DrawLevelField(ax, ay);
9138 if (IS_ANIMATED(graphic))
9139 DrawLevelGraphicAnimationIfNeeded(ax, ay, graphic);
9141 if (!MovDelay[ax][ay]) // start making new amoeba field
9142 MovDelay[ax][ay] = RND(FRAMES_PER_SECOND * 25 / (1 + level.amoeba_speed));
9144 if (MovDelay[ax][ay]) // wait some time before making new amoeba
9147 if (MovDelay[ax][ay])
9151 if (can_drop) // EL_AMOEBA_WET or EL_EMC_DRIPPER
9154 int x = ax + xy[start][0];
9155 int y = ay + xy[start][1];
9157 if (!IN_LEV_FIELD(x, y))
9160 if (IS_FREE(x, y) ||
9161 CAN_GROW_INTO(Tile[x][y]) ||
9162 Tile[x][y] == EL_QUICKSAND_EMPTY ||
9163 Tile[x][y] == EL_QUICKSAND_FAST_EMPTY)
9169 if (newax == ax && neway == ay)
9172 else // normal or "filled" (BD style) amoeba
9175 boolean waiting_for_player = FALSE;
9177 for (i = 0; i < NUM_DIRECTIONS; i++)
9179 int j = (start + i) % 4;
9180 int x = ax + xy[j][0];
9181 int y = ay + xy[j][1];
9183 if (!IN_LEV_FIELD(x, y))
9186 if (IS_FREE(x, y) ||
9187 CAN_GROW_INTO(Tile[x][y]) ||
9188 Tile[x][y] == EL_QUICKSAND_EMPTY ||
9189 Tile[x][y] == EL_QUICKSAND_FAST_EMPTY)
9195 else if (IS_PLAYER(x, y))
9196 waiting_for_player = TRUE;
9199 if (newax == ax && neway == ay) // amoeba cannot grow
9201 if (i == 4 && (!waiting_for_player || element == EL_BD_AMOEBA))
9203 Tile[ax][ay] = EL_AMOEBA_DEAD;
9204 TEST_DrawLevelField(ax, ay);
9205 AmoebaCnt[AmoebaNr[ax][ay]]--;
9207 if (AmoebaCnt[AmoebaNr[ax][ay]] <= 0) // amoeba is completely dead
9209 if (element == EL_AMOEBA_FULL)
9210 AmoebaToDiamond(ax, ay);
9211 else if (element == EL_BD_AMOEBA)
9212 AmoebaToDiamondBD(ax, ay, level.amoeba_content);
9217 else if (element == EL_AMOEBA_FULL || element == EL_BD_AMOEBA)
9219 // amoeba gets larger by growing in some direction
9221 int new_group_nr = AmoebaNr[ax][ay];
9224 if (new_group_nr == 0)
9226 Debug("game:playing:AmoebaReproduce", "newax = %d, neway = %d",
9228 Debug("game:playing:AmoebaReproduce", "This should never happen!");
9234 AmoebaNr[newax][neway] = new_group_nr;
9235 AmoebaCnt[new_group_nr]++;
9236 AmoebaCnt2[new_group_nr]++;
9238 // if amoeba touches other amoeba(s) after growing, unify them
9239 AmoebaMerge(newax, neway);
9241 if (element == EL_BD_AMOEBA && AmoebaCnt2[new_group_nr] >= 200)
9243 AmoebaToDiamondBD(newax, neway, EL_BD_ROCK);
9249 if (!can_drop || neway < ay || !IS_FREE(newax, neway) ||
9250 (neway == lev_fieldy - 1 && newax != ax))
9252 Tile[newax][neway] = EL_AMOEBA_GROWING; // creation of new amoeba
9253 Store[newax][neway] = element;
9255 else if (neway == ay || element == EL_EMC_DRIPPER)
9257 Tile[newax][neway] = EL_AMOEBA_DROP; // drop left/right of amoeba
9259 PlayLevelSoundAction(newax, neway, ACTION_GROWING);
9263 InitMovingField(ax, ay, MV_DOWN); // drop dripping from amoeba
9264 Tile[ax][ay] = EL_AMOEBA_DROPPING;
9265 Store[ax][ay] = EL_AMOEBA_DROP;
9266 ContinueMoving(ax, ay);
9270 TEST_DrawLevelField(newax, neway);
9273 static void Life(int ax, int ay)
9277 int element = Tile[ax][ay];
9278 int graphic = el2img(element);
9279 int *life_parameter = (element == EL_GAME_OF_LIFE ? level.game_of_life :
9281 boolean changed = FALSE;
9283 if (IS_ANIMATED(graphic))
9284 DrawLevelGraphicAnimationIfNeeded(ax, ay, graphic);
9289 if (!MovDelay[ax][ay]) // start new "game of life" cycle
9290 MovDelay[ax][ay] = life_time;
9292 if (MovDelay[ax][ay]) // wait some time before next cycle
9295 if (MovDelay[ax][ay])
9299 for (y1 = -1; y1 < 2; y1++) for (x1 = -1; x1 < 2; x1++)
9301 int xx = ax+x1, yy = ay+y1;
9302 int old_element = Tile[xx][yy];
9303 int num_neighbours = 0;
9305 if (!IN_LEV_FIELD(xx, yy))
9308 for (y2 = -1; y2 < 2; y2++) for (x2 = -1; x2 < 2; x2++)
9310 int x = xx+x2, y = yy+y2;
9312 if (!IN_LEV_FIELD(x, y) || (x == xx && y == yy))
9315 boolean is_player_cell = (element == EL_GAME_OF_LIFE && IS_PLAYER(x, y));
9316 boolean is_neighbour = FALSE;
9318 if (level.use_life_bugs)
9320 (((Tile[x][y] == element || is_player_cell) && !Stop[x][y]) ||
9321 (IS_FREE(x, y) && Stop[x][y]));
9324 (Last[x][y] == element || is_player_cell);
9330 boolean is_free = FALSE;
9332 if (level.use_life_bugs)
9333 is_free = (IS_FREE(xx, yy));
9335 is_free = (IS_FREE(xx, yy) && Last[xx][yy] == EL_EMPTY);
9337 if (xx == ax && yy == ay) // field in the middle
9339 if (num_neighbours < life_parameter[0] ||
9340 num_neighbours > life_parameter[1])
9342 Tile[xx][yy] = EL_EMPTY;
9343 if (Tile[xx][yy] != old_element)
9344 TEST_DrawLevelField(xx, yy);
9345 Stop[xx][yy] = TRUE;
9349 else if (is_free || CAN_GROW_INTO(Tile[xx][yy]))
9350 { // free border field
9351 if (num_neighbours >= life_parameter[2] &&
9352 num_neighbours <= life_parameter[3])
9354 Tile[xx][yy] = element;
9355 MovDelay[xx][yy] = (element == EL_GAME_OF_LIFE ? 0 : life_time-1);
9356 if (Tile[xx][yy] != old_element)
9357 TEST_DrawLevelField(xx, yy);
9358 Stop[xx][yy] = TRUE;
9365 PlayLevelSound(ax, ay, element == EL_BIOMAZE ? SND_BIOMAZE_GROWING :
9366 SND_GAME_OF_LIFE_GROWING);
9369 static void InitRobotWheel(int x, int y)
9371 ChangeDelay[x][y] = level.time_wheel * FRAMES_PER_SECOND;
9374 static void RunRobotWheel(int x, int y)
9376 PlayLevelSound(x, y, SND_ROBOT_WHEEL_ACTIVE);
9379 static void StopRobotWheel(int x, int y)
9381 if (game.robot_wheel_x == x &&
9382 game.robot_wheel_y == y)
9384 game.robot_wheel_x = -1;
9385 game.robot_wheel_y = -1;
9386 game.robot_wheel_active = FALSE;
9390 static void InitTimegateWheel(int x, int y)
9392 ChangeDelay[x][y] = level.time_timegate * FRAMES_PER_SECOND;
9395 static void RunTimegateWheel(int x, int y)
9397 PlayLevelSound(x, y, SND_CLASS_TIMEGATE_SWITCH_ACTIVE);
9400 static void InitMagicBallDelay(int x, int y)
9402 ChangeDelay[x][y] = (level.ball_time + 1) * 8 + 1;
9405 static void ActivateMagicBall(int bx, int by)
9409 if (level.ball_random)
9411 int pos_border = RND(8); // select one of the eight border elements
9412 int pos_content = (pos_border > 3 ? pos_border + 1 : pos_border);
9413 int xx = pos_content % 3;
9414 int yy = pos_content / 3;
9419 if (IN_LEV_FIELD(x, y) && Tile[x][y] == EL_EMPTY)
9420 CreateField(x, y, level.ball_content[game.ball_content_nr].e[xx][yy]);
9424 for (y = by - 1; y <= by + 1; y++) for (x = bx - 1; x <= bx + 1; x++)
9426 int xx = x - bx + 1;
9427 int yy = y - by + 1;
9429 if (IN_LEV_FIELD(x, y) && Tile[x][y] == EL_EMPTY)
9430 CreateField(x, y, level.ball_content[game.ball_content_nr].e[xx][yy]);
9434 game.ball_content_nr = (game.ball_content_nr + 1) % level.num_ball_contents;
9437 static void CheckExit(int x, int y)
9439 if (game.gems_still_needed > 0 ||
9440 game.sokoban_fields_still_needed > 0 ||
9441 game.sokoban_objects_still_needed > 0 ||
9442 game.lights_still_needed > 0)
9444 int element = Tile[x][y];
9445 int graphic = el2img(element);
9447 if (IS_ANIMATED(graphic))
9448 DrawLevelGraphicAnimationIfNeeded(x, y, graphic);
9453 // do not re-open exit door closed after last player
9454 if (game.all_players_gone)
9457 Tile[x][y] = EL_EXIT_OPENING;
9459 PlayLevelSoundNearest(x, y, SND_CLASS_EXIT_OPENING);
9462 static void CheckExitEM(int x, int y)
9464 if (game.gems_still_needed > 0 ||
9465 game.sokoban_fields_still_needed > 0 ||
9466 game.sokoban_objects_still_needed > 0 ||
9467 game.lights_still_needed > 0)
9469 int element = Tile[x][y];
9470 int graphic = el2img(element);
9472 if (IS_ANIMATED(graphic))
9473 DrawLevelGraphicAnimationIfNeeded(x, y, graphic);
9478 // do not re-open exit door closed after last player
9479 if (game.all_players_gone)
9482 Tile[x][y] = EL_EM_EXIT_OPENING;
9484 PlayLevelSoundNearest(x, y, SND_CLASS_EM_EXIT_OPENING);
9487 static void CheckExitSteel(int x, int y)
9489 if (game.gems_still_needed > 0 ||
9490 game.sokoban_fields_still_needed > 0 ||
9491 game.sokoban_objects_still_needed > 0 ||
9492 game.lights_still_needed > 0)
9494 int element = Tile[x][y];
9495 int graphic = el2img(element);
9497 if (IS_ANIMATED(graphic))
9498 DrawLevelGraphicAnimationIfNeeded(x, y, graphic);
9503 // do not re-open exit door closed after last player
9504 if (game.all_players_gone)
9507 Tile[x][y] = EL_STEEL_EXIT_OPENING;
9509 PlayLevelSoundNearest(x, y, SND_CLASS_STEEL_EXIT_OPENING);
9512 static void CheckExitSteelEM(int x, int y)
9514 if (game.gems_still_needed > 0 ||
9515 game.sokoban_fields_still_needed > 0 ||
9516 game.sokoban_objects_still_needed > 0 ||
9517 game.lights_still_needed > 0)
9519 int element = Tile[x][y];
9520 int graphic = el2img(element);
9522 if (IS_ANIMATED(graphic))
9523 DrawLevelGraphicAnimationIfNeeded(x, y, graphic);
9528 // do not re-open exit door closed after last player
9529 if (game.all_players_gone)
9532 Tile[x][y] = EL_EM_STEEL_EXIT_OPENING;
9534 PlayLevelSoundNearest(x, y, SND_CLASS_EM_STEEL_EXIT_OPENING);
9537 static void CheckExitSP(int x, int y)
9539 if (game.gems_still_needed > 0)
9541 int element = Tile[x][y];
9542 int graphic = el2img(element);
9544 if (IS_ANIMATED(graphic))
9545 DrawLevelGraphicAnimationIfNeeded(x, y, graphic);
9550 // do not re-open exit door closed after last player
9551 if (game.all_players_gone)
9554 Tile[x][y] = EL_SP_EXIT_OPENING;
9556 PlayLevelSoundNearest(x, y, SND_CLASS_SP_EXIT_OPENING);
9559 static void CloseAllOpenTimegates(void)
9563 SCAN_PLAYFIELD(x, y)
9565 int element = Tile[x][y];
9567 if (element == EL_TIMEGATE_OPEN || element == EL_TIMEGATE_OPENING)
9569 Tile[x][y] = EL_TIMEGATE_CLOSING;
9571 PlayLevelSoundAction(x, y, ACTION_CLOSING);
9576 static void DrawTwinkleOnField(int x, int y)
9578 if (!IN_SCR_FIELD(SCREENX(x), SCREENY(y)) || IS_MOVING(x, y))
9581 if (Tile[x][y] == EL_BD_DIAMOND)
9584 if (MovDelay[x][y] == 0) // next animation frame
9585 MovDelay[x][y] = 11 * !GetSimpleRandom(500);
9587 if (MovDelay[x][y] != 0) // wait some time before next frame
9591 DrawLevelElementAnimation(x, y, Tile[x][y]);
9593 if (MovDelay[x][y] != 0)
9595 int frame = getGraphicAnimationFrame(IMG_TWINKLE_WHITE,
9596 10 - MovDelay[x][y]);
9598 DrawGraphicThruMask(SCREENX(x), SCREENY(y), IMG_TWINKLE_WHITE, frame);
9603 static void MauerWaechst(int x, int y)
9607 if (!MovDelay[x][y]) // next animation frame
9608 MovDelay[x][y] = 3 * delay;
9610 if (MovDelay[x][y]) // wait some time before next frame
9614 if (IN_SCR_FIELD(SCREENX(x), SCREENY(y)))
9616 int graphic = el_dir2img(Tile[x][y], GfxDir[x][y]);
9617 int frame = getGraphicAnimationFrame(graphic, 17 - MovDelay[x][y]);
9619 DrawGraphic(SCREENX(x), SCREENY(y), graphic, frame);
9622 if (!MovDelay[x][y])
9624 if (MovDir[x][y] == MV_LEFT)
9626 if (IN_LEV_FIELD(x - 1, y) && IS_WALL(Tile[x - 1][y]))
9627 TEST_DrawLevelField(x - 1, y);
9629 else if (MovDir[x][y] == MV_RIGHT)
9631 if (IN_LEV_FIELD(x + 1, y) && IS_WALL(Tile[x + 1][y]))
9632 TEST_DrawLevelField(x + 1, y);
9634 else if (MovDir[x][y] == MV_UP)
9636 if (IN_LEV_FIELD(x, y - 1) && IS_WALL(Tile[x][y - 1]))
9637 TEST_DrawLevelField(x, y - 1);
9641 if (IN_LEV_FIELD(x, y + 1) && IS_WALL(Tile[x][y + 1]))
9642 TEST_DrawLevelField(x, y + 1);
9645 Tile[x][y] = Store[x][y];
9647 GfxDir[x][y] = MovDir[x][y] = MV_NONE;
9648 TEST_DrawLevelField(x, y);
9653 static void MauerAbleger(int ax, int ay)
9655 int element = Tile[ax][ay];
9656 int graphic = el2img(element);
9657 boolean oben_frei = FALSE, unten_frei = FALSE;
9658 boolean links_frei = FALSE, rechts_frei = FALSE;
9659 boolean oben_massiv = FALSE, unten_massiv = FALSE;
9660 boolean links_massiv = FALSE, rechts_massiv = FALSE;
9661 boolean new_wall = FALSE;
9663 if (IS_ANIMATED(graphic))
9664 DrawLevelGraphicAnimationIfNeeded(ax, ay, graphic);
9666 if (!MovDelay[ax][ay]) // start building new wall
9667 MovDelay[ax][ay] = 6;
9669 if (MovDelay[ax][ay]) // wait some time before building new wall
9672 if (MovDelay[ax][ay])
9676 if (IN_LEV_FIELD(ax, ay-1) && IS_FREE(ax, ay-1))
9678 if (IN_LEV_FIELD(ax, ay+1) && IS_FREE(ax, ay+1))
9680 if (IN_LEV_FIELD(ax-1, ay) && IS_FREE(ax-1, ay))
9682 if (IN_LEV_FIELD(ax+1, ay) && IS_FREE(ax+1, ay))
9685 if (element == EL_EXPANDABLE_WALL_VERTICAL ||
9686 element == EL_EXPANDABLE_WALL_ANY)
9690 Tile[ax][ay-1] = EL_EXPANDABLE_WALL_GROWING;
9691 Store[ax][ay-1] = element;
9692 GfxDir[ax][ay-1] = MovDir[ax][ay-1] = MV_UP;
9693 if (IN_SCR_FIELD(SCREENX(ax), SCREENY(ay-1)))
9694 DrawGraphic(SCREENX(ax), SCREENY(ay - 1),
9695 IMG_EXPANDABLE_WALL_GROWING_UP, 0);
9700 Tile[ax][ay+1] = EL_EXPANDABLE_WALL_GROWING;
9701 Store[ax][ay+1] = element;
9702 GfxDir[ax][ay+1] = MovDir[ax][ay+1] = MV_DOWN;
9703 if (IN_SCR_FIELD(SCREENX(ax), SCREENY(ay+1)))
9704 DrawGraphic(SCREENX(ax), SCREENY(ay + 1),
9705 IMG_EXPANDABLE_WALL_GROWING_DOWN, 0);
9710 if (element == EL_EXPANDABLE_WALL_HORIZONTAL ||
9711 element == EL_EXPANDABLE_WALL_ANY ||
9712 element == EL_EXPANDABLE_WALL ||
9713 element == EL_BD_EXPANDABLE_WALL)
9717 Tile[ax-1][ay] = EL_EXPANDABLE_WALL_GROWING;
9718 Store[ax-1][ay] = element;
9719 GfxDir[ax-1][ay] = MovDir[ax-1][ay] = MV_LEFT;
9720 if (IN_SCR_FIELD(SCREENX(ax-1), SCREENY(ay)))
9721 DrawGraphic(SCREENX(ax - 1), SCREENY(ay),
9722 IMG_EXPANDABLE_WALL_GROWING_LEFT, 0);
9728 Tile[ax+1][ay] = EL_EXPANDABLE_WALL_GROWING;
9729 Store[ax+1][ay] = element;
9730 GfxDir[ax+1][ay] = MovDir[ax+1][ay] = MV_RIGHT;
9731 if (IN_SCR_FIELD(SCREENX(ax+1), SCREENY(ay)))
9732 DrawGraphic(SCREENX(ax + 1), SCREENY(ay),
9733 IMG_EXPANDABLE_WALL_GROWING_RIGHT, 0);
9738 if (element == EL_EXPANDABLE_WALL && (links_frei || rechts_frei))
9739 TEST_DrawLevelField(ax, ay);
9741 if (!IN_LEV_FIELD(ax, ay-1) || IS_WALL(Tile[ax][ay-1]))
9743 if (!IN_LEV_FIELD(ax, ay+1) || IS_WALL(Tile[ax][ay+1]))
9744 unten_massiv = TRUE;
9745 if (!IN_LEV_FIELD(ax-1, ay) || IS_WALL(Tile[ax-1][ay]))
9746 links_massiv = TRUE;
9747 if (!IN_LEV_FIELD(ax+1, ay) || IS_WALL(Tile[ax+1][ay]))
9748 rechts_massiv = TRUE;
9750 if (((oben_massiv && unten_massiv) ||
9751 element == EL_EXPANDABLE_WALL_HORIZONTAL ||
9752 element == EL_EXPANDABLE_WALL) &&
9753 ((links_massiv && rechts_massiv) ||
9754 element == EL_EXPANDABLE_WALL_VERTICAL))
9755 Tile[ax][ay] = EL_WALL;
9758 PlayLevelSoundAction(ax, ay, ACTION_GROWING);
9761 static void MauerAblegerStahl(int ax, int ay)
9763 int element = Tile[ax][ay];
9764 int graphic = el2img(element);
9765 boolean oben_frei = FALSE, unten_frei = FALSE;
9766 boolean links_frei = FALSE, rechts_frei = FALSE;
9767 boolean oben_massiv = FALSE, unten_massiv = FALSE;
9768 boolean links_massiv = FALSE, rechts_massiv = FALSE;
9769 boolean new_wall = FALSE;
9771 if (IS_ANIMATED(graphic))
9772 DrawLevelGraphicAnimationIfNeeded(ax, ay, graphic);
9774 if (!MovDelay[ax][ay]) // start building new wall
9775 MovDelay[ax][ay] = 6;
9777 if (MovDelay[ax][ay]) // wait some time before building new wall
9780 if (MovDelay[ax][ay])
9784 if (IN_LEV_FIELD(ax, ay-1) && IS_FREE(ax, ay-1))
9786 if (IN_LEV_FIELD(ax, ay+1) && IS_FREE(ax, ay+1))
9788 if (IN_LEV_FIELD(ax-1, ay) && IS_FREE(ax-1, ay))
9790 if (IN_LEV_FIELD(ax+1, ay) && IS_FREE(ax+1, ay))
9793 if (element == EL_EXPANDABLE_STEELWALL_VERTICAL ||
9794 element == EL_EXPANDABLE_STEELWALL_ANY)
9798 Tile[ax][ay-1] = EL_EXPANDABLE_STEELWALL_GROWING;
9799 Store[ax][ay-1] = element;
9800 GfxDir[ax][ay-1] = MovDir[ax][ay-1] = MV_UP;
9801 if (IN_SCR_FIELD(SCREENX(ax), SCREENY(ay-1)))
9802 DrawGraphic(SCREENX(ax), SCREENY(ay - 1),
9803 IMG_EXPANDABLE_STEELWALL_GROWING_UP, 0);
9808 Tile[ax][ay+1] = EL_EXPANDABLE_STEELWALL_GROWING;
9809 Store[ax][ay+1] = element;
9810 GfxDir[ax][ay+1] = MovDir[ax][ay+1] = MV_DOWN;
9811 if (IN_SCR_FIELD(SCREENX(ax), SCREENY(ay+1)))
9812 DrawGraphic(SCREENX(ax), SCREENY(ay + 1),
9813 IMG_EXPANDABLE_STEELWALL_GROWING_DOWN, 0);
9818 if (element == EL_EXPANDABLE_STEELWALL_HORIZONTAL ||
9819 element == EL_EXPANDABLE_STEELWALL_ANY)
9823 Tile[ax-1][ay] = EL_EXPANDABLE_STEELWALL_GROWING;
9824 Store[ax-1][ay] = element;
9825 GfxDir[ax-1][ay] = MovDir[ax-1][ay] = MV_LEFT;
9826 if (IN_SCR_FIELD(SCREENX(ax-1), SCREENY(ay)))
9827 DrawGraphic(SCREENX(ax - 1), SCREENY(ay),
9828 IMG_EXPANDABLE_STEELWALL_GROWING_LEFT, 0);
9834 Tile[ax+1][ay] = EL_EXPANDABLE_STEELWALL_GROWING;
9835 Store[ax+1][ay] = element;
9836 GfxDir[ax+1][ay] = MovDir[ax+1][ay] = MV_RIGHT;
9837 if (IN_SCR_FIELD(SCREENX(ax+1), SCREENY(ay)))
9838 DrawGraphic(SCREENX(ax + 1), SCREENY(ay),
9839 IMG_EXPANDABLE_STEELWALL_GROWING_RIGHT, 0);
9844 if (!IN_LEV_FIELD(ax, ay-1) || IS_WALL(Tile[ax][ay-1]))
9846 if (!IN_LEV_FIELD(ax, ay+1) || IS_WALL(Tile[ax][ay+1]))
9847 unten_massiv = TRUE;
9848 if (!IN_LEV_FIELD(ax-1, ay) || IS_WALL(Tile[ax-1][ay]))
9849 links_massiv = TRUE;
9850 if (!IN_LEV_FIELD(ax+1, ay) || IS_WALL(Tile[ax+1][ay]))
9851 rechts_massiv = TRUE;
9853 if (((oben_massiv && unten_massiv) ||
9854 element == EL_EXPANDABLE_STEELWALL_HORIZONTAL) &&
9855 ((links_massiv && rechts_massiv) ||
9856 element == EL_EXPANDABLE_STEELWALL_VERTICAL))
9857 Tile[ax][ay] = EL_STEELWALL;
9860 PlayLevelSoundAction(ax, ay, ACTION_GROWING);
9863 static void CheckForDragon(int x, int y)
9866 boolean dragon_found = FALSE;
9867 static int xy[4][2] =
9875 for (i = 0; i < NUM_DIRECTIONS; i++)
9877 for (j = 0; j < 4; j++)
9879 int xx = x + j * xy[i][0], yy = y + j * xy[i][1];
9881 if (IN_LEV_FIELD(xx, yy) &&
9882 (Tile[xx][yy] == EL_FLAMES || Tile[xx][yy] == EL_DRAGON))
9884 if (Tile[xx][yy] == EL_DRAGON)
9885 dragon_found = TRUE;
9894 for (i = 0; i < NUM_DIRECTIONS; i++)
9896 for (j = 0; j < 3; j++)
9898 int xx = x + j * xy[i][0], yy = y + j * xy[i][1];
9900 if (IN_LEV_FIELD(xx, yy) && Tile[xx][yy] == EL_FLAMES)
9902 Tile[xx][yy] = EL_EMPTY;
9903 TEST_DrawLevelField(xx, yy);
9912 static void InitBuggyBase(int x, int y)
9914 int element = Tile[x][y];
9915 int activating_delay = FRAMES_PER_SECOND / 4;
9918 (element == EL_SP_BUGGY_BASE ?
9919 2 * FRAMES_PER_SECOND + RND(5 * FRAMES_PER_SECOND) - activating_delay :
9920 element == EL_SP_BUGGY_BASE_ACTIVATING ?
9922 element == EL_SP_BUGGY_BASE_ACTIVE ?
9923 1 * FRAMES_PER_SECOND + RND(1 * FRAMES_PER_SECOND) : 1);
9926 static void WarnBuggyBase(int x, int y)
9929 static int xy[4][2] =
9937 for (i = 0; i < NUM_DIRECTIONS; i++)
9939 int xx = x + xy[i][0];
9940 int yy = y + xy[i][1];
9942 if (IN_LEV_FIELD(xx, yy) && IS_PLAYER(xx, yy))
9944 PlayLevelSound(x, y, SND_SP_BUGGY_BASE_ACTIVE);
9951 static void InitTrap(int x, int y)
9953 ChangeDelay[x][y] = 2 * FRAMES_PER_SECOND + RND(5 * FRAMES_PER_SECOND);
9956 static void ActivateTrap(int x, int y)
9958 PlayLevelSound(x, y, SND_TRAP_ACTIVATING);
9961 static void ChangeActiveTrap(int x, int y)
9963 int graphic = IMG_TRAP_ACTIVE;
9965 // if new animation frame was drawn, correct crumbled sand border
9966 if (IS_NEW_FRAME(GfxFrame[x][y], graphic))
9967 TEST_DrawLevelFieldCrumbled(x, y);
9970 static int getSpecialActionElement(int element, int number, int base_element)
9972 return (element != EL_EMPTY ? element :
9973 number != -1 ? base_element + number - 1 :
9977 static int getModifiedActionNumber(int value_old, int operator, int operand,
9978 int value_min, int value_max)
9980 int value_new = (operator == CA_MODE_SET ? operand :
9981 operator == CA_MODE_ADD ? value_old + operand :
9982 operator == CA_MODE_SUBTRACT ? value_old - operand :
9983 operator == CA_MODE_MULTIPLY ? value_old * operand :
9984 operator == CA_MODE_DIVIDE ? value_old / MAX(1, operand) :
9985 operator == CA_MODE_MODULO ? value_old % MAX(1, operand) :
9988 return (value_new < value_min ? value_min :
9989 value_new > value_max ? value_max :
9993 static void ExecuteCustomElementAction(int x, int y, int element, int page)
9995 struct ElementInfo *ei = &element_info[element];
9996 struct ElementChangeInfo *change = &ei->change_page[page];
9997 int target_element = change->target_element;
9998 int action_type = change->action_type;
9999 int action_mode = change->action_mode;
10000 int action_arg = change->action_arg;
10001 int action_element = change->action_element;
10004 if (!change->has_action)
10007 // ---------- determine action paramater values -----------------------------
10009 int level_time_value =
10010 (level.time > 0 ? TimeLeft :
10013 int action_arg_element_raw =
10014 (action_arg == CA_ARG_PLAYER_TRIGGER ? change->actual_trigger_player :
10015 action_arg == CA_ARG_ELEMENT_TRIGGER ? change->actual_trigger_element :
10016 action_arg == CA_ARG_ELEMENT_TARGET ? change->target_element :
10017 action_arg == CA_ARG_ELEMENT_ACTION ? change->action_element :
10018 action_arg == CA_ARG_INVENTORY_RM_TRIGGER ? change->actual_trigger_element:
10019 action_arg == CA_ARG_INVENTORY_RM_TARGET ? change->target_element :
10020 action_arg == CA_ARG_INVENTORY_RM_ACTION ? change->action_element :
10022 int action_arg_element = GetElementFromGroupElement(action_arg_element_raw);
10024 int action_arg_direction =
10025 (action_arg >= CA_ARG_DIRECTION_LEFT &&
10026 action_arg <= CA_ARG_DIRECTION_DOWN ? action_arg - CA_ARG_DIRECTION :
10027 action_arg == CA_ARG_DIRECTION_TRIGGER ?
10028 change->actual_trigger_side :
10029 action_arg == CA_ARG_DIRECTION_TRIGGER_BACK ?
10030 MV_DIR_OPPOSITE(change->actual_trigger_side) :
10033 int action_arg_number_min =
10034 (action_type == CA_SET_PLAYER_SPEED ? STEPSIZE_NOT_MOVING :
10037 int action_arg_number_max =
10038 (action_type == CA_SET_PLAYER_SPEED ? STEPSIZE_EVEN_FASTER :
10039 action_type == CA_SET_LEVEL_GEMS ? 999 :
10040 action_type == CA_SET_LEVEL_TIME ? 9999 :
10041 action_type == CA_SET_LEVEL_SCORE ? 99999 :
10042 action_type == CA_SET_CE_VALUE ? 9999 :
10043 action_type == CA_SET_CE_SCORE ? 9999 :
10046 int action_arg_number_reset =
10047 (action_type == CA_SET_PLAYER_SPEED ? level.initial_player_stepsize[0] :
10048 action_type == CA_SET_LEVEL_GEMS ? level.gems_needed :
10049 action_type == CA_SET_LEVEL_TIME ? level.time :
10050 action_type == CA_SET_LEVEL_SCORE ? 0 :
10051 action_type == CA_SET_CE_VALUE ? GET_NEW_CE_VALUE(element) :
10052 action_type == CA_SET_CE_SCORE ? 0 :
10055 int action_arg_number =
10056 (action_arg <= CA_ARG_MAX ? action_arg :
10057 action_arg >= CA_ARG_SPEED_NOT_MOVING &&
10058 action_arg <= CA_ARG_SPEED_EVEN_FASTER ? (action_arg - CA_ARG_SPEED) :
10059 action_arg == CA_ARG_SPEED_RESET ? action_arg_number_reset :
10060 action_arg == CA_ARG_NUMBER_MIN ? action_arg_number_min :
10061 action_arg == CA_ARG_NUMBER_MAX ? action_arg_number_max :
10062 action_arg == CA_ARG_NUMBER_RESET ? action_arg_number_reset :
10063 action_arg == CA_ARG_NUMBER_CE_VALUE ? CustomValue[x][y] :
10064 action_arg == CA_ARG_NUMBER_CE_SCORE ? ei->collect_score :
10065 action_arg == CA_ARG_NUMBER_CE_DELAY ? GET_CE_DELAY_VALUE(change) :
10066 action_arg == CA_ARG_NUMBER_LEVEL_TIME ? level_time_value :
10067 action_arg == CA_ARG_NUMBER_LEVEL_GEMS ? game.gems_still_needed :
10068 action_arg == CA_ARG_NUMBER_LEVEL_SCORE ? game.score :
10069 action_arg == CA_ARG_ELEMENT_CV_TARGET ? GET_NEW_CE_VALUE(target_element):
10070 action_arg == CA_ARG_ELEMENT_CV_TRIGGER ? change->actual_trigger_ce_value:
10071 action_arg == CA_ARG_ELEMENT_CV_ACTION ? GET_NEW_CE_VALUE(action_element):
10072 action_arg == CA_ARG_ELEMENT_CS_TARGET ? GET_CE_SCORE(target_element) :
10073 action_arg == CA_ARG_ELEMENT_CS_TRIGGER ? change->actual_trigger_ce_score:
10074 action_arg == CA_ARG_ELEMENT_CS_ACTION ? GET_CE_SCORE(action_element) :
10075 action_arg == CA_ARG_ELEMENT_NR_TARGET ? change->target_element :
10076 action_arg == CA_ARG_ELEMENT_NR_TRIGGER ? change->actual_trigger_element :
10077 action_arg == CA_ARG_ELEMENT_NR_ACTION ? change->action_element :
10080 int action_arg_number_old =
10081 (action_type == CA_SET_LEVEL_GEMS ? game.gems_still_needed :
10082 action_type == CA_SET_LEVEL_TIME ? TimeLeft :
10083 action_type == CA_SET_LEVEL_SCORE ? game.score :
10084 action_type == CA_SET_CE_VALUE ? CustomValue[x][y] :
10085 action_type == CA_SET_CE_SCORE ? ei->collect_score :
10088 int action_arg_number_new =
10089 getModifiedActionNumber(action_arg_number_old,
10090 action_mode, action_arg_number,
10091 action_arg_number_min, action_arg_number_max);
10093 int trigger_player_bits =
10094 (change->actual_trigger_player_bits != CH_PLAYER_NONE ?
10095 change->actual_trigger_player_bits : change->trigger_player);
10097 int action_arg_player_bits =
10098 (action_arg >= CA_ARG_PLAYER_1 &&
10099 action_arg <= CA_ARG_PLAYER_4 ? action_arg - CA_ARG_PLAYER :
10100 action_arg == CA_ARG_PLAYER_TRIGGER ? trigger_player_bits :
10101 action_arg == CA_ARG_PLAYER_ACTION ? 1 << GET_PLAYER_NR(action_element) :
10104 // ---------- execute action -----------------------------------------------
10106 switch (action_type)
10113 // ---------- level actions ----------------------------------------------
10115 case CA_RESTART_LEVEL:
10117 game.restart_level = TRUE;
10122 case CA_SHOW_ENVELOPE:
10124 int element = getSpecialActionElement(action_arg_element,
10125 action_arg_number, EL_ENVELOPE_1);
10127 if (IS_ENVELOPE(element))
10128 local_player->show_envelope = element;
10133 case CA_SET_LEVEL_TIME:
10135 if (level.time > 0) // only modify limited time value
10137 TimeLeft = action_arg_number_new;
10139 game_panel_controls[GAME_PANEL_TIME].value = TimeLeft;
10141 DisplayGameControlValues();
10143 if (!TimeLeft && setup.time_limit)
10144 for (i = 0; i < MAX_PLAYERS; i++)
10145 KillPlayer(&stored_player[i]);
10151 case CA_SET_LEVEL_SCORE:
10153 game.score = action_arg_number_new;
10155 game_panel_controls[GAME_PANEL_SCORE].value = game.score;
10157 DisplayGameControlValues();
10162 case CA_SET_LEVEL_GEMS:
10164 game.gems_still_needed = action_arg_number_new;
10166 game.snapshot.collected_item = TRUE;
10168 game_panel_controls[GAME_PANEL_GEMS].value = game.gems_still_needed;
10170 DisplayGameControlValues();
10175 case CA_SET_LEVEL_WIND:
10177 game.wind_direction = action_arg_direction;
10182 case CA_SET_LEVEL_RANDOM_SEED:
10184 // ensure that setting a new random seed while playing is predictable
10185 InitRND(action_arg_number_new ? action_arg_number_new : RND(1000000) + 1);
10190 // ---------- player actions ---------------------------------------------
10192 case CA_MOVE_PLAYER:
10193 case CA_MOVE_PLAYER_NEW:
10195 // automatically move to the next field in specified direction
10196 for (i = 0; i < MAX_PLAYERS; i++)
10197 if (trigger_player_bits & (1 << i))
10198 if (action_type == CA_MOVE_PLAYER ||
10199 stored_player[i].MovPos == 0)
10200 stored_player[i].programmed_action = action_arg_direction;
10205 case CA_EXIT_PLAYER:
10207 for (i = 0; i < MAX_PLAYERS; i++)
10208 if (action_arg_player_bits & (1 << i))
10209 ExitPlayer(&stored_player[i]);
10211 if (game.players_still_needed == 0)
10217 case CA_KILL_PLAYER:
10219 for (i = 0; i < MAX_PLAYERS; i++)
10220 if (action_arg_player_bits & (1 << i))
10221 KillPlayer(&stored_player[i]);
10226 case CA_SET_PLAYER_KEYS:
10228 int key_state = (action_mode == CA_MODE_ADD ? TRUE : FALSE);
10229 int element = getSpecialActionElement(action_arg_element,
10230 action_arg_number, EL_KEY_1);
10232 if (IS_KEY(element))
10234 for (i = 0; i < MAX_PLAYERS; i++)
10236 if (trigger_player_bits & (1 << i))
10238 stored_player[i].key[KEY_NR(element)] = key_state;
10240 DrawGameDoorValues();
10248 case CA_SET_PLAYER_SPEED:
10250 for (i = 0; i < MAX_PLAYERS; i++)
10252 if (trigger_player_bits & (1 << i))
10254 int move_stepsize = TILEX / stored_player[i].move_delay_value;
10256 if (action_arg == CA_ARG_SPEED_FASTER &&
10257 stored_player[i].cannot_move)
10259 action_arg_number = STEPSIZE_VERY_SLOW;
10261 else if (action_arg == CA_ARG_SPEED_SLOWER ||
10262 action_arg == CA_ARG_SPEED_FASTER)
10264 action_arg_number = 2;
10265 action_mode = (action_arg == CA_ARG_SPEED_SLOWER ? CA_MODE_DIVIDE :
10268 else if (action_arg == CA_ARG_NUMBER_RESET)
10270 action_arg_number = level.initial_player_stepsize[i];
10274 getModifiedActionNumber(move_stepsize,
10277 action_arg_number_min,
10278 action_arg_number_max);
10280 SetPlayerMoveSpeed(&stored_player[i], move_stepsize, FALSE);
10287 case CA_SET_PLAYER_SHIELD:
10289 for (i = 0; i < MAX_PLAYERS; i++)
10291 if (trigger_player_bits & (1 << i))
10293 if (action_arg == CA_ARG_SHIELD_OFF)
10295 stored_player[i].shield_normal_time_left = 0;
10296 stored_player[i].shield_deadly_time_left = 0;
10298 else if (action_arg == CA_ARG_SHIELD_NORMAL)
10300 stored_player[i].shield_normal_time_left = 999999;
10302 else if (action_arg == CA_ARG_SHIELD_DEADLY)
10304 stored_player[i].shield_normal_time_left = 999999;
10305 stored_player[i].shield_deadly_time_left = 999999;
10313 case CA_SET_PLAYER_GRAVITY:
10315 for (i = 0; i < MAX_PLAYERS; i++)
10317 if (trigger_player_bits & (1 << i))
10319 stored_player[i].gravity =
10320 (action_arg == CA_ARG_GRAVITY_OFF ? FALSE :
10321 action_arg == CA_ARG_GRAVITY_ON ? TRUE :
10322 action_arg == CA_ARG_GRAVITY_TOGGLE ? !stored_player[i].gravity :
10323 stored_player[i].gravity);
10330 case CA_SET_PLAYER_ARTWORK:
10332 for (i = 0; i < MAX_PLAYERS; i++)
10334 if (trigger_player_bits & (1 << i))
10336 int artwork_element = action_arg_element;
10338 if (action_arg == CA_ARG_ELEMENT_RESET)
10340 (level.use_artwork_element[i] ? level.artwork_element[i] :
10341 stored_player[i].element_nr);
10343 if (stored_player[i].artwork_element != artwork_element)
10344 stored_player[i].Frame = 0;
10346 stored_player[i].artwork_element = artwork_element;
10348 SetPlayerWaiting(&stored_player[i], FALSE);
10350 // set number of special actions for bored and sleeping animation
10351 stored_player[i].num_special_action_bored =
10352 get_num_special_action(artwork_element,
10353 ACTION_BORING_1, ACTION_BORING_LAST);
10354 stored_player[i].num_special_action_sleeping =
10355 get_num_special_action(artwork_element,
10356 ACTION_SLEEPING_1, ACTION_SLEEPING_LAST);
10363 case CA_SET_PLAYER_INVENTORY:
10365 for (i = 0; i < MAX_PLAYERS; i++)
10367 struct PlayerInfo *player = &stored_player[i];
10370 if (trigger_player_bits & (1 << i))
10372 int inventory_element = action_arg_element;
10374 if (action_arg == CA_ARG_ELEMENT_TARGET ||
10375 action_arg == CA_ARG_ELEMENT_TRIGGER ||
10376 action_arg == CA_ARG_ELEMENT_ACTION)
10378 int element = inventory_element;
10379 int collect_count = element_info[element].collect_count_initial;
10381 if (!IS_CUSTOM_ELEMENT(element))
10384 if (collect_count == 0)
10385 player->inventory_infinite_element = element;
10387 for (k = 0; k < collect_count; k++)
10388 if (player->inventory_size < MAX_INVENTORY_SIZE)
10389 player->inventory_element[player->inventory_size++] =
10392 else if (action_arg == CA_ARG_INVENTORY_RM_TARGET ||
10393 action_arg == CA_ARG_INVENTORY_RM_TRIGGER ||
10394 action_arg == CA_ARG_INVENTORY_RM_ACTION)
10396 if (player->inventory_infinite_element != EL_UNDEFINED &&
10397 IS_EQUAL_OR_IN_GROUP(player->inventory_infinite_element,
10398 action_arg_element_raw))
10399 player->inventory_infinite_element = EL_UNDEFINED;
10401 for (k = 0, j = 0; j < player->inventory_size; j++)
10403 if (!IS_EQUAL_OR_IN_GROUP(player->inventory_element[j],
10404 action_arg_element_raw))
10405 player->inventory_element[k++] = player->inventory_element[j];
10408 player->inventory_size = k;
10410 else if (action_arg == CA_ARG_INVENTORY_RM_FIRST)
10412 if (player->inventory_size > 0)
10414 for (j = 0; j < player->inventory_size - 1; j++)
10415 player->inventory_element[j] = player->inventory_element[j + 1];
10417 player->inventory_size--;
10420 else if (action_arg == CA_ARG_INVENTORY_RM_LAST)
10422 if (player->inventory_size > 0)
10423 player->inventory_size--;
10425 else if (action_arg == CA_ARG_INVENTORY_RM_ALL)
10427 player->inventory_infinite_element = EL_UNDEFINED;
10428 player->inventory_size = 0;
10430 else if (action_arg == CA_ARG_INVENTORY_RESET)
10432 player->inventory_infinite_element = EL_UNDEFINED;
10433 player->inventory_size = 0;
10435 if (level.use_initial_inventory[i])
10437 for (j = 0; j < level.initial_inventory_size[i]; j++)
10439 int element = level.initial_inventory_content[i][j];
10440 int collect_count = element_info[element].collect_count_initial;
10442 if (!IS_CUSTOM_ELEMENT(element))
10445 if (collect_count == 0)
10446 player->inventory_infinite_element = element;
10448 for (k = 0; k < collect_count; k++)
10449 if (player->inventory_size < MAX_INVENTORY_SIZE)
10450 player->inventory_element[player->inventory_size++] =
10461 // ---------- CE actions -------------------------------------------------
10463 case CA_SET_CE_VALUE:
10465 int last_ce_value = CustomValue[x][y];
10467 CustomValue[x][y] = action_arg_number_new;
10469 if (CustomValue[x][y] != last_ce_value)
10471 CheckElementChange(x, y, element, EL_UNDEFINED, CE_VALUE_CHANGES);
10472 CheckTriggeredElementChange(x, y, element, CE_VALUE_CHANGES_OF_X);
10474 if (CustomValue[x][y] == 0)
10476 // reset change counter (else CE_VALUE_GETS_ZERO would not work)
10477 ChangeCount[x][y] = 0; // allow at least one more change
10479 CheckElementChange(x, y, element, EL_UNDEFINED, CE_VALUE_GETS_ZERO);
10480 CheckTriggeredElementChange(x, y, element, CE_VALUE_GETS_ZERO_OF_X);
10487 case CA_SET_CE_SCORE:
10489 int last_ce_score = ei->collect_score;
10491 ei->collect_score = action_arg_number_new;
10493 if (ei->collect_score != last_ce_score)
10495 CheckElementChange(x, y, element, EL_UNDEFINED, CE_SCORE_CHANGES);
10496 CheckTriggeredElementChange(x, y, element, CE_SCORE_CHANGES_OF_X);
10498 if (ei->collect_score == 0)
10502 // reset change counter (else CE_SCORE_GETS_ZERO would not work)
10503 ChangeCount[x][y] = 0; // allow at least one more change
10505 CheckElementChange(x, y, element, EL_UNDEFINED, CE_SCORE_GETS_ZERO);
10506 CheckTriggeredElementChange(x, y, element, CE_SCORE_GETS_ZERO_OF_X);
10509 This is a very special case that seems to be a mixture between
10510 CheckElementChange() and CheckTriggeredElementChange(): while
10511 the first one only affects single elements that are triggered
10512 directly, the second one affects multiple elements in the playfield
10513 that are triggered indirectly by another element. This is a third
10514 case: Changing the CE score always affects multiple identical CEs,
10515 so every affected CE must be checked, not only the single CE for
10516 which the CE score was changed in the first place (as every instance
10517 of that CE shares the same CE score, and therefore also can change)!
10519 SCAN_PLAYFIELD(xx, yy)
10521 if (Tile[xx][yy] == element)
10522 CheckElementChange(xx, yy, element, EL_UNDEFINED,
10523 CE_SCORE_GETS_ZERO);
10531 case CA_SET_CE_ARTWORK:
10533 int artwork_element = action_arg_element;
10534 boolean reset_frame = FALSE;
10537 if (action_arg == CA_ARG_ELEMENT_RESET)
10538 artwork_element = (ei->use_gfx_element ? ei->gfx_element_initial :
10541 if (ei->gfx_element != artwork_element)
10542 reset_frame = TRUE;
10544 ei->gfx_element = artwork_element;
10546 SCAN_PLAYFIELD(xx, yy)
10548 if (Tile[xx][yy] == element)
10552 ResetGfxAnimation(xx, yy);
10553 ResetRandomAnimationValue(xx, yy);
10556 TEST_DrawLevelField(xx, yy);
10563 // ---------- engine actions ---------------------------------------------
10565 case CA_SET_ENGINE_SCAN_MODE:
10567 InitPlayfieldScanMode(action_arg);
10577 static void CreateFieldExt(int x, int y, int element, boolean is_change)
10579 int old_element = Tile[x][y];
10580 int new_element = GetElementFromGroupElement(element);
10581 int previous_move_direction = MovDir[x][y];
10582 int last_ce_value = CustomValue[x][y];
10583 boolean player_explosion_protected = PLAYER_EXPLOSION_PROTECTED(x, y);
10584 boolean new_element_is_player = ELEM_IS_PLAYER(new_element);
10585 boolean add_player_onto_element = (new_element_is_player &&
10586 new_element != EL_SOKOBAN_FIELD_PLAYER &&
10587 IS_WALKABLE(old_element));
10589 if (!add_player_onto_element)
10591 if (IS_MOVING(x, y) || IS_BLOCKED(x, y))
10592 RemoveMovingField(x, y);
10596 Tile[x][y] = new_element;
10598 if (element_info[new_element].move_direction_initial == MV_START_PREVIOUS)
10599 MovDir[x][y] = previous_move_direction;
10601 if (element_info[new_element].use_last_ce_value)
10602 CustomValue[x][y] = last_ce_value;
10604 InitField_WithBug1(x, y, FALSE);
10606 new_element = Tile[x][y]; // element may have changed
10608 ResetGfxAnimation(x, y);
10609 ResetRandomAnimationValue(x, y);
10611 TEST_DrawLevelField(x, y);
10613 if (GFX_CRUMBLED(new_element))
10614 TEST_DrawLevelFieldCrumbledNeighbours(x, y);
10617 // check if element under the player changes from accessible to unaccessible
10618 // (needed for special case of dropping element which then changes)
10619 // (must be checked after creating new element for walkable group elements)
10620 if (IS_PLAYER(x, y) && !player_explosion_protected &&
10621 IS_ACCESSIBLE(old_element) && !IS_ACCESSIBLE(new_element))
10628 // "ChangeCount" not set yet to allow "entered by player" change one time
10629 if (new_element_is_player)
10630 RelocatePlayer(x, y, new_element);
10633 ChangeCount[x][y]++; // count number of changes in the same frame
10635 TestIfBadThingTouchesPlayer(x, y);
10636 TestIfPlayerTouchesCustomElement(x, y);
10637 TestIfElementTouchesCustomElement(x, y);
10640 static void CreateField(int x, int y, int element)
10642 CreateFieldExt(x, y, element, FALSE);
10645 static void CreateElementFromChange(int x, int y, int element)
10647 element = GET_VALID_RUNTIME_ELEMENT(element);
10649 if (game.engine_version >= VERSION_IDENT(3,2,0,7))
10651 int old_element = Tile[x][y];
10653 // prevent changed element from moving in same engine frame
10654 // unless both old and new element can either fall or move
10655 if ((!CAN_FALL(old_element) || !CAN_FALL(element)) &&
10656 (!CAN_MOVE(old_element) || !CAN_MOVE(element)))
10660 CreateFieldExt(x, y, element, TRUE);
10663 static boolean ChangeElement(int x, int y, int element, int page)
10665 struct ElementInfo *ei = &element_info[element];
10666 struct ElementChangeInfo *change = &ei->change_page[page];
10667 int ce_value = CustomValue[x][y];
10668 int ce_score = ei->collect_score;
10669 int target_element;
10670 int old_element = Tile[x][y];
10672 // always use default change event to prevent running into a loop
10673 if (ChangeEvent[x][y] == -1)
10674 ChangeEvent[x][y] = CE_DELAY;
10676 if (ChangeEvent[x][y] == CE_DELAY)
10678 // reset actual trigger element, trigger player and action element
10679 change->actual_trigger_element = EL_EMPTY;
10680 change->actual_trigger_player = EL_EMPTY;
10681 change->actual_trigger_player_bits = CH_PLAYER_NONE;
10682 change->actual_trigger_side = CH_SIDE_NONE;
10683 change->actual_trigger_ce_value = 0;
10684 change->actual_trigger_ce_score = 0;
10687 // do not change elements more than a specified maximum number of changes
10688 if (ChangeCount[x][y] >= game.max_num_changes_per_frame)
10691 ChangeCount[x][y]++; // count number of changes in the same frame
10693 if (change->explode)
10700 if (change->use_target_content)
10702 boolean complete_replace = TRUE;
10703 boolean can_replace[3][3];
10706 for (yy = 0; yy < 3; yy++) for (xx = 0; xx < 3 ; xx++)
10709 boolean is_walkable;
10710 boolean is_diggable;
10711 boolean is_collectible;
10712 boolean is_removable;
10713 boolean is_destructible;
10714 int ex = x + xx - 1;
10715 int ey = y + yy - 1;
10716 int content_element = change->target_content.e[xx][yy];
10719 can_replace[xx][yy] = TRUE;
10721 if (ex == x && ey == y) // do not check changing element itself
10724 if (content_element == EL_EMPTY_SPACE)
10726 can_replace[xx][yy] = FALSE; // do not replace border with space
10731 if (!IN_LEV_FIELD(ex, ey))
10733 can_replace[xx][yy] = FALSE;
10734 complete_replace = FALSE;
10741 if (IS_MOVING(ex, ey) || IS_BLOCKED(ex, ey))
10742 e = MovingOrBlocked2Element(ex, ey);
10744 is_empty = (IS_FREE(ex, ey) ||
10745 (IS_FREE_OR_PLAYER(ex, ey) && IS_WALKABLE(content_element)));
10747 is_walkable = (is_empty || IS_WALKABLE(e));
10748 is_diggable = (is_empty || IS_DIGGABLE(e));
10749 is_collectible = (is_empty || IS_COLLECTIBLE(e));
10750 is_destructible = (is_empty || !IS_INDESTRUCTIBLE(e));
10751 is_removable = (is_diggable || is_collectible);
10753 can_replace[xx][yy] =
10754 (((change->replace_when == CP_WHEN_EMPTY && is_empty) ||
10755 (change->replace_when == CP_WHEN_WALKABLE && is_walkable) ||
10756 (change->replace_when == CP_WHEN_DIGGABLE && is_diggable) ||
10757 (change->replace_when == CP_WHEN_COLLECTIBLE && is_collectible) ||
10758 (change->replace_when == CP_WHEN_REMOVABLE && is_removable) ||
10759 (change->replace_when == CP_WHEN_DESTRUCTIBLE && is_destructible)) &&
10760 !(IS_PLAYER(ex, ey) && ELEM_IS_PLAYER(content_element)));
10762 if (!can_replace[xx][yy])
10763 complete_replace = FALSE;
10766 if (!change->only_if_complete || complete_replace)
10768 boolean something_has_changed = FALSE;
10770 if (change->only_if_complete && change->use_random_replace &&
10771 RND(100) < change->random_percentage)
10774 for (yy = 0; yy < 3; yy++) for (xx = 0; xx < 3 ; xx++)
10776 int ex = x + xx - 1;
10777 int ey = y + yy - 1;
10778 int content_element;
10780 if (can_replace[xx][yy] && (!change->use_random_replace ||
10781 RND(100) < change->random_percentage))
10783 if (IS_MOVING(ex, ey) || IS_BLOCKED(ex, ey))
10784 RemoveMovingField(ex, ey);
10786 ChangeEvent[ex][ey] = ChangeEvent[x][y];
10788 content_element = change->target_content.e[xx][yy];
10789 target_element = GET_TARGET_ELEMENT(element, content_element, change,
10790 ce_value, ce_score);
10792 CreateElementFromChange(ex, ey, target_element);
10794 something_has_changed = TRUE;
10796 // for symmetry reasons, freeze newly created border elements
10797 if (ex != x || ey != y)
10798 Stop[ex][ey] = TRUE; // no more moving in this frame
10802 if (something_has_changed)
10804 PlayLevelSoundElementAction(x, y, element, ACTION_CHANGING);
10805 PlayLevelSoundElementAction(x, y, element, ACTION_PAGE_1 + page);
10811 target_element = GET_TARGET_ELEMENT(element, change->target_element, change,
10812 ce_value, ce_score);
10814 if (element == EL_DIAGONAL_GROWING ||
10815 element == EL_DIAGONAL_SHRINKING)
10817 target_element = Store[x][y];
10819 Store[x][y] = EL_EMPTY;
10822 CreateElementFromChange(x, y, target_element);
10824 PlayLevelSoundElementAction(x, y, element, ACTION_CHANGING);
10825 PlayLevelSoundElementAction(x, y, element, ACTION_PAGE_1 + page);
10828 // this uses direct change before indirect change
10829 CheckTriggeredElementChangeByPage(x, y, old_element, CE_CHANGE_OF_X, page);
10834 static void HandleElementChange(int x, int y, int page)
10836 int element = MovingOrBlocked2Element(x, y);
10837 struct ElementInfo *ei = &element_info[element];
10838 struct ElementChangeInfo *change = &ei->change_page[page];
10839 boolean handle_action_before_change = FALSE;
10842 if (!CAN_CHANGE_OR_HAS_ACTION(element) &&
10843 !CAN_CHANGE_OR_HAS_ACTION(Back[x][y]))
10845 Debug("game:playing:HandleElementChange", "%d,%d: element = %d ('%s')",
10846 x, y, element, element_info[element].token_name);
10847 Debug("game:playing:HandleElementChange", "This should never happen!");
10851 // this can happen with classic bombs on walkable, changing elements
10852 if (!CAN_CHANGE_OR_HAS_ACTION(element))
10857 if (ChangeDelay[x][y] == 0) // initialize element change
10859 ChangeDelay[x][y] = GET_CHANGE_DELAY(change) + 1;
10861 if (change->can_change)
10863 // !!! not clear why graphic animation should be reset at all here !!!
10864 // !!! UPDATE: but is needed for correct Snake Bite tail animation !!!
10865 // !!! SOLUTION: do not reset if graphics engine set to 4 or above !!!
10868 GRAPHICAL BUG ADDRESSED BY CHECKING GRAPHICS ENGINE VERSION:
10870 When using an animation frame delay of 1 (this only happens with
10871 "sp_zonk.moving.left/right" in the classic graphics), the default
10872 (non-moving) animation shows wrong animation frames (while the
10873 moving animation, like "sp_zonk.moving.left/right", is correct,
10874 so this graphical bug never shows up with the classic graphics).
10875 For an animation with 4 frames, this causes wrong frames 0,0,1,2
10876 be drawn instead of the correct frames 0,1,2,3. This is caused by
10877 "GfxFrame[][]" being reset *twice* (in two successive frames) after
10878 an element change: First when the change delay ("ChangeDelay[][]")
10879 counter has reached zero after decrementing, then a second time in
10880 the next frame (after "GfxFrame[][]" was already incremented) when
10881 "ChangeDelay[][]" is reset to the initial delay value again.
10883 This causes frame 0 to be drawn twice, while the last frame won't
10884 be drawn anymore, resulting in the wrong frame sequence 0,0,1,2.
10886 As some animations may already be cleverly designed around this bug
10887 (at least the "Snake Bite" snake tail animation does this), it cannot
10888 simply be fixed here without breaking such existing animations.
10889 Unfortunately, it cannot easily be detected if a graphics set was
10890 designed "before" or "after" the bug was fixed. As a workaround,
10891 a new graphics set option "game.graphics_engine_version" was added
10892 to be able to specify the game's major release version for which the
10893 graphics set was designed, which can then be used to decide if the
10894 bugfix should be used (version 4 and above) or not (version 3 or
10895 below, or if no version was specified at all, as with old sets).
10897 (The wrong/fixed animation frames can be tested with the test level set
10898 "test_gfxframe" and level "000", which contains a specially prepared
10899 custom element at level position (x/y) == (11/9) which uses the zonk
10900 animation mentioned above. Using "game.graphics_engine_version: 4"
10901 fixes the wrong animation frames, showing the correct frames 0,1,2,3.
10902 This can also be seen from the debug output for this test element.)
10905 // when a custom element is about to change (for example by change delay),
10906 // do not reset graphic animation when the custom element is moving
10907 if (game.graphics_engine_version < 4 &&
10910 ResetGfxAnimation(x, y);
10911 ResetRandomAnimationValue(x, y);
10914 if (change->pre_change_function)
10915 change->pre_change_function(x, y);
10919 ChangeDelay[x][y]--;
10921 if (ChangeDelay[x][y] != 0) // continue element change
10923 if (change->can_change)
10925 int graphic = el_act_dir2img(element, GfxAction[x][y], GfxDir[x][y]);
10927 if (IS_ANIMATED(graphic))
10928 DrawLevelGraphicAnimationIfNeeded(x, y, graphic);
10930 if (change->change_function)
10931 change->change_function(x, y);
10934 else // finish element change
10936 if (ChangePage[x][y] != -1) // remember page from delayed change
10938 page = ChangePage[x][y];
10939 ChangePage[x][y] = -1;
10941 change = &ei->change_page[page];
10944 if (IS_MOVING(x, y)) // never change a running system ;-)
10946 ChangeDelay[x][y] = 1; // try change after next move step
10947 ChangePage[x][y] = page; // remember page to use for change
10952 // special case: set new level random seed before changing element
10953 if (change->has_action && change->action_type == CA_SET_LEVEL_RANDOM_SEED)
10954 handle_action_before_change = TRUE;
10956 if (change->has_action && handle_action_before_change)
10957 ExecuteCustomElementAction(x, y, element, page);
10959 if (change->can_change)
10961 if (ChangeElement(x, y, element, page))
10963 if (change->post_change_function)
10964 change->post_change_function(x, y);
10968 if (change->has_action && !handle_action_before_change)
10969 ExecuteCustomElementAction(x, y, element, page);
10973 static boolean CheckTriggeredElementChangeExt(int trigger_x, int trigger_y,
10974 int trigger_element,
10976 int trigger_player,
10980 boolean change_done_any = FALSE;
10981 int trigger_page_bits = (trigger_page < 0 ? CH_PAGE_ANY : 1 << trigger_page);
10984 if (!(trigger_events[trigger_element][trigger_event]))
10987 RECURSION_LOOP_DETECTION_START(trigger_element, FALSE);
10989 for (i = 0; i < NUM_CUSTOM_ELEMENTS; i++)
10991 int element = EL_CUSTOM_START + i;
10992 boolean change_done = FALSE;
10995 if (!CAN_CHANGE_OR_HAS_ACTION(element) ||
10996 !HAS_ANY_CHANGE_EVENT(element, trigger_event))
10999 for (p = 0; p < element_info[element].num_change_pages; p++)
11001 struct ElementChangeInfo *change = &element_info[element].change_page[p];
11003 if (change->can_change_or_has_action &&
11004 change->has_event[trigger_event] &&
11005 change->trigger_side & trigger_side &&
11006 change->trigger_player & trigger_player &&
11007 change->trigger_page & trigger_page_bits &&
11008 IS_EQUAL_OR_IN_GROUP(trigger_element, change->trigger_element))
11010 change->actual_trigger_element = trigger_element;
11011 change->actual_trigger_player = GET_PLAYER_FROM_BITS(trigger_player);
11012 change->actual_trigger_player_bits = trigger_player;
11013 change->actual_trigger_side = trigger_side;
11014 change->actual_trigger_ce_value = CustomValue[trigger_x][trigger_y];
11015 change->actual_trigger_ce_score = GET_CE_SCORE(trigger_element);
11017 if ((change->can_change && !change_done) || change->has_action)
11021 SCAN_PLAYFIELD(x, y)
11023 if (Tile[x][y] == element)
11025 if (change->can_change && !change_done)
11027 // if element already changed in this frame, not only prevent
11028 // another element change (checked in ChangeElement()), but
11029 // also prevent additional element actions for this element
11031 if (ChangeCount[x][y] >= game.max_num_changes_per_frame &&
11032 !level.use_action_after_change_bug)
11035 ChangeDelay[x][y] = 1;
11036 ChangeEvent[x][y] = trigger_event;
11038 HandleElementChange(x, y, p);
11040 else if (change->has_action)
11042 // if element already changed in this frame, not only prevent
11043 // another element change (checked in ChangeElement()), but
11044 // also prevent additional element actions for this element
11046 if (ChangeCount[x][y] >= game.max_num_changes_per_frame &&
11047 !level.use_action_after_change_bug)
11050 ExecuteCustomElementAction(x, y, element, p);
11051 PlayLevelSoundElementAction(x, y, element, ACTION_PAGE_1 + p);
11056 if (change->can_change)
11058 change_done = TRUE;
11059 change_done_any = TRUE;
11066 RECURSION_LOOP_DETECTION_END();
11068 return change_done_any;
11071 static boolean CheckElementChangeExt(int x, int y,
11073 int trigger_element,
11075 int trigger_player,
11078 boolean change_done = FALSE;
11081 if (!CAN_CHANGE_OR_HAS_ACTION(element) ||
11082 !HAS_ANY_CHANGE_EVENT(element, trigger_event))
11085 if (Tile[x][y] == EL_BLOCKED)
11087 Blocked2Moving(x, y, &x, &y);
11088 element = Tile[x][y];
11091 // check if element has already changed or is about to change after moving
11092 if ((game.engine_version < VERSION_IDENT(3,2,0,7) &&
11093 Tile[x][y] != element) ||
11095 (game.engine_version >= VERSION_IDENT(3,2,0,7) &&
11096 (ChangeCount[x][y] >= game.max_num_changes_per_frame ||
11097 ChangePage[x][y] != -1)))
11100 RECURSION_LOOP_DETECTION_START(trigger_element, FALSE);
11102 for (p = 0; p < element_info[element].num_change_pages; p++)
11104 struct ElementChangeInfo *change = &element_info[element].change_page[p];
11106 /* check trigger element for all events where the element that is checked
11107 for changing interacts with a directly adjacent element -- this is
11108 different to element changes that affect other elements to change on the
11109 whole playfield (which is handeld by CheckTriggeredElementChangeExt()) */
11110 boolean check_trigger_element =
11111 (trigger_event == CE_TOUCHING_X ||
11112 trigger_event == CE_HITTING_X ||
11113 trigger_event == CE_HIT_BY_X ||
11114 trigger_event == CE_DIGGING_X); // this one was forgotten until 3.2.3
11116 if (change->can_change_or_has_action &&
11117 change->has_event[trigger_event] &&
11118 change->trigger_side & trigger_side &&
11119 change->trigger_player & trigger_player &&
11120 (!check_trigger_element ||
11121 IS_EQUAL_OR_IN_GROUP(trigger_element, change->trigger_element)))
11123 change->actual_trigger_element = trigger_element;
11124 change->actual_trigger_player = GET_PLAYER_FROM_BITS(trigger_player);
11125 change->actual_trigger_player_bits = trigger_player;
11126 change->actual_trigger_side = trigger_side;
11127 change->actual_trigger_ce_value = CustomValue[x][y];
11128 change->actual_trigger_ce_score = GET_CE_SCORE(trigger_element);
11130 // special case: trigger element not at (x,y) position for some events
11131 if (check_trigger_element)
11143 { 0, 0 }, { 0, 0 }, { 0, 0 },
11147 int xx = x + move_xy[MV_DIR_OPPOSITE(trigger_side)].dx;
11148 int yy = y + move_xy[MV_DIR_OPPOSITE(trigger_side)].dy;
11150 change->actual_trigger_ce_value = CustomValue[xx][yy];
11151 change->actual_trigger_ce_score = GET_CE_SCORE(trigger_element);
11154 if (change->can_change && !change_done)
11156 ChangeDelay[x][y] = 1;
11157 ChangeEvent[x][y] = trigger_event;
11159 HandleElementChange(x, y, p);
11161 change_done = TRUE;
11163 else if (change->has_action)
11165 ExecuteCustomElementAction(x, y, element, p);
11166 PlayLevelSoundElementAction(x, y, element, ACTION_PAGE_1 + p);
11171 RECURSION_LOOP_DETECTION_END();
11173 return change_done;
11176 static void PlayPlayerSound(struct PlayerInfo *player)
11178 int jx = player->jx, jy = player->jy;
11179 int sound_element = player->artwork_element;
11180 int last_action = player->last_action_waiting;
11181 int action = player->action_waiting;
11183 if (player->is_waiting)
11185 if (action != last_action)
11186 PlayLevelSoundElementAction(jx, jy, sound_element, action);
11188 PlayLevelSoundElementActionIfLoop(jx, jy, sound_element, action);
11192 if (action != last_action)
11193 StopSound(element_info[sound_element].sound[last_action]);
11195 if (last_action == ACTION_SLEEPING)
11196 PlayLevelSoundElementAction(jx, jy, sound_element, ACTION_AWAKENING);
11200 static void PlayAllPlayersSound(void)
11204 for (i = 0; i < MAX_PLAYERS; i++)
11205 if (stored_player[i].active)
11206 PlayPlayerSound(&stored_player[i]);
11209 static void SetPlayerWaiting(struct PlayerInfo *player, boolean is_waiting)
11211 boolean last_waiting = player->is_waiting;
11212 int move_dir = player->MovDir;
11214 player->dir_waiting = move_dir;
11215 player->last_action_waiting = player->action_waiting;
11219 if (!last_waiting) // not waiting -> waiting
11221 player->is_waiting = TRUE;
11223 player->frame_counter_bored =
11225 game.player_boring_delay_fixed +
11226 GetSimpleRandom(game.player_boring_delay_random);
11227 player->frame_counter_sleeping =
11229 game.player_sleeping_delay_fixed +
11230 GetSimpleRandom(game.player_sleeping_delay_random);
11232 InitPlayerGfxAnimation(player, ACTION_WAITING, move_dir);
11235 if (game.player_sleeping_delay_fixed +
11236 game.player_sleeping_delay_random > 0 &&
11237 player->anim_delay_counter == 0 &&
11238 player->post_delay_counter == 0 &&
11239 FrameCounter >= player->frame_counter_sleeping)
11240 player->is_sleeping = TRUE;
11241 else if (game.player_boring_delay_fixed +
11242 game.player_boring_delay_random > 0 &&
11243 FrameCounter >= player->frame_counter_bored)
11244 player->is_bored = TRUE;
11246 player->action_waiting = (player->is_sleeping ? ACTION_SLEEPING :
11247 player->is_bored ? ACTION_BORING :
11250 if (player->is_sleeping && player->use_murphy)
11252 // special case for sleeping Murphy when leaning against non-free tile
11254 if (!IN_LEV_FIELD(player->jx - 1, player->jy) ||
11255 (Tile[player->jx - 1][player->jy] != EL_EMPTY &&
11256 !IS_MOVING(player->jx - 1, player->jy)))
11257 move_dir = MV_LEFT;
11258 else if (!IN_LEV_FIELD(player->jx + 1, player->jy) ||
11259 (Tile[player->jx + 1][player->jy] != EL_EMPTY &&
11260 !IS_MOVING(player->jx + 1, player->jy)))
11261 move_dir = MV_RIGHT;
11263 player->is_sleeping = FALSE;
11265 player->dir_waiting = move_dir;
11268 if (player->is_sleeping)
11270 if (player->num_special_action_sleeping > 0)
11272 if (player->anim_delay_counter == 0 && player->post_delay_counter == 0)
11274 int last_special_action = player->special_action_sleeping;
11275 int num_special_action = player->num_special_action_sleeping;
11276 int special_action =
11277 (last_special_action == ACTION_DEFAULT ? ACTION_SLEEPING_1 :
11278 last_special_action == ACTION_SLEEPING ? ACTION_SLEEPING :
11279 last_special_action < ACTION_SLEEPING_1 + num_special_action - 1 ?
11280 last_special_action + 1 : ACTION_SLEEPING);
11281 int special_graphic =
11282 el_act_dir2img(player->artwork_element, special_action, move_dir);
11284 player->anim_delay_counter =
11285 graphic_info[special_graphic].anim_delay_fixed +
11286 GetSimpleRandom(graphic_info[special_graphic].anim_delay_random);
11287 player->post_delay_counter =
11288 graphic_info[special_graphic].post_delay_fixed +
11289 GetSimpleRandom(graphic_info[special_graphic].post_delay_random);
11291 player->special_action_sleeping = special_action;
11294 if (player->anim_delay_counter > 0)
11296 player->action_waiting = player->special_action_sleeping;
11297 player->anim_delay_counter--;
11299 else if (player->post_delay_counter > 0)
11301 player->post_delay_counter--;
11305 else if (player->is_bored)
11307 if (player->num_special_action_bored > 0)
11309 if (player->anim_delay_counter == 0 && player->post_delay_counter == 0)
11311 int special_action =
11312 ACTION_BORING_1 + GetSimpleRandom(player->num_special_action_bored);
11313 int special_graphic =
11314 el_act_dir2img(player->artwork_element, special_action, move_dir);
11316 player->anim_delay_counter =
11317 graphic_info[special_graphic].anim_delay_fixed +
11318 GetSimpleRandom(graphic_info[special_graphic].anim_delay_random);
11319 player->post_delay_counter =
11320 graphic_info[special_graphic].post_delay_fixed +
11321 GetSimpleRandom(graphic_info[special_graphic].post_delay_random);
11323 player->special_action_bored = special_action;
11326 if (player->anim_delay_counter > 0)
11328 player->action_waiting = player->special_action_bored;
11329 player->anim_delay_counter--;
11331 else if (player->post_delay_counter > 0)
11333 player->post_delay_counter--;
11338 else if (last_waiting) // waiting -> not waiting
11340 player->is_waiting = FALSE;
11341 player->is_bored = FALSE;
11342 player->is_sleeping = FALSE;
11344 player->frame_counter_bored = -1;
11345 player->frame_counter_sleeping = -1;
11347 player->anim_delay_counter = 0;
11348 player->post_delay_counter = 0;
11350 player->dir_waiting = player->MovDir;
11351 player->action_waiting = ACTION_DEFAULT;
11353 player->special_action_bored = ACTION_DEFAULT;
11354 player->special_action_sleeping = ACTION_DEFAULT;
11358 static void CheckSaveEngineSnapshot(struct PlayerInfo *player)
11360 if ((!player->is_moving && player->was_moving) ||
11361 (player->MovPos == 0 && player->was_moving) ||
11362 (player->is_snapping && !player->was_snapping) ||
11363 (player->is_dropping && !player->was_dropping))
11365 if (!CheckSaveEngineSnapshotToList())
11368 player->was_moving = FALSE;
11369 player->was_snapping = TRUE;
11370 player->was_dropping = TRUE;
11374 if (player->is_moving)
11375 player->was_moving = TRUE;
11377 if (!player->is_snapping)
11378 player->was_snapping = FALSE;
11380 if (!player->is_dropping)
11381 player->was_dropping = FALSE;
11384 static struct MouseActionInfo mouse_action_last = { 0 };
11385 struct MouseActionInfo mouse_action = player->effective_mouse_action;
11386 boolean new_released = (!mouse_action.button && mouse_action_last.button);
11389 CheckSaveEngineSnapshotToList();
11391 mouse_action_last = mouse_action;
11394 static void CheckSingleStepMode(struct PlayerInfo *player)
11396 if (tape.single_step && tape.recording && !tape.pausing)
11398 // as it is called "single step mode", just return to pause mode when the
11399 // player stopped moving after one tile (or never starts moving at all)
11400 // (reverse logic needed here in case single step mode used in team mode)
11401 if (player->is_moving ||
11402 player->is_pushing ||
11403 player->is_dropping_pressed ||
11404 player->effective_mouse_action.button)
11405 game.enter_single_step_mode = FALSE;
11408 CheckSaveEngineSnapshot(player);
11411 static byte PlayerActions(struct PlayerInfo *player, byte player_action)
11413 int left = player_action & JOY_LEFT;
11414 int right = player_action & JOY_RIGHT;
11415 int up = player_action & JOY_UP;
11416 int down = player_action & JOY_DOWN;
11417 int button1 = player_action & JOY_BUTTON_1;
11418 int button2 = player_action & JOY_BUTTON_2;
11419 int dx = (left ? -1 : right ? 1 : 0);
11420 int dy = (up ? -1 : down ? 1 : 0);
11422 if (!player->active || tape.pausing)
11428 SnapField(player, dx, dy);
11432 DropElement(player);
11434 MovePlayer(player, dx, dy);
11437 CheckSingleStepMode(player);
11439 SetPlayerWaiting(player, FALSE);
11441 return player_action;
11445 // no actions for this player (no input at player's configured device)
11447 DigField(player, 0, 0, 0, 0, 0, 0, DF_NO_PUSH);
11448 SnapField(player, 0, 0);
11449 CheckGravityMovementWhenNotMoving(player);
11451 if (player->MovPos == 0)
11452 SetPlayerWaiting(player, TRUE);
11454 if (player->MovPos == 0) // needed for tape.playing
11455 player->is_moving = FALSE;
11457 player->is_dropping = FALSE;
11458 player->is_dropping_pressed = FALSE;
11459 player->drop_pressed_delay = 0;
11461 CheckSingleStepMode(player);
11467 static void SetMouseActionFromTapeAction(struct MouseActionInfo *mouse_action,
11470 if (!tape.use_mouse_actions)
11473 mouse_action->lx = tape_action[TAPE_ACTION_LX];
11474 mouse_action->ly = tape_action[TAPE_ACTION_LY];
11475 mouse_action->button = tape_action[TAPE_ACTION_BUTTON];
11478 static void SetTapeActionFromMouseAction(byte *tape_action,
11479 struct MouseActionInfo *mouse_action)
11481 if (!tape.use_mouse_actions)
11484 tape_action[TAPE_ACTION_LX] = mouse_action->lx;
11485 tape_action[TAPE_ACTION_LY] = mouse_action->ly;
11486 tape_action[TAPE_ACTION_BUTTON] = mouse_action->button;
11489 static void CheckLevelSolved(void)
11491 if (level.game_engine_type == GAME_ENGINE_TYPE_EM)
11493 if (game_em.level_solved &&
11494 !game_em.game_over) // game won
11498 game_em.game_over = TRUE;
11500 game.all_players_gone = TRUE;
11503 if (game_em.game_over) // game lost
11504 game.all_players_gone = TRUE;
11506 else if (level.game_engine_type == GAME_ENGINE_TYPE_SP)
11508 if (game_sp.level_solved &&
11509 !game_sp.game_over) // game won
11513 game_sp.game_over = TRUE;
11515 game.all_players_gone = TRUE;
11518 if (game_sp.game_over) // game lost
11519 game.all_players_gone = TRUE;
11521 else if (level.game_engine_type == GAME_ENGINE_TYPE_MM)
11523 if (game_mm.level_solved &&
11524 !game_mm.game_over) // game won
11528 game_mm.game_over = TRUE;
11530 game.all_players_gone = TRUE;
11533 if (game_mm.game_over) // game lost
11534 game.all_players_gone = TRUE;
11538 static void CheckLevelTime(void)
11542 if (TimeFrames >= FRAMES_PER_SECOND)
11547 for (i = 0; i < MAX_PLAYERS; i++)
11549 struct PlayerInfo *player = &stored_player[i];
11551 if (SHIELD_ON(player))
11553 player->shield_normal_time_left--;
11555 if (player->shield_deadly_time_left > 0)
11556 player->shield_deadly_time_left--;
11560 if (!game.LevelSolved && !level.use_step_counter)
11568 if (TimeLeft <= 10 && setup.time_limit)
11569 PlaySound(SND_GAME_RUNNING_OUT_OF_TIME);
11571 /* this does not make sense: game_panel_controls[GAME_PANEL_TIME].value
11572 is reset from other values in UpdateGameDoorValues() -- FIX THIS */
11574 game_panel_controls[GAME_PANEL_TIME].value = TimeLeft;
11576 if (!TimeLeft && setup.time_limit)
11578 if (level.game_engine_type == GAME_ENGINE_TYPE_EM)
11579 game_em.lev->killed_out_of_time = TRUE;
11581 for (i = 0; i < MAX_PLAYERS; i++)
11582 KillPlayer(&stored_player[i]);
11585 else if (game.no_time_limit && !game.all_players_gone)
11587 game_panel_controls[GAME_PANEL_TIME].value = TimePlayed;
11590 game_em.lev->time = (game.no_time_limit ? TimePlayed : TimeLeft);
11593 if (tape.recording || tape.playing)
11594 DrawVideoDisplay(VIDEO_STATE_TIME_ON, TapeTime);
11597 if (tape.recording || tape.playing)
11598 DrawVideoDisplay(VIDEO_STATE_FRAME_ON, FrameCounter);
11600 UpdateAndDisplayGameControlValues();
11603 void AdvanceFrameAndPlayerCounters(int player_nr)
11607 // advance frame counters (global frame counter and time frame counter)
11611 // advance player counters (counters for move delay, move animation etc.)
11612 for (i = 0; i < MAX_PLAYERS; i++)
11614 boolean advance_player_counters = (player_nr == -1 || player_nr == i);
11615 int move_delay_value = stored_player[i].move_delay_value;
11616 int move_frames = MOVE_DELAY_NORMAL_SPEED / move_delay_value;
11618 if (!advance_player_counters) // not all players may be affected
11621 if (move_frames == 0) // less than one move per game frame
11623 int stepsize = TILEX / move_delay_value;
11624 int delay = move_delay_value / MOVE_DELAY_NORMAL_SPEED;
11625 int count = (stored_player[i].is_moving ?
11626 ABS(stored_player[i].MovPos) / stepsize : FrameCounter);
11628 if (count % delay == 0)
11632 stored_player[i].Frame += move_frames;
11634 if (stored_player[i].MovPos != 0)
11635 stored_player[i].StepFrame += move_frames;
11637 if (stored_player[i].move_delay > 0)
11638 stored_player[i].move_delay--;
11640 // due to bugs in previous versions, counter must count up, not down
11641 if (stored_player[i].push_delay != -1)
11642 stored_player[i].push_delay++;
11644 if (stored_player[i].drop_delay > 0)
11645 stored_player[i].drop_delay--;
11647 if (stored_player[i].is_dropping_pressed)
11648 stored_player[i].drop_pressed_delay++;
11652 void StartGameActions(boolean init_network_game, boolean record_tape,
11655 unsigned int new_random_seed = InitRND(random_seed);
11658 TapeStartRecording(new_random_seed);
11660 if (init_network_game)
11662 SendToServer_LevelFile();
11663 SendToServer_StartPlaying();
11671 static void GameActionsExt(void)
11674 static unsigned int game_frame_delay = 0;
11676 unsigned int game_frame_delay_value;
11677 byte *recorded_player_action;
11678 byte summarized_player_action = 0;
11679 byte tape_action[MAX_TAPE_ACTIONS] = { 0 };
11682 // detect endless loops, caused by custom element programming
11683 if (recursion_loop_detected && recursion_loop_depth == 0)
11685 char *message = getStringCat3("Internal Error! Element ",
11686 EL_NAME(recursion_loop_element),
11687 " caused endless loop! Quit the game?");
11689 Warn("element '%s' caused endless loop in game engine",
11690 EL_NAME(recursion_loop_element));
11692 RequestQuitGameExt(FALSE, level_editor_test_game, message);
11694 recursion_loop_detected = FALSE; // if game should be continued
11701 if (game.restart_level)
11702 StartGameActions(network.enabled, setup.autorecord, level.random_seed);
11704 CheckLevelSolved();
11706 if (game.LevelSolved && !game.LevelSolved_GameEnd)
11709 if (game.all_players_gone && !TAPE_IS_STOPPED(tape))
11712 if (game_status != GAME_MODE_PLAYING) // status might have changed
11715 game_frame_delay_value =
11716 (tape.playing && tape.fast_forward ? FfwdFrameDelay : GameFrameDelay);
11718 if (tape.playing && tape.warp_forward && !tape.pausing)
11719 game_frame_delay_value = 0;
11721 SetVideoFrameDelay(game_frame_delay_value);
11723 // (de)activate virtual buttons depending on current game status
11724 if (strEqual(setup.touch.control_type, TOUCH_CONTROL_VIRTUAL_BUTTONS))
11726 if (game.all_players_gone) // if no players there to be controlled anymore
11727 SetOverlayActive(FALSE);
11728 else if (!tape.playing) // if game continues after tape stopped playing
11729 SetOverlayActive(TRUE);
11734 // ---------- main game synchronization point ----------
11736 int skip = WaitUntilDelayReached(&game_frame_delay, game_frame_delay_value);
11738 Debug("game:playing:skip", "skip == %d", skip);
11741 // ---------- main game synchronization point ----------
11743 WaitUntilDelayReached(&game_frame_delay, game_frame_delay_value);
11747 if (network_playing && !network_player_action_received)
11749 // try to get network player actions in time
11751 // last chance to get network player actions without main loop delay
11752 HandleNetworking();
11754 // game was quit by network peer
11755 if (game_status != GAME_MODE_PLAYING)
11758 // check if network player actions still missing and game still running
11759 if (!network_player_action_received && !checkGameEnded())
11760 return; // failed to get network player actions in time
11762 // do not yet reset "network_player_action_received" (for tape.pausing)
11768 // at this point we know that we really continue executing the game
11770 network_player_action_received = FALSE;
11772 // when playing tape, read previously recorded player input from tape data
11773 recorded_player_action = (tape.playing ? TapePlayAction() : NULL);
11775 local_player->effective_mouse_action = local_player->mouse_action;
11777 if (recorded_player_action != NULL)
11778 SetMouseActionFromTapeAction(&local_player->effective_mouse_action,
11779 recorded_player_action);
11781 // TapePlayAction() may return NULL when toggling to "pause before death"
11785 if (tape.set_centered_player)
11787 game.centered_player_nr_next = tape.centered_player_nr_next;
11788 game.set_centered_player = TRUE;
11791 for (i = 0; i < MAX_PLAYERS; i++)
11793 summarized_player_action |= stored_player[i].action;
11795 if (!network_playing && (game.team_mode || tape.playing))
11796 stored_player[i].effective_action = stored_player[i].action;
11799 if (network_playing && !checkGameEnded())
11800 SendToServer_MovePlayer(summarized_player_action);
11802 // summarize all actions at local players mapped input device position
11803 // (this allows using different input devices in single player mode)
11804 if (!network.enabled && !game.team_mode)
11805 stored_player[map_player_action[local_player->index_nr]].effective_action =
11806 summarized_player_action;
11808 // summarize all actions at centered player in local team mode
11809 if (tape.recording &&
11810 setup.team_mode && !network.enabled &&
11811 setup.input_on_focus &&
11812 game.centered_player_nr != -1)
11814 for (i = 0; i < MAX_PLAYERS; i++)
11815 stored_player[map_player_action[i]].effective_action =
11816 (i == game.centered_player_nr ? summarized_player_action : 0);
11819 if (recorded_player_action != NULL)
11820 for (i = 0; i < MAX_PLAYERS; i++)
11821 stored_player[i].effective_action = recorded_player_action[i];
11823 for (i = 0; i < MAX_PLAYERS; i++)
11825 tape_action[i] = stored_player[i].effective_action;
11827 /* (this may happen in the RND game engine if a player was not present on
11828 the playfield on level start, but appeared later from a custom element */
11829 if (setup.team_mode &&
11832 !tape.player_participates[i])
11833 tape.player_participates[i] = TRUE;
11836 SetTapeActionFromMouseAction(tape_action,
11837 &local_player->effective_mouse_action);
11839 // only record actions from input devices, but not programmed actions
11840 if (tape.recording)
11841 TapeRecordAction(tape_action);
11843 // remember if game was played (especially after tape stopped playing)
11844 if (!tape.playing && summarized_player_action)
11845 game.GamePlayed = TRUE;
11847 #if USE_NEW_PLAYER_ASSIGNMENTS
11848 // !!! also map player actions in single player mode !!!
11849 // if (game.team_mode)
11852 byte mapped_action[MAX_PLAYERS];
11854 #if DEBUG_PLAYER_ACTIONS
11855 for (i = 0; i < MAX_PLAYERS; i++)
11856 DebugContinued("", "%d, ", stored_player[i].effective_action);
11859 for (i = 0; i < MAX_PLAYERS; i++)
11860 mapped_action[i] = stored_player[map_player_action[i]].effective_action;
11862 for (i = 0; i < MAX_PLAYERS; i++)
11863 stored_player[i].effective_action = mapped_action[i];
11865 #if DEBUG_PLAYER_ACTIONS
11866 DebugContinued("", "=> ");
11867 for (i = 0; i < MAX_PLAYERS; i++)
11868 DebugContinued("", "%d, ", stored_player[i].effective_action);
11869 DebugContinued("game:playing:player", "\n");
11872 #if DEBUG_PLAYER_ACTIONS
11875 for (i = 0; i < MAX_PLAYERS; i++)
11876 DebugContinued("", "%d, ", stored_player[i].effective_action);
11877 DebugContinued("game:playing:player", "\n");
11882 for (i = 0; i < MAX_PLAYERS; i++)
11884 // allow engine snapshot in case of changed movement attempt
11885 if ((game.snapshot.last_action[i] & KEY_MOTION) !=
11886 (stored_player[i].effective_action & KEY_MOTION))
11887 game.snapshot.changed_action = TRUE;
11889 // allow engine snapshot in case of snapping/dropping attempt
11890 if ((game.snapshot.last_action[i] & KEY_BUTTON) == 0 &&
11891 (stored_player[i].effective_action & KEY_BUTTON) != 0)
11892 game.snapshot.changed_action = TRUE;
11894 game.snapshot.last_action[i] = stored_player[i].effective_action;
11897 if (level.game_engine_type == GAME_ENGINE_TYPE_EM)
11899 GameActions_EM_Main();
11901 else if (level.game_engine_type == GAME_ENGINE_TYPE_SP)
11903 GameActions_SP_Main();
11905 else if (level.game_engine_type == GAME_ENGINE_TYPE_MM)
11907 GameActions_MM_Main();
11911 GameActions_RND_Main();
11914 BlitScreenToBitmap(backbuffer);
11916 CheckLevelSolved();
11919 AdvanceFrameAndPlayerCounters(-1); // advance counters for all players
11921 if (global.show_frames_per_second)
11923 static unsigned int fps_counter = 0;
11924 static int fps_frames = 0;
11925 unsigned int fps_delay_ms = Counter() - fps_counter;
11929 if (fps_delay_ms >= 500) // calculate FPS every 0.5 seconds
11931 global.frames_per_second = 1000 * (float)fps_frames / fps_delay_ms;
11934 fps_counter = Counter();
11936 // always draw FPS to screen after FPS value was updated
11937 redraw_mask |= REDRAW_FPS;
11940 // only draw FPS if no screen areas are deactivated (invisible warp mode)
11941 if (GetDrawDeactivationMask() == REDRAW_NONE)
11942 redraw_mask |= REDRAW_FPS;
11946 static void GameActions_CheckSaveEngineSnapshot(void)
11948 if (!game.snapshot.save_snapshot)
11951 // clear flag for saving snapshot _before_ saving snapshot
11952 game.snapshot.save_snapshot = FALSE;
11954 SaveEngineSnapshotToList();
11957 void GameActions(void)
11961 GameActions_CheckSaveEngineSnapshot();
11964 void GameActions_EM_Main(void)
11966 byte effective_action[MAX_PLAYERS];
11967 boolean warp_mode = (tape.playing && tape.warp_forward && !tape.pausing);
11970 for (i = 0; i < MAX_PLAYERS; i++)
11971 effective_action[i] = stored_player[i].effective_action;
11973 GameActions_EM(effective_action, warp_mode);
11976 void GameActions_SP_Main(void)
11978 byte effective_action[MAX_PLAYERS];
11979 boolean warp_mode = (tape.playing && tape.warp_forward && !tape.pausing);
11982 for (i = 0; i < MAX_PLAYERS; i++)
11983 effective_action[i] = stored_player[i].effective_action;
11985 GameActions_SP(effective_action, warp_mode);
11987 for (i = 0; i < MAX_PLAYERS; i++)
11989 if (stored_player[i].force_dropping)
11990 stored_player[i].action |= KEY_BUTTON_DROP;
11992 stored_player[i].force_dropping = FALSE;
11996 void GameActions_MM_Main(void)
11998 boolean warp_mode = (tape.playing && tape.warp_forward && !tape.pausing);
12000 GameActions_MM(local_player->effective_mouse_action, warp_mode);
12003 void GameActions_RND_Main(void)
12008 void GameActions_RND(void)
12010 static struct MouseActionInfo mouse_action_last = { 0 };
12011 struct MouseActionInfo mouse_action = local_player->effective_mouse_action;
12012 int magic_wall_x = 0, magic_wall_y = 0;
12013 int i, x, y, element, graphic, last_gfx_frame;
12015 InitPlayfieldScanModeVars();
12017 if (game.engine_version >= VERSION_IDENT(3,2,0,7))
12019 SCAN_PLAYFIELD(x, y)
12021 ChangeCount[x][y] = 0;
12022 ChangeEvent[x][y] = -1;
12026 if (game.set_centered_player)
12028 boolean all_players_fit_to_screen = checkIfAllPlayersFitToScreen_RND();
12030 // switching to "all players" only possible if all players fit to screen
12031 if (game.centered_player_nr_next == -1 && !all_players_fit_to_screen)
12033 game.centered_player_nr_next = game.centered_player_nr;
12034 game.set_centered_player = FALSE;
12037 // do not switch focus to non-existing (or non-active) player
12038 if (game.centered_player_nr_next >= 0 &&
12039 !stored_player[game.centered_player_nr_next].active)
12041 game.centered_player_nr_next = game.centered_player_nr;
12042 game.set_centered_player = FALSE;
12046 if (game.set_centered_player &&
12047 ScreenMovPos == 0) // screen currently aligned at tile position
12051 if (game.centered_player_nr_next == -1)
12053 setScreenCenteredToAllPlayers(&sx, &sy);
12057 sx = stored_player[game.centered_player_nr_next].jx;
12058 sy = stored_player[game.centered_player_nr_next].jy;
12061 game.centered_player_nr = game.centered_player_nr_next;
12062 game.set_centered_player = FALSE;
12064 DrawRelocateScreen(0, 0, sx, sy, MV_NONE, TRUE, setup.quick_switch);
12065 DrawGameDoorValues();
12068 // check single step mode (set flag and clear again if any player is active)
12069 game.enter_single_step_mode =
12070 (tape.single_step && tape.recording && !tape.pausing);
12072 for (i = 0; i < MAX_PLAYERS; i++)
12074 int actual_player_action = stored_player[i].effective_action;
12077 /* !!! THIS BREAKS THE FOLLOWING TAPES: !!!
12078 - rnd_equinox_tetrachloride 048
12079 - rnd_equinox_tetrachloride_ii 096
12080 - rnd_emanuel_schmieg 002
12081 - doctor_sloan_ww 001, 020
12083 if (stored_player[i].MovPos == 0)
12084 CheckGravityMovement(&stored_player[i]);
12087 // overwrite programmed action with tape action
12088 if (stored_player[i].programmed_action)
12089 actual_player_action = stored_player[i].programmed_action;
12091 PlayerActions(&stored_player[i], actual_player_action);
12093 ScrollPlayer(&stored_player[i], SCROLL_GO_ON);
12096 // single step pause mode may already have been toggled by "ScrollPlayer()"
12097 if (game.enter_single_step_mode && !tape.pausing)
12098 TapeTogglePause(TAPE_TOGGLE_AUTOMATIC);
12100 ScrollScreen(NULL, SCROLL_GO_ON);
12102 /* for backwards compatibility, the following code emulates a fixed bug that
12103 occured when pushing elements (causing elements that just made their last
12104 pushing step to already (if possible) make their first falling step in the
12105 same game frame, which is bad); this code is also needed to use the famous
12106 "spring push bug" which is used in older levels and might be wanted to be
12107 used also in newer levels, but in this case the buggy pushing code is only
12108 affecting the "spring" element and no other elements */
12110 if (game.engine_version < VERSION_IDENT(2,2,0,7) || level.use_spring_bug)
12112 for (i = 0; i < MAX_PLAYERS; i++)
12114 struct PlayerInfo *player = &stored_player[i];
12115 int x = player->jx;
12116 int y = player->jy;
12118 if (player->active && player->is_pushing && player->is_moving &&
12120 (game.engine_version < VERSION_IDENT(2,2,0,7) ||
12121 Tile[x][y] == EL_SPRING))
12123 ContinueMoving(x, y);
12125 // continue moving after pushing (this is actually a bug)
12126 if (!IS_MOVING(x, y))
12127 Stop[x][y] = FALSE;
12132 SCAN_PLAYFIELD(x, y)
12134 Last[x][y] = Tile[x][y];
12136 ChangeCount[x][y] = 0;
12137 ChangeEvent[x][y] = -1;
12139 // this must be handled before main playfield loop
12140 if (Tile[x][y] == EL_PLAYER_IS_LEAVING)
12143 if (MovDelay[x][y] <= 0)
12147 if (Tile[x][y] == EL_ELEMENT_SNAPPING)
12150 if (MovDelay[x][y] <= 0)
12152 int element = Store[x][y];
12153 int move_direction = MovDir[x][y];
12154 int player_index_bit = Store2[x][y];
12160 TEST_DrawLevelField(x, y);
12162 TestFieldAfterSnapping(x, y, element, move_direction, player_index_bit);
12167 if (ChangePage[x][y] != -1 && ChangeDelay[x][y] != 1)
12169 Debug("game:playing:GameActions_RND", "x = %d, y = %d: ChangePage != -1",
12171 Debug("game:playing:GameActions_RND", "This should never happen!");
12173 ChangePage[x][y] = -1;
12177 Stop[x][y] = FALSE;
12178 if (WasJustMoving[x][y] > 0)
12179 WasJustMoving[x][y]--;
12180 if (WasJustFalling[x][y] > 0)
12181 WasJustFalling[x][y]--;
12182 if (CheckCollision[x][y] > 0)
12183 CheckCollision[x][y]--;
12184 if (CheckImpact[x][y] > 0)
12185 CheckImpact[x][y]--;
12189 /* reset finished pushing action (not done in ContinueMoving() to allow
12190 continuous pushing animation for elements with zero push delay) */
12191 if (GfxAction[x][y] == ACTION_PUSHING && !IS_MOVING(x, y))
12193 ResetGfxAnimation(x, y);
12194 TEST_DrawLevelField(x, y);
12198 if (IS_BLOCKED(x, y))
12202 Blocked2Moving(x, y, &oldx, &oldy);
12203 if (!IS_MOVING(oldx, oldy))
12205 Debug("game:playing:GameActions_RND", "(BLOCKED => MOVING) context corrupted!");
12206 Debug("game:playing:GameActions_RND", "BLOCKED: x = %d, y = %d", x, y);
12207 Debug("game:playing:GameActions_RND", "!MOVING: oldx = %d, oldy = %d", oldx, oldy);
12208 Debug("game:playing:GameActions_RND", "This should never happen!");
12214 if (mouse_action.button)
12216 int new_button = (mouse_action.button && mouse_action_last.button == 0);
12217 int ch_button = CH_SIDE_FROM_BUTTON(mouse_action.button);
12219 x = mouse_action.lx;
12220 y = mouse_action.ly;
12221 element = Tile[x][y];
12225 CheckElementChangeByMouse(x, y, element, CE_CLICKED_BY_MOUSE, ch_button);
12226 CheckTriggeredElementChangeByMouse(x, y, element, CE_MOUSE_CLICKED_ON_X,
12230 CheckElementChangeByMouse(x, y, element, CE_PRESSED_BY_MOUSE, ch_button);
12231 CheckTriggeredElementChangeByMouse(x, y, element, CE_MOUSE_PRESSED_ON_X,
12235 SCAN_PLAYFIELD(x, y)
12237 element = Tile[x][y];
12238 graphic = el_act_dir2img(element, GfxAction[x][y], GfxDir[x][y]);
12239 last_gfx_frame = GfxFrame[x][y];
12241 ResetGfxFrame(x, y);
12243 if (GfxFrame[x][y] != last_gfx_frame && !Stop[x][y])
12244 DrawLevelGraphicAnimation(x, y, graphic);
12246 if (ANIM_MODE(graphic) == ANIM_RANDOM &&
12247 IS_NEXT_FRAME(GfxFrame[x][y], graphic))
12248 ResetRandomAnimationValue(x, y);
12250 SetRandomAnimationValue(x, y);
12252 PlayLevelSoundActionIfLoop(x, y, GfxAction[x][y]);
12254 if (IS_INACTIVE(element))
12256 if (IS_ANIMATED(graphic))
12257 DrawLevelGraphicAnimationIfNeeded(x, y, graphic);
12262 // this may take place after moving, so 'element' may have changed
12263 if (IS_CHANGING(x, y) &&
12264 (game.engine_version < VERSION_IDENT(3,0,7,1) || !Stop[x][y]))
12266 int page = element_info[element].event_page_nr[CE_DELAY];
12268 HandleElementChange(x, y, page);
12270 element = Tile[x][y];
12271 graphic = el_act_dir2img(element, GfxAction[x][y], GfxDir[x][y]);
12274 if (!IS_MOVING(x, y) && (CAN_FALL(element) || CAN_MOVE(element)))
12278 element = Tile[x][y];
12279 graphic = el_act_dir2img(element, GfxAction[x][y], GfxDir[x][y]);
12281 if (IS_ANIMATED(graphic) &&
12282 !IS_MOVING(x, y) &&
12284 DrawLevelGraphicAnimationIfNeeded(x, y, graphic);
12286 if (IS_GEM(element) || element == EL_SP_INFOTRON)
12287 TEST_DrawTwinkleOnField(x, y);
12289 else if (element == EL_ACID)
12292 DrawLevelGraphicAnimationIfNeeded(x, y, graphic);
12294 else if ((element == EL_EXIT_OPEN ||
12295 element == EL_EM_EXIT_OPEN ||
12296 element == EL_SP_EXIT_OPEN ||
12297 element == EL_STEEL_EXIT_OPEN ||
12298 element == EL_EM_STEEL_EXIT_OPEN ||
12299 element == EL_SP_TERMINAL ||
12300 element == EL_SP_TERMINAL_ACTIVE ||
12301 element == EL_EXTRA_TIME ||
12302 element == EL_SHIELD_NORMAL ||
12303 element == EL_SHIELD_DEADLY) &&
12304 IS_ANIMATED(graphic))
12305 DrawLevelGraphicAnimationIfNeeded(x, y, graphic);
12306 else if (IS_MOVING(x, y))
12307 ContinueMoving(x, y);
12308 else if (IS_ACTIVE_BOMB(element))
12309 CheckDynamite(x, y);
12310 else if (element == EL_AMOEBA_GROWING)
12311 AmoebaGrowing(x, y);
12312 else if (element == EL_AMOEBA_SHRINKING)
12313 AmoebaShrinking(x, y);
12315 #if !USE_NEW_AMOEBA_CODE
12316 else if (IS_AMOEBALIVE(element))
12317 AmoebaReproduce(x, y);
12320 else if (element == EL_GAME_OF_LIFE || element == EL_BIOMAZE)
12322 else if (element == EL_EXIT_CLOSED)
12324 else if (element == EL_EM_EXIT_CLOSED)
12326 else if (element == EL_STEEL_EXIT_CLOSED)
12327 CheckExitSteel(x, y);
12328 else if (element == EL_EM_STEEL_EXIT_CLOSED)
12329 CheckExitSteelEM(x, y);
12330 else if (element == EL_SP_EXIT_CLOSED)
12332 else if (element == EL_EXPANDABLE_WALL_GROWING ||
12333 element == EL_EXPANDABLE_STEELWALL_GROWING)
12334 MauerWaechst(x, y);
12335 else if (element == EL_EXPANDABLE_WALL ||
12336 element == EL_EXPANDABLE_WALL_HORIZONTAL ||
12337 element == EL_EXPANDABLE_WALL_VERTICAL ||
12338 element == EL_EXPANDABLE_WALL_ANY ||
12339 element == EL_BD_EXPANDABLE_WALL)
12340 MauerAbleger(x, y);
12341 else if (element == EL_EXPANDABLE_STEELWALL_HORIZONTAL ||
12342 element == EL_EXPANDABLE_STEELWALL_VERTICAL ||
12343 element == EL_EXPANDABLE_STEELWALL_ANY)
12344 MauerAblegerStahl(x, y);
12345 else if (element == EL_FLAMES)
12346 CheckForDragon(x, y);
12347 else if (element == EL_EXPLOSION)
12348 ; // drawing of correct explosion animation is handled separately
12349 else if (element == EL_ELEMENT_SNAPPING ||
12350 element == EL_DIAGONAL_SHRINKING ||
12351 element == EL_DIAGONAL_GROWING)
12353 graphic = el_act_dir2img(GfxElement[x][y], GfxAction[x][y],GfxDir[x][y]);
12355 DrawLevelGraphicAnimationIfNeeded(x, y, graphic);
12357 else if (IS_ANIMATED(graphic) && !IS_CHANGING(x, y))
12358 DrawLevelGraphicAnimationIfNeeded(x, y, graphic);
12360 if (IS_BELT_ACTIVE(element))
12361 PlayLevelSoundAction(x, y, ACTION_ACTIVE);
12363 if (game.magic_wall_active)
12365 int jx = local_player->jx, jy = local_player->jy;
12367 // play the element sound at the position nearest to the player
12368 if ((element == EL_MAGIC_WALL_FULL ||
12369 element == EL_MAGIC_WALL_ACTIVE ||
12370 element == EL_MAGIC_WALL_EMPTYING ||
12371 element == EL_BD_MAGIC_WALL_FULL ||
12372 element == EL_BD_MAGIC_WALL_ACTIVE ||
12373 element == EL_BD_MAGIC_WALL_EMPTYING ||
12374 element == EL_DC_MAGIC_WALL_FULL ||
12375 element == EL_DC_MAGIC_WALL_ACTIVE ||
12376 element == EL_DC_MAGIC_WALL_EMPTYING) &&
12377 ABS(x - jx) + ABS(y - jy) <
12378 ABS(magic_wall_x - jx) + ABS(magic_wall_y - jy))
12386 #if USE_NEW_AMOEBA_CODE
12387 // new experimental amoeba growth stuff
12388 if (!(FrameCounter % 8))
12390 static unsigned int random = 1684108901;
12392 for (i = 0; i < level.amoeba_speed * 28 / 8; i++)
12394 x = RND(lev_fieldx);
12395 y = RND(lev_fieldy);
12396 element = Tile[x][y];
12398 if (!IS_PLAYER(x,y) &&
12399 (element == EL_EMPTY ||
12400 CAN_GROW_INTO(element) ||
12401 element == EL_QUICKSAND_EMPTY ||
12402 element == EL_QUICKSAND_FAST_EMPTY ||
12403 element == EL_ACID_SPLASH_LEFT ||
12404 element == EL_ACID_SPLASH_RIGHT))
12406 if ((IN_LEV_FIELD(x, y-1) && Tile[x][y-1] == EL_AMOEBA_WET) ||
12407 (IN_LEV_FIELD(x-1, y) && Tile[x-1][y] == EL_AMOEBA_WET) ||
12408 (IN_LEV_FIELD(x+1, y) && Tile[x+1][y] == EL_AMOEBA_WET) ||
12409 (IN_LEV_FIELD(x, y+1) && Tile[x][y+1] == EL_AMOEBA_WET))
12410 Tile[x][y] = EL_AMOEBA_DROP;
12413 random = random * 129 + 1;
12418 game.explosions_delayed = FALSE;
12420 SCAN_PLAYFIELD(x, y)
12422 element = Tile[x][y];
12424 if (ExplodeField[x][y])
12425 Explode(x, y, EX_PHASE_START, ExplodeField[x][y]);
12426 else if (element == EL_EXPLOSION)
12427 Explode(x, y, ExplodePhase[x][y], EX_TYPE_NORMAL);
12429 ExplodeField[x][y] = EX_TYPE_NONE;
12432 game.explosions_delayed = TRUE;
12434 if (game.magic_wall_active)
12436 if (!(game.magic_wall_time_left % 4))
12438 int element = Tile[magic_wall_x][magic_wall_y];
12440 if (element == EL_BD_MAGIC_WALL_FULL ||
12441 element == EL_BD_MAGIC_WALL_ACTIVE ||
12442 element == EL_BD_MAGIC_WALL_EMPTYING)
12443 PlayLevelSound(magic_wall_x, magic_wall_y, SND_BD_MAGIC_WALL_ACTIVE);
12444 else if (element == EL_DC_MAGIC_WALL_FULL ||
12445 element == EL_DC_MAGIC_WALL_ACTIVE ||
12446 element == EL_DC_MAGIC_WALL_EMPTYING)
12447 PlayLevelSound(magic_wall_x, magic_wall_y, SND_DC_MAGIC_WALL_ACTIVE);
12449 PlayLevelSound(magic_wall_x, magic_wall_y, SND_MAGIC_WALL_ACTIVE);
12452 if (game.magic_wall_time_left > 0)
12454 game.magic_wall_time_left--;
12456 if (!game.magic_wall_time_left)
12458 SCAN_PLAYFIELD(x, y)
12460 element = Tile[x][y];
12462 if (element == EL_MAGIC_WALL_ACTIVE ||
12463 element == EL_MAGIC_WALL_FULL)
12465 Tile[x][y] = EL_MAGIC_WALL_DEAD;
12466 TEST_DrawLevelField(x, y);
12468 else if (element == EL_BD_MAGIC_WALL_ACTIVE ||
12469 element == EL_BD_MAGIC_WALL_FULL)
12471 Tile[x][y] = EL_BD_MAGIC_WALL_DEAD;
12472 TEST_DrawLevelField(x, y);
12474 else if (element == EL_DC_MAGIC_WALL_ACTIVE ||
12475 element == EL_DC_MAGIC_WALL_FULL)
12477 Tile[x][y] = EL_DC_MAGIC_WALL_DEAD;
12478 TEST_DrawLevelField(x, y);
12482 game.magic_wall_active = FALSE;
12487 if (game.light_time_left > 0)
12489 game.light_time_left--;
12491 if (game.light_time_left == 0)
12492 RedrawAllLightSwitchesAndInvisibleElements();
12495 if (game.timegate_time_left > 0)
12497 game.timegate_time_left--;
12499 if (game.timegate_time_left == 0)
12500 CloseAllOpenTimegates();
12503 if (game.lenses_time_left > 0)
12505 game.lenses_time_left--;
12507 if (game.lenses_time_left == 0)
12508 RedrawAllInvisibleElementsForLenses();
12511 if (game.magnify_time_left > 0)
12513 game.magnify_time_left--;
12515 if (game.magnify_time_left == 0)
12516 RedrawAllInvisibleElementsForMagnifier();
12519 for (i = 0; i < MAX_PLAYERS; i++)
12521 struct PlayerInfo *player = &stored_player[i];
12523 if (SHIELD_ON(player))
12525 if (player->shield_deadly_time_left)
12526 PlayLevelSound(player->jx, player->jy, SND_SHIELD_DEADLY_ACTIVE);
12527 else if (player->shield_normal_time_left)
12528 PlayLevelSound(player->jx, player->jy, SND_SHIELD_NORMAL_ACTIVE);
12532 #if USE_DELAYED_GFX_REDRAW
12533 SCAN_PLAYFIELD(x, y)
12535 if (GfxRedraw[x][y] != GFX_REDRAW_NONE)
12537 /* !!! PROBLEM: THIS REDRAWS THE PLAYFIELD _AFTER_ THE SCAN, BUT TILES
12538 !!! MAY HAVE CHANGED AFTER BEING DRAWN DURING PLAYFIELD SCAN !!! */
12540 if (GfxRedraw[x][y] & GFX_REDRAW_TILE)
12541 DrawLevelField(x, y);
12543 if (GfxRedraw[x][y] & GFX_REDRAW_TILE_CRUMBLED)
12544 DrawLevelFieldCrumbled(x, y);
12546 if (GfxRedraw[x][y] & GFX_REDRAW_TILE_CRUMBLED_NEIGHBOURS)
12547 DrawLevelFieldCrumbledNeighbours(x, y);
12549 if (GfxRedraw[x][y] & GFX_REDRAW_TILE_TWINKLED)
12550 DrawTwinkleOnField(x, y);
12553 GfxRedraw[x][y] = GFX_REDRAW_NONE;
12558 PlayAllPlayersSound();
12560 for (i = 0; i < MAX_PLAYERS; i++)
12562 struct PlayerInfo *player = &stored_player[i];
12564 if (player->show_envelope != 0 && (!player->active ||
12565 player->MovPos == 0))
12567 ShowEnvelope(player->show_envelope - EL_ENVELOPE_1);
12569 player->show_envelope = 0;
12573 // use random number generator in every frame to make it less predictable
12574 if (game.engine_version >= VERSION_IDENT(3,1,1,0))
12577 mouse_action_last = mouse_action;
12580 static boolean AllPlayersInSight(struct PlayerInfo *player, int x, int y)
12582 int min_x = x, min_y = y, max_x = x, max_y = y;
12583 int scr_fieldx = getScreenFieldSizeX();
12584 int scr_fieldy = getScreenFieldSizeY();
12587 for (i = 0; i < MAX_PLAYERS; i++)
12589 int jx = stored_player[i].jx, jy = stored_player[i].jy;
12591 if (!stored_player[i].active || &stored_player[i] == player)
12594 min_x = MIN(min_x, jx);
12595 min_y = MIN(min_y, jy);
12596 max_x = MAX(max_x, jx);
12597 max_y = MAX(max_y, jy);
12600 return (max_x - min_x < scr_fieldx && max_y - min_y < scr_fieldy);
12603 static boolean AllPlayersInVisibleScreen(void)
12607 for (i = 0; i < MAX_PLAYERS; i++)
12609 int jx = stored_player[i].jx, jy = stored_player[i].jy;
12611 if (!stored_player[i].active)
12614 if (!IN_VIS_FIELD(SCREENX(jx), SCREENY(jy)))
12621 void ScrollLevel(int dx, int dy)
12623 int scroll_offset = 2 * TILEX_VAR;
12626 BlitBitmap(drawto_field, drawto_field,
12627 FX + TILEX_VAR * (dx == -1) - scroll_offset,
12628 FY + TILEY_VAR * (dy == -1) - scroll_offset,
12629 SXSIZE - TILEX_VAR * (dx != 0) + 2 * scroll_offset,
12630 SYSIZE - TILEY_VAR * (dy != 0) + 2 * scroll_offset,
12631 FX + TILEX_VAR * (dx == 1) - scroll_offset,
12632 FY + TILEY_VAR * (dy == 1) - scroll_offset);
12636 x = (dx == 1 ? BX1 : BX2);
12637 for (y = BY1; y <= BY2; y++)
12638 DrawScreenField(x, y);
12643 y = (dy == 1 ? BY1 : BY2);
12644 for (x = BX1; x <= BX2; x++)
12645 DrawScreenField(x, y);
12648 redraw_mask |= REDRAW_FIELD;
12651 static boolean canFallDown(struct PlayerInfo *player)
12653 int jx = player->jx, jy = player->jy;
12655 return (IN_LEV_FIELD(jx, jy + 1) &&
12656 (IS_FREE(jx, jy + 1) ||
12657 (Tile[jx][jy + 1] == EL_ACID && player->can_fall_into_acid)) &&
12658 IS_WALKABLE_FROM(Tile[jx][jy], MV_DOWN) &&
12659 !IS_WALKABLE_INSIDE(Tile[jx][jy]));
12662 static boolean canPassField(int x, int y, int move_dir)
12664 int opposite_dir = MV_DIR_OPPOSITE(move_dir);
12665 int dx = (move_dir & MV_LEFT ? -1 : move_dir & MV_RIGHT ? +1 : 0);
12666 int dy = (move_dir & MV_UP ? -1 : move_dir & MV_DOWN ? +1 : 0);
12667 int nextx = x + dx;
12668 int nexty = y + dy;
12669 int element = Tile[x][y];
12671 return (IS_PASSABLE_FROM(element, opposite_dir) &&
12672 !CAN_MOVE(element) &&
12673 IN_LEV_FIELD(nextx, nexty) && !IS_PLAYER(nextx, nexty) &&
12674 IS_WALKABLE_FROM(Tile[nextx][nexty], move_dir) &&
12675 (level.can_pass_to_walkable || IS_FREE(nextx, nexty)));
12678 static boolean canMoveToValidFieldWithGravity(int x, int y, int move_dir)
12680 int opposite_dir = MV_DIR_OPPOSITE(move_dir);
12681 int dx = (move_dir & MV_LEFT ? -1 : move_dir & MV_RIGHT ? +1 : 0);
12682 int dy = (move_dir & MV_UP ? -1 : move_dir & MV_DOWN ? +1 : 0);
12686 return (IN_LEV_FIELD(newx, newy) && !IS_FREE_OR_PLAYER(newx, newy) &&
12687 IS_GRAVITY_REACHABLE(Tile[newx][newy]) &&
12688 (IS_DIGGABLE(Tile[newx][newy]) ||
12689 IS_WALKABLE_FROM(Tile[newx][newy], opposite_dir) ||
12690 canPassField(newx, newy, move_dir)));
12693 static void CheckGravityMovement(struct PlayerInfo *player)
12695 if (player->gravity && !player->programmed_action)
12697 int move_dir_horizontal = player->effective_action & MV_HORIZONTAL;
12698 int move_dir_vertical = player->effective_action & MV_VERTICAL;
12699 boolean player_is_snapping = (player->effective_action & JOY_BUTTON_1);
12700 int jx = player->jx, jy = player->jy;
12701 boolean player_is_moving_to_valid_field =
12702 (!player_is_snapping &&
12703 (canMoveToValidFieldWithGravity(jx, jy, move_dir_horizontal) ||
12704 canMoveToValidFieldWithGravity(jx, jy, move_dir_vertical)));
12705 boolean player_can_fall_down = canFallDown(player);
12707 if (player_can_fall_down &&
12708 !player_is_moving_to_valid_field)
12709 player->programmed_action = MV_DOWN;
12713 static void CheckGravityMovementWhenNotMoving(struct PlayerInfo *player)
12715 return CheckGravityMovement(player);
12717 if (player->gravity && !player->programmed_action)
12719 int jx = player->jx, jy = player->jy;
12720 boolean field_under_player_is_free =
12721 (IN_LEV_FIELD(jx, jy + 1) && IS_FREE(jx, jy + 1));
12722 boolean player_is_standing_on_valid_field =
12723 (IS_WALKABLE_INSIDE(Tile[jx][jy]) ||
12724 (IS_WALKABLE(Tile[jx][jy]) &&
12725 !(element_info[Tile[jx][jy]].access_direction & MV_DOWN)));
12727 if (field_under_player_is_free && !player_is_standing_on_valid_field)
12728 player->programmed_action = MV_DOWN;
12733 MovePlayerOneStep()
12734 -----------------------------------------------------------------------------
12735 dx, dy: direction (non-diagonal) to try to move the player to
12736 real_dx, real_dy: direction as read from input device (can be diagonal)
12739 boolean MovePlayerOneStep(struct PlayerInfo *player,
12740 int dx, int dy, int real_dx, int real_dy)
12742 int jx = player->jx, jy = player->jy;
12743 int new_jx = jx + dx, new_jy = jy + dy;
12745 boolean player_can_move = !player->cannot_move;
12747 if (!player->active || (!dx && !dy))
12748 return MP_NO_ACTION;
12750 player->MovDir = (dx < 0 ? MV_LEFT :
12751 dx > 0 ? MV_RIGHT :
12753 dy > 0 ? MV_DOWN : MV_NONE);
12755 if (!IN_LEV_FIELD(new_jx, new_jy))
12756 return MP_NO_ACTION;
12758 if (!player_can_move)
12760 if (player->MovPos == 0)
12762 player->is_moving = FALSE;
12763 player->is_digging = FALSE;
12764 player->is_collecting = FALSE;
12765 player->is_snapping = FALSE;
12766 player->is_pushing = FALSE;
12770 if (!network.enabled && game.centered_player_nr == -1 &&
12771 !AllPlayersInSight(player, new_jx, new_jy))
12772 return MP_NO_ACTION;
12774 can_move = DigField(player, jx, jy, new_jx, new_jy, real_dx,real_dy, DF_DIG);
12775 if (can_move != MP_MOVING)
12778 // check if DigField() has caused relocation of the player
12779 if (player->jx != jx || player->jy != jy)
12780 return MP_NO_ACTION; // <-- !!! CHECK THIS [-> MP_ACTION ?] !!!
12782 StorePlayer[jx][jy] = 0;
12783 player->last_jx = jx;
12784 player->last_jy = jy;
12785 player->jx = new_jx;
12786 player->jy = new_jy;
12787 StorePlayer[new_jx][new_jy] = player->element_nr;
12789 if (player->move_delay_value_next != -1)
12791 player->move_delay_value = player->move_delay_value_next;
12792 player->move_delay_value_next = -1;
12796 (dx > 0 || dy > 0 ? -1 : 1) * (TILEX - TILEX / player->move_delay_value);
12798 player->step_counter++;
12800 PlayerVisit[jx][jy] = FrameCounter;
12802 player->is_moving = TRUE;
12805 // should better be called in MovePlayer(), but this breaks some tapes
12806 ScrollPlayer(player, SCROLL_INIT);
12812 boolean MovePlayer(struct PlayerInfo *player, int dx, int dy)
12814 int jx = player->jx, jy = player->jy;
12815 int old_jx = jx, old_jy = jy;
12816 int moved = MP_NO_ACTION;
12818 if (!player->active)
12823 if (player->MovPos == 0)
12825 player->is_moving = FALSE;
12826 player->is_digging = FALSE;
12827 player->is_collecting = FALSE;
12828 player->is_snapping = FALSE;
12829 player->is_pushing = FALSE;
12835 if (player->move_delay > 0)
12838 player->move_delay = -1; // set to "uninitialized" value
12840 // store if player is automatically moved to next field
12841 player->is_auto_moving = (player->programmed_action != MV_NONE);
12843 // remove the last programmed player action
12844 player->programmed_action = 0;
12846 if (player->MovPos)
12848 // should only happen if pre-1.2 tape recordings are played
12849 // this is only for backward compatibility
12851 int original_move_delay_value = player->move_delay_value;
12854 Debug("game:playing:MovePlayer",
12855 "THIS SHOULD ONLY HAPPEN WITH PRE-1.2 LEVEL TAPES. [%d]",
12859 // scroll remaining steps with finest movement resolution
12860 player->move_delay_value = MOVE_DELAY_NORMAL_SPEED;
12862 while (player->MovPos)
12864 ScrollPlayer(player, SCROLL_GO_ON);
12865 ScrollScreen(NULL, SCROLL_GO_ON);
12867 AdvanceFrameAndPlayerCounters(player->index_nr);
12870 BackToFront_WithFrameDelay(0);
12873 player->move_delay_value = original_move_delay_value;
12876 player->is_active = FALSE;
12878 if (player->last_move_dir & MV_HORIZONTAL)
12880 if (!(moved |= MovePlayerOneStep(player, 0, dy, dx, dy)))
12881 moved |= MovePlayerOneStep(player, dx, 0, dx, dy);
12885 if (!(moved |= MovePlayerOneStep(player, dx, 0, dx, dy)))
12886 moved |= MovePlayerOneStep(player, 0, dy, dx, dy);
12889 if (!moved && !player->is_active)
12891 player->is_moving = FALSE;
12892 player->is_digging = FALSE;
12893 player->is_collecting = FALSE;
12894 player->is_snapping = FALSE;
12895 player->is_pushing = FALSE;
12901 if (moved & MP_MOVING && !ScreenMovPos &&
12902 (player->index_nr == game.centered_player_nr ||
12903 game.centered_player_nr == -1))
12905 int old_scroll_x = scroll_x, old_scroll_y = scroll_y;
12907 if (!IN_VIS_FIELD(SCREENX(jx), SCREENY(jy)))
12909 // actual player has left the screen -- scroll in that direction
12910 if (jx != old_jx) // player has moved horizontally
12911 scroll_x += (jx - old_jx);
12912 else // player has moved vertically
12913 scroll_y += (jy - old_jy);
12917 int offset_raw = game.scroll_delay_value;
12919 if (jx != old_jx) // player has moved horizontally
12921 int offset = MIN(offset_raw, (SCR_FIELDX - 2) / 2);
12922 int offset_x = offset * (player->MovDir == MV_LEFT ? +1 : -1);
12923 int new_scroll_x = jx - MIDPOSX + offset_x;
12925 if ((player->MovDir == MV_LEFT && scroll_x > new_scroll_x) ||
12926 (player->MovDir == MV_RIGHT && scroll_x < new_scroll_x))
12927 scroll_x = new_scroll_x;
12929 // don't scroll over playfield boundaries
12930 scroll_x = MIN(MAX(SBX_Left, scroll_x), SBX_Right);
12932 // don't scroll more than one field at a time
12933 scroll_x = old_scroll_x + SIGN(scroll_x - old_scroll_x);
12935 // don't scroll against the player's moving direction
12936 if ((player->MovDir == MV_LEFT && scroll_x > old_scroll_x) ||
12937 (player->MovDir == MV_RIGHT && scroll_x < old_scroll_x))
12938 scroll_x = old_scroll_x;
12940 else // player has moved vertically
12942 int offset = MIN(offset_raw, (SCR_FIELDY - 2) / 2);
12943 int offset_y = offset * (player->MovDir == MV_UP ? +1 : -1);
12944 int new_scroll_y = jy - MIDPOSY + offset_y;
12946 if ((player->MovDir == MV_UP && scroll_y > new_scroll_y) ||
12947 (player->MovDir == MV_DOWN && scroll_y < new_scroll_y))
12948 scroll_y = new_scroll_y;
12950 // don't scroll over playfield boundaries
12951 scroll_y = MIN(MAX(SBY_Upper, scroll_y), SBY_Lower);
12953 // don't scroll more than one field at a time
12954 scroll_y = old_scroll_y + SIGN(scroll_y - old_scroll_y);
12956 // don't scroll against the player's moving direction
12957 if ((player->MovDir == MV_UP && scroll_y > old_scroll_y) ||
12958 (player->MovDir == MV_DOWN && scroll_y < old_scroll_y))
12959 scroll_y = old_scroll_y;
12963 if (scroll_x != old_scroll_x || scroll_y != old_scroll_y)
12965 if (!network.enabled && game.centered_player_nr == -1 &&
12966 !AllPlayersInVisibleScreen())
12968 scroll_x = old_scroll_x;
12969 scroll_y = old_scroll_y;
12973 ScrollScreen(player, SCROLL_INIT);
12974 ScrollLevel(old_scroll_x - scroll_x, old_scroll_y - scroll_y);
12979 player->StepFrame = 0;
12981 if (moved & MP_MOVING)
12983 if (old_jx != jx && old_jy == jy)
12984 player->MovDir = (old_jx < jx ? MV_RIGHT : MV_LEFT);
12985 else if (old_jx == jx && old_jy != jy)
12986 player->MovDir = (old_jy < jy ? MV_DOWN : MV_UP);
12988 TEST_DrawLevelField(jx, jy); // for "crumbled sand"
12990 player->last_move_dir = player->MovDir;
12991 player->is_moving = TRUE;
12992 player->is_snapping = FALSE;
12993 player->is_switching = FALSE;
12994 player->is_dropping = FALSE;
12995 player->is_dropping_pressed = FALSE;
12996 player->drop_pressed_delay = 0;
12999 // should better be called here than above, but this breaks some tapes
13000 ScrollPlayer(player, SCROLL_INIT);
13005 CheckGravityMovementWhenNotMoving(player);
13007 player->is_moving = FALSE;
13009 /* at this point, the player is allowed to move, but cannot move right now
13010 (e.g. because of something blocking the way) -- ensure that the player
13011 is also allowed to move in the next frame (in old versions before 3.1.1,
13012 the player was forced to wait again for eight frames before next try) */
13014 if (game.engine_version >= VERSION_IDENT(3,1,1,0))
13015 player->move_delay = 0; // allow direct movement in the next frame
13018 if (player->move_delay == -1) // not yet initialized by DigField()
13019 player->move_delay = player->move_delay_value;
13021 if (game.engine_version < VERSION_IDENT(3,0,7,0))
13023 TestIfPlayerTouchesBadThing(jx, jy);
13024 TestIfPlayerTouchesCustomElement(jx, jy);
13027 if (!player->active)
13028 RemovePlayer(player);
13033 void ScrollPlayer(struct PlayerInfo *player, int mode)
13035 int jx = player->jx, jy = player->jy;
13036 int last_jx = player->last_jx, last_jy = player->last_jy;
13037 int move_stepsize = TILEX / player->move_delay_value;
13039 if (!player->active)
13042 if (player->MovPos == 0 && mode == SCROLL_GO_ON) // player not moving
13045 if (mode == SCROLL_INIT)
13047 player->actual_frame_counter = FrameCounter;
13048 player->GfxPos = move_stepsize * (player->MovPos / move_stepsize);
13050 if ((player->block_last_field || player->block_delay_adjustment > 0) &&
13051 Tile[last_jx][last_jy] == EL_EMPTY)
13053 int last_field_block_delay = 0; // start with no blocking at all
13054 int block_delay_adjustment = player->block_delay_adjustment;
13056 // if player blocks last field, add delay for exactly one move
13057 if (player->block_last_field)
13059 last_field_block_delay += player->move_delay_value;
13061 // when blocking enabled, prevent moving up despite gravity
13062 if (player->gravity && player->MovDir == MV_UP)
13063 block_delay_adjustment = -1;
13066 // add block delay adjustment (also possible when not blocking)
13067 last_field_block_delay += block_delay_adjustment;
13069 Tile[last_jx][last_jy] = EL_PLAYER_IS_LEAVING;
13070 MovDelay[last_jx][last_jy] = last_field_block_delay + 1;
13073 if (player->MovPos != 0) // player has not yet reached destination
13076 else if (!FrameReached(&player->actual_frame_counter, 1))
13079 if (player->MovPos != 0)
13081 player->MovPos += (player->MovPos > 0 ? -1 : 1) * move_stepsize;
13082 player->GfxPos = move_stepsize * (player->MovPos / move_stepsize);
13084 // before DrawPlayer() to draw correct player graphic for this case
13085 if (player->MovPos == 0)
13086 CheckGravityMovement(player);
13089 if (player->MovPos == 0) // player reached destination field
13091 if (player->move_delay_reset_counter > 0)
13093 player->move_delay_reset_counter--;
13095 if (player->move_delay_reset_counter == 0)
13097 // continue with normal speed after quickly moving through gate
13098 HALVE_PLAYER_SPEED(player);
13100 // be able to make the next move without delay
13101 player->move_delay = 0;
13105 player->last_jx = jx;
13106 player->last_jy = jy;
13108 if (Tile[jx][jy] == EL_EXIT_OPEN ||
13109 Tile[jx][jy] == EL_EM_EXIT_OPEN ||
13110 Tile[jx][jy] == EL_EM_EXIT_OPENING ||
13111 Tile[jx][jy] == EL_STEEL_EXIT_OPEN ||
13112 Tile[jx][jy] == EL_EM_STEEL_EXIT_OPEN ||
13113 Tile[jx][jy] == EL_EM_STEEL_EXIT_OPENING ||
13114 Tile[jx][jy] == EL_SP_EXIT_OPEN ||
13115 Tile[jx][jy] == EL_SP_EXIT_OPENING) // <-- special case
13117 ExitPlayer(player);
13119 if (game.players_still_needed == 0 &&
13120 (game.friends_still_needed == 0 ||
13121 IS_SP_ELEMENT(Tile[jx][jy])))
13125 // this breaks one level: "machine", level 000
13127 int move_direction = player->MovDir;
13128 int enter_side = MV_DIR_OPPOSITE(move_direction);
13129 int leave_side = move_direction;
13130 int old_jx = last_jx;
13131 int old_jy = last_jy;
13132 int old_element = Tile[old_jx][old_jy];
13133 int new_element = Tile[jx][jy];
13135 if (IS_CUSTOM_ELEMENT(old_element))
13136 CheckElementChangeByPlayer(old_jx, old_jy, old_element,
13138 player->index_bit, leave_side);
13140 CheckTriggeredElementChangeByPlayer(old_jx, old_jy, old_element,
13141 CE_PLAYER_LEAVES_X,
13142 player->index_bit, leave_side);
13144 if (IS_CUSTOM_ELEMENT(new_element))
13145 CheckElementChangeByPlayer(jx, jy, new_element, CE_ENTERED_BY_PLAYER,
13146 player->index_bit, enter_side);
13148 CheckTriggeredElementChangeByPlayer(jx, jy, new_element,
13149 CE_PLAYER_ENTERS_X,
13150 player->index_bit, enter_side);
13152 CheckTriggeredElementChangeBySide(jx, jy, player->initial_element,
13153 CE_MOVE_OF_X, move_direction);
13156 if (game.engine_version >= VERSION_IDENT(3,0,7,0))
13158 TestIfPlayerTouchesBadThing(jx, jy);
13159 TestIfPlayerTouchesCustomElement(jx, jy);
13161 /* needed because pushed element has not yet reached its destination,
13162 so it would trigger a change event at its previous field location */
13163 if (!player->is_pushing)
13164 TestIfElementTouchesCustomElement(jx, jy); // for empty space
13166 if (level.finish_dig_collect &&
13167 (player->is_digging || player->is_collecting))
13169 int last_element = player->last_removed_element;
13170 int move_direction = player->MovDir;
13171 int enter_side = MV_DIR_OPPOSITE(move_direction);
13172 int change_event = (player->is_digging ? CE_PLAYER_DIGS_X :
13173 CE_PLAYER_COLLECTS_X);
13175 CheckTriggeredElementChangeByPlayer(jx, jy, last_element, change_event,
13176 player->index_bit, enter_side);
13178 player->last_removed_element = EL_UNDEFINED;
13181 if (!player->active)
13182 RemovePlayer(player);
13185 if (level.use_step_counter)
13195 if (TimeLeft <= 10 && setup.time_limit && !game.LevelSolved)
13196 PlaySound(SND_GAME_RUNNING_OUT_OF_TIME);
13198 game_panel_controls[GAME_PANEL_TIME].value = TimeLeft;
13200 DisplayGameControlValues();
13202 if (!TimeLeft && setup.time_limit && !game.LevelSolved)
13203 for (i = 0; i < MAX_PLAYERS; i++)
13204 KillPlayer(&stored_player[i]);
13206 else if (game.no_time_limit && !game.all_players_gone)
13208 game_panel_controls[GAME_PANEL_TIME].value = TimePlayed;
13210 DisplayGameControlValues();
13214 if (tape.single_step && tape.recording && !tape.pausing &&
13215 !player->programmed_action)
13216 TapeTogglePause(TAPE_TOGGLE_AUTOMATIC);
13218 if (!player->programmed_action)
13219 CheckSaveEngineSnapshot(player);
13223 void ScrollScreen(struct PlayerInfo *player, int mode)
13225 static unsigned int screen_frame_counter = 0;
13227 if (mode == SCROLL_INIT)
13229 // set scrolling step size according to actual player's moving speed
13230 ScrollStepSize = TILEX / player->move_delay_value;
13232 screen_frame_counter = FrameCounter;
13233 ScreenMovDir = player->MovDir;
13234 ScreenMovPos = player->MovPos;
13235 ScreenGfxPos = ScrollStepSize * (ScreenMovPos / ScrollStepSize);
13238 else if (!FrameReached(&screen_frame_counter, 1))
13243 ScreenMovPos += (ScreenMovPos > 0 ? -1 : 1) * ScrollStepSize;
13244 ScreenGfxPos = ScrollStepSize * (ScreenMovPos / ScrollStepSize);
13245 redraw_mask |= REDRAW_FIELD;
13248 ScreenMovDir = MV_NONE;
13251 void TestIfPlayerTouchesCustomElement(int x, int y)
13253 static int xy[4][2] =
13260 static int trigger_sides[4][2] =
13262 // center side border side
13263 { CH_SIDE_TOP, CH_SIDE_BOTTOM }, // check top
13264 { CH_SIDE_LEFT, CH_SIDE_RIGHT }, // check left
13265 { CH_SIDE_RIGHT, CH_SIDE_LEFT }, // check right
13266 { CH_SIDE_BOTTOM, CH_SIDE_TOP } // check bottom
13268 static int touch_dir[4] =
13270 MV_LEFT | MV_RIGHT,
13275 int center_element = Tile[x][y]; // should always be non-moving!
13278 for (i = 0; i < NUM_DIRECTIONS; i++)
13280 int xx = x + xy[i][0];
13281 int yy = y + xy[i][1];
13282 int center_side = trigger_sides[i][0];
13283 int border_side = trigger_sides[i][1];
13284 int border_element;
13286 if (!IN_LEV_FIELD(xx, yy))
13289 if (IS_PLAYER(x, y)) // player found at center element
13291 struct PlayerInfo *player = PLAYERINFO(x, y);
13293 if (game.engine_version < VERSION_IDENT(3,0,7,0))
13294 border_element = Tile[xx][yy]; // may be moving!
13295 else if (!IS_MOVING(xx, yy) && !IS_BLOCKED(xx, yy))
13296 border_element = Tile[xx][yy];
13297 else if (MovDir[xx][yy] & touch_dir[i]) // elements are touching
13298 border_element = MovingOrBlocked2Element(xx, yy);
13300 continue; // center and border element do not touch
13302 CheckElementChangeByPlayer(xx, yy, border_element, CE_TOUCHED_BY_PLAYER,
13303 player->index_bit, border_side);
13304 CheckTriggeredElementChangeByPlayer(xx, yy, border_element,
13305 CE_PLAYER_TOUCHES_X,
13306 player->index_bit, border_side);
13309 /* use player element that is initially defined in the level playfield,
13310 not the player element that corresponds to the runtime player number
13311 (example: a level that contains EL_PLAYER_3 as the only player would
13312 incorrectly give EL_PLAYER_1 for "player->element_nr") */
13313 int player_element = PLAYERINFO(x, y)->initial_element;
13315 CheckElementChangeBySide(xx, yy, border_element, player_element,
13316 CE_TOUCHING_X, border_side);
13319 else if (IS_PLAYER(xx, yy)) // player found at border element
13321 struct PlayerInfo *player = PLAYERINFO(xx, yy);
13323 if (game.engine_version >= VERSION_IDENT(3,0,7,0))
13325 if (player->MovPos != 0 && !(player->MovDir & touch_dir[i]))
13326 continue; // center and border element do not touch
13329 CheckElementChangeByPlayer(x, y, center_element, CE_TOUCHED_BY_PLAYER,
13330 player->index_bit, center_side);
13331 CheckTriggeredElementChangeByPlayer(x, y, center_element,
13332 CE_PLAYER_TOUCHES_X,
13333 player->index_bit, center_side);
13336 /* use player element that is initially defined in the level playfield,
13337 not the player element that corresponds to the runtime player number
13338 (example: a level that contains EL_PLAYER_3 as the only player would
13339 incorrectly give EL_PLAYER_1 for "player->element_nr") */
13340 int player_element = PLAYERINFO(xx, yy)->initial_element;
13342 CheckElementChangeBySide(x, y, center_element, player_element,
13343 CE_TOUCHING_X, center_side);
13351 void TestIfElementTouchesCustomElement(int x, int y)
13353 static int xy[4][2] =
13360 static int trigger_sides[4][2] =
13362 // center side border side
13363 { CH_SIDE_TOP, CH_SIDE_BOTTOM }, // check top
13364 { CH_SIDE_LEFT, CH_SIDE_RIGHT }, // check left
13365 { CH_SIDE_RIGHT, CH_SIDE_LEFT }, // check right
13366 { CH_SIDE_BOTTOM, CH_SIDE_TOP } // check bottom
13368 static int touch_dir[4] =
13370 MV_LEFT | MV_RIGHT,
13375 boolean change_center_element = FALSE;
13376 int center_element = Tile[x][y]; // should always be non-moving!
13377 int border_element_old[NUM_DIRECTIONS];
13380 for (i = 0; i < NUM_DIRECTIONS; i++)
13382 int xx = x + xy[i][0];
13383 int yy = y + xy[i][1];
13384 int border_element;
13386 border_element_old[i] = -1;
13388 if (!IN_LEV_FIELD(xx, yy))
13391 if (game.engine_version < VERSION_IDENT(3,0,7,0))
13392 border_element = Tile[xx][yy]; // may be moving!
13393 else if (!IS_MOVING(xx, yy) && !IS_BLOCKED(xx, yy))
13394 border_element = Tile[xx][yy];
13395 else if (MovDir[xx][yy] & touch_dir[i]) // elements are touching
13396 border_element = MovingOrBlocked2Element(xx, yy);
13398 continue; // center and border element do not touch
13400 border_element_old[i] = border_element;
13403 for (i = 0; i < NUM_DIRECTIONS; i++)
13405 int xx = x + xy[i][0];
13406 int yy = y + xy[i][1];
13407 int center_side = trigger_sides[i][0];
13408 int border_element = border_element_old[i];
13410 if (border_element == -1)
13413 // check for change of border element
13414 CheckElementChangeBySide(xx, yy, border_element, center_element,
13415 CE_TOUCHING_X, center_side);
13417 // (center element cannot be player, so we dont have to check this here)
13420 for (i = 0; i < NUM_DIRECTIONS; i++)
13422 int xx = x + xy[i][0];
13423 int yy = y + xy[i][1];
13424 int border_side = trigger_sides[i][1];
13425 int border_element = border_element_old[i];
13427 if (border_element == -1)
13430 // check for change of center element (but change it only once)
13431 if (!change_center_element)
13432 change_center_element =
13433 CheckElementChangeBySide(x, y, center_element, border_element,
13434 CE_TOUCHING_X, border_side);
13436 if (IS_PLAYER(xx, yy))
13438 /* use player element that is initially defined in the level playfield,
13439 not the player element that corresponds to the runtime player number
13440 (example: a level that contains EL_PLAYER_3 as the only player would
13441 incorrectly give EL_PLAYER_1 for "player->element_nr") */
13442 int player_element = PLAYERINFO(xx, yy)->initial_element;
13444 CheckElementChangeBySide(x, y, center_element, player_element,
13445 CE_TOUCHING_X, border_side);
13450 void TestIfElementHitsCustomElement(int x, int y, int direction)
13452 int dx = (direction == MV_LEFT ? -1 : direction == MV_RIGHT ? +1 : 0);
13453 int dy = (direction == MV_UP ? -1 : direction == MV_DOWN ? +1 : 0);
13454 int hitx = x + dx, hity = y + dy;
13455 int hitting_element = Tile[x][y];
13456 int touched_element;
13458 if (IN_LEV_FIELD(hitx, hity) && IS_FREE(hitx, hity))
13461 touched_element = (IN_LEV_FIELD(hitx, hity) ?
13462 MovingOrBlocked2Element(hitx, hity) : EL_STEELWALL);
13464 if (IN_LEV_FIELD(hitx, hity))
13466 int opposite_direction = MV_DIR_OPPOSITE(direction);
13467 int hitting_side = direction;
13468 int touched_side = opposite_direction;
13469 boolean object_hit = (!IS_MOVING(hitx, hity) ||
13470 MovDir[hitx][hity] != direction ||
13471 ABS(MovPos[hitx][hity]) <= TILEY / 2);
13477 CheckElementChangeBySide(x, y, hitting_element, touched_element,
13478 CE_HITTING_X, touched_side);
13480 CheckElementChangeBySide(hitx, hity, touched_element, hitting_element,
13481 CE_HIT_BY_X, hitting_side);
13483 CheckElementChangeBySide(hitx, hity, touched_element, hitting_element,
13484 CE_HIT_BY_SOMETHING, opposite_direction);
13486 if (IS_PLAYER(hitx, hity))
13488 /* use player element that is initially defined in the level playfield,
13489 not the player element that corresponds to the runtime player number
13490 (example: a level that contains EL_PLAYER_3 as the only player would
13491 incorrectly give EL_PLAYER_1 for "player->element_nr") */
13492 int player_element = PLAYERINFO(hitx, hity)->initial_element;
13494 CheckElementChangeBySide(x, y, hitting_element, player_element,
13495 CE_HITTING_X, touched_side);
13500 // "hitting something" is also true when hitting the playfield border
13501 CheckElementChangeBySide(x, y, hitting_element, touched_element,
13502 CE_HITTING_SOMETHING, direction);
13505 void TestIfGoodThingHitsBadThing(int good_x, int good_y, int good_move_dir)
13507 int i, kill_x = -1, kill_y = -1;
13509 int bad_element = -1;
13510 static int test_xy[4][2] =
13517 static int test_dir[4] =
13525 for (i = 0; i < NUM_DIRECTIONS; i++)
13527 int test_x, test_y, test_move_dir, test_element;
13529 test_x = good_x + test_xy[i][0];
13530 test_y = good_y + test_xy[i][1];
13532 if (!IN_LEV_FIELD(test_x, test_y))
13536 (IS_MOVING(test_x, test_y) ? MovDir[test_x][test_y] : MV_NONE);
13538 test_element = MovingOrBlocked2ElementIfNotLeaving(test_x, test_y);
13540 /* 1st case: good thing is moving towards DONT_RUN_INTO style bad thing;
13541 2nd case: DONT_TOUCH style bad thing does not move away from good thing
13543 if ((DONT_RUN_INTO(test_element) && good_move_dir == test_dir[i]) ||
13544 (DONT_TOUCH(test_element) && test_move_dir != test_dir[i]))
13548 bad_element = test_element;
13554 if (kill_x != -1 || kill_y != -1)
13556 if (IS_PLAYER(good_x, good_y))
13558 struct PlayerInfo *player = PLAYERINFO(good_x, good_y);
13560 if (player->shield_deadly_time_left > 0 &&
13561 !IS_INDESTRUCTIBLE(bad_element))
13562 Bang(kill_x, kill_y);
13563 else if (!PLAYER_ENEMY_PROTECTED(good_x, good_y))
13564 KillPlayer(player);
13567 Bang(good_x, good_y);
13571 void TestIfBadThingHitsGoodThing(int bad_x, int bad_y, int bad_move_dir)
13573 int i, kill_x = -1, kill_y = -1;
13574 int bad_element = Tile[bad_x][bad_y];
13575 static int test_xy[4][2] =
13582 static int touch_dir[4] =
13584 MV_LEFT | MV_RIGHT,
13589 static int test_dir[4] =
13597 if (bad_element == EL_EXPLOSION) // skip just exploding bad things
13600 for (i = 0; i < NUM_DIRECTIONS; i++)
13602 int test_x, test_y, test_move_dir, test_element;
13604 test_x = bad_x + test_xy[i][0];
13605 test_y = bad_y + test_xy[i][1];
13607 if (!IN_LEV_FIELD(test_x, test_y))
13611 (IS_MOVING(test_x, test_y) ? MovDir[test_x][test_y] : MV_NONE);
13613 test_element = Tile[test_x][test_y];
13615 /* 1st case: good thing is moving towards DONT_RUN_INTO style bad thing;
13616 2nd case: DONT_TOUCH style bad thing does not move away from good thing
13618 if ((DONT_RUN_INTO(bad_element) && bad_move_dir == test_dir[i]) ||
13619 (DONT_TOUCH(bad_element) && test_move_dir != test_dir[i]))
13621 // good thing is player or penguin that does not move away
13622 if (IS_PLAYER(test_x, test_y))
13624 struct PlayerInfo *player = PLAYERINFO(test_x, test_y);
13626 if (bad_element == EL_ROBOT && player->is_moving)
13627 continue; // robot does not kill player if he is moving
13629 if (game.engine_version >= VERSION_IDENT(3,0,7,0))
13631 if (player->MovPos != 0 && !(player->MovDir & touch_dir[i]))
13632 continue; // center and border element do not touch
13640 else if (test_element == EL_PENGUIN)
13650 if (kill_x != -1 || kill_y != -1)
13652 if (IS_PLAYER(kill_x, kill_y))
13654 struct PlayerInfo *player = PLAYERINFO(kill_x, kill_y);
13656 if (player->shield_deadly_time_left > 0 &&
13657 !IS_INDESTRUCTIBLE(bad_element))
13658 Bang(bad_x, bad_y);
13659 else if (!PLAYER_ENEMY_PROTECTED(kill_x, kill_y))
13660 KillPlayer(player);
13663 Bang(kill_x, kill_y);
13667 void TestIfGoodThingGetsHitByBadThing(int bad_x, int bad_y, int bad_move_dir)
13669 int bad_element = Tile[bad_x][bad_y];
13670 int dx = (bad_move_dir == MV_LEFT ? -1 : bad_move_dir == MV_RIGHT ? +1 : 0);
13671 int dy = (bad_move_dir == MV_UP ? -1 : bad_move_dir == MV_DOWN ? +1 : 0);
13672 int test_x = bad_x + dx, test_y = bad_y + dy;
13673 int test_move_dir, test_element;
13674 int kill_x = -1, kill_y = -1;
13676 if (!IN_LEV_FIELD(test_x, test_y))
13680 (IS_MOVING(test_x, test_y) ? MovDir[test_x][test_y] : MV_NONE);
13682 test_element = Tile[test_x][test_y];
13684 if (test_move_dir != bad_move_dir)
13686 // good thing can be player or penguin that does not move away
13687 if (IS_PLAYER(test_x, test_y))
13689 struct PlayerInfo *player = PLAYERINFO(test_x, test_y);
13691 /* (note: in comparison to DONT_RUN_TO and DONT_TOUCH, also handle the
13692 player as being hit when he is moving towards the bad thing, because
13693 the "get hit by" condition would be lost after the player stops) */
13694 if (player->MovPos != 0 && player->MovDir == bad_move_dir)
13695 return; // player moves away from bad thing
13700 else if (test_element == EL_PENGUIN)
13707 if (kill_x != -1 || kill_y != -1)
13709 if (IS_PLAYER(kill_x, kill_y))
13711 struct PlayerInfo *player = PLAYERINFO(kill_x, kill_y);
13713 if (player->shield_deadly_time_left > 0 &&
13714 !IS_INDESTRUCTIBLE(bad_element))
13715 Bang(bad_x, bad_y);
13716 else if (!PLAYER_ENEMY_PROTECTED(kill_x, kill_y))
13717 KillPlayer(player);
13720 Bang(kill_x, kill_y);
13724 void TestIfPlayerTouchesBadThing(int x, int y)
13726 TestIfGoodThingHitsBadThing(x, y, MV_NONE);
13729 void TestIfPlayerRunsIntoBadThing(int x, int y, int move_dir)
13731 TestIfGoodThingHitsBadThing(x, y, move_dir);
13734 void TestIfBadThingTouchesPlayer(int x, int y)
13736 TestIfBadThingHitsGoodThing(x, y, MV_NONE);
13739 void TestIfBadThingRunsIntoPlayer(int x, int y, int move_dir)
13741 TestIfBadThingHitsGoodThing(x, y, move_dir);
13744 void TestIfFriendTouchesBadThing(int x, int y)
13746 TestIfGoodThingHitsBadThing(x, y, MV_NONE);
13749 void TestIfBadThingTouchesFriend(int x, int y)
13751 TestIfBadThingHitsGoodThing(x, y, MV_NONE);
13754 void TestIfBadThingTouchesOtherBadThing(int bad_x, int bad_y)
13756 int i, kill_x = bad_x, kill_y = bad_y;
13757 static int xy[4][2] =
13765 for (i = 0; i < NUM_DIRECTIONS; i++)
13769 x = bad_x + xy[i][0];
13770 y = bad_y + xy[i][1];
13771 if (!IN_LEV_FIELD(x, y))
13774 element = Tile[x][y];
13775 if (IS_AMOEBOID(element) || element == EL_GAME_OF_LIFE ||
13776 element == EL_AMOEBA_GROWING || element == EL_AMOEBA_DROP)
13784 if (kill_x != bad_x || kill_y != bad_y)
13785 Bang(bad_x, bad_y);
13788 void KillPlayer(struct PlayerInfo *player)
13790 int jx = player->jx, jy = player->jy;
13792 if (!player->active)
13796 Debug("game:playing:KillPlayer",
13797 "0: killed == %d, active == %d, reanimated == %d",
13798 player->killed, player->active, player->reanimated);
13801 /* the following code was introduced to prevent an infinite loop when calling
13803 -> CheckTriggeredElementChangeExt()
13804 -> ExecuteCustomElementAction()
13806 -> (infinitely repeating the above sequence of function calls)
13807 which occurs when killing the player while having a CE with the setting
13808 "kill player X when explosion of <player X>"; the solution using a new
13809 field "player->killed" was chosen for backwards compatibility, although
13810 clever use of the fields "player->active" etc. would probably also work */
13812 if (player->killed)
13816 player->killed = TRUE;
13818 // remove accessible field at the player's position
13819 Tile[jx][jy] = EL_EMPTY;
13821 // deactivate shield (else Bang()/Explode() would not work right)
13822 player->shield_normal_time_left = 0;
13823 player->shield_deadly_time_left = 0;
13826 Debug("game:playing:KillPlayer",
13827 "1: killed == %d, active == %d, reanimated == %d",
13828 player->killed, player->active, player->reanimated);
13834 Debug("game:playing:KillPlayer",
13835 "2: killed == %d, active == %d, reanimated == %d",
13836 player->killed, player->active, player->reanimated);
13839 if (player->reanimated) // killed player may have been reanimated
13840 player->killed = player->reanimated = FALSE;
13842 BuryPlayer(player);
13845 static void KillPlayerUnlessEnemyProtected(int x, int y)
13847 if (!PLAYER_ENEMY_PROTECTED(x, y))
13848 KillPlayer(PLAYERINFO(x, y));
13851 static void KillPlayerUnlessExplosionProtected(int x, int y)
13853 if (!PLAYER_EXPLOSION_PROTECTED(x, y))
13854 KillPlayer(PLAYERINFO(x, y));
13857 void BuryPlayer(struct PlayerInfo *player)
13859 int jx = player->jx, jy = player->jy;
13861 if (!player->active)
13864 PlayLevelSoundElementAction(jx, jy, player->artwork_element, ACTION_DYING);
13865 PlayLevelSound(jx, jy, SND_GAME_LOSING);
13867 RemovePlayer(player);
13869 player->buried = TRUE;
13871 if (game.all_players_gone)
13872 game.GameOver = TRUE;
13875 void RemovePlayer(struct PlayerInfo *player)
13877 int jx = player->jx, jy = player->jy;
13878 int i, found = FALSE;
13880 player->present = FALSE;
13881 player->active = FALSE;
13883 // required for some CE actions (even if the player is not active anymore)
13884 player->MovPos = 0;
13886 if (!ExplodeField[jx][jy])
13887 StorePlayer[jx][jy] = 0;
13889 if (player->is_moving)
13890 TEST_DrawLevelField(player->last_jx, player->last_jy);
13892 for (i = 0; i < MAX_PLAYERS; i++)
13893 if (stored_player[i].active)
13898 game.all_players_gone = TRUE;
13899 game.GameOver = TRUE;
13902 game.exit_x = game.robot_wheel_x = jx;
13903 game.exit_y = game.robot_wheel_y = jy;
13906 void ExitPlayer(struct PlayerInfo *player)
13908 DrawPlayer(player); // needed here only to cleanup last field
13909 RemovePlayer(player);
13911 if (game.players_still_needed > 0)
13912 game.players_still_needed--;
13915 static void SetFieldForSnapping(int x, int y, int element, int direction,
13916 int player_index_bit)
13918 struct ElementInfo *ei = &element_info[element];
13919 int direction_bit = MV_DIR_TO_BIT(direction);
13920 int graphic_snapping = ei->direction_graphic[ACTION_SNAPPING][direction_bit];
13921 int action = (graphic_snapping != IMG_EMPTY_SPACE ? ACTION_SNAPPING :
13922 IS_DIGGABLE(element) ? ACTION_DIGGING : ACTION_COLLECTING);
13924 Tile[x][y] = EL_ELEMENT_SNAPPING;
13925 MovDelay[x][y] = MOVE_DELAY_NORMAL_SPEED + 1 - 1;
13926 MovDir[x][y] = direction;
13927 Store[x][y] = element;
13928 Store2[x][y] = player_index_bit;
13930 ResetGfxAnimation(x, y);
13932 GfxElement[x][y] = element;
13933 GfxAction[x][y] = action;
13934 GfxDir[x][y] = direction;
13935 GfxFrame[x][y] = -1;
13938 static void TestFieldAfterSnapping(int x, int y, int element, int direction,
13939 int player_index_bit)
13941 TestIfElementTouchesCustomElement(x, y); // for empty space
13943 if (level.finish_dig_collect)
13945 int dig_side = MV_DIR_OPPOSITE(direction);
13947 CheckTriggeredElementChangeByPlayer(x, y, element, CE_PLAYER_SNAPS_X,
13948 player_index_bit, dig_side);
13953 =============================================================================
13954 checkDiagonalPushing()
13955 -----------------------------------------------------------------------------
13956 check if diagonal input device direction results in pushing of object
13957 (by checking if the alternative direction is walkable, diggable, ...)
13958 =============================================================================
13961 static boolean checkDiagonalPushing(struct PlayerInfo *player,
13962 int x, int y, int real_dx, int real_dy)
13964 int jx, jy, dx, dy, xx, yy;
13966 if (real_dx == 0 || real_dy == 0) // no diagonal direction => push
13969 // diagonal direction: check alternative direction
13974 xx = jx + (dx == 0 ? real_dx : 0);
13975 yy = jy + (dy == 0 ? real_dy : 0);
13977 return (!IN_LEV_FIELD(xx, yy) || IS_SOLID_FOR_PUSHING(Tile[xx][yy]));
13981 =============================================================================
13983 -----------------------------------------------------------------------------
13984 x, y: field next to player (non-diagonal) to try to dig to
13985 real_dx, real_dy: direction as read from input device (can be diagonal)
13986 =============================================================================
13989 static int DigField(struct PlayerInfo *player,
13990 int oldx, int oldy, int x, int y,
13991 int real_dx, int real_dy, int mode)
13993 boolean is_player = (IS_PLAYER(oldx, oldy) || mode != DF_DIG);
13994 boolean player_was_pushing = player->is_pushing;
13995 boolean player_can_move = (!player->cannot_move && mode != DF_SNAP);
13996 boolean player_can_move_or_snap = (!player->cannot_move || mode == DF_SNAP);
13997 int jx = oldx, jy = oldy;
13998 int dx = x - jx, dy = y - jy;
13999 int nextx = x + dx, nexty = y + dy;
14000 int move_direction = (dx == -1 ? MV_LEFT :
14001 dx == +1 ? MV_RIGHT :
14003 dy == +1 ? MV_DOWN : MV_NONE);
14004 int opposite_direction = MV_DIR_OPPOSITE(move_direction);
14005 int dig_side = MV_DIR_OPPOSITE(move_direction);
14006 int old_element = Tile[jx][jy];
14007 int element = MovingOrBlocked2ElementIfNotLeaving(x, y);
14010 if (is_player) // function can also be called by EL_PENGUIN
14012 if (player->MovPos == 0)
14014 player->is_digging = FALSE;
14015 player->is_collecting = FALSE;
14018 if (player->MovPos == 0) // last pushing move finished
14019 player->is_pushing = FALSE;
14021 if (mode == DF_NO_PUSH) // player just stopped pushing
14023 player->is_switching = FALSE;
14024 player->push_delay = -1;
14026 return MP_NO_ACTION;
14030 if (IS_TUBE(Back[jx][jy]) && game.engine_version >= VERSION_IDENT(2,2,0,0))
14031 old_element = Back[jx][jy];
14033 // in case of element dropped at player position, check background
14034 else if (Back[jx][jy] != EL_EMPTY &&
14035 game.engine_version >= VERSION_IDENT(2,2,0,0))
14036 old_element = Back[jx][jy];
14038 if (IS_WALKABLE(old_element) && !ACCESS_FROM(old_element, move_direction))
14039 return MP_NO_ACTION; // field has no opening in this direction
14041 if (IS_PASSABLE(old_element) && !ACCESS_FROM(old_element,opposite_direction))
14042 return MP_NO_ACTION; // field has no opening in this direction
14044 if (player_can_move && element == EL_ACID && move_direction == MV_DOWN)
14048 Tile[jx][jy] = player->artwork_element;
14049 InitMovingField(jx, jy, MV_DOWN);
14050 Store[jx][jy] = EL_ACID;
14051 ContinueMoving(jx, jy);
14052 BuryPlayer(player);
14054 return MP_DONT_RUN_INTO;
14057 if (player_can_move && DONT_RUN_INTO(element))
14059 TestIfPlayerRunsIntoBadThing(jx, jy, player->MovDir);
14061 return MP_DONT_RUN_INTO;
14064 if (IS_MOVING(x, y) || IS_PLAYER(x, y))
14065 return MP_NO_ACTION;
14067 collect_count = element_info[element].collect_count_initial;
14069 if (!is_player && !IS_COLLECTIBLE(element)) // penguin cannot collect it
14070 return MP_NO_ACTION;
14072 if (game.engine_version < VERSION_IDENT(2,2,0,0))
14073 player_can_move = player_can_move_or_snap;
14075 if (mode == DF_SNAP && !IS_SNAPPABLE(element) &&
14076 game.engine_version >= VERSION_IDENT(2,2,0,0))
14078 CheckElementChangeByPlayer(x, y, element, CE_SNAPPED_BY_PLAYER,
14079 player->index_bit, dig_side);
14080 CheckTriggeredElementChangeByPlayer(x, y, element, CE_PLAYER_SNAPS_X,
14081 player->index_bit, dig_side);
14083 if (element == EL_DC_LANDMINE)
14086 if (Tile[x][y] != element) // field changed by snapping
14089 return MP_NO_ACTION;
14092 if (player->gravity && is_player && !player->is_auto_moving &&
14093 canFallDown(player) && move_direction != MV_DOWN &&
14094 !canMoveToValidFieldWithGravity(jx, jy, move_direction))
14095 return MP_NO_ACTION; // player cannot walk here due to gravity
14097 if (player_can_move &&
14098 IS_WALKABLE(element) && ACCESS_FROM(element, opposite_direction))
14100 int sound_element = SND_ELEMENT(element);
14101 int sound_action = ACTION_WALKING;
14103 if (IS_RND_GATE(element))
14105 if (!player->key[RND_GATE_NR(element)])
14106 return MP_NO_ACTION;
14108 else if (IS_RND_GATE_GRAY(element))
14110 if (!player->key[RND_GATE_GRAY_NR(element)])
14111 return MP_NO_ACTION;
14113 else if (IS_RND_GATE_GRAY_ACTIVE(element))
14115 if (!player->key[RND_GATE_GRAY_ACTIVE_NR(element)])
14116 return MP_NO_ACTION;
14118 else if (element == EL_EXIT_OPEN ||
14119 element == EL_EM_EXIT_OPEN ||
14120 element == EL_EM_EXIT_OPENING ||
14121 element == EL_STEEL_EXIT_OPEN ||
14122 element == EL_EM_STEEL_EXIT_OPEN ||
14123 element == EL_EM_STEEL_EXIT_OPENING ||
14124 element == EL_SP_EXIT_OPEN ||
14125 element == EL_SP_EXIT_OPENING)
14127 sound_action = ACTION_PASSING; // player is passing exit
14129 else if (element == EL_EMPTY)
14131 sound_action = ACTION_MOVING; // nothing to walk on
14134 // play sound from background or player, whatever is available
14135 if (element_info[sound_element].sound[sound_action] != SND_UNDEFINED)
14136 PlayLevelSoundElementAction(x, y, sound_element, sound_action);
14138 PlayLevelSoundElementAction(x, y, player->artwork_element, sound_action);
14140 else if (player_can_move &&
14141 IS_PASSABLE(element) && canPassField(x, y, move_direction))
14143 if (!ACCESS_FROM(element, opposite_direction))
14144 return MP_NO_ACTION; // field not accessible from this direction
14146 if (CAN_MOVE(element)) // only fixed elements can be passed!
14147 return MP_NO_ACTION;
14149 if (IS_EM_GATE(element))
14151 if (!player->key[EM_GATE_NR(element)])
14152 return MP_NO_ACTION;
14154 else if (IS_EM_GATE_GRAY(element))
14156 if (!player->key[EM_GATE_GRAY_NR(element)])
14157 return MP_NO_ACTION;
14159 else if (IS_EM_GATE_GRAY_ACTIVE(element))
14161 if (!player->key[EM_GATE_GRAY_ACTIVE_NR(element)])
14162 return MP_NO_ACTION;
14164 else if (IS_EMC_GATE(element))
14166 if (!player->key[EMC_GATE_NR(element)])
14167 return MP_NO_ACTION;
14169 else if (IS_EMC_GATE_GRAY(element))
14171 if (!player->key[EMC_GATE_GRAY_NR(element)])
14172 return MP_NO_ACTION;
14174 else if (IS_EMC_GATE_GRAY_ACTIVE(element))
14176 if (!player->key[EMC_GATE_GRAY_ACTIVE_NR(element)])
14177 return MP_NO_ACTION;
14179 else if (element == EL_DC_GATE_WHITE ||
14180 element == EL_DC_GATE_WHITE_GRAY ||
14181 element == EL_DC_GATE_WHITE_GRAY_ACTIVE)
14183 if (player->num_white_keys == 0)
14184 return MP_NO_ACTION;
14186 player->num_white_keys--;
14188 else if (IS_SP_PORT(element))
14190 if (element == EL_SP_GRAVITY_PORT_LEFT ||
14191 element == EL_SP_GRAVITY_PORT_RIGHT ||
14192 element == EL_SP_GRAVITY_PORT_UP ||
14193 element == EL_SP_GRAVITY_PORT_DOWN)
14194 player->gravity = !player->gravity;
14195 else if (element == EL_SP_GRAVITY_ON_PORT_LEFT ||
14196 element == EL_SP_GRAVITY_ON_PORT_RIGHT ||
14197 element == EL_SP_GRAVITY_ON_PORT_UP ||
14198 element == EL_SP_GRAVITY_ON_PORT_DOWN)
14199 player->gravity = TRUE;
14200 else if (element == EL_SP_GRAVITY_OFF_PORT_LEFT ||
14201 element == EL_SP_GRAVITY_OFF_PORT_RIGHT ||
14202 element == EL_SP_GRAVITY_OFF_PORT_UP ||
14203 element == EL_SP_GRAVITY_OFF_PORT_DOWN)
14204 player->gravity = FALSE;
14207 // automatically move to the next field with double speed
14208 player->programmed_action = move_direction;
14210 if (player->move_delay_reset_counter == 0)
14212 player->move_delay_reset_counter = 2; // two double speed steps
14214 DOUBLE_PLAYER_SPEED(player);
14217 PlayLevelSoundAction(x, y, ACTION_PASSING);
14219 else if (player_can_move_or_snap && IS_DIGGABLE(element))
14223 if (mode != DF_SNAP)
14225 GfxElement[x][y] = GFX_ELEMENT(element);
14226 player->is_digging = TRUE;
14229 PlayLevelSoundElementAction(x, y, element, ACTION_DIGGING);
14231 // use old behaviour for old levels (digging)
14232 if (!level.finish_dig_collect)
14234 CheckTriggeredElementChangeByPlayer(x, y, element, CE_PLAYER_DIGS_X,
14235 player->index_bit, dig_side);
14237 // if digging triggered player relocation, finish digging tile
14238 if (mode == DF_DIG && (player->jx != jx || player->jy != jy))
14239 SetFieldForSnapping(x, y, element, move_direction, player->index_bit);
14242 if (mode == DF_SNAP)
14244 if (level.block_snap_field)
14245 SetFieldForSnapping(x, y, element, move_direction, player->index_bit);
14247 TestFieldAfterSnapping(x, y, element, move_direction, player->index_bit);
14249 // use old behaviour for old levels (snapping)
14250 if (!level.finish_dig_collect)
14251 CheckTriggeredElementChangeByPlayer(x, y, element, CE_PLAYER_SNAPS_X,
14252 player->index_bit, dig_side);
14255 else if (player_can_move_or_snap && IS_COLLECTIBLE(element))
14259 if (is_player && mode != DF_SNAP)
14261 GfxElement[x][y] = element;
14262 player->is_collecting = TRUE;
14265 if (element == EL_SPEED_PILL)
14267 player->move_delay_value = MOVE_DELAY_HIGH_SPEED;
14269 else if (element == EL_EXTRA_TIME && level.time > 0)
14271 TimeLeft += level.extra_time;
14273 game_panel_controls[GAME_PANEL_TIME].value = TimeLeft;
14275 DisplayGameControlValues();
14277 else if (element == EL_SHIELD_NORMAL || element == EL_SHIELD_DEADLY)
14279 player->shield_normal_time_left += level.shield_normal_time;
14280 if (element == EL_SHIELD_DEADLY)
14281 player->shield_deadly_time_left += level.shield_deadly_time;
14283 else if (element == EL_DYNAMITE ||
14284 element == EL_EM_DYNAMITE ||
14285 element == EL_SP_DISK_RED)
14287 if (player->inventory_size < MAX_INVENTORY_SIZE)
14288 player->inventory_element[player->inventory_size++] = element;
14290 DrawGameDoorValues();
14292 else if (element == EL_DYNABOMB_INCREASE_NUMBER)
14294 player->dynabomb_count++;
14295 player->dynabombs_left++;
14297 else if (element == EL_DYNABOMB_INCREASE_SIZE)
14299 player->dynabomb_size++;
14301 else if (element == EL_DYNABOMB_INCREASE_POWER)
14303 player->dynabomb_xl = TRUE;
14305 else if (IS_KEY(element))
14307 player->key[KEY_NR(element)] = TRUE;
14309 DrawGameDoorValues();
14311 else if (element == EL_DC_KEY_WHITE)
14313 player->num_white_keys++;
14315 // display white keys?
14316 // DrawGameDoorValues();
14318 else if (IS_ENVELOPE(element))
14320 player->show_envelope = element;
14322 else if (element == EL_EMC_LENSES)
14324 game.lenses_time_left = level.lenses_time * FRAMES_PER_SECOND;
14326 RedrawAllInvisibleElementsForLenses();
14328 else if (element == EL_EMC_MAGNIFIER)
14330 game.magnify_time_left = level.magnify_time * FRAMES_PER_SECOND;
14332 RedrawAllInvisibleElementsForMagnifier();
14334 else if (IS_DROPPABLE(element) ||
14335 IS_THROWABLE(element)) // can be collected and dropped
14339 if (collect_count == 0)
14340 player->inventory_infinite_element = element;
14342 for (i = 0; i < collect_count; i++)
14343 if (player->inventory_size < MAX_INVENTORY_SIZE)
14344 player->inventory_element[player->inventory_size++] = element;
14346 DrawGameDoorValues();
14348 else if (collect_count > 0)
14350 game.gems_still_needed -= collect_count;
14351 if (game.gems_still_needed < 0)
14352 game.gems_still_needed = 0;
14354 game.snapshot.collected_item = TRUE;
14356 game_panel_controls[GAME_PANEL_GEMS].value = game.gems_still_needed;
14358 DisplayGameControlValues();
14361 RaiseScoreElement(element);
14362 PlayLevelSoundElementAction(x, y, element, ACTION_COLLECTING);
14364 // use old behaviour for old levels (collecting)
14365 if (!level.finish_dig_collect && is_player)
14367 CheckTriggeredElementChangeByPlayer(x, y, element, CE_PLAYER_COLLECTS_X,
14368 player->index_bit, dig_side);
14370 // if collecting triggered player relocation, finish collecting tile
14371 if (mode == DF_DIG && (player->jx != jx || player->jy != jy))
14372 SetFieldForSnapping(x, y, element, move_direction, player->index_bit);
14375 if (mode == DF_SNAP)
14377 if (level.block_snap_field)
14378 SetFieldForSnapping(x, y, element, move_direction, player->index_bit);
14380 TestFieldAfterSnapping(x, y, element, move_direction, player->index_bit);
14382 // use old behaviour for old levels (snapping)
14383 if (!level.finish_dig_collect)
14384 CheckTriggeredElementChangeByPlayer(x, y, element, CE_PLAYER_SNAPS_X,
14385 player->index_bit, dig_side);
14388 else if (player_can_move_or_snap && IS_PUSHABLE(element))
14390 if (mode == DF_SNAP && element != EL_BD_ROCK)
14391 return MP_NO_ACTION;
14393 if (CAN_FALL(element) && dy)
14394 return MP_NO_ACTION;
14396 if (CAN_FALL(element) && IN_LEV_FIELD(x, y + 1) && IS_FREE(x, y + 1) &&
14397 !(element == EL_SPRING && level.use_spring_bug))
14398 return MP_NO_ACTION;
14400 if (CAN_MOVE(element) && GET_MAX_MOVE_DELAY(element) == 0 &&
14401 ((move_direction & MV_VERTICAL &&
14402 ((element_info[element].move_pattern & MV_LEFT &&
14403 IN_LEV_FIELD(x - 1, y) && IS_FREE(x - 1, y)) ||
14404 (element_info[element].move_pattern & MV_RIGHT &&
14405 IN_LEV_FIELD(x + 1, y) && IS_FREE(x + 1, y)))) ||
14406 (move_direction & MV_HORIZONTAL &&
14407 ((element_info[element].move_pattern & MV_UP &&
14408 IN_LEV_FIELD(x, y - 1) && IS_FREE(x, y - 1)) ||
14409 (element_info[element].move_pattern & MV_DOWN &&
14410 IN_LEV_FIELD(x, y + 1) && IS_FREE(x, y + 1))))))
14411 return MP_NO_ACTION;
14413 // do not push elements already moving away faster than player
14414 if (CAN_MOVE(element) && MovDir[x][y] == move_direction &&
14415 ABS(getElementMoveStepsize(x, y)) > MOVE_STEPSIZE_NORMAL)
14416 return MP_NO_ACTION;
14418 if (game.engine_version >= VERSION_IDENT(3,1,0,0))
14420 if (player->push_delay_value == -1 || !player_was_pushing)
14421 player->push_delay_value = GET_NEW_PUSH_DELAY(element);
14423 else if (game.engine_version >= VERSION_IDENT(3,0,7,1))
14425 if (player->push_delay_value == -1)
14426 player->push_delay_value = GET_NEW_PUSH_DELAY(element);
14428 else if (game.engine_version >= VERSION_IDENT(2,2,0,7))
14430 if (!player->is_pushing)
14431 player->push_delay_value = GET_NEW_PUSH_DELAY(element);
14434 player->is_pushing = TRUE;
14435 player->is_active = TRUE;
14437 if (!(IN_LEV_FIELD(nextx, nexty) &&
14438 (IS_FREE(nextx, nexty) ||
14439 (IS_SB_ELEMENT(element) &&
14440 Tile[nextx][nexty] == EL_SOKOBAN_FIELD_EMPTY) ||
14441 (IS_CUSTOM_ELEMENT(element) &&
14442 CUSTOM_ELEMENT_CAN_ENTER_FIELD(element, nextx, nexty)))))
14443 return MP_NO_ACTION;
14445 if (!checkDiagonalPushing(player, x, y, real_dx, real_dy))
14446 return MP_NO_ACTION;
14448 if (player->push_delay == -1) // new pushing; restart delay
14449 player->push_delay = 0;
14451 if (player->push_delay < player->push_delay_value &&
14452 !(tape.playing && tape.file_version < FILE_VERSION_2_0) &&
14453 element != EL_SPRING && element != EL_BALLOON)
14455 // make sure that there is no move delay before next try to push
14456 if (game.engine_version >= VERSION_IDENT(3,0,7,1))
14457 player->move_delay = 0;
14459 return MP_NO_ACTION;
14462 if (IS_CUSTOM_ELEMENT(element) &&
14463 CUSTOM_ELEMENT_CAN_ENTER_FIELD(element, nextx, nexty))
14465 if (!DigFieldByCE(nextx, nexty, element))
14466 return MP_NO_ACTION;
14469 if (IS_SB_ELEMENT(element))
14471 boolean sokoban_task_solved = FALSE;
14473 if (element == EL_SOKOBAN_FIELD_FULL)
14475 Back[x][y] = EL_SOKOBAN_FIELD_EMPTY;
14477 IncrementSokobanFieldsNeeded();
14478 IncrementSokobanObjectsNeeded();
14481 if (Tile[nextx][nexty] == EL_SOKOBAN_FIELD_EMPTY)
14483 Back[nextx][nexty] = EL_SOKOBAN_FIELD_EMPTY;
14485 DecrementSokobanFieldsNeeded();
14486 DecrementSokobanObjectsNeeded();
14488 // sokoban object was pushed from empty field to sokoban field
14489 if (Back[x][y] == EL_EMPTY)
14490 sokoban_task_solved = TRUE;
14493 Tile[x][y] = EL_SOKOBAN_OBJECT;
14495 if (Back[x][y] == Back[nextx][nexty])
14496 PlayLevelSoundAction(x, y, ACTION_PUSHING);
14497 else if (Back[x][y] != 0)
14498 PlayLevelSoundElementAction(x, y, EL_SOKOBAN_FIELD_FULL,
14501 PlayLevelSoundElementAction(nextx, nexty, EL_SOKOBAN_FIELD_EMPTY,
14504 if (sokoban_task_solved &&
14505 game.sokoban_fields_still_needed == 0 &&
14506 game.sokoban_objects_still_needed == 0 &&
14507 (game.emulation == EMU_SOKOBAN || level.auto_exit_sokoban))
14509 game.players_still_needed = 0;
14513 PlayLevelSound(x, y, SND_GAME_SOKOBAN_SOLVING);
14517 PlayLevelSoundElementAction(x, y, element, ACTION_PUSHING);
14519 InitMovingField(x, y, move_direction);
14520 GfxAction[x][y] = ACTION_PUSHING;
14522 if (mode == DF_SNAP)
14523 ContinueMoving(x, y);
14525 MovPos[x][y] = (dx != 0 ? dx : dy);
14527 Pushed[x][y] = TRUE;
14528 Pushed[nextx][nexty] = TRUE;
14530 if (game.engine_version < VERSION_IDENT(2,2,0,7))
14531 player->push_delay_value = GET_NEW_PUSH_DELAY(element);
14533 player->push_delay_value = -1; // get new value later
14535 // check for element change _after_ element has been pushed
14536 if (game.use_change_when_pushing_bug)
14538 CheckElementChangeByPlayer(x, y, element, CE_PUSHED_BY_PLAYER,
14539 player->index_bit, dig_side);
14540 CheckTriggeredElementChangeByPlayer(x, y, element, CE_PLAYER_PUSHES_X,
14541 player->index_bit, dig_side);
14544 else if (IS_SWITCHABLE(element))
14546 if (PLAYER_SWITCHING(player, x, y))
14548 CheckTriggeredElementChangeByPlayer(x, y, element, CE_PLAYER_PRESSES_X,
14549 player->index_bit, dig_side);
14554 player->is_switching = TRUE;
14555 player->switch_x = x;
14556 player->switch_y = y;
14558 PlayLevelSoundElementAction(x, y, element, ACTION_ACTIVATING);
14560 if (element == EL_ROBOT_WHEEL)
14562 Tile[x][y] = EL_ROBOT_WHEEL_ACTIVE;
14564 game.robot_wheel_x = x;
14565 game.robot_wheel_y = y;
14566 game.robot_wheel_active = TRUE;
14568 TEST_DrawLevelField(x, y);
14570 else if (element == EL_SP_TERMINAL)
14574 SCAN_PLAYFIELD(xx, yy)
14576 if (Tile[xx][yy] == EL_SP_DISK_YELLOW)
14580 else if (Tile[xx][yy] == EL_SP_TERMINAL)
14582 Tile[xx][yy] = EL_SP_TERMINAL_ACTIVE;
14584 ResetGfxAnimation(xx, yy);
14585 TEST_DrawLevelField(xx, yy);
14589 else if (IS_BELT_SWITCH(element))
14591 ToggleBeltSwitch(x, y);
14593 else if (element == EL_SWITCHGATE_SWITCH_UP ||
14594 element == EL_SWITCHGATE_SWITCH_DOWN ||
14595 element == EL_DC_SWITCHGATE_SWITCH_UP ||
14596 element == EL_DC_SWITCHGATE_SWITCH_DOWN)
14598 ToggleSwitchgateSwitch(x, y);
14600 else if (element == EL_LIGHT_SWITCH ||
14601 element == EL_LIGHT_SWITCH_ACTIVE)
14603 ToggleLightSwitch(x, y);
14605 else if (element == EL_TIMEGATE_SWITCH ||
14606 element == EL_DC_TIMEGATE_SWITCH)
14608 ActivateTimegateSwitch(x, y);
14610 else if (element == EL_BALLOON_SWITCH_LEFT ||
14611 element == EL_BALLOON_SWITCH_RIGHT ||
14612 element == EL_BALLOON_SWITCH_UP ||
14613 element == EL_BALLOON_SWITCH_DOWN ||
14614 element == EL_BALLOON_SWITCH_NONE ||
14615 element == EL_BALLOON_SWITCH_ANY)
14617 game.wind_direction = (element == EL_BALLOON_SWITCH_LEFT ? MV_LEFT :
14618 element == EL_BALLOON_SWITCH_RIGHT ? MV_RIGHT :
14619 element == EL_BALLOON_SWITCH_UP ? MV_UP :
14620 element == EL_BALLOON_SWITCH_DOWN ? MV_DOWN :
14621 element == EL_BALLOON_SWITCH_NONE ? MV_NONE :
14624 else if (element == EL_LAMP)
14626 Tile[x][y] = EL_LAMP_ACTIVE;
14627 game.lights_still_needed--;
14629 ResetGfxAnimation(x, y);
14630 TEST_DrawLevelField(x, y);
14632 else if (element == EL_TIME_ORB_FULL)
14634 Tile[x][y] = EL_TIME_ORB_EMPTY;
14636 if (level.time > 0 || level.use_time_orb_bug)
14638 TimeLeft += level.time_orb_time;
14639 game.no_time_limit = FALSE;
14641 game_panel_controls[GAME_PANEL_TIME].value = TimeLeft;
14643 DisplayGameControlValues();
14646 ResetGfxAnimation(x, y);
14647 TEST_DrawLevelField(x, y);
14649 else if (element == EL_EMC_MAGIC_BALL_SWITCH ||
14650 element == EL_EMC_MAGIC_BALL_SWITCH_ACTIVE)
14654 game.ball_active = !game.ball_active;
14656 SCAN_PLAYFIELD(xx, yy)
14658 int e = Tile[xx][yy];
14660 if (game.ball_active)
14662 if (e == EL_EMC_MAGIC_BALL)
14663 CreateField(xx, yy, EL_EMC_MAGIC_BALL_ACTIVE);
14664 else if (e == EL_EMC_MAGIC_BALL_SWITCH)
14665 CreateField(xx, yy, EL_EMC_MAGIC_BALL_SWITCH_ACTIVE);
14669 if (e == EL_EMC_MAGIC_BALL_ACTIVE)
14670 CreateField(xx, yy, EL_EMC_MAGIC_BALL);
14671 else if (e == EL_EMC_MAGIC_BALL_SWITCH_ACTIVE)
14672 CreateField(xx, yy, EL_EMC_MAGIC_BALL_SWITCH);
14677 CheckTriggeredElementChangeByPlayer(x, y, element, CE_SWITCH_OF_X,
14678 player->index_bit, dig_side);
14680 CheckTriggeredElementChangeByPlayer(x, y, element, CE_PLAYER_SWITCHES_X,
14681 player->index_bit, dig_side);
14683 CheckTriggeredElementChangeByPlayer(x, y, element, CE_PLAYER_PRESSES_X,
14684 player->index_bit, dig_side);
14690 if (!PLAYER_SWITCHING(player, x, y))
14692 player->is_switching = TRUE;
14693 player->switch_x = x;
14694 player->switch_y = y;
14696 CheckElementChangeByPlayer(x, y, element, CE_SWITCHED,
14697 player->index_bit, dig_side);
14698 CheckTriggeredElementChangeByPlayer(x, y, element, CE_SWITCH_OF_X,
14699 player->index_bit, dig_side);
14701 CheckElementChangeByPlayer(x, y, element, CE_SWITCHED_BY_PLAYER,
14702 player->index_bit, dig_side);
14703 CheckTriggeredElementChangeByPlayer(x, y, element, CE_PLAYER_SWITCHES_X,
14704 player->index_bit, dig_side);
14707 CheckElementChangeByPlayer(x, y, element, CE_PRESSED_BY_PLAYER,
14708 player->index_bit, dig_side);
14709 CheckTriggeredElementChangeByPlayer(x, y, element, CE_PLAYER_PRESSES_X,
14710 player->index_bit, dig_side);
14712 return MP_NO_ACTION;
14715 player->push_delay = -1;
14717 if (is_player) // function can also be called by EL_PENGUIN
14719 if (Tile[x][y] != element) // really digged/collected something
14721 player->is_collecting = !player->is_digging;
14722 player->is_active = TRUE;
14724 player->last_removed_element = element;
14731 static boolean DigFieldByCE(int x, int y, int digging_element)
14733 int element = Tile[x][y];
14735 if (!IS_FREE(x, y))
14737 int action = (IS_DIGGABLE(element) ? ACTION_DIGGING :
14738 IS_COLLECTIBLE(element) ? ACTION_COLLECTING :
14741 // no element can dig solid indestructible elements
14742 if (IS_INDESTRUCTIBLE(element) &&
14743 !IS_DIGGABLE(element) &&
14744 !IS_COLLECTIBLE(element))
14747 if (AmoebaNr[x][y] &&
14748 (element == EL_AMOEBA_FULL ||
14749 element == EL_BD_AMOEBA ||
14750 element == EL_AMOEBA_GROWING))
14752 AmoebaCnt[AmoebaNr[x][y]]--;
14753 AmoebaCnt2[AmoebaNr[x][y]]--;
14756 if (IS_MOVING(x, y))
14757 RemoveMovingField(x, y);
14761 TEST_DrawLevelField(x, y);
14764 // if digged element was about to explode, prevent the explosion
14765 ExplodeField[x][y] = EX_TYPE_NONE;
14767 PlayLevelSoundAction(x, y, action);
14770 Store[x][y] = EL_EMPTY;
14772 // this makes it possible to leave the removed element again
14773 if (IS_EQUAL_OR_IN_GROUP(element, MOVE_ENTER_EL(digging_element)))
14774 Store[x][y] = element;
14779 static boolean SnapField(struct PlayerInfo *player, int dx, int dy)
14781 int jx = player->jx, jy = player->jy;
14782 int x = jx + dx, y = jy + dy;
14783 int snap_direction = (dx == -1 ? MV_LEFT :
14784 dx == +1 ? MV_RIGHT :
14786 dy == +1 ? MV_DOWN : MV_NONE);
14787 boolean can_continue_snapping = (level.continuous_snapping &&
14788 WasJustFalling[x][y] < CHECK_DELAY_FALLING);
14790 if (player->MovPos != 0 && game.engine_version >= VERSION_IDENT(2,2,0,0))
14793 if (!player->active || !IN_LEV_FIELD(x, y))
14801 if (player->MovPos == 0)
14802 player->is_pushing = FALSE;
14804 player->is_snapping = FALSE;
14806 if (player->MovPos == 0)
14808 player->is_moving = FALSE;
14809 player->is_digging = FALSE;
14810 player->is_collecting = FALSE;
14816 // prevent snapping with already pressed snap key when not allowed
14817 if (player->is_snapping && !can_continue_snapping)
14820 player->MovDir = snap_direction;
14822 if (player->MovPos == 0)
14824 player->is_moving = FALSE;
14825 player->is_digging = FALSE;
14826 player->is_collecting = FALSE;
14829 player->is_dropping = FALSE;
14830 player->is_dropping_pressed = FALSE;
14831 player->drop_pressed_delay = 0;
14833 if (DigField(player, jx, jy, x, y, 0, 0, DF_SNAP) == MP_NO_ACTION)
14836 player->is_snapping = TRUE;
14837 player->is_active = TRUE;
14839 if (player->MovPos == 0)
14841 player->is_moving = FALSE;
14842 player->is_digging = FALSE;
14843 player->is_collecting = FALSE;
14846 if (player->MovPos != 0) // prevent graphic bugs in versions < 2.2.0
14847 TEST_DrawLevelField(player->last_jx, player->last_jy);
14849 TEST_DrawLevelField(x, y);
14854 static boolean DropElement(struct PlayerInfo *player)
14856 int old_element, new_element;
14857 int dropx = player->jx, dropy = player->jy;
14858 int drop_direction = player->MovDir;
14859 int drop_side = drop_direction;
14860 int drop_element = get_next_dropped_element(player);
14862 /* do not drop an element on top of another element; when holding drop key
14863 pressed without moving, dropped element must move away before the next
14864 element can be dropped (this is especially important if the next element
14865 is dynamite, which can be placed on background for historical reasons) */
14866 if (PLAYER_DROPPING(player, dropx, dropy) && Tile[dropx][dropy] != EL_EMPTY)
14869 if (IS_THROWABLE(drop_element))
14871 dropx += GET_DX_FROM_DIR(drop_direction);
14872 dropy += GET_DY_FROM_DIR(drop_direction);
14874 if (!IN_LEV_FIELD(dropx, dropy))
14878 old_element = Tile[dropx][dropy]; // old element at dropping position
14879 new_element = drop_element; // default: no change when dropping
14881 // check if player is active, not moving and ready to drop
14882 if (!player->active || player->MovPos || player->drop_delay > 0)
14885 // check if player has anything that can be dropped
14886 if (new_element == EL_UNDEFINED)
14889 // only set if player has anything that can be dropped
14890 player->is_dropping_pressed = TRUE;
14892 // check if drop key was pressed long enough for EM style dynamite
14893 if (new_element == EL_EM_DYNAMITE && player->drop_pressed_delay < 40)
14896 // check if anything can be dropped at the current position
14897 if (IS_ACTIVE_BOMB(old_element) || old_element == EL_EXPLOSION)
14900 // collected custom elements can only be dropped on empty fields
14901 if (IS_CUSTOM_ELEMENT(new_element) && old_element != EL_EMPTY)
14904 if (old_element != EL_EMPTY)
14905 Back[dropx][dropy] = old_element; // store old element on this field
14907 ResetGfxAnimation(dropx, dropy);
14908 ResetRandomAnimationValue(dropx, dropy);
14910 if (player->inventory_size > 0 ||
14911 player->inventory_infinite_element != EL_UNDEFINED)
14913 if (player->inventory_size > 0)
14915 player->inventory_size--;
14917 DrawGameDoorValues();
14919 if (new_element == EL_DYNAMITE)
14920 new_element = EL_DYNAMITE_ACTIVE;
14921 else if (new_element == EL_EM_DYNAMITE)
14922 new_element = EL_EM_DYNAMITE_ACTIVE;
14923 else if (new_element == EL_SP_DISK_RED)
14924 new_element = EL_SP_DISK_RED_ACTIVE;
14927 Tile[dropx][dropy] = new_element;
14929 if (IN_SCR_FIELD(SCREENX(dropx), SCREENY(dropy)))
14930 DrawGraphicThruMask(SCREENX(dropx), SCREENY(dropy),
14931 el2img(Tile[dropx][dropy]), 0);
14933 PlayLevelSoundAction(dropx, dropy, ACTION_DROPPING);
14935 // needed if previous element just changed to "empty" in the last frame
14936 ChangeCount[dropx][dropy] = 0; // allow at least one more change
14938 CheckElementChangeByPlayer(dropx, dropy, new_element, CE_DROPPED_BY_PLAYER,
14939 player->index_bit, drop_side);
14940 CheckTriggeredElementChangeByPlayer(dropx, dropy, new_element,
14942 player->index_bit, drop_side);
14944 TestIfElementTouchesCustomElement(dropx, dropy);
14946 else // player is dropping a dyna bomb
14948 player->dynabombs_left--;
14950 Tile[dropx][dropy] = new_element;
14952 if (IN_SCR_FIELD(SCREENX(dropx), SCREENY(dropy)))
14953 DrawGraphicThruMask(SCREENX(dropx), SCREENY(dropy),
14954 el2img(Tile[dropx][dropy]), 0);
14956 PlayLevelSoundAction(dropx, dropy, ACTION_DROPPING);
14959 if (Tile[dropx][dropy] == new_element) // uninitialized unless CE change
14960 InitField_WithBug1(dropx, dropy, FALSE);
14962 new_element = Tile[dropx][dropy]; // element might have changed
14964 if (IS_CUSTOM_ELEMENT(new_element) && CAN_MOVE(new_element) &&
14965 element_info[new_element].move_pattern == MV_WHEN_DROPPED)
14967 if (element_info[new_element].move_direction_initial == MV_START_AUTOMATIC)
14968 MovDir[dropx][dropy] = drop_direction;
14970 ChangeCount[dropx][dropy] = 0; // allow at least one more change
14972 // do not cause impact style collision by dropping elements that can fall
14973 CheckCollision[dropx][dropy] = CHECK_DELAY_COLLISION;
14976 player->drop_delay = GET_NEW_DROP_DELAY(drop_element);
14977 player->is_dropping = TRUE;
14979 player->drop_pressed_delay = 0;
14980 player->is_dropping_pressed = FALSE;
14982 player->drop_x = dropx;
14983 player->drop_y = dropy;
14988 // ----------------------------------------------------------------------------
14989 // game sound playing functions
14990 // ----------------------------------------------------------------------------
14992 static int *loop_sound_frame = NULL;
14993 static int *loop_sound_volume = NULL;
14995 void InitPlayLevelSound(void)
14997 int num_sounds = getSoundListSize();
14999 checked_free(loop_sound_frame);
15000 checked_free(loop_sound_volume);
15002 loop_sound_frame = checked_calloc(num_sounds * sizeof(int));
15003 loop_sound_volume = checked_calloc(num_sounds * sizeof(int));
15006 static void PlayLevelSound(int x, int y, int nr)
15008 int sx = SCREENX(x), sy = SCREENY(y);
15009 int volume, stereo_position;
15010 int max_distance = 8;
15011 int type = (IS_LOOP_SOUND(nr) ? SND_CTRL_PLAY_LOOP : SND_CTRL_PLAY_SOUND);
15013 if ((!setup.sound_simple && !IS_LOOP_SOUND(nr)) ||
15014 (!setup.sound_loops && IS_LOOP_SOUND(nr)))
15017 if (!IN_LEV_FIELD(x, y) ||
15018 sx < -max_distance || sx >= SCR_FIELDX + max_distance ||
15019 sy < -max_distance || sy >= SCR_FIELDY + max_distance)
15022 volume = SOUND_MAX_VOLUME;
15024 if (!IN_SCR_FIELD(sx, sy))
15026 int dx = ABS(sx - SCR_FIELDX / 2) - SCR_FIELDX / 2;
15027 int dy = ABS(sy - SCR_FIELDY / 2) - SCR_FIELDY / 2;
15029 volume -= volume * (dx > dy ? dx : dy) / max_distance;
15032 stereo_position = (SOUND_MAX_LEFT +
15033 (sx + max_distance) * SOUND_MAX_LEFT2RIGHT /
15034 (SCR_FIELDX + 2 * max_distance));
15036 if (IS_LOOP_SOUND(nr))
15038 /* This assures that quieter loop sounds do not overwrite louder ones,
15039 while restarting sound volume comparison with each new game frame. */
15041 if (loop_sound_volume[nr] > volume && loop_sound_frame[nr] == FrameCounter)
15044 loop_sound_volume[nr] = volume;
15045 loop_sound_frame[nr] = FrameCounter;
15048 PlaySoundExt(nr, volume, stereo_position, type);
15051 static void PlayLevelSoundNearest(int x, int y, int sound_action)
15053 PlayLevelSound(x < LEVELX(BX1) ? LEVELX(BX1) :
15054 x > LEVELX(BX2) ? LEVELX(BX2) : x,
15055 y < LEVELY(BY1) ? LEVELY(BY1) :
15056 y > LEVELY(BY2) ? LEVELY(BY2) : y,
15060 static void PlayLevelSoundAction(int x, int y, int action)
15062 PlayLevelSoundElementAction(x, y, Tile[x][y], action);
15065 static void PlayLevelSoundElementAction(int x, int y, int element, int action)
15067 int sound_effect = element_info[SND_ELEMENT(element)].sound[action];
15069 if (sound_effect != SND_UNDEFINED)
15070 PlayLevelSound(x, y, sound_effect);
15073 static void PlayLevelSoundElementActionIfLoop(int x, int y, int element,
15076 int sound_effect = element_info[SND_ELEMENT(element)].sound[action];
15078 if (sound_effect != SND_UNDEFINED && IS_LOOP_SOUND(sound_effect))
15079 PlayLevelSound(x, y, sound_effect);
15082 static void PlayLevelSoundActionIfLoop(int x, int y, int action)
15084 int sound_effect = element_info[SND_ELEMENT(Tile[x][y])].sound[action];
15086 if (sound_effect != SND_UNDEFINED && IS_LOOP_SOUND(sound_effect))
15087 PlayLevelSound(x, y, sound_effect);
15090 static void StopLevelSoundActionIfLoop(int x, int y, int action)
15092 int sound_effect = element_info[SND_ELEMENT(Tile[x][y])].sound[action];
15094 if (sound_effect != SND_UNDEFINED && IS_LOOP_SOUND(sound_effect))
15095 StopSound(sound_effect);
15098 static int getLevelMusicNr(void)
15100 if (levelset.music[level_nr] != MUS_UNDEFINED)
15101 return levelset.music[level_nr]; // from config file
15103 return MAP_NOCONF_MUSIC(level_nr); // from music dir
15106 static void FadeLevelSounds(void)
15111 static void FadeLevelMusic(void)
15113 int music_nr = getLevelMusicNr();
15114 char *curr_music = getCurrentlyPlayingMusicFilename();
15115 char *next_music = getMusicInfoEntryFilename(music_nr);
15117 if (!strEqual(curr_music, next_music))
15121 void FadeLevelSoundsAndMusic(void)
15127 static void PlayLevelMusic(void)
15129 int music_nr = getLevelMusicNr();
15130 char *curr_music = getCurrentlyPlayingMusicFilename();
15131 char *next_music = getMusicInfoEntryFilename(music_nr);
15133 if (!strEqual(curr_music, next_music))
15134 PlayMusicLoop(music_nr);
15137 void PlayLevelSound_EM(int xx, int yy, int element_em, int sample)
15139 int element = (element_em > -1 ? map_element_EM_to_RND_game(element_em) : 0);
15141 int x = xx - offset;
15142 int y = yy - offset;
15147 PlayLevelSoundElementAction(x, y, element, ACTION_WALKING);
15151 PlayLevelSoundElementAction(x, y, element, ACTION_PUSHING);
15155 PlayLevelSoundElementAction(x, y, element, ACTION_IMPACT);
15159 PlayLevelSoundElementAction(x, y, element, ACTION_IMPACT);
15163 PlayLevelSoundElementAction(x, y, element, ACTION_BREAKING);
15167 PlayLevelSoundElementAction(x, y, element, ACTION_MOVING);
15171 PlayLevelSoundElementAction(x, y, element, ACTION_MOVING);
15174 case SOUND_android_clone:
15175 PlayLevelSoundElementAction(x, y, element, ACTION_DROPPING);
15178 case SOUND_android_move:
15179 PlayLevelSoundElementAction(x, y, element, ACTION_MOVING);
15183 PlayLevelSoundElementAction(x, y, element, ACTION_IMPACT);
15187 PlayLevelSoundElementAction(x, y, element, ACTION_EATING);
15191 PlayLevelSoundElementAction(x, y, element, ACTION_WAITING);
15194 case SOUND_eater_eat:
15195 PlayLevelSoundElementAction(x, y, element, ACTION_DIGGING);
15199 PlayLevelSoundElementAction(x, y, element, ACTION_MOVING);
15202 case SOUND_collect:
15203 PlayLevelSoundElementAction(x, y, element, ACTION_COLLECTING);
15206 case SOUND_diamond:
15207 PlayLevelSoundElementAction(x, y, element, ACTION_IMPACT);
15211 // !!! CHECK THIS !!!
15213 PlayLevelSoundElementAction(x, y, element, ACTION_BREAKING);
15215 PlayLevelSoundElementAction(x, y, element, ACTION_SMASHED_BY_ROCK);
15219 case SOUND_wonderfall:
15220 PlayLevelSoundElementAction(x, y, element, ACTION_FILLING);
15224 PlayLevelSoundElementAction(x, y, element, ACTION_IMPACT);
15228 PlayLevelSoundElementAction(x, y, element, ACTION_PUSHING);
15232 PlayLevelSoundElementAction(x, y, element, ACTION_DIGGING);
15236 PlayLevelSoundElementAction(x, y, element, ACTION_SPLASHING);
15240 PlayLevelSoundElementAction(x, y, element, ACTION_DROPPING);
15244 PlayLevelSoundElementAction(x, y, element, ACTION_GROWING);
15248 PlayLevelSoundElementAction(x, y, element, ACTION_ACTIVE);
15252 PlayLevelSoundElementAction(x, y, element, ACTION_PASSING);
15255 case SOUND_exit_open:
15256 PlayLevelSoundElementAction(x, y, element, ACTION_OPENING);
15259 case SOUND_exit_leave:
15260 PlayLevelSoundElementAction(x, y, element, ACTION_PASSING);
15263 case SOUND_dynamite:
15264 PlayLevelSoundElementAction(x, y, element, ACTION_DROPPING);
15268 PlayLevelSoundElementAction(x, y, element, ACTION_ACTIVE);
15272 PlayLevelSoundElementAction(x, y, element, ACTION_ACTIVATING);
15276 PlayLevelSoundElementAction(x, y, element, ACTION_ACTIVE);
15280 PlayLevelSoundElementAction(x, y, element, ACTION_EXPLODING);
15284 PlayLevelSoundElementAction(x, y, element, ACTION_DYING);
15288 PlaySound(SND_GAME_RUNNING_OUT_OF_TIME);
15292 PlayLevelSoundElementAction(x, y, element, ACTION_DEFAULT);
15297 void PlayLevelSound_SP(int xx, int yy, int element_sp, int action_sp)
15299 int element = map_element_SP_to_RND(element_sp);
15300 int action = map_action_SP_to_RND(action_sp);
15301 int offset = (setup.sp_show_border_elements ? 0 : 1);
15302 int x = xx - offset;
15303 int y = yy - offset;
15305 PlayLevelSoundElementAction(x, y, element, action);
15308 void PlayLevelSound_MM(int xx, int yy, int element_mm, int action_mm)
15310 int element = map_element_MM_to_RND(element_mm);
15311 int action = map_action_MM_to_RND(action_mm);
15313 int x = xx - offset;
15314 int y = yy - offset;
15316 if (!IS_MM_ELEMENT(element))
15317 element = EL_MM_DEFAULT;
15319 PlayLevelSoundElementAction(x, y, element, action);
15322 void PlaySound_MM(int sound_mm)
15324 int sound = map_sound_MM_to_RND(sound_mm);
15326 if (sound == SND_UNDEFINED)
15332 void PlaySoundLoop_MM(int sound_mm)
15334 int sound = map_sound_MM_to_RND(sound_mm);
15336 if (sound == SND_UNDEFINED)
15339 PlaySoundLoop(sound);
15342 void StopSound_MM(int sound_mm)
15344 int sound = map_sound_MM_to_RND(sound_mm);
15346 if (sound == SND_UNDEFINED)
15352 void RaiseScore(int value)
15354 game.score += value;
15356 game_panel_controls[GAME_PANEL_SCORE].value = game.score;
15358 DisplayGameControlValues();
15361 void RaiseScoreElement(int element)
15366 case EL_BD_DIAMOND:
15367 case EL_EMERALD_YELLOW:
15368 case EL_EMERALD_RED:
15369 case EL_EMERALD_PURPLE:
15370 case EL_SP_INFOTRON:
15371 RaiseScore(level.score[SC_EMERALD]);
15374 RaiseScore(level.score[SC_DIAMOND]);
15377 RaiseScore(level.score[SC_CRYSTAL]);
15380 RaiseScore(level.score[SC_PEARL]);
15383 case EL_BD_BUTTERFLY:
15384 case EL_SP_ELECTRON:
15385 RaiseScore(level.score[SC_BUG]);
15388 case EL_BD_FIREFLY:
15389 case EL_SP_SNIKSNAK:
15390 RaiseScore(level.score[SC_SPACESHIP]);
15393 case EL_DARK_YAMYAM:
15394 RaiseScore(level.score[SC_YAMYAM]);
15397 RaiseScore(level.score[SC_ROBOT]);
15400 RaiseScore(level.score[SC_PACMAN]);
15403 RaiseScore(level.score[SC_NUT]);
15406 case EL_EM_DYNAMITE:
15407 case EL_SP_DISK_RED:
15408 case EL_DYNABOMB_INCREASE_NUMBER:
15409 case EL_DYNABOMB_INCREASE_SIZE:
15410 case EL_DYNABOMB_INCREASE_POWER:
15411 RaiseScore(level.score[SC_DYNAMITE]);
15413 case EL_SHIELD_NORMAL:
15414 case EL_SHIELD_DEADLY:
15415 RaiseScore(level.score[SC_SHIELD]);
15417 case EL_EXTRA_TIME:
15418 RaiseScore(level.extra_time_score);
15432 case EL_DC_KEY_WHITE:
15433 RaiseScore(level.score[SC_KEY]);
15436 RaiseScore(element_info[element].collect_score);
15441 void RequestQuitGameExt(boolean skip_request, boolean quick_quit, char *message)
15443 if (skip_request || Request(message, REQ_ASK | REQ_STAY_CLOSED))
15447 // prevent short reactivation of overlay buttons while closing door
15448 SetOverlayActive(FALSE);
15450 // door may still be open due to skipped or envelope style request
15451 CloseDoor(DOOR_CLOSE_1);
15454 if (network.enabled)
15455 SendToServer_StopPlaying(NETWORK_STOP_BY_PLAYER);
15459 FadeSkipNextFadeIn();
15461 SetGameStatus(GAME_MODE_MAIN);
15466 else // continue playing the game
15468 if (tape.playing && tape.deactivate_display)
15469 TapeDeactivateDisplayOff(TRUE);
15471 OpenDoor(DOOR_OPEN_1 | DOOR_COPY_BACK);
15473 if (tape.playing && tape.deactivate_display)
15474 TapeDeactivateDisplayOn();
15478 void RequestQuitGame(boolean escape_key_pressed)
15480 boolean ask_on_escape = (setup.ask_on_escape && setup.ask_on_quit_game);
15481 boolean quick_quit = ((escape_key_pressed && !ask_on_escape) ||
15482 level_editor_test_game);
15483 boolean skip_request = (game.all_players_gone || !setup.ask_on_quit_game ||
15486 RequestQuitGameExt(skip_request, quick_quit,
15487 "Do you really want to quit the game?");
15490 void RequestRestartGame(char *message)
15492 game.restart_game_message = NULL;
15494 boolean has_started_game = hasStartedNetworkGame();
15495 int request_mode = (has_started_game ? REQ_ASK : REQ_CONFIRM);
15497 if (Request(message, request_mode | REQ_STAY_CLOSED) && has_started_game)
15499 StartGameActions(network.enabled, setup.autorecord, level.random_seed);
15503 // needed in case of envelope request to close game panel
15504 CloseDoor(DOOR_CLOSE_1);
15506 SetGameStatus(GAME_MODE_MAIN);
15512 void CheckGameOver(void)
15514 static boolean last_game_over = FALSE;
15515 static int game_over_delay = 0;
15516 int game_over_delay_value = 50;
15517 boolean game_over = checkGameFailed();
15519 // do not handle game over if request dialog is already active
15520 if (game.request_active)
15523 // do not ask to play again if game was never actually played
15524 if (!game.GamePlayed)
15529 last_game_over = FALSE;
15530 game_over_delay = game_over_delay_value;
15535 if (game_over_delay > 0)
15542 if (last_game_over != game_over)
15543 game.restart_game_message = (hasStartedNetworkGame() ?
15544 "Game over! Play it again?" :
15547 last_game_over = game_over;
15550 boolean checkGameSolved(void)
15552 // set for all game engines if level was solved
15553 return game.LevelSolved_GameEnd;
15556 boolean checkGameFailed(void)
15558 if (level.game_engine_type == GAME_ENGINE_TYPE_EM)
15559 return (game_em.game_over && !game_em.level_solved);
15560 else if (level.game_engine_type == GAME_ENGINE_TYPE_SP)
15561 return (game_sp.game_over && !game_sp.level_solved);
15562 else if (level.game_engine_type == GAME_ENGINE_TYPE_MM)
15563 return (game_mm.game_over && !game_mm.level_solved);
15564 else // GAME_ENGINE_TYPE_RND
15565 return (game.GameOver && !game.LevelSolved);
15568 boolean checkGameEnded(void)
15570 return (checkGameSolved() || checkGameFailed());
15574 // ----------------------------------------------------------------------------
15575 // random generator functions
15576 // ----------------------------------------------------------------------------
15578 unsigned int InitEngineRandom_RND(int seed)
15580 game.num_random_calls = 0;
15582 return InitEngineRandom(seed);
15585 unsigned int RND(int max)
15589 game.num_random_calls++;
15591 return GetEngineRandom(max);
15598 // ----------------------------------------------------------------------------
15599 // game engine snapshot handling functions
15600 // ----------------------------------------------------------------------------
15602 struct EngineSnapshotInfo
15604 // runtime values for custom element collect score
15605 int collect_score[NUM_CUSTOM_ELEMENTS];
15607 // runtime values for group element choice position
15608 int choice_pos[NUM_GROUP_ELEMENTS];
15610 // runtime values for belt position animations
15611 int belt_graphic[4][NUM_BELT_PARTS];
15612 int belt_anim_mode[4][NUM_BELT_PARTS];
15615 static struct EngineSnapshotInfo engine_snapshot_rnd;
15616 static char *snapshot_level_identifier = NULL;
15617 static int snapshot_level_nr = -1;
15619 static void SaveEngineSnapshotValues_RND(void)
15621 static int belt_base_active_element[4] =
15623 EL_CONVEYOR_BELT_1_LEFT_ACTIVE,
15624 EL_CONVEYOR_BELT_2_LEFT_ACTIVE,
15625 EL_CONVEYOR_BELT_3_LEFT_ACTIVE,
15626 EL_CONVEYOR_BELT_4_LEFT_ACTIVE
15630 for (i = 0; i < NUM_CUSTOM_ELEMENTS; i++)
15632 int element = EL_CUSTOM_START + i;
15634 engine_snapshot_rnd.collect_score[i] = element_info[element].collect_score;
15637 for (i = 0; i < NUM_GROUP_ELEMENTS; i++)
15639 int element = EL_GROUP_START + i;
15641 engine_snapshot_rnd.choice_pos[i] = element_info[element].group->choice_pos;
15644 for (i = 0; i < 4; i++)
15646 for (j = 0; j < NUM_BELT_PARTS; j++)
15648 int element = belt_base_active_element[i] + j;
15649 int graphic = el2img(element);
15650 int anim_mode = graphic_info[graphic].anim_mode;
15652 engine_snapshot_rnd.belt_graphic[i][j] = graphic;
15653 engine_snapshot_rnd.belt_anim_mode[i][j] = anim_mode;
15658 static void LoadEngineSnapshotValues_RND(void)
15660 unsigned int num_random_calls = game.num_random_calls;
15663 for (i = 0; i < NUM_CUSTOM_ELEMENTS; i++)
15665 int element = EL_CUSTOM_START + i;
15667 element_info[element].collect_score = engine_snapshot_rnd.collect_score[i];
15670 for (i = 0; i < NUM_GROUP_ELEMENTS; i++)
15672 int element = EL_GROUP_START + i;
15674 element_info[element].group->choice_pos = engine_snapshot_rnd.choice_pos[i];
15677 for (i = 0; i < 4; i++)
15679 for (j = 0; j < NUM_BELT_PARTS; j++)
15681 int graphic = engine_snapshot_rnd.belt_graphic[i][j];
15682 int anim_mode = engine_snapshot_rnd.belt_anim_mode[i][j];
15684 graphic_info[graphic].anim_mode = anim_mode;
15688 if (level.game_engine_type == GAME_ENGINE_TYPE_RND)
15690 InitRND(tape.random_seed);
15691 for (i = 0; i < num_random_calls; i++)
15695 if (game.num_random_calls != num_random_calls)
15697 Error("number of random calls out of sync");
15698 Error("number of random calls should be %d", num_random_calls);
15699 Error("number of random calls is %d", game.num_random_calls);
15701 Fail("this should not happen -- please debug");
15705 void FreeEngineSnapshotSingle(void)
15707 FreeSnapshotSingle();
15709 setString(&snapshot_level_identifier, NULL);
15710 snapshot_level_nr = -1;
15713 void FreeEngineSnapshotList(void)
15715 FreeSnapshotList();
15718 static ListNode *SaveEngineSnapshotBuffers(void)
15720 ListNode *buffers = NULL;
15722 // copy some special values to a structure better suited for the snapshot
15724 if (level.game_engine_type == GAME_ENGINE_TYPE_RND)
15725 SaveEngineSnapshotValues_RND();
15726 if (level.game_engine_type == GAME_ENGINE_TYPE_EM)
15727 SaveEngineSnapshotValues_EM();
15728 if (level.game_engine_type == GAME_ENGINE_TYPE_SP)
15729 SaveEngineSnapshotValues_SP(&buffers);
15730 if (level.game_engine_type == GAME_ENGINE_TYPE_MM)
15731 SaveEngineSnapshotValues_MM(&buffers);
15733 // save values stored in special snapshot structure
15735 if (level.game_engine_type == GAME_ENGINE_TYPE_RND)
15736 SaveSnapshotBuffer(&buffers, ARGS_ADDRESS_AND_SIZEOF(engine_snapshot_rnd));
15737 if (level.game_engine_type == GAME_ENGINE_TYPE_EM)
15738 SaveSnapshotBuffer(&buffers, ARGS_ADDRESS_AND_SIZEOF(engine_snapshot_em));
15739 if (level.game_engine_type == GAME_ENGINE_TYPE_SP)
15740 SaveSnapshotBuffer(&buffers, ARGS_ADDRESS_AND_SIZEOF(engine_snapshot_sp));
15741 if (level.game_engine_type == GAME_ENGINE_TYPE_MM)
15742 SaveSnapshotBuffer(&buffers, ARGS_ADDRESS_AND_SIZEOF(engine_snapshot_mm));
15744 // save further RND engine values
15746 SaveSnapshotBuffer(&buffers, ARGS_ADDRESS_AND_SIZEOF(stored_player));
15747 SaveSnapshotBuffer(&buffers, ARGS_ADDRESS_AND_SIZEOF(game));
15748 SaveSnapshotBuffer(&buffers, ARGS_ADDRESS_AND_SIZEOF(tape));
15750 SaveSnapshotBuffer(&buffers, ARGS_ADDRESS_AND_SIZEOF(FrameCounter));
15751 SaveSnapshotBuffer(&buffers, ARGS_ADDRESS_AND_SIZEOF(TimeFrames));
15752 SaveSnapshotBuffer(&buffers, ARGS_ADDRESS_AND_SIZEOF(TimePlayed));
15753 SaveSnapshotBuffer(&buffers, ARGS_ADDRESS_AND_SIZEOF(TimeLeft));
15754 SaveSnapshotBuffer(&buffers, ARGS_ADDRESS_AND_SIZEOF(TapeTime));
15756 SaveSnapshotBuffer(&buffers, ARGS_ADDRESS_AND_SIZEOF(ScreenMovDir));
15757 SaveSnapshotBuffer(&buffers, ARGS_ADDRESS_AND_SIZEOF(ScreenMovPos));
15758 SaveSnapshotBuffer(&buffers, ARGS_ADDRESS_AND_SIZEOF(ScreenGfxPos));
15760 SaveSnapshotBuffer(&buffers, ARGS_ADDRESS_AND_SIZEOF(ScrollStepSize));
15762 SaveSnapshotBuffer(&buffers, ARGS_ADDRESS_AND_SIZEOF(AmoebaCnt));
15763 SaveSnapshotBuffer(&buffers, ARGS_ADDRESS_AND_SIZEOF(AmoebaCnt2));
15765 SaveSnapshotBuffer(&buffers, ARGS_ADDRESS_AND_SIZEOF(Tile));
15766 SaveSnapshotBuffer(&buffers, ARGS_ADDRESS_AND_SIZEOF(MovPos));
15767 SaveSnapshotBuffer(&buffers, ARGS_ADDRESS_AND_SIZEOF(MovDir));
15768 SaveSnapshotBuffer(&buffers, ARGS_ADDRESS_AND_SIZEOF(MovDelay));
15769 SaveSnapshotBuffer(&buffers, ARGS_ADDRESS_AND_SIZEOF(ChangeDelay));
15770 SaveSnapshotBuffer(&buffers, ARGS_ADDRESS_AND_SIZEOF(ChangePage));
15771 SaveSnapshotBuffer(&buffers, ARGS_ADDRESS_AND_SIZEOF(CustomValue));
15772 SaveSnapshotBuffer(&buffers, ARGS_ADDRESS_AND_SIZEOF(Store));
15773 SaveSnapshotBuffer(&buffers, ARGS_ADDRESS_AND_SIZEOF(Store2));
15774 SaveSnapshotBuffer(&buffers, ARGS_ADDRESS_AND_SIZEOF(StorePlayer));
15775 SaveSnapshotBuffer(&buffers, ARGS_ADDRESS_AND_SIZEOF(Back));
15776 SaveSnapshotBuffer(&buffers, ARGS_ADDRESS_AND_SIZEOF(AmoebaNr));
15777 SaveSnapshotBuffer(&buffers, ARGS_ADDRESS_AND_SIZEOF(WasJustMoving));
15778 SaveSnapshotBuffer(&buffers, ARGS_ADDRESS_AND_SIZEOF(WasJustFalling));
15779 SaveSnapshotBuffer(&buffers, ARGS_ADDRESS_AND_SIZEOF(CheckCollision));
15780 SaveSnapshotBuffer(&buffers, ARGS_ADDRESS_AND_SIZEOF(CheckImpact));
15781 SaveSnapshotBuffer(&buffers, ARGS_ADDRESS_AND_SIZEOF(Stop));
15782 SaveSnapshotBuffer(&buffers, ARGS_ADDRESS_AND_SIZEOF(Pushed));
15784 SaveSnapshotBuffer(&buffers, ARGS_ADDRESS_AND_SIZEOF(ChangeCount));
15785 SaveSnapshotBuffer(&buffers, ARGS_ADDRESS_AND_SIZEOF(ChangeEvent));
15787 SaveSnapshotBuffer(&buffers, ARGS_ADDRESS_AND_SIZEOF(ExplodePhase));
15788 SaveSnapshotBuffer(&buffers, ARGS_ADDRESS_AND_SIZEOF(ExplodeDelay));
15789 SaveSnapshotBuffer(&buffers, ARGS_ADDRESS_AND_SIZEOF(ExplodeField));
15791 SaveSnapshotBuffer(&buffers, ARGS_ADDRESS_AND_SIZEOF(RunnerVisit));
15792 SaveSnapshotBuffer(&buffers, ARGS_ADDRESS_AND_SIZEOF(PlayerVisit));
15794 SaveSnapshotBuffer(&buffers, ARGS_ADDRESS_AND_SIZEOF(GfxFrame));
15795 SaveSnapshotBuffer(&buffers, ARGS_ADDRESS_AND_SIZEOF(GfxRandom));
15796 SaveSnapshotBuffer(&buffers, ARGS_ADDRESS_AND_SIZEOF(GfxElement));
15797 SaveSnapshotBuffer(&buffers, ARGS_ADDRESS_AND_SIZEOF(GfxAction));
15798 SaveSnapshotBuffer(&buffers, ARGS_ADDRESS_AND_SIZEOF(GfxDir));
15800 SaveSnapshotBuffer(&buffers, ARGS_ADDRESS_AND_SIZEOF(scroll_x));
15801 SaveSnapshotBuffer(&buffers, ARGS_ADDRESS_AND_SIZEOF(scroll_y));
15804 ListNode *node = engine_snapshot_list_rnd;
15807 while (node != NULL)
15809 num_bytes += ((struct EngineSnapshotNodeInfo *)node->content)->size;
15814 Debug("game:playing:SaveEngineSnapshotBuffers",
15815 "size of engine snapshot: %d bytes", num_bytes);
15821 void SaveEngineSnapshotSingle(void)
15823 ListNode *buffers = SaveEngineSnapshotBuffers();
15825 // finally save all snapshot buffers to single snapshot
15826 SaveSnapshotSingle(buffers);
15828 // save level identification information
15829 setString(&snapshot_level_identifier, leveldir_current->identifier);
15830 snapshot_level_nr = level_nr;
15833 boolean CheckSaveEngineSnapshotToList(void)
15835 boolean save_snapshot =
15836 ((game.snapshot.mode == SNAPSHOT_MODE_EVERY_STEP) ||
15837 (game.snapshot.mode == SNAPSHOT_MODE_EVERY_MOVE &&
15838 game.snapshot.changed_action) ||
15839 (game.snapshot.mode == SNAPSHOT_MODE_EVERY_COLLECT &&
15840 game.snapshot.collected_item));
15842 game.snapshot.changed_action = FALSE;
15843 game.snapshot.collected_item = FALSE;
15844 game.snapshot.save_snapshot = save_snapshot;
15846 return save_snapshot;
15849 void SaveEngineSnapshotToList(void)
15851 if (game.snapshot.mode == SNAPSHOT_MODE_OFF ||
15855 ListNode *buffers = SaveEngineSnapshotBuffers();
15857 // finally save all snapshot buffers to snapshot list
15858 SaveSnapshotToList(buffers);
15861 void SaveEngineSnapshotToListInitial(void)
15863 FreeEngineSnapshotList();
15865 SaveEngineSnapshotToList();
15868 static void LoadEngineSnapshotValues(void)
15870 // restore special values from snapshot structure
15872 if (level.game_engine_type == GAME_ENGINE_TYPE_RND)
15873 LoadEngineSnapshotValues_RND();
15874 if (level.game_engine_type == GAME_ENGINE_TYPE_EM)
15875 LoadEngineSnapshotValues_EM();
15876 if (level.game_engine_type == GAME_ENGINE_TYPE_SP)
15877 LoadEngineSnapshotValues_SP();
15878 if (level.game_engine_type == GAME_ENGINE_TYPE_MM)
15879 LoadEngineSnapshotValues_MM();
15882 void LoadEngineSnapshotSingle(void)
15884 LoadSnapshotSingle();
15886 LoadEngineSnapshotValues();
15889 static void LoadEngineSnapshot_Undo(int steps)
15891 LoadSnapshotFromList_Older(steps);
15893 LoadEngineSnapshotValues();
15896 static void LoadEngineSnapshot_Redo(int steps)
15898 LoadSnapshotFromList_Newer(steps);
15900 LoadEngineSnapshotValues();
15903 boolean CheckEngineSnapshotSingle(void)
15905 return (strEqual(snapshot_level_identifier, leveldir_current->identifier) &&
15906 snapshot_level_nr == level_nr);
15909 boolean CheckEngineSnapshotList(void)
15911 return CheckSnapshotList();
15915 // ---------- new game button stuff -------------------------------------------
15922 boolean *setup_value;
15923 boolean allowed_on_tape;
15924 boolean is_touch_button;
15926 } gamebutton_info[NUM_GAME_BUTTONS] =
15929 IMG_GFX_GAME_BUTTON_STOP, &game.button.stop,
15930 GAME_CTRL_ID_STOP, NULL,
15931 TRUE, FALSE, "stop game"
15934 IMG_GFX_GAME_BUTTON_PAUSE, &game.button.pause,
15935 GAME_CTRL_ID_PAUSE, NULL,
15936 TRUE, FALSE, "pause game"
15939 IMG_GFX_GAME_BUTTON_PLAY, &game.button.play,
15940 GAME_CTRL_ID_PLAY, NULL,
15941 TRUE, FALSE, "play game"
15944 IMG_GFX_GAME_BUTTON_UNDO, &game.button.undo,
15945 GAME_CTRL_ID_UNDO, NULL,
15946 TRUE, FALSE, "undo step"
15949 IMG_GFX_GAME_BUTTON_REDO, &game.button.redo,
15950 GAME_CTRL_ID_REDO, NULL,
15951 TRUE, FALSE, "redo step"
15954 IMG_GFX_GAME_BUTTON_SAVE, &game.button.save,
15955 GAME_CTRL_ID_SAVE, NULL,
15956 TRUE, FALSE, "save game"
15959 IMG_GFX_GAME_BUTTON_PAUSE2, &game.button.pause2,
15960 GAME_CTRL_ID_PAUSE2, NULL,
15961 TRUE, FALSE, "pause game"
15964 IMG_GFX_GAME_BUTTON_LOAD, &game.button.load,
15965 GAME_CTRL_ID_LOAD, NULL,
15966 TRUE, FALSE, "load game"
15969 IMG_GFX_GAME_BUTTON_PANEL_STOP, &game.button.panel_stop,
15970 GAME_CTRL_ID_PANEL_STOP, NULL,
15971 FALSE, FALSE, "stop game"
15974 IMG_GFX_GAME_BUTTON_PANEL_PAUSE, &game.button.panel_pause,
15975 GAME_CTRL_ID_PANEL_PAUSE, NULL,
15976 FALSE, FALSE, "pause game"
15979 IMG_GFX_GAME_BUTTON_PANEL_PLAY, &game.button.panel_play,
15980 GAME_CTRL_ID_PANEL_PLAY, NULL,
15981 FALSE, FALSE, "play game"
15984 IMG_GFX_GAME_BUTTON_TOUCH_STOP, &game.button.touch_stop,
15985 GAME_CTRL_ID_TOUCH_STOP, NULL,
15986 FALSE, TRUE, "stop game"
15989 IMG_GFX_GAME_BUTTON_TOUCH_PAUSE, &game.button.touch_pause,
15990 GAME_CTRL_ID_TOUCH_PAUSE, NULL,
15991 FALSE, TRUE, "pause game"
15994 IMG_GFX_GAME_BUTTON_SOUND_MUSIC, &game.button.sound_music,
15995 SOUND_CTRL_ID_MUSIC, &setup.sound_music,
15996 TRUE, FALSE, "background music on/off"
15999 IMG_GFX_GAME_BUTTON_SOUND_LOOPS, &game.button.sound_loops,
16000 SOUND_CTRL_ID_LOOPS, &setup.sound_loops,
16001 TRUE, FALSE, "sound loops on/off"
16004 IMG_GFX_GAME_BUTTON_SOUND_SIMPLE, &game.button.sound_simple,
16005 SOUND_CTRL_ID_SIMPLE, &setup.sound_simple,
16006 TRUE, FALSE, "normal sounds on/off"
16009 IMG_GFX_GAME_BUTTON_PANEL_SOUND_MUSIC, &game.button.panel_sound_music,
16010 SOUND_CTRL_ID_PANEL_MUSIC, &setup.sound_music,
16011 FALSE, FALSE, "background music on/off"
16014 IMG_GFX_GAME_BUTTON_PANEL_SOUND_LOOPS, &game.button.panel_sound_loops,
16015 SOUND_CTRL_ID_PANEL_LOOPS, &setup.sound_loops,
16016 FALSE, FALSE, "sound loops on/off"
16019 IMG_GFX_GAME_BUTTON_PANEL_SOUND_SIMPLE, &game.button.panel_sound_simple,
16020 SOUND_CTRL_ID_PANEL_SIMPLE, &setup.sound_simple,
16021 FALSE, FALSE, "normal sounds on/off"
16025 void CreateGameButtons(void)
16029 for (i = 0; i < NUM_GAME_BUTTONS; i++)
16031 int graphic = gamebutton_info[i].graphic;
16032 struct GraphicInfo *gfx = &graphic_info[graphic];
16033 struct XY *pos = gamebutton_info[i].pos;
16034 struct GadgetInfo *gi;
16037 unsigned int event_mask;
16038 boolean is_touch_button = gamebutton_info[i].is_touch_button;
16039 boolean allowed_on_tape = gamebutton_info[i].allowed_on_tape;
16040 boolean on_tape = (tape.show_game_buttons && allowed_on_tape);
16041 int base_x = (is_touch_button ? 0 : on_tape ? VX : DX);
16042 int base_y = (is_touch_button ? 0 : on_tape ? VY : DY);
16043 int gd_x = gfx->src_x;
16044 int gd_y = gfx->src_y;
16045 int gd_xp = gfx->src_x + gfx->pressed_xoffset;
16046 int gd_yp = gfx->src_y + gfx->pressed_yoffset;
16047 int gd_xa = gfx->src_x + gfx->active_xoffset;
16048 int gd_ya = gfx->src_y + gfx->active_yoffset;
16049 int gd_xap = gfx->src_x + gfx->active_xoffset + gfx->pressed_xoffset;
16050 int gd_yap = gfx->src_y + gfx->active_yoffset + gfx->pressed_yoffset;
16051 int x = (is_touch_button ? pos->x : GDI_ACTIVE_POS(pos->x));
16052 int y = (is_touch_button ? pos->y : GDI_ACTIVE_POS(pos->y));
16055 if (gfx->bitmap == NULL)
16057 game_gadget[id] = NULL;
16062 if (id == GAME_CTRL_ID_STOP ||
16063 id == GAME_CTRL_ID_PANEL_STOP ||
16064 id == GAME_CTRL_ID_TOUCH_STOP ||
16065 id == GAME_CTRL_ID_PLAY ||
16066 id == GAME_CTRL_ID_PANEL_PLAY ||
16067 id == GAME_CTRL_ID_SAVE ||
16068 id == GAME_CTRL_ID_LOAD)
16070 button_type = GD_TYPE_NORMAL_BUTTON;
16072 event_mask = GD_EVENT_RELEASED;
16074 else if (id == GAME_CTRL_ID_UNDO ||
16075 id == GAME_CTRL_ID_REDO)
16077 button_type = GD_TYPE_NORMAL_BUTTON;
16079 event_mask = GD_EVENT_PRESSED | GD_EVENT_REPEATED;
16083 button_type = GD_TYPE_CHECK_BUTTON;
16084 checked = (gamebutton_info[i].setup_value != NULL ?
16085 *gamebutton_info[i].setup_value : FALSE);
16086 event_mask = GD_EVENT_PRESSED;
16089 gi = CreateGadget(GDI_CUSTOM_ID, id,
16090 GDI_IMAGE_ID, graphic,
16091 GDI_INFO_TEXT, gamebutton_info[i].infotext,
16094 GDI_WIDTH, gfx->width,
16095 GDI_HEIGHT, gfx->height,
16096 GDI_TYPE, button_type,
16097 GDI_STATE, GD_BUTTON_UNPRESSED,
16098 GDI_CHECKED, checked,
16099 GDI_DESIGN_UNPRESSED, gfx->bitmap, gd_x, gd_y,
16100 GDI_DESIGN_PRESSED, gfx->bitmap, gd_xp, gd_yp,
16101 GDI_ALT_DESIGN_UNPRESSED, gfx->bitmap, gd_xa, gd_ya,
16102 GDI_ALT_DESIGN_PRESSED, gfx->bitmap, gd_xap, gd_yap,
16103 GDI_DIRECT_DRAW, FALSE,
16104 GDI_OVERLAY_TOUCH_BUTTON, is_touch_button,
16105 GDI_EVENT_MASK, event_mask,
16106 GDI_CALLBACK_ACTION, HandleGameButtons,
16110 Fail("cannot create gadget");
16112 game_gadget[id] = gi;
16116 void FreeGameButtons(void)
16120 for (i = 0; i < NUM_GAME_BUTTONS; i++)
16121 FreeGadget(game_gadget[i]);
16124 static void UnmapGameButtonsAtSamePosition(int id)
16128 for (i = 0; i < NUM_GAME_BUTTONS; i++)
16130 gamebutton_info[i].pos->x == gamebutton_info[id].pos->x &&
16131 gamebutton_info[i].pos->y == gamebutton_info[id].pos->y)
16132 UnmapGadget(game_gadget[i]);
16135 static void UnmapGameButtonsAtSamePosition_All(void)
16137 if (setup.show_snapshot_buttons)
16139 UnmapGameButtonsAtSamePosition(GAME_CTRL_ID_SAVE);
16140 UnmapGameButtonsAtSamePosition(GAME_CTRL_ID_PAUSE2);
16141 UnmapGameButtonsAtSamePosition(GAME_CTRL_ID_LOAD);
16145 UnmapGameButtonsAtSamePosition(GAME_CTRL_ID_STOP);
16146 UnmapGameButtonsAtSamePosition(GAME_CTRL_ID_PAUSE);
16147 UnmapGameButtonsAtSamePosition(GAME_CTRL_ID_PLAY);
16149 UnmapGameButtonsAtSamePosition(GAME_CTRL_ID_PANEL_STOP);
16150 UnmapGameButtonsAtSamePosition(GAME_CTRL_ID_PANEL_PAUSE);
16151 UnmapGameButtonsAtSamePosition(GAME_CTRL_ID_PANEL_PLAY);
16155 static void MapGameButtonsAtSamePosition(int id)
16159 for (i = 0; i < NUM_GAME_BUTTONS; i++)
16161 gamebutton_info[i].pos->x == gamebutton_info[id].pos->x &&
16162 gamebutton_info[i].pos->y == gamebutton_info[id].pos->y)
16163 MapGadget(game_gadget[i]);
16165 UnmapGameButtonsAtSamePosition_All();
16168 void MapUndoRedoButtons(void)
16170 UnmapGameButtonsAtSamePosition(GAME_CTRL_ID_UNDO);
16171 UnmapGameButtonsAtSamePosition(GAME_CTRL_ID_REDO);
16173 MapGadget(game_gadget[GAME_CTRL_ID_UNDO]);
16174 MapGadget(game_gadget[GAME_CTRL_ID_REDO]);
16177 void UnmapUndoRedoButtons(void)
16179 UnmapGadget(game_gadget[GAME_CTRL_ID_UNDO]);
16180 UnmapGadget(game_gadget[GAME_CTRL_ID_REDO]);
16182 MapGameButtonsAtSamePosition(GAME_CTRL_ID_UNDO);
16183 MapGameButtonsAtSamePosition(GAME_CTRL_ID_REDO);
16186 void ModifyPauseButtons(void)
16190 GAME_CTRL_ID_PAUSE,
16191 GAME_CTRL_ID_PAUSE2,
16192 GAME_CTRL_ID_PANEL_PAUSE,
16193 GAME_CTRL_ID_TOUCH_PAUSE,
16198 for (i = 0; ids[i] > -1; i++)
16199 ModifyGadget(game_gadget[ids[i]], GDI_CHECKED, tape.pausing, GDI_END);
16202 static void MapGameButtonsExt(boolean on_tape)
16206 for (i = 0; i < NUM_GAME_BUTTONS; i++)
16207 if ((!on_tape || gamebutton_info[i].allowed_on_tape) &&
16208 i != GAME_CTRL_ID_UNDO &&
16209 i != GAME_CTRL_ID_REDO)
16210 MapGadget(game_gadget[i]);
16212 UnmapGameButtonsAtSamePosition_All();
16214 RedrawGameButtons();
16217 static void UnmapGameButtonsExt(boolean on_tape)
16221 for (i = 0; i < NUM_GAME_BUTTONS; i++)
16222 if (!on_tape || gamebutton_info[i].allowed_on_tape)
16223 UnmapGadget(game_gadget[i]);
16226 static void RedrawGameButtonsExt(boolean on_tape)
16230 for (i = 0; i < NUM_GAME_BUTTONS; i++)
16231 if (!on_tape || gamebutton_info[i].allowed_on_tape)
16232 RedrawGadget(game_gadget[i]);
16235 static void SetGadgetState(struct GadgetInfo *gi, boolean state)
16240 gi->checked = state;
16243 static void RedrawSoundButtonGadget(int id)
16245 int id2 = (id == SOUND_CTRL_ID_MUSIC ? SOUND_CTRL_ID_PANEL_MUSIC :
16246 id == SOUND_CTRL_ID_LOOPS ? SOUND_CTRL_ID_PANEL_LOOPS :
16247 id == SOUND_CTRL_ID_SIMPLE ? SOUND_CTRL_ID_PANEL_SIMPLE :
16248 id == SOUND_CTRL_ID_PANEL_MUSIC ? SOUND_CTRL_ID_MUSIC :
16249 id == SOUND_CTRL_ID_PANEL_LOOPS ? SOUND_CTRL_ID_LOOPS :
16250 id == SOUND_CTRL_ID_PANEL_SIMPLE ? SOUND_CTRL_ID_SIMPLE :
16253 SetGadgetState(game_gadget[id2], *gamebutton_info[id2].setup_value);
16254 RedrawGadget(game_gadget[id2]);
16257 void MapGameButtons(void)
16259 MapGameButtonsExt(FALSE);
16262 void UnmapGameButtons(void)
16264 UnmapGameButtonsExt(FALSE);
16267 void RedrawGameButtons(void)
16269 RedrawGameButtonsExt(FALSE);
16272 void MapGameButtonsOnTape(void)
16274 MapGameButtonsExt(TRUE);
16277 void UnmapGameButtonsOnTape(void)
16279 UnmapGameButtonsExt(TRUE);
16282 void RedrawGameButtonsOnTape(void)
16284 RedrawGameButtonsExt(TRUE);
16287 static void GameUndoRedoExt(void)
16289 ClearPlayerAction();
16291 tape.pausing = TRUE;
16294 UpdateAndDisplayGameControlValues();
16296 DrawCompleteVideoDisplay();
16297 DrawVideoDisplay(VIDEO_STATE_TIME_ON, TapeTime);
16298 DrawVideoDisplay(VIDEO_STATE_FRAME_ON, FrameCounter);
16299 DrawVideoDisplay(VIDEO_STATE_1STEP(tape.single_step), 0);
16304 static void GameUndo(int steps)
16306 if (!CheckEngineSnapshotList())
16309 LoadEngineSnapshot_Undo(steps);
16314 static void GameRedo(int steps)
16316 if (!CheckEngineSnapshotList())
16319 LoadEngineSnapshot_Redo(steps);
16324 static void HandleGameButtonsExt(int id, int button)
16326 static boolean game_undo_executed = FALSE;
16327 int steps = BUTTON_STEPSIZE(button);
16328 boolean handle_game_buttons =
16329 (game_status == GAME_MODE_PLAYING ||
16330 (game_status == GAME_MODE_MAIN && tape.show_game_buttons));
16332 if (!handle_game_buttons)
16337 case GAME_CTRL_ID_STOP:
16338 case GAME_CTRL_ID_PANEL_STOP:
16339 case GAME_CTRL_ID_TOUCH_STOP:
16340 if (game_status == GAME_MODE_MAIN)
16346 RequestQuitGame(FALSE);
16350 case GAME_CTRL_ID_PAUSE:
16351 case GAME_CTRL_ID_PAUSE2:
16352 case GAME_CTRL_ID_PANEL_PAUSE:
16353 case GAME_CTRL_ID_TOUCH_PAUSE:
16354 if (network.enabled && game_status == GAME_MODE_PLAYING)
16357 SendToServer_ContinuePlaying();
16359 SendToServer_PausePlaying();
16362 TapeTogglePause(TAPE_TOGGLE_MANUAL);
16364 game_undo_executed = FALSE;
16368 case GAME_CTRL_ID_PLAY:
16369 case GAME_CTRL_ID_PANEL_PLAY:
16370 if (game_status == GAME_MODE_MAIN)
16372 StartGameActions(network.enabled, setup.autorecord, level.random_seed);
16374 else if (tape.pausing)
16376 if (network.enabled)
16377 SendToServer_ContinuePlaying();
16379 TapeTogglePause(TAPE_TOGGLE_MANUAL | TAPE_TOGGLE_PLAY_PAUSE);
16383 case GAME_CTRL_ID_UNDO:
16384 // Important: When using "save snapshot when collecting an item" mode,
16385 // load last (current) snapshot for first "undo" after pressing "pause"
16386 // (else the last-but-one snapshot would be loaded, because the snapshot
16387 // pointer already points to the last snapshot when pressing "pause",
16388 // which is fine for "every step/move" mode, but not for "every collect")
16389 if (game.snapshot.mode == SNAPSHOT_MODE_EVERY_COLLECT &&
16390 !game_undo_executed)
16393 game_undo_executed = TRUE;
16398 case GAME_CTRL_ID_REDO:
16402 case GAME_CTRL_ID_SAVE:
16406 case GAME_CTRL_ID_LOAD:
16410 case SOUND_CTRL_ID_MUSIC:
16411 case SOUND_CTRL_ID_PANEL_MUSIC:
16412 if (setup.sound_music)
16414 setup.sound_music = FALSE;
16418 else if (audio.music_available)
16420 setup.sound = setup.sound_music = TRUE;
16422 SetAudioMode(setup.sound);
16424 if (game_status == GAME_MODE_PLAYING)
16428 RedrawSoundButtonGadget(id);
16432 case SOUND_CTRL_ID_LOOPS:
16433 case SOUND_CTRL_ID_PANEL_LOOPS:
16434 if (setup.sound_loops)
16435 setup.sound_loops = FALSE;
16436 else if (audio.loops_available)
16438 setup.sound = setup.sound_loops = TRUE;
16440 SetAudioMode(setup.sound);
16443 RedrawSoundButtonGadget(id);
16447 case SOUND_CTRL_ID_SIMPLE:
16448 case SOUND_CTRL_ID_PANEL_SIMPLE:
16449 if (setup.sound_simple)
16450 setup.sound_simple = FALSE;
16451 else if (audio.sound_available)
16453 setup.sound = setup.sound_simple = TRUE;
16455 SetAudioMode(setup.sound);
16458 RedrawSoundButtonGadget(id);
16467 static void HandleGameButtons(struct GadgetInfo *gi)
16469 HandleGameButtonsExt(gi->custom_id, gi->event.button);
16472 void HandleSoundButtonKeys(Key key)
16474 if (key == setup.shortcut.sound_simple)
16475 ClickOnGadget(game_gadget[SOUND_CTRL_ID_SIMPLE], MB_LEFTBUTTON);
16476 else if (key == setup.shortcut.sound_loops)
16477 ClickOnGadget(game_gadget[SOUND_CTRL_ID_LOOPS], MB_LEFTBUTTON);
16478 else if (key == setup.shortcut.sound_music)
16479 ClickOnGadget(game_gadget[SOUND_CTRL_ID_MUSIC], MB_LEFTBUTTON);