1 // ============================================================================
2 // Rocks'n'Diamonds - McDuffin Strikes Back!
3 // ----------------------------------------------------------------------------
4 // (c) 1995-2014 by Artsoft Entertainment
7 // https://www.artsoft.org/
8 // ----------------------------------------------------------------------------
10 // ============================================================================
12 #include "libgame/libgame.h"
26 #define DEBUG_INIT_PLAYER 1
27 #define DEBUG_PLAYER_ACTIONS 0
30 #define USE_NEW_AMOEBA_CODE FALSE
33 #define USE_QUICKSAND_BD_ROCK_BUGFIX 0
34 #define USE_QUICKSAND_IMPACT_BUGFIX 0
35 #define USE_DELAYED_GFX_REDRAW 0
36 #define USE_NEW_PLAYER_ASSIGNMENTS 1
38 #if USE_DELAYED_GFX_REDRAW
39 #define TEST_DrawLevelField(x, y) \
40 GfxRedraw[x][y] |= GFX_REDRAW_TILE
41 #define TEST_DrawLevelFieldCrumbled(x, y) \
42 GfxRedraw[x][y] |= GFX_REDRAW_TILE_CRUMBLED
43 #define TEST_DrawLevelFieldCrumbledNeighbours(x, y) \
44 GfxRedraw[x][y] |= GFX_REDRAW_TILE_CRUMBLED_NEIGHBOURS
45 #define TEST_DrawTwinkleOnField(x, y) \
46 GfxRedraw[x][y] |= GFX_REDRAW_TILE_TWINKLED
48 #define TEST_DrawLevelField(x, y) \
50 #define TEST_DrawLevelFieldCrumbled(x, y) \
51 DrawLevelFieldCrumbled(x, y)
52 #define TEST_DrawLevelFieldCrumbledNeighbours(x, y) \
53 DrawLevelFieldCrumbledNeighbours(x, y)
54 #define TEST_DrawTwinkleOnField(x, y) \
55 DrawTwinkleOnField(x, y)
65 #define MP_NO_ACTION 0
68 #define MP_DONT_RUN_INTO (MP_MOVING | MP_ACTION)
72 #define SCROLL_GO_ON 1
74 // for Bang()/Explode()
75 #define EX_PHASE_START 0
76 #define EX_TYPE_NONE 0
77 #define EX_TYPE_NORMAL (1 << 0)
78 #define EX_TYPE_CENTER (1 << 1)
79 #define EX_TYPE_BORDER (1 << 2)
80 #define EX_TYPE_CROSS (1 << 3)
81 #define EX_TYPE_DYNA (1 << 4)
82 #define EX_TYPE_SINGLE_TILE (EX_TYPE_CENTER | EX_TYPE_BORDER)
84 #define PANEL_OFF() (game.panel.active == FALSE)
85 #define PANEL_DEACTIVATED(p) ((p)->x < 0 || (p)->y < 0 || PANEL_OFF())
86 #define PANEL_XPOS(p) (DX + ALIGNED_TEXT_XPOS(p))
87 #define PANEL_YPOS(p) (DY + ALIGNED_TEXT_YPOS(p))
89 // game panel display and control definitions
90 #define GAME_PANEL_LEVEL_NUMBER 0
91 #define GAME_PANEL_GEMS 1
92 #define GAME_PANEL_INVENTORY_COUNT 2
93 #define GAME_PANEL_INVENTORY_FIRST_1 3
94 #define GAME_PANEL_INVENTORY_FIRST_2 4
95 #define GAME_PANEL_INVENTORY_FIRST_3 5
96 #define GAME_PANEL_INVENTORY_FIRST_4 6
97 #define GAME_PANEL_INVENTORY_FIRST_5 7
98 #define GAME_PANEL_INVENTORY_FIRST_6 8
99 #define GAME_PANEL_INVENTORY_FIRST_7 9
100 #define GAME_PANEL_INVENTORY_FIRST_8 10
101 #define GAME_PANEL_INVENTORY_LAST_1 11
102 #define GAME_PANEL_INVENTORY_LAST_2 12
103 #define GAME_PANEL_INVENTORY_LAST_3 13
104 #define GAME_PANEL_INVENTORY_LAST_4 14
105 #define GAME_PANEL_INVENTORY_LAST_5 15
106 #define GAME_PANEL_INVENTORY_LAST_6 16
107 #define GAME_PANEL_INVENTORY_LAST_7 17
108 #define GAME_PANEL_INVENTORY_LAST_8 18
109 #define GAME_PANEL_KEY_1 19
110 #define GAME_PANEL_KEY_2 20
111 #define GAME_PANEL_KEY_3 21
112 #define GAME_PANEL_KEY_4 22
113 #define GAME_PANEL_KEY_5 23
114 #define GAME_PANEL_KEY_6 24
115 #define GAME_PANEL_KEY_7 25
116 #define GAME_PANEL_KEY_8 26
117 #define GAME_PANEL_KEY_WHITE 27
118 #define GAME_PANEL_KEY_WHITE_COUNT 28
119 #define GAME_PANEL_SCORE 29
120 #define GAME_PANEL_HIGHSCORE 30
121 #define GAME_PANEL_TIME 31
122 #define GAME_PANEL_TIME_HH 32
123 #define GAME_PANEL_TIME_MM 33
124 #define GAME_PANEL_TIME_SS 34
125 #define GAME_PANEL_TIME_ANIM 35
126 #define GAME_PANEL_HEALTH 36
127 #define GAME_PANEL_HEALTH_ANIM 37
128 #define GAME_PANEL_FRAME 38
129 #define GAME_PANEL_SHIELD_NORMAL 39
130 #define GAME_PANEL_SHIELD_NORMAL_TIME 40
131 #define GAME_PANEL_SHIELD_DEADLY 41
132 #define GAME_PANEL_SHIELD_DEADLY_TIME 42
133 #define GAME_PANEL_EXIT 43
134 #define GAME_PANEL_EMC_MAGIC_BALL 44
135 #define GAME_PANEL_EMC_MAGIC_BALL_SWITCH 45
136 #define GAME_PANEL_LIGHT_SWITCH 46
137 #define GAME_PANEL_LIGHT_SWITCH_TIME 47
138 #define GAME_PANEL_TIMEGATE_SWITCH 48
139 #define GAME_PANEL_TIMEGATE_SWITCH_TIME 49
140 #define GAME_PANEL_SWITCHGATE_SWITCH 50
141 #define GAME_PANEL_EMC_LENSES 51
142 #define GAME_PANEL_EMC_LENSES_TIME 52
143 #define GAME_PANEL_EMC_MAGNIFIER 53
144 #define GAME_PANEL_EMC_MAGNIFIER_TIME 54
145 #define GAME_PANEL_BALLOON_SWITCH 55
146 #define GAME_PANEL_DYNABOMB_NUMBER 56
147 #define GAME_PANEL_DYNABOMB_SIZE 57
148 #define GAME_PANEL_DYNABOMB_POWER 58
149 #define GAME_PANEL_PENGUINS 59
150 #define GAME_PANEL_SOKOBAN_OBJECTS 60
151 #define GAME_PANEL_SOKOBAN_FIELDS 61
152 #define GAME_PANEL_ROBOT_WHEEL 62
153 #define GAME_PANEL_CONVEYOR_BELT_1 63
154 #define GAME_PANEL_CONVEYOR_BELT_2 64
155 #define GAME_PANEL_CONVEYOR_BELT_3 65
156 #define GAME_PANEL_CONVEYOR_BELT_4 66
157 #define GAME_PANEL_CONVEYOR_BELT_1_SWITCH 67
158 #define GAME_PANEL_CONVEYOR_BELT_2_SWITCH 68
159 #define GAME_PANEL_CONVEYOR_BELT_3_SWITCH 69
160 #define GAME_PANEL_CONVEYOR_BELT_4_SWITCH 70
161 #define GAME_PANEL_MAGIC_WALL 71
162 #define GAME_PANEL_MAGIC_WALL_TIME 72
163 #define GAME_PANEL_GRAVITY_STATE 73
164 #define GAME_PANEL_GRAPHIC_1 74
165 #define GAME_PANEL_GRAPHIC_2 75
166 #define GAME_PANEL_GRAPHIC_3 76
167 #define GAME_PANEL_GRAPHIC_4 77
168 #define GAME_PANEL_GRAPHIC_5 78
169 #define GAME_PANEL_GRAPHIC_6 79
170 #define GAME_PANEL_GRAPHIC_7 80
171 #define GAME_PANEL_GRAPHIC_8 81
172 #define GAME_PANEL_ELEMENT_1 82
173 #define GAME_PANEL_ELEMENT_2 83
174 #define GAME_PANEL_ELEMENT_3 84
175 #define GAME_PANEL_ELEMENT_4 85
176 #define GAME_PANEL_ELEMENT_5 86
177 #define GAME_PANEL_ELEMENT_6 87
178 #define GAME_PANEL_ELEMENT_7 88
179 #define GAME_PANEL_ELEMENT_8 89
180 #define GAME_PANEL_ELEMENT_COUNT_1 90
181 #define GAME_PANEL_ELEMENT_COUNT_2 91
182 #define GAME_PANEL_ELEMENT_COUNT_3 92
183 #define GAME_PANEL_ELEMENT_COUNT_4 93
184 #define GAME_PANEL_ELEMENT_COUNT_5 94
185 #define GAME_PANEL_ELEMENT_COUNT_6 95
186 #define GAME_PANEL_ELEMENT_COUNT_7 96
187 #define GAME_PANEL_ELEMENT_COUNT_8 97
188 #define GAME_PANEL_CE_SCORE_1 98
189 #define GAME_PANEL_CE_SCORE_2 99
190 #define GAME_PANEL_CE_SCORE_3 100
191 #define GAME_PANEL_CE_SCORE_4 101
192 #define GAME_PANEL_CE_SCORE_5 102
193 #define GAME_PANEL_CE_SCORE_6 103
194 #define GAME_PANEL_CE_SCORE_7 104
195 #define GAME_PANEL_CE_SCORE_8 105
196 #define GAME_PANEL_CE_SCORE_1_ELEMENT 106
197 #define GAME_PANEL_CE_SCORE_2_ELEMENT 107
198 #define GAME_PANEL_CE_SCORE_3_ELEMENT 108
199 #define GAME_PANEL_CE_SCORE_4_ELEMENT 109
200 #define GAME_PANEL_CE_SCORE_5_ELEMENT 110
201 #define GAME_PANEL_CE_SCORE_6_ELEMENT 111
202 #define GAME_PANEL_CE_SCORE_7_ELEMENT 112
203 #define GAME_PANEL_CE_SCORE_8_ELEMENT 113
204 #define GAME_PANEL_PLAYER_NAME 114
205 #define GAME_PANEL_LEVEL_NAME 115
206 #define GAME_PANEL_LEVEL_AUTHOR 116
208 #define NUM_GAME_PANEL_CONTROLS 117
210 struct GamePanelOrderInfo
216 static struct GamePanelOrderInfo game_panel_order[NUM_GAME_PANEL_CONTROLS];
218 struct GamePanelControlInfo
222 struct TextPosInfo *pos;
225 int graphic, graphic_active;
227 int value, last_value;
228 int frame, last_frame;
233 static struct GamePanelControlInfo game_panel_controls[] =
236 GAME_PANEL_LEVEL_NUMBER,
237 &game.panel.level_number,
246 GAME_PANEL_INVENTORY_COUNT,
247 &game.panel.inventory_count,
251 GAME_PANEL_INVENTORY_FIRST_1,
252 &game.panel.inventory_first[0],
256 GAME_PANEL_INVENTORY_FIRST_2,
257 &game.panel.inventory_first[1],
261 GAME_PANEL_INVENTORY_FIRST_3,
262 &game.panel.inventory_first[2],
266 GAME_PANEL_INVENTORY_FIRST_4,
267 &game.panel.inventory_first[3],
271 GAME_PANEL_INVENTORY_FIRST_5,
272 &game.panel.inventory_first[4],
276 GAME_PANEL_INVENTORY_FIRST_6,
277 &game.panel.inventory_first[5],
281 GAME_PANEL_INVENTORY_FIRST_7,
282 &game.panel.inventory_first[6],
286 GAME_PANEL_INVENTORY_FIRST_8,
287 &game.panel.inventory_first[7],
291 GAME_PANEL_INVENTORY_LAST_1,
292 &game.panel.inventory_last[0],
296 GAME_PANEL_INVENTORY_LAST_2,
297 &game.panel.inventory_last[1],
301 GAME_PANEL_INVENTORY_LAST_3,
302 &game.panel.inventory_last[2],
306 GAME_PANEL_INVENTORY_LAST_4,
307 &game.panel.inventory_last[3],
311 GAME_PANEL_INVENTORY_LAST_5,
312 &game.panel.inventory_last[4],
316 GAME_PANEL_INVENTORY_LAST_6,
317 &game.panel.inventory_last[5],
321 GAME_PANEL_INVENTORY_LAST_7,
322 &game.panel.inventory_last[6],
326 GAME_PANEL_INVENTORY_LAST_8,
327 &game.panel.inventory_last[7],
371 GAME_PANEL_KEY_WHITE,
372 &game.panel.key_white,
376 GAME_PANEL_KEY_WHITE_COUNT,
377 &game.panel.key_white_count,
386 GAME_PANEL_HIGHSCORE,
387 &game.panel.highscore,
411 GAME_PANEL_TIME_ANIM,
412 &game.panel.time_anim,
415 IMG_GFX_GAME_PANEL_TIME_ANIM,
416 IMG_GFX_GAME_PANEL_TIME_ANIM_ACTIVE
424 GAME_PANEL_HEALTH_ANIM,
425 &game.panel.health_anim,
428 IMG_GFX_GAME_PANEL_HEALTH_ANIM,
429 IMG_GFX_GAME_PANEL_HEALTH_ANIM_ACTIVE
437 GAME_PANEL_SHIELD_NORMAL,
438 &game.panel.shield_normal,
442 GAME_PANEL_SHIELD_NORMAL_TIME,
443 &game.panel.shield_normal_time,
447 GAME_PANEL_SHIELD_DEADLY,
448 &game.panel.shield_deadly,
452 GAME_PANEL_SHIELD_DEADLY_TIME,
453 &game.panel.shield_deadly_time,
462 GAME_PANEL_EMC_MAGIC_BALL,
463 &game.panel.emc_magic_ball,
467 GAME_PANEL_EMC_MAGIC_BALL_SWITCH,
468 &game.panel.emc_magic_ball_switch,
472 GAME_PANEL_LIGHT_SWITCH,
473 &game.panel.light_switch,
477 GAME_PANEL_LIGHT_SWITCH_TIME,
478 &game.panel.light_switch_time,
482 GAME_PANEL_TIMEGATE_SWITCH,
483 &game.panel.timegate_switch,
487 GAME_PANEL_TIMEGATE_SWITCH_TIME,
488 &game.panel.timegate_switch_time,
492 GAME_PANEL_SWITCHGATE_SWITCH,
493 &game.panel.switchgate_switch,
497 GAME_PANEL_EMC_LENSES,
498 &game.panel.emc_lenses,
502 GAME_PANEL_EMC_LENSES_TIME,
503 &game.panel.emc_lenses_time,
507 GAME_PANEL_EMC_MAGNIFIER,
508 &game.panel.emc_magnifier,
512 GAME_PANEL_EMC_MAGNIFIER_TIME,
513 &game.panel.emc_magnifier_time,
517 GAME_PANEL_BALLOON_SWITCH,
518 &game.panel.balloon_switch,
522 GAME_PANEL_DYNABOMB_NUMBER,
523 &game.panel.dynabomb_number,
527 GAME_PANEL_DYNABOMB_SIZE,
528 &game.panel.dynabomb_size,
532 GAME_PANEL_DYNABOMB_POWER,
533 &game.panel.dynabomb_power,
538 &game.panel.penguins,
542 GAME_PANEL_SOKOBAN_OBJECTS,
543 &game.panel.sokoban_objects,
547 GAME_PANEL_SOKOBAN_FIELDS,
548 &game.panel.sokoban_fields,
552 GAME_PANEL_ROBOT_WHEEL,
553 &game.panel.robot_wheel,
557 GAME_PANEL_CONVEYOR_BELT_1,
558 &game.panel.conveyor_belt[0],
562 GAME_PANEL_CONVEYOR_BELT_2,
563 &game.panel.conveyor_belt[1],
567 GAME_PANEL_CONVEYOR_BELT_3,
568 &game.panel.conveyor_belt[2],
572 GAME_PANEL_CONVEYOR_BELT_4,
573 &game.panel.conveyor_belt[3],
577 GAME_PANEL_CONVEYOR_BELT_1_SWITCH,
578 &game.panel.conveyor_belt_switch[0],
582 GAME_PANEL_CONVEYOR_BELT_2_SWITCH,
583 &game.panel.conveyor_belt_switch[1],
587 GAME_PANEL_CONVEYOR_BELT_3_SWITCH,
588 &game.panel.conveyor_belt_switch[2],
592 GAME_PANEL_CONVEYOR_BELT_4_SWITCH,
593 &game.panel.conveyor_belt_switch[3],
597 GAME_PANEL_MAGIC_WALL,
598 &game.panel.magic_wall,
602 GAME_PANEL_MAGIC_WALL_TIME,
603 &game.panel.magic_wall_time,
607 GAME_PANEL_GRAVITY_STATE,
608 &game.panel.gravity_state,
612 GAME_PANEL_GRAPHIC_1,
613 &game.panel.graphic[0],
617 GAME_PANEL_GRAPHIC_2,
618 &game.panel.graphic[1],
622 GAME_PANEL_GRAPHIC_3,
623 &game.panel.graphic[2],
627 GAME_PANEL_GRAPHIC_4,
628 &game.panel.graphic[3],
632 GAME_PANEL_GRAPHIC_5,
633 &game.panel.graphic[4],
637 GAME_PANEL_GRAPHIC_6,
638 &game.panel.graphic[5],
642 GAME_PANEL_GRAPHIC_7,
643 &game.panel.graphic[6],
647 GAME_PANEL_GRAPHIC_8,
648 &game.panel.graphic[7],
652 GAME_PANEL_ELEMENT_1,
653 &game.panel.element[0],
657 GAME_PANEL_ELEMENT_2,
658 &game.panel.element[1],
662 GAME_PANEL_ELEMENT_3,
663 &game.panel.element[2],
667 GAME_PANEL_ELEMENT_4,
668 &game.panel.element[3],
672 GAME_PANEL_ELEMENT_5,
673 &game.panel.element[4],
677 GAME_PANEL_ELEMENT_6,
678 &game.panel.element[5],
682 GAME_PANEL_ELEMENT_7,
683 &game.panel.element[6],
687 GAME_PANEL_ELEMENT_8,
688 &game.panel.element[7],
692 GAME_PANEL_ELEMENT_COUNT_1,
693 &game.panel.element_count[0],
697 GAME_PANEL_ELEMENT_COUNT_2,
698 &game.panel.element_count[1],
702 GAME_PANEL_ELEMENT_COUNT_3,
703 &game.panel.element_count[2],
707 GAME_PANEL_ELEMENT_COUNT_4,
708 &game.panel.element_count[3],
712 GAME_PANEL_ELEMENT_COUNT_5,
713 &game.panel.element_count[4],
717 GAME_PANEL_ELEMENT_COUNT_6,
718 &game.panel.element_count[5],
722 GAME_PANEL_ELEMENT_COUNT_7,
723 &game.panel.element_count[6],
727 GAME_PANEL_ELEMENT_COUNT_8,
728 &game.panel.element_count[7],
732 GAME_PANEL_CE_SCORE_1,
733 &game.panel.ce_score[0],
737 GAME_PANEL_CE_SCORE_2,
738 &game.panel.ce_score[1],
742 GAME_PANEL_CE_SCORE_3,
743 &game.panel.ce_score[2],
747 GAME_PANEL_CE_SCORE_4,
748 &game.panel.ce_score[3],
752 GAME_PANEL_CE_SCORE_5,
753 &game.panel.ce_score[4],
757 GAME_PANEL_CE_SCORE_6,
758 &game.panel.ce_score[5],
762 GAME_PANEL_CE_SCORE_7,
763 &game.panel.ce_score[6],
767 GAME_PANEL_CE_SCORE_8,
768 &game.panel.ce_score[7],
772 GAME_PANEL_CE_SCORE_1_ELEMENT,
773 &game.panel.ce_score_element[0],
777 GAME_PANEL_CE_SCORE_2_ELEMENT,
778 &game.panel.ce_score_element[1],
782 GAME_PANEL_CE_SCORE_3_ELEMENT,
783 &game.panel.ce_score_element[2],
787 GAME_PANEL_CE_SCORE_4_ELEMENT,
788 &game.panel.ce_score_element[3],
792 GAME_PANEL_CE_SCORE_5_ELEMENT,
793 &game.panel.ce_score_element[4],
797 GAME_PANEL_CE_SCORE_6_ELEMENT,
798 &game.panel.ce_score_element[5],
802 GAME_PANEL_CE_SCORE_7_ELEMENT,
803 &game.panel.ce_score_element[6],
807 GAME_PANEL_CE_SCORE_8_ELEMENT,
808 &game.panel.ce_score_element[7],
812 GAME_PANEL_PLAYER_NAME,
813 &game.panel.player_name,
817 GAME_PANEL_LEVEL_NAME,
818 &game.panel.level_name,
822 GAME_PANEL_LEVEL_AUTHOR,
823 &game.panel.level_author,
834 // values for delayed check of falling and moving elements and for collision
835 #define CHECK_DELAY_MOVING 3
836 #define CHECK_DELAY_FALLING CHECK_DELAY_MOVING
837 #define CHECK_DELAY_COLLISION 2
838 #define CHECK_DELAY_IMPACT CHECK_DELAY_COLLISION
840 // values for initial player move delay (initial delay counter value)
841 #define INITIAL_MOVE_DELAY_OFF -1
842 #define INITIAL_MOVE_DELAY_ON 0
844 // values for player movement speed (which is in fact a delay value)
845 #define MOVE_DELAY_MIN_SPEED 32
846 #define MOVE_DELAY_NORMAL_SPEED 8
847 #define MOVE_DELAY_HIGH_SPEED 4
848 #define MOVE_DELAY_MAX_SPEED 1
850 #define DOUBLE_MOVE_DELAY(x) (x = (x < MOVE_DELAY_MIN_SPEED ? x * 2 : x))
851 #define HALVE_MOVE_DELAY(x) (x = (x > MOVE_DELAY_MAX_SPEED ? x / 2 : x))
853 #define DOUBLE_PLAYER_SPEED(p) (HALVE_MOVE_DELAY( (p)->move_delay_value))
854 #define HALVE_PLAYER_SPEED(p) (DOUBLE_MOVE_DELAY((p)->move_delay_value))
856 // values for scroll positions
857 #define SCROLL_POSITION_X(x) ((x) < SBX_Left + MIDPOSX ? SBX_Left : \
858 (x) > SBX_Right + MIDPOSX ? SBX_Right :\
860 #define SCROLL_POSITION_Y(y) ((y) < SBY_Upper + MIDPOSY ? SBY_Upper :\
861 (y) > SBY_Lower + MIDPOSY ? SBY_Lower :\
864 // values for other actions
865 #define MOVE_STEPSIZE_NORMAL (TILEX / MOVE_DELAY_NORMAL_SPEED)
866 #define MOVE_STEPSIZE_MIN (1)
867 #define MOVE_STEPSIZE_MAX (TILEX)
869 #define GET_DX_FROM_DIR(d) ((d) == MV_LEFT ? -1 : (d) == MV_RIGHT ? 1 : 0)
870 #define GET_DY_FROM_DIR(d) ((d) == MV_UP ? -1 : (d) == MV_DOWN ? 1 : 0)
872 #define INIT_GFX_RANDOM() (GetSimpleRandom(1000000))
874 #define GET_NEW_PUSH_DELAY(e) ( (element_info[e].push_delay_fixed) + \
875 RND(element_info[e].push_delay_random))
876 #define GET_NEW_DROP_DELAY(e) ( (element_info[e].drop_delay_fixed) + \
877 RND(element_info[e].drop_delay_random))
878 #define GET_NEW_MOVE_DELAY(e) ( (element_info[e].move_delay_fixed) + \
879 RND(element_info[e].move_delay_random))
880 #define GET_MAX_MOVE_DELAY(e) ( (element_info[e].move_delay_fixed) + \
881 (element_info[e].move_delay_random))
882 #define GET_NEW_STEP_DELAY(e) ( (element_info[e].step_delay_fixed) + \
883 RND(element_info[e].step_delay_random))
884 #define GET_MAX_STEP_DELAY(e) ( (element_info[e].step_delay_fixed) + \
885 (element_info[e].step_delay_random))
886 #define GET_NEW_CE_VALUE(e) ( (element_info[e].ce_value_fixed_initial) +\
887 RND(element_info[e].ce_value_random_initial))
888 #define GET_CE_SCORE(e) ( (element_info[e].collect_score))
889 #define GET_CHANGE_DELAY(c) ( ((c)->delay_fixed * (c)->delay_frames) + \
890 RND((c)->delay_random * (c)->delay_frames))
891 #define GET_CE_DELAY_VALUE(c) ( ((c)->delay_fixed) + \
892 RND((c)->delay_random))
895 #define GET_VALID_RUNTIME_ELEMENT(e) \
896 ((e) >= NUM_RUNTIME_ELEMENTS ? EL_UNKNOWN : (e))
898 #define RESOLVED_REFERENCE_ELEMENT(be, e) \
899 ((be) + (e) - EL_SELF < EL_CUSTOM_START ? EL_CUSTOM_START : \
900 (be) + (e) - EL_SELF > EL_CUSTOM_END ? EL_CUSTOM_END : \
901 (be) + (e) - EL_SELF)
903 #define GET_PLAYER_FROM_BITS(p) \
904 (EL_PLAYER_1 + ((p) != PLAYER_BITS_ANY ? log_2(p) : 0))
906 #define GET_TARGET_ELEMENT(be, e, ch, cv, cs) \
907 ((e) == EL_TRIGGER_PLAYER ? (ch)->actual_trigger_player : \
908 (e) == EL_TRIGGER_ELEMENT ? (ch)->actual_trigger_element : \
909 (e) == EL_TRIGGER_CE_VALUE ? (ch)->actual_trigger_ce_value : \
910 (e) == EL_TRIGGER_CE_SCORE ? (ch)->actual_trigger_ce_score : \
911 (e) == EL_CURRENT_CE_VALUE ? (cv) : \
912 (e) == EL_CURRENT_CE_SCORE ? (cs) : \
913 (e) >= EL_PREV_CE_8 && (e) <= EL_NEXT_CE_8 ? \
914 RESOLVED_REFERENCE_ELEMENT(be, e) : \
917 #define CAN_GROW_INTO(e) \
918 ((e) == EL_SAND || (IS_DIGGABLE(e) && level.grow_into_diggable))
920 #define ELEMENT_CAN_ENTER_FIELD_BASE_X(x, y, condition) \
921 (IN_LEV_FIELD(x, y) && (IS_FREE(x, y) || \
924 #define ELEMENT_CAN_ENTER_FIELD_BASE_2(e, x, y, condition) \
925 (IN_LEV_FIELD(x, y) && (IS_FREE(x, y) || \
926 (CAN_MOVE_INTO_ACID(e) && \
927 Tile[x][y] == EL_ACID) || \
930 #define ELEMENT_CAN_ENTER_FIELD_BASE_3(e, x, y, condition) \
931 (IN_LEV_FIELD(x, y) && (IS_FREE_OR_PLAYER(x, y) || \
932 (CAN_MOVE_INTO_ACID(e) && \
933 Tile[x][y] == EL_ACID) || \
936 #define ELEMENT_CAN_ENTER_FIELD_BASE_4(e, x, y, condition) \
937 (IN_LEV_FIELD(x, y) && (IS_FREE(x, y) || \
939 (CAN_MOVE_INTO_ACID(e) && \
940 Tile[x][y] == EL_ACID) || \
941 (DONT_COLLIDE_WITH(e) && \
943 !PLAYER_ENEMY_PROTECTED(x, y))))
945 #define ELEMENT_CAN_ENTER_FIELD(e, x, y) \
946 ELEMENT_CAN_ENTER_FIELD_BASE_4(e, x, y, 0)
948 #define SATELLITE_CAN_ENTER_FIELD(x, y) \
949 ELEMENT_CAN_ENTER_FIELD_BASE_2(EL_SATELLITE, x, y, 0)
951 #define ANDROID_CAN_ENTER_FIELD(e, x, y) \
952 ELEMENT_CAN_ENTER_FIELD_BASE_2(e, x, y, Tile[x][y] == EL_EMC_PLANT)
954 #define ANDROID_CAN_CLONE_FIELD(x, y) \
955 (IN_LEV_FIELD(x, y) && (CAN_BE_CLONED_BY_ANDROID(Tile[x][y]) || \
956 CAN_BE_CLONED_BY_ANDROID(EL_TRIGGER_ELEMENT)))
958 #define ENEMY_CAN_ENTER_FIELD(e, x, y) \
959 ELEMENT_CAN_ENTER_FIELD_BASE_2(e, x, y, 0)
961 #define YAMYAM_CAN_ENTER_FIELD(e, x, y) \
962 ELEMENT_CAN_ENTER_FIELD_BASE_3(e, x, y, Tile[x][y] == EL_DIAMOND)
964 #define DARK_YAMYAM_CAN_ENTER_FIELD(e, x, y) \
965 ELEMENT_CAN_ENTER_FIELD_BASE_3(e, x,y, IS_FOOD_DARK_YAMYAM(Tile[x][y]))
967 #define PACMAN_CAN_ENTER_FIELD(e, x, y) \
968 ELEMENT_CAN_ENTER_FIELD_BASE_3(e, x, y, IS_AMOEBOID(Tile[x][y]))
970 #define PIG_CAN_ENTER_FIELD(e, x, y) \
971 ELEMENT_CAN_ENTER_FIELD_BASE_2(e, x, y, IS_FOOD_PIG(Tile[x][y]))
973 #define PENGUIN_CAN_ENTER_FIELD(e, x, y) \
974 ELEMENT_CAN_ENTER_FIELD_BASE_2(e, x, y, (Tile[x][y] == EL_EXIT_OPEN || \
975 Tile[x][y] == EL_EM_EXIT_OPEN || \
976 Tile[x][y] == EL_STEEL_EXIT_OPEN || \
977 Tile[x][y] == EL_EM_STEEL_EXIT_OPEN || \
978 IS_FOOD_PENGUIN(Tile[x][y])))
979 #define DRAGON_CAN_ENTER_FIELD(e, x, y) \
980 ELEMENT_CAN_ENTER_FIELD_BASE_2(e, x, y, 0)
982 #define MOLE_CAN_ENTER_FIELD(e, x, y, condition) \
983 ELEMENT_CAN_ENTER_FIELD_BASE_2(e, x, y, (condition))
985 #define SPRING_CAN_ENTER_FIELD(e, x, y) \
986 ELEMENT_CAN_ENTER_FIELD_BASE_2(e, x, y, 0)
988 #define SPRING_CAN_BUMP_FROM_FIELD(x, y) \
989 (IN_LEV_FIELD(x, y) && (Tile[x][y] == EL_EMC_SPRING_BUMPER || \
990 Tile[x][y] == EL_EMC_SPRING_BUMPER_ACTIVE))
992 #define MOVE_ENTER_EL(e) (element_info[e].move_enter_element)
994 #define CE_ENTER_FIELD_COND(e, x, y) \
995 (!IS_PLAYER(x, y) && \
996 IS_EQUAL_OR_IN_GROUP(Tile[x][y], MOVE_ENTER_EL(e)))
998 #define CUSTOM_ELEMENT_CAN_ENTER_FIELD(e, x, y) \
999 ELEMENT_CAN_ENTER_FIELD_BASE_4(e, x, y, CE_ENTER_FIELD_COND(e, x, y))
1001 #define IN_LEV_FIELD_AND_IS_FREE(x, y) (IN_LEV_FIELD(x, y) && IS_FREE(x, y))
1002 #define IN_LEV_FIELD_AND_NOT_FREE(x, y) (IN_LEV_FIELD(x, y) && !IS_FREE(x, y))
1004 #define ACCESS_FROM(e, d) (element_info[e].access_direction &(d))
1005 #define IS_WALKABLE_FROM(e, d) (IS_WALKABLE(e) && ACCESS_FROM(e, d))
1006 #define IS_PASSABLE_FROM(e, d) (IS_PASSABLE(e) && ACCESS_FROM(e, d))
1007 #define IS_ACCESSIBLE_FROM(e, d) (IS_ACCESSIBLE(e) && ACCESS_FROM(e, d))
1009 #define MM_HEALTH(x) (MIN(MAX(0, MAX_HEALTH - (x)), MAX_HEALTH))
1011 // game button identifiers
1012 #define GAME_CTRL_ID_STOP 0
1013 #define GAME_CTRL_ID_PAUSE 1
1014 #define GAME_CTRL_ID_PLAY 2
1015 #define GAME_CTRL_ID_UNDO 3
1016 #define GAME_CTRL_ID_REDO 4
1017 #define GAME_CTRL_ID_SAVE 5
1018 #define GAME_CTRL_ID_PAUSE2 6
1019 #define GAME_CTRL_ID_LOAD 7
1020 #define GAME_CTRL_ID_PANEL_STOP 8
1021 #define GAME_CTRL_ID_PANEL_PAUSE 9
1022 #define GAME_CTRL_ID_PANEL_PLAY 10
1023 #define GAME_CTRL_ID_TOUCH_STOP 11
1024 #define GAME_CTRL_ID_TOUCH_PAUSE 12
1025 #define SOUND_CTRL_ID_MUSIC 13
1026 #define SOUND_CTRL_ID_LOOPS 14
1027 #define SOUND_CTRL_ID_SIMPLE 15
1028 #define SOUND_CTRL_ID_PANEL_MUSIC 16
1029 #define SOUND_CTRL_ID_PANEL_LOOPS 17
1030 #define SOUND_CTRL_ID_PANEL_SIMPLE 18
1032 #define NUM_GAME_BUTTONS 19
1035 // forward declaration for internal use
1037 static void CreateField(int, int, int);
1039 static void ResetGfxAnimation(int, int);
1041 static void SetPlayerWaiting(struct PlayerInfo *, boolean);
1042 static void AdvanceFrameAndPlayerCounters(int);
1044 static boolean MovePlayerOneStep(struct PlayerInfo *, int, int, int, int);
1045 static boolean MovePlayer(struct PlayerInfo *, int, int);
1046 static void ScrollPlayer(struct PlayerInfo *, int);
1047 static void ScrollScreen(struct PlayerInfo *, int);
1049 static int DigField(struct PlayerInfo *, int, int, int, int, int, int, int);
1050 static boolean DigFieldByCE(int, int, int);
1051 static boolean SnapField(struct PlayerInfo *, int, int);
1052 static boolean DropElement(struct PlayerInfo *);
1054 static void InitBeltMovement(void);
1055 static void CloseAllOpenTimegates(void);
1056 static void CheckGravityMovement(struct PlayerInfo *);
1057 static void CheckGravityMovementWhenNotMoving(struct PlayerInfo *);
1058 static void KillPlayerUnlessEnemyProtected(int, int);
1059 static void KillPlayerUnlessExplosionProtected(int, int);
1061 static void TestIfPlayerTouchesCustomElement(int, int);
1062 static void TestIfElementTouchesCustomElement(int, int);
1063 static void TestIfElementHitsCustomElement(int, int, int);
1065 static void HandleElementChange(int, int, int);
1066 static void ExecuteCustomElementAction(int, int, int, int);
1067 static boolean ChangeElement(int, int, int, int);
1069 static boolean CheckTriggeredElementChangeExt(int, int, int, int, int,int,int);
1070 #define CheckTriggeredElementChange(x, y, e, ev) \
1071 CheckTriggeredElementChangeExt(x,y,e,ev, CH_PLAYER_ANY,CH_SIDE_ANY, -1)
1072 #define CheckTriggeredElementChangeByPlayer(x, y, e, ev, p, s) \
1073 CheckTriggeredElementChangeExt(x, y, e, ev, p, s, -1)
1074 #define CheckTriggeredElementChangeBySide(x, y, e, ev, s) \
1075 CheckTriggeredElementChangeExt(x, y, e, ev, CH_PLAYER_ANY, s, -1)
1076 #define CheckTriggeredElementChangeByPage(x, y, e, ev, p) \
1077 CheckTriggeredElementChangeExt(x,y,e,ev, CH_PLAYER_ANY, CH_SIDE_ANY, p)
1078 #define CheckTriggeredElementChangeByMouse(x, y, e, ev, s) \
1079 CheckTriggeredElementChangeExt(x, y, e, ev, CH_PLAYER_ANY, s, -1)
1081 static boolean CheckElementChangeExt(int, int, int, int, int, int, int);
1082 #define CheckElementChange(x, y, e, te, ev) \
1083 CheckElementChangeExt(x, y, e, te, ev, CH_PLAYER_ANY, CH_SIDE_ANY)
1084 #define CheckElementChangeByPlayer(x, y, e, ev, p, s) \
1085 CheckElementChangeExt(x, y, e, EL_EMPTY, ev, p, s)
1086 #define CheckElementChangeBySide(x, y, e, te, ev, s) \
1087 CheckElementChangeExt(x, y, e, te, ev, CH_PLAYER_ANY, s)
1088 #define CheckElementChangeByMouse(x, y, e, ev, s) \
1089 CheckElementChangeExt(x, y, e, EL_UNDEFINED, ev, CH_PLAYER_ANY, s)
1091 static void PlayLevelSound(int, int, int);
1092 static void PlayLevelSoundNearest(int, int, int);
1093 static void PlayLevelSoundAction(int, int, int);
1094 static void PlayLevelSoundElementAction(int, int, int, int);
1095 static void PlayLevelSoundElementActionIfLoop(int, int, int, int);
1096 static void PlayLevelSoundActionIfLoop(int, int, int);
1097 static void StopLevelSoundActionIfLoop(int, int, int);
1098 static void PlayLevelMusic(void);
1099 static void FadeLevelSoundsAndMusic(void);
1101 static void HandleGameButtons(struct GadgetInfo *);
1103 int AmoebaNeighbourNr(int, int);
1104 void AmoebaToDiamond(int, int);
1105 void ContinueMoving(int, int);
1106 void Bang(int, int);
1107 void InitMovDir(int, int);
1108 void InitAmoebaNr(int, int);
1109 int NewHiScore(int);
1111 void TestIfGoodThingHitsBadThing(int, int, int);
1112 void TestIfBadThingHitsGoodThing(int, int, int);
1113 void TestIfPlayerTouchesBadThing(int, int);
1114 void TestIfPlayerRunsIntoBadThing(int, int, int);
1115 void TestIfBadThingTouchesPlayer(int, int);
1116 void TestIfBadThingRunsIntoPlayer(int, int, int);
1117 void TestIfFriendTouchesBadThing(int, int);
1118 void TestIfBadThingTouchesFriend(int, int);
1119 void TestIfBadThingTouchesOtherBadThing(int, int);
1120 void TestIfGoodThingGetsHitByBadThing(int, int, int);
1122 void KillPlayer(struct PlayerInfo *);
1123 void BuryPlayer(struct PlayerInfo *);
1124 void RemovePlayer(struct PlayerInfo *);
1125 void ExitPlayer(struct PlayerInfo *);
1127 static int getInvisibleActiveFromInvisibleElement(int);
1128 static int getInvisibleFromInvisibleActiveElement(int);
1130 static void TestFieldAfterSnapping(int, int, int, int, int);
1132 static struct GadgetInfo *game_gadget[NUM_GAME_BUTTONS];
1134 // for detection of endless loops, caused by custom element programming
1135 // (using maximal playfield width x 10 is just a rough approximation)
1136 #define MAX_ELEMENT_CHANGE_RECURSION_DEPTH (MAX_PLAYFIELD_WIDTH * 10)
1138 #define RECURSION_LOOP_DETECTION_START(e, rc) \
1140 if (recursion_loop_detected) \
1143 if (recursion_loop_depth > MAX_ELEMENT_CHANGE_RECURSION_DEPTH) \
1145 recursion_loop_detected = TRUE; \
1146 recursion_loop_element = (e); \
1149 recursion_loop_depth++; \
1152 #define RECURSION_LOOP_DETECTION_END() \
1154 recursion_loop_depth--; \
1157 static int recursion_loop_depth;
1158 static boolean recursion_loop_detected;
1159 static boolean recursion_loop_element;
1161 static int map_player_action[MAX_PLAYERS];
1164 // ----------------------------------------------------------------------------
1165 // definition of elements that automatically change to other elements after
1166 // a specified time, eventually calling a function when changing
1167 // ----------------------------------------------------------------------------
1169 // forward declaration for changer functions
1170 static void InitBuggyBase(int, int);
1171 static void WarnBuggyBase(int, int);
1173 static void InitTrap(int, int);
1174 static void ActivateTrap(int, int);
1175 static void ChangeActiveTrap(int, int);
1177 static void InitRobotWheel(int, int);
1178 static void RunRobotWheel(int, int);
1179 static void StopRobotWheel(int, int);
1181 static void InitTimegateWheel(int, int);
1182 static void RunTimegateWheel(int, int);
1184 static void InitMagicBallDelay(int, int);
1185 static void ActivateMagicBall(int, int);
1187 struct ChangingElementInfo
1192 void (*pre_change_function)(int x, int y);
1193 void (*change_function)(int x, int y);
1194 void (*post_change_function)(int x, int y);
1197 static struct ChangingElementInfo change_delay_list[] =
1232 EL_STEEL_EXIT_OPENING,
1240 EL_STEEL_EXIT_CLOSING,
1241 EL_STEEL_EXIT_CLOSED,
1264 EL_EM_STEEL_EXIT_OPENING,
1265 EL_EM_STEEL_EXIT_OPEN,
1272 EL_EM_STEEL_EXIT_CLOSING,
1296 EL_SWITCHGATE_OPENING,
1304 EL_SWITCHGATE_CLOSING,
1305 EL_SWITCHGATE_CLOSED,
1312 EL_TIMEGATE_OPENING,
1320 EL_TIMEGATE_CLOSING,
1329 EL_ACID_SPLASH_LEFT,
1337 EL_ACID_SPLASH_RIGHT,
1346 EL_SP_BUGGY_BASE_ACTIVATING,
1353 EL_SP_BUGGY_BASE_ACTIVATING,
1354 EL_SP_BUGGY_BASE_ACTIVE,
1361 EL_SP_BUGGY_BASE_ACTIVE,
1385 EL_ROBOT_WHEEL_ACTIVE,
1393 EL_TIMEGATE_SWITCH_ACTIVE,
1401 EL_DC_TIMEGATE_SWITCH_ACTIVE,
1402 EL_DC_TIMEGATE_SWITCH,
1409 EL_EMC_MAGIC_BALL_ACTIVE,
1410 EL_EMC_MAGIC_BALL_ACTIVE,
1417 EL_EMC_SPRING_BUMPER_ACTIVE,
1418 EL_EMC_SPRING_BUMPER,
1425 EL_DIAGONAL_SHRINKING,
1433 EL_DIAGONAL_GROWING,
1454 int push_delay_fixed, push_delay_random;
1458 { EL_SPRING, 0, 0 },
1459 { EL_BALLOON, 0, 0 },
1461 { EL_SOKOBAN_OBJECT, 2, 0 },
1462 { EL_SOKOBAN_FIELD_FULL, 2, 0 },
1463 { EL_SATELLITE, 2, 0 },
1464 { EL_SP_DISK_YELLOW, 2, 0 },
1466 { EL_UNDEFINED, 0, 0 },
1474 move_stepsize_list[] =
1476 { EL_AMOEBA_DROP, 2 },
1477 { EL_AMOEBA_DROPPING, 2 },
1478 { EL_QUICKSAND_FILLING, 1 },
1479 { EL_QUICKSAND_EMPTYING, 1 },
1480 { EL_QUICKSAND_FAST_FILLING, 2 },
1481 { EL_QUICKSAND_FAST_EMPTYING, 2 },
1482 { EL_MAGIC_WALL_FILLING, 2 },
1483 { EL_MAGIC_WALL_EMPTYING, 2 },
1484 { EL_BD_MAGIC_WALL_FILLING, 2 },
1485 { EL_BD_MAGIC_WALL_EMPTYING, 2 },
1486 { EL_DC_MAGIC_WALL_FILLING, 2 },
1487 { EL_DC_MAGIC_WALL_EMPTYING, 2 },
1489 { EL_UNDEFINED, 0 },
1497 collect_count_list[] =
1500 { EL_BD_DIAMOND, 1 },
1501 { EL_EMERALD_YELLOW, 1 },
1502 { EL_EMERALD_RED, 1 },
1503 { EL_EMERALD_PURPLE, 1 },
1505 { EL_SP_INFOTRON, 1 },
1509 { EL_UNDEFINED, 0 },
1517 access_direction_list[] =
1519 { EL_TUBE_ANY, MV_LEFT | MV_RIGHT | MV_UP | MV_DOWN },
1520 { EL_TUBE_VERTICAL, MV_UP | MV_DOWN },
1521 { EL_TUBE_HORIZONTAL, MV_LEFT | MV_RIGHT },
1522 { EL_TUBE_VERTICAL_LEFT, MV_LEFT | MV_UP | MV_DOWN },
1523 { EL_TUBE_VERTICAL_RIGHT, MV_RIGHT | MV_UP | MV_DOWN },
1524 { EL_TUBE_HORIZONTAL_UP, MV_LEFT | MV_RIGHT | MV_UP },
1525 { EL_TUBE_HORIZONTAL_DOWN, MV_LEFT | MV_RIGHT | MV_DOWN },
1526 { EL_TUBE_LEFT_UP, MV_LEFT | MV_UP },
1527 { EL_TUBE_LEFT_DOWN, MV_LEFT | MV_DOWN },
1528 { EL_TUBE_RIGHT_UP, MV_RIGHT | MV_UP },
1529 { EL_TUBE_RIGHT_DOWN, MV_RIGHT | MV_DOWN },
1531 { EL_SP_PORT_LEFT, MV_RIGHT },
1532 { EL_SP_PORT_RIGHT, MV_LEFT },
1533 { EL_SP_PORT_UP, MV_DOWN },
1534 { EL_SP_PORT_DOWN, MV_UP },
1535 { EL_SP_PORT_HORIZONTAL, MV_LEFT | MV_RIGHT },
1536 { EL_SP_PORT_VERTICAL, MV_UP | MV_DOWN },
1537 { EL_SP_PORT_ANY, MV_LEFT | MV_RIGHT | MV_UP | MV_DOWN },
1538 { EL_SP_GRAVITY_PORT_LEFT, MV_RIGHT },
1539 { EL_SP_GRAVITY_PORT_RIGHT, MV_LEFT },
1540 { EL_SP_GRAVITY_PORT_UP, MV_DOWN },
1541 { EL_SP_GRAVITY_PORT_DOWN, MV_UP },
1542 { EL_SP_GRAVITY_ON_PORT_LEFT, MV_RIGHT },
1543 { EL_SP_GRAVITY_ON_PORT_RIGHT, MV_LEFT },
1544 { EL_SP_GRAVITY_ON_PORT_UP, MV_DOWN },
1545 { EL_SP_GRAVITY_ON_PORT_DOWN, MV_UP },
1546 { EL_SP_GRAVITY_OFF_PORT_LEFT, MV_RIGHT },
1547 { EL_SP_GRAVITY_OFF_PORT_RIGHT, MV_LEFT },
1548 { EL_SP_GRAVITY_OFF_PORT_UP, MV_DOWN },
1549 { EL_SP_GRAVITY_OFF_PORT_DOWN, MV_UP },
1551 { EL_UNDEFINED, MV_NONE }
1554 static boolean trigger_events[MAX_NUM_ELEMENTS][NUM_CHANGE_EVENTS];
1556 #define IS_AUTO_CHANGING(e) (element_info[e].has_change_event[CE_DELAY])
1557 #define IS_JUST_CHANGING(x, y) (ChangeDelay[x][y] != 0)
1558 #define IS_CHANGING(x, y) (IS_AUTO_CHANGING(Tile[x][y]) || \
1559 IS_JUST_CHANGING(x, y))
1561 #define CE_PAGE(e, ce) (element_info[e].event_page[ce])
1563 // static variables for playfield scan mode (scanning forward or backward)
1564 static int playfield_scan_start_x = 0;
1565 static int playfield_scan_start_y = 0;
1566 static int playfield_scan_delta_x = 1;
1567 static int playfield_scan_delta_y = 1;
1569 #define SCAN_PLAYFIELD(x, y) for ((y) = playfield_scan_start_y; \
1570 (y) >= 0 && (y) <= lev_fieldy - 1; \
1571 (y) += playfield_scan_delta_y) \
1572 for ((x) = playfield_scan_start_x; \
1573 (x) >= 0 && (x) <= lev_fieldx - 1; \
1574 (x) += playfield_scan_delta_x)
1577 void DEBUG_SetMaximumDynamite(void)
1581 for (i = 0; i < MAX_INVENTORY_SIZE; i++)
1582 if (local_player->inventory_size < MAX_INVENTORY_SIZE)
1583 local_player->inventory_element[local_player->inventory_size++] =
1588 static void InitPlayfieldScanModeVars(void)
1590 if (game.use_reverse_scan_direction)
1592 playfield_scan_start_x = lev_fieldx - 1;
1593 playfield_scan_start_y = lev_fieldy - 1;
1595 playfield_scan_delta_x = -1;
1596 playfield_scan_delta_y = -1;
1600 playfield_scan_start_x = 0;
1601 playfield_scan_start_y = 0;
1603 playfield_scan_delta_x = 1;
1604 playfield_scan_delta_y = 1;
1608 static void InitPlayfieldScanMode(int mode)
1610 game.use_reverse_scan_direction =
1611 (mode == CA_ARG_SCAN_MODE_REVERSE ? TRUE : FALSE);
1613 InitPlayfieldScanModeVars();
1616 static int get_move_delay_from_stepsize(int move_stepsize)
1619 MIN(MAX(MOVE_STEPSIZE_MIN, move_stepsize), MOVE_STEPSIZE_MAX);
1621 // make sure that stepsize value is always a power of 2
1622 move_stepsize = (1 << log_2(move_stepsize));
1624 return TILEX / move_stepsize;
1627 static void SetPlayerMoveSpeed(struct PlayerInfo *player, int move_stepsize,
1630 int player_nr = player->index_nr;
1631 int move_delay = get_move_delay_from_stepsize(move_stepsize);
1632 boolean cannot_move = (move_stepsize == STEPSIZE_NOT_MOVING ? TRUE : FALSE);
1634 // do no immediately change move delay -- the player might just be moving
1635 player->move_delay_value_next = move_delay;
1637 // information if player can move must be set separately
1638 player->cannot_move = cannot_move;
1642 player->move_delay = game.initial_move_delay[player_nr];
1643 player->move_delay_value = game.initial_move_delay_value[player_nr];
1645 player->move_delay_value_next = -1;
1647 player->move_delay_reset_counter = 0;
1651 void GetPlayerConfig(void)
1653 GameFrameDelay = setup.game_frame_delay;
1655 if (!audio.sound_available)
1656 setup.sound_simple = FALSE;
1658 if (!audio.loops_available)
1659 setup.sound_loops = FALSE;
1661 if (!audio.music_available)
1662 setup.sound_music = FALSE;
1664 if (!video.fullscreen_available)
1665 setup.fullscreen = FALSE;
1667 setup.sound = (setup.sound_simple || setup.sound_loops || setup.sound_music);
1669 SetAudioMode(setup.sound);
1672 int GetElementFromGroupElement(int element)
1674 if (IS_GROUP_ELEMENT(element))
1676 struct ElementGroupInfo *group = element_info[element].group;
1677 int last_anim_random_frame = gfx.anim_random_frame;
1680 if (group->choice_mode == ANIM_RANDOM)
1681 gfx.anim_random_frame = RND(group->num_elements_resolved);
1683 element_pos = getAnimationFrame(group->num_elements_resolved, 1,
1684 group->choice_mode, 0,
1687 if (group->choice_mode == ANIM_RANDOM)
1688 gfx.anim_random_frame = last_anim_random_frame;
1690 group->choice_pos++;
1692 element = group->element_resolved[element_pos];
1698 static void IncrementSokobanFieldsNeeded(void)
1700 if (level.sb_fields_needed)
1701 game.sokoban_fields_still_needed++;
1704 static void IncrementSokobanObjectsNeeded(void)
1706 if (level.sb_objects_needed)
1707 game.sokoban_objects_still_needed++;
1710 static void DecrementSokobanFieldsNeeded(void)
1712 if (game.sokoban_fields_still_needed > 0)
1713 game.sokoban_fields_still_needed--;
1716 static void DecrementSokobanObjectsNeeded(void)
1718 if (game.sokoban_objects_still_needed > 0)
1719 game.sokoban_objects_still_needed--;
1722 static void InitPlayerField(int x, int y, int element, boolean init_game)
1724 if (element == EL_SP_MURPHY)
1728 if (stored_player[0].present)
1730 Tile[x][y] = EL_SP_MURPHY_CLONE;
1736 stored_player[0].initial_element = element;
1737 stored_player[0].use_murphy = TRUE;
1739 if (!level.use_artwork_element[0])
1740 stored_player[0].artwork_element = EL_SP_MURPHY;
1743 Tile[x][y] = EL_PLAYER_1;
1749 struct PlayerInfo *player = &stored_player[Tile[x][y] - EL_PLAYER_1];
1750 int jx = player->jx, jy = player->jy;
1752 player->present = TRUE;
1754 player->block_last_field = (element == EL_SP_MURPHY ?
1755 level.sp_block_last_field :
1756 level.block_last_field);
1758 // ---------- initialize player's last field block delay ------------------
1760 // always start with reliable default value (no adjustment needed)
1761 player->block_delay_adjustment = 0;
1763 // special case 1: in Supaplex, Murphy blocks last field one more frame
1764 if (player->block_last_field && element == EL_SP_MURPHY)
1765 player->block_delay_adjustment = 1;
1767 // special case 2: in game engines before 3.1.1, blocking was different
1768 if (game.use_block_last_field_bug)
1769 player->block_delay_adjustment = (player->block_last_field ? -1 : 1);
1771 if (!network.enabled || player->connected_network)
1773 player->active = TRUE;
1775 // remove potentially duplicate players
1776 if (StorePlayer[jx][jy] == Tile[x][y])
1777 StorePlayer[jx][jy] = 0;
1779 StorePlayer[x][y] = Tile[x][y];
1781 #if DEBUG_INIT_PLAYER
1782 Debug("game:init:player", "- player element %d activated",
1783 player->element_nr);
1784 Debug("game:init:player", " (local player is %d and currently %s)",
1785 local_player->element_nr,
1786 local_player->active ? "active" : "not active");
1790 Tile[x][y] = EL_EMPTY;
1792 player->jx = player->last_jx = x;
1793 player->jy = player->last_jy = y;
1796 // always check if player was just killed and should be reanimated
1798 int player_nr = GET_PLAYER_NR(element);
1799 struct PlayerInfo *player = &stored_player[player_nr];
1801 if (player->active && player->killed)
1802 player->reanimated = TRUE; // if player was just killed, reanimate him
1806 static void InitField(int x, int y, boolean init_game)
1808 int element = Tile[x][y];
1817 InitPlayerField(x, y, element, init_game);
1820 case EL_SOKOBAN_FIELD_PLAYER:
1821 element = Tile[x][y] = EL_PLAYER_1;
1822 InitField(x, y, init_game);
1824 element = Tile[x][y] = EL_SOKOBAN_FIELD_EMPTY;
1825 InitField(x, y, init_game);
1828 case EL_SOKOBAN_FIELD_EMPTY:
1829 IncrementSokobanFieldsNeeded();
1832 case EL_SOKOBAN_OBJECT:
1833 IncrementSokobanObjectsNeeded();
1837 if (x < lev_fieldx-1 && Tile[x+1][y] == EL_ACID)
1838 Tile[x][y] = EL_ACID_POOL_TOPLEFT;
1839 else if (x > 0 && Tile[x-1][y] == EL_ACID)
1840 Tile[x][y] = EL_ACID_POOL_TOPRIGHT;
1841 else if (y > 0 && Tile[x][y-1] == EL_ACID_POOL_TOPLEFT)
1842 Tile[x][y] = EL_ACID_POOL_BOTTOMLEFT;
1843 else if (y > 0 && Tile[x][y-1] == EL_ACID)
1844 Tile[x][y] = EL_ACID_POOL_BOTTOM;
1845 else if (y > 0 && Tile[x][y-1] == EL_ACID_POOL_TOPRIGHT)
1846 Tile[x][y] = EL_ACID_POOL_BOTTOMRIGHT;
1855 case EL_SPACESHIP_RIGHT:
1856 case EL_SPACESHIP_UP:
1857 case EL_SPACESHIP_LEFT:
1858 case EL_SPACESHIP_DOWN:
1859 case EL_BD_BUTTERFLY:
1860 case EL_BD_BUTTERFLY_RIGHT:
1861 case EL_BD_BUTTERFLY_UP:
1862 case EL_BD_BUTTERFLY_LEFT:
1863 case EL_BD_BUTTERFLY_DOWN:
1865 case EL_BD_FIREFLY_RIGHT:
1866 case EL_BD_FIREFLY_UP:
1867 case EL_BD_FIREFLY_LEFT:
1868 case EL_BD_FIREFLY_DOWN:
1869 case EL_PACMAN_RIGHT:
1871 case EL_PACMAN_LEFT:
1872 case EL_PACMAN_DOWN:
1874 case EL_YAMYAM_LEFT:
1875 case EL_YAMYAM_RIGHT:
1877 case EL_YAMYAM_DOWN:
1878 case EL_DARK_YAMYAM:
1881 case EL_SP_SNIKSNAK:
1882 case EL_SP_ELECTRON:
1888 case EL_SPRING_LEFT:
1889 case EL_SPRING_RIGHT:
1893 case EL_AMOEBA_FULL:
1898 case EL_AMOEBA_DROP:
1899 if (y == lev_fieldy - 1)
1901 Tile[x][y] = EL_AMOEBA_GROWING;
1902 Store[x][y] = EL_AMOEBA_WET;
1906 case EL_DYNAMITE_ACTIVE:
1907 case EL_SP_DISK_RED_ACTIVE:
1908 case EL_DYNABOMB_PLAYER_1_ACTIVE:
1909 case EL_DYNABOMB_PLAYER_2_ACTIVE:
1910 case EL_DYNABOMB_PLAYER_3_ACTIVE:
1911 case EL_DYNABOMB_PLAYER_4_ACTIVE:
1912 MovDelay[x][y] = 96;
1915 case EL_EM_DYNAMITE_ACTIVE:
1916 MovDelay[x][y] = 32;
1920 game.lights_still_needed++;
1924 game.friends_still_needed++;
1929 GfxDir[x][y] = MovDir[x][y] = 1 << RND(4);
1932 case EL_CONVEYOR_BELT_1_SWITCH_LEFT:
1933 case EL_CONVEYOR_BELT_1_SWITCH_MIDDLE:
1934 case EL_CONVEYOR_BELT_1_SWITCH_RIGHT:
1935 case EL_CONVEYOR_BELT_2_SWITCH_LEFT:
1936 case EL_CONVEYOR_BELT_2_SWITCH_MIDDLE:
1937 case EL_CONVEYOR_BELT_2_SWITCH_RIGHT:
1938 case EL_CONVEYOR_BELT_3_SWITCH_LEFT:
1939 case EL_CONVEYOR_BELT_3_SWITCH_MIDDLE:
1940 case EL_CONVEYOR_BELT_3_SWITCH_RIGHT:
1941 case EL_CONVEYOR_BELT_4_SWITCH_LEFT:
1942 case EL_CONVEYOR_BELT_4_SWITCH_MIDDLE:
1943 case EL_CONVEYOR_BELT_4_SWITCH_RIGHT:
1946 int belt_nr = getBeltNrFromBeltSwitchElement(Tile[x][y]);
1947 int belt_dir = getBeltDirFromBeltSwitchElement(Tile[x][y]);
1948 int belt_dir_nr = getBeltDirNrFromBeltSwitchElement(Tile[x][y]);
1950 if (game.belt_dir_nr[belt_nr] == 3) // initial value
1952 game.belt_dir[belt_nr] = belt_dir;
1953 game.belt_dir_nr[belt_nr] = belt_dir_nr;
1955 else // more than one switch -- set it like the first switch
1957 Tile[x][y] = Tile[x][y] - belt_dir_nr + game.belt_dir_nr[belt_nr];
1962 case EL_LIGHT_SWITCH_ACTIVE:
1964 game.light_time_left = level.time_light * FRAMES_PER_SECOND;
1967 case EL_INVISIBLE_STEELWALL:
1968 case EL_INVISIBLE_WALL:
1969 case EL_INVISIBLE_SAND:
1970 if (game.light_time_left > 0 ||
1971 game.lenses_time_left > 0)
1972 Tile[x][y] = getInvisibleActiveFromInvisibleElement(element);
1975 case EL_EMC_MAGIC_BALL:
1976 if (game.ball_active)
1977 Tile[x][y] = EL_EMC_MAGIC_BALL_ACTIVE;
1980 case EL_EMC_MAGIC_BALL_SWITCH:
1981 if (game.ball_active)
1982 Tile[x][y] = EL_EMC_MAGIC_BALL_SWITCH_ACTIVE;
1985 case EL_TRIGGER_PLAYER:
1986 case EL_TRIGGER_ELEMENT:
1987 case EL_TRIGGER_CE_VALUE:
1988 case EL_TRIGGER_CE_SCORE:
1990 case EL_ANY_ELEMENT:
1991 case EL_CURRENT_CE_VALUE:
1992 case EL_CURRENT_CE_SCORE:
2009 // reference elements should not be used on the playfield
2010 Tile[x][y] = EL_EMPTY;
2014 if (IS_CUSTOM_ELEMENT(element))
2016 if (CAN_MOVE(element))
2019 if (!element_info[element].use_last_ce_value || init_game)
2020 CustomValue[x][y] = GET_NEW_CE_VALUE(Tile[x][y]);
2022 else if (IS_GROUP_ELEMENT(element))
2024 Tile[x][y] = GetElementFromGroupElement(element);
2026 InitField(x, y, init_game);
2033 CheckTriggeredElementChange(x, y, element, CE_CREATION_OF_X);
2036 static void InitField_WithBug1(int x, int y, boolean init_game)
2038 InitField(x, y, init_game);
2040 // not needed to call InitMovDir() -- already done by InitField()!
2041 if (game.engine_version < VERSION_IDENT(3,1,0,0) &&
2042 CAN_MOVE(Tile[x][y]))
2046 static void InitField_WithBug2(int x, int y, boolean init_game)
2048 int old_element = Tile[x][y];
2050 InitField(x, y, init_game);
2052 // not needed to call InitMovDir() -- already done by InitField()!
2053 if (game.engine_version < VERSION_IDENT(3,1,0,0) &&
2054 CAN_MOVE(old_element) &&
2055 (old_element < EL_MOLE_LEFT || old_element > EL_MOLE_DOWN))
2058 /* this case is in fact a combination of not less than three bugs:
2059 first, it calls InitMovDir() for elements that can move, although this is
2060 already done by InitField(); then, it checks the element that was at this
2061 field _before_ the call to InitField() (which can change it); lastly, it
2062 was not called for "mole with direction" elements, which were treated as
2063 "cannot move" due to (fixed) wrong element initialization in "src/init.c"
2067 static int get_key_element_from_nr(int key_nr)
2069 int key_base_element = (key_nr >= STD_NUM_KEYS ? EL_EMC_KEY_5 - STD_NUM_KEYS :
2070 level.game_engine_type == GAME_ENGINE_TYPE_EM ?
2071 EL_EM_KEY_1 : EL_KEY_1);
2073 return key_base_element + key_nr;
2076 static int get_next_dropped_element(struct PlayerInfo *player)
2078 return (player->inventory_size > 0 ?
2079 player->inventory_element[player->inventory_size - 1] :
2080 player->inventory_infinite_element != EL_UNDEFINED ?
2081 player->inventory_infinite_element :
2082 player->dynabombs_left > 0 ?
2083 EL_DYNABOMB_PLAYER_1_ACTIVE + player->index_nr :
2087 static int get_inventory_element_from_pos(struct PlayerInfo *player, int pos)
2089 // pos >= 0: get element from bottom of the stack;
2090 // pos < 0: get element from top of the stack
2094 int min_inventory_size = -pos;
2095 int inventory_pos = player->inventory_size - min_inventory_size;
2096 int min_dynabombs_left = min_inventory_size - player->inventory_size;
2098 return (player->inventory_size >= min_inventory_size ?
2099 player->inventory_element[inventory_pos] :
2100 player->inventory_infinite_element != EL_UNDEFINED ?
2101 player->inventory_infinite_element :
2102 player->dynabombs_left >= min_dynabombs_left ?
2103 EL_DYNABOMB_PLAYER_1 + player->index_nr :
2108 int min_dynabombs_left = pos + 1;
2109 int min_inventory_size = pos + 1 - player->dynabombs_left;
2110 int inventory_pos = pos - player->dynabombs_left;
2112 return (player->inventory_infinite_element != EL_UNDEFINED ?
2113 player->inventory_infinite_element :
2114 player->dynabombs_left >= min_dynabombs_left ?
2115 EL_DYNABOMB_PLAYER_1 + player->index_nr :
2116 player->inventory_size >= min_inventory_size ?
2117 player->inventory_element[inventory_pos] :
2122 static int compareGamePanelOrderInfo(const void *object1, const void *object2)
2124 const struct GamePanelOrderInfo *gpo1 = (struct GamePanelOrderInfo *)object1;
2125 const struct GamePanelOrderInfo *gpo2 = (struct GamePanelOrderInfo *)object2;
2128 if (gpo1->sort_priority != gpo2->sort_priority)
2129 compare_result = gpo1->sort_priority - gpo2->sort_priority;
2131 compare_result = gpo1->nr - gpo2->nr;
2133 return compare_result;
2136 int getPlayerInventorySize(int player_nr)
2138 if (level.game_engine_type == GAME_ENGINE_TYPE_EM)
2139 return game_em.ply[player_nr]->dynamite;
2140 else if (level.game_engine_type == GAME_ENGINE_TYPE_SP)
2141 return game_sp.red_disk_count;
2143 return stored_player[player_nr].inventory_size;
2146 static void InitGameControlValues(void)
2150 for (i = 0; game_panel_controls[i].nr != -1; i++)
2152 struct GamePanelControlInfo *gpc = &game_panel_controls[i];
2153 struct GamePanelOrderInfo *gpo = &game_panel_order[i];
2154 struct TextPosInfo *pos = gpc->pos;
2156 int type = gpc->type;
2160 Error("'game_panel_controls' structure corrupted at %d", i);
2162 Fail("this should not happen -- please debug");
2165 // force update of game controls after initialization
2166 gpc->value = gpc->last_value = -1;
2167 gpc->frame = gpc->last_frame = -1;
2168 gpc->gfx_frame = -1;
2170 // determine panel value width for later calculation of alignment
2171 if (type == TYPE_INTEGER || type == TYPE_STRING)
2173 pos->width = pos->size * getFontWidth(pos->font);
2174 pos->height = getFontHeight(pos->font);
2176 else if (type == TYPE_ELEMENT)
2178 pos->width = pos->size;
2179 pos->height = pos->size;
2182 // fill structure for game panel draw order
2184 gpo->sort_priority = pos->sort_priority;
2187 // sort game panel controls according to sort_priority and control number
2188 qsort(game_panel_order, NUM_GAME_PANEL_CONTROLS,
2189 sizeof(struct GamePanelOrderInfo), compareGamePanelOrderInfo);
2192 static void UpdatePlayfieldElementCount(void)
2194 boolean use_element_count = FALSE;
2197 // first check if it is needed at all to calculate playfield element count
2198 for (i = GAME_PANEL_ELEMENT_COUNT_1; i <= GAME_PANEL_ELEMENT_COUNT_8; i++)
2199 if (!PANEL_DEACTIVATED(game_panel_controls[i].pos))
2200 use_element_count = TRUE;
2202 if (!use_element_count)
2205 for (i = 0; i < MAX_NUM_ELEMENTS; i++)
2206 element_info[i].element_count = 0;
2208 SCAN_PLAYFIELD(x, y)
2210 element_info[Tile[x][y]].element_count++;
2213 for (i = 0; i < NUM_GROUP_ELEMENTS; i++)
2214 for (j = 0; j < MAX_NUM_ELEMENTS; j++)
2215 if (IS_IN_GROUP(j, i))
2216 element_info[EL_GROUP_START + i].element_count +=
2217 element_info[j].element_count;
2220 static void UpdateGameControlValues(void)
2223 int time = (game.LevelSolved ?
2224 game.LevelSolved_CountingTime :
2225 level.game_engine_type == GAME_ENGINE_TYPE_EM ?
2227 level.game_engine_type == GAME_ENGINE_TYPE_SP ?
2228 game_sp.time_played :
2229 level.game_engine_type == GAME_ENGINE_TYPE_MM ?
2230 game_mm.energy_left :
2231 game.no_time_limit ? TimePlayed : TimeLeft);
2232 int score = (game.LevelSolved ?
2233 game.LevelSolved_CountingScore :
2234 level.game_engine_type == GAME_ENGINE_TYPE_EM ?
2235 game_em.lev->score :
2236 level.game_engine_type == GAME_ENGINE_TYPE_SP ?
2238 level.game_engine_type == GAME_ENGINE_TYPE_MM ?
2241 int gems = (level.game_engine_type == GAME_ENGINE_TYPE_EM ?
2242 game_em.lev->gems_needed :
2243 level.game_engine_type == GAME_ENGINE_TYPE_SP ?
2244 game_sp.infotrons_still_needed :
2245 level.game_engine_type == GAME_ENGINE_TYPE_MM ?
2246 game_mm.kettles_still_needed :
2247 game.gems_still_needed);
2248 int exit_closed = (level.game_engine_type == GAME_ENGINE_TYPE_EM ?
2249 game_em.lev->gems_needed > 0 :
2250 level.game_engine_type == GAME_ENGINE_TYPE_SP ?
2251 game_sp.infotrons_still_needed > 0 :
2252 level.game_engine_type == GAME_ENGINE_TYPE_MM ?
2253 game_mm.kettles_still_needed > 0 ||
2254 game_mm.lights_still_needed > 0 :
2255 game.gems_still_needed > 0 ||
2256 game.sokoban_fields_still_needed > 0 ||
2257 game.sokoban_objects_still_needed > 0 ||
2258 game.lights_still_needed > 0);
2259 int health = (game.LevelSolved ?
2260 game.LevelSolved_CountingHealth :
2261 level.game_engine_type == GAME_ENGINE_TYPE_MM ?
2262 MM_HEALTH(game_mm.laser_overload_value) :
2264 int sync_random_frame = INIT_GFX_RANDOM(); // random, but synchronized
2266 UpdatePlayfieldElementCount();
2268 // update game panel control values
2270 // used instead of "level_nr" (for network games)
2271 game_panel_controls[GAME_PANEL_LEVEL_NUMBER].value = levelset.level_nr;
2272 game_panel_controls[GAME_PANEL_GEMS].value = gems;
2274 game_panel_controls[GAME_PANEL_INVENTORY_COUNT].value = 0;
2275 for (i = 0; i < MAX_NUM_KEYS; i++)
2276 game_panel_controls[GAME_PANEL_KEY_1 + i].value = EL_EMPTY;
2277 game_panel_controls[GAME_PANEL_KEY_WHITE].value = EL_EMPTY;
2278 game_panel_controls[GAME_PANEL_KEY_WHITE_COUNT].value = 0;
2280 if (game.centered_player_nr == -1)
2282 for (i = 0; i < MAX_PLAYERS; i++)
2284 // only one player in Supaplex game engine
2285 if (level.game_engine_type == GAME_ENGINE_TYPE_SP && i > 0)
2288 for (k = 0; k < MAX_NUM_KEYS; k++)
2290 if (level.game_engine_type == GAME_ENGINE_TYPE_EM)
2292 if (game_em.ply[i]->keys & (1 << k))
2293 game_panel_controls[GAME_PANEL_KEY_1 + k].value =
2294 get_key_element_from_nr(k);
2296 else if (stored_player[i].key[k])
2297 game_panel_controls[GAME_PANEL_KEY_1 + k].value =
2298 get_key_element_from_nr(k);
2301 game_panel_controls[GAME_PANEL_INVENTORY_COUNT].value +=
2302 getPlayerInventorySize(i);
2304 if (stored_player[i].num_white_keys > 0)
2305 game_panel_controls[GAME_PANEL_KEY_WHITE].value =
2308 game_panel_controls[GAME_PANEL_KEY_WHITE_COUNT].value +=
2309 stored_player[i].num_white_keys;
2314 int player_nr = game.centered_player_nr;
2316 for (k = 0; k < MAX_NUM_KEYS; k++)
2318 if (level.game_engine_type == GAME_ENGINE_TYPE_EM)
2320 if (game_em.ply[player_nr]->keys & (1 << k))
2321 game_panel_controls[GAME_PANEL_KEY_1 + k].value =
2322 get_key_element_from_nr(k);
2324 else if (stored_player[player_nr].key[k])
2325 game_panel_controls[GAME_PANEL_KEY_1 + k].value =
2326 get_key_element_from_nr(k);
2329 game_panel_controls[GAME_PANEL_INVENTORY_COUNT].value +=
2330 getPlayerInventorySize(player_nr);
2332 if (stored_player[player_nr].num_white_keys > 0)
2333 game_panel_controls[GAME_PANEL_KEY_WHITE].value = EL_DC_KEY_WHITE;
2335 game_panel_controls[GAME_PANEL_KEY_WHITE_COUNT].value +=
2336 stored_player[player_nr].num_white_keys;
2339 // re-arrange keys on game panel, if needed or if defined by style settings
2340 for (i = 0; i < MAX_NUM_KEYS + 1; i++) // all normal keys + white key
2342 int nr = GAME_PANEL_KEY_1 + i;
2343 struct GamePanelControlInfo *gpc = &game_panel_controls[nr];
2344 struct TextPosInfo *pos = gpc->pos;
2346 // skip check if key is not in the player's inventory
2347 if (gpc->value == EL_EMPTY)
2350 // check if keys should be arranged on panel from left to right
2351 if (pos->style == STYLE_LEFTMOST_POSITION)
2353 // check previous key positions (left from current key)
2354 for (k = 0; k < i; k++)
2356 int nr_new = GAME_PANEL_KEY_1 + k;
2358 if (game_panel_controls[nr_new].value == EL_EMPTY)
2360 game_panel_controls[nr_new].value = gpc->value;
2361 gpc->value = EL_EMPTY;
2368 // check if "undefined" keys can be placed at some other position
2369 if (pos->x == -1 && pos->y == -1)
2371 int nr_new = GAME_PANEL_KEY_1 + i % STD_NUM_KEYS;
2373 // 1st try: display key at the same position as normal or EM keys
2374 if (game_panel_controls[nr_new].value == EL_EMPTY)
2376 game_panel_controls[nr_new].value = gpc->value;
2380 // 2nd try: display key at the next free position in the key panel
2381 for (k = 0; k < STD_NUM_KEYS; k++)
2383 nr_new = GAME_PANEL_KEY_1 + k;
2385 if (game_panel_controls[nr_new].value == EL_EMPTY)
2387 game_panel_controls[nr_new].value = gpc->value;
2396 for (i = 0; i < NUM_PANEL_INVENTORY; i++)
2398 game_panel_controls[GAME_PANEL_INVENTORY_FIRST_1 + i].value =
2399 get_inventory_element_from_pos(local_player, i);
2400 game_panel_controls[GAME_PANEL_INVENTORY_LAST_1 + i].value =
2401 get_inventory_element_from_pos(local_player, -i - 1);
2404 game_panel_controls[GAME_PANEL_SCORE].value = score;
2405 game_panel_controls[GAME_PANEL_HIGHSCORE].value = scores.entry[0].score;
2407 game_panel_controls[GAME_PANEL_TIME].value = time;
2409 game_panel_controls[GAME_PANEL_TIME_HH].value = time / 3600;
2410 game_panel_controls[GAME_PANEL_TIME_MM].value = (time / 60) % 60;
2411 game_panel_controls[GAME_PANEL_TIME_SS].value = time % 60;
2413 if (level.time == 0)
2414 game_panel_controls[GAME_PANEL_TIME_ANIM].value = 100;
2416 game_panel_controls[GAME_PANEL_TIME_ANIM].value = time * 100 / level.time;
2418 game_panel_controls[GAME_PANEL_HEALTH].value = health;
2419 game_panel_controls[GAME_PANEL_HEALTH_ANIM].value = health;
2421 game_panel_controls[GAME_PANEL_FRAME].value = FrameCounter;
2423 game_panel_controls[GAME_PANEL_SHIELD_NORMAL].value =
2424 (local_player->shield_normal_time_left > 0 ? EL_SHIELD_NORMAL_ACTIVE :
2426 game_panel_controls[GAME_PANEL_SHIELD_NORMAL_TIME].value =
2427 local_player->shield_normal_time_left;
2428 game_panel_controls[GAME_PANEL_SHIELD_DEADLY].value =
2429 (local_player->shield_deadly_time_left > 0 ? EL_SHIELD_DEADLY_ACTIVE :
2431 game_panel_controls[GAME_PANEL_SHIELD_DEADLY_TIME].value =
2432 local_player->shield_deadly_time_left;
2434 game_panel_controls[GAME_PANEL_EXIT].value =
2435 (exit_closed ? EL_EXIT_CLOSED : EL_EXIT_OPEN);
2437 game_panel_controls[GAME_PANEL_EMC_MAGIC_BALL].value =
2438 (game.ball_active ? EL_EMC_MAGIC_BALL_ACTIVE : EL_EMC_MAGIC_BALL);
2439 game_panel_controls[GAME_PANEL_EMC_MAGIC_BALL_SWITCH].value =
2440 (game.ball_active ? EL_EMC_MAGIC_BALL_SWITCH_ACTIVE :
2441 EL_EMC_MAGIC_BALL_SWITCH);
2443 game_panel_controls[GAME_PANEL_LIGHT_SWITCH].value =
2444 (game.light_time_left > 0 ? EL_LIGHT_SWITCH_ACTIVE : EL_LIGHT_SWITCH);
2445 game_panel_controls[GAME_PANEL_LIGHT_SWITCH_TIME].value =
2446 game.light_time_left;
2448 game_panel_controls[GAME_PANEL_TIMEGATE_SWITCH].value =
2449 (game.timegate_time_left > 0 ? EL_TIMEGATE_OPEN : EL_TIMEGATE_CLOSED);
2450 game_panel_controls[GAME_PANEL_TIMEGATE_SWITCH_TIME].value =
2451 game.timegate_time_left;
2453 game_panel_controls[GAME_PANEL_SWITCHGATE_SWITCH].value =
2454 EL_SWITCHGATE_SWITCH_UP + game.switchgate_pos;
2456 game_panel_controls[GAME_PANEL_EMC_LENSES].value =
2457 (game.lenses_time_left > 0 ? EL_EMC_LENSES : EL_EMPTY);
2458 game_panel_controls[GAME_PANEL_EMC_LENSES_TIME].value =
2459 game.lenses_time_left;
2461 game_panel_controls[GAME_PANEL_EMC_MAGNIFIER].value =
2462 (game.magnify_time_left > 0 ? EL_EMC_MAGNIFIER : EL_EMPTY);
2463 game_panel_controls[GAME_PANEL_EMC_MAGNIFIER_TIME].value =
2464 game.magnify_time_left;
2466 game_panel_controls[GAME_PANEL_BALLOON_SWITCH].value =
2467 (game.wind_direction == MV_LEFT ? EL_BALLOON_SWITCH_LEFT :
2468 game.wind_direction == MV_RIGHT ? EL_BALLOON_SWITCH_RIGHT :
2469 game.wind_direction == MV_UP ? EL_BALLOON_SWITCH_UP :
2470 game.wind_direction == MV_DOWN ? EL_BALLOON_SWITCH_DOWN :
2471 EL_BALLOON_SWITCH_NONE);
2473 game_panel_controls[GAME_PANEL_DYNABOMB_NUMBER].value =
2474 local_player->dynabomb_count;
2475 game_panel_controls[GAME_PANEL_DYNABOMB_SIZE].value =
2476 local_player->dynabomb_size;
2477 game_panel_controls[GAME_PANEL_DYNABOMB_POWER].value =
2478 (local_player->dynabomb_xl ? EL_DYNABOMB_INCREASE_POWER : EL_EMPTY);
2480 game_panel_controls[GAME_PANEL_PENGUINS].value =
2481 game.friends_still_needed;
2483 game_panel_controls[GAME_PANEL_SOKOBAN_OBJECTS].value =
2484 game.sokoban_objects_still_needed;
2485 game_panel_controls[GAME_PANEL_SOKOBAN_FIELDS].value =
2486 game.sokoban_fields_still_needed;
2488 game_panel_controls[GAME_PANEL_ROBOT_WHEEL].value =
2489 (game.robot_wheel_active ? EL_ROBOT_WHEEL_ACTIVE : EL_ROBOT_WHEEL);
2491 for (i = 0; i < NUM_BELTS; i++)
2493 game_panel_controls[GAME_PANEL_CONVEYOR_BELT_1 + i].value =
2494 (game.belt_dir[i] != MV_NONE ? EL_CONVEYOR_BELT_1_MIDDLE_ACTIVE :
2495 EL_CONVEYOR_BELT_1_MIDDLE) + i;
2496 game_panel_controls[GAME_PANEL_CONVEYOR_BELT_1_SWITCH + i].value =
2497 getBeltSwitchElementFromBeltNrAndBeltDir(i, game.belt_dir[i]);
2500 game_panel_controls[GAME_PANEL_MAGIC_WALL].value =
2501 (game.magic_wall_active ? EL_MAGIC_WALL_ACTIVE : EL_MAGIC_WALL);
2502 game_panel_controls[GAME_PANEL_MAGIC_WALL_TIME].value =
2503 game.magic_wall_time_left;
2505 game_panel_controls[GAME_PANEL_GRAVITY_STATE].value =
2506 local_player->gravity;
2508 for (i = 0; i < NUM_PANEL_GRAPHICS; i++)
2509 game_panel_controls[GAME_PANEL_GRAPHIC_1 + i].value = EL_GRAPHIC_1 + i;
2511 for (i = 0; i < NUM_PANEL_ELEMENTS; i++)
2512 game_panel_controls[GAME_PANEL_ELEMENT_1 + i].value =
2513 (IS_DRAWABLE_ELEMENT(game.panel.element[i].id) ?
2514 game.panel.element[i].id : EL_UNDEFINED);
2516 for (i = 0; i < NUM_PANEL_ELEMENTS; i++)
2517 game_panel_controls[GAME_PANEL_ELEMENT_COUNT_1 + i].value =
2518 (IS_VALID_ELEMENT(game.panel.element_count[i].id) ?
2519 element_info[game.panel.element_count[i].id].element_count : 0);
2521 for (i = 0; i < NUM_PANEL_CE_SCORE; i++)
2522 game_panel_controls[GAME_PANEL_CE_SCORE_1 + i].value =
2523 (IS_CUSTOM_ELEMENT(game.panel.ce_score[i].id) ?
2524 element_info[game.panel.ce_score[i].id].collect_score : 0);
2526 for (i = 0; i < NUM_PANEL_CE_SCORE; i++)
2527 game_panel_controls[GAME_PANEL_CE_SCORE_1_ELEMENT + i].value =
2528 (IS_CUSTOM_ELEMENT(game.panel.ce_score_element[i].id) ?
2529 element_info[game.panel.ce_score_element[i].id].collect_score :
2532 game_panel_controls[GAME_PANEL_PLAYER_NAME].value = 0;
2533 game_panel_controls[GAME_PANEL_LEVEL_NAME].value = 0;
2534 game_panel_controls[GAME_PANEL_LEVEL_AUTHOR].value = 0;
2536 // update game panel control frames
2538 for (i = 0; game_panel_controls[i].nr != -1; i++)
2540 struct GamePanelControlInfo *gpc = &game_panel_controls[i];
2542 if (gpc->type == TYPE_ELEMENT)
2544 if (gpc->value != EL_UNDEFINED && gpc->value != EL_EMPTY)
2546 int last_anim_random_frame = gfx.anim_random_frame;
2547 int element = gpc->value;
2548 int graphic = el2panelimg(element);
2549 int init_gfx_random = (graphic_info[graphic].anim_global_sync ?
2550 sync_random_frame : INIT_GFX_RANDOM());
2552 if (gpc->value != gpc->last_value)
2555 gpc->gfx_random = init_gfx_random;
2561 if (ANIM_MODE(graphic) == ANIM_RANDOM &&
2562 IS_NEXT_FRAME(gpc->gfx_frame, graphic))
2563 gpc->gfx_random = init_gfx_random;
2566 if (ANIM_MODE(graphic) == ANIM_RANDOM)
2567 gfx.anim_random_frame = gpc->gfx_random;
2569 if (ANIM_MODE(graphic) == ANIM_CE_SCORE)
2570 gpc->gfx_frame = element_info[element].collect_score;
2572 gpc->frame = getGraphicAnimationFrame(graphic, gpc->gfx_frame);
2574 if (ANIM_MODE(graphic) == ANIM_RANDOM)
2575 gfx.anim_random_frame = last_anim_random_frame;
2578 else if (gpc->type == TYPE_GRAPHIC)
2580 if (gpc->graphic != IMG_UNDEFINED)
2582 int last_anim_random_frame = gfx.anim_random_frame;
2583 int graphic = gpc->graphic;
2584 int init_gfx_random = (graphic_info[graphic].anim_global_sync ?
2585 sync_random_frame : INIT_GFX_RANDOM());
2587 if (gpc->value != gpc->last_value)
2590 gpc->gfx_random = init_gfx_random;
2596 if (ANIM_MODE(graphic) == ANIM_RANDOM &&
2597 IS_NEXT_FRAME(gpc->gfx_frame, graphic))
2598 gpc->gfx_random = init_gfx_random;
2601 if (ANIM_MODE(graphic) == ANIM_RANDOM)
2602 gfx.anim_random_frame = gpc->gfx_random;
2604 gpc->frame = getGraphicAnimationFrame(graphic, gpc->gfx_frame);
2606 if (ANIM_MODE(graphic) == ANIM_RANDOM)
2607 gfx.anim_random_frame = last_anim_random_frame;
2613 static void DisplayGameControlValues(void)
2615 boolean redraw_panel = FALSE;
2618 for (i = 0; game_panel_controls[i].nr != -1; i++)
2620 struct GamePanelControlInfo *gpc = &game_panel_controls[i];
2622 if (PANEL_DEACTIVATED(gpc->pos))
2625 if (gpc->value == gpc->last_value &&
2626 gpc->frame == gpc->last_frame)
2629 redraw_panel = TRUE;
2635 // copy default game door content to main double buffer
2637 // !!! CHECK AGAIN !!!
2638 SetPanelBackground();
2639 // SetDoorBackgroundImage(IMG_BACKGROUND_PANEL);
2640 DrawBackground(DX, DY, DXSIZE, DYSIZE);
2642 // redraw game control buttons
2643 RedrawGameButtons();
2645 SetGameStatus(GAME_MODE_PSEUDO_PANEL);
2647 for (i = 0; i < NUM_GAME_PANEL_CONTROLS; i++)
2649 int nr = game_panel_order[i].nr;
2650 struct GamePanelControlInfo *gpc = &game_panel_controls[nr];
2651 struct TextPosInfo *pos = gpc->pos;
2652 int type = gpc->type;
2653 int value = gpc->value;
2654 int frame = gpc->frame;
2655 int size = pos->size;
2656 int font = pos->font;
2657 boolean draw_masked = pos->draw_masked;
2658 int mask_mode = (draw_masked ? BLIT_MASKED : BLIT_OPAQUE);
2660 if (PANEL_DEACTIVATED(pos))
2663 if (pos->class == get_hash_from_key("extra_panel_items") &&
2664 !setup.prefer_extra_panel_items)
2667 gpc->last_value = value;
2668 gpc->last_frame = frame;
2670 if (type == TYPE_INTEGER)
2672 if (nr == GAME_PANEL_LEVEL_NUMBER ||
2673 nr == GAME_PANEL_TIME)
2675 boolean use_dynamic_size = (size == -1 ? TRUE : FALSE);
2677 if (use_dynamic_size) // use dynamic number of digits
2679 int value_change = (nr == GAME_PANEL_LEVEL_NUMBER ? 100 : 1000);
2680 int size1 = (nr == GAME_PANEL_LEVEL_NUMBER ? 2 : 3);
2681 int size2 = size1 + 1;
2682 int font1 = pos->font;
2683 int font2 = pos->font_alt;
2685 size = (value < value_change ? size1 : size2);
2686 font = (value < value_change ? font1 : font2);
2690 // correct text size if "digits" is zero or less
2692 size = strlen(int2str(value, size));
2694 // dynamically correct text alignment
2695 pos->width = size * getFontWidth(font);
2697 DrawTextExt(drawto, PANEL_XPOS(pos), PANEL_YPOS(pos),
2698 int2str(value, size), font, mask_mode);
2700 else if (type == TYPE_ELEMENT)
2702 int element, graphic;
2706 int dst_x = PANEL_XPOS(pos);
2707 int dst_y = PANEL_YPOS(pos);
2709 if (value != EL_UNDEFINED && value != EL_EMPTY)
2712 graphic = el2panelimg(value);
2715 Debug("game:DisplayGameControlValues", "%d, '%s' [%d]",
2716 element, EL_NAME(element), size);
2719 if (element >= EL_GRAPHIC_1 && element <= EL_GRAPHIC_8 && size == 0)
2722 getSizedGraphicSource(graphic, frame, size, &src_bitmap,
2725 width = graphic_info[graphic].width * size / TILESIZE;
2726 height = graphic_info[graphic].height * size / TILESIZE;
2729 BlitBitmapMasked(src_bitmap, drawto, src_x, src_y, width, height,
2732 BlitBitmap(src_bitmap, drawto, src_x, src_y, width, height,
2736 else if (type == TYPE_GRAPHIC)
2738 int graphic = gpc->graphic;
2739 int graphic_active = gpc->graphic_active;
2743 int dst_x = PANEL_XPOS(pos);
2744 int dst_y = PANEL_YPOS(pos);
2745 boolean skip = (pos->class == get_hash_from_key("mm_engine_only") &&
2746 level.game_engine_type != GAME_ENGINE_TYPE_MM);
2748 if (graphic != IMG_UNDEFINED && !skip)
2750 if (pos->style == STYLE_REVERSE)
2751 value = 100 - value;
2753 getGraphicSource(graphic_active, frame, &src_bitmap, &src_x, &src_y);
2755 if (pos->direction & MV_HORIZONTAL)
2757 width = graphic_info[graphic_active].width * value / 100;
2758 height = graphic_info[graphic_active].height;
2760 if (pos->direction == MV_LEFT)
2762 src_x += graphic_info[graphic_active].width - width;
2763 dst_x += graphic_info[graphic_active].width - width;
2768 width = graphic_info[graphic_active].width;
2769 height = graphic_info[graphic_active].height * value / 100;
2771 if (pos->direction == MV_UP)
2773 src_y += graphic_info[graphic_active].height - height;
2774 dst_y += graphic_info[graphic_active].height - height;
2779 BlitBitmapMasked(src_bitmap, drawto, src_x, src_y, width, height,
2782 BlitBitmap(src_bitmap, drawto, src_x, src_y, width, height,
2785 getGraphicSource(graphic, frame, &src_bitmap, &src_x, &src_y);
2787 if (pos->direction & MV_HORIZONTAL)
2789 if (pos->direction == MV_RIGHT)
2796 dst_x = PANEL_XPOS(pos);
2799 width = graphic_info[graphic].width - width;
2803 if (pos->direction == MV_DOWN)
2810 dst_y = PANEL_YPOS(pos);
2813 height = graphic_info[graphic].height - height;
2817 BlitBitmapMasked(src_bitmap, drawto, src_x, src_y, width, height,
2820 BlitBitmap(src_bitmap, drawto, src_x, src_y, width, height,
2824 else if (type == TYPE_STRING)
2826 boolean active = (value != 0);
2827 char *state_normal = "off";
2828 char *state_active = "on";
2829 char *state = (active ? state_active : state_normal);
2830 char *s = (nr == GAME_PANEL_GRAVITY_STATE ? state :
2831 nr == GAME_PANEL_PLAYER_NAME ? setup.player_name :
2832 nr == GAME_PANEL_LEVEL_NAME ? level.name :
2833 nr == GAME_PANEL_LEVEL_AUTHOR ? level.author : NULL);
2835 if (nr == GAME_PANEL_GRAVITY_STATE)
2837 int font1 = pos->font; // (used for normal state)
2838 int font2 = pos->font_alt; // (used for active state)
2840 font = (active ? font2 : font1);
2849 // don't truncate output if "chars" is zero or less
2852 // dynamically correct text alignment
2853 pos->width = size * getFontWidth(font);
2856 s_cut = getStringCopyN(s, size);
2858 DrawTextExt(drawto, PANEL_XPOS(pos), PANEL_YPOS(pos),
2859 s_cut, font, mask_mode);
2865 redraw_mask |= REDRAW_DOOR_1;
2868 SetGameStatus(GAME_MODE_PLAYING);
2871 void UpdateAndDisplayGameControlValues(void)
2873 if (tape.deactivate_display)
2876 UpdateGameControlValues();
2877 DisplayGameControlValues();
2880 void UpdateGameDoorValues(void)
2882 UpdateGameControlValues();
2885 void DrawGameDoorValues(void)
2887 DisplayGameControlValues();
2891 // ============================================================================
2893 // ----------------------------------------------------------------------------
2894 // initialize game engine due to level / tape version number
2895 // ============================================================================
2897 static void InitGameEngine(void)
2899 int i, j, k, l, x, y;
2901 // set game engine from tape file when re-playing, else from level file
2902 game.engine_version = (tape.playing ? tape.engine_version :
2903 level.game_version);
2905 // set single or multi-player game mode (needed for re-playing tapes)
2906 game.team_mode = setup.team_mode;
2910 int num_players = 0;
2912 for (i = 0; i < MAX_PLAYERS; i++)
2913 if (tape.player_participates[i])
2916 // multi-player tapes contain input data for more than one player
2917 game.team_mode = (num_players > 1);
2921 Debug("game:init:level", "level %d: level.game_version == %06d", level_nr,
2922 level.game_version);
2923 Debug("game:init:level", " tape.file_version == %06d",
2925 Debug("game:init:level", " tape.game_version == %06d",
2927 Debug("game:init:level", " tape.engine_version == %06d",
2928 tape.engine_version);
2929 Debug("game:init:level", " => game.engine_version == %06d [tape mode: %s]",
2930 game.engine_version, (tape.playing ? "PLAYING" : "RECORDING"));
2933 // --------------------------------------------------------------------------
2934 // set flags for bugs and changes according to active game engine version
2935 // --------------------------------------------------------------------------
2939 Fixed property "can fall" for run-time element "EL_AMOEBA_DROPPING"
2941 Bug was introduced in version:
2944 Bug was fixed in version:
2948 In version 2.0.1, a new run-time element "EL_AMOEBA_DROPPING" was added,
2949 but the property "can fall" was missing, which caused some levels to be
2950 unsolvable. This was fixed in version 4.2.0.0.
2952 Affected levels/tapes:
2953 An example for a tape that was fixed by this bugfix is tape 029 from the
2954 level set "rnd_sam_bateman".
2955 The wrong behaviour will still be used for all levels or tapes that were
2956 created/recorded with it. An example for this is tape 023 from the level
2957 set "rnd_gerhard_haeusler", which was recorded with a buggy game engine.
2960 boolean use_amoeba_dropping_cannot_fall_bug =
2961 ((game.engine_version >= VERSION_IDENT(2,0,1,0) &&
2962 game.engine_version < VERSION_IDENT(4,2,0,0)) ||
2964 tape.game_version >= VERSION_IDENT(2,0,1,0) &&
2965 tape.game_version < VERSION_IDENT(4,2,0,0)));
2968 Summary of bugfix/change:
2969 Fixed move speed of elements entering or leaving magic wall.
2971 Fixed/changed in version:
2975 Before 2.0.1, move speed of elements entering or leaving magic wall was
2976 twice as fast as it is now.
2977 Since 2.0.1, this is set to a lower value by using move_stepsize_list[].
2979 Affected levels/tapes:
2980 The first condition is generally needed for all levels/tapes before version
2981 2.0.1, which might use the old behaviour before it was changed; known tapes
2982 that are affected: Tape 014 from the level set "rnd_conor_mancone".
2983 The second condition is an exception from the above case and is needed for
2984 the special case of tapes recorded with game (not engine!) version 2.0.1 or
2985 above, but before it was known that this change would break tapes like the
2986 above and was fixed in 4.2.0.0, so that the changed behaviour was active
2987 although the engine version while recording maybe was before 2.0.1. There
2988 are a lot of tapes that are affected by this exception, like tape 006 from
2989 the level set "rnd_conor_mancone".
2992 boolean use_old_move_stepsize_for_magic_wall =
2993 (game.engine_version < VERSION_IDENT(2,0,1,0) &&
2995 tape.game_version >= VERSION_IDENT(2,0,1,0) &&
2996 tape.game_version < VERSION_IDENT(4,2,0,0)));
2999 Summary of bugfix/change:
3000 Fixed handling for custom elements that change when pushed by the player.
3002 Fixed/changed in version:
3006 Before 3.1.0, custom elements that "change when pushing" changed directly
3007 after the player started pushing them (until then handled in "DigField()").
3008 Since 3.1.0, these custom elements are not changed until the "pushing"
3009 move of the element is finished (now handled in "ContinueMoving()").
3011 Affected levels/tapes:
3012 The first condition is generally needed for all levels/tapes before version
3013 3.1.0, which might use the old behaviour before it was changed; known tapes
3014 that are affected are some tapes from the level set "Walpurgis Gardens" by
3016 The second condition is an exception from the above case and is needed for
3017 the special case of tapes recorded with game (not engine!) version 3.1.0 or
3018 above (including some development versions of 3.1.0), but before it was
3019 known that this change would break tapes like the above and was fixed in
3020 3.1.1, so that the changed behaviour was active although the engine version
3021 while recording maybe was before 3.1.0. There is at least one tape that is
3022 affected by this exception, which is the tape for the one-level set "Bug
3023 Machine" by Juergen Bonhagen.
3026 game.use_change_when_pushing_bug =
3027 (game.engine_version < VERSION_IDENT(3,1,0,0) &&
3029 tape.game_version >= VERSION_IDENT(3,1,0,0) &&
3030 tape.game_version < VERSION_IDENT(3,1,1,0)));
3033 Summary of bugfix/change:
3034 Fixed handling for blocking the field the player leaves when moving.
3036 Fixed/changed in version:
3040 Before 3.1.1, when "block last field when moving" was enabled, the field
3041 the player is leaving when moving was blocked for the time of the move,
3042 and was directly unblocked afterwards. This resulted in the last field
3043 being blocked for exactly one less than the number of frames of one player
3044 move. Additionally, even when blocking was disabled, the last field was
3045 blocked for exactly one frame.
3046 Since 3.1.1, due to changes in player movement handling, the last field
3047 is not blocked at all when blocking is disabled. When blocking is enabled,
3048 the last field is blocked for exactly the number of frames of one player
3049 move. Additionally, if the player is Murphy, the hero of Supaplex, the
3050 last field is blocked for exactly one more than the number of frames of
3053 Affected levels/tapes:
3054 (!!! yet to be determined -- probably many !!!)
3057 game.use_block_last_field_bug =
3058 (game.engine_version < VERSION_IDENT(3,1,1,0));
3060 /* various special flags and settings for native Emerald Mine game engine */
3062 game_em.use_single_button =
3063 (game.engine_version > VERSION_IDENT(4,0,0,2));
3065 game_em.use_snap_key_bug =
3066 (game.engine_version < VERSION_IDENT(4,0,1,0));
3068 game_em.use_random_bug =
3069 (tape.property_bits & TAPE_PROPERTY_EM_RANDOM_BUG);
3071 boolean use_old_em_engine = (game.engine_version < VERSION_IDENT(4,2,0,0));
3073 game_em.use_old_explosions = use_old_em_engine;
3074 game_em.use_old_android = use_old_em_engine;
3075 game_em.use_old_push_elements = use_old_em_engine;
3076 game_em.use_old_push_into_acid = use_old_em_engine;
3078 game_em.use_wrap_around = !use_old_em_engine;
3080 // --------------------------------------------------------------------------
3082 // set maximal allowed number of custom element changes per game frame
3083 game.max_num_changes_per_frame = 1;
3085 // default scan direction: scan playfield from top/left to bottom/right
3086 InitPlayfieldScanMode(CA_ARG_SCAN_MODE_NORMAL);
3088 // dynamically adjust element properties according to game engine version
3089 InitElementPropertiesEngine(game.engine_version);
3091 // ---------- initialize special element properties -------------------------
3093 // "EL_AMOEBA_DROPPING" missed property "can fall" in older game versions
3094 if (use_amoeba_dropping_cannot_fall_bug)
3095 SET_PROPERTY(EL_AMOEBA_DROPPING, EP_CAN_FALL, FALSE);
3097 // ---------- initialize player's initial move delay ------------------------
3099 // dynamically adjust player properties according to level information
3100 for (i = 0; i < MAX_PLAYERS; i++)
3101 game.initial_move_delay_value[i] =
3102 get_move_delay_from_stepsize(level.initial_player_stepsize[i]);
3104 // dynamically adjust player properties according to game engine version
3105 for (i = 0; i < MAX_PLAYERS; i++)
3106 game.initial_move_delay[i] =
3107 (game.engine_version <= VERSION_IDENT(2,0,1,0) ?
3108 game.initial_move_delay_value[i] : 0);
3110 // ---------- initialize player's initial push delay ------------------------
3112 // dynamically adjust player properties according to game engine version
3113 game.initial_push_delay_value =
3114 (game.engine_version < VERSION_IDENT(3,0,7,1) ? 5 : -1);
3116 // ---------- initialize changing elements ----------------------------------
3118 // initialize changing elements information
3119 for (i = 0; i < MAX_NUM_ELEMENTS; i++)
3121 struct ElementInfo *ei = &element_info[i];
3123 // this pointer might have been changed in the level editor
3124 ei->change = &ei->change_page[0];
3126 if (!IS_CUSTOM_ELEMENT(i))
3128 ei->change->target_element = EL_EMPTY_SPACE;
3129 ei->change->delay_fixed = 0;
3130 ei->change->delay_random = 0;
3131 ei->change->delay_frames = 1;
3134 for (j = 0; j < NUM_CHANGE_EVENTS; j++)
3136 ei->has_change_event[j] = FALSE;
3138 ei->event_page_nr[j] = 0;
3139 ei->event_page[j] = &ei->change_page[0];
3143 // add changing elements from pre-defined list
3144 for (i = 0; change_delay_list[i].element != EL_UNDEFINED; i++)
3146 struct ChangingElementInfo *ch_delay = &change_delay_list[i];
3147 struct ElementInfo *ei = &element_info[ch_delay->element];
3149 ei->change->target_element = ch_delay->target_element;
3150 ei->change->delay_fixed = ch_delay->change_delay;
3152 ei->change->pre_change_function = ch_delay->pre_change_function;
3153 ei->change->change_function = ch_delay->change_function;
3154 ei->change->post_change_function = ch_delay->post_change_function;
3156 ei->change->can_change = TRUE;
3157 ei->change->can_change_or_has_action = TRUE;
3159 ei->has_change_event[CE_DELAY] = TRUE;
3161 SET_PROPERTY(ch_delay->element, EP_CAN_CHANGE, TRUE);
3162 SET_PROPERTY(ch_delay->element, EP_CAN_CHANGE_OR_HAS_ACTION, TRUE);
3165 // ---------- initialize internal run-time variables ------------------------
3167 for (i = 0; i < NUM_CUSTOM_ELEMENTS; i++)
3169 struct ElementInfo *ei = &element_info[EL_CUSTOM_START + i];
3171 for (j = 0; j < ei->num_change_pages; j++)
3173 ei->change_page[j].can_change_or_has_action =
3174 (ei->change_page[j].can_change |
3175 ei->change_page[j].has_action);
3179 // add change events from custom element configuration
3180 for (i = 0; i < NUM_CUSTOM_ELEMENTS; i++)
3182 struct ElementInfo *ei = &element_info[EL_CUSTOM_START + i];
3184 for (j = 0; j < ei->num_change_pages; j++)
3186 if (!ei->change_page[j].can_change_or_has_action)
3189 for (k = 0; k < NUM_CHANGE_EVENTS; k++)
3191 // only add event page for the first page found with this event
3192 if (ei->change_page[j].has_event[k] && !(ei->has_change_event[k]))
3194 ei->has_change_event[k] = TRUE;
3196 ei->event_page_nr[k] = j;
3197 ei->event_page[k] = &ei->change_page[j];
3203 // ---------- initialize reference elements in change conditions ------------
3205 for (i = 0; i < NUM_CUSTOM_ELEMENTS; i++)
3207 int element = EL_CUSTOM_START + i;
3208 struct ElementInfo *ei = &element_info[element];
3210 for (j = 0; j < ei->num_change_pages; j++)
3212 int trigger_element = ei->change_page[j].initial_trigger_element;
3214 if (trigger_element >= EL_PREV_CE_8 &&
3215 trigger_element <= EL_NEXT_CE_8)
3216 trigger_element = RESOLVED_REFERENCE_ELEMENT(element, trigger_element);
3218 ei->change_page[j].trigger_element = trigger_element;
3222 // ---------- initialize run-time trigger player and element ----------------
3224 for (i = 0; i < NUM_CUSTOM_ELEMENTS; i++)
3226 struct ElementInfo *ei = &element_info[EL_CUSTOM_START + i];
3228 for (j = 0; j < ei->num_change_pages; j++)
3230 ei->change_page[j].actual_trigger_element = EL_EMPTY;
3231 ei->change_page[j].actual_trigger_player = EL_EMPTY;
3232 ei->change_page[j].actual_trigger_player_bits = CH_PLAYER_NONE;
3233 ei->change_page[j].actual_trigger_side = CH_SIDE_NONE;
3234 ei->change_page[j].actual_trigger_ce_value = 0;
3235 ei->change_page[j].actual_trigger_ce_score = 0;
3239 // ---------- initialize trigger events -------------------------------------
3241 // initialize trigger events information
3242 for (i = 0; i < MAX_NUM_ELEMENTS; i++)
3243 for (j = 0; j < NUM_CHANGE_EVENTS; j++)
3244 trigger_events[i][j] = FALSE;
3246 // add trigger events from element change event properties
3247 for (i = 0; i < MAX_NUM_ELEMENTS; i++)
3249 struct ElementInfo *ei = &element_info[i];
3251 for (j = 0; j < ei->num_change_pages; j++)
3253 if (!ei->change_page[j].can_change_or_has_action)
3256 if (ei->change_page[j].has_event[CE_BY_OTHER_ACTION])
3258 int trigger_element = ei->change_page[j].trigger_element;
3260 for (k = 0; k < NUM_CHANGE_EVENTS; k++)
3262 if (ei->change_page[j].has_event[k])
3264 if (IS_GROUP_ELEMENT(trigger_element))
3266 struct ElementGroupInfo *group =
3267 element_info[trigger_element].group;
3269 for (l = 0; l < group->num_elements_resolved; l++)
3270 trigger_events[group->element_resolved[l]][k] = TRUE;
3272 else if (trigger_element == EL_ANY_ELEMENT)
3273 for (l = 0; l < MAX_NUM_ELEMENTS; l++)
3274 trigger_events[l][k] = TRUE;
3276 trigger_events[trigger_element][k] = TRUE;
3283 // ---------- initialize push delay -----------------------------------------
3285 // initialize push delay values to default
3286 for (i = 0; i < MAX_NUM_ELEMENTS; i++)
3288 if (!IS_CUSTOM_ELEMENT(i))
3290 // set default push delay values (corrected since version 3.0.7-1)
3291 if (game.engine_version < VERSION_IDENT(3,0,7,1))
3293 element_info[i].push_delay_fixed = 2;
3294 element_info[i].push_delay_random = 8;
3298 element_info[i].push_delay_fixed = 8;
3299 element_info[i].push_delay_random = 8;
3304 // set push delay value for certain elements from pre-defined list
3305 for (i = 0; push_delay_list[i].element != EL_UNDEFINED; i++)
3307 int e = push_delay_list[i].element;
3309 element_info[e].push_delay_fixed = push_delay_list[i].push_delay_fixed;
3310 element_info[e].push_delay_random = push_delay_list[i].push_delay_random;
3313 // set push delay value for Supaplex elements for newer engine versions
3314 if (game.engine_version >= VERSION_IDENT(3,1,0,0))
3316 for (i = 0; i < MAX_NUM_ELEMENTS; i++)
3318 if (IS_SP_ELEMENT(i))
3320 // set SP push delay to just enough to push under a falling zonk
3321 int delay = (game.engine_version >= VERSION_IDENT(3,1,1,0) ? 8 : 6);
3323 element_info[i].push_delay_fixed = delay;
3324 element_info[i].push_delay_random = 0;
3329 // ---------- initialize move stepsize --------------------------------------
3331 // initialize move stepsize values to default
3332 for (i = 0; i < MAX_NUM_ELEMENTS; i++)
3333 if (!IS_CUSTOM_ELEMENT(i))
3334 element_info[i].move_stepsize = MOVE_STEPSIZE_NORMAL;
3336 // set move stepsize value for certain elements from pre-defined list
3337 for (i = 0; move_stepsize_list[i].element != EL_UNDEFINED; i++)
3339 int e = move_stepsize_list[i].element;
3341 element_info[e].move_stepsize = move_stepsize_list[i].move_stepsize;
3343 // set move stepsize value for certain elements for older engine versions
3344 if (use_old_move_stepsize_for_magic_wall)
3346 if (e == EL_MAGIC_WALL_FILLING ||
3347 e == EL_MAGIC_WALL_EMPTYING ||
3348 e == EL_BD_MAGIC_WALL_FILLING ||
3349 e == EL_BD_MAGIC_WALL_EMPTYING)
3350 element_info[e].move_stepsize *= 2;
3354 // ---------- initialize collect score --------------------------------------
3356 // initialize collect score values for custom elements from initial value
3357 for (i = 0; i < MAX_NUM_ELEMENTS; i++)
3358 if (IS_CUSTOM_ELEMENT(i))
3359 element_info[i].collect_score = element_info[i].collect_score_initial;
3361 // ---------- initialize collect count --------------------------------------
3363 // initialize collect count values for non-custom elements
3364 for (i = 0; i < MAX_NUM_ELEMENTS; i++)
3365 if (!IS_CUSTOM_ELEMENT(i))
3366 element_info[i].collect_count_initial = 0;
3368 // add collect count values for all elements from pre-defined list
3369 for (i = 0; collect_count_list[i].element != EL_UNDEFINED; i++)
3370 element_info[collect_count_list[i].element].collect_count_initial =
3371 collect_count_list[i].count;
3373 // ---------- initialize access direction -----------------------------------
3375 // initialize access direction values to default (access from every side)
3376 for (i = 0; i < MAX_NUM_ELEMENTS; i++)
3377 if (!IS_CUSTOM_ELEMENT(i))
3378 element_info[i].access_direction = MV_ALL_DIRECTIONS;
3380 // set access direction value for certain elements from pre-defined list
3381 for (i = 0; access_direction_list[i].element != EL_UNDEFINED; i++)
3382 element_info[access_direction_list[i].element].access_direction =
3383 access_direction_list[i].direction;
3385 // ---------- initialize explosion content ----------------------------------
3386 for (i = 0; i < MAX_NUM_ELEMENTS; i++)
3388 if (IS_CUSTOM_ELEMENT(i))
3391 for (y = 0; y < 3; y++) for (x = 0; x < 3; x++)
3393 // (content for EL_YAMYAM set at run-time with game.yamyam_content_nr)
3395 element_info[i].content.e[x][y] =
3396 (i == EL_PLAYER_1 ? EL_EMERALD_YELLOW :
3397 i == EL_PLAYER_2 ? EL_EMERALD_RED :
3398 i == EL_PLAYER_3 ? EL_EMERALD :
3399 i == EL_PLAYER_4 ? EL_EMERALD_PURPLE :
3400 i == EL_MOLE ? EL_EMERALD_RED :
3401 i == EL_PENGUIN ? EL_EMERALD_PURPLE :
3402 i == EL_BUG ? (x == 1 && y == 1 ? EL_DIAMOND : EL_EMERALD) :
3403 i == EL_BD_BUTTERFLY ? EL_BD_DIAMOND :
3404 i == EL_SP_ELECTRON ? EL_SP_INFOTRON :
3405 i == EL_AMOEBA_TO_DIAMOND ? level.amoeba_content :
3406 i == EL_WALL_EMERALD ? EL_EMERALD :
3407 i == EL_WALL_DIAMOND ? EL_DIAMOND :
3408 i == EL_WALL_BD_DIAMOND ? EL_BD_DIAMOND :
3409 i == EL_WALL_EMERALD_YELLOW ? EL_EMERALD_YELLOW :
3410 i == EL_WALL_EMERALD_RED ? EL_EMERALD_RED :
3411 i == EL_WALL_EMERALD_PURPLE ? EL_EMERALD_PURPLE :
3412 i == EL_WALL_PEARL ? EL_PEARL :
3413 i == EL_WALL_CRYSTAL ? EL_CRYSTAL :
3418 // ---------- initialize recursion detection --------------------------------
3419 recursion_loop_depth = 0;
3420 recursion_loop_detected = FALSE;
3421 recursion_loop_element = EL_UNDEFINED;
3423 // ---------- initialize graphics engine ------------------------------------
3424 game.scroll_delay_value =
3425 (game.forced_scroll_delay_value != -1 ? game.forced_scroll_delay_value :
3426 level.game_engine_type == GAME_ENGINE_TYPE_EM &&
3427 !setup.forced_scroll_delay ? 0 :
3428 setup.scroll_delay ? setup.scroll_delay_value : 0);
3429 game.scroll_delay_value =
3430 MIN(MAX(MIN_SCROLL_DELAY, game.scroll_delay_value), MAX_SCROLL_DELAY);
3432 // ---------- initialize game engine snapshots ------------------------------
3433 for (i = 0; i < MAX_PLAYERS; i++)
3434 game.snapshot.last_action[i] = 0;
3435 game.snapshot.changed_action = FALSE;
3436 game.snapshot.collected_item = FALSE;
3437 game.snapshot.mode =
3438 (strEqual(setup.engine_snapshot_mode, STR_SNAPSHOT_MODE_EVERY_STEP) ?
3439 SNAPSHOT_MODE_EVERY_STEP :
3440 strEqual(setup.engine_snapshot_mode, STR_SNAPSHOT_MODE_EVERY_MOVE) ?
3441 SNAPSHOT_MODE_EVERY_MOVE :
3442 strEqual(setup.engine_snapshot_mode, STR_SNAPSHOT_MODE_EVERY_COLLECT) ?
3443 SNAPSHOT_MODE_EVERY_COLLECT : SNAPSHOT_MODE_OFF);
3444 game.snapshot.save_snapshot = FALSE;
3446 // ---------- initialize level time for Supaplex engine ---------------------
3447 // Supaplex levels with time limit currently unsupported -- should be added
3448 if (level.game_engine_type == GAME_ENGINE_TYPE_SP)
3451 // ---------- initialize flags for handling game actions --------------------
3453 // set flags for game actions to default values
3454 game.use_key_actions = TRUE;
3455 game.use_mouse_actions = FALSE;
3457 // when using Mirror Magic game engine, handle mouse events only
3458 if (level.game_engine_type == GAME_ENGINE_TYPE_MM)
3460 game.use_key_actions = FALSE;
3461 game.use_mouse_actions = TRUE;
3464 // check for custom elements with mouse click events
3465 if (level.game_engine_type == GAME_ENGINE_TYPE_RND)
3467 for (i = 0; i < NUM_CUSTOM_ELEMENTS; i++)
3469 int element = EL_CUSTOM_START + i;
3471 if (HAS_CHANGE_EVENT(element, CE_CLICKED_BY_MOUSE) ||
3472 HAS_CHANGE_EVENT(element, CE_PRESSED_BY_MOUSE) ||
3473 HAS_CHANGE_EVENT(element, CE_MOUSE_CLICKED_ON_X) ||
3474 HAS_CHANGE_EVENT(element, CE_MOUSE_PRESSED_ON_X))
3475 game.use_mouse_actions = TRUE;
3480 static int get_num_special_action(int element, int action_first,
3483 int num_special_action = 0;
3486 for (i = action_first; i <= action_last; i++)
3488 boolean found = FALSE;
3490 for (j = 0; j < NUM_DIRECTIONS; j++)
3491 if (el_act_dir2img(element, i, j) !=
3492 el_act_dir2img(element, ACTION_DEFAULT, j))
3496 num_special_action++;
3501 return num_special_action;
3505 // ============================================================================
3507 // ----------------------------------------------------------------------------
3508 // initialize and start new game
3509 // ============================================================================
3511 #if DEBUG_INIT_PLAYER
3512 static void DebugPrintPlayerStatus(char *message)
3519 Debug("game:init:player", "%s:", message);
3521 for (i = 0; i < MAX_PLAYERS; i++)
3523 struct PlayerInfo *player = &stored_player[i];
3525 Debug("game:init:player",
3526 "- player %d: present == %d, connected == %d [%d/%d], active == %d%s",
3530 player->connected_locally,
3531 player->connected_network,
3533 (local_player == player ? " (local player)" : ""));
3540 int full_lev_fieldx = lev_fieldx + (BorderElement != EL_EMPTY ? 2 : 0);
3541 int full_lev_fieldy = lev_fieldy + (BorderElement != EL_EMPTY ? 2 : 0);
3542 int fade_mask = REDRAW_FIELD;
3544 boolean emulate_bd = TRUE; // unless non-BOULDERDASH elements found
3545 boolean emulate_sb = TRUE; // unless non-SOKOBAN elements found
3546 boolean emulate_sp = TRUE; // unless non-SUPAPLEX elements found
3547 int initial_move_dir = MV_DOWN;
3550 // required here to update video display before fading (FIX THIS)
3551 DrawMaskedBorder(REDRAW_DOOR_2);
3553 if (!game.restart_level)
3554 CloseDoor(DOOR_CLOSE_1);
3556 SetGameStatus(GAME_MODE_PLAYING);
3558 if (level_editor_test_game)
3559 FadeSkipNextFadeOut();
3561 FadeSetEnterScreen();
3564 fade_mask = REDRAW_ALL;
3566 FadeLevelSoundsAndMusic();
3568 ExpireSoundLoops(TRUE);
3572 if (level_editor_test_game)
3573 FadeSkipNextFadeIn();
3575 // needed if different viewport properties defined for playing
3576 ChangeViewportPropertiesIfNeeded();
3580 DrawCompleteVideoDisplay();
3582 OpenDoor(GetDoorState() | DOOR_NO_DELAY | DOOR_FORCE_REDRAW);
3585 InitGameControlValues();
3589 // initialize tape actions from game when recording tape
3590 tape.use_key_actions = game.use_key_actions;
3591 tape.use_mouse_actions = game.use_mouse_actions;
3593 // initialize visible playfield size when recording tape (for team mode)
3594 tape.scr_fieldx = SCR_FIELDX;
3595 tape.scr_fieldy = SCR_FIELDY;
3598 // don't play tapes over network
3599 network_playing = (network.enabled && !tape.playing);
3601 for (i = 0; i < MAX_PLAYERS; i++)
3603 struct PlayerInfo *player = &stored_player[i];
3605 player->index_nr = i;
3606 player->index_bit = (1 << i);
3607 player->element_nr = EL_PLAYER_1 + i;
3609 player->present = FALSE;
3610 player->active = FALSE;
3611 player->mapped = FALSE;
3613 player->killed = FALSE;
3614 player->reanimated = FALSE;
3615 player->buried = FALSE;
3618 player->effective_action = 0;
3619 player->programmed_action = 0;
3620 player->snap_action = 0;
3622 player->mouse_action.lx = 0;
3623 player->mouse_action.ly = 0;
3624 player->mouse_action.button = 0;
3625 player->mouse_action.button_hint = 0;
3627 player->effective_mouse_action.lx = 0;
3628 player->effective_mouse_action.ly = 0;
3629 player->effective_mouse_action.button = 0;
3630 player->effective_mouse_action.button_hint = 0;
3632 for (j = 0; j < MAX_NUM_KEYS; j++)
3633 player->key[j] = FALSE;
3635 player->num_white_keys = 0;
3637 player->dynabomb_count = 0;
3638 player->dynabomb_size = 1;
3639 player->dynabombs_left = 0;
3640 player->dynabomb_xl = FALSE;
3642 player->MovDir = initial_move_dir;
3645 player->GfxDir = initial_move_dir;
3646 player->GfxAction = ACTION_DEFAULT;
3648 player->StepFrame = 0;
3650 player->initial_element = player->element_nr;
3651 player->artwork_element =
3652 (level.use_artwork_element[i] ? level.artwork_element[i] :
3653 player->element_nr);
3654 player->use_murphy = FALSE;
3656 player->block_last_field = FALSE; // initialized in InitPlayerField()
3657 player->block_delay_adjustment = 0; // initialized in InitPlayerField()
3659 player->gravity = level.initial_player_gravity[i];
3661 player->can_fall_into_acid = CAN_MOVE_INTO_ACID(player->element_nr);
3663 player->actual_frame_counter = 0;
3665 player->step_counter = 0;
3667 player->last_move_dir = initial_move_dir;
3669 player->is_active = FALSE;
3671 player->is_waiting = FALSE;
3672 player->is_moving = FALSE;
3673 player->is_auto_moving = FALSE;
3674 player->is_digging = FALSE;
3675 player->is_snapping = FALSE;
3676 player->is_collecting = FALSE;
3677 player->is_pushing = FALSE;
3678 player->is_switching = FALSE;
3679 player->is_dropping = FALSE;
3680 player->is_dropping_pressed = FALSE;
3682 player->is_bored = FALSE;
3683 player->is_sleeping = FALSE;
3685 player->was_waiting = TRUE;
3686 player->was_moving = FALSE;
3687 player->was_snapping = FALSE;
3688 player->was_dropping = FALSE;
3690 player->force_dropping = FALSE;
3692 player->frame_counter_bored = -1;
3693 player->frame_counter_sleeping = -1;
3695 player->anim_delay_counter = 0;
3696 player->post_delay_counter = 0;
3698 player->dir_waiting = initial_move_dir;
3699 player->action_waiting = ACTION_DEFAULT;
3700 player->last_action_waiting = ACTION_DEFAULT;
3701 player->special_action_bored = ACTION_DEFAULT;
3702 player->special_action_sleeping = ACTION_DEFAULT;
3704 player->switch_x = -1;
3705 player->switch_y = -1;
3707 player->drop_x = -1;
3708 player->drop_y = -1;
3710 player->show_envelope = 0;
3712 SetPlayerMoveSpeed(player, level.initial_player_stepsize[i], TRUE);
3714 player->push_delay = -1; // initialized when pushing starts
3715 player->push_delay_value = game.initial_push_delay_value;
3717 player->drop_delay = 0;
3718 player->drop_pressed_delay = 0;
3720 player->last_jx = -1;
3721 player->last_jy = -1;
3725 player->shield_normal_time_left = 0;
3726 player->shield_deadly_time_left = 0;
3728 player->last_removed_element = EL_UNDEFINED;
3730 player->inventory_infinite_element = EL_UNDEFINED;
3731 player->inventory_size = 0;
3733 if (level.use_initial_inventory[i])
3735 for (j = 0; j < level.initial_inventory_size[i]; j++)
3737 int element = level.initial_inventory_content[i][j];
3738 int collect_count = element_info[element].collect_count_initial;
3741 if (!IS_CUSTOM_ELEMENT(element))
3744 if (collect_count == 0)
3745 player->inventory_infinite_element = element;
3747 for (k = 0; k < collect_count; k++)
3748 if (player->inventory_size < MAX_INVENTORY_SIZE)
3749 player->inventory_element[player->inventory_size++] = element;
3753 DigField(player, 0, 0, 0, 0, 0, 0, DF_NO_PUSH);
3754 SnapField(player, 0, 0);
3756 map_player_action[i] = i;
3759 network_player_action_received = FALSE;
3761 // initial null action
3762 if (network_playing)
3763 SendToServer_MovePlayer(MV_NONE);
3768 TimeLeft = level.time;
3771 ScreenMovDir = MV_NONE;
3775 ScrollStepSize = 0; // will be correctly initialized by ScrollScreen()
3777 game.robot_wheel_x = -1;
3778 game.robot_wheel_y = -1;
3783 game.all_players_gone = FALSE;
3785 game.LevelSolved = FALSE;
3786 game.GameOver = FALSE;
3788 game.GamePlayed = !tape.playing;
3790 game.LevelSolved_GameWon = FALSE;
3791 game.LevelSolved_GameEnd = FALSE;
3792 game.LevelSolved_SaveTape = FALSE;
3793 game.LevelSolved_SaveScore = FALSE;
3795 game.LevelSolved_CountingTime = 0;
3796 game.LevelSolved_CountingScore = 0;
3797 game.LevelSolved_CountingHealth = 0;
3799 game.panel.active = TRUE;
3801 game.no_time_limit = (level.time == 0);
3803 game.yamyam_content_nr = 0;
3804 game.robot_wheel_active = FALSE;
3805 game.magic_wall_active = FALSE;
3806 game.magic_wall_time_left = 0;
3807 game.light_time_left = 0;
3808 game.timegate_time_left = 0;
3809 game.switchgate_pos = 0;
3810 game.wind_direction = level.wind_direction_initial;
3812 game.time_final = 0;
3813 game.score_time_final = 0;
3816 game.score_final = 0;
3818 game.health = MAX_HEALTH;
3819 game.health_final = MAX_HEALTH;
3821 game.gems_still_needed = level.gems_needed;
3822 game.sokoban_fields_still_needed = 0;
3823 game.sokoban_objects_still_needed = 0;
3824 game.lights_still_needed = 0;
3825 game.players_still_needed = 0;
3826 game.friends_still_needed = 0;
3828 game.lenses_time_left = 0;
3829 game.magnify_time_left = 0;
3831 game.ball_active = level.ball_active_initial;
3832 game.ball_content_nr = 0;
3834 game.explosions_delayed = TRUE;
3836 game.envelope_active = FALSE;
3838 for (i = 0; i < NUM_BELTS; i++)
3840 game.belt_dir[i] = MV_NONE;
3841 game.belt_dir_nr[i] = 3; // not moving, next moving left
3844 for (i = 0; i < MAX_NUM_AMOEBA; i++)
3845 AmoebaCnt[i] = AmoebaCnt2[i] = 0;
3847 #if DEBUG_INIT_PLAYER
3848 DebugPrintPlayerStatus("Player status at level initialization");
3851 SCAN_PLAYFIELD(x, y)
3853 Tile[x][y] = Last[x][y] = level.field[x][y];
3854 MovPos[x][y] = MovDir[x][y] = MovDelay[x][y] = 0;
3855 ChangeDelay[x][y] = 0;
3856 ChangePage[x][y] = -1;
3857 CustomValue[x][y] = 0; // initialized in InitField()
3858 Store[x][y] = Store2[x][y] = StorePlayer[x][y] = Back[x][y] = 0;
3860 WasJustMoving[x][y] = 0;
3861 WasJustFalling[x][y] = 0;
3862 CheckCollision[x][y] = 0;
3863 CheckImpact[x][y] = 0;
3865 Pushed[x][y] = FALSE;
3867 ChangeCount[x][y] = 0;
3868 ChangeEvent[x][y] = -1;
3870 ExplodePhase[x][y] = 0;
3871 ExplodeDelay[x][y] = 0;
3872 ExplodeField[x][y] = EX_TYPE_NONE;
3874 RunnerVisit[x][y] = 0;
3875 PlayerVisit[x][y] = 0;
3878 GfxRandom[x][y] = INIT_GFX_RANDOM();
3879 GfxElement[x][y] = EL_UNDEFINED;
3880 GfxAction[x][y] = ACTION_DEFAULT;
3881 GfxDir[x][y] = MV_NONE;
3882 GfxRedraw[x][y] = GFX_REDRAW_NONE;
3885 SCAN_PLAYFIELD(x, y)
3887 if (emulate_bd && !IS_BD_ELEMENT(Tile[x][y]))
3889 if (emulate_sb && !IS_SB_ELEMENT(Tile[x][y]))
3891 if (emulate_sp && !IS_SP_ELEMENT(Tile[x][y]))
3894 InitField(x, y, TRUE);
3896 ResetGfxAnimation(x, y);
3901 for (i = 0; i < MAX_PLAYERS; i++)
3903 struct PlayerInfo *player = &stored_player[i];
3905 // set number of special actions for bored and sleeping animation
3906 player->num_special_action_bored =
3907 get_num_special_action(player->artwork_element,
3908 ACTION_BORING_1, ACTION_BORING_LAST);
3909 player->num_special_action_sleeping =
3910 get_num_special_action(player->artwork_element,
3911 ACTION_SLEEPING_1, ACTION_SLEEPING_LAST);
3914 game.emulation = (emulate_bd ? EMU_BOULDERDASH :
3915 emulate_sb ? EMU_SOKOBAN :
3916 emulate_sp ? EMU_SUPAPLEX : EMU_NONE);
3918 // initialize type of slippery elements
3919 for (i = 0; i < MAX_NUM_ELEMENTS; i++)
3921 if (!IS_CUSTOM_ELEMENT(i))
3923 // default: elements slip down either to the left or right randomly
3924 element_info[i].slippery_type = SLIPPERY_ANY_RANDOM;
3926 // SP style elements prefer to slip down on the left side
3927 if (game.engine_version >= VERSION_IDENT(3,1,1,0) && IS_SP_ELEMENT(i))
3928 element_info[i].slippery_type = SLIPPERY_ANY_LEFT_RIGHT;
3930 // BD style elements prefer to slip down on the left side
3931 if (game.emulation == EMU_BOULDERDASH)
3932 element_info[i].slippery_type = SLIPPERY_ANY_LEFT_RIGHT;
3936 // initialize explosion and ignition delay
3937 for (i = 0; i < MAX_NUM_ELEMENTS; i++)
3939 if (!IS_CUSTOM_ELEMENT(i))
3942 int delay = (((IS_SP_ELEMENT(i) && i != EL_EMPTY_SPACE) &&
3943 game.engine_version >= VERSION_IDENT(3,1,0,0)) ||
3944 game.emulation == EMU_SUPAPLEX ? 3 : 2);
3945 int last_phase = (num_phase + 1) * delay;
3946 int half_phase = (num_phase / 2) * delay;
3948 element_info[i].explosion_delay = last_phase - 1;
3949 element_info[i].ignition_delay = half_phase;
3951 if (i == EL_BLACK_ORB)
3952 element_info[i].ignition_delay = 1;
3956 // correct non-moving belts to start moving left
3957 for (i = 0; i < NUM_BELTS; i++)
3958 if (game.belt_dir[i] == MV_NONE)
3959 game.belt_dir_nr[i] = 3; // not moving, next moving left
3961 #if USE_NEW_PLAYER_ASSIGNMENTS
3962 // use preferred player also in local single-player mode
3963 if (!network.enabled && !game.team_mode)
3965 int new_index_nr = setup.network_player_nr;
3967 if (new_index_nr >= 0 && new_index_nr < MAX_PLAYERS)
3969 for (i = 0; i < MAX_PLAYERS; i++)
3970 stored_player[i].connected_locally = FALSE;
3972 stored_player[new_index_nr].connected_locally = TRUE;
3976 for (i = 0; i < MAX_PLAYERS; i++)
3978 stored_player[i].connected = FALSE;
3980 // in network game mode, the local player might not be the first player
3981 if (stored_player[i].connected_locally)
3982 local_player = &stored_player[i];
3985 if (!network.enabled)
3986 local_player->connected = TRUE;
3990 for (i = 0; i < MAX_PLAYERS; i++)
3991 stored_player[i].connected = tape.player_participates[i];
3993 else if (network.enabled)
3995 // add team mode players connected over the network (needed for correct
3996 // assignment of player figures from level to locally playing players)
3998 for (i = 0; i < MAX_PLAYERS; i++)
3999 if (stored_player[i].connected_network)
4000 stored_player[i].connected = TRUE;
4002 else if (game.team_mode)
4004 // try to guess locally connected team mode players (needed for correct
4005 // assignment of player figures from level to locally playing players)
4007 for (i = 0; i < MAX_PLAYERS; i++)
4008 if (setup.input[i].use_joystick ||
4009 setup.input[i].key.left != KSYM_UNDEFINED)
4010 stored_player[i].connected = TRUE;
4013 #if DEBUG_INIT_PLAYER
4014 DebugPrintPlayerStatus("Player status after level initialization");
4017 #if DEBUG_INIT_PLAYER
4018 Debug("game:init:player", "Reassigning players ...");
4021 // check if any connected player was not found in playfield
4022 for (i = 0; i < MAX_PLAYERS; i++)
4024 struct PlayerInfo *player = &stored_player[i];
4026 if (player->connected && !player->present)
4028 struct PlayerInfo *field_player = NULL;
4030 #if DEBUG_INIT_PLAYER
4031 Debug("game:init:player",
4032 "- looking for field player for player %d ...", i + 1);
4035 // assign first free player found that is present in the playfield
4037 // first try: look for unmapped playfield player that is not connected
4038 for (j = 0; j < MAX_PLAYERS; j++)
4039 if (field_player == NULL &&
4040 stored_player[j].present &&
4041 !stored_player[j].mapped &&
4042 !stored_player[j].connected)
4043 field_player = &stored_player[j];
4045 // second try: look for *any* unmapped playfield player
4046 for (j = 0; j < MAX_PLAYERS; j++)
4047 if (field_player == NULL &&
4048 stored_player[j].present &&
4049 !stored_player[j].mapped)
4050 field_player = &stored_player[j];
4052 if (field_player != NULL)
4054 int jx = field_player->jx, jy = field_player->jy;
4056 #if DEBUG_INIT_PLAYER
4057 Debug("game:init:player", "- found player %d",
4058 field_player->index_nr + 1);
4061 player->present = FALSE;
4062 player->active = FALSE;
4064 field_player->present = TRUE;
4065 field_player->active = TRUE;
4068 player->initial_element = field_player->initial_element;
4069 player->artwork_element = field_player->artwork_element;
4071 player->block_last_field = field_player->block_last_field;
4072 player->block_delay_adjustment = field_player->block_delay_adjustment;
4075 StorePlayer[jx][jy] = field_player->element_nr;
4077 field_player->jx = field_player->last_jx = jx;
4078 field_player->jy = field_player->last_jy = jy;
4080 if (local_player == player)
4081 local_player = field_player;
4083 map_player_action[field_player->index_nr] = i;
4085 field_player->mapped = TRUE;
4087 #if DEBUG_INIT_PLAYER
4088 Debug("game:init:player", "- map_player_action[%d] == %d",
4089 field_player->index_nr + 1, i + 1);
4094 if (player->connected && player->present)
4095 player->mapped = TRUE;
4098 #if DEBUG_INIT_PLAYER
4099 DebugPrintPlayerStatus("Player status after player assignment (first stage)");
4104 // check if any connected player was not found in playfield
4105 for (i = 0; i < MAX_PLAYERS; i++)
4107 struct PlayerInfo *player = &stored_player[i];
4109 if (player->connected && !player->present)
4111 for (j = 0; j < MAX_PLAYERS; j++)
4113 struct PlayerInfo *field_player = &stored_player[j];
4114 int jx = field_player->jx, jy = field_player->jy;
4116 // assign first free player found that is present in the playfield
4117 if (field_player->present && !field_player->connected)
4119 player->present = TRUE;
4120 player->active = TRUE;
4122 field_player->present = FALSE;
4123 field_player->active = FALSE;
4125 player->initial_element = field_player->initial_element;
4126 player->artwork_element = field_player->artwork_element;
4128 player->block_last_field = field_player->block_last_field;
4129 player->block_delay_adjustment = field_player->block_delay_adjustment;
4131 StorePlayer[jx][jy] = player->element_nr;
4133 player->jx = player->last_jx = jx;
4134 player->jy = player->last_jy = jy;
4144 Debug("game:init:player", "local_player->present == %d",
4145 local_player->present);
4148 // set focus to local player for network games, else to all players
4149 game.centered_player_nr = (network_playing ? local_player->index_nr : -1);
4150 game.centered_player_nr_next = game.centered_player_nr;
4151 game.set_centered_player = FALSE;
4152 game.set_centered_player_wrap = FALSE;
4154 if (network_playing && tape.recording)
4156 // store client dependent player focus when recording network games
4157 tape.centered_player_nr_next = game.centered_player_nr_next;
4158 tape.set_centered_player = TRUE;
4163 // when playing a tape, eliminate all players who do not participate
4165 #if USE_NEW_PLAYER_ASSIGNMENTS
4167 if (!game.team_mode)
4169 for (i = 0; i < MAX_PLAYERS; i++)
4171 if (stored_player[i].active &&
4172 !tape.player_participates[map_player_action[i]])
4174 struct PlayerInfo *player = &stored_player[i];
4175 int jx = player->jx, jy = player->jy;
4177 #if DEBUG_INIT_PLAYER
4178 Debug("game:init:player", "Removing player %d at (%d, %d)",
4182 player->active = FALSE;
4183 StorePlayer[jx][jy] = 0;
4184 Tile[jx][jy] = EL_EMPTY;
4191 for (i = 0; i < MAX_PLAYERS; i++)
4193 if (stored_player[i].active &&
4194 !tape.player_participates[i])
4196 struct PlayerInfo *player = &stored_player[i];
4197 int jx = player->jx, jy = player->jy;
4199 player->active = FALSE;
4200 StorePlayer[jx][jy] = 0;
4201 Tile[jx][jy] = EL_EMPTY;
4206 else if (!network.enabled && !game.team_mode) // && !tape.playing
4208 // when in single player mode, eliminate all but the local player
4210 for (i = 0; i < MAX_PLAYERS; i++)
4212 struct PlayerInfo *player = &stored_player[i];
4214 if (player->active && player != local_player)
4216 int jx = player->jx, jy = player->jy;
4218 player->active = FALSE;
4219 player->present = FALSE;
4221 StorePlayer[jx][jy] = 0;
4222 Tile[jx][jy] = EL_EMPTY;
4227 for (i = 0; i < MAX_PLAYERS; i++)
4228 if (stored_player[i].active)
4229 game.players_still_needed++;
4231 if (level.solved_by_one_player)
4232 game.players_still_needed = 1;
4234 // when recording the game, store which players take part in the game
4237 #if USE_NEW_PLAYER_ASSIGNMENTS
4238 for (i = 0; i < MAX_PLAYERS; i++)
4239 if (stored_player[i].connected)
4240 tape.player_participates[i] = TRUE;
4242 for (i = 0; i < MAX_PLAYERS; i++)
4243 if (stored_player[i].active)
4244 tape.player_participates[i] = TRUE;
4248 #if DEBUG_INIT_PLAYER
4249 DebugPrintPlayerStatus("Player status after player assignment (final stage)");
4252 if (BorderElement == EL_EMPTY)
4255 SBX_Right = lev_fieldx - SCR_FIELDX;
4257 SBY_Lower = lev_fieldy - SCR_FIELDY;
4262 SBX_Right = lev_fieldx - SCR_FIELDX + 1;
4264 SBY_Lower = lev_fieldy - SCR_FIELDY + 1;
4267 if (full_lev_fieldx <= SCR_FIELDX)
4268 SBX_Left = SBX_Right = -1 * (SCR_FIELDX - lev_fieldx) / 2;
4269 if (full_lev_fieldy <= SCR_FIELDY)
4270 SBY_Upper = SBY_Lower = -1 * (SCR_FIELDY - lev_fieldy) / 2;
4272 if (EVEN(SCR_FIELDX) && full_lev_fieldx > SCR_FIELDX)
4274 if (EVEN(SCR_FIELDY) && full_lev_fieldy > SCR_FIELDY)
4277 // if local player not found, look for custom element that might create
4278 // the player (make some assumptions about the right custom element)
4279 if (!local_player->present)
4281 int start_x = 0, start_y = 0;
4282 int found_rating = 0;
4283 int found_element = EL_UNDEFINED;
4284 int player_nr = local_player->index_nr;
4286 SCAN_PLAYFIELD(x, y)
4288 int element = Tile[x][y];
4293 if (level.use_start_element[player_nr] &&
4294 level.start_element[player_nr] == element &&
4301 found_element = element;
4304 if (!IS_CUSTOM_ELEMENT(element))
4307 if (CAN_CHANGE(element))
4309 for (i = 0; i < element_info[element].num_change_pages; i++)
4311 // check for player created from custom element as single target
4312 content = element_info[element].change_page[i].target_element;
4313 is_player = ELEM_IS_PLAYER(content);
4315 if (is_player && (found_rating < 3 ||
4316 (found_rating == 3 && element < found_element)))
4322 found_element = element;
4327 for (yy = 0; yy < 3; yy++) for (xx = 0; xx < 3; xx++)
4329 // check for player created from custom element as explosion content
4330 content = element_info[element].content.e[xx][yy];
4331 is_player = ELEM_IS_PLAYER(content);
4333 if (is_player && (found_rating < 2 ||
4334 (found_rating == 2 && element < found_element)))
4336 start_x = x + xx - 1;
4337 start_y = y + yy - 1;
4340 found_element = element;
4343 if (!CAN_CHANGE(element))
4346 for (i = 0; i < element_info[element].num_change_pages; i++)
4348 // check for player created from custom element as extended target
4350 element_info[element].change_page[i].target_content.e[xx][yy];
4352 is_player = ELEM_IS_PLAYER(content);
4354 if (is_player && (found_rating < 1 ||
4355 (found_rating == 1 && element < found_element)))
4357 start_x = x + xx - 1;
4358 start_y = y + yy - 1;
4361 found_element = element;
4367 scroll_x = SCROLL_POSITION_X(start_x);
4368 scroll_y = SCROLL_POSITION_Y(start_y);
4372 scroll_x = SCROLL_POSITION_X(local_player->jx);
4373 scroll_y = SCROLL_POSITION_Y(local_player->jy);
4376 // !!! FIX THIS (START) !!!
4377 if (level.game_engine_type == GAME_ENGINE_TYPE_EM)
4379 InitGameEngine_EM();
4381 else if (level.game_engine_type == GAME_ENGINE_TYPE_SP)
4383 InitGameEngine_SP();
4385 else if (level.game_engine_type == GAME_ENGINE_TYPE_MM)
4387 InitGameEngine_MM();
4391 DrawLevel(REDRAW_FIELD);
4394 // after drawing the level, correct some elements
4395 if (game.timegate_time_left == 0)
4396 CloseAllOpenTimegates();
4399 // blit playfield from scroll buffer to normal back buffer for fading in
4400 BlitScreenToBitmap(backbuffer);
4401 // !!! FIX THIS (END) !!!
4403 DrawMaskedBorder(fade_mask);
4408 // full screen redraw is required at this point in the following cases:
4409 // - special editor door undrawn when game was started from level editor
4410 // - drawing area (playfield) was changed and has to be removed completely
4411 redraw_mask = REDRAW_ALL;
4415 if (!game.restart_level)
4417 // copy default game door content to main double buffer
4419 // !!! CHECK AGAIN !!!
4420 SetPanelBackground();
4421 // SetDoorBackgroundImage(IMG_BACKGROUND_PANEL);
4422 DrawBackground(DX, DY, DXSIZE, DYSIZE);
4425 SetPanelBackground();
4426 SetDrawBackgroundMask(REDRAW_DOOR_1);
4428 UpdateAndDisplayGameControlValues();
4430 if (!game.restart_level)
4436 CreateGameButtons();
4441 // copy actual game door content to door double buffer for OpenDoor()
4442 BlitBitmap(drawto, bitmap_db_door_1, DX, DY, DXSIZE, DYSIZE, 0, 0);
4444 OpenDoor(DOOR_OPEN_ALL);
4446 KeyboardAutoRepeatOffUnlessAutoplay();
4448 #if DEBUG_INIT_PLAYER
4449 DebugPrintPlayerStatus("Player status (final)");
4458 if (!game.restart_level && !tape.playing)
4460 LevelStats_incPlayed(level_nr);
4462 SaveLevelSetup_SeriesInfo();
4465 game.restart_level = FALSE;
4466 game.restart_game_message = NULL;
4468 game.request_active = FALSE;
4469 game.request_active_or_moving = FALSE;
4471 if (level.game_engine_type == GAME_ENGINE_TYPE_MM)
4472 InitGameActions_MM();
4474 SaveEngineSnapshotToListInitial();
4476 if (!game.restart_level)
4478 PlaySound(SND_GAME_STARTING);
4480 if (setup.sound_music)
4485 void UpdateEngineValues(int actual_scroll_x, int actual_scroll_y,
4486 int actual_player_x, int actual_player_y)
4488 // this is used for non-R'n'D game engines to update certain engine values
4490 // needed to determine if sounds are played within the visible screen area
4491 scroll_x = actual_scroll_x;
4492 scroll_y = actual_scroll_y;
4494 // needed to get player position for "follow finger" playing input method
4495 local_player->jx = actual_player_x;
4496 local_player->jy = actual_player_y;
4499 void InitMovDir(int x, int y)
4501 int i, element = Tile[x][y];
4502 static int xy[4][2] =
4509 static int direction[3][4] =
4511 { MV_RIGHT, MV_UP, MV_LEFT, MV_DOWN },
4512 { MV_LEFT, MV_DOWN, MV_RIGHT, MV_UP },
4513 { MV_LEFT, MV_RIGHT, MV_UP, MV_DOWN }
4522 Tile[x][y] = EL_BUG;
4523 MovDir[x][y] = direction[0][element - EL_BUG_RIGHT];
4526 case EL_SPACESHIP_RIGHT:
4527 case EL_SPACESHIP_UP:
4528 case EL_SPACESHIP_LEFT:
4529 case EL_SPACESHIP_DOWN:
4530 Tile[x][y] = EL_SPACESHIP;
4531 MovDir[x][y] = direction[0][element - EL_SPACESHIP_RIGHT];
4534 case EL_BD_BUTTERFLY_RIGHT:
4535 case EL_BD_BUTTERFLY_UP:
4536 case EL_BD_BUTTERFLY_LEFT:
4537 case EL_BD_BUTTERFLY_DOWN:
4538 Tile[x][y] = EL_BD_BUTTERFLY;
4539 MovDir[x][y] = direction[0][element - EL_BD_BUTTERFLY_RIGHT];
4542 case EL_BD_FIREFLY_RIGHT:
4543 case EL_BD_FIREFLY_UP:
4544 case EL_BD_FIREFLY_LEFT:
4545 case EL_BD_FIREFLY_DOWN:
4546 Tile[x][y] = EL_BD_FIREFLY;
4547 MovDir[x][y] = direction[0][element - EL_BD_FIREFLY_RIGHT];
4550 case EL_PACMAN_RIGHT:
4552 case EL_PACMAN_LEFT:
4553 case EL_PACMAN_DOWN:
4554 Tile[x][y] = EL_PACMAN;
4555 MovDir[x][y] = direction[0][element - EL_PACMAN_RIGHT];
4558 case EL_YAMYAM_LEFT:
4559 case EL_YAMYAM_RIGHT:
4561 case EL_YAMYAM_DOWN:
4562 Tile[x][y] = EL_YAMYAM;
4563 MovDir[x][y] = direction[2][element - EL_YAMYAM_LEFT];
4566 case EL_SP_SNIKSNAK:
4567 MovDir[x][y] = MV_UP;
4570 case EL_SP_ELECTRON:
4571 MovDir[x][y] = MV_LEFT;
4578 Tile[x][y] = EL_MOLE;
4579 MovDir[x][y] = direction[2][element - EL_MOLE_LEFT];
4582 case EL_SPRING_LEFT:
4583 case EL_SPRING_RIGHT:
4584 Tile[x][y] = EL_SPRING;
4585 MovDir[x][y] = direction[2][element - EL_SPRING_LEFT];
4589 if (IS_CUSTOM_ELEMENT(element))
4591 struct ElementInfo *ei = &element_info[element];
4592 int move_direction_initial = ei->move_direction_initial;
4593 int move_pattern = ei->move_pattern;
4595 if (move_direction_initial == MV_START_PREVIOUS)
4597 if (MovDir[x][y] != MV_NONE)
4600 move_direction_initial = MV_START_AUTOMATIC;
4603 if (move_direction_initial == MV_START_RANDOM)
4604 MovDir[x][y] = 1 << RND(4);
4605 else if (move_direction_initial & MV_ANY_DIRECTION)
4606 MovDir[x][y] = move_direction_initial;
4607 else if (move_pattern == MV_ALL_DIRECTIONS ||
4608 move_pattern == MV_TURNING_LEFT ||
4609 move_pattern == MV_TURNING_RIGHT ||
4610 move_pattern == MV_TURNING_LEFT_RIGHT ||
4611 move_pattern == MV_TURNING_RIGHT_LEFT ||
4612 move_pattern == MV_TURNING_RANDOM)
4613 MovDir[x][y] = 1 << RND(4);
4614 else if (move_pattern == MV_HORIZONTAL)
4615 MovDir[x][y] = (RND(2) ? MV_LEFT : MV_RIGHT);
4616 else if (move_pattern == MV_VERTICAL)
4617 MovDir[x][y] = (RND(2) ? MV_UP : MV_DOWN);
4618 else if (move_pattern & MV_ANY_DIRECTION)
4619 MovDir[x][y] = element_info[element].move_pattern;
4620 else if (move_pattern == MV_ALONG_LEFT_SIDE ||
4621 move_pattern == MV_ALONG_RIGHT_SIDE)
4623 // use random direction as default start direction
4624 if (game.engine_version >= VERSION_IDENT(3,1,0,0))
4625 MovDir[x][y] = 1 << RND(4);
4627 for (i = 0; i < NUM_DIRECTIONS; i++)
4629 int x1 = x + xy[i][0];
4630 int y1 = y + xy[i][1];
4632 if (!IN_LEV_FIELD(x1, y1) || !IS_FREE(x1, y1))
4634 if (move_pattern == MV_ALONG_RIGHT_SIDE)
4635 MovDir[x][y] = direction[0][i];
4637 MovDir[x][y] = direction[1][i];
4646 MovDir[x][y] = 1 << RND(4);
4648 if (element != EL_BUG &&
4649 element != EL_SPACESHIP &&
4650 element != EL_BD_BUTTERFLY &&
4651 element != EL_BD_FIREFLY)
4654 for (i = 0; i < NUM_DIRECTIONS; i++)
4656 int x1 = x + xy[i][0];
4657 int y1 = y + xy[i][1];
4659 if (!IN_LEV_FIELD(x1, y1) || !IS_FREE(x1, y1))
4661 if (element == EL_BUG || element == EL_BD_BUTTERFLY)
4663 MovDir[x][y] = direction[0][i];
4666 else if (element == EL_SPACESHIP || element == EL_BD_FIREFLY ||
4667 element == EL_SP_SNIKSNAK || element == EL_SP_ELECTRON)
4669 MovDir[x][y] = direction[1][i];
4678 GfxDir[x][y] = MovDir[x][y];
4681 void InitAmoebaNr(int x, int y)
4684 int group_nr = AmoebaNeighbourNr(x, y);
4688 for (i = 1; i < MAX_NUM_AMOEBA; i++)
4690 if (AmoebaCnt[i] == 0)
4698 AmoebaNr[x][y] = group_nr;
4699 AmoebaCnt[group_nr]++;
4700 AmoebaCnt2[group_nr]++;
4703 static void LevelSolved(void)
4705 if (level.game_engine_type == GAME_ENGINE_TYPE_RND &&
4706 game.players_still_needed > 0)
4709 game.LevelSolved = TRUE;
4710 game.GameOver = TRUE;
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;
4965 game.LevelSolved_GameEnd = TRUE;
4967 if (game.LevelSolved_SaveTape)
4969 // make sure that request dialog to save tape does not open door again
4970 if (!global.use_envelope_request)
4971 CloseDoor(DOOR_CLOSE_1);
4973 SaveTapeChecked_LevelSolved(tape.level_nr); // ask to save tape
4975 // set unique basename for score tape (also saved in high score table)
4976 strcpy(tape.score_tape_basename, getScoreTapeBasename(setup.player_name));
4979 // if no tape is to be saved, close both doors simultaneously
4980 CloseDoor(DOOR_CLOSE_ALL);
4982 if (level_editor_test_game)
4984 SetGameStatus(GAME_MODE_MAIN);
4991 if (!game.LevelSolved_SaveScore)
4993 SetGameStatus(GAME_MODE_MAIN);
5000 if (level_nr == leveldir_current->handicap_level)
5002 leveldir_current->handicap_level++;
5004 SaveLevelSetup_SeriesInfo();
5007 if (setup.increment_levels &&
5008 level_nr < leveldir_current->last_level &&
5011 level_nr++; // advance to next level
5012 TapeErase(); // start with empty tape
5014 if (setup.auto_play_next_level)
5016 LoadLevel(level_nr);
5018 SaveLevelSetup_SeriesInfo();
5022 hi_pos = NewHiScore(last_level_nr);
5024 if (hi_pos >= 0 && setup.show_scores_after_game)
5026 SetGameStatus(GAME_MODE_SCORES);
5028 DrawHallOfFame(last_level_nr, hi_pos);
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 int NewHiScore(int level_nr)
5048 boolean one_score_entry_per_name = !program.many_scores_per_name;
5050 LoadScore(level_nr);
5052 if (strEqual(setup.player_name, EMPTY_PLAYER_NAME) ||
5053 game.score_final < scores.entry[MAX_SCORE_ENTRIES - 1].score)
5056 for (k = 0; k < MAX_SCORE_ENTRIES; k++)
5058 struct ScoreEntry *entry = &scores.entry[k];
5059 boolean score_is_better = (game.score_final > entry->score);
5060 boolean score_is_equal = (game.score_final == entry->score);
5061 boolean time_is_better = (game.score_time_final < entry->time);
5062 boolean time_is_equal = (game.score_time_final == entry->time);
5063 boolean better_by_score = (score_is_better ||
5064 (score_is_equal && time_is_better));
5065 boolean better_by_time = (time_is_better ||
5066 (time_is_equal && score_is_better));
5067 boolean is_better = (level.rate_time_over_score ? better_by_time :
5069 boolean entry_is_empty = (entry->score == 0 &&
5072 if (is_better || entry_is_empty)
5074 // player has made it to the hall of fame
5076 if (k < MAX_SCORE_ENTRIES - 1)
5078 int m = MAX_SCORE_ENTRIES - 1;
5080 if (one_score_entry_per_name)
5082 for (l = k; l < MAX_SCORE_ENTRIES; l++)
5083 if (strEqual(setup.player_name, scores.entry[l].name))
5086 if (m == k) // player's new highscore overwrites his old one
5090 for (l = m; l > k; l--)
5092 strcpy(scores.entry[l].name, scores.entry[l - 1].name);
5093 scores.entry[l].score = scores.entry[l - 1].score;
5094 scores.entry[l].time = scores.entry[l - 1].time;
5100 strncpy(entry->name, setup.player_name, MAX_PLAYER_NAME_LEN);
5101 entry->name[MAX_PLAYER_NAME_LEN] = '\0';
5102 entry->score = game.score_final;
5103 entry->time = game.score_time_final;
5108 else if (one_score_entry_per_name &&
5109 !strncmp(setup.player_name, entry->name, MAX_PLAYER_NAME_LEN))
5110 break; // player already there with a higher score
5115 SaveScoreTape(level_nr);
5116 SaveScore(level_nr);
5122 static int getElementMoveStepsizeExt(int x, int y, int direction)
5124 int element = Tile[x][y];
5125 int dx = (direction == MV_LEFT ? -1 : direction == MV_RIGHT ? +1 : 0);
5126 int dy = (direction == MV_UP ? -1 : direction == MV_DOWN ? +1 : 0);
5127 int horiz_move = (dx != 0);
5128 int sign = (horiz_move ? dx : dy);
5129 int step = sign * element_info[element].move_stepsize;
5131 // special values for move stepsize for spring and things on conveyor belt
5134 if (CAN_FALL(element) &&
5135 y < lev_fieldy - 1 && IS_BELT_ACTIVE(Tile[x][y + 1]))
5136 step = sign * MOVE_STEPSIZE_NORMAL / 2;
5137 else if (element == EL_SPRING)
5138 step = sign * MOVE_STEPSIZE_NORMAL * 2;
5144 static int getElementMoveStepsize(int x, int y)
5146 return getElementMoveStepsizeExt(x, y, MovDir[x][y]);
5149 void InitPlayerGfxAnimation(struct PlayerInfo *player, int action, int dir)
5151 if (player->GfxAction != action || player->GfxDir != dir)
5153 player->GfxAction = action;
5154 player->GfxDir = dir;
5156 player->StepFrame = 0;
5160 static void ResetGfxFrame(int x, int y)
5162 // profiling showed that "autotest" spends 10~20% of its time in this function
5163 if (DrawingDeactivatedField())
5166 int element = Tile[x][y];
5167 int graphic = el_act_dir2img(element, GfxAction[x][y], GfxDir[x][y]);
5169 if (graphic_info[graphic].anim_global_sync)
5170 GfxFrame[x][y] = FrameCounter;
5171 else if (ANIM_MODE(graphic) == ANIM_CE_VALUE)
5172 GfxFrame[x][y] = CustomValue[x][y];
5173 else if (ANIM_MODE(graphic) == ANIM_CE_SCORE)
5174 GfxFrame[x][y] = element_info[element].collect_score;
5175 else if (ANIM_MODE(graphic) == ANIM_CE_DELAY)
5176 GfxFrame[x][y] = ChangeDelay[x][y];
5179 static void ResetGfxAnimation(int x, int y)
5181 GfxAction[x][y] = ACTION_DEFAULT;
5182 GfxDir[x][y] = MovDir[x][y];
5185 ResetGfxFrame(x, y);
5188 static void ResetRandomAnimationValue(int x, int y)
5190 GfxRandom[x][y] = INIT_GFX_RANDOM();
5193 static void InitMovingField(int x, int y, int direction)
5195 int element = Tile[x][y];
5196 int dx = (direction == MV_LEFT ? -1 : direction == MV_RIGHT ? +1 : 0);
5197 int dy = (direction == MV_UP ? -1 : direction == MV_DOWN ? +1 : 0);
5200 boolean is_moving_before, is_moving_after;
5202 // check if element was/is moving or being moved before/after mode change
5203 is_moving_before = (WasJustMoving[x][y] != 0);
5204 is_moving_after = (getElementMoveStepsizeExt(x, y, direction) != 0);
5206 // reset animation only for moving elements which change direction of moving
5207 // or which just started or stopped moving
5208 // (else CEs with property "can move" / "not moving" are reset each frame)
5209 if (is_moving_before != is_moving_after ||
5210 direction != MovDir[x][y])
5211 ResetGfxAnimation(x, y);
5213 MovDir[x][y] = direction;
5214 GfxDir[x][y] = direction;
5216 GfxAction[x][y] = (!is_moving_after ? ACTION_WAITING :
5217 direction == MV_DOWN && CAN_FALL(element) ?
5218 ACTION_FALLING : ACTION_MOVING);
5220 // this is needed for CEs with property "can move" / "not moving"
5222 if (is_moving_after)
5224 if (Tile[newx][newy] == EL_EMPTY)
5225 Tile[newx][newy] = EL_BLOCKED;
5227 MovDir[newx][newy] = MovDir[x][y];
5229 CustomValue[newx][newy] = CustomValue[x][y];
5231 GfxFrame[newx][newy] = GfxFrame[x][y];
5232 GfxRandom[newx][newy] = GfxRandom[x][y];
5233 GfxAction[newx][newy] = GfxAction[x][y];
5234 GfxDir[newx][newy] = GfxDir[x][y];
5238 void Moving2Blocked(int x, int y, int *goes_to_x, int *goes_to_y)
5240 int direction = MovDir[x][y];
5241 int newx = x + (direction & MV_LEFT ? -1 : direction & MV_RIGHT ? +1 : 0);
5242 int newy = y + (direction & MV_UP ? -1 : direction & MV_DOWN ? +1 : 0);
5248 void Blocked2Moving(int x, int y, int *comes_from_x, int *comes_from_y)
5250 int oldx = x, oldy = y;
5251 int direction = MovDir[x][y];
5253 if (direction == MV_LEFT)
5255 else if (direction == MV_RIGHT)
5257 else if (direction == MV_UP)
5259 else if (direction == MV_DOWN)
5262 *comes_from_x = oldx;
5263 *comes_from_y = oldy;
5266 static int MovingOrBlocked2Element(int x, int y)
5268 int element = Tile[x][y];
5270 if (element == EL_BLOCKED)
5274 Blocked2Moving(x, y, &oldx, &oldy);
5275 return Tile[oldx][oldy];
5281 static int MovingOrBlocked2ElementIfNotLeaving(int x, int y)
5283 // like MovingOrBlocked2Element(), but if element is moving
5284 // and (x,y) is the field the moving element is just leaving,
5285 // return EL_BLOCKED instead of the element value
5286 int element = Tile[x][y];
5288 if (IS_MOVING(x, y))
5290 if (element == EL_BLOCKED)
5294 Blocked2Moving(x, y, &oldx, &oldy);
5295 return Tile[oldx][oldy];
5304 static void RemoveField(int x, int y)
5306 Tile[x][y] = EL_EMPTY;
5312 CustomValue[x][y] = 0;
5315 ChangeDelay[x][y] = 0;
5316 ChangePage[x][y] = -1;
5317 Pushed[x][y] = FALSE;
5319 GfxElement[x][y] = EL_UNDEFINED;
5320 GfxAction[x][y] = ACTION_DEFAULT;
5321 GfxDir[x][y] = MV_NONE;
5324 static void RemoveMovingField(int x, int y)
5326 int oldx = x, oldy = y, newx = x, newy = y;
5327 int element = Tile[x][y];
5328 int next_element = EL_UNDEFINED;
5330 if (element != EL_BLOCKED && !IS_MOVING(x, y))
5333 if (IS_MOVING(x, y))
5335 Moving2Blocked(x, y, &newx, &newy);
5337 if (Tile[newx][newy] != EL_BLOCKED)
5339 // element is moving, but target field is not free (blocked), but
5340 // already occupied by something different (example: acid pool);
5341 // in this case, only remove the moving field, but not the target
5343 RemoveField(oldx, oldy);
5345 Store[oldx][oldy] = Store2[oldx][oldy] = 0;
5347 TEST_DrawLevelField(oldx, oldy);
5352 else if (element == EL_BLOCKED)
5354 Blocked2Moving(x, y, &oldx, &oldy);
5355 if (!IS_MOVING(oldx, oldy))
5359 if (element == EL_BLOCKED &&
5360 (Tile[oldx][oldy] == EL_QUICKSAND_EMPTYING ||
5361 Tile[oldx][oldy] == EL_QUICKSAND_FAST_EMPTYING ||
5362 Tile[oldx][oldy] == EL_MAGIC_WALL_EMPTYING ||
5363 Tile[oldx][oldy] == EL_BD_MAGIC_WALL_EMPTYING ||
5364 Tile[oldx][oldy] == EL_DC_MAGIC_WALL_EMPTYING ||
5365 Tile[oldx][oldy] == EL_AMOEBA_DROPPING))
5366 next_element = get_next_element(Tile[oldx][oldy]);
5368 RemoveField(oldx, oldy);
5369 RemoveField(newx, newy);
5371 Store[oldx][oldy] = Store2[oldx][oldy] = 0;
5373 if (next_element != EL_UNDEFINED)
5374 Tile[oldx][oldy] = next_element;
5376 TEST_DrawLevelField(oldx, oldy);
5377 TEST_DrawLevelField(newx, newy);
5380 void DrawDynamite(int x, int y)
5382 int sx = SCREENX(x), sy = SCREENY(y);
5383 int graphic = el2img(Tile[x][y]);
5386 if (!IN_SCR_FIELD(sx, sy) || IS_PLAYER(x, y))
5389 if (IS_WALKABLE_INSIDE(Back[x][y]))
5393 DrawLevelElement(x, y, Back[x][y]);
5394 else if (Store[x][y])
5395 DrawLevelElement(x, y, Store[x][y]);
5396 else if (game.use_masked_elements)
5397 DrawLevelElement(x, y, EL_EMPTY);
5399 frame = getGraphicAnimationFrame(graphic, GfxFrame[x][y]);
5401 if (Back[x][y] || Store[x][y] || game.use_masked_elements)
5402 DrawGraphicThruMask(sx, sy, graphic, frame);
5404 DrawGraphic(sx, sy, graphic, frame);
5407 static void CheckDynamite(int x, int y)
5409 if (MovDelay[x][y] != 0) // dynamite is still waiting to explode
5413 if (MovDelay[x][y] != 0)
5416 PlayLevelSoundActionIfLoop(x, y, ACTION_ACTIVE);
5422 StopLevelSoundActionIfLoop(x, y, ACTION_ACTIVE);
5427 static void setMinimalPlayerBoundaries(int *sx1, int *sy1, int *sx2, int *sy2)
5429 boolean num_checked_players = 0;
5432 for (i = 0; i < MAX_PLAYERS; i++)
5434 if (stored_player[i].active)
5436 int sx = stored_player[i].jx;
5437 int sy = stored_player[i].jy;
5439 if (num_checked_players == 0)
5446 *sx1 = MIN(*sx1, sx);
5447 *sy1 = MIN(*sy1, sy);
5448 *sx2 = MAX(*sx2, sx);
5449 *sy2 = MAX(*sy2, sy);
5452 num_checked_players++;
5457 static boolean checkIfAllPlayersFitToScreen_RND(void)
5459 int sx1 = 0, sy1 = 0, sx2 = 0, sy2 = 0;
5461 setMinimalPlayerBoundaries(&sx1, &sy1, &sx2, &sy2);
5463 return (sx2 - sx1 < SCR_FIELDX &&
5464 sy2 - sy1 < SCR_FIELDY);
5467 static void setScreenCenteredToAllPlayers(int *sx, int *sy)
5469 int sx1 = scroll_x, sy1 = scroll_y, sx2 = scroll_x, sy2 = scroll_y;
5471 setMinimalPlayerBoundaries(&sx1, &sy1, &sx2, &sy2);
5473 *sx = (sx1 + sx2) / 2;
5474 *sy = (sy1 + sy2) / 2;
5477 static void DrawRelocateScreen(int old_x, int old_y, int x, int y, int move_dir,
5478 boolean center_screen, boolean quick_relocation)
5480 unsigned int frame_delay_value_old = GetVideoFrameDelay();
5481 boolean ffwd_delay = (tape.playing && tape.fast_forward);
5482 boolean no_delay = (tape.warp_forward);
5483 int frame_delay_value = (ffwd_delay ? FfwdFrameDelay : GameFrameDelay);
5484 int wait_delay_value = (no_delay ? 0 : frame_delay_value);
5485 int new_scroll_x, new_scroll_y;
5487 if (level.lazy_relocation && IN_VIS_FIELD(SCREENX(x), SCREENY(y)))
5489 // case 1: quick relocation inside visible screen (without scrolling)
5496 if (!level.shifted_relocation || center_screen)
5498 // relocation _with_ centering of screen
5500 new_scroll_x = SCROLL_POSITION_X(x);
5501 new_scroll_y = SCROLL_POSITION_Y(y);
5505 // relocation _without_ centering of screen
5507 int center_scroll_x = SCROLL_POSITION_X(old_x);
5508 int center_scroll_y = SCROLL_POSITION_Y(old_y);
5509 int offset_x = x + (scroll_x - center_scroll_x);
5510 int offset_y = y + (scroll_y - center_scroll_y);
5512 // for new screen position, apply previous offset to center position
5513 new_scroll_x = SCROLL_POSITION_X(offset_x);
5514 new_scroll_y = SCROLL_POSITION_Y(offset_y);
5517 if (quick_relocation)
5519 // case 2: quick relocation (redraw without visible scrolling)
5521 scroll_x = new_scroll_x;
5522 scroll_y = new_scroll_y;
5529 // case 3: visible relocation (with scrolling to new position)
5531 ScrollScreen(NULL, SCROLL_GO_ON); // scroll last frame to full tile
5533 SetVideoFrameDelay(wait_delay_value);
5535 while (scroll_x != new_scroll_x || scroll_y != new_scroll_y)
5537 int dx = (new_scroll_x < scroll_x ? +1 : new_scroll_x > scroll_x ? -1 : 0);
5538 int dy = (new_scroll_y < scroll_y ? +1 : new_scroll_y > scroll_y ? -1 : 0);
5540 if (dx == 0 && dy == 0) // no scrolling needed at all
5546 // set values for horizontal/vertical screen scrolling (half tile size)
5547 int dir_x = (dx != 0 ? MV_HORIZONTAL : 0);
5548 int dir_y = (dy != 0 ? MV_VERTICAL : 0);
5549 int pos_x = dx * TILEX / 2;
5550 int pos_y = dy * TILEY / 2;
5551 int fx = getFieldbufferOffsetX_RND(dir_x, pos_x);
5552 int fy = getFieldbufferOffsetY_RND(dir_y, pos_y);
5554 ScrollLevel(dx, dy);
5557 // scroll in two steps of half tile size to make things smoother
5558 BlitScreenToBitmapExt_RND(window, fx, fy);
5560 // scroll second step to align at full tile size
5561 BlitScreenToBitmap(window);
5567 SetVideoFrameDelay(frame_delay_value_old);
5570 static void RelocatePlayer(int jx, int jy, int el_player_raw)
5572 int el_player = GET_PLAYER_ELEMENT(el_player_raw);
5573 int player_nr = GET_PLAYER_NR(el_player);
5574 struct PlayerInfo *player = &stored_player[player_nr];
5575 boolean ffwd_delay = (tape.playing && tape.fast_forward);
5576 boolean no_delay = (tape.warp_forward);
5577 int frame_delay_value = (ffwd_delay ? FfwdFrameDelay : GameFrameDelay);
5578 int wait_delay_value = (no_delay ? 0 : frame_delay_value);
5579 int old_jx = player->jx;
5580 int old_jy = player->jy;
5581 int old_element = Tile[old_jx][old_jy];
5582 int element = Tile[jx][jy];
5583 boolean player_relocated = (old_jx != jx || old_jy != jy);
5585 int move_dir_horiz = (jx < old_jx ? MV_LEFT : jx > old_jx ? MV_RIGHT : 0);
5586 int move_dir_vert = (jy < old_jy ? MV_UP : jy > old_jy ? MV_DOWN : 0);
5587 int enter_side_horiz = MV_DIR_OPPOSITE(move_dir_horiz);
5588 int enter_side_vert = MV_DIR_OPPOSITE(move_dir_vert);
5589 int leave_side_horiz = move_dir_horiz;
5590 int leave_side_vert = move_dir_vert;
5591 int enter_side = enter_side_horiz | enter_side_vert;
5592 int leave_side = leave_side_horiz | leave_side_vert;
5594 if (player->buried) // do not reanimate dead player
5597 if (!player_relocated) // no need to relocate the player
5600 if (IS_PLAYER(jx, jy)) // player already placed at new position
5602 RemoveField(jx, jy); // temporarily remove newly placed player
5603 DrawLevelField(jx, jy);
5606 if (player->present)
5608 while (player->MovPos)
5610 ScrollPlayer(player, SCROLL_GO_ON);
5611 ScrollScreen(NULL, SCROLL_GO_ON);
5613 AdvanceFrameAndPlayerCounters(player->index_nr);
5617 BackToFront_WithFrameDelay(wait_delay_value);
5620 DrawPlayer(player); // needed here only to cleanup last field
5621 DrawLevelField(player->jx, player->jy); // remove player graphic
5623 player->is_moving = FALSE;
5626 if (IS_CUSTOM_ELEMENT(old_element))
5627 CheckElementChangeByPlayer(old_jx, old_jy, old_element,
5629 player->index_bit, leave_side);
5631 CheckTriggeredElementChangeByPlayer(old_jx, old_jy, old_element,
5633 player->index_bit, leave_side);
5635 Tile[jx][jy] = el_player;
5636 InitPlayerField(jx, jy, el_player, TRUE);
5638 /* "InitPlayerField()" above sets Tile[jx][jy] to EL_EMPTY, but it may be
5639 possible that the relocation target field did not contain a player element,
5640 but a walkable element, to which the new player was relocated -- in this
5641 case, restore that (already initialized!) element on the player field */
5642 if (!ELEM_IS_PLAYER(element)) // player may be set on walkable element
5644 Tile[jx][jy] = element; // restore previously existing element
5647 // only visually relocate centered player
5648 DrawRelocateScreen(old_jx, old_jy, player->jx, player->jy, player->MovDir,
5649 FALSE, level.instant_relocation);
5651 TestIfPlayerTouchesBadThing(jx, jy);
5652 TestIfPlayerTouchesCustomElement(jx, jy);
5654 if (IS_CUSTOM_ELEMENT(element))
5655 CheckElementChangeByPlayer(jx, jy, element, CE_ENTERED_BY_PLAYER,
5656 player->index_bit, enter_side);
5658 CheckTriggeredElementChangeByPlayer(jx, jy, element, CE_PLAYER_ENTERS_X,
5659 player->index_bit, enter_side);
5661 if (player->is_switching)
5663 /* ensure that relocation while still switching an element does not cause
5664 a new element to be treated as also switched directly after relocation
5665 (this is important for teleporter switches that teleport the player to
5666 a place where another teleporter switch is in the same direction, which
5667 would then incorrectly be treated as immediately switched before the
5668 direction key that caused the switch was released) */
5670 player->switch_x += jx - old_jx;
5671 player->switch_y += jy - old_jy;
5675 static void Explode(int ex, int ey, int phase, int mode)
5681 // !!! eliminate this variable !!!
5682 int delay = (game.emulation == EMU_SUPAPLEX ? 3 : 2);
5684 if (game.explosions_delayed)
5686 ExplodeField[ex][ey] = mode;
5690 if (phase == EX_PHASE_START) // initialize 'Store[][]' field
5692 int center_element = Tile[ex][ey];
5693 int artwork_element, explosion_element; // set these values later
5695 // remove things displayed in background while burning dynamite
5696 if (Back[ex][ey] != EL_EMPTY && !IS_INDESTRUCTIBLE(Back[ex][ey]))
5699 if (IS_MOVING(ex, ey) || IS_BLOCKED(ex, ey))
5701 // put moving element to center field (and let it explode there)
5702 center_element = MovingOrBlocked2Element(ex, ey);
5703 RemoveMovingField(ex, ey);
5704 Tile[ex][ey] = center_element;
5707 // now "center_element" is finally determined -- set related values now
5708 artwork_element = center_element; // for custom player artwork
5709 explosion_element = center_element; // for custom player artwork
5711 if (IS_PLAYER(ex, ey))
5713 int player_nr = GET_PLAYER_NR(StorePlayer[ex][ey]);
5715 artwork_element = stored_player[player_nr].artwork_element;
5717 if (level.use_explosion_element[player_nr])
5719 explosion_element = level.explosion_element[player_nr];
5720 artwork_element = explosion_element;
5724 if (mode == EX_TYPE_NORMAL ||
5725 mode == EX_TYPE_CENTER ||
5726 mode == EX_TYPE_CROSS)
5727 PlayLevelSoundElementAction(ex, ey, artwork_element, ACTION_EXPLODING);
5729 last_phase = element_info[explosion_element].explosion_delay + 1;
5731 for (y = ey - 1; y <= ey + 1; y++) for (x = ex - 1; x <= ex + 1; x++)
5733 int xx = x - ex + 1;
5734 int yy = y - ey + 1;
5737 if (!IN_LEV_FIELD(x, y) ||
5738 (mode & EX_TYPE_SINGLE_TILE && (x != ex || y != ey)) ||
5739 (mode == EX_TYPE_CROSS && (x != ex && y != ey)))
5742 element = Tile[x][y];
5744 if (IS_MOVING(x, y) || IS_BLOCKED(x, y))
5746 element = MovingOrBlocked2Element(x, y);
5748 if (!IS_EXPLOSION_PROOF(element))
5749 RemoveMovingField(x, y);
5752 // indestructible elements can only explode in center (but not flames)
5753 if ((IS_EXPLOSION_PROOF(element) && (x != ex || y != ey ||
5754 mode == EX_TYPE_BORDER)) ||
5755 element == EL_FLAMES)
5758 /* no idea why this was changed from 3.0.8 to 3.1.0 -- this causes buggy
5759 behaviour, for example when touching a yamyam that explodes to rocks
5760 with active deadly shield, a rock is created under the player !!! */
5761 // (case 1 (surely buggy): >= 3.1.0, case 2 (maybe buggy): <= 3.0.8)
5763 if (IS_PLAYER(x, y) && SHIELD_ON(PLAYERINFO(x, y)) &&
5764 (game.engine_version < VERSION_IDENT(3,1,0,0) ||
5765 (x == ex && y == ey && mode != EX_TYPE_BORDER)))
5767 if (IS_PLAYER(x, y) && SHIELD_ON(PLAYERINFO(x, y)))
5770 if (IS_ACTIVE_BOMB(element))
5772 // re-activate things under the bomb like gate or penguin
5773 Tile[x][y] = (Back[x][y] ? Back[x][y] : EL_EMPTY);
5780 // save walkable background elements while explosion on same tile
5781 if (IS_WALKABLE(element) && IS_INDESTRUCTIBLE(element) &&
5782 (x != ex || y != ey || mode == EX_TYPE_BORDER))
5783 Back[x][y] = element;
5785 // ignite explodable elements reached by other explosion
5786 if (element == EL_EXPLOSION)
5787 element = Store2[x][y];
5789 if (AmoebaNr[x][y] &&
5790 (element == EL_AMOEBA_FULL ||
5791 element == EL_BD_AMOEBA ||
5792 element == EL_AMOEBA_GROWING))
5794 AmoebaCnt[AmoebaNr[x][y]]--;
5795 AmoebaCnt2[AmoebaNr[x][y]]--;
5800 if (IS_PLAYER(ex, ey) && !PLAYER_EXPLOSION_PROTECTED(ex, ey))
5802 int player_nr = StorePlayer[ex][ey] - EL_PLAYER_1;
5804 Store[x][y] = EL_PLAYER_IS_EXPLODING_1 + player_nr;
5806 if (PLAYERINFO(ex, ey)->use_murphy)
5807 Store[x][y] = EL_EMPTY;
5810 // !!! check this case -- currently needed for rnd_rado_negundo_v,
5811 // !!! levels 015 018 019 020 021 022 023 026 027 028 !!!
5812 else if (ELEM_IS_PLAYER(center_element))
5813 Store[x][y] = EL_EMPTY;
5814 else if (center_element == EL_YAMYAM)
5815 Store[x][y] = level.yamyam_content[game.yamyam_content_nr].e[xx][yy];
5816 else if (element_info[center_element].content.e[xx][yy] != EL_EMPTY)
5817 Store[x][y] = element_info[center_element].content.e[xx][yy];
5819 // needed because EL_BD_BUTTERFLY is not defined as "CAN_EXPLODE"
5820 // (killing EL_BD_BUTTERFLY with dynamite would result in BD diamond
5821 // otherwise) -- FIX THIS !!!
5822 else if (!CAN_EXPLODE(element) && element != EL_BD_BUTTERFLY)
5823 Store[x][y] = element_info[element].content.e[1][1];
5825 else if (!CAN_EXPLODE(element))
5826 Store[x][y] = element_info[element].content.e[1][1];
5829 Store[x][y] = EL_EMPTY;
5831 if (x != ex || y != ey || mode == EX_TYPE_BORDER ||
5832 center_element == EL_AMOEBA_TO_DIAMOND)
5833 Store2[x][y] = element;
5835 Tile[x][y] = EL_EXPLOSION;
5836 GfxElement[x][y] = artwork_element;
5838 ExplodePhase[x][y] = 1;
5839 ExplodeDelay[x][y] = last_phase;
5844 if (center_element == EL_YAMYAM)
5845 game.yamyam_content_nr =
5846 (game.yamyam_content_nr + 1) % level.num_yamyam_contents;
5858 GfxFrame[x][y] = 0; // restart explosion animation
5860 last_phase = ExplodeDelay[x][y];
5862 ExplodePhase[x][y] = (phase < last_phase ? phase + 1 : 0);
5864 // this can happen if the player leaves an explosion just in time
5865 if (GfxElement[x][y] == EL_UNDEFINED)
5866 GfxElement[x][y] = EL_EMPTY;
5868 border_element = Store2[x][y];
5869 if (IS_PLAYER(x, y) && !PLAYER_EXPLOSION_PROTECTED(x, y))
5870 border_element = StorePlayer[x][y];
5872 if (phase == element_info[border_element].ignition_delay ||
5873 phase == last_phase)
5875 boolean border_explosion = FALSE;
5877 if (IS_PLAYER(x, y) && PLAYERINFO(x, y)->present &&
5878 !PLAYER_EXPLOSION_PROTECTED(x, y))
5880 KillPlayerUnlessExplosionProtected(x, y);
5881 border_explosion = TRUE;
5883 else if (CAN_EXPLODE_BY_EXPLOSION(border_element))
5885 Tile[x][y] = Store2[x][y];
5888 border_explosion = TRUE;
5890 else if (border_element == EL_AMOEBA_TO_DIAMOND)
5892 AmoebaToDiamond(x, y);
5894 border_explosion = TRUE;
5897 // if an element just explodes due to another explosion (chain-reaction),
5898 // do not immediately end the new explosion when it was the last frame of
5899 // the explosion (as it would be done in the following "if"-statement!)
5900 if (border_explosion && phase == last_phase)
5904 if (phase == last_phase)
5908 element = Tile[x][y] = Store[x][y];
5909 Store[x][y] = Store2[x][y] = 0;
5910 GfxElement[x][y] = EL_UNDEFINED;
5912 // player can escape from explosions and might therefore be still alive
5913 if (element >= EL_PLAYER_IS_EXPLODING_1 &&
5914 element <= EL_PLAYER_IS_EXPLODING_4)
5916 int player_nr = element - EL_PLAYER_IS_EXPLODING_1;
5917 int explosion_element = EL_PLAYER_1 + player_nr;
5918 int xx = MIN(MAX(0, x - stored_player[player_nr].jx + 1), 2);
5919 int yy = MIN(MAX(0, y - stored_player[player_nr].jy + 1), 2);
5921 if (level.use_explosion_element[player_nr])
5922 explosion_element = level.explosion_element[player_nr];
5924 Tile[x][y] = (stored_player[player_nr].active ? EL_EMPTY :
5925 element_info[explosion_element].content.e[xx][yy]);
5928 // restore probably existing indestructible background element
5929 if (Back[x][y] && IS_INDESTRUCTIBLE(Back[x][y]))
5930 element = Tile[x][y] = Back[x][y];
5933 MovDir[x][y] = MovPos[x][y] = MovDelay[x][y] = 0;
5934 GfxDir[x][y] = MV_NONE;
5935 ChangeDelay[x][y] = 0;
5936 ChangePage[x][y] = -1;
5938 CustomValue[x][y] = 0;
5940 InitField_WithBug2(x, y, FALSE);
5942 TEST_DrawLevelField(x, y);
5944 TestIfElementTouchesCustomElement(x, y);
5946 if (GFX_CRUMBLED(element))
5947 TEST_DrawLevelFieldCrumbledNeighbours(x, y);
5949 if (IS_PLAYER(x, y) && !PLAYERINFO(x, y)->present)
5950 StorePlayer[x][y] = 0;
5952 if (ELEM_IS_PLAYER(element))
5953 RelocatePlayer(x, y, element);
5955 else if (IN_SCR_FIELD(SCREENX(x), SCREENY(y)))
5957 int graphic = el_act2img(GfxElement[x][y], ACTION_EXPLODING);
5958 int frame = getGraphicAnimationFrame(graphic, GfxFrame[x][y]);
5961 TEST_DrawLevelFieldCrumbled(x, y);
5963 if (IS_WALKABLE_OVER(Back[x][y]) && Back[x][y] != EL_EMPTY)
5965 DrawLevelElement(x, y, Back[x][y]);
5966 DrawGraphicThruMask(SCREENX(x), SCREENY(y), graphic, frame);
5968 else if (IS_WALKABLE_UNDER(Back[x][y]))
5970 DrawGraphic(SCREENX(x), SCREENY(y), graphic, frame);
5971 DrawLevelElementThruMask(x, y, Back[x][y]);
5973 else if (!IS_WALKABLE_INSIDE(Back[x][y]))
5974 DrawScreenGraphic(SCREENX(x), SCREENY(y), graphic, frame);
5978 static void DynaExplode(int ex, int ey)
5981 int dynabomb_element = Tile[ex][ey];
5982 int dynabomb_size = 1;
5983 boolean dynabomb_xl = FALSE;
5984 struct PlayerInfo *player;
5985 static int xy[4][2] =
5993 if (IS_ACTIVE_BOMB(dynabomb_element))
5995 player = &stored_player[dynabomb_element - EL_DYNABOMB_PLAYER_1_ACTIVE];
5996 dynabomb_size = player->dynabomb_size;
5997 dynabomb_xl = player->dynabomb_xl;
5998 player->dynabombs_left++;
6001 Explode(ex, ey, EX_PHASE_START, EX_TYPE_CENTER);
6003 for (i = 0; i < NUM_DIRECTIONS; i++)
6005 for (j = 1; j <= dynabomb_size; j++)
6007 int x = ex + j * xy[i][0];
6008 int y = ey + j * xy[i][1];
6011 if (!IN_LEV_FIELD(x, y) || IS_INDESTRUCTIBLE(Tile[x][y]))
6014 element = Tile[x][y];
6016 // do not restart explosions of fields with active bombs
6017 if (element == EL_EXPLOSION && IS_ACTIVE_BOMB(Store2[x][y]))
6020 Explode(x, y, EX_PHASE_START, EX_TYPE_BORDER);
6022 if (element != EL_EMPTY && element != EL_EXPLOSION &&
6023 !IS_DIGGABLE(element) && !dynabomb_xl)
6029 void Bang(int x, int y)
6031 int element = MovingOrBlocked2Element(x, y);
6032 int explosion_type = EX_TYPE_NORMAL;
6034 if (IS_PLAYER(x, y) && !PLAYER_EXPLOSION_PROTECTED(x, y))
6036 struct PlayerInfo *player = PLAYERINFO(x, y);
6038 element = Tile[x][y] = player->initial_element;
6040 if (level.use_explosion_element[player->index_nr])
6042 int explosion_element = level.explosion_element[player->index_nr];
6044 if (element_info[explosion_element].explosion_type == EXPLODES_CROSS)
6045 explosion_type = EX_TYPE_CROSS;
6046 else if (element_info[explosion_element].explosion_type == EXPLODES_1X1)
6047 explosion_type = EX_TYPE_CENTER;
6055 case EL_BD_BUTTERFLY:
6058 case EL_DARK_YAMYAM:
6062 RaiseScoreElement(element);
6065 case EL_DYNABOMB_PLAYER_1_ACTIVE:
6066 case EL_DYNABOMB_PLAYER_2_ACTIVE:
6067 case EL_DYNABOMB_PLAYER_3_ACTIVE:
6068 case EL_DYNABOMB_PLAYER_4_ACTIVE:
6069 case EL_DYNABOMB_INCREASE_NUMBER:
6070 case EL_DYNABOMB_INCREASE_SIZE:
6071 case EL_DYNABOMB_INCREASE_POWER:
6072 explosion_type = EX_TYPE_DYNA;
6075 case EL_DC_LANDMINE:
6076 explosion_type = EX_TYPE_CENTER;
6081 case EL_LAMP_ACTIVE:
6082 case EL_AMOEBA_TO_DIAMOND:
6083 if (!IS_PLAYER(x, y)) // penguin and player may be at same field
6084 explosion_type = EX_TYPE_CENTER;
6088 if (element_info[element].explosion_type == EXPLODES_CROSS)
6089 explosion_type = EX_TYPE_CROSS;
6090 else if (element_info[element].explosion_type == EXPLODES_1X1)
6091 explosion_type = EX_TYPE_CENTER;
6095 if (explosion_type == EX_TYPE_DYNA)
6098 Explode(x, y, EX_PHASE_START, explosion_type);
6100 CheckTriggeredElementChange(x, y, element, CE_EXPLOSION_OF_X);
6103 static void SplashAcid(int x, int y)
6105 if (IN_LEV_FIELD(x - 1, y - 1) && IS_FREE(x - 1, y - 1) &&
6106 (!IN_LEV_FIELD(x - 1, y - 2) ||
6107 !CAN_FALL(MovingOrBlocked2Element(x - 1, y - 2))))
6108 Tile[x - 1][y - 1] = EL_ACID_SPLASH_LEFT;
6110 if (IN_LEV_FIELD(x + 1, y - 1) && IS_FREE(x + 1, y - 1) &&
6111 (!IN_LEV_FIELD(x + 1, y - 2) ||
6112 !CAN_FALL(MovingOrBlocked2Element(x + 1, y - 2))))
6113 Tile[x + 1][y - 1] = EL_ACID_SPLASH_RIGHT;
6115 PlayLevelSound(x, y, SND_ACID_SPLASHING);
6118 static void InitBeltMovement(void)
6120 static int belt_base_element[4] =
6122 EL_CONVEYOR_BELT_1_LEFT,
6123 EL_CONVEYOR_BELT_2_LEFT,
6124 EL_CONVEYOR_BELT_3_LEFT,
6125 EL_CONVEYOR_BELT_4_LEFT
6127 static int belt_base_active_element[4] =
6129 EL_CONVEYOR_BELT_1_LEFT_ACTIVE,
6130 EL_CONVEYOR_BELT_2_LEFT_ACTIVE,
6131 EL_CONVEYOR_BELT_3_LEFT_ACTIVE,
6132 EL_CONVEYOR_BELT_4_LEFT_ACTIVE
6137 // set frame order for belt animation graphic according to belt direction
6138 for (i = 0; i < NUM_BELTS; i++)
6142 for (j = 0; j < NUM_BELT_PARTS; j++)
6144 int element = belt_base_active_element[belt_nr] + j;
6145 int graphic_1 = el2img(element);
6146 int graphic_2 = el2panelimg(element);
6148 if (game.belt_dir[i] == MV_LEFT)
6150 graphic_info[graphic_1].anim_mode &= ~ANIM_REVERSE;
6151 graphic_info[graphic_2].anim_mode &= ~ANIM_REVERSE;
6155 graphic_info[graphic_1].anim_mode |= ANIM_REVERSE;
6156 graphic_info[graphic_2].anim_mode |= ANIM_REVERSE;
6161 SCAN_PLAYFIELD(x, y)
6163 int element = Tile[x][y];
6165 for (i = 0; i < NUM_BELTS; i++)
6167 if (IS_BELT(element) && game.belt_dir[i] != MV_NONE)
6169 int e_belt_nr = getBeltNrFromBeltElement(element);
6172 if (e_belt_nr == belt_nr)
6174 int belt_part = Tile[x][y] - belt_base_element[belt_nr];
6176 Tile[x][y] = belt_base_active_element[belt_nr] + belt_part;
6183 static void ToggleBeltSwitch(int x, int y)
6185 static int belt_base_element[4] =
6187 EL_CONVEYOR_BELT_1_LEFT,
6188 EL_CONVEYOR_BELT_2_LEFT,
6189 EL_CONVEYOR_BELT_3_LEFT,
6190 EL_CONVEYOR_BELT_4_LEFT
6192 static int belt_base_active_element[4] =
6194 EL_CONVEYOR_BELT_1_LEFT_ACTIVE,
6195 EL_CONVEYOR_BELT_2_LEFT_ACTIVE,
6196 EL_CONVEYOR_BELT_3_LEFT_ACTIVE,
6197 EL_CONVEYOR_BELT_4_LEFT_ACTIVE
6199 static int belt_base_switch_element[4] =
6201 EL_CONVEYOR_BELT_1_SWITCH_LEFT,
6202 EL_CONVEYOR_BELT_2_SWITCH_LEFT,
6203 EL_CONVEYOR_BELT_3_SWITCH_LEFT,
6204 EL_CONVEYOR_BELT_4_SWITCH_LEFT
6206 static int belt_move_dir[4] =
6214 int element = Tile[x][y];
6215 int belt_nr = getBeltNrFromBeltSwitchElement(element);
6216 int belt_dir_nr = (game.belt_dir_nr[belt_nr] + 1) % 4;
6217 int belt_dir = belt_move_dir[belt_dir_nr];
6220 if (!IS_BELT_SWITCH(element))
6223 game.belt_dir_nr[belt_nr] = belt_dir_nr;
6224 game.belt_dir[belt_nr] = belt_dir;
6226 if (belt_dir_nr == 3)
6229 // set frame order for belt animation graphic according to belt direction
6230 for (i = 0; i < NUM_BELT_PARTS; i++)
6232 int element = belt_base_active_element[belt_nr] + i;
6233 int graphic_1 = el2img(element);
6234 int graphic_2 = el2panelimg(element);
6236 if (belt_dir == MV_LEFT)
6238 graphic_info[graphic_1].anim_mode &= ~ANIM_REVERSE;
6239 graphic_info[graphic_2].anim_mode &= ~ANIM_REVERSE;
6243 graphic_info[graphic_1].anim_mode |= ANIM_REVERSE;
6244 graphic_info[graphic_2].anim_mode |= ANIM_REVERSE;
6248 SCAN_PLAYFIELD(xx, yy)
6250 int element = Tile[xx][yy];
6252 if (IS_BELT_SWITCH(element))
6254 int e_belt_nr = getBeltNrFromBeltSwitchElement(element);
6256 if (e_belt_nr == belt_nr)
6258 Tile[xx][yy] = belt_base_switch_element[belt_nr] + belt_dir_nr;
6259 TEST_DrawLevelField(xx, yy);
6262 else if (IS_BELT(element) && belt_dir != MV_NONE)
6264 int e_belt_nr = getBeltNrFromBeltElement(element);
6266 if (e_belt_nr == belt_nr)
6268 int belt_part = Tile[xx][yy] - belt_base_element[belt_nr];
6270 Tile[xx][yy] = belt_base_active_element[belt_nr] + belt_part;
6271 TEST_DrawLevelField(xx, yy);
6274 else if (IS_BELT_ACTIVE(element) && belt_dir == MV_NONE)
6276 int e_belt_nr = getBeltNrFromBeltActiveElement(element);
6278 if (e_belt_nr == belt_nr)
6280 int belt_part = Tile[xx][yy] - belt_base_active_element[belt_nr];
6282 Tile[xx][yy] = belt_base_element[belt_nr] + belt_part;
6283 TEST_DrawLevelField(xx, yy);
6289 static void ToggleSwitchgateSwitch(int x, int y)
6293 game.switchgate_pos = !game.switchgate_pos;
6295 SCAN_PLAYFIELD(xx, yy)
6297 int element = Tile[xx][yy];
6299 if (element == EL_SWITCHGATE_SWITCH_UP)
6301 Tile[xx][yy] = EL_SWITCHGATE_SWITCH_DOWN;
6302 TEST_DrawLevelField(xx, yy);
6304 else if (element == EL_SWITCHGATE_SWITCH_DOWN)
6306 Tile[xx][yy] = EL_SWITCHGATE_SWITCH_UP;
6307 TEST_DrawLevelField(xx, yy);
6309 else if (element == EL_DC_SWITCHGATE_SWITCH_UP)
6311 Tile[xx][yy] = EL_DC_SWITCHGATE_SWITCH_DOWN;
6312 TEST_DrawLevelField(xx, yy);
6314 else if (element == EL_DC_SWITCHGATE_SWITCH_DOWN)
6316 Tile[xx][yy] = EL_DC_SWITCHGATE_SWITCH_UP;
6317 TEST_DrawLevelField(xx, yy);
6319 else if (element == EL_SWITCHGATE_OPEN ||
6320 element == EL_SWITCHGATE_OPENING)
6322 Tile[xx][yy] = EL_SWITCHGATE_CLOSING;
6324 PlayLevelSoundAction(xx, yy, ACTION_CLOSING);
6326 else if (element == EL_SWITCHGATE_CLOSED ||
6327 element == EL_SWITCHGATE_CLOSING)
6329 Tile[xx][yy] = EL_SWITCHGATE_OPENING;
6331 PlayLevelSoundAction(xx, yy, ACTION_OPENING);
6336 static int getInvisibleActiveFromInvisibleElement(int element)
6338 return (element == EL_INVISIBLE_STEELWALL ? EL_INVISIBLE_STEELWALL_ACTIVE :
6339 element == EL_INVISIBLE_WALL ? EL_INVISIBLE_WALL_ACTIVE :
6340 element == EL_INVISIBLE_SAND ? EL_INVISIBLE_SAND_ACTIVE :
6344 static int getInvisibleFromInvisibleActiveElement(int element)
6346 return (element == EL_INVISIBLE_STEELWALL_ACTIVE ? EL_INVISIBLE_STEELWALL :
6347 element == EL_INVISIBLE_WALL_ACTIVE ? EL_INVISIBLE_WALL :
6348 element == EL_INVISIBLE_SAND_ACTIVE ? EL_INVISIBLE_SAND :
6352 static void RedrawAllLightSwitchesAndInvisibleElements(void)
6356 SCAN_PLAYFIELD(x, y)
6358 int element = Tile[x][y];
6360 if (element == EL_LIGHT_SWITCH &&
6361 game.light_time_left > 0)
6363 Tile[x][y] = EL_LIGHT_SWITCH_ACTIVE;
6364 TEST_DrawLevelField(x, y);
6366 else if (element == EL_LIGHT_SWITCH_ACTIVE &&
6367 game.light_time_left == 0)
6369 Tile[x][y] = EL_LIGHT_SWITCH;
6370 TEST_DrawLevelField(x, y);
6372 else if (element == EL_EMC_DRIPPER &&
6373 game.light_time_left > 0)
6375 Tile[x][y] = EL_EMC_DRIPPER_ACTIVE;
6376 TEST_DrawLevelField(x, y);
6378 else if (element == EL_EMC_DRIPPER_ACTIVE &&
6379 game.light_time_left == 0)
6381 Tile[x][y] = EL_EMC_DRIPPER;
6382 TEST_DrawLevelField(x, y);
6384 else if (element == EL_INVISIBLE_STEELWALL ||
6385 element == EL_INVISIBLE_WALL ||
6386 element == EL_INVISIBLE_SAND)
6388 if (game.light_time_left > 0)
6389 Tile[x][y] = getInvisibleActiveFromInvisibleElement(element);
6391 TEST_DrawLevelField(x, y);
6393 // uncrumble neighbour fields, if needed
6394 if (element == EL_INVISIBLE_SAND)
6395 TEST_DrawLevelFieldCrumbledNeighbours(x, y);
6397 else if (element == EL_INVISIBLE_STEELWALL_ACTIVE ||
6398 element == EL_INVISIBLE_WALL_ACTIVE ||
6399 element == EL_INVISIBLE_SAND_ACTIVE)
6401 if (game.light_time_left == 0)
6402 Tile[x][y] = getInvisibleFromInvisibleActiveElement(element);
6404 TEST_DrawLevelField(x, y);
6406 // re-crumble neighbour fields, if needed
6407 if (element == EL_INVISIBLE_SAND)
6408 TEST_DrawLevelFieldCrumbledNeighbours(x, y);
6413 static void RedrawAllInvisibleElementsForLenses(void)
6417 SCAN_PLAYFIELD(x, y)
6419 int element = Tile[x][y];
6421 if (element == EL_EMC_DRIPPER &&
6422 game.lenses_time_left > 0)
6424 Tile[x][y] = EL_EMC_DRIPPER_ACTIVE;
6425 TEST_DrawLevelField(x, y);
6427 else if (element == EL_EMC_DRIPPER_ACTIVE &&
6428 game.lenses_time_left == 0)
6430 Tile[x][y] = EL_EMC_DRIPPER;
6431 TEST_DrawLevelField(x, y);
6433 else if (element == EL_INVISIBLE_STEELWALL ||
6434 element == EL_INVISIBLE_WALL ||
6435 element == EL_INVISIBLE_SAND)
6437 if (game.lenses_time_left > 0)
6438 Tile[x][y] = getInvisibleActiveFromInvisibleElement(element);
6440 TEST_DrawLevelField(x, y);
6442 // uncrumble neighbour fields, if needed
6443 if (element == EL_INVISIBLE_SAND)
6444 TEST_DrawLevelFieldCrumbledNeighbours(x, y);
6446 else if (element == EL_INVISIBLE_STEELWALL_ACTIVE ||
6447 element == EL_INVISIBLE_WALL_ACTIVE ||
6448 element == EL_INVISIBLE_SAND_ACTIVE)
6450 if (game.lenses_time_left == 0)
6451 Tile[x][y] = getInvisibleFromInvisibleActiveElement(element);
6453 TEST_DrawLevelField(x, y);
6455 // re-crumble neighbour fields, if needed
6456 if (element == EL_INVISIBLE_SAND)
6457 TEST_DrawLevelFieldCrumbledNeighbours(x, y);
6462 static void RedrawAllInvisibleElementsForMagnifier(void)
6466 SCAN_PLAYFIELD(x, y)
6468 int element = Tile[x][y];
6470 if (element == EL_EMC_FAKE_GRASS &&
6471 game.magnify_time_left > 0)
6473 Tile[x][y] = EL_EMC_FAKE_GRASS_ACTIVE;
6474 TEST_DrawLevelField(x, y);
6476 else if (element == EL_EMC_FAKE_GRASS_ACTIVE &&
6477 game.magnify_time_left == 0)
6479 Tile[x][y] = EL_EMC_FAKE_GRASS;
6480 TEST_DrawLevelField(x, y);
6482 else if (IS_GATE_GRAY(element) &&
6483 game.magnify_time_left > 0)
6485 Tile[x][y] = (IS_RND_GATE_GRAY(element) ?
6486 element - EL_GATE_1_GRAY + EL_GATE_1_GRAY_ACTIVE :
6487 IS_EM_GATE_GRAY(element) ?
6488 element - EL_EM_GATE_1_GRAY + EL_EM_GATE_1_GRAY_ACTIVE :
6489 IS_EMC_GATE_GRAY(element) ?
6490 element - EL_EMC_GATE_5_GRAY + EL_EMC_GATE_5_GRAY_ACTIVE :
6491 IS_DC_GATE_GRAY(element) ?
6492 EL_DC_GATE_WHITE_GRAY_ACTIVE :
6494 TEST_DrawLevelField(x, y);
6496 else if (IS_GATE_GRAY_ACTIVE(element) &&
6497 game.magnify_time_left == 0)
6499 Tile[x][y] = (IS_RND_GATE_GRAY_ACTIVE(element) ?
6500 element - EL_GATE_1_GRAY_ACTIVE + EL_GATE_1_GRAY :
6501 IS_EM_GATE_GRAY_ACTIVE(element) ?
6502 element - EL_EM_GATE_1_GRAY_ACTIVE + EL_EM_GATE_1_GRAY :
6503 IS_EMC_GATE_GRAY_ACTIVE(element) ?
6504 element - EL_EMC_GATE_5_GRAY_ACTIVE + EL_EMC_GATE_5_GRAY :
6505 IS_DC_GATE_GRAY_ACTIVE(element) ?
6506 EL_DC_GATE_WHITE_GRAY :
6508 TEST_DrawLevelField(x, y);
6513 static void ToggleLightSwitch(int x, int y)
6515 int element = Tile[x][y];
6517 game.light_time_left =
6518 (element == EL_LIGHT_SWITCH ?
6519 level.time_light * FRAMES_PER_SECOND : 0);
6521 RedrawAllLightSwitchesAndInvisibleElements();
6524 static void ActivateTimegateSwitch(int x, int y)
6528 game.timegate_time_left = level.time_timegate * FRAMES_PER_SECOND;
6530 SCAN_PLAYFIELD(xx, yy)
6532 int element = Tile[xx][yy];
6534 if (element == EL_TIMEGATE_CLOSED ||
6535 element == EL_TIMEGATE_CLOSING)
6537 Tile[xx][yy] = EL_TIMEGATE_OPENING;
6538 PlayLevelSound(xx, yy, SND_CLASS_TIMEGATE_OPENING);
6542 else if (element == EL_TIMEGATE_SWITCH_ACTIVE)
6544 Tile[xx][yy] = EL_TIMEGATE_SWITCH;
6545 TEST_DrawLevelField(xx, yy);
6551 Tile[x][y] = (Tile[x][y] == EL_TIMEGATE_SWITCH ? EL_TIMEGATE_SWITCH_ACTIVE :
6552 EL_DC_TIMEGATE_SWITCH_ACTIVE);
6555 static void Impact(int x, int y)
6557 boolean last_line = (y == lev_fieldy - 1);
6558 boolean object_hit = FALSE;
6559 boolean impact = (last_line || object_hit);
6560 int element = Tile[x][y];
6561 int smashed = EL_STEELWALL;
6563 if (!last_line) // check if element below was hit
6565 if (Tile[x][y + 1] == EL_PLAYER_IS_LEAVING)
6568 object_hit = (!IS_FREE(x, y + 1) && (!IS_MOVING(x, y + 1) ||
6569 MovDir[x][y + 1] != MV_DOWN ||
6570 MovPos[x][y + 1] <= TILEY / 2));
6572 // do not smash moving elements that left the smashed field in time
6573 if (game.engine_version >= VERSION_IDENT(2,2,0,7) && IS_MOVING(x, y + 1) &&
6574 ABS(MovPos[x][y + 1] + getElementMoveStepsize(x, y + 1)) >= TILEX)
6577 #if USE_QUICKSAND_IMPACT_BUGFIX
6578 if (Tile[x][y + 1] == EL_QUICKSAND_EMPTYING && object_hit == FALSE)
6580 RemoveMovingField(x, y + 1);
6581 Tile[x][y + 1] = EL_QUICKSAND_EMPTY;
6582 Tile[x][y + 2] = EL_ROCK;
6583 TEST_DrawLevelField(x, y + 2);
6588 if (Tile[x][y + 1] == EL_QUICKSAND_FAST_EMPTYING && object_hit == FALSE)
6590 RemoveMovingField(x, y + 1);
6591 Tile[x][y + 1] = EL_QUICKSAND_FAST_EMPTY;
6592 Tile[x][y + 2] = EL_ROCK;
6593 TEST_DrawLevelField(x, y + 2);
6600 smashed = MovingOrBlocked2Element(x, y + 1);
6602 impact = (last_line || object_hit);
6605 if (!last_line && smashed == EL_ACID) // element falls into acid
6607 SplashAcid(x, y + 1);
6611 // !!! not sufficient for all cases -- see EL_PEARL below !!!
6612 // only reset graphic animation if graphic really changes after impact
6614 el_act_dir2img(element, GfxAction[x][y], MV_DOWN) != el2img(element))
6616 ResetGfxAnimation(x, y);
6617 TEST_DrawLevelField(x, y);
6620 if (impact && CAN_EXPLODE_IMPACT(element))
6625 else if (impact && element == EL_PEARL &&
6626 smashed != EL_DC_MAGIC_WALL && smashed != EL_DC_MAGIC_WALL_ACTIVE)
6628 ResetGfxAnimation(x, y);
6630 Tile[x][y] = EL_PEARL_BREAKING;
6631 PlayLevelSound(x, y, SND_PEARL_BREAKING);
6634 else if (impact && CheckElementChange(x, y, element, smashed, CE_IMPACT))
6636 PlayLevelSoundElementAction(x, y, element, ACTION_IMPACT);
6641 if (impact && element == EL_AMOEBA_DROP)
6643 if (object_hit && IS_PLAYER(x, y + 1))
6644 KillPlayerUnlessEnemyProtected(x, y + 1);
6645 else if (object_hit && smashed == EL_PENGUIN)
6649 Tile[x][y] = EL_AMOEBA_GROWING;
6650 Store[x][y] = EL_AMOEBA_WET;
6652 ResetRandomAnimationValue(x, y);
6657 if (object_hit) // check which object was hit
6659 if ((CAN_PASS_MAGIC_WALL(element) &&
6660 (smashed == EL_MAGIC_WALL ||
6661 smashed == EL_BD_MAGIC_WALL)) ||
6662 (CAN_PASS_DC_MAGIC_WALL(element) &&
6663 smashed == EL_DC_MAGIC_WALL))
6666 int activated_magic_wall =
6667 (smashed == EL_MAGIC_WALL ? EL_MAGIC_WALL_ACTIVE :
6668 smashed == EL_BD_MAGIC_WALL ? EL_BD_MAGIC_WALL_ACTIVE :
6669 EL_DC_MAGIC_WALL_ACTIVE);
6671 // activate magic wall / mill
6672 SCAN_PLAYFIELD(xx, yy)
6674 if (Tile[xx][yy] == smashed)
6675 Tile[xx][yy] = activated_magic_wall;
6678 game.magic_wall_time_left = level.time_magic_wall * FRAMES_PER_SECOND;
6679 game.magic_wall_active = TRUE;
6681 PlayLevelSound(x, y, (smashed == EL_MAGIC_WALL ?
6682 SND_MAGIC_WALL_ACTIVATING :
6683 smashed == EL_BD_MAGIC_WALL ?
6684 SND_BD_MAGIC_WALL_ACTIVATING :
6685 SND_DC_MAGIC_WALL_ACTIVATING));
6688 if (IS_PLAYER(x, y + 1))
6690 if (CAN_SMASH_PLAYER(element))
6692 KillPlayerUnlessEnemyProtected(x, y + 1);
6696 else if (smashed == EL_PENGUIN)
6698 if (CAN_SMASH_PLAYER(element))
6704 else if (element == EL_BD_DIAMOND)
6706 if (IS_CLASSIC_ENEMY(smashed) && IS_BD_ELEMENT(smashed))
6712 else if (((element == EL_SP_INFOTRON ||
6713 element == EL_SP_ZONK) &&
6714 (smashed == EL_SP_SNIKSNAK ||
6715 smashed == EL_SP_ELECTRON ||
6716 smashed == EL_SP_DISK_ORANGE)) ||
6717 (element == EL_SP_INFOTRON &&
6718 smashed == EL_SP_DISK_YELLOW))
6723 else if (CAN_SMASH_EVERYTHING(element))
6725 if (IS_CLASSIC_ENEMY(smashed) ||
6726 CAN_EXPLODE_SMASHED(smashed))
6731 else if (!IS_MOVING(x, y + 1) && !IS_BLOCKED(x, y + 1))
6733 if (smashed == EL_LAMP ||
6734 smashed == EL_LAMP_ACTIVE)
6739 else if (smashed == EL_NUT)
6741 Tile[x][y + 1] = EL_NUT_BREAKING;
6742 PlayLevelSound(x, y, SND_NUT_BREAKING);
6743 RaiseScoreElement(EL_NUT);
6746 else if (smashed == EL_PEARL)
6748 ResetGfxAnimation(x, y);
6750 Tile[x][y + 1] = EL_PEARL_BREAKING;
6751 PlayLevelSound(x, y, SND_PEARL_BREAKING);
6754 else if (smashed == EL_DIAMOND)
6756 Tile[x][y + 1] = EL_DIAMOND_BREAKING;
6757 PlayLevelSound(x, y, SND_DIAMOND_BREAKING);
6760 else if (IS_BELT_SWITCH(smashed))
6762 ToggleBeltSwitch(x, y + 1);
6764 else if (smashed == EL_SWITCHGATE_SWITCH_UP ||
6765 smashed == EL_SWITCHGATE_SWITCH_DOWN ||
6766 smashed == EL_DC_SWITCHGATE_SWITCH_UP ||
6767 smashed == EL_DC_SWITCHGATE_SWITCH_DOWN)
6769 ToggleSwitchgateSwitch(x, y + 1);
6771 else if (smashed == EL_LIGHT_SWITCH ||
6772 smashed == EL_LIGHT_SWITCH_ACTIVE)
6774 ToggleLightSwitch(x, y + 1);
6778 CheckElementChange(x, y + 1, smashed, element, CE_SMASHED);
6780 CheckElementChangeBySide(x, y + 1, smashed, element,
6781 CE_SWITCHED, CH_SIDE_TOP);
6782 CheckTriggeredElementChangeBySide(x, y + 1, smashed, CE_SWITCH_OF_X,
6788 CheckElementChange(x, y + 1, smashed, element, CE_SMASHED);
6793 // play sound of magic wall / mill
6795 (Tile[x][y + 1] == EL_MAGIC_WALL_ACTIVE ||
6796 Tile[x][y + 1] == EL_BD_MAGIC_WALL_ACTIVE ||
6797 Tile[x][y + 1] == EL_DC_MAGIC_WALL_ACTIVE))
6799 if (Tile[x][y + 1] == EL_MAGIC_WALL_ACTIVE)
6800 PlayLevelSound(x, y, SND_MAGIC_WALL_FILLING);
6801 else if (Tile[x][y + 1] == EL_BD_MAGIC_WALL_ACTIVE)
6802 PlayLevelSound(x, y, SND_BD_MAGIC_WALL_FILLING);
6803 else if (Tile[x][y + 1] == EL_DC_MAGIC_WALL_ACTIVE)
6804 PlayLevelSound(x, y, SND_DC_MAGIC_WALL_FILLING);
6809 // play sound of object that hits the ground
6810 if (last_line || object_hit)
6811 PlayLevelSoundElementAction(x, y, element, ACTION_IMPACT);
6814 static void TurnRoundExt(int x, int y)
6826 { 0, 0 }, { 0, 0 }, { 0, 0 },
6831 int left, right, back;
6835 { MV_DOWN, MV_UP, MV_RIGHT },
6836 { MV_UP, MV_DOWN, MV_LEFT },
6838 { MV_LEFT, MV_RIGHT, MV_DOWN },
6842 { MV_RIGHT, MV_LEFT, MV_UP }
6845 int element = Tile[x][y];
6846 int move_pattern = element_info[element].move_pattern;
6848 int old_move_dir = MovDir[x][y];
6849 int left_dir = turn[old_move_dir].left;
6850 int right_dir = turn[old_move_dir].right;
6851 int back_dir = turn[old_move_dir].back;
6853 int left_dx = move_xy[left_dir].dx, left_dy = move_xy[left_dir].dy;
6854 int right_dx = move_xy[right_dir].dx, right_dy = move_xy[right_dir].dy;
6855 int move_dx = move_xy[old_move_dir].dx, move_dy = move_xy[old_move_dir].dy;
6856 int back_dx = move_xy[back_dir].dx, back_dy = move_xy[back_dir].dy;
6858 int left_x = x + left_dx, left_y = y + left_dy;
6859 int right_x = x + right_dx, right_y = y + right_dy;
6860 int move_x = x + move_dx, move_y = y + move_dy;
6864 if (element == EL_BUG || element == EL_BD_BUTTERFLY)
6866 TestIfBadThingTouchesOtherBadThing(x, y);
6868 if (ENEMY_CAN_ENTER_FIELD(element, right_x, right_y))
6869 MovDir[x][y] = right_dir;
6870 else if (!ENEMY_CAN_ENTER_FIELD(element, move_x, move_y))
6871 MovDir[x][y] = left_dir;
6873 if (element == EL_BUG && MovDir[x][y] != old_move_dir)
6875 else if (element == EL_BD_BUTTERFLY) // && MovDir[x][y] == left_dir)
6878 else if (element == EL_SPACESHIP || element == EL_BD_FIREFLY)
6880 TestIfBadThingTouchesOtherBadThing(x, y);
6882 if (ENEMY_CAN_ENTER_FIELD(element, left_x, left_y))
6883 MovDir[x][y] = left_dir;
6884 else if (!ENEMY_CAN_ENTER_FIELD(element, move_x, move_y))
6885 MovDir[x][y] = right_dir;
6887 if (element == EL_SPACESHIP && MovDir[x][y] != old_move_dir)
6889 else if (element == EL_BD_FIREFLY) // && MovDir[x][y] == right_dir)
6892 else if (element == EL_SP_SNIKSNAK || element == EL_SP_ELECTRON)
6894 TestIfBadThingTouchesOtherBadThing(x, y);
6896 if (ELEMENT_CAN_ENTER_FIELD_BASE_4(element, left_x, left_y, 0))
6897 MovDir[x][y] = left_dir;
6898 else if (!ELEMENT_CAN_ENTER_FIELD_BASE_4(element, move_x, move_y, 0))
6899 MovDir[x][y] = right_dir;
6901 if (MovDir[x][y] != old_move_dir)
6904 else if (element == EL_YAMYAM)
6906 boolean can_turn_left = YAMYAM_CAN_ENTER_FIELD(element, left_x, left_y);
6907 boolean can_turn_right = YAMYAM_CAN_ENTER_FIELD(element, right_x, right_y);
6909 if (can_turn_left && can_turn_right)
6910 MovDir[x][y] = (RND(3) ? (RND(2) ? left_dir : right_dir) : back_dir);
6911 else if (can_turn_left)
6912 MovDir[x][y] = (RND(2) ? left_dir : back_dir);
6913 else if (can_turn_right)
6914 MovDir[x][y] = (RND(2) ? right_dir : back_dir);
6916 MovDir[x][y] = back_dir;
6918 MovDelay[x][y] = 16 + 16 * RND(3);
6920 else if (element == EL_DARK_YAMYAM)
6922 boolean can_turn_left = DARK_YAMYAM_CAN_ENTER_FIELD(element,
6924 boolean can_turn_right = DARK_YAMYAM_CAN_ENTER_FIELD(element,
6927 if (can_turn_left && can_turn_right)
6928 MovDir[x][y] = (RND(3) ? (RND(2) ? left_dir : right_dir) : back_dir);
6929 else if (can_turn_left)
6930 MovDir[x][y] = (RND(2) ? left_dir : back_dir);
6931 else if (can_turn_right)
6932 MovDir[x][y] = (RND(2) ? right_dir : back_dir);
6934 MovDir[x][y] = back_dir;
6936 MovDelay[x][y] = 16 + 16 * RND(3);
6938 else if (element == EL_PACMAN)
6940 boolean can_turn_left = PACMAN_CAN_ENTER_FIELD(element, left_x, left_y);
6941 boolean can_turn_right = PACMAN_CAN_ENTER_FIELD(element, right_x, right_y);
6943 if (can_turn_left && can_turn_right)
6944 MovDir[x][y] = (RND(3) ? (RND(2) ? left_dir : right_dir) : back_dir);
6945 else if (can_turn_left)
6946 MovDir[x][y] = (RND(2) ? left_dir : back_dir);
6947 else if (can_turn_right)
6948 MovDir[x][y] = (RND(2) ? right_dir : back_dir);
6950 MovDir[x][y] = back_dir;
6952 MovDelay[x][y] = 6 + RND(40);
6954 else if (element == EL_PIG)
6956 boolean can_turn_left = PIG_CAN_ENTER_FIELD(element, left_x, left_y);
6957 boolean can_turn_right = PIG_CAN_ENTER_FIELD(element, right_x, right_y);
6958 boolean can_move_on = PIG_CAN_ENTER_FIELD(element, move_x, move_y);
6959 boolean should_turn_left, should_turn_right, should_move_on;
6961 int rnd = RND(rnd_value);
6963 should_turn_left = (can_turn_left &&
6965 IN_LEV_FIELD_AND_NOT_FREE(x + back_dx + left_dx,
6966 y + back_dy + left_dy)));
6967 should_turn_right = (can_turn_right &&
6969 IN_LEV_FIELD_AND_NOT_FREE(x + back_dx + right_dx,
6970 y + back_dy + right_dy)));
6971 should_move_on = (can_move_on &&
6974 IN_LEV_FIELD_AND_NOT_FREE(x + move_dx + left_dx,
6975 y + move_dy + left_dy) ||
6976 IN_LEV_FIELD_AND_NOT_FREE(x + move_dx + right_dx,
6977 y + move_dy + right_dy)));
6979 if (should_turn_left || should_turn_right || should_move_on)
6981 if (should_turn_left && should_turn_right && should_move_on)
6982 MovDir[x][y] = (rnd < rnd_value / 3 ? left_dir :
6983 rnd < 2 * rnd_value / 3 ? right_dir :
6985 else if (should_turn_left && should_turn_right)
6986 MovDir[x][y] = (rnd < rnd_value / 2 ? left_dir : right_dir);
6987 else if (should_turn_left && should_move_on)
6988 MovDir[x][y] = (rnd < rnd_value / 2 ? left_dir : old_move_dir);
6989 else if (should_turn_right && should_move_on)
6990 MovDir[x][y] = (rnd < rnd_value / 2 ? right_dir : old_move_dir);
6991 else if (should_turn_left)
6992 MovDir[x][y] = left_dir;
6993 else if (should_turn_right)
6994 MovDir[x][y] = right_dir;
6995 else if (should_move_on)
6996 MovDir[x][y] = old_move_dir;
6998 else if (can_move_on && rnd > rnd_value / 8)
6999 MovDir[x][y] = old_move_dir;
7000 else if (can_turn_left && can_turn_right)
7001 MovDir[x][y] = (rnd < rnd_value / 2 ? left_dir : right_dir);
7002 else if (can_turn_left && rnd > rnd_value / 8)
7003 MovDir[x][y] = left_dir;
7004 else if (can_turn_right && rnd > rnd_value/8)
7005 MovDir[x][y] = right_dir;
7007 MovDir[x][y] = back_dir;
7009 xx = x + move_xy[MovDir[x][y]].dx;
7010 yy = y + move_xy[MovDir[x][y]].dy;
7012 if (!IN_LEV_FIELD(xx, yy) ||
7013 (!IS_FREE(xx, yy) && !IS_FOOD_PIG(Tile[xx][yy])))
7014 MovDir[x][y] = old_move_dir;
7018 else if (element == EL_DRAGON)
7020 boolean can_turn_left = DRAGON_CAN_ENTER_FIELD(element, left_x, left_y);
7021 boolean can_turn_right = DRAGON_CAN_ENTER_FIELD(element, right_x, right_y);
7022 boolean can_move_on = DRAGON_CAN_ENTER_FIELD(element, move_x, move_y);
7024 int rnd = RND(rnd_value);
7026 if (can_move_on && rnd > rnd_value / 8)
7027 MovDir[x][y] = old_move_dir;
7028 else if (can_turn_left && can_turn_right)
7029 MovDir[x][y] = (rnd < rnd_value / 2 ? left_dir : right_dir);
7030 else if (can_turn_left && rnd > rnd_value / 8)
7031 MovDir[x][y] = left_dir;
7032 else if (can_turn_right && rnd > rnd_value / 8)
7033 MovDir[x][y] = right_dir;
7035 MovDir[x][y] = back_dir;
7037 xx = x + move_xy[MovDir[x][y]].dx;
7038 yy = y + move_xy[MovDir[x][y]].dy;
7040 if (!IN_LEV_FIELD_AND_IS_FREE(xx, yy))
7041 MovDir[x][y] = old_move_dir;
7045 else if (element == EL_MOLE)
7047 boolean can_move_on =
7048 (MOLE_CAN_ENTER_FIELD(element, move_x, move_y,
7049 IS_AMOEBOID(Tile[move_x][move_y]) ||
7050 Tile[move_x][move_y] == EL_AMOEBA_SHRINKING));
7053 boolean can_turn_left =
7054 (MOLE_CAN_ENTER_FIELD(element, left_x, left_y,
7055 IS_AMOEBOID(Tile[left_x][left_y])));
7057 boolean can_turn_right =
7058 (MOLE_CAN_ENTER_FIELD(element, right_x, right_y,
7059 IS_AMOEBOID(Tile[right_x][right_y])));
7061 if (can_turn_left && can_turn_right)
7062 MovDir[x][y] = (RND(2) ? left_dir : right_dir);
7063 else if (can_turn_left)
7064 MovDir[x][y] = left_dir;
7066 MovDir[x][y] = right_dir;
7069 if (MovDir[x][y] != old_move_dir)
7072 else if (element == EL_BALLOON)
7074 MovDir[x][y] = game.wind_direction;
7077 else if (element == EL_SPRING)
7079 if (MovDir[x][y] & MV_HORIZONTAL)
7081 if (SPRING_CAN_BUMP_FROM_FIELD(move_x, move_y) &&
7082 !SPRING_CAN_ENTER_FIELD(element, x, y + 1))
7084 Tile[move_x][move_y] = EL_EMC_SPRING_BUMPER_ACTIVE;
7085 ResetGfxAnimation(move_x, move_y);
7086 TEST_DrawLevelField(move_x, move_y);
7088 MovDir[x][y] = back_dir;
7090 else if (!SPRING_CAN_ENTER_FIELD(element, move_x, move_y) ||
7091 SPRING_CAN_ENTER_FIELD(element, x, y + 1))
7092 MovDir[x][y] = MV_NONE;
7097 else if (element == EL_ROBOT ||
7098 element == EL_SATELLITE ||
7099 element == EL_PENGUIN ||
7100 element == EL_EMC_ANDROID)
7102 int attr_x = -1, attr_y = -1;
7104 if (game.all_players_gone)
7106 attr_x = game.exit_x;
7107 attr_y = game.exit_y;
7113 for (i = 0; i < MAX_PLAYERS; i++)
7115 struct PlayerInfo *player = &stored_player[i];
7116 int jx = player->jx, jy = player->jy;
7118 if (!player->active)
7122 ABS(jx - x) + ABS(jy - y) < ABS(attr_x - x) + ABS(attr_y - y))
7130 if (element == EL_ROBOT &&
7131 game.robot_wheel_x >= 0 &&
7132 game.robot_wheel_y >= 0 &&
7133 (Tile[game.robot_wheel_x][game.robot_wheel_y] == EL_ROBOT_WHEEL_ACTIVE ||
7134 game.engine_version < VERSION_IDENT(3,1,0,0)))
7136 attr_x = game.robot_wheel_x;
7137 attr_y = game.robot_wheel_y;
7140 if (element == EL_PENGUIN)
7143 static int xy[4][2] =
7151 for (i = 0; i < NUM_DIRECTIONS; i++)
7153 int ex = x + xy[i][0];
7154 int ey = y + xy[i][1];
7156 if (IN_LEV_FIELD(ex, ey) && (Tile[ex][ey] == EL_EXIT_OPEN ||
7157 Tile[ex][ey] == EL_EM_EXIT_OPEN ||
7158 Tile[ex][ey] == EL_STEEL_EXIT_OPEN ||
7159 Tile[ex][ey] == EL_EM_STEEL_EXIT_OPEN))
7168 MovDir[x][y] = MV_NONE;
7170 MovDir[x][y] |= (game.all_players_gone ? MV_RIGHT : MV_LEFT);
7171 else if (attr_x > x)
7172 MovDir[x][y] |= (game.all_players_gone ? MV_LEFT : MV_RIGHT);
7174 MovDir[x][y] |= (game.all_players_gone ? MV_DOWN : MV_UP);
7175 else if (attr_y > y)
7176 MovDir[x][y] |= (game.all_players_gone ? MV_UP : MV_DOWN);
7178 if (element == EL_ROBOT)
7182 if (MovDir[x][y] & MV_HORIZONTAL && MovDir[x][y] & MV_VERTICAL)
7183 MovDir[x][y] &= (RND(2) ? MV_HORIZONTAL : MV_VERTICAL);
7184 Moving2Blocked(x, y, &newx, &newy);
7186 if (IN_LEV_FIELD(newx, newy) && IS_FREE_OR_PLAYER(newx, newy))
7187 MovDelay[x][y] = 8 + 8 * !RND(3);
7189 MovDelay[x][y] = 16;
7191 else if (element == EL_PENGUIN)
7197 if (MovDir[x][y] & MV_HORIZONTAL && MovDir[x][y] & MV_VERTICAL)
7199 boolean first_horiz = RND(2);
7200 int new_move_dir = MovDir[x][y];
7203 new_move_dir & (first_horiz ? MV_HORIZONTAL : MV_VERTICAL);
7204 Moving2Blocked(x, y, &newx, &newy);
7206 if (PENGUIN_CAN_ENTER_FIELD(element, newx, newy))
7210 new_move_dir & (!first_horiz ? MV_HORIZONTAL : MV_VERTICAL);
7211 Moving2Blocked(x, y, &newx, &newy);
7213 if (PENGUIN_CAN_ENTER_FIELD(element, newx, newy))
7216 MovDir[x][y] = old_move_dir;
7220 else if (element == EL_SATELLITE)
7226 if (MovDir[x][y] & MV_HORIZONTAL && MovDir[x][y] & MV_VERTICAL)
7228 boolean first_horiz = RND(2);
7229 int new_move_dir = MovDir[x][y];
7232 new_move_dir & (first_horiz ? MV_HORIZONTAL : MV_VERTICAL);
7233 Moving2Blocked(x, y, &newx, &newy);
7235 if (SATELLITE_CAN_ENTER_FIELD(newx, newy))
7239 new_move_dir & (!first_horiz ? MV_HORIZONTAL : MV_VERTICAL);
7240 Moving2Blocked(x, y, &newx, &newy);
7242 if (SATELLITE_CAN_ENTER_FIELD(newx, newy))
7245 MovDir[x][y] = old_move_dir;
7249 else if (element == EL_EMC_ANDROID)
7251 static int check_pos[16] =
7253 -1, // 0 => (invalid)
7256 -1, // 3 => (invalid)
7258 0, // 5 => MV_LEFT | MV_UP
7259 2, // 6 => MV_RIGHT | MV_UP
7260 -1, // 7 => (invalid)
7262 6, // 9 => MV_LEFT | MV_DOWN
7263 4, // 10 => MV_RIGHT | MV_DOWN
7264 -1, // 11 => (invalid)
7265 -1, // 12 => (invalid)
7266 -1, // 13 => (invalid)
7267 -1, // 14 => (invalid)
7268 -1, // 15 => (invalid)
7276 { -1, -1, MV_LEFT | MV_UP },
7278 { +1, -1, MV_RIGHT | MV_UP },
7279 { +1, 0, MV_RIGHT },
7280 { +1, +1, MV_RIGHT | MV_DOWN },
7282 { -1, +1, MV_LEFT | MV_DOWN },
7285 int start_pos, check_order;
7286 boolean can_clone = FALSE;
7289 // check if there is any free field around current position
7290 for (i = 0; i < 8; i++)
7292 int newx = x + check_xy[i].dx;
7293 int newy = y + check_xy[i].dy;
7295 if (IN_LEV_FIELD_AND_IS_FREE(newx, newy))
7303 if (can_clone) // randomly find an element to clone
7307 start_pos = check_pos[RND(8)];
7308 check_order = (RND(2) ? -1 : +1);
7310 for (i = 0; i < 8; i++)
7312 int pos_raw = start_pos + i * check_order;
7313 int pos = (pos_raw + 8) % 8;
7314 int newx = x + check_xy[pos].dx;
7315 int newy = y + check_xy[pos].dy;
7317 if (ANDROID_CAN_CLONE_FIELD(newx, newy))
7319 element_info[element].move_leave_type = LEAVE_TYPE_LIMITED;
7320 element_info[element].move_leave_element = EL_TRIGGER_ELEMENT;
7322 Store[x][y] = Tile[newx][newy];
7331 if (can_clone) // randomly find a direction to move
7335 start_pos = check_pos[RND(8)];
7336 check_order = (RND(2) ? -1 : +1);
7338 for (i = 0; i < 8; i++)
7340 int pos_raw = start_pos + i * check_order;
7341 int pos = (pos_raw + 8) % 8;
7342 int newx = x + check_xy[pos].dx;
7343 int newy = y + check_xy[pos].dy;
7344 int new_move_dir = check_xy[pos].dir;
7346 if (IN_LEV_FIELD_AND_IS_FREE(newx, newy))
7348 MovDir[x][y] = new_move_dir;
7349 MovDelay[x][y] = level.android_clone_time * 8 + 1;
7358 if (can_clone) // cloning and moving successful
7361 // cannot clone -- try to move towards player
7363 start_pos = check_pos[MovDir[x][y] & 0x0f];
7364 check_order = (RND(2) ? -1 : +1);
7366 for (i = 0; i < 3; i++)
7368 // first check start_pos, then previous/next or (next/previous) pos
7369 int pos_raw = start_pos + (i < 2 ? i : -1) * check_order;
7370 int pos = (pos_raw + 8) % 8;
7371 int newx = x + check_xy[pos].dx;
7372 int newy = y + check_xy[pos].dy;
7373 int new_move_dir = check_xy[pos].dir;
7375 if (IS_PLAYER(newx, newy))
7378 if (ANDROID_CAN_ENTER_FIELD(element, newx, newy))
7380 MovDir[x][y] = new_move_dir;
7381 MovDelay[x][y] = level.android_move_time * 8 + 1;
7388 else if (move_pattern == MV_TURNING_LEFT ||
7389 move_pattern == MV_TURNING_RIGHT ||
7390 move_pattern == MV_TURNING_LEFT_RIGHT ||
7391 move_pattern == MV_TURNING_RIGHT_LEFT ||
7392 move_pattern == MV_TURNING_RANDOM ||
7393 move_pattern == MV_ALL_DIRECTIONS)
7395 boolean can_turn_left =
7396 CUSTOM_ELEMENT_CAN_ENTER_FIELD(element, left_x, left_y);
7397 boolean can_turn_right =
7398 CUSTOM_ELEMENT_CAN_ENTER_FIELD(element, right_x,right_y);
7400 if (element_info[element].move_stepsize == 0) // "not moving"
7403 if (move_pattern == MV_TURNING_LEFT)
7404 MovDir[x][y] = left_dir;
7405 else if (move_pattern == MV_TURNING_RIGHT)
7406 MovDir[x][y] = right_dir;
7407 else if (move_pattern == MV_TURNING_LEFT_RIGHT)
7408 MovDir[x][y] = (can_turn_left || !can_turn_right ? left_dir : right_dir);
7409 else if (move_pattern == MV_TURNING_RIGHT_LEFT)
7410 MovDir[x][y] = (can_turn_right || !can_turn_left ? right_dir : left_dir);
7411 else if (move_pattern == MV_TURNING_RANDOM)
7412 MovDir[x][y] = (can_turn_left && !can_turn_right ? left_dir :
7413 can_turn_right && !can_turn_left ? right_dir :
7414 RND(2) ? left_dir : right_dir);
7415 else if (can_turn_left && can_turn_right)
7416 MovDir[x][y] = (RND(3) ? (RND(2) ? left_dir : right_dir) : back_dir);
7417 else if (can_turn_left)
7418 MovDir[x][y] = (RND(2) ? left_dir : back_dir);
7419 else if (can_turn_right)
7420 MovDir[x][y] = (RND(2) ? right_dir : back_dir);
7422 MovDir[x][y] = back_dir;
7424 MovDelay[x][y] = GET_NEW_MOVE_DELAY(element);
7426 else if (move_pattern == MV_HORIZONTAL ||
7427 move_pattern == MV_VERTICAL)
7429 if (move_pattern & old_move_dir)
7430 MovDir[x][y] = back_dir;
7431 else if (move_pattern == MV_HORIZONTAL)
7432 MovDir[x][y] = (RND(2) ? MV_LEFT : MV_RIGHT);
7433 else if (move_pattern == MV_VERTICAL)
7434 MovDir[x][y] = (RND(2) ? MV_UP : MV_DOWN);
7436 MovDelay[x][y] = GET_NEW_MOVE_DELAY(element);
7438 else if (move_pattern & MV_ANY_DIRECTION)
7440 MovDir[x][y] = move_pattern;
7441 MovDelay[x][y] = GET_NEW_MOVE_DELAY(element);
7443 else if (move_pattern & MV_WIND_DIRECTION)
7445 MovDir[x][y] = game.wind_direction;
7446 MovDelay[x][y] = GET_NEW_MOVE_DELAY(element);
7448 else if (move_pattern == MV_ALONG_LEFT_SIDE)
7450 if (CUSTOM_ELEMENT_CAN_ENTER_FIELD(element, left_x, left_y))
7451 MovDir[x][y] = left_dir;
7452 else if (!CUSTOM_ELEMENT_CAN_ENTER_FIELD(element, move_x, move_y))
7453 MovDir[x][y] = right_dir;
7455 if (MovDir[x][y] != old_move_dir)
7456 MovDelay[x][y] = GET_NEW_MOVE_DELAY(element);
7458 else if (move_pattern == MV_ALONG_RIGHT_SIDE)
7460 if (CUSTOM_ELEMENT_CAN_ENTER_FIELD(element, right_x, right_y))
7461 MovDir[x][y] = right_dir;
7462 else if (!CUSTOM_ELEMENT_CAN_ENTER_FIELD(element, move_x, move_y))
7463 MovDir[x][y] = left_dir;
7465 if (MovDir[x][y] != old_move_dir)
7466 MovDelay[x][y] = GET_NEW_MOVE_DELAY(element);
7468 else if (move_pattern == MV_TOWARDS_PLAYER ||
7469 move_pattern == MV_AWAY_FROM_PLAYER)
7471 int attr_x = -1, attr_y = -1;
7473 boolean move_away = (move_pattern == MV_AWAY_FROM_PLAYER);
7475 if (game.all_players_gone)
7477 attr_x = game.exit_x;
7478 attr_y = game.exit_y;
7484 for (i = 0; i < MAX_PLAYERS; i++)
7486 struct PlayerInfo *player = &stored_player[i];
7487 int jx = player->jx, jy = player->jy;
7489 if (!player->active)
7493 ABS(jx - x) + ABS(jy - y) < ABS(attr_x - x) + ABS(attr_y - y))
7501 MovDir[x][y] = MV_NONE;
7503 MovDir[x][y] |= (move_away ? MV_RIGHT : MV_LEFT);
7504 else if (attr_x > x)
7505 MovDir[x][y] |= (move_away ? MV_LEFT : MV_RIGHT);
7507 MovDir[x][y] |= (move_away ? MV_DOWN : MV_UP);
7508 else if (attr_y > y)
7509 MovDir[x][y] |= (move_away ? MV_UP : MV_DOWN);
7511 MovDelay[x][y] = GET_NEW_MOVE_DELAY(element);
7513 if (MovDir[x][y] & MV_HORIZONTAL && MovDir[x][y] & MV_VERTICAL)
7515 boolean first_horiz = RND(2);
7516 int new_move_dir = MovDir[x][y];
7518 if (element_info[element].move_stepsize == 0) // "not moving"
7520 first_horiz = (ABS(attr_x - x) >= ABS(attr_y - y));
7521 MovDir[x][y] &= (first_horiz ? MV_HORIZONTAL : MV_VERTICAL);
7527 new_move_dir & (first_horiz ? MV_HORIZONTAL : MV_VERTICAL);
7528 Moving2Blocked(x, y, &newx, &newy);
7530 if (CUSTOM_ELEMENT_CAN_ENTER_FIELD(element, newx, newy))
7534 new_move_dir & (!first_horiz ? MV_HORIZONTAL : MV_VERTICAL);
7535 Moving2Blocked(x, y, &newx, &newy);
7537 if (CUSTOM_ELEMENT_CAN_ENTER_FIELD(element, newx, newy))
7540 MovDir[x][y] = old_move_dir;
7543 else if (move_pattern == MV_WHEN_PUSHED ||
7544 move_pattern == MV_WHEN_DROPPED)
7546 if (!CUSTOM_ELEMENT_CAN_ENTER_FIELD(element, move_x, move_y))
7547 MovDir[x][y] = MV_NONE;
7551 else if (move_pattern & MV_MAZE_RUNNER_STYLE)
7553 static int test_xy[7][2] =
7563 static int test_dir[7] =
7573 boolean hunter_mode = (move_pattern == MV_MAZE_HUNTER);
7574 int move_preference = -1000000; // start with very low preference
7575 int new_move_dir = MV_NONE;
7576 int start_test = RND(4);
7579 for (i = 0; i < NUM_DIRECTIONS; i++)
7581 int move_dir = test_dir[start_test + i];
7582 int move_dir_preference;
7584 xx = x + test_xy[start_test + i][0];
7585 yy = y + test_xy[start_test + i][1];
7587 if (hunter_mode && IN_LEV_FIELD(xx, yy) &&
7588 (IS_PLAYER(xx, yy) || Tile[xx][yy] == EL_PLAYER_IS_LEAVING))
7590 new_move_dir = move_dir;
7595 if (!CUSTOM_ELEMENT_CAN_ENTER_FIELD(element, xx, yy))
7598 move_dir_preference = -1 * RunnerVisit[xx][yy];
7599 if (hunter_mode && PlayerVisit[xx][yy] > 0)
7600 move_dir_preference = PlayerVisit[xx][yy];
7602 if (move_dir_preference > move_preference)
7604 // prefer field that has not been visited for the longest time
7605 move_preference = move_dir_preference;
7606 new_move_dir = move_dir;
7608 else if (move_dir_preference == move_preference &&
7609 move_dir == old_move_dir)
7611 // prefer last direction when all directions are preferred equally
7612 move_preference = move_dir_preference;
7613 new_move_dir = move_dir;
7617 MovDir[x][y] = new_move_dir;
7618 if (old_move_dir != new_move_dir)
7619 MovDelay[x][y] = GET_NEW_MOVE_DELAY(element);
7623 static void TurnRound(int x, int y)
7625 int direction = MovDir[x][y];
7629 GfxDir[x][y] = MovDir[x][y];
7631 if (direction != MovDir[x][y])
7635 GfxAction[x][y] = ACTION_TURNING_FROM_LEFT + MV_DIR_TO_BIT(direction);
7637 ResetGfxFrame(x, y);
7640 static boolean JustBeingPushed(int x, int y)
7644 for (i = 0; i < MAX_PLAYERS; i++)
7646 struct PlayerInfo *player = &stored_player[i];
7648 if (player->active && player->is_pushing && player->MovPos)
7650 int next_jx = player->jx + (player->jx - player->last_jx);
7651 int next_jy = player->jy + (player->jy - player->last_jy);
7653 if (x == next_jx && y == next_jy)
7661 static void StartMoving(int x, int y)
7663 boolean started_moving = FALSE; // some elements can fall _and_ move
7664 int element = Tile[x][y];
7669 if (MovDelay[x][y] == 0)
7670 GfxAction[x][y] = ACTION_DEFAULT;
7672 if (CAN_FALL(element) && y < lev_fieldy - 1)
7674 if ((x > 0 && IS_PLAYER(x - 1, y)) ||
7675 (x < lev_fieldx - 1 && IS_PLAYER(x + 1, y)))
7676 if (JustBeingPushed(x, y))
7679 if (element == EL_QUICKSAND_FULL)
7681 if (IS_FREE(x, y + 1))
7683 InitMovingField(x, y, MV_DOWN);
7684 started_moving = TRUE;
7686 Tile[x][y] = EL_QUICKSAND_EMPTYING;
7687 #if USE_QUICKSAND_BD_ROCK_BUGFIX
7688 if (Store[x][y] != EL_ROCK && Store[x][y] != EL_BD_ROCK)
7689 Store[x][y] = EL_ROCK;
7691 Store[x][y] = EL_ROCK;
7694 PlayLevelSoundAction(x, y, ACTION_EMPTYING);
7696 else if (Tile[x][y + 1] == EL_QUICKSAND_EMPTY)
7698 if (!MovDelay[x][y])
7700 MovDelay[x][y] = TILEY + 1;
7702 ResetGfxAnimation(x, y);
7703 ResetGfxAnimation(x, y + 1);
7708 DrawLevelElement(x, y, EL_QUICKSAND_EMPTYING);
7709 DrawLevelElement(x, y + 1, EL_QUICKSAND_FILLING);
7716 Tile[x][y] = EL_QUICKSAND_EMPTY;
7717 Tile[x][y + 1] = EL_QUICKSAND_FULL;
7718 Store[x][y + 1] = Store[x][y];
7721 PlayLevelSoundAction(x, y, ACTION_FILLING);
7723 else if (Tile[x][y + 1] == EL_QUICKSAND_FAST_EMPTY)
7725 if (!MovDelay[x][y])
7727 MovDelay[x][y] = TILEY + 1;
7729 ResetGfxAnimation(x, y);
7730 ResetGfxAnimation(x, y + 1);
7735 DrawLevelElement(x, y, EL_QUICKSAND_EMPTYING);
7736 DrawLevelElement(x, y + 1, EL_QUICKSAND_FAST_FILLING);
7743 Tile[x][y] = EL_QUICKSAND_EMPTY;
7744 Tile[x][y + 1] = EL_QUICKSAND_FAST_FULL;
7745 Store[x][y + 1] = Store[x][y];
7748 PlayLevelSoundAction(x, y, ACTION_FILLING);
7751 else if (element == EL_QUICKSAND_FAST_FULL)
7753 if (IS_FREE(x, y + 1))
7755 InitMovingField(x, y, MV_DOWN);
7756 started_moving = TRUE;
7758 Tile[x][y] = EL_QUICKSAND_FAST_EMPTYING;
7759 #if USE_QUICKSAND_BD_ROCK_BUGFIX
7760 if (Store[x][y] != EL_ROCK && Store[x][y] != EL_BD_ROCK)
7761 Store[x][y] = EL_ROCK;
7763 Store[x][y] = EL_ROCK;
7766 PlayLevelSoundAction(x, y, ACTION_EMPTYING);
7768 else if (Tile[x][y + 1] == EL_QUICKSAND_FAST_EMPTY)
7770 if (!MovDelay[x][y])
7772 MovDelay[x][y] = TILEY + 1;
7774 ResetGfxAnimation(x, y);
7775 ResetGfxAnimation(x, y + 1);
7780 DrawLevelElement(x, y, EL_QUICKSAND_FAST_EMPTYING);
7781 DrawLevelElement(x, y + 1, EL_QUICKSAND_FAST_FILLING);
7788 Tile[x][y] = EL_QUICKSAND_FAST_EMPTY;
7789 Tile[x][y + 1] = EL_QUICKSAND_FAST_FULL;
7790 Store[x][y + 1] = Store[x][y];
7793 PlayLevelSoundAction(x, y, ACTION_FILLING);
7795 else if (Tile[x][y + 1] == EL_QUICKSAND_EMPTY)
7797 if (!MovDelay[x][y])
7799 MovDelay[x][y] = TILEY + 1;
7801 ResetGfxAnimation(x, y);
7802 ResetGfxAnimation(x, y + 1);
7807 DrawLevelElement(x, y, EL_QUICKSAND_FAST_EMPTYING);
7808 DrawLevelElement(x, y + 1, EL_QUICKSAND_FILLING);
7815 Tile[x][y] = EL_QUICKSAND_FAST_EMPTY;
7816 Tile[x][y + 1] = EL_QUICKSAND_FULL;
7817 Store[x][y + 1] = Store[x][y];
7820 PlayLevelSoundAction(x, y, ACTION_FILLING);
7823 else if ((element == EL_ROCK || element == EL_BD_ROCK) &&
7824 Tile[x][y + 1] == EL_QUICKSAND_EMPTY)
7826 InitMovingField(x, y, MV_DOWN);
7827 started_moving = TRUE;
7829 Tile[x][y] = EL_QUICKSAND_FILLING;
7830 Store[x][y] = element;
7832 PlayLevelSoundAction(x, y, ACTION_FILLING);
7834 else if ((element == EL_ROCK || element == EL_BD_ROCK) &&
7835 Tile[x][y + 1] == EL_QUICKSAND_FAST_EMPTY)
7837 InitMovingField(x, y, MV_DOWN);
7838 started_moving = TRUE;
7840 Tile[x][y] = EL_QUICKSAND_FAST_FILLING;
7841 Store[x][y] = element;
7843 PlayLevelSoundAction(x, y, ACTION_FILLING);
7845 else if (element == EL_MAGIC_WALL_FULL)
7847 if (IS_FREE(x, y + 1))
7849 InitMovingField(x, y, MV_DOWN);
7850 started_moving = TRUE;
7852 Tile[x][y] = EL_MAGIC_WALL_EMPTYING;
7853 Store[x][y] = EL_CHANGED(Store[x][y]);
7855 else if (Tile[x][y + 1] == EL_MAGIC_WALL_ACTIVE)
7857 if (!MovDelay[x][y])
7858 MovDelay[x][y] = TILEY / 4 + 1;
7867 Tile[x][y] = EL_MAGIC_WALL_ACTIVE;
7868 Tile[x][y + 1] = EL_MAGIC_WALL_FULL;
7869 Store[x][y + 1] = EL_CHANGED(Store[x][y]);
7873 else if (element == EL_BD_MAGIC_WALL_FULL)
7875 if (IS_FREE(x, y + 1))
7877 InitMovingField(x, y, MV_DOWN);
7878 started_moving = TRUE;
7880 Tile[x][y] = EL_BD_MAGIC_WALL_EMPTYING;
7881 Store[x][y] = EL_CHANGED_BD(Store[x][y]);
7883 else if (Tile[x][y + 1] == EL_BD_MAGIC_WALL_ACTIVE)
7885 if (!MovDelay[x][y])
7886 MovDelay[x][y] = TILEY / 4 + 1;
7895 Tile[x][y] = EL_BD_MAGIC_WALL_ACTIVE;
7896 Tile[x][y + 1] = EL_BD_MAGIC_WALL_FULL;
7897 Store[x][y + 1] = EL_CHANGED_BD(Store[x][y]);
7901 else if (element == EL_DC_MAGIC_WALL_FULL)
7903 if (IS_FREE(x, y + 1))
7905 InitMovingField(x, y, MV_DOWN);
7906 started_moving = TRUE;
7908 Tile[x][y] = EL_DC_MAGIC_WALL_EMPTYING;
7909 Store[x][y] = EL_CHANGED_DC(Store[x][y]);
7911 else if (Tile[x][y + 1] == EL_DC_MAGIC_WALL_ACTIVE)
7913 if (!MovDelay[x][y])
7914 MovDelay[x][y] = TILEY / 4 + 1;
7923 Tile[x][y] = EL_DC_MAGIC_WALL_ACTIVE;
7924 Tile[x][y + 1] = EL_DC_MAGIC_WALL_FULL;
7925 Store[x][y + 1] = EL_CHANGED_DC(Store[x][y]);
7929 else if ((CAN_PASS_MAGIC_WALL(element) &&
7930 (Tile[x][y + 1] == EL_MAGIC_WALL_ACTIVE ||
7931 Tile[x][y + 1] == EL_BD_MAGIC_WALL_ACTIVE)) ||
7932 (CAN_PASS_DC_MAGIC_WALL(element) &&
7933 (Tile[x][y + 1] == EL_DC_MAGIC_WALL_ACTIVE)))
7936 InitMovingField(x, y, MV_DOWN);
7937 started_moving = TRUE;
7940 (Tile[x][y + 1] == EL_MAGIC_WALL_ACTIVE ? EL_MAGIC_WALL_FILLING :
7941 Tile[x][y + 1] == EL_BD_MAGIC_WALL_ACTIVE ? EL_BD_MAGIC_WALL_FILLING :
7942 EL_DC_MAGIC_WALL_FILLING);
7943 Store[x][y] = element;
7945 else if (CAN_FALL(element) && Tile[x][y + 1] == EL_ACID)
7947 SplashAcid(x, y + 1);
7949 InitMovingField(x, y, MV_DOWN);
7950 started_moving = TRUE;
7952 Store[x][y] = EL_ACID;
7955 (game.engine_version >= VERSION_IDENT(3,1,0,0) &&
7956 CheckImpact[x][y] && !IS_FREE(x, y + 1)) ||
7957 (game.engine_version >= VERSION_IDENT(3,0,7,0) &&
7958 CAN_FALL(element) && WasJustFalling[x][y] &&
7959 (Tile[x][y + 1] == EL_BLOCKED || IS_PLAYER(x, y + 1))) ||
7961 (game.engine_version < VERSION_IDENT(2,2,0,7) &&
7962 CAN_FALL(element) && WasJustMoving[x][y] && !Pushed[x][y + 1] &&
7963 (Tile[x][y + 1] == EL_BLOCKED)))
7965 /* this is needed for a special case not covered by calling "Impact()"
7966 from "ContinueMoving()": if an element moves to a tile directly below
7967 another element which was just falling on that tile (which was empty
7968 in the previous frame), the falling element above would just stop
7969 instead of smashing the element below (in previous version, the above
7970 element was just checked for "moving" instead of "falling", resulting
7971 in incorrect smashes caused by horizontal movement of the above
7972 element; also, the case of the player being the element to smash was
7973 simply not covered here... :-/ ) */
7975 CheckCollision[x][y] = 0;
7976 CheckImpact[x][y] = 0;
7980 else if (IS_FREE(x, y + 1) && element == EL_SPRING && level.use_spring_bug)
7982 if (MovDir[x][y] == MV_NONE)
7984 InitMovingField(x, y, MV_DOWN);
7985 started_moving = TRUE;
7988 else if (IS_FREE(x, y + 1) || Tile[x][y + 1] == EL_DIAMOND_BREAKING)
7990 if (WasJustFalling[x][y]) // prevent animation from being restarted
7991 MovDir[x][y] = MV_DOWN;
7993 InitMovingField(x, y, MV_DOWN);
7994 started_moving = TRUE;
7996 else if (element == EL_AMOEBA_DROP)
7998 Tile[x][y] = EL_AMOEBA_GROWING;
7999 Store[x][y] = EL_AMOEBA_WET;
8001 else if (((IS_SLIPPERY(Tile[x][y + 1]) && !IS_PLAYER(x, y + 1)) ||
8002 (IS_EM_SLIPPERY_WALL(Tile[x][y + 1]) && IS_GEM(element))) &&
8003 !IS_FALLING(x, y + 1) && !WasJustMoving[x][y + 1] &&
8004 element != EL_DX_SUPABOMB && element != EL_SP_DISK_ORANGE)
8006 boolean can_fall_left = (x > 0 && IS_FREE(x - 1, y) &&
8007 (IS_FREE(x - 1, y + 1) ||
8008 Tile[x - 1][y + 1] == EL_ACID));
8009 boolean can_fall_right = (x < lev_fieldx - 1 && IS_FREE(x + 1, y) &&
8010 (IS_FREE(x + 1, y + 1) ||
8011 Tile[x + 1][y + 1] == EL_ACID));
8012 boolean can_fall_any = (can_fall_left || can_fall_right);
8013 boolean can_fall_both = (can_fall_left && can_fall_right);
8014 int slippery_type = element_info[Tile[x][y + 1]].slippery_type;
8016 if (can_fall_any && slippery_type != SLIPPERY_ANY_RANDOM)
8018 if (slippery_type == SLIPPERY_ANY_LEFT_RIGHT && can_fall_both)
8019 can_fall_right = FALSE;
8020 else if (slippery_type == SLIPPERY_ANY_RIGHT_LEFT && can_fall_both)
8021 can_fall_left = FALSE;
8022 else if (slippery_type == SLIPPERY_ONLY_LEFT)
8023 can_fall_right = FALSE;
8024 else if (slippery_type == SLIPPERY_ONLY_RIGHT)
8025 can_fall_left = FALSE;
8027 can_fall_any = (can_fall_left || can_fall_right);
8028 can_fall_both = FALSE;
8033 if (element == EL_BD_ROCK || element == EL_BD_DIAMOND)
8034 can_fall_right = FALSE; // slip down on left side
8036 can_fall_left = !(can_fall_right = RND(2));
8038 can_fall_both = FALSE;
8043 // if not determined otherwise, prefer left side for slipping down
8044 InitMovingField(x, y, can_fall_left ? MV_LEFT : MV_RIGHT);
8045 started_moving = TRUE;
8048 else if (IS_BELT_ACTIVE(Tile[x][y + 1]))
8050 boolean left_is_free = (x > 0 && IS_FREE(x - 1, y));
8051 boolean right_is_free = (x < lev_fieldx - 1 && IS_FREE(x + 1, y));
8052 int belt_nr = getBeltNrFromBeltActiveElement(Tile[x][y + 1]);
8053 int belt_dir = game.belt_dir[belt_nr];
8055 if ((belt_dir == MV_LEFT && left_is_free) ||
8056 (belt_dir == MV_RIGHT && right_is_free))
8058 int nextx = (belt_dir == MV_LEFT ? x - 1 : x + 1);
8060 InitMovingField(x, y, belt_dir);
8061 started_moving = TRUE;
8063 Pushed[x][y] = TRUE;
8064 Pushed[nextx][y] = TRUE;
8066 GfxAction[x][y] = ACTION_DEFAULT;
8070 MovDir[x][y] = 0; // if element was moving, stop it
8075 // not "else if" because of elements that can fall and move (EL_SPRING)
8076 if (CAN_MOVE(element) && !started_moving)
8078 int move_pattern = element_info[element].move_pattern;
8081 Moving2Blocked(x, y, &newx, &newy);
8083 if (IS_PUSHABLE(element) && JustBeingPushed(x, y))
8086 if (game.engine_version >= VERSION_IDENT(3,1,0,0) &&
8087 CheckCollision[x][y] && !IN_LEV_FIELD_AND_IS_FREE(newx, newy))
8089 WasJustMoving[x][y] = 0;
8090 CheckCollision[x][y] = 0;
8092 TestIfElementHitsCustomElement(x, y, MovDir[x][y]);
8094 if (Tile[x][y] != element) // element has changed
8098 if (!MovDelay[x][y]) // start new movement phase
8100 // all objects that can change their move direction after each step
8101 // (YAMYAM, DARK_YAMYAM and PACMAN go straight until they hit a wall
8103 if (element != EL_YAMYAM &&
8104 element != EL_DARK_YAMYAM &&
8105 element != EL_PACMAN &&
8106 !(move_pattern & MV_ANY_DIRECTION) &&
8107 move_pattern != MV_TURNING_LEFT &&
8108 move_pattern != MV_TURNING_RIGHT &&
8109 move_pattern != MV_TURNING_LEFT_RIGHT &&
8110 move_pattern != MV_TURNING_RIGHT_LEFT &&
8111 move_pattern != MV_TURNING_RANDOM)
8115 if (MovDelay[x][y] && (element == EL_BUG ||
8116 element == EL_SPACESHIP ||
8117 element == EL_SP_SNIKSNAK ||
8118 element == EL_SP_ELECTRON ||
8119 element == EL_MOLE))
8120 TEST_DrawLevelField(x, y);
8124 if (MovDelay[x][y]) // wait some time before next movement
8128 if (element == EL_ROBOT ||
8129 element == EL_YAMYAM ||
8130 element == EL_DARK_YAMYAM)
8132 DrawLevelElementAnimationIfNeeded(x, y, element);
8133 PlayLevelSoundAction(x, y, ACTION_WAITING);
8135 else if (element == EL_SP_ELECTRON)
8136 DrawLevelElementAnimationIfNeeded(x, y, element);
8137 else if (element == EL_DRAGON)
8140 int dir = MovDir[x][y];
8141 int dx = (dir == MV_LEFT ? -1 : dir == MV_RIGHT ? +1 : 0);
8142 int dy = (dir == MV_UP ? -1 : dir == MV_DOWN ? +1 : 0);
8143 int graphic = (dir == MV_LEFT ? IMG_FLAMES_1_LEFT :
8144 dir == MV_RIGHT ? IMG_FLAMES_1_RIGHT :
8145 dir == MV_UP ? IMG_FLAMES_1_UP :
8146 dir == MV_DOWN ? IMG_FLAMES_1_DOWN : IMG_EMPTY);
8147 int frame = getGraphicAnimationFrame(graphic, GfxFrame[x][y]);
8149 GfxAction[x][y] = ACTION_ATTACKING;
8151 if (IS_PLAYER(x, y))
8152 DrawPlayerField(x, y);
8154 TEST_DrawLevelField(x, y);
8156 PlayLevelSoundActionIfLoop(x, y, ACTION_ATTACKING);
8158 for (i = 1; i <= 3; i++)
8160 int xx = x + i * dx;
8161 int yy = y + i * dy;
8162 int sx = SCREENX(xx);
8163 int sy = SCREENY(yy);
8164 int flame_graphic = graphic + (i - 1);
8166 if (!IN_LEV_FIELD(xx, yy) || IS_DRAGONFIRE_PROOF(Tile[xx][yy]))
8171 int flamed = MovingOrBlocked2Element(xx, yy);
8173 if (IS_CLASSIC_ENEMY(flamed) || CAN_EXPLODE_BY_DRAGONFIRE(flamed))
8176 RemoveMovingField(xx, yy);
8178 ChangeDelay[xx][yy] = 0;
8180 Tile[xx][yy] = EL_FLAMES;
8182 if (IN_SCR_FIELD(sx, sy))
8184 TEST_DrawLevelFieldCrumbled(xx, yy);
8185 DrawGraphic(sx, sy, flame_graphic, frame);
8190 if (Tile[xx][yy] == EL_FLAMES)
8191 Tile[xx][yy] = EL_EMPTY;
8192 TEST_DrawLevelField(xx, yy);
8197 if (MovDelay[x][y]) // element still has to wait some time
8199 PlayLevelSoundAction(x, y, ACTION_WAITING);
8205 // now make next step
8207 Moving2Blocked(x, y, &newx, &newy); // get next screen position
8209 if (DONT_COLLIDE_WITH(element) &&
8210 IN_LEV_FIELD(newx, newy) && IS_PLAYER(newx, newy) &&
8211 !PLAYER_ENEMY_PROTECTED(newx, newy))
8213 TestIfBadThingRunsIntoPlayer(x, y, MovDir[x][y]);
8218 else if (CAN_MOVE_INTO_ACID(element) &&
8219 IN_LEV_FIELD(newx, newy) && Tile[newx][newy] == EL_ACID &&
8220 !IS_MV_DIAGONAL(MovDir[x][y]) &&
8221 (MovDir[x][y] == MV_DOWN ||
8222 game.engine_version >= VERSION_IDENT(3,1,0,0)))
8224 SplashAcid(newx, newy);
8225 Store[x][y] = EL_ACID;
8227 else if (element == EL_PENGUIN && IN_LEV_FIELD(newx, newy))
8229 if (Tile[newx][newy] == EL_EXIT_OPEN ||
8230 Tile[newx][newy] == EL_EM_EXIT_OPEN ||
8231 Tile[newx][newy] == EL_STEEL_EXIT_OPEN ||
8232 Tile[newx][newy] == EL_EM_STEEL_EXIT_OPEN)
8235 TEST_DrawLevelField(x, y);
8237 PlayLevelSound(newx, newy, SND_PENGUIN_PASSING);
8238 if (IN_SCR_FIELD(SCREENX(newx), SCREENY(newy)))
8239 DrawGraphicThruMask(SCREENX(newx),SCREENY(newy), el2img(element), 0);
8241 game.friends_still_needed--;
8242 if (!game.friends_still_needed &&
8244 game.all_players_gone)
8249 else if (IS_FOOD_PENGUIN(Tile[newx][newy]))
8251 if (DigField(local_player, x, y, newx, newy, 0,0, DF_DIG) == MP_MOVING)
8252 TEST_DrawLevelField(newx, newy);
8254 GfxDir[x][y] = MovDir[x][y] = MV_NONE;
8256 else if (!IS_FREE(newx, newy))
8258 GfxAction[x][y] = ACTION_WAITING;
8260 if (IS_PLAYER(x, y))
8261 DrawPlayerField(x, y);
8263 TEST_DrawLevelField(x, y);
8268 else if (element == EL_PIG && IN_LEV_FIELD(newx, newy))
8270 if (IS_FOOD_PIG(Tile[newx][newy]))
8272 if (IS_MOVING(newx, newy))
8273 RemoveMovingField(newx, newy);
8276 Tile[newx][newy] = EL_EMPTY;
8277 TEST_DrawLevelField(newx, newy);
8280 PlayLevelSound(x, y, SND_PIG_DIGGING);
8282 else if (!IS_FREE(newx, newy))
8284 if (IS_PLAYER(x, y))
8285 DrawPlayerField(x, y);
8287 TEST_DrawLevelField(x, y);
8292 else if (element == EL_EMC_ANDROID && IN_LEV_FIELD(newx, newy))
8294 if (Store[x][y] != EL_EMPTY)
8296 boolean can_clone = FALSE;
8299 // check if element to clone is still there
8300 for (yy = y - 1; yy <= y + 1; yy++) for (xx = x - 1; xx <= x + 1; xx++)
8302 if (IN_LEV_FIELD(xx, yy) && Tile[xx][yy] == Store[x][y])
8310 // cannot clone or target field not free anymore -- do not clone
8311 if (!can_clone || !ANDROID_CAN_ENTER_FIELD(element, newx, newy))
8312 Store[x][y] = EL_EMPTY;
8315 if (ANDROID_CAN_ENTER_FIELD(element, newx, newy))
8317 if (IS_MV_DIAGONAL(MovDir[x][y]))
8319 int diagonal_move_dir = MovDir[x][y];
8320 int stored = Store[x][y];
8321 int change_delay = 8;
8324 // android is moving diagonally
8326 CreateField(x, y, EL_DIAGONAL_SHRINKING);
8328 Store[x][y] = (stored == EL_ACID ? EL_EMPTY : stored);
8329 GfxElement[x][y] = EL_EMC_ANDROID;
8330 GfxAction[x][y] = ACTION_SHRINKING;
8331 GfxDir[x][y] = diagonal_move_dir;
8332 ChangeDelay[x][y] = change_delay;
8334 graphic = el_act_dir2img(GfxElement[x][y], GfxAction[x][y],
8337 DrawLevelGraphicAnimation(x, y, graphic);
8338 PlayLevelSoundAction(x, y, ACTION_SHRINKING);
8340 if (Tile[newx][newy] == EL_ACID)
8342 SplashAcid(newx, newy);
8347 CreateField(newx, newy, EL_DIAGONAL_GROWING);
8349 Store[newx][newy] = EL_EMC_ANDROID;
8350 GfxElement[newx][newy] = EL_EMC_ANDROID;
8351 GfxAction[newx][newy] = ACTION_GROWING;
8352 GfxDir[newx][newy] = diagonal_move_dir;
8353 ChangeDelay[newx][newy] = change_delay;
8355 graphic = el_act_dir2img(GfxElement[newx][newy],
8356 GfxAction[newx][newy], GfxDir[newx][newy]);
8358 DrawLevelGraphicAnimation(newx, newy, graphic);
8359 PlayLevelSoundAction(newx, newy, ACTION_GROWING);
8365 Tile[newx][newy] = EL_EMPTY;
8366 TEST_DrawLevelField(newx, newy);
8368 PlayLevelSoundAction(x, y, ACTION_DIGGING);
8371 else if (!IS_FREE(newx, newy))
8376 else if (IS_CUSTOM_ELEMENT(element) &&
8377 CUSTOM_ELEMENT_CAN_ENTER_FIELD(element, newx, newy))
8379 if (!DigFieldByCE(newx, newy, element))
8382 if (move_pattern & MV_MAZE_RUNNER_STYLE)
8384 RunnerVisit[x][y] = FrameCounter;
8385 PlayerVisit[x][y] /= 8; // expire player visit path
8388 else if (element == EL_DRAGON && IN_LEV_FIELD(newx, newy))
8390 if (!IS_FREE(newx, newy))
8392 if (IS_PLAYER(x, y))
8393 DrawPlayerField(x, y);
8395 TEST_DrawLevelField(x, y);
8401 boolean wanna_flame = !RND(10);
8402 int dx = newx - x, dy = newy - y;
8403 int newx1 = newx + 1 * dx, newy1 = newy + 1 * dy;
8404 int newx2 = newx + 2 * dx, newy2 = newy + 2 * dy;
8405 int element1 = (IN_LEV_FIELD(newx1, newy1) ?
8406 MovingOrBlocked2Element(newx1, newy1) : EL_STEELWALL);
8407 int element2 = (IN_LEV_FIELD(newx2, newy2) ?
8408 MovingOrBlocked2Element(newx2, newy2) : EL_STEELWALL);
8411 IS_CLASSIC_ENEMY(element1) ||
8412 IS_CLASSIC_ENEMY(element2)) &&
8413 element1 != EL_DRAGON && element2 != EL_DRAGON &&
8414 element1 != EL_FLAMES && element2 != EL_FLAMES)
8416 ResetGfxAnimation(x, y);
8417 GfxAction[x][y] = ACTION_ATTACKING;
8419 if (IS_PLAYER(x, y))
8420 DrawPlayerField(x, y);
8422 TEST_DrawLevelField(x, y);
8424 PlayLevelSound(x, y, SND_DRAGON_ATTACKING);
8426 MovDelay[x][y] = 50;
8428 Tile[newx][newy] = EL_FLAMES;
8429 if (IN_LEV_FIELD(newx1, newy1) && Tile[newx1][newy1] == EL_EMPTY)
8430 Tile[newx1][newy1] = EL_FLAMES;
8431 if (IN_LEV_FIELD(newx2, newy2) && Tile[newx2][newy2] == EL_EMPTY)
8432 Tile[newx2][newy2] = EL_FLAMES;
8438 else if (element == EL_YAMYAM && IN_LEV_FIELD(newx, newy) &&
8439 Tile[newx][newy] == EL_DIAMOND)
8441 if (IS_MOVING(newx, newy))
8442 RemoveMovingField(newx, newy);
8445 Tile[newx][newy] = EL_EMPTY;
8446 TEST_DrawLevelField(newx, newy);
8449 PlayLevelSound(x, y, SND_YAMYAM_DIGGING);
8451 else if (element == EL_DARK_YAMYAM && IN_LEV_FIELD(newx, newy) &&
8452 IS_FOOD_DARK_YAMYAM(Tile[newx][newy]))
8454 if (AmoebaNr[newx][newy])
8456 AmoebaCnt2[AmoebaNr[newx][newy]]--;
8457 if (Tile[newx][newy] == EL_AMOEBA_FULL ||
8458 Tile[newx][newy] == EL_BD_AMOEBA)
8459 AmoebaCnt[AmoebaNr[newx][newy]]--;
8462 if (IS_MOVING(newx, newy))
8464 RemoveMovingField(newx, newy);
8468 Tile[newx][newy] = EL_EMPTY;
8469 TEST_DrawLevelField(newx, newy);
8472 PlayLevelSound(x, y, SND_DARK_YAMYAM_DIGGING);
8474 else if ((element == EL_PACMAN || element == EL_MOLE)
8475 && IN_LEV_FIELD(newx, newy) && IS_AMOEBOID(Tile[newx][newy]))
8477 if (AmoebaNr[newx][newy])
8479 AmoebaCnt2[AmoebaNr[newx][newy]]--;
8480 if (Tile[newx][newy] == EL_AMOEBA_FULL ||
8481 Tile[newx][newy] == EL_BD_AMOEBA)
8482 AmoebaCnt[AmoebaNr[newx][newy]]--;
8485 if (element == EL_MOLE)
8487 Tile[newx][newy] = EL_AMOEBA_SHRINKING;
8488 PlayLevelSound(x, y, SND_MOLE_DIGGING);
8490 ResetGfxAnimation(x, y);
8491 GfxAction[x][y] = ACTION_DIGGING;
8492 TEST_DrawLevelField(x, y);
8494 MovDelay[newx][newy] = 0; // start amoeba shrinking delay
8496 return; // wait for shrinking amoeba
8498 else // element == EL_PACMAN
8500 Tile[newx][newy] = EL_EMPTY;
8501 TEST_DrawLevelField(newx, newy);
8502 PlayLevelSound(x, y, SND_PACMAN_DIGGING);
8505 else if (element == EL_MOLE && IN_LEV_FIELD(newx, newy) &&
8506 (Tile[newx][newy] == EL_AMOEBA_SHRINKING ||
8507 (Tile[newx][newy] == EL_EMPTY && Stop[newx][newy])))
8509 // wait for shrinking amoeba to completely disappear
8512 else if (!IN_LEV_FIELD(newx, newy) || !IS_FREE(newx, newy))
8514 // object was running against a wall
8518 if (GFX_ELEMENT(element) != EL_SAND) // !!! FIX THIS (crumble) !!!
8519 DrawLevelElementAnimation(x, y, element);
8521 if (DONT_TOUCH(element))
8522 TestIfBadThingTouchesPlayer(x, y);
8527 InitMovingField(x, y, MovDir[x][y]);
8529 PlayLevelSoundAction(x, y, ACTION_MOVING);
8533 ContinueMoving(x, y);
8536 void ContinueMoving(int x, int y)
8538 int element = Tile[x][y];
8539 struct ElementInfo *ei = &element_info[element];
8540 int direction = MovDir[x][y];
8541 int dx = (direction == MV_LEFT ? -1 : direction == MV_RIGHT ? +1 : 0);
8542 int dy = (direction == MV_UP ? -1 : direction == MV_DOWN ? +1 : 0);
8543 int newx = x + dx, newy = y + dy;
8544 int stored = Store[x][y];
8545 int stored_new = Store[newx][newy];
8546 boolean pushed_by_player = (Pushed[x][y] && IS_PLAYER(x, y));
8547 boolean pushed_by_conveyor = (Pushed[x][y] && !IS_PLAYER(x, y));
8548 boolean last_line = (newy == lev_fieldy - 1);
8549 boolean use_step_delay = (GET_MAX_STEP_DELAY(element) != 0);
8551 if (pushed_by_player) // special case: moving object pushed by player
8553 MovPos[x][y] = SIGN(MovPos[x][y]) * (TILEX - ABS(PLAYERINFO(x,y)->MovPos));
8555 else if (use_step_delay) // special case: moving object has step delay
8557 if (!MovDelay[x][y])
8558 MovPos[x][y] += getElementMoveStepsize(x, y);
8563 MovDelay[x][y] = GET_NEW_STEP_DELAY(element);
8567 TEST_DrawLevelField(x, y);
8569 return; // element is still waiting
8572 else // normal case: generically moving object
8574 MovPos[x][y] += getElementMoveStepsize(x, y);
8577 if (ABS(MovPos[x][y]) < TILEX)
8579 TEST_DrawLevelField(x, y);
8581 return; // element is still moving
8584 // element reached destination field
8586 Tile[x][y] = EL_EMPTY;
8587 Tile[newx][newy] = element;
8588 MovPos[x][y] = 0; // force "not moving" for "crumbled sand"
8590 if (Store[x][y] == EL_ACID) // element is moving into acid pool
8592 element = Tile[newx][newy] = EL_ACID;
8594 else if (element == EL_MOLE)
8596 Tile[x][y] = EL_SAND;
8598 TEST_DrawLevelFieldCrumbledNeighbours(x, y);
8600 else if (element == EL_QUICKSAND_FILLING)
8602 element = Tile[newx][newy] = get_next_element(element);
8603 Store[newx][newy] = Store[x][y];
8605 else if (element == EL_QUICKSAND_EMPTYING)
8607 Tile[x][y] = get_next_element(element);
8608 element = Tile[newx][newy] = Store[x][y];
8610 else if (element == EL_QUICKSAND_FAST_FILLING)
8612 element = Tile[newx][newy] = get_next_element(element);
8613 Store[newx][newy] = Store[x][y];
8615 else if (element == EL_QUICKSAND_FAST_EMPTYING)
8617 Tile[x][y] = get_next_element(element);
8618 element = Tile[newx][newy] = Store[x][y];
8620 else if (element == EL_MAGIC_WALL_FILLING)
8622 element = Tile[newx][newy] = get_next_element(element);
8623 if (!game.magic_wall_active)
8624 element = Tile[newx][newy] = EL_MAGIC_WALL_DEAD;
8625 Store[newx][newy] = Store[x][y];
8627 else if (element == EL_MAGIC_WALL_EMPTYING)
8629 Tile[x][y] = get_next_element(element);
8630 if (!game.magic_wall_active)
8631 Tile[x][y] = EL_MAGIC_WALL_DEAD;
8632 element = Tile[newx][newy] = Store[x][y];
8634 InitField(newx, newy, FALSE);
8636 else if (element == EL_BD_MAGIC_WALL_FILLING)
8638 element = Tile[newx][newy] = get_next_element(element);
8639 if (!game.magic_wall_active)
8640 element = Tile[newx][newy] = EL_BD_MAGIC_WALL_DEAD;
8641 Store[newx][newy] = Store[x][y];
8643 else if (element == EL_BD_MAGIC_WALL_EMPTYING)
8645 Tile[x][y] = get_next_element(element);
8646 if (!game.magic_wall_active)
8647 Tile[x][y] = EL_BD_MAGIC_WALL_DEAD;
8648 element = Tile[newx][newy] = Store[x][y];
8650 InitField(newx, newy, FALSE);
8652 else if (element == EL_DC_MAGIC_WALL_FILLING)
8654 element = Tile[newx][newy] = get_next_element(element);
8655 if (!game.magic_wall_active)
8656 element = Tile[newx][newy] = EL_DC_MAGIC_WALL_DEAD;
8657 Store[newx][newy] = Store[x][y];
8659 else if (element == EL_DC_MAGIC_WALL_EMPTYING)
8661 Tile[x][y] = get_next_element(element);
8662 if (!game.magic_wall_active)
8663 Tile[x][y] = EL_DC_MAGIC_WALL_DEAD;
8664 element = Tile[newx][newy] = Store[x][y];
8666 InitField(newx, newy, FALSE);
8668 else if (element == EL_AMOEBA_DROPPING)
8670 Tile[x][y] = get_next_element(element);
8671 element = Tile[newx][newy] = Store[x][y];
8673 else if (element == EL_SOKOBAN_OBJECT)
8676 Tile[x][y] = Back[x][y];
8678 if (Back[newx][newy])
8679 Tile[newx][newy] = EL_SOKOBAN_FIELD_FULL;
8681 Back[x][y] = Back[newx][newy] = 0;
8684 Store[x][y] = EL_EMPTY;
8689 MovDelay[newx][newy] = 0;
8691 if (CAN_CHANGE_OR_HAS_ACTION(element))
8693 // copy element change control values to new field
8694 ChangeDelay[newx][newy] = ChangeDelay[x][y];
8695 ChangePage[newx][newy] = ChangePage[x][y];
8696 ChangeCount[newx][newy] = ChangeCount[x][y];
8697 ChangeEvent[newx][newy] = ChangeEvent[x][y];
8700 CustomValue[newx][newy] = CustomValue[x][y];
8702 ChangeDelay[x][y] = 0;
8703 ChangePage[x][y] = -1;
8704 ChangeCount[x][y] = 0;
8705 ChangeEvent[x][y] = -1;
8707 CustomValue[x][y] = 0;
8709 // copy animation control values to new field
8710 GfxFrame[newx][newy] = GfxFrame[x][y];
8711 GfxRandom[newx][newy] = GfxRandom[x][y]; // keep same random value
8712 GfxAction[newx][newy] = GfxAction[x][y]; // keep action one frame
8713 GfxDir[newx][newy] = GfxDir[x][y]; // keep element direction
8715 Pushed[x][y] = Pushed[newx][newy] = FALSE;
8717 // some elements can leave other elements behind after moving
8718 if (ei->move_leave_element != EL_EMPTY &&
8719 (ei->move_leave_type == LEAVE_TYPE_UNLIMITED || stored != EL_EMPTY) &&
8720 (!IS_PLAYER(x, y) || IS_WALKABLE(ei->move_leave_element)))
8722 int move_leave_element = ei->move_leave_element;
8724 // this makes it possible to leave the removed element again
8725 if (ei->move_leave_element == EL_TRIGGER_ELEMENT)
8726 move_leave_element = (stored == EL_ACID ? EL_EMPTY : stored);
8728 Tile[x][y] = move_leave_element;
8730 if (element_info[Tile[x][y]].move_direction_initial == MV_START_PREVIOUS)
8731 MovDir[x][y] = direction;
8733 InitField(x, y, FALSE);
8735 if (GFX_CRUMBLED(Tile[x][y]))
8736 TEST_DrawLevelFieldCrumbledNeighbours(x, y);
8738 if (ELEM_IS_PLAYER(move_leave_element))
8739 RelocatePlayer(x, y, move_leave_element);
8742 // do this after checking for left-behind element
8743 ResetGfxAnimation(x, y); // reset animation values for old field
8745 if (!CAN_MOVE(element) ||
8746 (CAN_FALL(element) && direction == MV_DOWN &&
8747 (element == EL_SPRING ||
8748 element_info[element].move_pattern == MV_WHEN_PUSHED ||
8749 element_info[element].move_pattern == MV_WHEN_DROPPED)))
8750 GfxDir[x][y] = MovDir[newx][newy] = 0;
8752 TEST_DrawLevelField(x, y);
8753 TEST_DrawLevelField(newx, newy);
8755 Stop[newx][newy] = TRUE; // ignore this element until the next frame
8757 // prevent pushed element from moving on in pushed direction
8758 if (pushed_by_player && CAN_MOVE(element) &&
8759 element_info[element].move_pattern & MV_ANY_DIRECTION &&
8760 !(element_info[element].move_pattern & direction))
8761 TurnRound(newx, newy);
8763 // prevent elements on conveyor belt from moving on in last direction
8764 if (pushed_by_conveyor && CAN_FALL(element) &&
8765 direction & MV_HORIZONTAL)
8766 MovDir[newx][newy] = 0;
8768 if (!pushed_by_player)
8770 int nextx = newx + dx, nexty = newy + dy;
8771 boolean check_collision_again = IN_LEV_FIELD_AND_IS_FREE(nextx, nexty);
8773 WasJustMoving[newx][newy] = CHECK_DELAY_MOVING;
8775 if (CAN_FALL(element) && direction == MV_DOWN)
8776 WasJustFalling[newx][newy] = CHECK_DELAY_FALLING;
8778 if ((!CAN_FALL(element) || direction == MV_DOWN) && check_collision_again)
8779 CheckCollision[newx][newy] = CHECK_DELAY_COLLISION;
8781 if (CAN_FALL(element) && direction == MV_DOWN && check_collision_again)
8782 CheckImpact[newx][newy] = CHECK_DELAY_IMPACT;
8785 if (DONT_TOUCH(element)) // object may be nasty to player or others
8787 TestIfBadThingTouchesPlayer(newx, newy);
8788 TestIfBadThingTouchesFriend(newx, newy);
8790 if (!IS_CUSTOM_ELEMENT(element))
8791 TestIfBadThingTouchesOtherBadThing(newx, newy);
8793 else if (element == EL_PENGUIN)
8794 TestIfFriendTouchesBadThing(newx, newy);
8796 if (DONT_GET_HIT_BY(element))
8798 TestIfGoodThingGetsHitByBadThing(newx, newy, direction);
8801 // give the player one last chance (one more frame) to move away
8802 if (CAN_FALL(element) && direction == MV_DOWN &&
8803 (last_line || (!IS_FREE(x, newy + 1) &&
8804 (!IS_PLAYER(x, newy + 1) ||
8805 game.engine_version < VERSION_IDENT(3,1,1,0)))))
8808 if (pushed_by_player && !game.use_change_when_pushing_bug)
8810 int push_side = MV_DIR_OPPOSITE(direction);
8811 struct PlayerInfo *player = PLAYERINFO(x, y);
8813 CheckElementChangeByPlayer(newx, newy, element, CE_PUSHED_BY_PLAYER,
8814 player->index_bit, push_side);
8815 CheckTriggeredElementChangeByPlayer(newx,newy, element, CE_PLAYER_PUSHES_X,
8816 player->index_bit, push_side);
8819 if (element == EL_EMC_ANDROID && pushed_by_player) // make another move
8820 MovDelay[newx][newy] = 1;
8822 CheckTriggeredElementChangeBySide(x, y, element, CE_MOVE_OF_X, direction);
8824 TestIfElementTouchesCustomElement(x, y); // empty or new element
8825 TestIfElementHitsCustomElement(newx, newy, direction);
8826 TestIfPlayerTouchesCustomElement(newx, newy);
8827 TestIfElementTouchesCustomElement(newx, newy);
8829 if (IS_CUSTOM_ELEMENT(element) && ei->move_enter_element != EL_EMPTY &&
8830 IS_EQUAL_OR_IN_GROUP(stored_new, ei->move_enter_element))
8831 CheckElementChangeBySide(newx, newy, element, stored_new, CE_DIGGING_X,
8832 MV_DIR_OPPOSITE(direction));
8835 int AmoebaNeighbourNr(int ax, int ay)
8838 int element = Tile[ax][ay];
8840 static int xy[4][2] =
8848 for (i = 0; i < NUM_DIRECTIONS; i++)
8850 int x = ax + xy[i][0];
8851 int y = ay + xy[i][1];
8853 if (!IN_LEV_FIELD(x, y))
8856 if (Tile[x][y] == element && AmoebaNr[x][y] > 0)
8857 group_nr = AmoebaNr[x][y];
8863 static void AmoebaMerge(int ax, int ay)
8865 int i, x, y, xx, yy;
8866 int new_group_nr = AmoebaNr[ax][ay];
8867 static int xy[4][2] =
8875 if (new_group_nr == 0)
8878 for (i = 0; i < NUM_DIRECTIONS; i++)
8883 if (!IN_LEV_FIELD(x, y))
8886 if ((Tile[x][y] == EL_AMOEBA_FULL ||
8887 Tile[x][y] == EL_BD_AMOEBA ||
8888 Tile[x][y] == EL_AMOEBA_DEAD) &&
8889 AmoebaNr[x][y] != new_group_nr)
8891 int old_group_nr = AmoebaNr[x][y];
8893 if (old_group_nr == 0)
8896 AmoebaCnt[new_group_nr] += AmoebaCnt[old_group_nr];
8897 AmoebaCnt[old_group_nr] = 0;
8898 AmoebaCnt2[new_group_nr] += AmoebaCnt2[old_group_nr];
8899 AmoebaCnt2[old_group_nr] = 0;
8901 SCAN_PLAYFIELD(xx, yy)
8903 if (AmoebaNr[xx][yy] == old_group_nr)
8904 AmoebaNr[xx][yy] = new_group_nr;
8910 void AmoebaToDiamond(int ax, int ay)
8914 if (Tile[ax][ay] == EL_AMOEBA_DEAD)
8916 int group_nr = AmoebaNr[ax][ay];
8921 Debug("game:playing:AmoebaToDiamond", "ax = %d, ay = %d", ax, ay);
8922 Debug("game:playing:AmoebaToDiamond", "This should never happen!");
8928 SCAN_PLAYFIELD(x, y)
8930 if (Tile[x][y] == EL_AMOEBA_DEAD && AmoebaNr[x][y] == group_nr)
8933 Tile[x][y] = EL_AMOEBA_TO_DIAMOND;
8937 PlayLevelSound(ax, ay, (IS_GEM(level.amoeba_content) ?
8938 SND_AMOEBA_TURNING_TO_GEM :
8939 SND_AMOEBA_TURNING_TO_ROCK));
8944 static int xy[4][2] =
8952 for (i = 0; i < NUM_DIRECTIONS; i++)
8957 if (!IN_LEV_FIELD(x, y))
8960 if (Tile[x][y] == EL_AMOEBA_TO_DIAMOND)
8962 PlayLevelSound(x, y, (IS_GEM(level.amoeba_content) ?
8963 SND_AMOEBA_TURNING_TO_GEM :
8964 SND_AMOEBA_TURNING_TO_ROCK));
8971 static void AmoebaToDiamondBD(int ax, int ay, int new_element)
8974 int group_nr = AmoebaNr[ax][ay];
8975 boolean done = FALSE;
8980 Debug("game:playing:AmoebaToDiamondBD", "ax = %d, ay = %d", ax, ay);
8981 Debug("game:playing:AmoebaToDiamondBD", "This should never happen!");
8987 SCAN_PLAYFIELD(x, y)
8989 if (AmoebaNr[x][y] == group_nr &&
8990 (Tile[x][y] == EL_AMOEBA_DEAD ||
8991 Tile[x][y] == EL_BD_AMOEBA ||
8992 Tile[x][y] == EL_AMOEBA_GROWING))
8995 Tile[x][y] = new_element;
8996 InitField(x, y, FALSE);
8997 TEST_DrawLevelField(x, y);
9003 PlayLevelSound(ax, ay, (new_element == EL_BD_ROCK ?
9004 SND_BD_AMOEBA_TURNING_TO_ROCK :
9005 SND_BD_AMOEBA_TURNING_TO_GEM));
9008 static void AmoebaGrowing(int x, int y)
9010 static unsigned int sound_delay = 0;
9011 static unsigned int sound_delay_value = 0;
9013 if (!MovDelay[x][y]) // start new growing cycle
9017 if (DelayReached(&sound_delay, sound_delay_value))
9019 PlayLevelSoundElementAction(x, y, Store[x][y], ACTION_GROWING);
9020 sound_delay_value = 30;
9024 if (MovDelay[x][y]) // wait some time before growing bigger
9027 if (MovDelay[x][y]/2 && IN_SCR_FIELD(SCREENX(x), SCREENY(y)))
9029 int frame = getGraphicAnimationFrame(IMG_AMOEBA_GROWING,
9030 6 - MovDelay[x][y]);
9032 DrawGraphic(SCREENX(x), SCREENY(y), IMG_AMOEBA_GROWING, frame);
9035 if (!MovDelay[x][y])
9037 Tile[x][y] = Store[x][y];
9039 TEST_DrawLevelField(x, y);
9044 static void AmoebaShrinking(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 shrinking cycle
9053 if (DelayReached(&sound_delay, sound_delay_value))
9054 sound_delay_value = 30;
9057 if (MovDelay[x][y]) // wait some time before shrinking
9060 if (MovDelay[x][y]/2 && IN_SCR_FIELD(SCREENX(x), SCREENY(y)))
9062 int frame = getGraphicAnimationFrame(IMG_AMOEBA_SHRINKING,
9063 6 - MovDelay[x][y]);
9065 DrawGraphic(SCREENX(x), SCREENY(y), IMG_AMOEBA_SHRINKING, frame);
9068 if (!MovDelay[x][y])
9070 Tile[x][y] = EL_EMPTY;
9071 TEST_DrawLevelField(x, y);
9073 // don't let mole enter this field in this cycle;
9074 // (give priority to objects falling to this field from above)
9080 static void AmoebaReproduce(int ax, int ay)
9083 int element = Tile[ax][ay];
9084 int graphic = el2img(element);
9085 int newax = ax, neway = ay;
9086 boolean can_drop = (element == EL_AMOEBA_WET || element == EL_EMC_DRIPPER);
9087 static int xy[4][2] =
9095 if (!level.amoeba_speed && element != EL_EMC_DRIPPER)
9097 Tile[ax][ay] = EL_AMOEBA_DEAD;
9098 TEST_DrawLevelField(ax, ay);
9102 if (IS_ANIMATED(graphic))
9103 DrawLevelGraphicAnimationIfNeeded(ax, ay, graphic);
9105 if (!MovDelay[ax][ay]) // start making new amoeba field
9106 MovDelay[ax][ay] = RND(FRAMES_PER_SECOND * 25 / (1 + level.amoeba_speed));
9108 if (MovDelay[ax][ay]) // wait some time before making new amoeba
9111 if (MovDelay[ax][ay])
9115 if (can_drop) // EL_AMOEBA_WET or EL_EMC_DRIPPER
9118 int x = ax + xy[start][0];
9119 int y = ay + xy[start][1];
9121 if (!IN_LEV_FIELD(x, y))
9124 if (IS_FREE(x, y) ||
9125 CAN_GROW_INTO(Tile[x][y]) ||
9126 Tile[x][y] == EL_QUICKSAND_EMPTY ||
9127 Tile[x][y] == EL_QUICKSAND_FAST_EMPTY)
9133 if (newax == ax && neway == ay)
9136 else // normal or "filled" (BD style) amoeba
9139 boolean waiting_for_player = FALSE;
9141 for (i = 0; i < NUM_DIRECTIONS; i++)
9143 int j = (start + i) % 4;
9144 int x = ax + xy[j][0];
9145 int y = ay + xy[j][1];
9147 if (!IN_LEV_FIELD(x, y))
9150 if (IS_FREE(x, y) ||
9151 CAN_GROW_INTO(Tile[x][y]) ||
9152 Tile[x][y] == EL_QUICKSAND_EMPTY ||
9153 Tile[x][y] == EL_QUICKSAND_FAST_EMPTY)
9159 else if (IS_PLAYER(x, y))
9160 waiting_for_player = TRUE;
9163 if (newax == ax && neway == ay) // amoeba cannot grow
9165 if (i == 4 && (!waiting_for_player || element == EL_BD_AMOEBA))
9167 Tile[ax][ay] = EL_AMOEBA_DEAD;
9168 TEST_DrawLevelField(ax, ay);
9169 AmoebaCnt[AmoebaNr[ax][ay]]--;
9171 if (AmoebaCnt[AmoebaNr[ax][ay]] <= 0) // amoeba is completely dead
9173 if (element == EL_AMOEBA_FULL)
9174 AmoebaToDiamond(ax, ay);
9175 else if (element == EL_BD_AMOEBA)
9176 AmoebaToDiamondBD(ax, ay, level.amoeba_content);
9181 else if (element == EL_AMOEBA_FULL || element == EL_BD_AMOEBA)
9183 // amoeba gets larger by growing in some direction
9185 int new_group_nr = AmoebaNr[ax][ay];
9188 if (new_group_nr == 0)
9190 Debug("game:playing:AmoebaReproduce", "newax = %d, neway = %d",
9192 Debug("game:playing:AmoebaReproduce", "This should never happen!");
9198 AmoebaNr[newax][neway] = new_group_nr;
9199 AmoebaCnt[new_group_nr]++;
9200 AmoebaCnt2[new_group_nr]++;
9202 // if amoeba touches other amoeba(s) after growing, unify them
9203 AmoebaMerge(newax, neway);
9205 if (element == EL_BD_AMOEBA && AmoebaCnt2[new_group_nr] >= 200)
9207 AmoebaToDiamondBD(newax, neway, EL_BD_ROCK);
9213 if (!can_drop || neway < ay || !IS_FREE(newax, neway) ||
9214 (neway == lev_fieldy - 1 && newax != ax))
9216 Tile[newax][neway] = EL_AMOEBA_GROWING; // creation of new amoeba
9217 Store[newax][neway] = element;
9219 else if (neway == ay || element == EL_EMC_DRIPPER)
9221 Tile[newax][neway] = EL_AMOEBA_DROP; // drop left/right of amoeba
9223 PlayLevelSoundAction(newax, neway, ACTION_GROWING);
9227 InitMovingField(ax, ay, MV_DOWN); // drop dripping from amoeba
9228 Tile[ax][ay] = EL_AMOEBA_DROPPING;
9229 Store[ax][ay] = EL_AMOEBA_DROP;
9230 ContinueMoving(ax, ay);
9234 TEST_DrawLevelField(newax, neway);
9237 static void Life(int ax, int ay)
9241 int element = Tile[ax][ay];
9242 int graphic = el2img(element);
9243 int *life_parameter = (element == EL_GAME_OF_LIFE ? level.game_of_life :
9245 boolean changed = FALSE;
9247 if (IS_ANIMATED(graphic))
9248 DrawLevelGraphicAnimationIfNeeded(ax, ay, graphic);
9253 if (!MovDelay[ax][ay]) // start new "game of life" cycle
9254 MovDelay[ax][ay] = life_time;
9256 if (MovDelay[ax][ay]) // wait some time before next cycle
9259 if (MovDelay[ax][ay])
9263 for (y1 = -1; y1 < 2; y1++) for (x1 = -1; x1 < 2; x1++)
9265 int xx = ax+x1, yy = ay+y1;
9266 int old_element = Tile[xx][yy];
9267 int num_neighbours = 0;
9269 if (!IN_LEV_FIELD(xx, yy))
9272 for (y2 = -1; y2 < 2; y2++) for (x2 = -1; x2 < 2; x2++)
9274 int x = xx+x2, y = yy+y2;
9276 if (!IN_LEV_FIELD(x, y) || (x == xx && y == yy))
9279 boolean is_player_cell = (element == EL_GAME_OF_LIFE && IS_PLAYER(x, y));
9280 boolean is_neighbour = FALSE;
9282 if (level.use_life_bugs)
9284 (((Tile[x][y] == element || is_player_cell) && !Stop[x][y]) ||
9285 (IS_FREE(x, y) && Stop[x][y]));
9288 (Last[x][y] == element || is_player_cell);
9294 boolean is_free = FALSE;
9296 if (level.use_life_bugs)
9297 is_free = (IS_FREE(xx, yy));
9299 is_free = (IS_FREE(xx, yy) && Last[xx][yy] == EL_EMPTY);
9301 if (xx == ax && yy == ay) // field in the middle
9303 if (num_neighbours < life_parameter[0] ||
9304 num_neighbours > life_parameter[1])
9306 Tile[xx][yy] = EL_EMPTY;
9307 if (Tile[xx][yy] != old_element)
9308 TEST_DrawLevelField(xx, yy);
9309 Stop[xx][yy] = TRUE;
9313 else if (is_free || CAN_GROW_INTO(Tile[xx][yy]))
9314 { // free border field
9315 if (num_neighbours >= life_parameter[2] &&
9316 num_neighbours <= life_parameter[3])
9318 Tile[xx][yy] = element;
9319 MovDelay[xx][yy] = (element == EL_GAME_OF_LIFE ? 0 : life_time-1);
9320 if (Tile[xx][yy] != old_element)
9321 TEST_DrawLevelField(xx, yy);
9322 Stop[xx][yy] = TRUE;
9329 PlayLevelSound(ax, ay, element == EL_BIOMAZE ? SND_BIOMAZE_GROWING :
9330 SND_GAME_OF_LIFE_GROWING);
9333 static void InitRobotWheel(int x, int y)
9335 ChangeDelay[x][y] = level.time_wheel * FRAMES_PER_SECOND;
9338 static void RunRobotWheel(int x, int y)
9340 PlayLevelSound(x, y, SND_ROBOT_WHEEL_ACTIVE);
9343 static void StopRobotWheel(int x, int y)
9345 if (game.robot_wheel_x == x &&
9346 game.robot_wheel_y == y)
9348 game.robot_wheel_x = -1;
9349 game.robot_wheel_y = -1;
9350 game.robot_wheel_active = FALSE;
9354 static void InitTimegateWheel(int x, int y)
9356 ChangeDelay[x][y] = level.time_timegate * FRAMES_PER_SECOND;
9359 static void RunTimegateWheel(int x, int y)
9361 PlayLevelSound(x, y, SND_CLASS_TIMEGATE_SWITCH_ACTIVE);
9364 static void InitMagicBallDelay(int x, int y)
9366 ChangeDelay[x][y] = (level.ball_time + 1) * 8 + 1;
9369 static void ActivateMagicBall(int bx, int by)
9373 if (level.ball_random)
9375 int pos_border = RND(8); // select one of the eight border elements
9376 int pos_content = (pos_border > 3 ? pos_border + 1 : pos_border);
9377 int xx = pos_content % 3;
9378 int yy = pos_content / 3;
9383 if (IN_LEV_FIELD(x, y) && Tile[x][y] == EL_EMPTY)
9384 CreateField(x, y, level.ball_content[game.ball_content_nr].e[xx][yy]);
9388 for (y = by - 1; y <= by + 1; y++) for (x = bx - 1; x <= bx + 1; x++)
9390 int xx = x - bx + 1;
9391 int yy = y - by + 1;
9393 if (IN_LEV_FIELD(x, y) && Tile[x][y] == EL_EMPTY)
9394 CreateField(x, y, level.ball_content[game.ball_content_nr].e[xx][yy]);
9398 game.ball_content_nr = (game.ball_content_nr + 1) % level.num_ball_contents;
9401 static void CheckExit(int x, int y)
9403 if (game.gems_still_needed > 0 ||
9404 game.sokoban_fields_still_needed > 0 ||
9405 game.sokoban_objects_still_needed > 0 ||
9406 game.lights_still_needed > 0)
9408 int element = Tile[x][y];
9409 int graphic = el2img(element);
9411 if (IS_ANIMATED(graphic))
9412 DrawLevelGraphicAnimationIfNeeded(x, y, graphic);
9417 // do not re-open exit door closed after last player
9418 if (game.all_players_gone)
9421 Tile[x][y] = EL_EXIT_OPENING;
9423 PlayLevelSoundNearest(x, y, SND_CLASS_EXIT_OPENING);
9426 static void CheckExitEM(int x, int y)
9428 if (game.gems_still_needed > 0 ||
9429 game.sokoban_fields_still_needed > 0 ||
9430 game.sokoban_objects_still_needed > 0 ||
9431 game.lights_still_needed > 0)
9433 int element = Tile[x][y];
9434 int graphic = el2img(element);
9436 if (IS_ANIMATED(graphic))
9437 DrawLevelGraphicAnimationIfNeeded(x, y, graphic);
9442 // do not re-open exit door closed after last player
9443 if (game.all_players_gone)
9446 Tile[x][y] = EL_EM_EXIT_OPENING;
9448 PlayLevelSoundNearest(x, y, SND_CLASS_EM_EXIT_OPENING);
9451 static void CheckExitSteel(int x, int y)
9453 if (game.gems_still_needed > 0 ||
9454 game.sokoban_fields_still_needed > 0 ||
9455 game.sokoban_objects_still_needed > 0 ||
9456 game.lights_still_needed > 0)
9458 int element = Tile[x][y];
9459 int graphic = el2img(element);
9461 if (IS_ANIMATED(graphic))
9462 DrawLevelGraphicAnimationIfNeeded(x, y, graphic);
9467 // do not re-open exit door closed after last player
9468 if (game.all_players_gone)
9471 Tile[x][y] = EL_STEEL_EXIT_OPENING;
9473 PlayLevelSoundNearest(x, y, SND_CLASS_STEEL_EXIT_OPENING);
9476 static void CheckExitSteelEM(int x, int y)
9478 if (game.gems_still_needed > 0 ||
9479 game.sokoban_fields_still_needed > 0 ||
9480 game.sokoban_objects_still_needed > 0 ||
9481 game.lights_still_needed > 0)
9483 int element = Tile[x][y];
9484 int graphic = el2img(element);
9486 if (IS_ANIMATED(graphic))
9487 DrawLevelGraphicAnimationIfNeeded(x, y, graphic);
9492 // do not re-open exit door closed after last player
9493 if (game.all_players_gone)
9496 Tile[x][y] = EL_EM_STEEL_EXIT_OPENING;
9498 PlayLevelSoundNearest(x, y, SND_CLASS_EM_STEEL_EXIT_OPENING);
9501 static void CheckExitSP(int x, int y)
9503 if (game.gems_still_needed > 0)
9505 int element = Tile[x][y];
9506 int graphic = el2img(element);
9508 if (IS_ANIMATED(graphic))
9509 DrawLevelGraphicAnimationIfNeeded(x, y, graphic);
9514 // do not re-open exit door closed after last player
9515 if (game.all_players_gone)
9518 Tile[x][y] = EL_SP_EXIT_OPENING;
9520 PlayLevelSoundNearest(x, y, SND_CLASS_SP_EXIT_OPENING);
9523 static void CloseAllOpenTimegates(void)
9527 SCAN_PLAYFIELD(x, y)
9529 int element = Tile[x][y];
9531 if (element == EL_TIMEGATE_OPEN || element == EL_TIMEGATE_OPENING)
9533 Tile[x][y] = EL_TIMEGATE_CLOSING;
9535 PlayLevelSoundAction(x, y, ACTION_CLOSING);
9540 static void DrawTwinkleOnField(int x, int y)
9542 if (!IN_SCR_FIELD(SCREENX(x), SCREENY(y)) || IS_MOVING(x, y))
9545 if (Tile[x][y] == EL_BD_DIAMOND)
9548 if (MovDelay[x][y] == 0) // next animation frame
9549 MovDelay[x][y] = 11 * !GetSimpleRandom(500);
9551 if (MovDelay[x][y] != 0) // wait some time before next frame
9555 DrawLevelElementAnimation(x, y, Tile[x][y]);
9557 if (MovDelay[x][y] != 0)
9559 int frame = getGraphicAnimationFrame(IMG_TWINKLE_WHITE,
9560 10 - MovDelay[x][y]);
9562 DrawGraphicThruMask(SCREENX(x), SCREENY(y), IMG_TWINKLE_WHITE, frame);
9567 static void MauerWaechst(int x, int y)
9571 if (!MovDelay[x][y]) // next animation frame
9572 MovDelay[x][y] = 3 * delay;
9574 if (MovDelay[x][y]) // wait some time before next frame
9578 if (IN_SCR_FIELD(SCREENX(x), SCREENY(y)))
9580 int graphic = el_dir2img(Tile[x][y], GfxDir[x][y]);
9581 int frame = getGraphicAnimationFrame(graphic, 17 - MovDelay[x][y]);
9583 DrawGraphic(SCREENX(x), SCREENY(y), graphic, frame);
9586 if (!MovDelay[x][y])
9588 if (MovDir[x][y] == MV_LEFT)
9590 if (IN_LEV_FIELD(x - 1, y) && IS_WALL(Tile[x - 1][y]))
9591 TEST_DrawLevelField(x - 1, y);
9593 else if (MovDir[x][y] == MV_RIGHT)
9595 if (IN_LEV_FIELD(x + 1, y) && IS_WALL(Tile[x + 1][y]))
9596 TEST_DrawLevelField(x + 1, y);
9598 else if (MovDir[x][y] == MV_UP)
9600 if (IN_LEV_FIELD(x, y - 1) && IS_WALL(Tile[x][y - 1]))
9601 TEST_DrawLevelField(x, y - 1);
9605 if (IN_LEV_FIELD(x, y + 1) && IS_WALL(Tile[x][y + 1]))
9606 TEST_DrawLevelField(x, y + 1);
9609 Tile[x][y] = Store[x][y];
9611 GfxDir[x][y] = MovDir[x][y] = MV_NONE;
9612 TEST_DrawLevelField(x, y);
9617 static void MauerAbleger(int ax, int ay)
9619 int element = Tile[ax][ay];
9620 int graphic = el2img(element);
9621 boolean oben_frei = FALSE, unten_frei = FALSE;
9622 boolean links_frei = FALSE, rechts_frei = FALSE;
9623 boolean oben_massiv = FALSE, unten_massiv = FALSE;
9624 boolean links_massiv = FALSE, rechts_massiv = FALSE;
9625 boolean new_wall = FALSE;
9627 if (IS_ANIMATED(graphic))
9628 DrawLevelGraphicAnimationIfNeeded(ax, ay, graphic);
9630 if (!MovDelay[ax][ay]) // start building new wall
9631 MovDelay[ax][ay] = 6;
9633 if (MovDelay[ax][ay]) // wait some time before building new wall
9636 if (MovDelay[ax][ay])
9640 if (IN_LEV_FIELD(ax, ay-1) && IS_FREE(ax, ay-1))
9642 if (IN_LEV_FIELD(ax, ay+1) && IS_FREE(ax, ay+1))
9644 if (IN_LEV_FIELD(ax-1, ay) && IS_FREE(ax-1, ay))
9646 if (IN_LEV_FIELD(ax+1, ay) && IS_FREE(ax+1, ay))
9649 if (element == EL_EXPANDABLE_WALL_VERTICAL ||
9650 element == EL_EXPANDABLE_WALL_ANY)
9654 Tile[ax][ay-1] = EL_EXPANDABLE_WALL_GROWING;
9655 Store[ax][ay-1] = element;
9656 GfxDir[ax][ay-1] = MovDir[ax][ay-1] = MV_UP;
9657 if (IN_SCR_FIELD(SCREENX(ax), SCREENY(ay-1)))
9658 DrawGraphic(SCREENX(ax), SCREENY(ay - 1),
9659 IMG_EXPANDABLE_WALL_GROWING_UP, 0);
9664 Tile[ax][ay+1] = EL_EXPANDABLE_WALL_GROWING;
9665 Store[ax][ay+1] = element;
9666 GfxDir[ax][ay+1] = MovDir[ax][ay+1] = MV_DOWN;
9667 if (IN_SCR_FIELD(SCREENX(ax), SCREENY(ay+1)))
9668 DrawGraphic(SCREENX(ax), SCREENY(ay + 1),
9669 IMG_EXPANDABLE_WALL_GROWING_DOWN, 0);
9674 if (element == EL_EXPANDABLE_WALL_HORIZONTAL ||
9675 element == EL_EXPANDABLE_WALL_ANY ||
9676 element == EL_EXPANDABLE_WALL ||
9677 element == EL_BD_EXPANDABLE_WALL)
9681 Tile[ax-1][ay] = EL_EXPANDABLE_WALL_GROWING;
9682 Store[ax-1][ay] = element;
9683 GfxDir[ax-1][ay] = MovDir[ax-1][ay] = MV_LEFT;
9684 if (IN_SCR_FIELD(SCREENX(ax-1), SCREENY(ay)))
9685 DrawGraphic(SCREENX(ax - 1), SCREENY(ay),
9686 IMG_EXPANDABLE_WALL_GROWING_LEFT, 0);
9692 Tile[ax+1][ay] = EL_EXPANDABLE_WALL_GROWING;
9693 Store[ax+1][ay] = element;
9694 GfxDir[ax+1][ay] = MovDir[ax+1][ay] = MV_RIGHT;
9695 if (IN_SCR_FIELD(SCREENX(ax+1), SCREENY(ay)))
9696 DrawGraphic(SCREENX(ax + 1), SCREENY(ay),
9697 IMG_EXPANDABLE_WALL_GROWING_RIGHT, 0);
9702 if (element == EL_EXPANDABLE_WALL && (links_frei || rechts_frei))
9703 TEST_DrawLevelField(ax, ay);
9705 if (!IN_LEV_FIELD(ax, ay-1) || IS_WALL(Tile[ax][ay-1]))
9707 if (!IN_LEV_FIELD(ax, ay+1) || IS_WALL(Tile[ax][ay+1]))
9708 unten_massiv = TRUE;
9709 if (!IN_LEV_FIELD(ax-1, ay) || IS_WALL(Tile[ax-1][ay]))
9710 links_massiv = TRUE;
9711 if (!IN_LEV_FIELD(ax+1, ay) || IS_WALL(Tile[ax+1][ay]))
9712 rechts_massiv = TRUE;
9714 if (((oben_massiv && unten_massiv) ||
9715 element == EL_EXPANDABLE_WALL_HORIZONTAL ||
9716 element == EL_EXPANDABLE_WALL) &&
9717 ((links_massiv && rechts_massiv) ||
9718 element == EL_EXPANDABLE_WALL_VERTICAL))
9719 Tile[ax][ay] = EL_WALL;
9722 PlayLevelSoundAction(ax, ay, ACTION_GROWING);
9725 static void MauerAblegerStahl(int ax, int ay)
9727 int element = Tile[ax][ay];
9728 int graphic = el2img(element);
9729 boolean oben_frei = FALSE, unten_frei = FALSE;
9730 boolean links_frei = FALSE, rechts_frei = FALSE;
9731 boolean oben_massiv = FALSE, unten_massiv = FALSE;
9732 boolean links_massiv = FALSE, rechts_massiv = FALSE;
9733 boolean new_wall = FALSE;
9735 if (IS_ANIMATED(graphic))
9736 DrawLevelGraphicAnimationIfNeeded(ax, ay, graphic);
9738 if (!MovDelay[ax][ay]) // start building new wall
9739 MovDelay[ax][ay] = 6;
9741 if (MovDelay[ax][ay]) // wait some time before building new wall
9744 if (MovDelay[ax][ay])
9748 if (IN_LEV_FIELD(ax, ay-1) && IS_FREE(ax, ay-1))
9750 if (IN_LEV_FIELD(ax, ay+1) && IS_FREE(ax, ay+1))
9752 if (IN_LEV_FIELD(ax-1, ay) && IS_FREE(ax-1, ay))
9754 if (IN_LEV_FIELD(ax+1, ay) && IS_FREE(ax+1, ay))
9757 if (element == EL_EXPANDABLE_STEELWALL_VERTICAL ||
9758 element == EL_EXPANDABLE_STEELWALL_ANY)
9762 Tile[ax][ay-1] = EL_EXPANDABLE_STEELWALL_GROWING;
9763 Store[ax][ay-1] = element;
9764 GfxDir[ax][ay-1] = MovDir[ax][ay-1] = MV_UP;
9765 if (IN_SCR_FIELD(SCREENX(ax), SCREENY(ay-1)))
9766 DrawGraphic(SCREENX(ax), SCREENY(ay - 1),
9767 IMG_EXPANDABLE_STEELWALL_GROWING_UP, 0);
9772 Tile[ax][ay+1] = EL_EXPANDABLE_STEELWALL_GROWING;
9773 Store[ax][ay+1] = element;
9774 GfxDir[ax][ay+1] = MovDir[ax][ay+1] = MV_DOWN;
9775 if (IN_SCR_FIELD(SCREENX(ax), SCREENY(ay+1)))
9776 DrawGraphic(SCREENX(ax), SCREENY(ay + 1),
9777 IMG_EXPANDABLE_STEELWALL_GROWING_DOWN, 0);
9782 if (element == EL_EXPANDABLE_STEELWALL_HORIZONTAL ||
9783 element == EL_EXPANDABLE_STEELWALL_ANY)
9787 Tile[ax-1][ay] = EL_EXPANDABLE_STEELWALL_GROWING;
9788 Store[ax-1][ay] = element;
9789 GfxDir[ax-1][ay] = MovDir[ax-1][ay] = MV_LEFT;
9790 if (IN_SCR_FIELD(SCREENX(ax-1), SCREENY(ay)))
9791 DrawGraphic(SCREENX(ax - 1), SCREENY(ay),
9792 IMG_EXPANDABLE_STEELWALL_GROWING_LEFT, 0);
9798 Tile[ax+1][ay] = EL_EXPANDABLE_STEELWALL_GROWING;
9799 Store[ax+1][ay] = element;
9800 GfxDir[ax+1][ay] = MovDir[ax+1][ay] = MV_RIGHT;
9801 if (IN_SCR_FIELD(SCREENX(ax+1), SCREENY(ay)))
9802 DrawGraphic(SCREENX(ax + 1), SCREENY(ay),
9803 IMG_EXPANDABLE_STEELWALL_GROWING_RIGHT, 0);
9808 if (!IN_LEV_FIELD(ax, ay-1) || IS_WALL(Tile[ax][ay-1]))
9810 if (!IN_LEV_FIELD(ax, ay+1) || IS_WALL(Tile[ax][ay+1]))
9811 unten_massiv = TRUE;
9812 if (!IN_LEV_FIELD(ax-1, ay) || IS_WALL(Tile[ax-1][ay]))
9813 links_massiv = TRUE;
9814 if (!IN_LEV_FIELD(ax+1, ay) || IS_WALL(Tile[ax+1][ay]))
9815 rechts_massiv = TRUE;
9817 if (((oben_massiv && unten_massiv) ||
9818 element == EL_EXPANDABLE_STEELWALL_HORIZONTAL) &&
9819 ((links_massiv && rechts_massiv) ||
9820 element == EL_EXPANDABLE_STEELWALL_VERTICAL))
9821 Tile[ax][ay] = EL_STEELWALL;
9824 PlayLevelSoundAction(ax, ay, ACTION_GROWING);
9827 static void CheckForDragon(int x, int y)
9830 boolean dragon_found = FALSE;
9831 static int xy[4][2] =
9839 for (i = 0; i < NUM_DIRECTIONS; i++)
9841 for (j = 0; j < 4; j++)
9843 int xx = x + j * xy[i][0], yy = y + j * xy[i][1];
9845 if (IN_LEV_FIELD(xx, yy) &&
9846 (Tile[xx][yy] == EL_FLAMES || Tile[xx][yy] == EL_DRAGON))
9848 if (Tile[xx][yy] == EL_DRAGON)
9849 dragon_found = TRUE;
9858 for (i = 0; i < NUM_DIRECTIONS; i++)
9860 for (j = 0; j < 3; j++)
9862 int xx = x + j * xy[i][0], yy = y + j * xy[i][1];
9864 if (IN_LEV_FIELD(xx, yy) && Tile[xx][yy] == EL_FLAMES)
9866 Tile[xx][yy] = EL_EMPTY;
9867 TEST_DrawLevelField(xx, yy);
9876 static void InitBuggyBase(int x, int y)
9878 int element = Tile[x][y];
9879 int activating_delay = FRAMES_PER_SECOND / 4;
9882 (element == EL_SP_BUGGY_BASE ?
9883 2 * FRAMES_PER_SECOND + RND(5 * FRAMES_PER_SECOND) - activating_delay :
9884 element == EL_SP_BUGGY_BASE_ACTIVATING ?
9886 element == EL_SP_BUGGY_BASE_ACTIVE ?
9887 1 * FRAMES_PER_SECOND + RND(1 * FRAMES_PER_SECOND) : 1);
9890 static void WarnBuggyBase(int x, int y)
9893 static int xy[4][2] =
9901 for (i = 0; i < NUM_DIRECTIONS; i++)
9903 int xx = x + xy[i][0];
9904 int yy = y + xy[i][1];
9906 if (IN_LEV_FIELD(xx, yy) && IS_PLAYER(xx, yy))
9908 PlayLevelSound(x, y, SND_SP_BUGGY_BASE_ACTIVE);
9915 static void InitTrap(int x, int y)
9917 ChangeDelay[x][y] = 2 * FRAMES_PER_SECOND + RND(5 * FRAMES_PER_SECOND);
9920 static void ActivateTrap(int x, int y)
9922 PlayLevelSound(x, y, SND_TRAP_ACTIVATING);
9925 static void ChangeActiveTrap(int x, int y)
9927 int graphic = IMG_TRAP_ACTIVE;
9929 // if new animation frame was drawn, correct crumbled sand border
9930 if (IS_NEW_FRAME(GfxFrame[x][y], graphic))
9931 TEST_DrawLevelFieldCrumbled(x, y);
9934 static int getSpecialActionElement(int element, int number, int base_element)
9936 return (element != EL_EMPTY ? element :
9937 number != -1 ? base_element + number - 1 :
9941 static int getModifiedActionNumber(int value_old, int operator, int operand,
9942 int value_min, int value_max)
9944 int value_new = (operator == CA_MODE_SET ? operand :
9945 operator == CA_MODE_ADD ? value_old + operand :
9946 operator == CA_MODE_SUBTRACT ? value_old - operand :
9947 operator == CA_MODE_MULTIPLY ? value_old * operand :
9948 operator == CA_MODE_DIVIDE ? value_old / MAX(1, operand) :
9949 operator == CA_MODE_MODULO ? value_old % MAX(1, operand) :
9952 return (value_new < value_min ? value_min :
9953 value_new > value_max ? value_max :
9957 static void ExecuteCustomElementAction(int x, int y, int element, int page)
9959 struct ElementInfo *ei = &element_info[element];
9960 struct ElementChangeInfo *change = &ei->change_page[page];
9961 int target_element = change->target_element;
9962 int action_type = change->action_type;
9963 int action_mode = change->action_mode;
9964 int action_arg = change->action_arg;
9965 int action_element = change->action_element;
9968 if (!change->has_action)
9971 // ---------- determine action paramater values -----------------------------
9973 int level_time_value =
9974 (level.time > 0 ? TimeLeft :
9977 int action_arg_element_raw =
9978 (action_arg == CA_ARG_PLAYER_TRIGGER ? change->actual_trigger_player :
9979 action_arg == CA_ARG_ELEMENT_TRIGGER ? change->actual_trigger_element :
9980 action_arg == CA_ARG_ELEMENT_TARGET ? change->target_element :
9981 action_arg == CA_ARG_ELEMENT_ACTION ? change->action_element :
9982 action_arg == CA_ARG_INVENTORY_RM_TRIGGER ? change->actual_trigger_element:
9983 action_arg == CA_ARG_INVENTORY_RM_TARGET ? change->target_element :
9984 action_arg == CA_ARG_INVENTORY_RM_ACTION ? change->action_element :
9986 int action_arg_element = GetElementFromGroupElement(action_arg_element_raw);
9988 int action_arg_direction =
9989 (action_arg >= CA_ARG_DIRECTION_LEFT &&
9990 action_arg <= CA_ARG_DIRECTION_DOWN ? action_arg - CA_ARG_DIRECTION :
9991 action_arg == CA_ARG_DIRECTION_TRIGGER ?
9992 change->actual_trigger_side :
9993 action_arg == CA_ARG_DIRECTION_TRIGGER_BACK ?
9994 MV_DIR_OPPOSITE(change->actual_trigger_side) :
9997 int action_arg_number_min =
9998 (action_type == CA_SET_PLAYER_SPEED ? STEPSIZE_NOT_MOVING :
10001 int action_arg_number_max =
10002 (action_type == CA_SET_PLAYER_SPEED ? STEPSIZE_EVEN_FASTER :
10003 action_type == CA_SET_LEVEL_GEMS ? 999 :
10004 action_type == CA_SET_LEVEL_TIME ? 9999 :
10005 action_type == CA_SET_LEVEL_SCORE ? 99999 :
10006 action_type == CA_SET_CE_VALUE ? 9999 :
10007 action_type == CA_SET_CE_SCORE ? 9999 :
10010 int action_arg_number_reset =
10011 (action_type == CA_SET_PLAYER_SPEED ? level.initial_player_stepsize[0] :
10012 action_type == CA_SET_LEVEL_GEMS ? level.gems_needed :
10013 action_type == CA_SET_LEVEL_TIME ? level.time :
10014 action_type == CA_SET_LEVEL_SCORE ? 0 :
10015 action_type == CA_SET_CE_VALUE ? GET_NEW_CE_VALUE(element) :
10016 action_type == CA_SET_CE_SCORE ? 0 :
10019 int action_arg_number =
10020 (action_arg <= CA_ARG_MAX ? action_arg :
10021 action_arg >= CA_ARG_SPEED_NOT_MOVING &&
10022 action_arg <= CA_ARG_SPEED_EVEN_FASTER ? (action_arg - CA_ARG_SPEED) :
10023 action_arg == CA_ARG_SPEED_RESET ? action_arg_number_reset :
10024 action_arg == CA_ARG_NUMBER_MIN ? action_arg_number_min :
10025 action_arg == CA_ARG_NUMBER_MAX ? action_arg_number_max :
10026 action_arg == CA_ARG_NUMBER_RESET ? action_arg_number_reset :
10027 action_arg == CA_ARG_NUMBER_CE_VALUE ? CustomValue[x][y] :
10028 action_arg == CA_ARG_NUMBER_CE_SCORE ? ei->collect_score :
10029 action_arg == CA_ARG_NUMBER_CE_DELAY ? GET_CE_DELAY_VALUE(change) :
10030 action_arg == CA_ARG_NUMBER_LEVEL_TIME ? level_time_value :
10031 action_arg == CA_ARG_NUMBER_LEVEL_GEMS ? game.gems_still_needed :
10032 action_arg == CA_ARG_NUMBER_LEVEL_SCORE ? game.score :
10033 action_arg == CA_ARG_ELEMENT_CV_TARGET ? GET_NEW_CE_VALUE(target_element):
10034 action_arg == CA_ARG_ELEMENT_CV_TRIGGER ? change->actual_trigger_ce_value:
10035 action_arg == CA_ARG_ELEMENT_CV_ACTION ? GET_NEW_CE_VALUE(action_element):
10036 action_arg == CA_ARG_ELEMENT_CS_TARGET ? GET_CE_SCORE(target_element) :
10037 action_arg == CA_ARG_ELEMENT_CS_TRIGGER ? change->actual_trigger_ce_score:
10038 action_arg == CA_ARG_ELEMENT_CS_ACTION ? GET_CE_SCORE(action_element) :
10039 action_arg == CA_ARG_ELEMENT_NR_TARGET ? change->target_element :
10040 action_arg == CA_ARG_ELEMENT_NR_TRIGGER ? change->actual_trigger_element :
10041 action_arg == CA_ARG_ELEMENT_NR_ACTION ? change->action_element :
10044 int action_arg_number_old =
10045 (action_type == CA_SET_LEVEL_GEMS ? game.gems_still_needed :
10046 action_type == CA_SET_LEVEL_TIME ? TimeLeft :
10047 action_type == CA_SET_LEVEL_SCORE ? game.score :
10048 action_type == CA_SET_CE_VALUE ? CustomValue[x][y] :
10049 action_type == CA_SET_CE_SCORE ? ei->collect_score :
10052 int action_arg_number_new =
10053 getModifiedActionNumber(action_arg_number_old,
10054 action_mode, action_arg_number,
10055 action_arg_number_min, action_arg_number_max);
10057 int trigger_player_bits =
10058 (change->actual_trigger_player_bits != CH_PLAYER_NONE ?
10059 change->actual_trigger_player_bits : change->trigger_player);
10061 int action_arg_player_bits =
10062 (action_arg >= CA_ARG_PLAYER_1 &&
10063 action_arg <= CA_ARG_PLAYER_4 ? action_arg - CA_ARG_PLAYER :
10064 action_arg == CA_ARG_PLAYER_TRIGGER ? trigger_player_bits :
10065 action_arg == CA_ARG_PLAYER_ACTION ? 1 << GET_PLAYER_NR(action_element) :
10068 // ---------- execute action -----------------------------------------------
10070 switch (action_type)
10077 // ---------- level actions ----------------------------------------------
10079 case CA_RESTART_LEVEL:
10081 game.restart_level = TRUE;
10086 case CA_SHOW_ENVELOPE:
10088 int element = getSpecialActionElement(action_arg_element,
10089 action_arg_number, EL_ENVELOPE_1);
10091 if (IS_ENVELOPE(element))
10092 local_player->show_envelope = element;
10097 case CA_SET_LEVEL_TIME:
10099 if (level.time > 0) // only modify limited time value
10101 TimeLeft = action_arg_number_new;
10103 game_panel_controls[GAME_PANEL_TIME].value = TimeLeft;
10105 DisplayGameControlValues();
10107 if (!TimeLeft && setup.time_limit)
10108 for (i = 0; i < MAX_PLAYERS; i++)
10109 KillPlayer(&stored_player[i]);
10115 case CA_SET_LEVEL_SCORE:
10117 game.score = action_arg_number_new;
10119 game_panel_controls[GAME_PANEL_SCORE].value = game.score;
10121 DisplayGameControlValues();
10126 case CA_SET_LEVEL_GEMS:
10128 game.gems_still_needed = action_arg_number_new;
10130 game.snapshot.collected_item = TRUE;
10132 game_panel_controls[GAME_PANEL_GEMS].value = game.gems_still_needed;
10134 DisplayGameControlValues();
10139 case CA_SET_LEVEL_WIND:
10141 game.wind_direction = action_arg_direction;
10146 case CA_SET_LEVEL_RANDOM_SEED:
10148 // ensure that setting a new random seed while playing is predictable
10149 InitRND(action_arg_number_new ? action_arg_number_new : RND(1000000) + 1);
10154 // ---------- player actions ---------------------------------------------
10156 case CA_MOVE_PLAYER:
10157 case CA_MOVE_PLAYER_NEW:
10159 // automatically move to the next field in specified direction
10160 for (i = 0; i < MAX_PLAYERS; i++)
10161 if (trigger_player_bits & (1 << i))
10162 if (action_type == CA_MOVE_PLAYER ||
10163 stored_player[i].MovPos == 0)
10164 stored_player[i].programmed_action = action_arg_direction;
10169 case CA_EXIT_PLAYER:
10171 for (i = 0; i < MAX_PLAYERS; i++)
10172 if (action_arg_player_bits & (1 << i))
10173 ExitPlayer(&stored_player[i]);
10175 if (game.players_still_needed == 0)
10181 case CA_KILL_PLAYER:
10183 for (i = 0; i < MAX_PLAYERS; i++)
10184 if (action_arg_player_bits & (1 << i))
10185 KillPlayer(&stored_player[i]);
10190 case CA_SET_PLAYER_KEYS:
10192 int key_state = (action_mode == CA_MODE_ADD ? TRUE : FALSE);
10193 int element = getSpecialActionElement(action_arg_element,
10194 action_arg_number, EL_KEY_1);
10196 if (IS_KEY(element))
10198 for (i = 0; i < MAX_PLAYERS; i++)
10200 if (trigger_player_bits & (1 << i))
10202 stored_player[i].key[KEY_NR(element)] = key_state;
10204 DrawGameDoorValues();
10212 case CA_SET_PLAYER_SPEED:
10214 for (i = 0; i < MAX_PLAYERS; i++)
10216 if (trigger_player_bits & (1 << i))
10218 int move_stepsize = TILEX / stored_player[i].move_delay_value;
10220 if (action_arg == CA_ARG_SPEED_FASTER &&
10221 stored_player[i].cannot_move)
10223 action_arg_number = STEPSIZE_VERY_SLOW;
10225 else if (action_arg == CA_ARG_SPEED_SLOWER ||
10226 action_arg == CA_ARG_SPEED_FASTER)
10228 action_arg_number = 2;
10229 action_mode = (action_arg == CA_ARG_SPEED_SLOWER ? CA_MODE_DIVIDE :
10232 else if (action_arg == CA_ARG_NUMBER_RESET)
10234 action_arg_number = level.initial_player_stepsize[i];
10238 getModifiedActionNumber(move_stepsize,
10241 action_arg_number_min,
10242 action_arg_number_max);
10244 SetPlayerMoveSpeed(&stored_player[i], move_stepsize, FALSE);
10251 case CA_SET_PLAYER_SHIELD:
10253 for (i = 0; i < MAX_PLAYERS; i++)
10255 if (trigger_player_bits & (1 << i))
10257 if (action_arg == CA_ARG_SHIELD_OFF)
10259 stored_player[i].shield_normal_time_left = 0;
10260 stored_player[i].shield_deadly_time_left = 0;
10262 else if (action_arg == CA_ARG_SHIELD_NORMAL)
10264 stored_player[i].shield_normal_time_left = 999999;
10266 else if (action_arg == CA_ARG_SHIELD_DEADLY)
10268 stored_player[i].shield_normal_time_left = 999999;
10269 stored_player[i].shield_deadly_time_left = 999999;
10277 case CA_SET_PLAYER_GRAVITY:
10279 for (i = 0; i < MAX_PLAYERS; i++)
10281 if (trigger_player_bits & (1 << i))
10283 stored_player[i].gravity =
10284 (action_arg == CA_ARG_GRAVITY_OFF ? FALSE :
10285 action_arg == CA_ARG_GRAVITY_ON ? TRUE :
10286 action_arg == CA_ARG_GRAVITY_TOGGLE ? !stored_player[i].gravity :
10287 stored_player[i].gravity);
10294 case CA_SET_PLAYER_ARTWORK:
10296 for (i = 0; i < MAX_PLAYERS; i++)
10298 if (trigger_player_bits & (1 << i))
10300 int artwork_element = action_arg_element;
10302 if (action_arg == CA_ARG_ELEMENT_RESET)
10304 (level.use_artwork_element[i] ? level.artwork_element[i] :
10305 stored_player[i].element_nr);
10307 if (stored_player[i].artwork_element != artwork_element)
10308 stored_player[i].Frame = 0;
10310 stored_player[i].artwork_element = artwork_element;
10312 SetPlayerWaiting(&stored_player[i], FALSE);
10314 // set number of special actions for bored and sleeping animation
10315 stored_player[i].num_special_action_bored =
10316 get_num_special_action(artwork_element,
10317 ACTION_BORING_1, ACTION_BORING_LAST);
10318 stored_player[i].num_special_action_sleeping =
10319 get_num_special_action(artwork_element,
10320 ACTION_SLEEPING_1, ACTION_SLEEPING_LAST);
10327 case CA_SET_PLAYER_INVENTORY:
10329 for (i = 0; i < MAX_PLAYERS; i++)
10331 struct PlayerInfo *player = &stored_player[i];
10334 if (trigger_player_bits & (1 << i))
10336 int inventory_element = action_arg_element;
10338 if (action_arg == CA_ARG_ELEMENT_TARGET ||
10339 action_arg == CA_ARG_ELEMENT_TRIGGER ||
10340 action_arg == CA_ARG_ELEMENT_ACTION)
10342 int element = inventory_element;
10343 int collect_count = element_info[element].collect_count_initial;
10345 if (!IS_CUSTOM_ELEMENT(element))
10348 if (collect_count == 0)
10349 player->inventory_infinite_element = element;
10351 for (k = 0; k < collect_count; k++)
10352 if (player->inventory_size < MAX_INVENTORY_SIZE)
10353 player->inventory_element[player->inventory_size++] =
10356 else if (action_arg == CA_ARG_INVENTORY_RM_TARGET ||
10357 action_arg == CA_ARG_INVENTORY_RM_TRIGGER ||
10358 action_arg == CA_ARG_INVENTORY_RM_ACTION)
10360 if (player->inventory_infinite_element != EL_UNDEFINED &&
10361 IS_EQUAL_OR_IN_GROUP(player->inventory_infinite_element,
10362 action_arg_element_raw))
10363 player->inventory_infinite_element = EL_UNDEFINED;
10365 for (k = 0, j = 0; j < player->inventory_size; j++)
10367 if (!IS_EQUAL_OR_IN_GROUP(player->inventory_element[j],
10368 action_arg_element_raw))
10369 player->inventory_element[k++] = player->inventory_element[j];
10372 player->inventory_size = k;
10374 else if (action_arg == CA_ARG_INVENTORY_RM_FIRST)
10376 if (player->inventory_size > 0)
10378 for (j = 0; j < player->inventory_size - 1; j++)
10379 player->inventory_element[j] = player->inventory_element[j + 1];
10381 player->inventory_size--;
10384 else if (action_arg == CA_ARG_INVENTORY_RM_LAST)
10386 if (player->inventory_size > 0)
10387 player->inventory_size--;
10389 else if (action_arg == CA_ARG_INVENTORY_RM_ALL)
10391 player->inventory_infinite_element = EL_UNDEFINED;
10392 player->inventory_size = 0;
10394 else if (action_arg == CA_ARG_INVENTORY_RESET)
10396 player->inventory_infinite_element = EL_UNDEFINED;
10397 player->inventory_size = 0;
10399 if (level.use_initial_inventory[i])
10401 for (j = 0; j < level.initial_inventory_size[i]; j++)
10403 int element = level.initial_inventory_content[i][j];
10404 int collect_count = element_info[element].collect_count_initial;
10406 if (!IS_CUSTOM_ELEMENT(element))
10409 if (collect_count == 0)
10410 player->inventory_infinite_element = element;
10412 for (k = 0; k < collect_count; k++)
10413 if (player->inventory_size < MAX_INVENTORY_SIZE)
10414 player->inventory_element[player->inventory_size++] =
10425 // ---------- CE actions -------------------------------------------------
10427 case CA_SET_CE_VALUE:
10429 int last_ce_value = CustomValue[x][y];
10431 CustomValue[x][y] = action_arg_number_new;
10433 if (CustomValue[x][y] != last_ce_value)
10435 CheckElementChange(x, y, element, EL_UNDEFINED, CE_VALUE_CHANGES);
10436 CheckTriggeredElementChange(x, y, element, CE_VALUE_CHANGES_OF_X);
10438 if (CustomValue[x][y] == 0)
10440 // reset change counter (else CE_VALUE_GETS_ZERO would not work)
10441 ChangeCount[x][y] = 0; // allow at least one more change
10443 CheckElementChange(x, y, element, EL_UNDEFINED, CE_VALUE_GETS_ZERO);
10444 CheckTriggeredElementChange(x, y, element, CE_VALUE_GETS_ZERO_OF_X);
10451 case CA_SET_CE_SCORE:
10453 int last_ce_score = ei->collect_score;
10455 ei->collect_score = action_arg_number_new;
10457 if (ei->collect_score != last_ce_score)
10459 CheckElementChange(x, y, element, EL_UNDEFINED, CE_SCORE_CHANGES);
10460 CheckTriggeredElementChange(x, y, element, CE_SCORE_CHANGES_OF_X);
10462 if (ei->collect_score == 0)
10466 // reset change counter (else CE_SCORE_GETS_ZERO would not work)
10467 ChangeCount[x][y] = 0; // allow at least one more change
10469 CheckElementChange(x, y, element, EL_UNDEFINED, CE_SCORE_GETS_ZERO);
10470 CheckTriggeredElementChange(x, y, element, CE_SCORE_GETS_ZERO_OF_X);
10473 This is a very special case that seems to be a mixture between
10474 CheckElementChange() and CheckTriggeredElementChange(): while
10475 the first one only affects single elements that are triggered
10476 directly, the second one affects multiple elements in the playfield
10477 that are triggered indirectly by another element. This is a third
10478 case: Changing the CE score always affects multiple identical CEs,
10479 so every affected CE must be checked, not only the single CE for
10480 which the CE score was changed in the first place (as every instance
10481 of that CE shares the same CE score, and therefore also can change)!
10483 SCAN_PLAYFIELD(xx, yy)
10485 if (Tile[xx][yy] == element)
10486 CheckElementChange(xx, yy, element, EL_UNDEFINED,
10487 CE_SCORE_GETS_ZERO);
10495 case CA_SET_CE_ARTWORK:
10497 int artwork_element = action_arg_element;
10498 boolean reset_frame = FALSE;
10501 if (action_arg == CA_ARG_ELEMENT_RESET)
10502 artwork_element = (ei->use_gfx_element ? ei->gfx_element_initial :
10505 if (ei->gfx_element != artwork_element)
10506 reset_frame = TRUE;
10508 ei->gfx_element = artwork_element;
10510 SCAN_PLAYFIELD(xx, yy)
10512 if (Tile[xx][yy] == element)
10516 ResetGfxAnimation(xx, yy);
10517 ResetRandomAnimationValue(xx, yy);
10520 TEST_DrawLevelField(xx, yy);
10527 // ---------- engine actions ---------------------------------------------
10529 case CA_SET_ENGINE_SCAN_MODE:
10531 InitPlayfieldScanMode(action_arg);
10541 static void CreateFieldExt(int x, int y, int element, boolean is_change)
10543 int old_element = Tile[x][y];
10544 int new_element = GetElementFromGroupElement(element);
10545 int previous_move_direction = MovDir[x][y];
10546 int last_ce_value = CustomValue[x][y];
10547 boolean player_explosion_protected = PLAYER_EXPLOSION_PROTECTED(x, y);
10548 boolean new_element_is_player = ELEM_IS_PLAYER(new_element);
10549 boolean add_player_onto_element = (new_element_is_player &&
10550 new_element != EL_SOKOBAN_FIELD_PLAYER &&
10551 IS_WALKABLE(old_element));
10553 if (!add_player_onto_element)
10555 if (IS_MOVING(x, y) || IS_BLOCKED(x, y))
10556 RemoveMovingField(x, y);
10560 Tile[x][y] = new_element;
10562 if (element_info[new_element].move_direction_initial == MV_START_PREVIOUS)
10563 MovDir[x][y] = previous_move_direction;
10565 if (element_info[new_element].use_last_ce_value)
10566 CustomValue[x][y] = last_ce_value;
10568 InitField_WithBug1(x, y, FALSE);
10570 new_element = Tile[x][y]; // element may have changed
10572 ResetGfxAnimation(x, y);
10573 ResetRandomAnimationValue(x, y);
10575 TEST_DrawLevelField(x, y);
10577 if (GFX_CRUMBLED(new_element))
10578 TEST_DrawLevelFieldCrumbledNeighbours(x, y);
10581 // check if element under the player changes from accessible to unaccessible
10582 // (needed for special case of dropping element which then changes)
10583 // (must be checked after creating new element for walkable group elements)
10584 if (IS_PLAYER(x, y) && !player_explosion_protected &&
10585 IS_ACCESSIBLE(old_element) && !IS_ACCESSIBLE(new_element))
10592 // "ChangeCount" not set yet to allow "entered by player" change one time
10593 if (new_element_is_player)
10594 RelocatePlayer(x, y, new_element);
10597 ChangeCount[x][y]++; // count number of changes in the same frame
10599 TestIfBadThingTouchesPlayer(x, y);
10600 TestIfPlayerTouchesCustomElement(x, y);
10601 TestIfElementTouchesCustomElement(x, y);
10604 static void CreateField(int x, int y, int element)
10606 CreateFieldExt(x, y, element, FALSE);
10609 static void CreateElementFromChange(int x, int y, int element)
10611 element = GET_VALID_RUNTIME_ELEMENT(element);
10613 if (game.engine_version >= VERSION_IDENT(3,2,0,7))
10615 int old_element = Tile[x][y];
10617 // prevent changed element from moving in same engine frame
10618 // unless both old and new element can either fall or move
10619 if ((!CAN_FALL(old_element) || !CAN_FALL(element)) &&
10620 (!CAN_MOVE(old_element) || !CAN_MOVE(element)))
10624 CreateFieldExt(x, y, element, TRUE);
10627 static boolean ChangeElement(int x, int y, int element, int page)
10629 struct ElementInfo *ei = &element_info[element];
10630 struct ElementChangeInfo *change = &ei->change_page[page];
10631 int ce_value = CustomValue[x][y];
10632 int ce_score = ei->collect_score;
10633 int target_element;
10634 int old_element = Tile[x][y];
10636 // always use default change event to prevent running into a loop
10637 if (ChangeEvent[x][y] == -1)
10638 ChangeEvent[x][y] = CE_DELAY;
10640 if (ChangeEvent[x][y] == CE_DELAY)
10642 // reset actual trigger element, trigger player and action element
10643 change->actual_trigger_element = EL_EMPTY;
10644 change->actual_trigger_player = EL_EMPTY;
10645 change->actual_trigger_player_bits = CH_PLAYER_NONE;
10646 change->actual_trigger_side = CH_SIDE_NONE;
10647 change->actual_trigger_ce_value = 0;
10648 change->actual_trigger_ce_score = 0;
10651 // do not change elements more than a specified maximum number of changes
10652 if (ChangeCount[x][y] >= game.max_num_changes_per_frame)
10655 ChangeCount[x][y]++; // count number of changes in the same frame
10657 if (change->explode)
10664 if (change->use_target_content)
10666 boolean complete_replace = TRUE;
10667 boolean can_replace[3][3];
10670 for (yy = 0; yy < 3; yy++) for (xx = 0; xx < 3 ; xx++)
10673 boolean is_walkable;
10674 boolean is_diggable;
10675 boolean is_collectible;
10676 boolean is_removable;
10677 boolean is_destructible;
10678 int ex = x + xx - 1;
10679 int ey = y + yy - 1;
10680 int content_element = change->target_content.e[xx][yy];
10683 can_replace[xx][yy] = TRUE;
10685 if (ex == x && ey == y) // do not check changing element itself
10688 if (content_element == EL_EMPTY_SPACE)
10690 can_replace[xx][yy] = FALSE; // do not replace border with space
10695 if (!IN_LEV_FIELD(ex, ey))
10697 can_replace[xx][yy] = FALSE;
10698 complete_replace = FALSE;
10705 if (IS_MOVING(ex, ey) || IS_BLOCKED(ex, ey))
10706 e = MovingOrBlocked2Element(ex, ey);
10708 is_empty = (IS_FREE(ex, ey) ||
10709 (IS_FREE_OR_PLAYER(ex, ey) && IS_WALKABLE(content_element)));
10711 is_walkable = (is_empty || IS_WALKABLE(e));
10712 is_diggable = (is_empty || IS_DIGGABLE(e));
10713 is_collectible = (is_empty || IS_COLLECTIBLE(e));
10714 is_destructible = (is_empty || !IS_INDESTRUCTIBLE(e));
10715 is_removable = (is_diggable || is_collectible);
10717 can_replace[xx][yy] =
10718 (((change->replace_when == CP_WHEN_EMPTY && is_empty) ||
10719 (change->replace_when == CP_WHEN_WALKABLE && is_walkable) ||
10720 (change->replace_when == CP_WHEN_DIGGABLE && is_diggable) ||
10721 (change->replace_when == CP_WHEN_COLLECTIBLE && is_collectible) ||
10722 (change->replace_when == CP_WHEN_REMOVABLE && is_removable) ||
10723 (change->replace_when == CP_WHEN_DESTRUCTIBLE && is_destructible)) &&
10724 !(IS_PLAYER(ex, ey) && ELEM_IS_PLAYER(content_element)));
10726 if (!can_replace[xx][yy])
10727 complete_replace = FALSE;
10730 if (!change->only_if_complete || complete_replace)
10732 boolean something_has_changed = FALSE;
10734 if (change->only_if_complete && change->use_random_replace &&
10735 RND(100) < change->random_percentage)
10738 for (yy = 0; yy < 3; yy++) for (xx = 0; xx < 3 ; xx++)
10740 int ex = x + xx - 1;
10741 int ey = y + yy - 1;
10742 int content_element;
10744 if (can_replace[xx][yy] && (!change->use_random_replace ||
10745 RND(100) < change->random_percentage))
10747 if (IS_MOVING(ex, ey) || IS_BLOCKED(ex, ey))
10748 RemoveMovingField(ex, ey);
10750 ChangeEvent[ex][ey] = ChangeEvent[x][y];
10752 content_element = change->target_content.e[xx][yy];
10753 target_element = GET_TARGET_ELEMENT(element, content_element, change,
10754 ce_value, ce_score);
10756 CreateElementFromChange(ex, ey, target_element);
10758 something_has_changed = TRUE;
10760 // for symmetry reasons, freeze newly created border elements
10761 if (ex != x || ey != y)
10762 Stop[ex][ey] = TRUE; // no more moving in this frame
10766 if (something_has_changed)
10768 PlayLevelSoundElementAction(x, y, element, ACTION_CHANGING);
10769 PlayLevelSoundElementAction(x, y, element, ACTION_PAGE_1 + page);
10775 target_element = GET_TARGET_ELEMENT(element, change->target_element, change,
10776 ce_value, ce_score);
10778 if (element == EL_DIAGONAL_GROWING ||
10779 element == EL_DIAGONAL_SHRINKING)
10781 target_element = Store[x][y];
10783 Store[x][y] = EL_EMPTY;
10786 CreateElementFromChange(x, y, target_element);
10788 PlayLevelSoundElementAction(x, y, element, ACTION_CHANGING);
10789 PlayLevelSoundElementAction(x, y, element, ACTION_PAGE_1 + page);
10792 // this uses direct change before indirect change
10793 CheckTriggeredElementChangeByPage(x, y, old_element, CE_CHANGE_OF_X, page);
10798 static void HandleElementChange(int x, int y, int page)
10800 int element = MovingOrBlocked2Element(x, y);
10801 struct ElementInfo *ei = &element_info[element];
10802 struct ElementChangeInfo *change = &ei->change_page[page];
10803 boolean handle_action_before_change = FALSE;
10806 if (!CAN_CHANGE_OR_HAS_ACTION(element) &&
10807 !CAN_CHANGE_OR_HAS_ACTION(Back[x][y]))
10809 Debug("game:playing:HandleElementChange", "%d,%d: element = %d ('%s')",
10810 x, y, element, element_info[element].token_name);
10811 Debug("game:playing:HandleElementChange", "This should never happen!");
10815 // this can happen with classic bombs on walkable, changing elements
10816 if (!CAN_CHANGE_OR_HAS_ACTION(element))
10821 if (ChangeDelay[x][y] == 0) // initialize element change
10823 ChangeDelay[x][y] = GET_CHANGE_DELAY(change) + 1;
10825 if (change->can_change)
10827 // !!! not clear why graphic animation should be reset at all here !!!
10828 // !!! UPDATE: but is needed for correct Snake Bite tail animation !!!
10829 // !!! SOLUTION: do not reset if graphics engine set to 4 or above !!!
10832 GRAPHICAL BUG ADDRESSED BY CHECKING GRAPHICS ENGINE VERSION:
10834 When using an animation frame delay of 1 (this only happens with
10835 "sp_zonk.moving.left/right" in the classic graphics), the default
10836 (non-moving) animation shows wrong animation frames (while the
10837 moving animation, like "sp_zonk.moving.left/right", is correct,
10838 so this graphical bug never shows up with the classic graphics).
10839 For an animation with 4 frames, this causes wrong frames 0,0,1,2
10840 be drawn instead of the correct frames 0,1,2,3. This is caused by
10841 "GfxFrame[][]" being reset *twice* (in two successive frames) after
10842 an element change: First when the change delay ("ChangeDelay[][]")
10843 counter has reached zero after decrementing, then a second time in
10844 the next frame (after "GfxFrame[][]" was already incremented) when
10845 "ChangeDelay[][]" is reset to the initial delay value again.
10847 This causes frame 0 to be drawn twice, while the last frame won't
10848 be drawn anymore, resulting in the wrong frame sequence 0,0,1,2.
10850 As some animations may already be cleverly designed around this bug
10851 (at least the "Snake Bite" snake tail animation does this), it cannot
10852 simply be fixed here without breaking such existing animations.
10853 Unfortunately, it cannot easily be detected if a graphics set was
10854 designed "before" or "after" the bug was fixed. As a workaround,
10855 a new graphics set option "game.graphics_engine_version" was added
10856 to be able to specify the game's major release version for which the
10857 graphics set was designed, which can then be used to decide if the
10858 bugfix should be used (version 4 and above) or not (version 3 or
10859 below, or if no version was specified at all, as with old sets).
10861 (The wrong/fixed animation frames can be tested with the test level set
10862 "test_gfxframe" and level "000", which contains a specially prepared
10863 custom element at level position (x/y) == (11/9) which uses the zonk
10864 animation mentioned above. Using "game.graphics_engine_version: 4"
10865 fixes the wrong animation frames, showing the correct frames 0,1,2,3.
10866 This can also be seen from the debug output for this test element.)
10869 // when a custom element is about to change (for example by change delay),
10870 // do not reset graphic animation when the custom element is moving
10871 if (game.graphics_engine_version < 4 &&
10874 ResetGfxAnimation(x, y);
10875 ResetRandomAnimationValue(x, y);
10878 if (change->pre_change_function)
10879 change->pre_change_function(x, y);
10883 ChangeDelay[x][y]--;
10885 if (ChangeDelay[x][y] != 0) // continue element change
10887 if (change->can_change)
10889 int graphic = el_act_dir2img(element, GfxAction[x][y], GfxDir[x][y]);
10891 if (IS_ANIMATED(graphic))
10892 DrawLevelGraphicAnimationIfNeeded(x, y, graphic);
10894 if (change->change_function)
10895 change->change_function(x, y);
10898 else // finish element change
10900 if (ChangePage[x][y] != -1) // remember page from delayed change
10902 page = ChangePage[x][y];
10903 ChangePage[x][y] = -1;
10905 change = &ei->change_page[page];
10908 if (IS_MOVING(x, y)) // never change a running system ;-)
10910 ChangeDelay[x][y] = 1; // try change after next move step
10911 ChangePage[x][y] = page; // remember page to use for change
10916 // special case: set new level random seed before changing element
10917 if (change->has_action && change->action_type == CA_SET_LEVEL_RANDOM_SEED)
10918 handle_action_before_change = TRUE;
10920 if (change->has_action && handle_action_before_change)
10921 ExecuteCustomElementAction(x, y, element, page);
10923 if (change->can_change)
10925 if (ChangeElement(x, y, element, page))
10927 if (change->post_change_function)
10928 change->post_change_function(x, y);
10932 if (change->has_action && !handle_action_before_change)
10933 ExecuteCustomElementAction(x, y, element, page);
10937 static boolean CheckTriggeredElementChangeExt(int trigger_x, int trigger_y,
10938 int trigger_element,
10940 int trigger_player,
10944 boolean change_done_any = FALSE;
10945 int trigger_page_bits = (trigger_page < 0 ? CH_PAGE_ANY : 1 << trigger_page);
10948 if (!(trigger_events[trigger_element][trigger_event]))
10951 RECURSION_LOOP_DETECTION_START(trigger_element, FALSE);
10953 for (i = 0; i < NUM_CUSTOM_ELEMENTS; i++)
10955 int element = EL_CUSTOM_START + i;
10956 boolean change_done = FALSE;
10959 if (!CAN_CHANGE_OR_HAS_ACTION(element) ||
10960 !HAS_ANY_CHANGE_EVENT(element, trigger_event))
10963 for (p = 0; p < element_info[element].num_change_pages; p++)
10965 struct ElementChangeInfo *change = &element_info[element].change_page[p];
10967 if (change->can_change_or_has_action &&
10968 change->has_event[trigger_event] &&
10969 change->trigger_side & trigger_side &&
10970 change->trigger_player & trigger_player &&
10971 change->trigger_page & trigger_page_bits &&
10972 IS_EQUAL_OR_IN_GROUP(trigger_element, change->trigger_element))
10974 change->actual_trigger_element = trigger_element;
10975 change->actual_trigger_player = GET_PLAYER_FROM_BITS(trigger_player);
10976 change->actual_trigger_player_bits = trigger_player;
10977 change->actual_trigger_side = trigger_side;
10978 change->actual_trigger_ce_value = CustomValue[trigger_x][trigger_y];
10979 change->actual_trigger_ce_score = GET_CE_SCORE(trigger_element);
10981 if ((change->can_change && !change_done) || change->has_action)
10985 SCAN_PLAYFIELD(x, y)
10987 if (Tile[x][y] == element)
10989 if (change->can_change && !change_done)
10991 // if element already changed in this frame, not only prevent
10992 // another element change (checked in ChangeElement()), but
10993 // also prevent additional element actions for this element
10995 if (ChangeCount[x][y] >= game.max_num_changes_per_frame &&
10996 !level.use_action_after_change_bug)
10999 ChangeDelay[x][y] = 1;
11000 ChangeEvent[x][y] = trigger_event;
11002 HandleElementChange(x, y, p);
11004 else if (change->has_action)
11006 // if element already changed in this frame, not only prevent
11007 // another element change (checked in ChangeElement()), but
11008 // also prevent additional element actions for this element
11010 if (ChangeCount[x][y] >= game.max_num_changes_per_frame &&
11011 !level.use_action_after_change_bug)
11014 ExecuteCustomElementAction(x, y, element, p);
11015 PlayLevelSoundElementAction(x, y, element, ACTION_PAGE_1 + p);
11020 if (change->can_change)
11022 change_done = TRUE;
11023 change_done_any = TRUE;
11030 RECURSION_LOOP_DETECTION_END();
11032 return change_done_any;
11035 static boolean CheckElementChangeExt(int x, int y,
11037 int trigger_element,
11039 int trigger_player,
11042 boolean change_done = FALSE;
11045 if (!CAN_CHANGE_OR_HAS_ACTION(element) ||
11046 !HAS_ANY_CHANGE_EVENT(element, trigger_event))
11049 if (Tile[x][y] == EL_BLOCKED)
11051 Blocked2Moving(x, y, &x, &y);
11052 element = Tile[x][y];
11055 // check if element has already changed or is about to change after moving
11056 if ((game.engine_version < VERSION_IDENT(3,2,0,7) &&
11057 Tile[x][y] != element) ||
11059 (game.engine_version >= VERSION_IDENT(3,2,0,7) &&
11060 (ChangeCount[x][y] >= game.max_num_changes_per_frame ||
11061 ChangePage[x][y] != -1)))
11064 RECURSION_LOOP_DETECTION_START(trigger_element, FALSE);
11066 for (p = 0; p < element_info[element].num_change_pages; p++)
11068 struct ElementChangeInfo *change = &element_info[element].change_page[p];
11070 /* check trigger element for all events where the element that is checked
11071 for changing interacts with a directly adjacent element -- this is
11072 different to element changes that affect other elements to change on the
11073 whole playfield (which is handeld by CheckTriggeredElementChangeExt()) */
11074 boolean check_trigger_element =
11075 (trigger_event == CE_TOUCHING_X ||
11076 trigger_event == CE_HITTING_X ||
11077 trigger_event == CE_HIT_BY_X ||
11078 trigger_event == CE_DIGGING_X); // this one was forgotten until 3.2.3
11080 if (change->can_change_or_has_action &&
11081 change->has_event[trigger_event] &&
11082 change->trigger_side & trigger_side &&
11083 change->trigger_player & trigger_player &&
11084 (!check_trigger_element ||
11085 IS_EQUAL_OR_IN_GROUP(trigger_element, change->trigger_element)))
11087 change->actual_trigger_element = trigger_element;
11088 change->actual_trigger_player = GET_PLAYER_FROM_BITS(trigger_player);
11089 change->actual_trigger_player_bits = trigger_player;
11090 change->actual_trigger_side = trigger_side;
11091 change->actual_trigger_ce_value = CustomValue[x][y];
11092 change->actual_trigger_ce_score = GET_CE_SCORE(trigger_element);
11094 // special case: trigger element not at (x,y) position for some events
11095 if (check_trigger_element)
11107 { 0, 0 }, { 0, 0 }, { 0, 0 },
11111 int xx = x + move_xy[MV_DIR_OPPOSITE(trigger_side)].dx;
11112 int yy = y + move_xy[MV_DIR_OPPOSITE(trigger_side)].dy;
11114 change->actual_trigger_ce_value = CustomValue[xx][yy];
11115 change->actual_trigger_ce_score = GET_CE_SCORE(trigger_element);
11118 if (change->can_change && !change_done)
11120 ChangeDelay[x][y] = 1;
11121 ChangeEvent[x][y] = trigger_event;
11123 HandleElementChange(x, y, p);
11125 change_done = TRUE;
11127 else if (change->has_action)
11129 ExecuteCustomElementAction(x, y, element, p);
11130 PlayLevelSoundElementAction(x, y, element, ACTION_PAGE_1 + p);
11135 RECURSION_LOOP_DETECTION_END();
11137 return change_done;
11140 static void PlayPlayerSound(struct PlayerInfo *player)
11142 int jx = player->jx, jy = player->jy;
11143 int sound_element = player->artwork_element;
11144 int last_action = player->last_action_waiting;
11145 int action = player->action_waiting;
11147 if (player->is_waiting)
11149 if (action != last_action)
11150 PlayLevelSoundElementAction(jx, jy, sound_element, action);
11152 PlayLevelSoundElementActionIfLoop(jx, jy, sound_element, action);
11156 if (action != last_action)
11157 StopSound(element_info[sound_element].sound[last_action]);
11159 if (last_action == ACTION_SLEEPING)
11160 PlayLevelSoundElementAction(jx, jy, sound_element, ACTION_AWAKENING);
11164 static void PlayAllPlayersSound(void)
11168 for (i = 0; i < MAX_PLAYERS; i++)
11169 if (stored_player[i].active)
11170 PlayPlayerSound(&stored_player[i]);
11173 static void SetPlayerWaiting(struct PlayerInfo *player, boolean is_waiting)
11175 boolean last_waiting = player->is_waiting;
11176 int move_dir = player->MovDir;
11178 player->dir_waiting = move_dir;
11179 player->last_action_waiting = player->action_waiting;
11183 if (!last_waiting) // not waiting -> waiting
11185 player->is_waiting = TRUE;
11187 player->frame_counter_bored =
11189 game.player_boring_delay_fixed +
11190 GetSimpleRandom(game.player_boring_delay_random);
11191 player->frame_counter_sleeping =
11193 game.player_sleeping_delay_fixed +
11194 GetSimpleRandom(game.player_sleeping_delay_random);
11196 InitPlayerGfxAnimation(player, ACTION_WAITING, move_dir);
11199 if (game.player_sleeping_delay_fixed +
11200 game.player_sleeping_delay_random > 0 &&
11201 player->anim_delay_counter == 0 &&
11202 player->post_delay_counter == 0 &&
11203 FrameCounter >= player->frame_counter_sleeping)
11204 player->is_sleeping = TRUE;
11205 else if (game.player_boring_delay_fixed +
11206 game.player_boring_delay_random > 0 &&
11207 FrameCounter >= player->frame_counter_bored)
11208 player->is_bored = TRUE;
11210 player->action_waiting = (player->is_sleeping ? ACTION_SLEEPING :
11211 player->is_bored ? ACTION_BORING :
11214 if (player->is_sleeping && player->use_murphy)
11216 // special case for sleeping Murphy when leaning against non-free tile
11218 if (!IN_LEV_FIELD(player->jx - 1, player->jy) ||
11219 (Tile[player->jx - 1][player->jy] != EL_EMPTY &&
11220 !IS_MOVING(player->jx - 1, player->jy)))
11221 move_dir = MV_LEFT;
11222 else if (!IN_LEV_FIELD(player->jx + 1, player->jy) ||
11223 (Tile[player->jx + 1][player->jy] != EL_EMPTY &&
11224 !IS_MOVING(player->jx + 1, player->jy)))
11225 move_dir = MV_RIGHT;
11227 player->is_sleeping = FALSE;
11229 player->dir_waiting = move_dir;
11232 if (player->is_sleeping)
11234 if (player->num_special_action_sleeping > 0)
11236 if (player->anim_delay_counter == 0 && player->post_delay_counter == 0)
11238 int last_special_action = player->special_action_sleeping;
11239 int num_special_action = player->num_special_action_sleeping;
11240 int special_action =
11241 (last_special_action == ACTION_DEFAULT ? ACTION_SLEEPING_1 :
11242 last_special_action == ACTION_SLEEPING ? ACTION_SLEEPING :
11243 last_special_action < ACTION_SLEEPING_1 + num_special_action - 1 ?
11244 last_special_action + 1 : ACTION_SLEEPING);
11245 int special_graphic =
11246 el_act_dir2img(player->artwork_element, special_action, move_dir);
11248 player->anim_delay_counter =
11249 graphic_info[special_graphic].anim_delay_fixed +
11250 GetSimpleRandom(graphic_info[special_graphic].anim_delay_random);
11251 player->post_delay_counter =
11252 graphic_info[special_graphic].post_delay_fixed +
11253 GetSimpleRandom(graphic_info[special_graphic].post_delay_random);
11255 player->special_action_sleeping = special_action;
11258 if (player->anim_delay_counter > 0)
11260 player->action_waiting = player->special_action_sleeping;
11261 player->anim_delay_counter--;
11263 else if (player->post_delay_counter > 0)
11265 player->post_delay_counter--;
11269 else if (player->is_bored)
11271 if (player->num_special_action_bored > 0)
11273 if (player->anim_delay_counter == 0 && player->post_delay_counter == 0)
11275 int special_action =
11276 ACTION_BORING_1 + GetSimpleRandom(player->num_special_action_bored);
11277 int special_graphic =
11278 el_act_dir2img(player->artwork_element, special_action, move_dir);
11280 player->anim_delay_counter =
11281 graphic_info[special_graphic].anim_delay_fixed +
11282 GetSimpleRandom(graphic_info[special_graphic].anim_delay_random);
11283 player->post_delay_counter =
11284 graphic_info[special_graphic].post_delay_fixed +
11285 GetSimpleRandom(graphic_info[special_graphic].post_delay_random);
11287 player->special_action_bored = special_action;
11290 if (player->anim_delay_counter > 0)
11292 player->action_waiting = player->special_action_bored;
11293 player->anim_delay_counter--;
11295 else if (player->post_delay_counter > 0)
11297 player->post_delay_counter--;
11302 else if (last_waiting) // waiting -> not waiting
11304 player->is_waiting = FALSE;
11305 player->is_bored = FALSE;
11306 player->is_sleeping = FALSE;
11308 player->frame_counter_bored = -1;
11309 player->frame_counter_sleeping = -1;
11311 player->anim_delay_counter = 0;
11312 player->post_delay_counter = 0;
11314 player->dir_waiting = player->MovDir;
11315 player->action_waiting = ACTION_DEFAULT;
11317 player->special_action_bored = ACTION_DEFAULT;
11318 player->special_action_sleeping = ACTION_DEFAULT;
11322 static void CheckSaveEngineSnapshot(struct PlayerInfo *player)
11324 if ((!player->is_moving && player->was_moving) ||
11325 (player->MovPos == 0 && player->was_moving) ||
11326 (player->is_snapping && !player->was_snapping) ||
11327 (player->is_dropping && !player->was_dropping))
11329 if (!CheckSaveEngineSnapshotToList())
11332 player->was_moving = FALSE;
11333 player->was_snapping = TRUE;
11334 player->was_dropping = TRUE;
11338 if (player->is_moving)
11339 player->was_moving = TRUE;
11341 if (!player->is_snapping)
11342 player->was_snapping = FALSE;
11344 if (!player->is_dropping)
11345 player->was_dropping = FALSE;
11348 static struct MouseActionInfo mouse_action_last = { 0 };
11349 struct MouseActionInfo mouse_action = player->effective_mouse_action;
11350 boolean new_released = (!mouse_action.button && mouse_action_last.button);
11353 CheckSaveEngineSnapshotToList();
11355 mouse_action_last = mouse_action;
11358 static void CheckSingleStepMode(struct PlayerInfo *player)
11360 if (tape.single_step && tape.recording && !tape.pausing)
11362 // as it is called "single step mode", just return to pause mode when the
11363 // player stopped moving after one tile (or never starts moving at all)
11364 // (reverse logic needed here in case single step mode used in team mode)
11365 if (player->is_moving ||
11366 player->is_pushing ||
11367 player->is_dropping_pressed ||
11368 player->effective_mouse_action.button)
11369 game.enter_single_step_mode = FALSE;
11372 CheckSaveEngineSnapshot(player);
11375 static byte PlayerActions(struct PlayerInfo *player, byte player_action)
11377 int left = player_action & JOY_LEFT;
11378 int right = player_action & JOY_RIGHT;
11379 int up = player_action & JOY_UP;
11380 int down = player_action & JOY_DOWN;
11381 int button1 = player_action & JOY_BUTTON_1;
11382 int button2 = player_action & JOY_BUTTON_2;
11383 int dx = (left ? -1 : right ? 1 : 0);
11384 int dy = (up ? -1 : down ? 1 : 0);
11386 if (!player->active || tape.pausing)
11392 SnapField(player, dx, dy);
11396 DropElement(player);
11398 MovePlayer(player, dx, dy);
11401 CheckSingleStepMode(player);
11403 SetPlayerWaiting(player, FALSE);
11405 return player_action;
11409 // no actions for this player (no input at player's configured device)
11411 DigField(player, 0, 0, 0, 0, 0, 0, DF_NO_PUSH);
11412 SnapField(player, 0, 0);
11413 CheckGravityMovementWhenNotMoving(player);
11415 if (player->MovPos == 0)
11416 SetPlayerWaiting(player, TRUE);
11418 if (player->MovPos == 0) // needed for tape.playing
11419 player->is_moving = FALSE;
11421 player->is_dropping = FALSE;
11422 player->is_dropping_pressed = FALSE;
11423 player->drop_pressed_delay = 0;
11425 CheckSingleStepMode(player);
11431 static void SetMouseActionFromTapeAction(struct MouseActionInfo *mouse_action,
11434 if (!tape.use_mouse_actions)
11437 mouse_action->lx = tape_action[TAPE_ACTION_LX];
11438 mouse_action->ly = tape_action[TAPE_ACTION_LY];
11439 mouse_action->button = tape_action[TAPE_ACTION_BUTTON];
11442 static void SetTapeActionFromMouseAction(byte *tape_action,
11443 struct MouseActionInfo *mouse_action)
11445 if (!tape.use_mouse_actions)
11448 tape_action[TAPE_ACTION_LX] = mouse_action->lx;
11449 tape_action[TAPE_ACTION_LY] = mouse_action->ly;
11450 tape_action[TAPE_ACTION_BUTTON] = mouse_action->button;
11453 static void CheckLevelSolved(void)
11455 if (level.game_engine_type == GAME_ENGINE_TYPE_EM)
11457 if (game_em.level_solved &&
11458 !game_em.game_over) // game won
11462 game_em.game_over = TRUE;
11464 game.all_players_gone = TRUE;
11467 if (game_em.game_over) // game lost
11468 game.all_players_gone = TRUE;
11470 else if (level.game_engine_type == GAME_ENGINE_TYPE_SP)
11472 if (game_sp.level_solved &&
11473 !game_sp.game_over) // game won
11477 game_sp.game_over = TRUE;
11479 game.all_players_gone = TRUE;
11482 if (game_sp.game_over) // game lost
11483 game.all_players_gone = TRUE;
11485 else if (level.game_engine_type == GAME_ENGINE_TYPE_MM)
11487 if (game_mm.level_solved &&
11488 !game_mm.game_over) // game won
11492 game_mm.game_over = TRUE;
11494 game.all_players_gone = TRUE;
11497 if (game_mm.game_over) // game lost
11498 game.all_players_gone = TRUE;
11502 static void CheckLevelTime(void)
11506 if (TimeFrames >= FRAMES_PER_SECOND)
11511 for (i = 0; i < MAX_PLAYERS; i++)
11513 struct PlayerInfo *player = &stored_player[i];
11515 if (SHIELD_ON(player))
11517 player->shield_normal_time_left--;
11519 if (player->shield_deadly_time_left > 0)
11520 player->shield_deadly_time_left--;
11524 if (!game.LevelSolved && !level.use_step_counter)
11532 if (TimeLeft <= 10 && setup.time_limit)
11533 PlaySound(SND_GAME_RUNNING_OUT_OF_TIME);
11535 /* this does not make sense: game_panel_controls[GAME_PANEL_TIME].value
11536 is reset from other values in UpdateGameDoorValues() -- FIX THIS */
11538 game_panel_controls[GAME_PANEL_TIME].value = TimeLeft;
11540 if (!TimeLeft && setup.time_limit)
11542 if (level.game_engine_type == GAME_ENGINE_TYPE_EM)
11543 game_em.lev->killed_out_of_time = TRUE;
11545 for (i = 0; i < MAX_PLAYERS; i++)
11546 KillPlayer(&stored_player[i]);
11549 else if (game.no_time_limit && !game.all_players_gone)
11551 game_panel_controls[GAME_PANEL_TIME].value = TimePlayed;
11554 game_em.lev->time = (game.no_time_limit ? TimePlayed : TimeLeft);
11557 if (tape.recording || tape.playing)
11558 DrawVideoDisplay(VIDEO_STATE_TIME_ON, TapeTime);
11561 if (tape.recording || tape.playing)
11562 DrawVideoDisplay(VIDEO_STATE_FRAME_ON, FrameCounter);
11564 UpdateAndDisplayGameControlValues();
11567 void AdvanceFrameAndPlayerCounters(int player_nr)
11571 // advance frame counters (global frame counter and time frame counter)
11575 // advance player counters (counters for move delay, move animation etc.)
11576 for (i = 0; i < MAX_PLAYERS; i++)
11578 boolean advance_player_counters = (player_nr == -1 || player_nr == i);
11579 int move_delay_value = stored_player[i].move_delay_value;
11580 int move_frames = MOVE_DELAY_NORMAL_SPEED / move_delay_value;
11582 if (!advance_player_counters) // not all players may be affected
11585 if (move_frames == 0) // less than one move per game frame
11587 int stepsize = TILEX / move_delay_value;
11588 int delay = move_delay_value / MOVE_DELAY_NORMAL_SPEED;
11589 int count = (stored_player[i].is_moving ?
11590 ABS(stored_player[i].MovPos) / stepsize : FrameCounter);
11592 if (count % delay == 0)
11596 stored_player[i].Frame += move_frames;
11598 if (stored_player[i].MovPos != 0)
11599 stored_player[i].StepFrame += move_frames;
11601 if (stored_player[i].move_delay > 0)
11602 stored_player[i].move_delay--;
11604 // due to bugs in previous versions, counter must count up, not down
11605 if (stored_player[i].push_delay != -1)
11606 stored_player[i].push_delay++;
11608 if (stored_player[i].drop_delay > 0)
11609 stored_player[i].drop_delay--;
11611 if (stored_player[i].is_dropping_pressed)
11612 stored_player[i].drop_pressed_delay++;
11616 void StartGameActions(boolean init_network_game, boolean record_tape,
11619 unsigned int new_random_seed = InitRND(random_seed);
11622 TapeStartRecording(new_random_seed);
11624 if (init_network_game)
11626 SendToServer_LevelFile();
11627 SendToServer_StartPlaying();
11635 static void GameActionsExt(void)
11638 static unsigned int game_frame_delay = 0;
11640 unsigned int game_frame_delay_value;
11641 byte *recorded_player_action;
11642 byte summarized_player_action = 0;
11643 byte tape_action[MAX_TAPE_ACTIONS] = { 0 };
11646 // detect endless loops, caused by custom element programming
11647 if (recursion_loop_detected && recursion_loop_depth == 0)
11649 char *message = getStringCat3("Internal Error! Element ",
11650 EL_NAME(recursion_loop_element),
11651 " caused endless loop! Quit the game?");
11653 Warn("element '%s' caused endless loop in game engine",
11654 EL_NAME(recursion_loop_element));
11656 RequestQuitGameExt(FALSE, level_editor_test_game, message);
11658 recursion_loop_detected = FALSE; // if game should be continued
11665 if (game.restart_level)
11666 StartGameActions(network.enabled, setup.autorecord, level.random_seed);
11668 CheckLevelSolved();
11670 if (game.LevelSolved && !game.LevelSolved_GameEnd)
11673 if (game.all_players_gone && !TAPE_IS_STOPPED(tape))
11676 if (game_status != GAME_MODE_PLAYING) // status might have changed
11679 game_frame_delay_value =
11680 (tape.playing && tape.fast_forward ? FfwdFrameDelay : GameFrameDelay);
11682 if (tape.playing && tape.warp_forward && !tape.pausing)
11683 game_frame_delay_value = 0;
11685 SetVideoFrameDelay(game_frame_delay_value);
11687 // (de)activate virtual buttons depending on current game status
11688 if (strEqual(setup.touch.control_type, TOUCH_CONTROL_VIRTUAL_BUTTONS))
11690 if (game.all_players_gone) // if no players there to be controlled anymore
11691 SetOverlayActive(FALSE);
11692 else if (!tape.playing) // if game continues after tape stopped playing
11693 SetOverlayActive(TRUE);
11698 // ---------- main game synchronization point ----------
11700 int skip = WaitUntilDelayReached(&game_frame_delay, game_frame_delay_value);
11702 Debug("game:playing:skip", "skip == %d", skip);
11705 // ---------- main game synchronization point ----------
11707 WaitUntilDelayReached(&game_frame_delay, game_frame_delay_value);
11711 if (network_playing && !network_player_action_received)
11713 // try to get network player actions in time
11715 // last chance to get network player actions without main loop delay
11716 HandleNetworking();
11718 // game was quit by network peer
11719 if (game_status != GAME_MODE_PLAYING)
11722 // check if network player actions still missing and game still running
11723 if (!network_player_action_received && !checkGameEnded())
11724 return; // failed to get network player actions in time
11726 // do not yet reset "network_player_action_received" (for tape.pausing)
11732 // at this point we know that we really continue executing the game
11734 network_player_action_received = FALSE;
11736 // when playing tape, read previously recorded player input from tape data
11737 recorded_player_action = (tape.playing ? TapePlayAction() : NULL);
11739 local_player->effective_mouse_action = local_player->mouse_action;
11741 if (recorded_player_action != NULL)
11742 SetMouseActionFromTapeAction(&local_player->effective_mouse_action,
11743 recorded_player_action);
11745 // TapePlayAction() may return NULL when toggling to "pause before death"
11749 if (tape.set_centered_player)
11751 game.centered_player_nr_next = tape.centered_player_nr_next;
11752 game.set_centered_player = TRUE;
11755 for (i = 0; i < MAX_PLAYERS; i++)
11757 summarized_player_action |= stored_player[i].action;
11759 if (!network_playing && (game.team_mode || tape.playing))
11760 stored_player[i].effective_action = stored_player[i].action;
11763 if (network_playing && !checkGameEnded())
11764 SendToServer_MovePlayer(summarized_player_action);
11766 // summarize all actions at local players mapped input device position
11767 // (this allows using different input devices in single player mode)
11768 if (!network.enabled && !game.team_mode)
11769 stored_player[map_player_action[local_player->index_nr]].effective_action =
11770 summarized_player_action;
11772 // summarize all actions at centered player in local team mode
11773 if (tape.recording &&
11774 setup.team_mode && !network.enabled &&
11775 setup.input_on_focus &&
11776 game.centered_player_nr != -1)
11778 for (i = 0; i < MAX_PLAYERS; i++)
11779 stored_player[map_player_action[i]].effective_action =
11780 (i == game.centered_player_nr ? summarized_player_action : 0);
11783 if (recorded_player_action != NULL)
11784 for (i = 0; i < MAX_PLAYERS; i++)
11785 stored_player[i].effective_action = recorded_player_action[i];
11787 for (i = 0; i < MAX_PLAYERS; i++)
11789 tape_action[i] = stored_player[i].effective_action;
11791 /* (this may happen in the RND game engine if a player was not present on
11792 the playfield on level start, but appeared later from a custom element */
11793 if (setup.team_mode &&
11796 !tape.player_participates[i])
11797 tape.player_participates[i] = TRUE;
11800 SetTapeActionFromMouseAction(tape_action,
11801 &local_player->effective_mouse_action);
11803 // only record actions from input devices, but not programmed actions
11804 if (tape.recording)
11805 TapeRecordAction(tape_action);
11807 // remember if game was played (especially after tape stopped playing)
11808 if (!tape.playing && summarized_player_action)
11809 game.GamePlayed = TRUE;
11811 #if USE_NEW_PLAYER_ASSIGNMENTS
11812 // !!! also map player actions in single player mode !!!
11813 // if (game.team_mode)
11816 byte mapped_action[MAX_PLAYERS];
11818 #if DEBUG_PLAYER_ACTIONS
11819 for (i = 0; i < MAX_PLAYERS; i++)
11820 DebugContinued("", "%d, ", stored_player[i].effective_action);
11823 for (i = 0; i < MAX_PLAYERS; i++)
11824 mapped_action[i] = stored_player[map_player_action[i]].effective_action;
11826 for (i = 0; i < MAX_PLAYERS; i++)
11827 stored_player[i].effective_action = mapped_action[i];
11829 #if DEBUG_PLAYER_ACTIONS
11830 DebugContinued("", "=> ");
11831 for (i = 0; i < MAX_PLAYERS; i++)
11832 DebugContinued("", "%d, ", stored_player[i].effective_action);
11833 DebugContinued("game:playing:player", "\n");
11836 #if DEBUG_PLAYER_ACTIONS
11839 for (i = 0; i < MAX_PLAYERS; i++)
11840 DebugContinued("", "%d, ", stored_player[i].effective_action);
11841 DebugContinued("game:playing:player", "\n");
11846 for (i = 0; i < MAX_PLAYERS; i++)
11848 // allow engine snapshot in case of changed movement attempt
11849 if ((game.snapshot.last_action[i] & KEY_MOTION) !=
11850 (stored_player[i].effective_action & KEY_MOTION))
11851 game.snapshot.changed_action = TRUE;
11853 // allow engine snapshot in case of snapping/dropping attempt
11854 if ((game.snapshot.last_action[i] & KEY_BUTTON) == 0 &&
11855 (stored_player[i].effective_action & KEY_BUTTON) != 0)
11856 game.snapshot.changed_action = TRUE;
11858 game.snapshot.last_action[i] = stored_player[i].effective_action;
11861 if (level.game_engine_type == GAME_ENGINE_TYPE_EM)
11863 GameActions_EM_Main();
11865 else if (level.game_engine_type == GAME_ENGINE_TYPE_SP)
11867 GameActions_SP_Main();
11869 else if (level.game_engine_type == GAME_ENGINE_TYPE_MM)
11871 GameActions_MM_Main();
11875 GameActions_RND_Main();
11878 BlitScreenToBitmap(backbuffer);
11880 CheckLevelSolved();
11883 AdvanceFrameAndPlayerCounters(-1); // advance counters for all players
11885 if (global.show_frames_per_second)
11887 static unsigned int fps_counter = 0;
11888 static int fps_frames = 0;
11889 unsigned int fps_delay_ms = Counter() - fps_counter;
11893 if (fps_delay_ms >= 500) // calculate FPS every 0.5 seconds
11895 global.frames_per_second = 1000 * (float)fps_frames / fps_delay_ms;
11898 fps_counter = Counter();
11900 // always draw FPS to screen after FPS value was updated
11901 redraw_mask |= REDRAW_FPS;
11904 // only draw FPS if no screen areas are deactivated (invisible warp mode)
11905 if (GetDrawDeactivationMask() == REDRAW_NONE)
11906 redraw_mask |= REDRAW_FPS;
11910 static void GameActions_CheckSaveEngineSnapshot(void)
11912 if (!game.snapshot.save_snapshot)
11915 // clear flag for saving snapshot _before_ saving snapshot
11916 game.snapshot.save_snapshot = FALSE;
11918 SaveEngineSnapshotToList();
11921 void GameActions(void)
11925 GameActions_CheckSaveEngineSnapshot();
11928 void GameActions_EM_Main(void)
11930 byte effective_action[MAX_PLAYERS];
11931 boolean warp_mode = (tape.playing && tape.warp_forward && !tape.pausing);
11934 for (i = 0; i < MAX_PLAYERS; i++)
11935 effective_action[i] = stored_player[i].effective_action;
11937 GameActions_EM(effective_action, warp_mode);
11940 void GameActions_SP_Main(void)
11942 byte effective_action[MAX_PLAYERS];
11943 boolean warp_mode = (tape.playing && tape.warp_forward && !tape.pausing);
11946 for (i = 0; i < MAX_PLAYERS; i++)
11947 effective_action[i] = stored_player[i].effective_action;
11949 GameActions_SP(effective_action, warp_mode);
11951 for (i = 0; i < MAX_PLAYERS; i++)
11953 if (stored_player[i].force_dropping)
11954 stored_player[i].action |= KEY_BUTTON_DROP;
11956 stored_player[i].force_dropping = FALSE;
11960 void GameActions_MM_Main(void)
11962 boolean warp_mode = (tape.playing && tape.warp_forward && !tape.pausing);
11964 GameActions_MM(local_player->effective_mouse_action, warp_mode);
11967 void GameActions_RND_Main(void)
11972 void GameActions_RND(void)
11974 static struct MouseActionInfo mouse_action_last = { 0 };
11975 struct MouseActionInfo mouse_action = local_player->effective_mouse_action;
11976 int magic_wall_x = 0, magic_wall_y = 0;
11977 int i, x, y, element, graphic, last_gfx_frame;
11979 InitPlayfieldScanModeVars();
11981 if (game.engine_version >= VERSION_IDENT(3,2,0,7))
11983 SCAN_PLAYFIELD(x, y)
11985 ChangeCount[x][y] = 0;
11986 ChangeEvent[x][y] = -1;
11990 if (game.set_centered_player)
11992 boolean all_players_fit_to_screen = checkIfAllPlayersFitToScreen_RND();
11994 // switching to "all players" only possible if all players fit to screen
11995 if (game.centered_player_nr_next == -1 && !all_players_fit_to_screen)
11997 game.centered_player_nr_next = game.centered_player_nr;
11998 game.set_centered_player = FALSE;
12001 // do not switch focus to non-existing (or non-active) player
12002 if (game.centered_player_nr_next >= 0 &&
12003 !stored_player[game.centered_player_nr_next].active)
12005 game.centered_player_nr_next = game.centered_player_nr;
12006 game.set_centered_player = FALSE;
12010 if (game.set_centered_player &&
12011 ScreenMovPos == 0) // screen currently aligned at tile position
12015 if (game.centered_player_nr_next == -1)
12017 setScreenCenteredToAllPlayers(&sx, &sy);
12021 sx = stored_player[game.centered_player_nr_next].jx;
12022 sy = stored_player[game.centered_player_nr_next].jy;
12025 game.centered_player_nr = game.centered_player_nr_next;
12026 game.set_centered_player = FALSE;
12028 DrawRelocateScreen(0, 0, sx, sy, MV_NONE, TRUE, setup.quick_switch);
12029 DrawGameDoorValues();
12032 // check single step mode (set flag and clear again if any player is active)
12033 game.enter_single_step_mode =
12034 (tape.single_step && tape.recording && !tape.pausing);
12036 for (i = 0; i < MAX_PLAYERS; i++)
12038 int actual_player_action = stored_player[i].effective_action;
12041 /* !!! THIS BREAKS THE FOLLOWING TAPES: !!!
12042 - rnd_equinox_tetrachloride 048
12043 - rnd_equinox_tetrachloride_ii 096
12044 - rnd_emanuel_schmieg 002
12045 - doctor_sloan_ww 001, 020
12047 if (stored_player[i].MovPos == 0)
12048 CheckGravityMovement(&stored_player[i]);
12051 // overwrite programmed action with tape action
12052 if (stored_player[i].programmed_action)
12053 actual_player_action = stored_player[i].programmed_action;
12055 PlayerActions(&stored_player[i], actual_player_action);
12057 ScrollPlayer(&stored_player[i], SCROLL_GO_ON);
12060 // single step pause mode may already have been toggled by "ScrollPlayer()"
12061 if (game.enter_single_step_mode && !tape.pausing)
12062 TapeTogglePause(TAPE_TOGGLE_AUTOMATIC);
12064 ScrollScreen(NULL, SCROLL_GO_ON);
12066 /* for backwards compatibility, the following code emulates a fixed bug that
12067 occured when pushing elements (causing elements that just made their last
12068 pushing step to already (if possible) make their first falling step in the
12069 same game frame, which is bad); this code is also needed to use the famous
12070 "spring push bug" which is used in older levels and might be wanted to be
12071 used also in newer levels, but in this case the buggy pushing code is only
12072 affecting the "spring" element and no other elements */
12074 if (game.engine_version < VERSION_IDENT(2,2,0,7) || level.use_spring_bug)
12076 for (i = 0; i < MAX_PLAYERS; i++)
12078 struct PlayerInfo *player = &stored_player[i];
12079 int x = player->jx;
12080 int y = player->jy;
12082 if (player->active && player->is_pushing && player->is_moving &&
12084 (game.engine_version < VERSION_IDENT(2,2,0,7) ||
12085 Tile[x][y] == EL_SPRING))
12087 ContinueMoving(x, y);
12089 // continue moving after pushing (this is actually a bug)
12090 if (!IS_MOVING(x, y))
12091 Stop[x][y] = FALSE;
12096 SCAN_PLAYFIELD(x, y)
12098 Last[x][y] = Tile[x][y];
12100 ChangeCount[x][y] = 0;
12101 ChangeEvent[x][y] = -1;
12103 // this must be handled before main playfield loop
12104 if (Tile[x][y] == EL_PLAYER_IS_LEAVING)
12107 if (MovDelay[x][y] <= 0)
12111 if (Tile[x][y] == EL_ELEMENT_SNAPPING)
12114 if (MovDelay[x][y] <= 0)
12116 int element = Store[x][y];
12117 int move_direction = MovDir[x][y];
12118 int player_index_bit = Store2[x][y];
12124 TEST_DrawLevelField(x, y);
12126 TestFieldAfterSnapping(x, y, element, move_direction, player_index_bit);
12131 if (ChangePage[x][y] != -1 && ChangeDelay[x][y] != 1)
12133 Debug("game:playing:GameActions_RND", "x = %d, y = %d: ChangePage != -1",
12135 Debug("game:playing:GameActions_RND", "This should never happen!");
12137 ChangePage[x][y] = -1;
12141 Stop[x][y] = FALSE;
12142 if (WasJustMoving[x][y] > 0)
12143 WasJustMoving[x][y]--;
12144 if (WasJustFalling[x][y] > 0)
12145 WasJustFalling[x][y]--;
12146 if (CheckCollision[x][y] > 0)
12147 CheckCollision[x][y]--;
12148 if (CheckImpact[x][y] > 0)
12149 CheckImpact[x][y]--;
12153 /* reset finished pushing action (not done in ContinueMoving() to allow
12154 continuous pushing animation for elements with zero push delay) */
12155 if (GfxAction[x][y] == ACTION_PUSHING && !IS_MOVING(x, y))
12157 ResetGfxAnimation(x, y);
12158 TEST_DrawLevelField(x, y);
12162 if (IS_BLOCKED(x, y))
12166 Blocked2Moving(x, y, &oldx, &oldy);
12167 if (!IS_MOVING(oldx, oldy))
12169 Debug("game:playing:GameActions_RND", "(BLOCKED => MOVING) context corrupted!");
12170 Debug("game:playing:GameActions_RND", "BLOCKED: x = %d, y = %d", x, y);
12171 Debug("game:playing:GameActions_RND", "!MOVING: oldx = %d, oldy = %d", oldx, oldy);
12172 Debug("game:playing:GameActions_RND", "This should never happen!");
12178 if (mouse_action.button)
12180 int new_button = (mouse_action.button && mouse_action_last.button == 0);
12181 int ch_button = CH_SIDE_FROM_BUTTON(mouse_action.button);
12183 x = mouse_action.lx;
12184 y = mouse_action.ly;
12185 element = Tile[x][y];
12189 CheckElementChangeByMouse(x, y, element, CE_CLICKED_BY_MOUSE, ch_button);
12190 CheckTriggeredElementChangeByMouse(x, y, element, CE_MOUSE_CLICKED_ON_X,
12194 CheckElementChangeByMouse(x, y, element, CE_PRESSED_BY_MOUSE, ch_button);
12195 CheckTriggeredElementChangeByMouse(x, y, element, CE_MOUSE_PRESSED_ON_X,
12199 SCAN_PLAYFIELD(x, y)
12201 element = Tile[x][y];
12202 graphic = el_act_dir2img(element, GfxAction[x][y], GfxDir[x][y]);
12203 last_gfx_frame = GfxFrame[x][y];
12205 ResetGfxFrame(x, y);
12207 if (GfxFrame[x][y] != last_gfx_frame && !Stop[x][y])
12208 DrawLevelGraphicAnimation(x, y, graphic);
12210 if (ANIM_MODE(graphic) == ANIM_RANDOM &&
12211 IS_NEXT_FRAME(GfxFrame[x][y], graphic))
12212 ResetRandomAnimationValue(x, y);
12214 SetRandomAnimationValue(x, y);
12216 PlayLevelSoundActionIfLoop(x, y, GfxAction[x][y]);
12218 if (IS_INACTIVE(element))
12220 if (IS_ANIMATED(graphic))
12221 DrawLevelGraphicAnimationIfNeeded(x, y, graphic);
12226 // this may take place after moving, so 'element' may have changed
12227 if (IS_CHANGING(x, y) &&
12228 (game.engine_version < VERSION_IDENT(3,0,7,1) || !Stop[x][y]))
12230 int page = element_info[element].event_page_nr[CE_DELAY];
12232 HandleElementChange(x, y, page);
12234 element = Tile[x][y];
12235 graphic = el_act_dir2img(element, GfxAction[x][y], GfxDir[x][y]);
12238 if (!IS_MOVING(x, y) && (CAN_FALL(element) || CAN_MOVE(element)))
12242 element = Tile[x][y];
12243 graphic = el_act_dir2img(element, GfxAction[x][y], GfxDir[x][y]);
12245 if (IS_ANIMATED(graphic) &&
12246 !IS_MOVING(x, y) &&
12248 DrawLevelGraphicAnimationIfNeeded(x, y, graphic);
12250 if (IS_GEM(element) || element == EL_SP_INFOTRON)
12251 TEST_DrawTwinkleOnField(x, y);
12253 else if (element == EL_ACID)
12256 DrawLevelGraphicAnimationIfNeeded(x, y, graphic);
12258 else if ((element == EL_EXIT_OPEN ||
12259 element == EL_EM_EXIT_OPEN ||
12260 element == EL_SP_EXIT_OPEN ||
12261 element == EL_STEEL_EXIT_OPEN ||
12262 element == EL_EM_STEEL_EXIT_OPEN ||
12263 element == EL_SP_TERMINAL ||
12264 element == EL_SP_TERMINAL_ACTIVE ||
12265 element == EL_EXTRA_TIME ||
12266 element == EL_SHIELD_NORMAL ||
12267 element == EL_SHIELD_DEADLY) &&
12268 IS_ANIMATED(graphic))
12269 DrawLevelGraphicAnimationIfNeeded(x, y, graphic);
12270 else if (IS_MOVING(x, y))
12271 ContinueMoving(x, y);
12272 else if (IS_ACTIVE_BOMB(element))
12273 CheckDynamite(x, y);
12274 else if (element == EL_AMOEBA_GROWING)
12275 AmoebaGrowing(x, y);
12276 else if (element == EL_AMOEBA_SHRINKING)
12277 AmoebaShrinking(x, y);
12279 #if !USE_NEW_AMOEBA_CODE
12280 else if (IS_AMOEBALIVE(element))
12281 AmoebaReproduce(x, y);
12284 else if (element == EL_GAME_OF_LIFE || element == EL_BIOMAZE)
12286 else if (element == EL_EXIT_CLOSED)
12288 else if (element == EL_EM_EXIT_CLOSED)
12290 else if (element == EL_STEEL_EXIT_CLOSED)
12291 CheckExitSteel(x, y);
12292 else if (element == EL_EM_STEEL_EXIT_CLOSED)
12293 CheckExitSteelEM(x, y);
12294 else if (element == EL_SP_EXIT_CLOSED)
12296 else if (element == EL_EXPANDABLE_WALL_GROWING ||
12297 element == EL_EXPANDABLE_STEELWALL_GROWING)
12298 MauerWaechst(x, y);
12299 else if (element == EL_EXPANDABLE_WALL ||
12300 element == EL_EXPANDABLE_WALL_HORIZONTAL ||
12301 element == EL_EXPANDABLE_WALL_VERTICAL ||
12302 element == EL_EXPANDABLE_WALL_ANY ||
12303 element == EL_BD_EXPANDABLE_WALL)
12304 MauerAbleger(x, y);
12305 else if (element == EL_EXPANDABLE_STEELWALL_HORIZONTAL ||
12306 element == EL_EXPANDABLE_STEELWALL_VERTICAL ||
12307 element == EL_EXPANDABLE_STEELWALL_ANY)
12308 MauerAblegerStahl(x, y);
12309 else if (element == EL_FLAMES)
12310 CheckForDragon(x, y);
12311 else if (element == EL_EXPLOSION)
12312 ; // drawing of correct explosion animation is handled separately
12313 else if (element == EL_ELEMENT_SNAPPING ||
12314 element == EL_DIAGONAL_SHRINKING ||
12315 element == EL_DIAGONAL_GROWING)
12317 graphic = el_act_dir2img(GfxElement[x][y], GfxAction[x][y],GfxDir[x][y]);
12319 DrawLevelGraphicAnimationIfNeeded(x, y, graphic);
12321 else if (IS_ANIMATED(graphic) && !IS_CHANGING(x, y))
12322 DrawLevelGraphicAnimationIfNeeded(x, y, graphic);
12324 if (IS_BELT_ACTIVE(element))
12325 PlayLevelSoundAction(x, y, ACTION_ACTIVE);
12327 if (game.magic_wall_active)
12329 int jx = local_player->jx, jy = local_player->jy;
12331 // play the element sound at the position nearest to the player
12332 if ((element == EL_MAGIC_WALL_FULL ||
12333 element == EL_MAGIC_WALL_ACTIVE ||
12334 element == EL_MAGIC_WALL_EMPTYING ||
12335 element == EL_BD_MAGIC_WALL_FULL ||
12336 element == EL_BD_MAGIC_WALL_ACTIVE ||
12337 element == EL_BD_MAGIC_WALL_EMPTYING ||
12338 element == EL_DC_MAGIC_WALL_FULL ||
12339 element == EL_DC_MAGIC_WALL_ACTIVE ||
12340 element == EL_DC_MAGIC_WALL_EMPTYING) &&
12341 ABS(x - jx) + ABS(y - jy) <
12342 ABS(magic_wall_x - jx) + ABS(magic_wall_y - jy))
12350 #if USE_NEW_AMOEBA_CODE
12351 // new experimental amoeba growth stuff
12352 if (!(FrameCounter % 8))
12354 static unsigned int random = 1684108901;
12356 for (i = 0; i < level.amoeba_speed * 28 / 8; i++)
12358 x = RND(lev_fieldx);
12359 y = RND(lev_fieldy);
12360 element = Tile[x][y];
12362 if (!IS_PLAYER(x,y) &&
12363 (element == EL_EMPTY ||
12364 CAN_GROW_INTO(element) ||
12365 element == EL_QUICKSAND_EMPTY ||
12366 element == EL_QUICKSAND_FAST_EMPTY ||
12367 element == EL_ACID_SPLASH_LEFT ||
12368 element == EL_ACID_SPLASH_RIGHT))
12370 if ((IN_LEV_FIELD(x, y-1) && Tile[x][y-1] == EL_AMOEBA_WET) ||
12371 (IN_LEV_FIELD(x-1, y) && Tile[x-1][y] == EL_AMOEBA_WET) ||
12372 (IN_LEV_FIELD(x+1, y) && Tile[x+1][y] == EL_AMOEBA_WET) ||
12373 (IN_LEV_FIELD(x, y+1) && Tile[x][y+1] == EL_AMOEBA_WET))
12374 Tile[x][y] = EL_AMOEBA_DROP;
12377 random = random * 129 + 1;
12382 game.explosions_delayed = FALSE;
12384 SCAN_PLAYFIELD(x, y)
12386 element = Tile[x][y];
12388 if (ExplodeField[x][y])
12389 Explode(x, y, EX_PHASE_START, ExplodeField[x][y]);
12390 else if (element == EL_EXPLOSION)
12391 Explode(x, y, ExplodePhase[x][y], EX_TYPE_NORMAL);
12393 ExplodeField[x][y] = EX_TYPE_NONE;
12396 game.explosions_delayed = TRUE;
12398 if (game.magic_wall_active)
12400 if (!(game.magic_wall_time_left % 4))
12402 int element = Tile[magic_wall_x][magic_wall_y];
12404 if (element == EL_BD_MAGIC_WALL_FULL ||
12405 element == EL_BD_MAGIC_WALL_ACTIVE ||
12406 element == EL_BD_MAGIC_WALL_EMPTYING)
12407 PlayLevelSound(magic_wall_x, magic_wall_y, SND_BD_MAGIC_WALL_ACTIVE);
12408 else if (element == EL_DC_MAGIC_WALL_FULL ||
12409 element == EL_DC_MAGIC_WALL_ACTIVE ||
12410 element == EL_DC_MAGIC_WALL_EMPTYING)
12411 PlayLevelSound(magic_wall_x, magic_wall_y, SND_DC_MAGIC_WALL_ACTIVE);
12413 PlayLevelSound(magic_wall_x, magic_wall_y, SND_MAGIC_WALL_ACTIVE);
12416 if (game.magic_wall_time_left > 0)
12418 game.magic_wall_time_left--;
12420 if (!game.magic_wall_time_left)
12422 SCAN_PLAYFIELD(x, y)
12424 element = Tile[x][y];
12426 if (element == EL_MAGIC_WALL_ACTIVE ||
12427 element == EL_MAGIC_WALL_FULL)
12429 Tile[x][y] = EL_MAGIC_WALL_DEAD;
12430 TEST_DrawLevelField(x, y);
12432 else if (element == EL_BD_MAGIC_WALL_ACTIVE ||
12433 element == EL_BD_MAGIC_WALL_FULL)
12435 Tile[x][y] = EL_BD_MAGIC_WALL_DEAD;
12436 TEST_DrawLevelField(x, y);
12438 else if (element == EL_DC_MAGIC_WALL_ACTIVE ||
12439 element == EL_DC_MAGIC_WALL_FULL)
12441 Tile[x][y] = EL_DC_MAGIC_WALL_DEAD;
12442 TEST_DrawLevelField(x, y);
12446 game.magic_wall_active = FALSE;
12451 if (game.light_time_left > 0)
12453 game.light_time_left--;
12455 if (game.light_time_left == 0)
12456 RedrawAllLightSwitchesAndInvisibleElements();
12459 if (game.timegate_time_left > 0)
12461 game.timegate_time_left--;
12463 if (game.timegate_time_left == 0)
12464 CloseAllOpenTimegates();
12467 if (game.lenses_time_left > 0)
12469 game.lenses_time_left--;
12471 if (game.lenses_time_left == 0)
12472 RedrawAllInvisibleElementsForLenses();
12475 if (game.magnify_time_left > 0)
12477 game.magnify_time_left--;
12479 if (game.magnify_time_left == 0)
12480 RedrawAllInvisibleElementsForMagnifier();
12483 for (i = 0; i < MAX_PLAYERS; i++)
12485 struct PlayerInfo *player = &stored_player[i];
12487 if (SHIELD_ON(player))
12489 if (player->shield_deadly_time_left)
12490 PlayLevelSound(player->jx, player->jy, SND_SHIELD_DEADLY_ACTIVE);
12491 else if (player->shield_normal_time_left)
12492 PlayLevelSound(player->jx, player->jy, SND_SHIELD_NORMAL_ACTIVE);
12496 #if USE_DELAYED_GFX_REDRAW
12497 SCAN_PLAYFIELD(x, y)
12499 if (GfxRedraw[x][y] != GFX_REDRAW_NONE)
12501 /* !!! PROBLEM: THIS REDRAWS THE PLAYFIELD _AFTER_ THE SCAN, BUT TILES
12502 !!! MAY HAVE CHANGED AFTER BEING DRAWN DURING PLAYFIELD SCAN !!! */
12504 if (GfxRedraw[x][y] & GFX_REDRAW_TILE)
12505 DrawLevelField(x, y);
12507 if (GfxRedraw[x][y] & GFX_REDRAW_TILE_CRUMBLED)
12508 DrawLevelFieldCrumbled(x, y);
12510 if (GfxRedraw[x][y] & GFX_REDRAW_TILE_CRUMBLED_NEIGHBOURS)
12511 DrawLevelFieldCrumbledNeighbours(x, y);
12513 if (GfxRedraw[x][y] & GFX_REDRAW_TILE_TWINKLED)
12514 DrawTwinkleOnField(x, y);
12517 GfxRedraw[x][y] = GFX_REDRAW_NONE;
12522 PlayAllPlayersSound();
12524 for (i = 0; i < MAX_PLAYERS; i++)
12526 struct PlayerInfo *player = &stored_player[i];
12528 if (player->show_envelope != 0 && (!player->active ||
12529 player->MovPos == 0))
12531 ShowEnvelope(player->show_envelope - EL_ENVELOPE_1);
12533 player->show_envelope = 0;
12537 // use random number generator in every frame to make it less predictable
12538 if (game.engine_version >= VERSION_IDENT(3,1,1,0))
12541 mouse_action_last = mouse_action;
12544 static boolean AllPlayersInSight(struct PlayerInfo *player, int x, int y)
12546 int min_x = x, min_y = y, max_x = x, max_y = y;
12547 int scr_fieldx = getScreenFieldSizeX();
12548 int scr_fieldy = getScreenFieldSizeY();
12551 for (i = 0; i < MAX_PLAYERS; i++)
12553 int jx = stored_player[i].jx, jy = stored_player[i].jy;
12555 if (!stored_player[i].active || &stored_player[i] == player)
12558 min_x = MIN(min_x, jx);
12559 min_y = MIN(min_y, jy);
12560 max_x = MAX(max_x, jx);
12561 max_y = MAX(max_y, jy);
12564 return (max_x - min_x < scr_fieldx && max_y - min_y < scr_fieldy);
12567 static boolean AllPlayersInVisibleScreen(void)
12571 for (i = 0; i < MAX_PLAYERS; i++)
12573 int jx = stored_player[i].jx, jy = stored_player[i].jy;
12575 if (!stored_player[i].active)
12578 if (!IN_VIS_FIELD(SCREENX(jx), SCREENY(jy)))
12585 void ScrollLevel(int dx, int dy)
12587 int scroll_offset = 2 * TILEX_VAR;
12590 BlitBitmap(drawto_field, drawto_field,
12591 FX + TILEX_VAR * (dx == -1) - scroll_offset,
12592 FY + TILEY_VAR * (dy == -1) - scroll_offset,
12593 SXSIZE - TILEX_VAR * (dx != 0) + 2 * scroll_offset,
12594 SYSIZE - TILEY_VAR * (dy != 0) + 2 * scroll_offset,
12595 FX + TILEX_VAR * (dx == 1) - scroll_offset,
12596 FY + TILEY_VAR * (dy == 1) - scroll_offset);
12600 x = (dx == 1 ? BX1 : BX2);
12601 for (y = BY1; y <= BY2; y++)
12602 DrawScreenField(x, y);
12607 y = (dy == 1 ? BY1 : BY2);
12608 for (x = BX1; x <= BX2; x++)
12609 DrawScreenField(x, y);
12612 redraw_mask |= REDRAW_FIELD;
12615 static boolean canFallDown(struct PlayerInfo *player)
12617 int jx = player->jx, jy = player->jy;
12619 return (IN_LEV_FIELD(jx, jy + 1) &&
12620 (IS_FREE(jx, jy + 1) ||
12621 (Tile[jx][jy + 1] == EL_ACID && player->can_fall_into_acid)) &&
12622 IS_WALKABLE_FROM(Tile[jx][jy], MV_DOWN) &&
12623 !IS_WALKABLE_INSIDE(Tile[jx][jy]));
12626 static boolean canPassField(int x, int y, int move_dir)
12628 int opposite_dir = MV_DIR_OPPOSITE(move_dir);
12629 int dx = (move_dir & MV_LEFT ? -1 : move_dir & MV_RIGHT ? +1 : 0);
12630 int dy = (move_dir & MV_UP ? -1 : move_dir & MV_DOWN ? +1 : 0);
12631 int nextx = x + dx;
12632 int nexty = y + dy;
12633 int element = Tile[x][y];
12635 return (IS_PASSABLE_FROM(element, opposite_dir) &&
12636 !CAN_MOVE(element) &&
12637 IN_LEV_FIELD(nextx, nexty) && !IS_PLAYER(nextx, nexty) &&
12638 IS_WALKABLE_FROM(Tile[nextx][nexty], move_dir) &&
12639 (level.can_pass_to_walkable || IS_FREE(nextx, nexty)));
12642 static boolean canMoveToValidFieldWithGravity(int x, int y, int move_dir)
12644 int opposite_dir = MV_DIR_OPPOSITE(move_dir);
12645 int dx = (move_dir & MV_LEFT ? -1 : move_dir & MV_RIGHT ? +1 : 0);
12646 int dy = (move_dir & MV_UP ? -1 : move_dir & MV_DOWN ? +1 : 0);
12650 return (IN_LEV_FIELD(newx, newy) && !IS_FREE_OR_PLAYER(newx, newy) &&
12651 IS_GRAVITY_REACHABLE(Tile[newx][newy]) &&
12652 (IS_DIGGABLE(Tile[newx][newy]) ||
12653 IS_WALKABLE_FROM(Tile[newx][newy], opposite_dir) ||
12654 canPassField(newx, newy, move_dir)));
12657 static void CheckGravityMovement(struct PlayerInfo *player)
12659 if (player->gravity && !player->programmed_action)
12661 int move_dir_horizontal = player->effective_action & MV_HORIZONTAL;
12662 int move_dir_vertical = player->effective_action & MV_VERTICAL;
12663 boolean player_is_snapping = (player->effective_action & JOY_BUTTON_1);
12664 int jx = player->jx, jy = player->jy;
12665 boolean player_is_moving_to_valid_field =
12666 (!player_is_snapping &&
12667 (canMoveToValidFieldWithGravity(jx, jy, move_dir_horizontal) ||
12668 canMoveToValidFieldWithGravity(jx, jy, move_dir_vertical)));
12669 boolean player_can_fall_down = canFallDown(player);
12671 if (player_can_fall_down &&
12672 !player_is_moving_to_valid_field)
12673 player->programmed_action = MV_DOWN;
12677 static void CheckGravityMovementWhenNotMoving(struct PlayerInfo *player)
12679 return CheckGravityMovement(player);
12681 if (player->gravity && !player->programmed_action)
12683 int jx = player->jx, jy = player->jy;
12684 boolean field_under_player_is_free =
12685 (IN_LEV_FIELD(jx, jy + 1) && IS_FREE(jx, jy + 1));
12686 boolean player_is_standing_on_valid_field =
12687 (IS_WALKABLE_INSIDE(Tile[jx][jy]) ||
12688 (IS_WALKABLE(Tile[jx][jy]) &&
12689 !(element_info[Tile[jx][jy]].access_direction & MV_DOWN)));
12691 if (field_under_player_is_free && !player_is_standing_on_valid_field)
12692 player->programmed_action = MV_DOWN;
12697 MovePlayerOneStep()
12698 -----------------------------------------------------------------------------
12699 dx, dy: direction (non-diagonal) to try to move the player to
12700 real_dx, real_dy: direction as read from input device (can be diagonal)
12703 boolean MovePlayerOneStep(struct PlayerInfo *player,
12704 int dx, int dy, int real_dx, int real_dy)
12706 int jx = player->jx, jy = player->jy;
12707 int new_jx = jx + dx, new_jy = jy + dy;
12709 boolean player_can_move = !player->cannot_move;
12711 if (!player->active || (!dx && !dy))
12712 return MP_NO_ACTION;
12714 player->MovDir = (dx < 0 ? MV_LEFT :
12715 dx > 0 ? MV_RIGHT :
12717 dy > 0 ? MV_DOWN : MV_NONE);
12719 if (!IN_LEV_FIELD(new_jx, new_jy))
12720 return MP_NO_ACTION;
12722 if (!player_can_move)
12724 if (player->MovPos == 0)
12726 player->is_moving = FALSE;
12727 player->is_digging = FALSE;
12728 player->is_collecting = FALSE;
12729 player->is_snapping = FALSE;
12730 player->is_pushing = FALSE;
12734 if (!network.enabled && game.centered_player_nr == -1 &&
12735 !AllPlayersInSight(player, new_jx, new_jy))
12736 return MP_NO_ACTION;
12738 can_move = DigField(player, jx, jy, new_jx, new_jy, real_dx,real_dy, DF_DIG);
12739 if (can_move != MP_MOVING)
12742 // check if DigField() has caused relocation of the player
12743 if (player->jx != jx || player->jy != jy)
12744 return MP_NO_ACTION; // <-- !!! CHECK THIS [-> MP_ACTION ?] !!!
12746 StorePlayer[jx][jy] = 0;
12747 player->last_jx = jx;
12748 player->last_jy = jy;
12749 player->jx = new_jx;
12750 player->jy = new_jy;
12751 StorePlayer[new_jx][new_jy] = player->element_nr;
12753 if (player->move_delay_value_next != -1)
12755 player->move_delay_value = player->move_delay_value_next;
12756 player->move_delay_value_next = -1;
12760 (dx > 0 || dy > 0 ? -1 : 1) * (TILEX - TILEX / player->move_delay_value);
12762 player->step_counter++;
12764 PlayerVisit[jx][jy] = FrameCounter;
12766 player->is_moving = TRUE;
12769 // should better be called in MovePlayer(), but this breaks some tapes
12770 ScrollPlayer(player, SCROLL_INIT);
12776 boolean MovePlayer(struct PlayerInfo *player, int dx, int dy)
12778 int jx = player->jx, jy = player->jy;
12779 int old_jx = jx, old_jy = jy;
12780 int moved = MP_NO_ACTION;
12782 if (!player->active)
12787 if (player->MovPos == 0)
12789 player->is_moving = FALSE;
12790 player->is_digging = FALSE;
12791 player->is_collecting = FALSE;
12792 player->is_snapping = FALSE;
12793 player->is_pushing = FALSE;
12799 if (player->move_delay > 0)
12802 player->move_delay = -1; // set to "uninitialized" value
12804 // store if player is automatically moved to next field
12805 player->is_auto_moving = (player->programmed_action != MV_NONE);
12807 // remove the last programmed player action
12808 player->programmed_action = 0;
12810 if (player->MovPos)
12812 // should only happen if pre-1.2 tape recordings are played
12813 // this is only for backward compatibility
12815 int original_move_delay_value = player->move_delay_value;
12818 Debug("game:playing:MovePlayer",
12819 "THIS SHOULD ONLY HAPPEN WITH PRE-1.2 LEVEL TAPES. [%d]",
12823 // scroll remaining steps with finest movement resolution
12824 player->move_delay_value = MOVE_DELAY_NORMAL_SPEED;
12826 while (player->MovPos)
12828 ScrollPlayer(player, SCROLL_GO_ON);
12829 ScrollScreen(NULL, SCROLL_GO_ON);
12831 AdvanceFrameAndPlayerCounters(player->index_nr);
12834 BackToFront_WithFrameDelay(0);
12837 player->move_delay_value = original_move_delay_value;
12840 player->is_active = FALSE;
12842 if (player->last_move_dir & MV_HORIZONTAL)
12844 if (!(moved |= MovePlayerOneStep(player, 0, dy, dx, dy)))
12845 moved |= MovePlayerOneStep(player, dx, 0, dx, dy);
12849 if (!(moved |= MovePlayerOneStep(player, dx, 0, dx, dy)))
12850 moved |= MovePlayerOneStep(player, 0, dy, dx, dy);
12853 if (!moved && !player->is_active)
12855 player->is_moving = FALSE;
12856 player->is_digging = FALSE;
12857 player->is_collecting = FALSE;
12858 player->is_snapping = FALSE;
12859 player->is_pushing = FALSE;
12865 if (moved & MP_MOVING && !ScreenMovPos &&
12866 (player->index_nr == game.centered_player_nr ||
12867 game.centered_player_nr == -1))
12869 int old_scroll_x = scroll_x, old_scroll_y = scroll_y;
12871 if (!IN_VIS_FIELD(SCREENX(jx), SCREENY(jy)))
12873 // actual player has left the screen -- scroll in that direction
12874 if (jx != old_jx) // player has moved horizontally
12875 scroll_x += (jx - old_jx);
12876 else // player has moved vertically
12877 scroll_y += (jy - old_jy);
12881 int offset_raw = game.scroll_delay_value;
12883 if (jx != old_jx) // player has moved horizontally
12885 int offset = MIN(offset_raw, (SCR_FIELDX - 2) / 2);
12886 int offset_x = offset * (player->MovDir == MV_LEFT ? +1 : -1);
12887 int new_scroll_x = jx - MIDPOSX + offset_x;
12889 if ((player->MovDir == MV_LEFT && scroll_x > new_scroll_x) ||
12890 (player->MovDir == MV_RIGHT && scroll_x < new_scroll_x))
12891 scroll_x = new_scroll_x;
12893 // don't scroll over playfield boundaries
12894 scroll_x = MIN(MAX(SBX_Left, scroll_x), SBX_Right);
12896 // don't scroll more than one field at a time
12897 scroll_x = old_scroll_x + SIGN(scroll_x - old_scroll_x);
12899 // don't scroll against the player's moving direction
12900 if ((player->MovDir == MV_LEFT && scroll_x > old_scroll_x) ||
12901 (player->MovDir == MV_RIGHT && scroll_x < old_scroll_x))
12902 scroll_x = old_scroll_x;
12904 else // player has moved vertically
12906 int offset = MIN(offset_raw, (SCR_FIELDY - 2) / 2);
12907 int offset_y = offset * (player->MovDir == MV_UP ? +1 : -1);
12908 int new_scroll_y = jy - MIDPOSY + offset_y;
12910 if ((player->MovDir == MV_UP && scroll_y > new_scroll_y) ||
12911 (player->MovDir == MV_DOWN && scroll_y < new_scroll_y))
12912 scroll_y = new_scroll_y;
12914 // don't scroll over playfield boundaries
12915 scroll_y = MIN(MAX(SBY_Upper, scroll_y), SBY_Lower);
12917 // don't scroll more than one field at a time
12918 scroll_y = old_scroll_y + SIGN(scroll_y - old_scroll_y);
12920 // don't scroll against the player's moving direction
12921 if ((player->MovDir == MV_UP && scroll_y > old_scroll_y) ||
12922 (player->MovDir == MV_DOWN && scroll_y < old_scroll_y))
12923 scroll_y = old_scroll_y;
12927 if (scroll_x != old_scroll_x || scroll_y != old_scroll_y)
12929 if (!network.enabled && game.centered_player_nr == -1 &&
12930 !AllPlayersInVisibleScreen())
12932 scroll_x = old_scroll_x;
12933 scroll_y = old_scroll_y;
12937 ScrollScreen(player, SCROLL_INIT);
12938 ScrollLevel(old_scroll_x - scroll_x, old_scroll_y - scroll_y);
12943 player->StepFrame = 0;
12945 if (moved & MP_MOVING)
12947 if (old_jx != jx && old_jy == jy)
12948 player->MovDir = (old_jx < jx ? MV_RIGHT : MV_LEFT);
12949 else if (old_jx == jx && old_jy != jy)
12950 player->MovDir = (old_jy < jy ? MV_DOWN : MV_UP);
12952 TEST_DrawLevelField(jx, jy); // for "crumbled sand"
12954 player->last_move_dir = player->MovDir;
12955 player->is_moving = TRUE;
12956 player->is_snapping = FALSE;
12957 player->is_switching = FALSE;
12958 player->is_dropping = FALSE;
12959 player->is_dropping_pressed = FALSE;
12960 player->drop_pressed_delay = 0;
12963 // should better be called here than above, but this breaks some tapes
12964 ScrollPlayer(player, SCROLL_INIT);
12969 CheckGravityMovementWhenNotMoving(player);
12971 player->is_moving = FALSE;
12973 /* at this point, the player is allowed to move, but cannot move right now
12974 (e.g. because of something blocking the way) -- ensure that the player
12975 is also allowed to move in the next frame (in old versions before 3.1.1,
12976 the player was forced to wait again for eight frames before next try) */
12978 if (game.engine_version >= VERSION_IDENT(3,1,1,0))
12979 player->move_delay = 0; // allow direct movement in the next frame
12982 if (player->move_delay == -1) // not yet initialized by DigField()
12983 player->move_delay = player->move_delay_value;
12985 if (game.engine_version < VERSION_IDENT(3,0,7,0))
12987 TestIfPlayerTouchesBadThing(jx, jy);
12988 TestIfPlayerTouchesCustomElement(jx, jy);
12991 if (!player->active)
12992 RemovePlayer(player);
12997 void ScrollPlayer(struct PlayerInfo *player, int mode)
12999 int jx = player->jx, jy = player->jy;
13000 int last_jx = player->last_jx, last_jy = player->last_jy;
13001 int move_stepsize = TILEX / player->move_delay_value;
13003 if (!player->active)
13006 if (player->MovPos == 0 && mode == SCROLL_GO_ON) // player not moving
13009 if (mode == SCROLL_INIT)
13011 player->actual_frame_counter = FrameCounter;
13012 player->GfxPos = move_stepsize * (player->MovPos / move_stepsize);
13014 if ((player->block_last_field || player->block_delay_adjustment > 0) &&
13015 Tile[last_jx][last_jy] == EL_EMPTY)
13017 int last_field_block_delay = 0; // start with no blocking at all
13018 int block_delay_adjustment = player->block_delay_adjustment;
13020 // if player blocks last field, add delay for exactly one move
13021 if (player->block_last_field)
13023 last_field_block_delay += player->move_delay_value;
13025 // when blocking enabled, prevent moving up despite gravity
13026 if (player->gravity && player->MovDir == MV_UP)
13027 block_delay_adjustment = -1;
13030 // add block delay adjustment (also possible when not blocking)
13031 last_field_block_delay += block_delay_adjustment;
13033 Tile[last_jx][last_jy] = EL_PLAYER_IS_LEAVING;
13034 MovDelay[last_jx][last_jy] = last_field_block_delay + 1;
13037 if (player->MovPos != 0) // player has not yet reached destination
13040 else if (!FrameReached(&player->actual_frame_counter, 1))
13043 if (player->MovPos != 0)
13045 player->MovPos += (player->MovPos > 0 ? -1 : 1) * move_stepsize;
13046 player->GfxPos = move_stepsize * (player->MovPos / move_stepsize);
13048 // before DrawPlayer() to draw correct player graphic for this case
13049 if (player->MovPos == 0)
13050 CheckGravityMovement(player);
13053 if (player->MovPos == 0) // player reached destination field
13055 if (player->move_delay_reset_counter > 0)
13057 player->move_delay_reset_counter--;
13059 if (player->move_delay_reset_counter == 0)
13061 // continue with normal speed after quickly moving through gate
13062 HALVE_PLAYER_SPEED(player);
13064 // be able to make the next move without delay
13065 player->move_delay = 0;
13069 player->last_jx = jx;
13070 player->last_jy = jy;
13072 if (Tile[jx][jy] == EL_EXIT_OPEN ||
13073 Tile[jx][jy] == EL_EM_EXIT_OPEN ||
13074 Tile[jx][jy] == EL_EM_EXIT_OPENING ||
13075 Tile[jx][jy] == EL_STEEL_EXIT_OPEN ||
13076 Tile[jx][jy] == EL_EM_STEEL_EXIT_OPEN ||
13077 Tile[jx][jy] == EL_EM_STEEL_EXIT_OPENING ||
13078 Tile[jx][jy] == EL_SP_EXIT_OPEN ||
13079 Tile[jx][jy] == EL_SP_EXIT_OPENING) // <-- special case
13081 ExitPlayer(player);
13083 if (game.players_still_needed == 0 &&
13084 (game.friends_still_needed == 0 ||
13085 IS_SP_ELEMENT(Tile[jx][jy])))
13089 // this breaks one level: "machine", level 000
13091 int move_direction = player->MovDir;
13092 int enter_side = MV_DIR_OPPOSITE(move_direction);
13093 int leave_side = move_direction;
13094 int old_jx = last_jx;
13095 int old_jy = last_jy;
13096 int old_element = Tile[old_jx][old_jy];
13097 int new_element = Tile[jx][jy];
13099 if (IS_CUSTOM_ELEMENT(old_element))
13100 CheckElementChangeByPlayer(old_jx, old_jy, old_element,
13102 player->index_bit, leave_side);
13104 CheckTriggeredElementChangeByPlayer(old_jx, old_jy, old_element,
13105 CE_PLAYER_LEAVES_X,
13106 player->index_bit, leave_side);
13108 if (IS_CUSTOM_ELEMENT(new_element))
13109 CheckElementChangeByPlayer(jx, jy, new_element, CE_ENTERED_BY_PLAYER,
13110 player->index_bit, enter_side);
13112 CheckTriggeredElementChangeByPlayer(jx, jy, new_element,
13113 CE_PLAYER_ENTERS_X,
13114 player->index_bit, enter_side);
13116 CheckTriggeredElementChangeBySide(jx, jy, player->initial_element,
13117 CE_MOVE_OF_X, move_direction);
13120 if (game.engine_version >= VERSION_IDENT(3,0,7,0))
13122 TestIfPlayerTouchesBadThing(jx, jy);
13123 TestIfPlayerTouchesCustomElement(jx, jy);
13125 /* needed because pushed element has not yet reached its destination,
13126 so it would trigger a change event at its previous field location */
13127 if (!player->is_pushing)
13128 TestIfElementTouchesCustomElement(jx, jy); // for empty space
13130 if (level.finish_dig_collect &&
13131 (player->is_digging || player->is_collecting))
13133 int last_element = player->last_removed_element;
13134 int move_direction = player->MovDir;
13135 int enter_side = MV_DIR_OPPOSITE(move_direction);
13136 int change_event = (player->is_digging ? CE_PLAYER_DIGS_X :
13137 CE_PLAYER_COLLECTS_X);
13139 CheckTriggeredElementChangeByPlayer(jx, jy, last_element, change_event,
13140 player->index_bit, enter_side);
13142 player->last_removed_element = EL_UNDEFINED;
13145 if (!player->active)
13146 RemovePlayer(player);
13149 if (level.use_step_counter)
13159 if (TimeLeft <= 10 && setup.time_limit && !game.LevelSolved)
13160 PlaySound(SND_GAME_RUNNING_OUT_OF_TIME);
13162 game_panel_controls[GAME_PANEL_TIME].value = TimeLeft;
13164 DisplayGameControlValues();
13166 if (!TimeLeft && setup.time_limit && !game.LevelSolved)
13167 for (i = 0; i < MAX_PLAYERS; i++)
13168 KillPlayer(&stored_player[i]);
13170 else if (game.no_time_limit && !game.all_players_gone)
13172 game_panel_controls[GAME_PANEL_TIME].value = TimePlayed;
13174 DisplayGameControlValues();
13178 if (tape.single_step && tape.recording && !tape.pausing &&
13179 !player->programmed_action)
13180 TapeTogglePause(TAPE_TOGGLE_AUTOMATIC);
13182 if (!player->programmed_action)
13183 CheckSaveEngineSnapshot(player);
13187 void ScrollScreen(struct PlayerInfo *player, int mode)
13189 static unsigned int screen_frame_counter = 0;
13191 if (mode == SCROLL_INIT)
13193 // set scrolling step size according to actual player's moving speed
13194 ScrollStepSize = TILEX / player->move_delay_value;
13196 screen_frame_counter = FrameCounter;
13197 ScreenMovDir = player->MovDir;
13198 ScreenMovPos = player->MovPos;
13199 ScreenGfxPos = ScrollStepSize * (ScreenMovPos / ScrollStepSize);
13202 else if (!FrameReached(&screen_frame_counter, 1))
13207 ScreenMovPos += (ScreenMovPos > 0 ? -1 : 1) * ScrollStepSize;
13208 ScreenGfxPos = ScrollStepSize * (ScreenMovPos / ScrollStepSize);
13209 redraw_mask |= REDRAW_FIELD;
13212 ScreenMovDir = MV_NONE;
13215 void TestIfPlayerTouchesCustomElement(int x, int y)
13217 static int xy[4][2] =
13224 static int trigger_sides[4][2] =
13226 // center side border side
13227 { CH_SIDE_TOP, CH_SIDE_BOTTOM }, // check top
13228 { CH_SIDE_LEFT, CH_SIDE_RIGHT }, // check left
13229 { CH_SIDE_RIGHT, CH_SIDE_LEFT }, // check right
13230 { CH_SIDE_BOTTOM, CH_SIDE_TOP } // check bottom
13232 static int touch_dir[4] =
13234 MV_LEFT | MV_RIGHT,
13239 int center_element = Tile[x][y]; // should always be non-moving!
13242 for (i = 0; i < NUM_DIRECTIONS; i++)
13244 int xx = x + xy[i][0];
13245 int yy = y + xy[i][1];
13246 int center_side = trigger_sides[i][0];
13247 int border_side = trigger_sides[i][1];
13248 int border_element;
13250 if (!IN_LEV_FIELD(xx, yy))
13253 if (IS_PLAYER(x, y)) // player found at center element
13255 struct PlayerInfo *player = PLAYERINFO(x, y);
13257 if (game.engine_version < VERSION_IDENT(3,0,7,0))
13258 border_element = Tile[xx][yy]; // may be moving!
13259 else if (!IS_MOVING(xx, yy) && !IS_BLOCKED(xx, yy))
13260 border_element = Tile[xx][yy];
13261 else if (MovDir[xx][yy] & touch_dir[i]) // elements are touching
13262 border_element = MovingOrBlocked2Element(xx, yy);
13264 continue; // center and border element do not touch
13266 CheckElementChangeByPlayer(xx, yy, border_element, CE_TOUCHED_BY_PLAYER,
13267 player->index_bit, border_side);
13268 CheckTriggeredElementChangeByPlayer(xx, yy, border_element,
13269 CE_PLAYER_TOUCHES_X,
13270 player->index_bit, border_side);
13273 /* use player element that is initially defined in the level playfield,
13274 not the player element that corresponds to the runtime player number
13275 (example: a level that contains EL_PLAYER_3 as the only player would
13276 incorrectly give EL_PLAYER_1 for "player->element_nr") */
13277 int player_element = PLAYERINFO(x, y)->initial_element;
13279 CheckElementChangeBySide(xx, yy, border_element, player_element,
13280 CE_TOUCHING_X, border_side);
13283 else if (IS_PLAYER(xx, yy)) // player found at border element
13285 struct PlayerInfo *player = PLAYERINFO(xx, yy);
13287 if (game.engine_version >= VERSION_IDENT(3,0,7,0))
13289 if (player->MovPos != 0 && !(player->MovDir & touch_dir[i]))
13290 continue; // center and border element do not touch
13293 CheckElementChangeByPlayer(x, y, center_element, CE_TOUCHED_BY_PLAYER,
13294 player->index_bit, center_side);
13295 CheckTriggeredElementChangeByPlayer(x, y, center_element,
13296 CE_PLAYER_TOUCHES_X,
13297 player->index_bit, center_side);
13300 /* use player element that is initially defined in the level playfield,
13301 not the player element that corresponds to the runtime player number
13302 (example: a level that contains EL_PLAYER_3 as the only player would
13303 incorrectly give EL_PLAYER_1 for "player->element_nr") */
13304 int player_element = PLAYERINFO(xx, yy)->initial_element;
13306 CheckElementChangeBySide(x, y, center_element, player_element,
13307 CE_TOUCHING_X, center_side);
13315 void TestIfElementTouchesCustomElement(int x, int y)
13317 static int xy[4][2] =
13324 static int trigger_sides[4][2] =
13326 // center side border side
13327 { CH_SIDE_TOP, CH_SIDE_BOTTOM }, // check top
13328 { CH_SIDE_LEFT, CH_SIDE_RIGHT }, // check left
13329 { CH_SIDE_RIGHT, CH_SIDE_LEFT }, // check right
13330 { CH_SIDE_BOTTOM, CH_SIDE_TOP } // check bottom
13332 static int touch_dir[4] =
13334 MV_LEFT | MV_RIGHT,
13339 boolean change_center_element = FALSE;
13340 int center_element = Tile[x][y]; // should always be non-moving!
13341 int border_element_old[NUM_DIRECTIONS];
13344 for (i = 0; i < NUM_DIRECTIONS; i++)
13346 int xx = x + xy[i][0];
13347 int yy = y + xy[i][1];
13348 int border_element;
13350 border_element_old[i] = -1;
13352 if (!IN_LEV_FIELD(xx, yy))
13355 if (game.engine_version < VERSION_IDENT(3,0,7,0))
13356 border_element = Tile[xx][yy]; // may be moving!
13357 else if (!IS_MOVING(xx, yy) && !IS_BLOCKED(xx, yy))
13358 border_element = Tile[xx][yy];
13359 else if (MovDir[xx][yy] & touch_dir[i]) // elements are touching
13360 border_element = MovingOrBlocked2Element(xx, yy);
13362 continue; // center and border element do not touch
13364 border_element_old[i] = border_element;
13367 for (i = 0; i < NUM_DIRECTIONS; i++)
13369 int xx = x + xy[i][0];
13370 int yy = y + xy[i][1];
13371 int center_side = trigger_sides[i][0];
13372 int border_element = border_element_old[i];
13374 if (border_element == -1)
13377 // check for change of border element
13378 CheckElementChangeBySide(xx, yy, border_element, center_element,
13379 CE_TOUCHING_X, center_side);
13381 // (center element cannot be player, so we dont have to check this here)
13384 for (i = 0; i < NUM_DIRECTIONS; i++)
13386 int xx = x + xy[i][0];
13387 int yy = y + xy[i][1];
13388 int border_side = trigger_sides[i][1];
13389 int border_element = border_element_old[i];
13391 if (border_element == -1)
13394 // check for change of center element (but change it only once)
13395 if (!change_center_element)
13396 change_center_element =
13397 CheckElementChangeBySide(x, y, center_element, border_element,
13398 CE_TOUCHING_X, border_side);
13400 if (IS_PLAYER(xx, yy))
13402 /* use player element that is initially defined in the level playfield,
13403 not the player element that corresponds to the runtime player number
13404 (example: a level that contains EL_PLAYER_3 as the only player would
13405 incorrectly give EL_PLAYER_1 for "player->element_nr") */
13406 int player_element = PLAYERINFO(xx, yy)->initial_element;
13408 CheckElementChangeBySide(x, y, center_element, player_element,
13409 CE_TOUCHING_X, border_side);
13414 void TestIfElementHitsCustomElement(int x, int y, int direction)
13416 int dx = (direction == MV_LEFT ? -1 : direction == MV_RIGHT ? +1 : 0);
13417 int dy = (direction == MV_UP ? -1 : direction == MV_DOWN ? +1 : 0);
13418 int hitx = x + dx, hity = y + dy;
13419 int hitting_element = Tile[x][y];
13420 int touched_element;
13422 if (IN_LEV_FIELD(hitx, hity) && IS_FREE(hitx, hity))
13425 touched_element = (IN_LEV_FIELD(hitx, hity) ?
13426 MovingOrBlocked2Element(hitx, hity) : EL_STEELWALL);
13428 if (IN_LEV_FIELD(hitx, hity))
13430 int opposite_direction = MV_DIR_OPPOSITE(direction);
13431 int hitting_side = direction;
13432 int touched_side = opposite_direction;
13433 boolean object_hit = (!IS_MOVING(hitx, hity) ||
13434 MovDir[hitx][hity] != direction ||
13435 ABS(MovPos[hitx][hity]) <= TILEY / 2);
13441 CheckElementChangeBySide(x, y, hitting_element, touched_element,
13442 CE_HITTING_X, touched_side);
13444 CheckElementChangeBySide(hitx, hity, touched_element, hitting_element,
13445 CE_HIT_BY_X, hitting_side);
13447 CheckElementChangeBySide(hitx, hity, touched_element, hitting_element,
13448 CE_HIT_BY_SOMETHING, opposite_direction);
13450 if (IS_PLAYER(hitx, hity))
13452 /* use player element that is initially defined in the level playfield,
13453 not the player element that corresponds to the runtime player number
13454 (example: a level that contains EL_PLAYER_3 as the only player would
13455 incorrectly give EL_PLAYER_1 for "player->element_nr") */
13456 int player_element = PLAYERINFO(hitx, hity)->initial_element;
13458 CheckElementChangeBySide(x, y, hitting_element, player_element,
13459 CE_HITTING_X, touched_side);
13464 // "hitting something" is also true when hitting the playfield border
13465 CheckElementChangeBySide(x, y, hitting_element, touched_element,
13466 CE_HITTING_SOMETHING, direction);
13469 void TestIfGoodThingHitsBadThing(int good_x, int good_y, int good_move_dir)
13471 int i, kill_x = -1, kill_y = -1;
13473 int bad_element = -1;
13474 static int test_xy[4][2] =
13481 static int test_dir[4] =
13489 for (i = 0; i < NUM_DIRECTIONS; i++)
13491 int test_x, test_y, test_move_dir, test_element;
13493 test_x = good_x + test_xy[i][0];
13494 test_y = good_y + test_xy[i][1];
13496 if (!IN_LEV_FIELD(test_x, test_y))
13500 (IS_MOVING(test_x, test_y) ? MovDir[test_x][test_y] : MV_NONE);
13502 test_element = MovingOrBlocked2ElementIfNotLeaving(test_x, test_y);
13504 /* 1st case: good thing is moving towards DONT_RUN_INTO style bad thing;
13505 2nd case: DONT_TOUCH style bad thing does not move away from good thing
13507 if ((DONT_RUN_INTO(test_element) && good_move_dir == test_dir[i]) ||
13508 (DONT_TOUCH(test_element) && test_move_dir != test_dir[i]))
13512 bad_element = test_element;
13518 if (kill_x != -1 || kill_y != -1)
13520 if (IS_PLAYER(good_x, good_y))
13522 struct PlayerInfo *player = PLAYERINFO(good_x, good_y);
13524 if (player->shield_deadly_time_left > 0 &&
13525 !IS_INDESTRUCTIBLE(bad_element))
13526 Bang(kill_x, kill_y);
13527 else if (!PLAYER_ENEMY_PROTECTED(good_x, good_y))
13528 KillPlayer(player);
13531 Bang(good_x, good_y);
13535 void TestIfBadThingHitsGoodThing(int bad_x, int bad_y, int bad_move_dir)
13537 int i, kill_x = -1, kill_y = -1;
13538 int bad_element = Tile[bad_x][bad_y];
13539 static int test_xy[4][2] =
13546 static int touch_dir[4] =
13548 MV_LEFT | MV_RIGHT,
13553 static int test_dir[4] =
13561 if (bad_element == EL_EXPLOSION) // skip just exploding bad things
13564 for (i = 0; i < NUM_DIRECTIONS; i++)
13566 int test_x, test_y, test_move_dir, test_element;
13568 test_x = bad_x + test_xy[i][0];
13569 test_y = bad_y + test_xy[i][1];
13571 if (!IN_LEV_FIELD(test_x, test_y))
13575 (IS_MOVING(test_x, test_y) ? MovDir[test_x][test_y] : MV_NONE);
13577 test_element = Tile[test_x][test_y];
13579 /* 1st case: good thing is moving towards DONT_RUN_INTO style bad thing;
13580 2nd case: DONT_TOUCH style bad thing does not move away from good thing
13582 if ((DONT_RUN_INTO(bad_element) && bad_move_dir == test_dir[i]) ||
13583 (DONT_TOUCH(bad_element) && test_move_dir != test_dir[i]))
13585 // good thing is player or penguin that does not move away
13586 if (IS_PLAYER(test_x, test_y))
13588 struct PlayerInfo *player = PLAYERINFO(test_x, test_y);
13590 if (bad_element == EL_ROBOT && player->is_moving)
13591 continue; // robot does not kill player if he is moving
13593 if (game.engine_version >= VERSION_IDENT(3,0,7,0))
13595 if (player->MovPos != 0 && !(player->MovDir & touch_dir[i]))
13596 continue; // center and border element do not touch
13604 else if (test_element == EL_PENGUIN)
13614 if (kill_x != -1 || kill_y != -1)
13616 if (IS_PLAYER(kill_x, kill_y))
13618 struct PlayerInfo *player = PLAYERINFO(kill_x, kill_y);
13620 if (player->shield_deadly_time_left > 0 &&
13621 !IS_INDESTRUCTIBLE(bad_element))
13622 Bang(bad_x, bad_y);
13623 else if (!PLAYER_ENEMY_PROTECTED(kill_x, kill_y))
13624 KillPlayer(player);
13627 Bang(kill_x, kill_y);
13631 void TestIfGoodThingGetsHitByBadThing(int bad_x, int bad_y, int bad_move_dir)
13633 int bad_element = Tile[bad_x][bad_y];
13634 int dx = (bad_move_dir == MV_LEFT ? -1 : bad_move_dir == MV_RIGHT ? +1 : 0);
13635 int dy = (bad_move_dir == MV_UP ? -1 : bad_move_dir == MV_DOWN ? +1 : 0);
13636 int test_x = bad_x + dx, test_y = bad_y + dy;
13637 int test_move_dir, test_element;
13638 int kill_x = -1, kill_y = -1;
13640 if (!IN_LEV_FIELD(test_x, test_y))
13644 (IS_MOVING(test_x, test_y) ? MovDir[test_x][test_y] : MV_NONE);
13646 test_element = Tile[test_x][test_y];
13648 if (test_move_dir != bad_move_dir)
13650 // good thing can be player or penguin that does not move away
13651 if (IS_PLAYER(test_x, test_y))
13653 struct PlayerInfo *player = PLAYERINFO(test_x, test_y);
13655 /* (note: in comparison to DONT_RUN_TO and DONT_TOUCH, also handle the
13656 player as being hit when he is moving towards the bad thing, because
13657 the "get hit by" condition would be lost after the player stops) */
13658 if (player->MovPos != 0 && player->MovDir == bad_move_dir)
13659 return; // player moves away from bad thing
13664 else if (test_element == EL_PENGUIN)
13671 if (kill_x != -1 || kill_y != -1)
13673 if (IS_PLAYER(kill_x, kill_y))
13675 struct PlayerInfo *player = PLAYERINFO(kill_x, kill_y);
13677 if (player->shield_deadly_time_left > 0 &&
13678 !IS_INDESTRUCTIBLE(bad_element))
13679 Bang(bad_x, bad_y);
13680 else if (!PLAYER_ENEMY_PROTECTED(kill_x, kill_y))
13681 KillPlayer(player);
13684 Bang(kill_x, kill_y);
13688 void TestIfPlayerTouchesBadThing(int x, int y)
13690 TestIfGoodThingHitsBadThing(x, y, MV_NONE);
13693 void TestIfPlayerRunsIntoBadThing(int x, int y, int move_dir)
13695 TestIfGoodThingHitsBadThing(x, y, move_dir);
13698 void TestIfBadThingTouchesPlayer(int x, int y)
13700 TestIfBadThingHitsGoodThing(x, y, MV_NONE);
13703 void TestIfBadThingRunsIntoPlayer(int x, int y, int move_dir)
13705 TestIfBadThingHitsGoodThing(x, y, move_dir);
13708 void TestIfFriendTouchesBadThing(int x, int y)
13710 TestIfGoodThingHitsBadThing(x, y, MV_NONE);
13713 void TestIfBadThingTouchesFriend(int x, int y)
13715 TestIfBadThingHitsGoodThing(x, y, MV_NONE);
13718 void TestIfBadThingTouchesOtherBadThing(int bad_x, int bad_y)
13720 int i, kill_x = bad_x, kill_y = bad_y;
13721 static int xy[4][2] =
13729 for (i = 0; i < NUM_DIRECTIONS; i++)
13733 x = bad_x + xy[i][0];
13734 y = bad_y + xy[i][1];
13735 if (!IN_LEV_FIELD(x, y))
13738 element = Tile[x][y];
13739 if (IS_AMOEBOID(element) || element == EL_GAME_OF_LIFE ||
13740 element == EL_AMOEBA_GROWING || element == EL_AMOEBA_DROP)
13748 if (kill_x != bad_x || kill_y != bad_y)
13749 Bang(bad_x, bad_y);
13752 void KillPlayer(struct PlayerInfo *player)
13754 int jx = player->jx, jy = player->jy;
13756 if (!player->active)
13760 Debug("game:playing:KillPlayer",
13761 "0: killed == %d, active == %d, reanimated == %d",
13762 player->killed, player->active, player->reanimated);
13765 /* the following code was introduced to prevent an infinite loop when calling
13767 -> CheckTriggeredElementChangeExt()
13768 -> ExecuteCustomElementAction()
13770 -> (infinitely repeating the above sequence of function calls)
13771 which occurs when killing the player while having a CE with the setting
13772 "kill player X when explosion of <player X>"; the solution using a new
13773 field "player->killed" was chosen for backwards compatibility, although
13774 clever use of the fields "player->active" etc. would probably also work */
13776 if (player->killed)
13780 player->killed = TRUE;
13782 // remove accessible field at the player's position
13783 Tile[jx][jy] = EL_EMPTY;
13785 // deactivate shield (else Bang()/Explode() would not work right)
13786 player->shield_normal_time_left = 0;
13787 player->shield_deadly_time_left = 0;
13790 Debug("game:playing:KillPlayer",
13791 "1: killed == %d, active == %d, reanimated == %d",
13792 player->killed, player->active, player->reanimated);
13798 Debug("game:playing:KillPlayer",
13799 "2: killed == %d, active == %d, reanimated == %d",
13800 player->killed, player->active, player->reanimated);
13803 if (player->reanimated) // killed player may have been reanimated
13804 player->killed = player->reanimated = FALSE;
13806 BuryPlayer(player);
13809 static void KillPlayerUnlessEnemyProtected(int x, int y)
13811 if (!PLAYER_ENEMY_PROTECTED(x, y))
13812 KillPlayer(PLAYERINFO(x, y));
13815 static void KillPlayerUnlessExplosionProtected(int x, int y)
13817 if (!PLAYER_EXPLOSION_PROTECTED(x, y))
13818 KillPlayer(PLAYERINFO(x, y));
13821 void BuryPlayer(struct PlayerInfo *player)
13823 int jx = player->jx, jy = player->jy;
13825 if (!player->active)
13828 PlayLevelSoundElementAction(jx, jy, player->artwork_element, ACTION_DYING);
13829 PlayLevelSound(jx, jy, SND_GAME_LOSING);
13831 RemovePlayer(player);
13833 player->buried = TRUE;
13835 if (game.all_players_gone)
13836 game.GameOver = TRUE;
13839 void RemovePlayer(struct PlayerInfo *player)
13841 int jx = player->jx, jy = player->jy;
13842 int i, found = FALSE;
13844 player->present = FALSE;
13845 player->active = FALSE;
13847 // required for some CE actions (even if the player is not active anymore)
13848 player->MovPos = 0;
13850 if (!ExplodeField[jx][jy])
13851 StorePlayer[jx][jy] = 0;
13853 if (player->is_moving)
13854 TEST_DrawLevelField(player->last_jx, player->last_jy);
13856 for (i = 0; i < MAX_PLAYERS; i++)
13857 if (stored_player[i].active)
13862 game.all_players_gone = TRUE;
13863 game.GameOver = TRUE;
13866 game.exit_x = game.robot_wheel_x = jx;
13867 game.exit_y = game.robot_wheel_y = jy;
13870 void ExitPlayer(struct PlayerInfo *player)
13872 DrawPlayer(player); // needed here only to cleanup last field
13873 RemovePlayer(player);
13875 if (game.players_still_needed > 0)
13876 game.players_still_needed--;
13879 static void SetFieldForSnapping(int x, int y, int element, int direction,
13880 int player_index_bit)
13882 struct ElementInfo *ei = &element_info[element];
13883 int direction_bit = MV_DIR_TO_BIT(direction);
13884 int graphic_snapping = ei->direction_graphic[ACTION_SNAPPING][direction_bit];
13885 int action = (graphic_snapping != IMG_EMPTY_SPACE ? ACTION_SNAPPING :
13886 IS_DIGGABLE(element) ? ACTION_DIGGING : ACTION_COLLECTING);
13888 Tile[x][y] = EL_ELEMENT_SNAPPING;
13889 MovDelay[x][y] = MOVE_DELAY_NORMAL_SPEED + 1 - 1;
13890 MovDir[x][y] = direction;
13891 Store[x][y] = element;
13892 Store2[x][y] = player_index_bit;
13894 ResetGfxAnimation(x, y);
13896 GfxElement[x][y] = element;
13897 GfxAction[x][y] = action;
13898 GfxDir[x][y] = direction;
13899 GfxFrame[x][y] = -1;
13902 static void TestFieldAfterSnapping(int x, int y, int element, int direction,
13903 int player_index_bit)
13905 TestIfElementTouchesCustomElement(x, y); // for empty space
13907 if (level.finish_dig_collect)
13909 int dig_side = MV_DIR_OPPOSITE(direction);
13911 CheckTriggeredElementChangeByPlayer(x, y, element, CE_PLAYER_SNAPS_X,
13912 player_index_bit, dig_side);
13917 =============================================================================
13918 checkDiagonalPushing()
13919 -----------------------------------------------------------------------------
13920 check if diagonal input device direction results in pushing of object
13921 (by checking if the alternative direction is walkable, diggable, ...)
13922 =============================================================================
13925 static boolean checkDiagonalPushing(struct PlayerInfo *player,
13926 int x, int y, int real_dx, int real_dy)
13928 int jx, jy, dx, dy, xx, yy;
13930 if (real_dx == 0 || real_dy == 0) // no diagonal direction => push
13933 // diagonal direction: check alternative direction
13938 xx = jx + (dx == 0 ? real_dx : 0);
13939 yy = jy + (dy == 0 ? real_dy : 0);
13941 return (!IN_LEV_FIELD(xx, yy) || IS_SOLID_FOR_PUSHING(Tile[xx][yy]));
13945 =============================================================================
13947 -----------------------------------------------------------------------------
13948 x, y: field next to player (non-diagonal) to try to dig to
13949 real_dx, real_dy: direction as read from input device (can be diagonal)
13950 =============================================================================
13953 static int DigField(struct PlayerInfo *player,
13954 int oldx, int oldy, int x, int y,
13955 int real_dx, int real_dy, int mode)
13957 boolean is_player = (IS_PLAYER(oldx, oldy) || mode != DF_DIG);
13958 boolean player_was_pushing = player->is_pushing;
13959 boolean player_can_move = (!player->cannot_move && mode != DF_SNAP);
13960 boolean player_can_move_or_snap = (!player->cannot_move || mode == DF_SNAP);
13961 int jx = oldx, jy = oldy;
13962 int dx = x - jx, dy = y - jy;
13963 int nextx = x + dx, nexty = y + dy;
13964 int move_direction = (dx == -1 ? MV_LEFT :
13965 dx == +1 ? MV_RIGHT :
13967 dy == +1 ? MV_DOWN : MV_NONE);
13968 int opposite_direction = MV_DIR_OPPOSITE(move_direction);
13969 int dig_side = MV_DIR_OPPOSITE(move_direction);
13970 int old_element = Tile[jx][jy];
13971 int element = MovingOrBlocked2ElementIfNotLeaving(x, y);
13974 if (is_player) // function can also be called by EL_PENGUIN
13976 if (player->MovPos == 0)
13978 player->is_digging = FALSE;
13979 player->is_collecting = FALSE;
13982 if (player->MovPos == 0) // last pushing move finished
13983 player->is_pushing = FALSE;
13985 if (mode == DF_NO_PUSH) // player just stopped pushing
13987 player->is_switching = FALSE;
13988 player->push_delay = -1;
13990 return MP_NO_ACTION;
13994 if (IS_TUBE(Back[jx][jy]) && game.engine_version >= VERSION_IDENT(2,2,0,0))
13995 old_element = Back[jx][jy];
13997 // in case of element dropped at player position, check background
13998 else if (Back[jx][jy] != EL_EMPTY &&
13999 game.engine_version >= VERSION_IDENT(2,2,0,0))
14000 old_element = Back[jx][jy];
14002 if (IS_WALKABLE(old_element) && !ACCESS_FROM(old_element, move_direction))
14003 return MP_NO_ACTION; // field has no opening in this direction
14005 if (IS_PASSABLE(old_element) && !ACCESS_FROM(old_element,opposite_direction))
14006 return MP_NO_ACTION; // field has no opening in this direction
14008 if (player_can_move && element == EL_ACID && move_direction == MV_DOWN)
14012 Tile[jx][jy] = player->artwork_element;
14013 InitMovingField(jx, jy, MV_DOWN);
14014 Store[jx][jy] = EL_ACID;
14015 ContinueMoving(jx, jy);
14016 BuryPlayer(player);
14018 return MP_DONT_RUN_INTO;
14021 if (player_can_move && DONT_RUN_INTO(element))
14023 TestIfPlayerRunsIntoBadThing(jx, jy, player->MovDir);
14025 return MP_DONT_RUN_INTO;
14028 if (IS_MOVING(x, y) || IS_PLAYER(x, y))
14029 return MP_NO_ACTION;
14031 collect_count = element_info[element].collect_count_initial;
14033 if (!is_player && !IS_COLLECTIBLE(element)) // penguin cannot collect it
14034 return MP_NO_ACTION;
14036 if (game.engine_version < VERSION_IDENT(2,2,0,0))
14037 player_can_move = player_can_move_or_snap;
14039 if (mode == DF_SNAP && !IS_SNAPPABLE(element) &&
14040 game.engine_version >= VERSION_IDENT(2,2,0,0))
14042 CheckElementChangeByPlayer(x, y, element, CE_SNAPPED_BY_PLAYER,
14043 player->index_bit, dig_side);
14044 CheckTriggeredElementChangeByPlayer(x, y, element, CE_PLAYER_SNAPS_X,
14045 player->index_bit, dig_side);
14047 if (element == EL_DC_LANDMINE)
14050 if (Tile[x][y] != element) // field changed by snapping
14053 return MP_NO_ACTION;
14056 if (player->gravity && is_player && !player->is_auto_moving &&
14057 canFallDown(player) && move_direction != MV_DOWN &&
14058 !canMoveToValidFieldWithGravity(jx, jy, move_direction))
14059 return MP_NO_ACTION; // player cannot walk here due to gravity
14061 if (player_can_move &&
14062 IS_WALKABLE(element) && ACCESS_FROM(element, opposite_direction))
14064 int sound_element = SND_ELEMENT(element);
14065 int sound_action = ACTION_WALKING;
14067 if (IS_RND_GATE(element))
14069 if (!player->key[RND_GATE_NR(element)])
14070 return MP_NO_ACTION;
14072 else if (IS_RND_GATE_GRAY(element))
14074 if (!player->key[RND_GATE_GRAY_NR(element)])
14075 return MP_NO_ACTION;
14077 else if (IS_RND_GATE_GRAY_ACTIVE(element))
14079 if (!player->key[RND_GATE_GRAY_ACTIVE_NR(element)])
14080 return MP_NO_ACTION;
14082 else if (element == EL_EXIT_OPEN ||
14083 element == EL_EM_EXIT_OPEN ||
14084 element == EL_EM_EXIT_OPENING ||
14085 element == EL_STEEL_EXIT_OPEN ||
14086 element == EL_EM_STEEL_EXIT_OPEN ||
14087 element == EL_EM_STEEL_EXIT_OPENING ||
14088 element == EL_SP_EXIT_OPEN ||
14089 element == EL_SP_EXIT_OPENING)
14091 sound_action = ACTION_PASSING; // player is passing exit
14093 else if (element == EL_EMPTY)
14095 sound_action = ACTION_MOVING; // nothing to walk on
14098 // play sound from background or player, whatever is available
14099 if (element_info[sound_element].sound[sound_action] != SND_UNDEFINED)
14100 PlayLevelSoundElementAction(x, y, sound_element, sound_action);
14102 PlayLevelSoundElementAction(x, y, player->artwork_element, sound_action);
14104 else if (player_can_move &&
14105 IS_PASSABLE(element) && canPassField(x, y, move_direction))
14107 if (!ACCESS_FROM(element, opposite_direction))
14108 return MP_NO_ACTION; // field not accessible from this direction
14110 if (CAN_MOVE(element)) // only fixed elements can be passed!
14111 return MP_NO_ACTION;
14113 if (IS_EM_GATE(element))
14115 if (!player->key[EM_GATE_NR(element)])
14116 return MP_NO_ACTION;
14118 else if (IS_EM_GATE_GRAY(element))
14120 if (!player->key[EM_GATE_GRAY_NR(element)])
14121 return MP_NO_ACTION;
14123 else if (IS_EM_GATE_GRAY_ACTIVE(element))
14125 if (!player->key[EM_GATE_GRAY_ACTIVE_NR(element)])
14126 return MP_NO_ACTION;
14128 else if (IS_EMC_GATE(element))
14130 if (!player->key[EMC_GATE_NR(element)])
14131 return MP_NO_ACTION;
14133 else if (IS_EMC_GATE_GRAY(element))
14135 if (!player->key[EMC_GATE_GRAY_NR(element)])
14136 return MP_NO_ACTION;
14138 else if (IS_EMC_GATE_GRAY_ACTIVE(element))
14140 if (!player->key[EMC_GATE_GRAY_ACTIVE_NR(element)])
14141 return MP_NO_ACTION;
14143 else if (element == EL_DC_GATE_WHITE ||
14144 element == EL_DC_GATE_WHITE_GRAY ||
14145 element == EL_DC_GATE_WHITE_GRAY_ACTIVE)
14147 if (player->num_white_keys == 0)
14148 return MP_NO_ACTION;
14150 player->num_white_keys--;
14152 else if (IS_SP_PORT(element))
14154 if (element == EL_SP_GRAVITY_PORT_LEFT ||
14155 element == EL_SP_GRAVITY_PORT_RIGHT ||
14156 element == EL_SP_GRAVITY_PORT_UP ||
14157 element == EL_SP_GRAVITY_PORT_DOWN)
14158 player->gravity = !player->gravity;
14159 else if (element == EL_SP_GRAVITY_ON_PORT_LEFT ||
14160 element == EL_SP_GRAVITY_ON_PORT_RIGHT ||
14161 element == EL_SP_GRAVITY_ON_PORT_UP ||
14162 element == EL_SP_GRAVITY_ON_PORT_DOWN)
14163 player->gravity = TRUE;
14164 else if (element == EL_SP_GRAVITY_OFF_PORT_LEFT ||
14165 element == EL_SP_GRAVITY_OFF_PORT_RIGHT ||
14166 element == EL_SP_GRAVITY_OFF_PORT_UP ||
14167 element == EL_SP_GRAVITY_OFF_PORT_DOWN)
14168 player->gravity = FALSE;
14171 // automatically move to the next field with double speed
14172 player->programmed_action = move_direction;
14174 if (player->move_delay_reset_counter == 0)
14176 player->move_delay_reset_counter = 2; // two double speed steps
14178 DOUBLE_PLAYER_SPEED(player);
14181 PlayLevelSoundAction(x, y, ACTION_PASSING);
14183 else if (player_can_move_or_snap && IS_DIGGABLE(element))
14187 if (mode != DF_SNAP)
14189 GfxElement[x][y] = GFX_ELEMENT(element);
14190 player->is_digging = TRUE;
14193 PlayLevelSoundElementAction(x, y, element, ACTION_DIGGING);
14195 // use old behaviour for old levels (digging)
14196 if (!level.finish_dig_collect)
14198 CheckTriggeredElementChangeByPlayer(x, y, element, CE_PLAYER_DIGS_X,
14199 player->index_bit, dig_side);
14201 // if digging triggered player relocation, finish digging tile
14202 if (mode == DF_DIG && (player->jx != jx || player->jy != jy))
14203 SetFieldForSnapping(x, y, element, move_direction, player->index_bit);
14206 if (mode == DF_SNAP)
14208 if (level.block_snap_field)
14209 SetFieldForSnapping(x, y, element, move_direction, player->index_bit);
14211 TestFieldAfterSnapping(x, y, element, move_direction, player->index_bit);
14213 // use old behaviour for old levels (snapping)
14214 if (!level.finish_dig_collect)
14215 CheckTriggeredElementChangeByPlayer(x, y, element, CE_PLAYER_SNAPS_X,
14216 player->index_bit, dig_side);
14219 else if (player_can_move_or_snap && IS_COLLECTIBLE(element))
14223 if (is_player && mode != DF_SNAP)
14225 GfxElement[x][y] = element;
14226 player->is_collecting = TRUE;
14229 if (element == EL_SPEED_PILL)
14231 player->move_delay_value = MOVE_DELAY_HIGH_SPEED;
14233 else if (element == EL_EXTRA_TIME && level.time > 0)
14235 TimeLeft += level.extra_time;
14237 game_panel_controls[GAME_PANEL_TIME].value = TimeLeft;
14239 DisplayGameControlValues();
14241 else if (element == EL_SHIELD_NORMAL || element == EL_SHIELD_DEADLY)
14243 player->shield_normal_time_left += level.shield_normal_time;
14244 if (element == EL_SHIELD_DEADLY)
14245 player->shield_deadly_time_left += level.shield_deadly_time;
14247 else if (element == EL_DYNAMITE ||
14248 element == EL_EM_DYNAMITE ||
14249 element == EL_SP_DISK_RED)
14251 if (player->inventory_size < MAX_INVENTORY_SIZE)
14252 player->inventory_element[player->inventory_size++] = element;
14254 DrawGameDoorValues();
14256 else if (element == EL_DYNABOMB_INCREASE_NUMBER)
14258 player->dynabomb_count++;
14259 player->dynabombs_left++;
14261 else if (element == EL_DYNABOMB_INCREASE_SIZE)
14263 player->dynabomb_size++;
14265 else if (element == EL_DYNABOMB_INCREASE_POWER)
14267 player->dynabomb_xl = TRUE;
14269 else if (IS_KEY(element))
14271 player->key[KEY_NR(element)] = TRUE;
14273 DrawGameDoorValues();
14275 else if (element == EL_DC_KEY_WHITE)
14277 player->num_white_keys++;
14279 // display white keys?
14280 // DrawGameDoorValues();
14282 else if (IS_ENVELOPE(element))
14284 player->show_envelope = element;
14286 else if (element == EL_EMC_LENSES)
14288 game.lenses_time_left = level.lenses_time * FRAMES_PER_SECOND;
14290 RedrawAllInvisibleElementsForLenses();
14292 else if (element == EL_EMC_MAGNIFIER)
14294 game.magnify_time_left = level.magnify_time * FRAMES_PER_SECOND;
14296 RedrawAllInvisibleElementsForMagnifier();
14298 else if (IS_DROPPABLE(element) ||
14299 IS_THROWABLE(element)) // can be collected and dropped
14303 if (collect_count == 0)
14304 player->inventory_infinite_element = element;
14306 for (i = 0; i < collect_count; i++)
14307 if (player->inventory_size < MAX_INVENTORY_SIZE)
14308 player->inventory_element[player->inventory_size++] = element;
14310 DrawGameDoorValues();
14312 else if (collect_count > 0)
14314 game.gems_still_needed -= collect_count;
14315 if (game.gems_still_needed < 0)
14316 game.gems_still_needed = 0;
14318 game.snapshot.collected_item = TRUE;
14320 game_panel_controls[GAME_PANEL_GEMS].value = game.gems_still_needed;
14322 DisplayGameControlValues();
14325 RaiseScoreElement(element);
14326 PlayLevelSoundElementAction(x, y, element, ACTION_COLLECTING);
14328 // use old behaviour for old levels (collecting)
14329 if (!level.finish_dig_collect && is_player)
14331 CheckTriggeredElementChangeByPlayer(x, y, element, CE_PLAYER_COLLECTS_X,
14332 player->index_bit, dig_side);
14334 // if collecting triggered player relocation, finish collecting tile
14335 if (mode == DF_DIG && (player->jx != jx || player->jy != jy))
14336 SetFieldForSnapping(x, y, element, move_direction, player->index_bit);
14339 if (mode == DF_SNAP)
14341 if (level.block_snap_field)
14342 SetFieldForSnapping(x, y, element, move_direction, player->index_bit);
14344 TestFieldAfterSnapping(x, y, element, move_direction, player->index_bit);
14346 // use old behaviour for old levels (snapping)
14347 if (!level.finish_dig_collect)
14348 CheckTriggeredElementChangeByPlayer(x, y, element, CE_PLAYER_SNAPS_X,
14349 player->index_bit, dig_side);
14352 else if (player_can_move_or_snap && IS_PUSHABLE(element))
14354 if (mode == DF_SNAP && element != EL_BD_ROCK)
14355 return MP_NO_ACTION;
14357 if (CAN_FALL(element) && dy)
14358 return MP_NO_ACTION;
14360 if (CAN_FALL(element) && IN_LEV_FIELD(x, y + 1) && IS_FREE(x, y + 1) &&
14361 !(element == EL_SPRING && level.use_spring_bug))
14362 return MP_NO_ACTION;
14364 if (CAN_MOVE(element) && GET_MAX_MOVE_DELAY(element) == 0 &&
14365 ((move_direction & MV_VERTICAL &&
14366 ((element_info[element].move_pattern & MV_LEFT &&
14367 IN_LEV_FIELD(x - 1, y) && IS_FREE(x - 1, y)) ||
14368 (element_info[element].move_pattern & MV_RIGHT &&
14369 IN_LEV_FIELD(x + 1, y) && IS_FREE(x + 1, y)))) ||
14370 (move_direction & MV_HORIZONTAL &&
14371 ((element_info[element].move_pattern & MV_UP &&
14372 IN_LEV_FIELD(x, y - 1) && IS_FREE(x, y - 1)) ||
14373 (element_info[element].move_pattern & MV_DOWN &&
14374 IN_LEV_FIELD(x, y + 1) && IS_FREE(x, y + 1))))))
14375 return MP_NO_ACTION;
14377 // do not push elements already moving away faster than player
14378 if (CAN_MOVE(element) && MovDir[x][y] == move_direction &&
14379 ABS(getElementMoveStepsize(x, y)) > MOVE_STEPSIZE_NORMAL)
14380 return MP_NO_ACTION;
14382 if (game.engine_version >= VERSION_IDENT(3,1,0,0))
14384 if (player->push_delay_value == -1 || !player_was_pushing)
14385 player->push_delay_value = GET_NEW_PUSH_DELAY(element);
14387 else if (game.engine_version >= VERSION_IDENT(3,0,7,1))
14389 if (player->push_delay_value == -1)
14390 player->push_delay_value = GET_NEW_PUSH_DELAY(element);
14392 else if (game.engine_version >= VERSION_IDENT(2,2,0,7))
14394 if (!player->is_pushing)
14395 player->push_delay_value = GET_NEW_PUSH_DELAY(element);
14398 player->is_pushing = TRUE;
14399 player->is_active = TRUE;
14401 if (!(IN_LEV_FIELD(nextx, nexty) &&
14402 (IS_FREE(nextx, nexty) ||
14403 (IS_SB_ELEMENT(element) &&
14404 Tile[nextx][nexty] == EL_SOKOBAN_FIELD_EMPTY) ||
14405 (IS_CUSTOM_ELEMENT(element) &&
14406 CUSTOM_ELEMENT_CAN_ENTER_FIELD(element, nextx, nexty)))))
14407 return MP_NO_ACTION;
14409 if (!checkDiagonalPushing(player, x, y, real_dx, real_dy))
14410 return MP_NO_ACTION;
14412 if (player->push_delay == -1) // new pushing; restart delay
14413 player->push_delay = 0;
14415 if (player->push_delay < player->push_delay_value &&
14416 !(tape.playing && tape.file_version < FILE_VERSION_2_0) &&
14417 element != EL_SPRING && element != EL_BALLOON)
14419 // make sure that there is no move delay before next try to push
14420 if (game.engine_version >= VERSION_IDENT(3,0,7,1))
14421 player->move_delay = 0;
14423 return MP_NO_ACTION;
14426 if (IS_CUSTOM_ELEMENT(element) &&
14427 CUSTOM_ELEMENT_CAN_ENTER_FIELD(element, nextx, nexty))
14429 if (!DigFieldByCE(nextx, nexty, element))
14430 return MP_NO_ACTION;
14433 if (IS_SB_ELEMENT(element))
14435 boolean sokoban_task_solved = FALSE;
14437 if (element == EL_SOKOBAN_FIELD_FULL)
14439 Back[x][y] = EL_SOKOBAN_FIELD_EMPTY;
14441 IncrementSokobanFieldsNeeded();
14442 IncrementSokobanObjectsNeeded();
14445 if (Tile[nextx][nexty] == EL_SOKOBAN_FIELD_EMPTY)
14447 Back[nextx][nexty] = EL_SOKOBAN_FIELD_EMPTY;
14449 DecrementSokobanFieldsNeeded();
14450 DecrementSokobanObjectsNeeded();
14452 // sokoban object was pushed from empty field to sokoban field
14453 if (Back[x][y] == EL_EMPTY)
14454 sokoban_task_solved = TRUE;
14457 Tile[x][y] = EL_SOKOBAN_OBJECT;
14459 if (Back[x][y] == Back[nextx][nexty])
14460 PlayLevelSoundAction(x, y, ACTION_PUSHING);
14461 else if (Back[x][y] != 0)
14462 PlayLevelSoundElementAction(x, y, EL_SOKOBAN_FIELD_FULL,
14465 PlayLevelSoundElementAction(nextx, nexty, EL_SOKOBAN_FIELD_EMPTY,
14468 if (sokoban_task_solved &&
14469 game.sokoban_fields_still_needed == 0 &&
14470 game.sokoban_objects_still_needed == 0 &&
14471 (game.emulation == EMU_SOKOBAN || level.auto_exit_sokoban))
14473 game.players_still_needed = 0;
14477 PlayLevelSound(x, y, SND_GAME_SOKOBAN_SOLVING);
14481 PlayLevelSoundElementAction(x, y, element, ACTION_PUSHING);
14483 InitMovingField(x, y, move_direction);
14484 GfxAction[x][y] = ACTION_PUSHING;
14486 if (mode == DF_SNAP)
14487 ContinueMoving(x, y);
14489 MovPos[x][y] = (dx != 0 ? dx : dy);
14491 Pushed[x][y] = TRUE;
14492 Pushed[nextx][nexty] = TRUE;
14494 if (game.engine_version < VERSION_IDENT(2,2,0,7))
14495 player->push_delay_value = GET_NEW_PUSH_DELAY(element);
14497 player->push_delay_value = -1; // get new value later
14499 // check for element change _after_ element has been pushed
14500 if (game.use_change_when_pushing_bug)
14502 CheckElementChangeByPlayer(x, y, element, CE_PUSHED_BY_PLAYER,
14503 player->index_bit, dig_side);
14504 CheckTriggeredElementChangeByPlayer(x, y, element, CE_PLAYER_PUSHES_X,
14505 player->index_bit, dig_side);
14508 else if (IS_SWITCHABLE(element))
14510 if (PLAYER_SWITCHING(player, x, y))
14512 CheckTriggeredElementChangeByPlayer(x, y, element, CE_PLAYER_PRESSES_X,
14513 player->index_bit, dig_side);
14518 player->is_switching = TRUE;
14519 player->switch_x = x;
14520 player->switch_y = y;
14522 PlayLevelSoundElementAction(x, y, element, ACTION_ACTIVATING);
14524 if (element == EL_ROBOT_WHEEL)
14526 Tile[x][y] = EL_ROBOT_WHEEL_ACTIVE;
14528 game.robot_wheel_x = x;
14529 game.robot_wheel_y = y;
14530 game.robot_wheel_active = TRUE;
14532 TEST_DrawLevelField(x, y);
14534 else if (element == EL_SP_TERMINAL)
14538 SCAN_PLAYFIELD(xx, yy)
14540 if (Tile[xx][yy] == EL_SP_DISK_YELLOW)
14544 else if (Tile[xx][yy] == EL_SP_TERMINAL)
14546 Tile[xx][yy] = EL_SP_TERMINAL_ACTIVE;
14548 ResetGfxAnimation(xx, yy);
14549 TEST_DrawLevelField(xx, yy);
14553 else if (IS_BELT_SWITCH(element))
14555 ToggleBeltSwitch(x, y);
14557 else if (element == EL_SWITCHGATE_SWITCH_UP ||
14558 element == EL_SWITCHGATE_SWITCH_DOWN ||
14559 element == EL_DC_SWITCHGATE_SWITCH_UP ||
14560 element == EL_DC_SWITCHGATE_SWITCH_DOWN)
14562 ToggleSwitchgateSwitch(x, y);
14564 else if (element == EL_LIGHT_SWITCH ||
14565 element == EL_LIGHT_SWITCH_ACTIVE)
14567 ToggleLightSwitch(x, y);
14569 else if (element == EL_TIMEGATE_SWITCH ||
14570 element == EL_DC_TIMEGATE_SWITCH)
14572 ActivateTimegateSwitch(x, y);
14574 else if (element == EL_BALLOON_SWITCH_LEFT ||
14575 element == EL_BALLOON_SWITCH_RIGHT ||
14576 element == EL_BALLOON_SWITCH_UP ||
14577 element == EL_BALLOON_SWITCH_DOWN ||
14578 element == EL_BALLOON_SWITCH_NONE ||
14579 element == EL_BALLOON_SWITCH_ANY)
14581 game.wind_direction = (element == EL_BALLOON_SWITCH_LEFT ? MV_LEFT :
14582 element == EL_BALLOON_SWITCH_RIGHT ? MV_RIGHT :
14583 element == EL_BALLOON_SWITCH_UP ? MV_UP :
14584 element == EL_BALLOON_SWITCH_DOWN ? MV_DOWN :
14585 element == EL_BALLOON_SWITCH_NONE ? MV_NONE :
14588 else if (element == EL_LAMP)
14590 Tile[x][y] = EL_LAMP_ACTIVE;
14591 game.lights_still_needed--;
14593 ResetGfxAnimation(x, y);
14594 TEST_DrawLevelField(x, y);
14596 else if (element == EL_TIME_ORB_FULL)
14598 Tile[x][y] = EL_TIME_ORB_EMPTY;
14600 if (level.time > 0 || level.use_time_orb_bug)
14602 TimeLeft += level.time_orb_time;
14603 game.no_time_limit = FALSE;
14605 game_panel_controls[GAME_PANEL_TIME].value = TimeLeft;
14607 DisplayGameControlValues();
14610 ResetGfxAnimation(x, y);
14611 TEST_DrawLevelField(x, y);
14613 else if (element == EL_EMC_MAGIC_BALL_SWITCH ||
14614 element == EL_EMC_MAGIC_BALL_SWITCH_ACTIVE)
14618 game.ball_active = !game.ball_active;
14620 SCAN_PLAYFIELD(xx, yy)
14622 int e = Tile[xx][yy];
14624 if (game.ball_active)
14626 if (e == EL_EMC_MAGIC_BALL)
14627 CreateField(xx, yy, EL_EMC_MAGIC_BALL_ACTIVE);
14628 else if (e == EL_EMC_MAGIC_BALL_SWITCH)
14629 CreateField(xx, yy, EL_EMC_MAGIC_BALL_SWITCH_ACTIVE);
14633 if (e == EL_EMC_MAGIC_BALL_ACTIVE)
14634 CreateField(xx, yy, EL_EMC_MAGIC_BALL);
14635 else if (e == EL_EMC_MAGIC_BALL_SWITCH_ACTIVE)
14636 CreateField(xx, yy, EL_EMC_MAGIC_BALL_SWITCH);
14641 CheckTriggeredElementChangeByPlayer(x, y, element, CE_SWITCH_OF_X,
14642 player->index_bit, dig_side);
14644 CheckTriggeredElementChangeByPlayer(x, y, element, CE_PLAYER_SWITCHES_X,
14645 player->index_bit, dig_side);
14647 CheckTriggeredElementChangeByPlayer(x, y, element, CE_PLAYER_PRESSES_X,
14648 player->index_bit, dig_side);
14654 if (!PLAYER_SWITCHING(player, x, y))
14656 player->is_switching = TRUE;
14657 player->switch_x = x;
14658 player->switch_y = y;
14660 CheckElementChangeByPlayer(x, y, element, CE_SWITCHED,
14661 player->index_bit, dig_side);
14662 CheckTriggeredElementChangeByPlayer(x, y, element, CE_SWITCH_OF_X,
14663 player->index_bit, dig_side);
14665 CheckElementChangeByPlayer(x, y, element, CE_SWITCHED_BY_PLAYER,
14666 player->index_bit, dig_side);
14667 CheckTriggeredElementChangeByPlayer(x, y, element, CE_PLAYER_SWITCHES_X,
14668 player->index_bit, dig_side);
14671 CheckElementChangeByPlayer(x, y, element, CE_PRESSED_BY_PLAYER,
14672 player->index_bit, dig_side);
14673 CheckTriggeredElementChangeByPlayer(x, y, element, CE_PLAYER_PRESSES_X,
14674 player->index_bit, dig_side);
14676 return MP_NO_ACTION;
14679 player->push_delay = -1;
14681 if (is_player) // function can also be called by EL_PENGUIN
14683 if (Tile[x][y] != element) // really digged/collected something
14685 player->is_collecting = !player->is_digging;
14686 player->is_active = TRUE;
14688 player->last_removed_element = element;
14695 static boolean DigFieldByCE(int x, int y, int digging_element)
14697 int element = Tile[x][y];
14699 if (!IS_FREE(x, y))
14701 int action = (IS_DIGGABLE(element) ? ACTION_DIGGING :
14702 IS_COLLECTIBLE(element) ? ACTION_COLLECTING :
14705 // no element can dig solid indestructible elements
14706 if (IS_INDESTRUCTIBLE(element) &&
14707 !IS_DIGGABLE(element) &&
14708 !IS_COLLECTIBLE(element))
14711 if (AmoebaNr[x][y] &&
14712 (element == EL_AMOEBA_FULL ||
14713 element == EL_BD_AMOEBA ||
14714 element == EL_AMOEBA_GROWING))
14716 AmoebaCnt[AmoebaNr[x][y]]--;
14717 AmoebaCnt2[AmoebaNr[x][y]]--;
14720 if (IS_MOVING(x, y))
14721 RemoveMovingField(x, y);
14725 TEST_DrawLevelField(x, y);
14728 // if digged element was about to explode, prevent the explosion
14729 ExplodeField[x][y] = EX_TYPE_NONE;
14731 PlayLevelSoundAction(x, y, action);
14734 Store[x][y] = EL_EMPTY;
14736 // this makes it possible to leave the removed element again
14737 if (IS_EQUAL_OR_IN_GROUP(element, MOVE_ENTER_EL(digging_element)))
14738 Store[x][y] = element;
14743 static boolean SnapField(struct PlayerInfo *player, int dx, int dy)
14745 int jx = player->jx, jy = player->jy;
14746 int x = jx + dx, y = jy + dy;
14747 int snap_direction = (dx == -1 ? MV_LEFT :
14748 dx == +1 ? MV_RIGHT :
14750 dy == +1 ? MV_DOWN : MV_NONE);
14751 boolean can_continue_snapping = (level.continuous_snapping &&
14752 WasJustFalling[x][y] < CHECK_DELAY_FALLING);
14754 if (player->MovPos != 0 && game.engine_version >= VERSION_IDENT(2,2,0,0))
14757 if (!player->active || !IN_LEV_FIELD(x, y))
14765 if (player->MovPos == 0)
14766 player->is_pushing = FALSE;
14768 player->is_snapping = FALSE;
14770 if (player->MovPos == 0)
14772 player->is_moving = FALSE;
14773 player->is_digging = FALSE;
14774 player->is_collecting = FALSE;
14780 // prevent snapping with already pressed snap key when not allowed
14781 if (player->is_snapping && !can_continue_snapping)
14784 player->MovDir = snap_direction;
14786 if (player->MovPos == 0)
14788 player->is_moving = FALSE;
14789 player->is_digging = FALSE;
14790 player->is_collecting = FALSE;
14793 player->is_dropping = FALSE;
14794 player->is_dropping_pressed = FALSE;
14795 player->drop_pressed_delay = 0;
14797 if (DigField(player, jx, jy, x, y, 0, 0, DF_SNAP) == MP_NO_ACTION)
14800 player->is_snapping = TRUE;
14801 player->is_active = TRUE;
14803 if (player->MovPos == 0)
14805 player->is_moving = FALSE;
14806 player->is_digging = FALSE;
14807 player->is_collecting = FALSE;
14810 if (player->MovPos != 0) // prevent graphic bugs in versions < 2.2.0
14811 TEST_DrawLevelField(player->last_jx, player->last_jy);
14813 TEST_DrawLevelField(x, y);
14818 static boolean DropElement(struct PlayerInfo *player)
14820 int old_element, new_element;
14821 int dropx = player->jx, dropy = player->jy;
14822 int drop_direction = player->MovDir;
14823 int drop_side = drop_direction;
14824 int drop_element = get_next_dropped_element(player);
14826 /* do not drop an element on top of another element; when holding drop key
14827 pressed without moving, dropped element must move away before the next
14828 element can be dropped (this is especially important if the next element
14829 is dynamite, which can be placed on background for historical reasons) */
14830 if (PLAYER_DROPPING(player, dropx, dropy) && Tile[dropx][dropy] != EL_EMPTY)
14833 if (IS_THROWABLE(drop_element))
14835 dropx += GET_DX_FROM_DIR(drop_direction);
14836 dropy += GET_DY_FROM_DIR(drop_direction);
14838 if (!IN_LEV_FIELD(dropx, dropy))
14842 old_element = Tile[dropx][dropy]; // old element at dropping position
14843 new_element = drop_element; // default: no change when dropping
14845 // check if player is active, not moving and ready to drop
14846 if (!player->active || player->MovPos || player->drop_delay > 0)
14849 // check if player has anything that can be dropped
14850 if (new_element == EL_UNDEFINED)
14853 // only set if player has anything that can be dropped
14854 player->is_dropping_pressed = TRUE;
14856 // check if drop key was pressed long enough for EM style dynamite
14857 if (new_element == EL_EM_DYNAMITE && player->drop_pressed_delay < 40)
14860 // check if anything can be dropped at the current position
14861 if (IS_ACTIVE_BOMB(old_element) || old_element == EL_EXPLOSION)
14864 // collected custom elements can only be dropped on empty fields
14865 if (IS_CUSTOM_ELEMENT(new_element) && old_element != EL_EMPTY)
14868 if (old_element != EL_EMPTY)
14869 Back[dropx][dropy] = old_element; // store old element on this field
14871 ResetGfxAnimation(dropx, dropy);
14872 ResetRandomAnimationValue(dropx, dropy);
14874 if (player->inventory_size > 0 ||
14875 player->inventory_infinite_element != EL_UNDEFINED)
14877 if (player->inventory_size > 0)
14879 player->inventory_size--;
14881 DrawGameDoorValues();
14883 if (new_element == EL_DYNAMITE)
14884 new_element = EL_DYNAMITE_ACTIVE;
14885 else if (new_element == EL_EM_DYNAMITE)
14886 new_element = EL_EM_DYNAMITE_ACTIVE;
14887 else if (new_element == EL_SP_DISK_RED)
14888 new_element = EL_SP_DISK_RED_ACTIVE;
14891 Tile[dropx][dropy] = new_element;
14893 if (IN_SCR_FIELD(SCREENX(dropx), SCREENY(dropy)))
14894 DrawGraphicThruMask(SCREENX(dropx), SCREENY(dropy),
14895 el2img(Tile[dropx][dropy]), 0);
14897 PlayLevelSoundAction(dropx, dropy, ACTION_DROPPING);
14899 // needed if previous element just changed to "empty" in the last frame
14900 ChangeCount[dropx][dropy] = 0; // allow at least one more change
14902 CheckElementChangeByPlayer(dropx, dropy, new_element, CE_DROPPED_BY_PLAYER,
14903 player->index_bit, drop_side);
14904 CheckTriggeredElementChangeByPlayer(dropx, dropy, new_element,
14906 player->index_bit, drop_side);
14908 TestIfElementTouchesCustomElement(dropx, dropy);
14910 else // player is dropping a dyna bomb
14912 player->dynabombs_left--;
14914 Tile[dropx][dropy] = new_element;
14916 if (IN_SCR_FIELD(SCREENX(dropx), SCREENY(dropy)))
14917 DrawGraphicThruMask(SCREENX(dropx), SCREENY(dropy),
14918 el2img(Tile[dropx][dropy]), 0);
14920 PlayLevelSoundAction(dropx, dropy, ACTION_DROPPING);
14923 if (Tile[dropx][dropy] == new_element) // uninitialized unless CE change
14924 InitField_WithBug1(dropx, dropy, FALSE);
14926 new_element = Tile[dropx][dropy]; // element might have changed
14928 if (IS_CUSTOM_ELEMENT(new_element) && CAN_MOVE(new_element) &&
14929 element_info[new_element].move_pattern == MV_WHEN_DROPPED)
14931 if (element_info[new_element].move_direction_initial == MV_START_AUTOMATIC)
14932 MovDir[dropx][dropy] = drop_direction;
14934 ChangeCount[dropx][dropy] = 0; // allow at least one more change
14936 // do not cause impact style collision by dropping elements that can fall
14937 CheckCollision[dropx][dropy] = CHECK_DELAY_COLLISION;
14940 player->drop_delay = GET_NEW_DROP_DELAY(drop_element);
14941 player->is_dropping = TRUE;
14943 player->drop_pressed_delay = 0;
14944 player->is_dropping_pressed = FALSE;
14946 player->drop_x = dropx;
14947 player->drop_y = dropy;
14952 // ----------------------------------------------------------------------------
14953 // game sound playing functions
14954 // ----------------------------------------------------------------------------
14956 static int *loop_sound_frame = NULL;
14957 static int *loop_sound_volume = NULL;
14959 void InitPlayLevelSound(void)
14961 int num_sounds = getSoundListSize();
14963 checked_free(loop_sound_frame);
14964 checked_free(loop_sound_volume);
14966 loop_sound_frame = checked_calloc(num_sounds * sizeof(int));
14967 loop_sound_volume = checked_calloc(num_sounds * sizeof(int));
14970 static void PlayLevelSound(int x, int y, int nr)
14972 int sx = SCREENX(x), sy = SCREENY(y);
14973 int volume, stereo_position;
14974 int max_distance = 8;
14975 int type = (IS_LOOP_SOUND(nr) ? SND_CTRL_PLAY_LOOP : SND_CTRL_PLAY_SOUND);
14977 if ((!setup.sound_simple && !IS_LOOP_SOUND(nr)) ||
14978 (!setup.sound_loops && IS_LOOP_SOUND(nr)))
14981 if (!IN_LEV_FIELD(x, y) ||
14982 sx < -max_distance || sx >= SCR_FIELDX + max_distance ||
14983 sy < -max_distance || sy >= SCR_FIELDY + max_distance)
14986 volume = SOUND_MAX_VOLUME;
14988 if (!IN_SCR_FIELD(sx, sy))
14990 int dx = ABS(sx - SCR_FIELDX / 2) - SCR_FIELDX / 2;
14991 int dy = ABS(sy - SCR_FIELDY / 2) - SCR_FIELDY / 2;
14993 volume -= volume * (dx > dy ? dx : dy) / max_distance;
14996 stereo_position = (SOUND_MAX_LEFT +
14997 (sx + max_distance) * SOUND_MAX_LEFT2RIGHT /
14998 (SCR_FIELDX + 2 * max_distance));
15000 if (IS_LOOP_SOUND(nr))
15002 /* This assures that quieter loop sounds do not overwrite louder ones,
15003 while restarting sound volume comparison with each new game frame. */
15005 if (loop_sound_volume[nr] > volume && loop_sound_frame[nr] == FrameCounter)
15008 loop_sound_volume[nr] = volume;
15009 loop_sound_frame[nr] = FrameCounter;
15012 PlaySoundExt(nr, volume, stereo_position, type);
15015 static void PlayLevelSoundNearest(int x, int y, int sound_action)
15017 PlayLevelSound(x < LEVELX(BX1) ? LEVELX(BX1) :
15018 x > LEVELX(BX2) ? LEVELX(BX2) : x,
15019 y < LEVELY(BY1) ? LEVELY(BY1) :
15020 y > LEVELY(BY2) ? LEVELY(BY2) : y,
15024 static void PlayLevelSoundAction(int x, int y, int action)
15026 PlayLevelSoundElementAction(x, y, Tile[x][y], action);
15029 static void PlayLevelSoundElementAction(int x, int y, int element, int action)
15031 int sound_effect = element_info[SND_ELEMENT(element)].sound[action];
15033 if (sound_effect != SND_UNDEFINED)
15034 PlayLevelSound(x, y, sound_effect);
15037 static void PlayLevelSoundElementActionIfLoop(int x, int y, int element,
15040 int sound_effect = element_info[SND_ELEMENT(element)].sound[action];
15042 if (sound_effect != SND_UNDEFINED && IS_LOOP_SOUND(sound_effect))
15043 PlayLevelSound(x, y, sound_effect);
15046 static void PlayLevelSoundActionIfLoop(int x, int y, int action)
15048 int sound_effect = element_info[SND_ELEMENT(Tile[x][y])].sound[action];
15050 if (sound_effect != SND_UNDEFINED && IS_LOOP_SOUND(sound_effect))
15051 PlayLevelSound(x, y, sound_effect);
15054 static void StopLevelSoundActionIfLoop(int x, int y, int action)
15056 int sound_effect = element_info[SND_ELEMENT(Tile[x][y])].sound[action];
15058 if (sound_effect != SND_UNDEFINED && IS_LOOP_SOUND(sound_effect))
15059 StopSound(sound_effect);
15062 static int getLevelMusicNr(void)
15064 if (levelset.music[level_nr] != MUS_UNDEFINED)
15065 return levelset.music[level_nr]; // from config file
15067 return MAP_NOCONF_MUSIC(level_nr); // from music dir
15070 static void FadeLevelSounds(void)
15075 static void FadeLevelMusic(void)
15077 int music_nr = getLevelMusicNr();
15078 char *curr_music = getCurrentlyPlayingMusicFilename();
15079 char *next_music = getMusicInfoEntryFilename(music_nr);
15081 if (!strEqual(curr_music, next_music))
15085 void FadeLevelSoundsAndMusic(void)
15091 static void PlayLevelMusic(void)
15093 int music_nr = getLevelMusicNr();
15094 char *curr_music = getCurrentlyPlayingMusicFilename();
15095 char *next_music = getMusicInfoEntryFilename(music_nr);
15097 if (!strEqual(curr_music, next_music))
15098 PlayMusicLoop(music_nr);
15101 void PlayLevelSound_EM(int xx, int yy, int element_em, int sample)
15103 int element = (element_em > -1 ? map_element_EM_to_RND_game(element_em) : 0);
15105 int x = xx - offset;
15106 int y = yy - offset;
15111 PlayLevelSoundElementAction(x, y, element, ACTION_WALKING);
15115 PlayLevelSoundElementAction(x, y, element, ACTION_PUSHING);
15119 PlayLevelSoundElementAction(x, y, element, ACTION_IMPACT);
15123 PlayLevelSoundElementAction(x, y, element, ACTION_IMPACT);
15127 PlayLevelSoundElementAction(x, y, element, ACTION_BREAKING);
15131 PlayLevelSoundElementAction(x, y, element, ACTION_MOVING);
15135 PlayLevelSoundElementAction(x, y, element, ACTION_MOVING);
15138 case SOUND_android_clone:
15139 PlayLevelSoundElementAction(x, y, element, ACTION_DROPPING);
15142 case SOUND_android_move:
15143 PlayLevelSoundElementAction(x, y, element, ACTION_MOVING);
15147 PlayLevelSoundElementAction(x, y, element, ACTION_IMPACT);
15151 PlayLevelSoundElementAction(x, y, element, ACTION_EATING);
15155 PlayLevelSoundElementAction(x, y, element, ACTION_WAITING);
15158 case SOUND_eater_eat:
15159 PlayLevelSoundElementAction(x, y, element, ACTION_DIGGING);
15163 PlayLevelSoundElementAction(x, y, element, ACTION_MOVING);
15166 case SOUND_collect:
15167 PlayLevelSoundElementAction(x, y, element, ACTION_COLLECTING);
15170 case SOUND_diamond:
15171 PlayLevelSoundElementAction(x, y, element, ACTION_IMPACT);
15175 // !!! CHECK THIS !!!
15177 PlayLevelSoundElementAction(x, y, element, ACTION_BREAKING);
15179 PlayLevelSoundElementAction(x, y, element, ACTION_SMASHED_BY_ROCK);
15183 case SOUND_wonderfall:
15184 PlayLevelSoundElementAction(x, y, element, ACTION_FILLING);
15188 PlayLevelSoundElementAction(x, y, element, ACTION_IMPACT);
15192 PlayLevelSoundElementAction(x, y, element, ACTION_PUSHING);
15196 PlayLevelSoundElementAction(x, y, element, ACTION_DIGGING);
15200 PlayLevelSoundElementAction(x, y, element, ACTION_SPLASHING);
15204 PlayLevelSoundElementAction(x, y, element, ACTION_DROPPING);
15208 PlayLevelSoundElementAction(x, y, element, ACTION_GROWING);
15212 PlayLevelSoundElementAction(x, y, element, ACTION_ACTIVE);
15216 PlayLevelSoundElementAction(x, y, element, ACTION_PASSING);
15219 case SOUND_exit_open:
15220 PlayLevelSoundElementAction(x, y, element, ACTION_OPENING);
15223 case SOUND_exit_leave:
15224 PlayLevelSoundElementAction(x, y, element, ACTION_PASSING);
15227 case SOUND_dynamite:
15228 PlayLevelSoundElementAction(x, y, element, ACTION_DROPPING);
15232 PlayLevelSoundElementAction(x, y, element, ACTION_ACTIVE);
15236 PlayLevelSoundElementAction(x, y, element, ACTION_ACTIVATING);
15240 PlayLevelSoundElementAction(x, y, element, ACTION_ACTIVE);
15244 PlayLevelSoundElementAction(x, y, element, ACTION_EXPLODING);
15248 PlayLevelSoundElementAction(x, y, element, ACTION_DYING);
15252 PlaySound(SND_GAME_RUNNING_OUT_OF_TIME);
15256 PlayLevelSoundElementAction(x, y, element, ACTION_DEFAULT);
15261 void PlayLevelSound_SP(int xx, int yy, int element_sp, int action_sp)
15263 int element = map_element_SP_to_RND(element_sp);
15264 int action = map_action_SP_to_RND(action_sp);
15265 int offset = (setup.sp_show_border_elements ? 0 : 1);
15266 int x = xx - offset;
15267 int y = yy - offset;
15269 PlayLevelSoundElementAction(x, y, element, action);
15272 void PlayLevelSound_MM(int xx, int yy, int element_mm, int action_mm)
15274 int element = map_element_MM_to_RND(element_mm);
15275 int action = map_action_MM_to_RND(action_mm);
15277 int x = xx - offset;
15278 int y = yy - offset;
15280 if (!IS_MM_ELEMENT(element))
15281 element = EL_MM_DEFAULT;
15283 PlayLevelSoundElementAction(x, y, element, action);
15286 void PlaySound_MM(int sound_mm)
15288 int sound = map_sound_MM_to_RND(sound_mm);
15290 if (sound == SND_UNDEFINED)
15296 void PlaySoundLoop_MM(int sound_mm)
15298 int sound = map_sound_MM_to_RND(sound_mm);
15300 if (sound == SND_UNDEFINED)
15303 PlaySoundLoop(sound);
15306 void StopSound_MM(int sound_mm)
15308 int sound = map_sound_MM_to_RND(sound_mm);
15310 if (sound == SND_UNDEFINED)
15316 void RaiseScore(int value)
15318 game.score += value;
15320 game_panel_controls[GAME_PANEL_SCORE].value = game.score;
15322 DisplayGameControlValues();
15325 void RaiseScoreElement(int element)
15330 case EL_BD_DIAMOND:
15331 case EL_EMERALD_YELLOW:
15332 case EL_EMERALD_RED:
15333 case EL_EMERALD_PURPLE:
15334 case EL_SP_INFOTRON:
15335 RaiseScore(level.score[SC_EMERALD]);
15338 RaiseScore(level.score[SC_DIAMOND]);
15341 RaiseScore(level.score[SC_CRYSTAL]);
15344 RaiseScore(level.score[SC_PEARL]);
15347 case EL_BD_BUTTERFLY:
15348 case EL_SP_ELECTRON:
15349 RaiseScore(level.score[SC_BUG]);
15352 case EL_BD_FIREFLY:
15353 case EL_SP_SNIKSNAK:
15354 RaiseScore(level.score[SC_SPACESHIP]);
15357 case EL_DARK_YAMYAM:
15358 RaiseScore(level.score[SC_YAMYAM]);
15361 RaiseScore(level.score[SC_ROBOT]);
15364 RaiseScore(level.score[SC_PACMAN]);
15367 RaiseScore(level.score[SC_NUT]);
15370 case EL_EM_DYNAMITE:
15371 case EL_SP_DISK_RED:
15372 case EL_DYNABOMB_INCREASE_NUMBER:
15373 case EL_DYNABOMB_INCREASE_SIZE:
15374 case EL_DYNABOMB_INCREASE_POWER:
15375 RaiseScore(level.score[SC_DYNAMITE]);
15377 case EL_SHIELD_NORMAL:
15378 case EL_SHIELD_DEADLY:
15379 RaiseScore(level.score[SC_SHIELD]);
15381 case EL_EXTRA_TIME:
15382 RaiseScore(level.extra_time_score);
15396 case EL_DC_KEY_WHITE:
15397 RaiseScore(level.score[SC_KEY]);
15400 RaiseScore(element_info[element].collect_score);
15405 void RequestQuitGameExt(boolean skip_request, boolean quick_quit, char *message)
15407 if (skip_request || Request(message, REQ_ASK | REQ_STAY_CLOSED))
15411 // prevent short reactivation of overlay buttons while closing door
15412 SetOverlayActive(FALSE);
15414 // door may still be open due to skipped or envelope style request
15415 CloseDoor(DOOR_CLOSE_1);
15418 if (network.enabled)
15419 SendToServer_StopPlaying(NETWORK_STOP_BY_PLAYER);
15423 FadeSkipNextFadeIn();
15425 SetGameStatus(GAME_MODE_MAIN);
15430 else // continue playing the game
15432 if (tape.playing && tape.deactivate_display)
15433 TapeDeactivateDisplayOff(TRUE);
15435 OpenDoor(DOOR_OPEN_1 | DOOR_COPY_BACK);
15437 if (tape.playing && tape.deactivate_display)
15438 TapeDeactivateDisplayOn();
15442 void RequestQuitGame(boolean escape_key_pressed)
15444 boolean ask_on_escape = (setup.ask_on_escape && setup.ask_on_quit_game);
15445 boolean quick_quit = ((escape_key_pressed && !ask_on_escape) ||
15446 level_editor_test_game);
15447 boolean skip_request = (game.all_players_gone || !setup.ask_on_quit_game ||
15450 RequestQuitGameExt(skip_request, quick_quit,
15451 "Do you really want to quit the game?");
15454 void RequestRestartGame(char *message)
15456 game.restart_game_message = NULL;
15458 boolean has_started_game = hasStartedNetworkGame();
15459 int request_mode = (has_started_game ? REQ_ASK : REQ_CONFIRM);
15461 if (Request(message, request_mode | REQ_STAY_CLOSED) && has_started_game)
15463 StartGameActions(network.enabled, setup.autorecord, level.random_seed);
15467 // needed in case of envelope request to close game panel
15468 CloseDoor(DOOR_CLOSE_1);
15470 SetGameStatus(GAME_MODE_MAIN);
15476 void CheckGameOver(void)
15478 static boolean last_game_over = FALSE;
15479 static int game_over_delay = 0;
15480 int game_over_delay_value = 50;
15481 boolean game_over = checkGameFailed();
15483 // do not handle game over if request dialog is already active
15484 if (game.request_active)
15487 // do not ask to play again if game was never actually played
15488 if (!game.GamePlayed)
15493 last_game_over = FALSE;
15494 game_over_delay = game_over_delay_value;
15499 if (game_over_delay > 0)
15506 if (last_game_over != game_over)
15507 game.restart_game_message = (hasStartedNetworkGame() ?
15508 "Game over! Play it again?" :
15511 last_game_over = game_over;
15514 boolean checkGameSolved(void)
15516 // set for all game engines if level was solved
15517 return game.LevelSolved_GameEnd;
15520 boolean checkGameFailed(void)
15522 if (level.game_engine_type == GAME_ENGINE_TYPE_EM)
15523 return (game_em.game_over && !game_em.level_solved);
15524 else if (level.game_engine_type == GAME_ENGINE_TYPE_SP)
15525 return (game_sp.game_over && !game_sp.level_solved);
15526 else if (level.game_engine_type == GAME_ENGINE_TYPE_MM)
15527 return (game_mm.game_over && !game_mm.level_solved);
15528 else // GAME_ENGINE_TYPE_RND
15529 return (game.GameOver && !game.LevelSolved);
15532 boolean checkGameEnded(void)
15534 return (checkGameSolved() || checkGameFailed());
15538 // ----------------------------------------------------------------------------
15539 // random generator functions
15540 // ----------------------------------------------------------------------------
15542 unsigned int InitEngineRandom_RND(int seed)
15544 game.num_random_calls = 0;
15546 return InitEngineRandom(seed);
15549 unsigned int RND(int max)
15553 game.num_random_calls++;
15555 return GetEngineRandom(max);
15562 // ----------------------------------------------------------------------------
15563 // game engine snapshot handling functions
15564 // ----------------------------------------------------------------------------
15566 struct EngineSnapshotInfo
15568 // runtime values for custom element collect score
15569 int collect_score[NUM_CUSTOM_ELEMENTS];
15571 // runtime values for group element choice position
15572 int choice_pos[NUM_GROUP_ELEMENTS];
15574 // runtime values for belt position animations
15575 int belt_graphic[4][NUM_BELT_PARTS];
15576 int belt_anim_mode[4][NUM_BELT_PARTS];
15579 static struct EngineSnapshotInfo engine_snapshot_rnd;
15580 static char *snapshot_level_identifier = NULL;
15581 static int snapshot_level_nr = -1;
15583 static void SaveEngineSnapshotValues_RND(void)
15585 static int belt_base_active_element[4] =
15587 EL_CONVEYOR_BELT_1_LEFT_ACTIVE,
15588 EL_CONVEYOR_BELT_2_LEFT_ACTIVE,
15589 EL_CONVEYOR_BELT_3_LEFT_ACTIVE,
15590 EL_CONVEYOR_BELT_4_LEFT_ACTIVE
15594 for (i = 0; i < NUM_CUSTOM_ELEMENTS; i++)
15596 int element = EL_CUSTOM_START + i;
15598 engine_snapshot_rnd.collect_score[i] = element_info[element].collect_score;
15601 for (i = 0; i < NUM_GROUP_ELEMENTS; i++)
15603 int element = EL_GROUP_START + i;
15605 engine_snapshot_rnd.choice_pos[i] = element_info[element].group->choice_pos;
15608 for (i = 0; i < 4; i++)
15610 for (j = 0; j < NUM_BELT_PARTS; j++)
15612 int element = belt_base_active_element[i] + j;
15613 int graphic = el2img(element);
15614 int anim_mode = graphic_info[graphic].anim_mode;
15616 engine_snapshot_rnd.belt_graphic[i][j] = graphic;
15617 engine_snapshot_rnd.belt_anim_mode[i][j] = anim_mode;
15622 static void LoadEngineSnapshotValues_RND(void)
15624 unsigned int num_random_calls = game.num_random_calls;
15627 for (i = 0; i < NUM_CUSTOM_ELEMENTS; i++)
15629 int element = EL_CUSTOM_START + i;
15631 element_info[element].collect_score = engine_snapshot_rnd.collect_score[i];
15634 for (i = 0; i < NUM_GROUP_ELEMENTS; i++)
15636 int element = EL_GROUP_START + i;
15638 element_info[element].group->choice_pos = engine_snapshot_rnd.choice_pos[i];
15641 for (i = 0; i < 4; i++)
15643 for (j = 0; j < NUM_BELT_PARTS; j++)
15645 int graphic = engine_snapshot_rnd.belt_graphic[i][j];
15646 int anim_mode = engine_snapshot_rnd.belt_anim_mode[i][j];
15648 graphic_info[graphic].anim_mode = anim_mode;
15652 if (level.game_engine_type == GAME_ENGINE_TYPE_RND)
15654 InitRND(tape.random_seed);
15655 for (i = 0; i < num_random_calls; i++)
15659 if (game.num_random_calls != num_random_calls)
15661 Error("number of random calls out of sync");
15662 Error("number of random calls should be %d", num_random_calls);
15663 Error("number of random calls is %d", game.num_random_calls);
15665 Fail("this should not happen -- please debug");
15669 void FreeEngineSnapshotSingle(void)
15671 FreeSnapshotSingle();
15673 setString(&snapshot_level_identifier, NULL);
15674 snapshot_level_nr = -1;
15677 void FreeEngineSnapshotList(void)
15679 FreeSnapshotList();
15682 static ListNode *SaveEngineSnapshotBuffers(void)
15684 ListNode *buffers = NULL;
15686 // copy some special values to a structure better suited for the snapshot
15688 if (level.game_engine_type == GAME_ENGINE_TYPE_RND)
15689 SaveEngineSnapshotValues_RND();
15690 if (level.game_engine_type == GAME_ENGINE_TYPE_EM)
15691 SaveEngineSnapshotValues_EM();
15692 if (level.game_engine_type == GAME_ENGINE_TYPE_SP)
15693 SaveEngineSnapshotValues_SP(&buffers);
15694 if (level.game_engine_type == GAME_ENGINE_TYPE_MM)
15695 SaveEngineSnapshotValues_MM(&buffers);
15697 // save values stored in special snapshot structure
15699 if (level.game_engine_type == GAME_ENGINE_TYPE_RND)
15700 SaveSnapshotBuffer(&buffers, ARGS_ADDRESS_AND_SIZEOF(engine_snapshot_rnd));
15701 if (level.game_engine_type == GAME_ENGINE_TYPE_EM)
15702 SaveSnapshotBuffer(&buffers, ARGS_ADDRESS_AND_SIZEOF(engine_snapshot_em));
15703 if (level.game_engine_type == GAME_ENGINE_TYPE_SP)
15704 SaveSnapshotBuffer(&buffers, ARGS_ADDRESS_AND_SIZEOF(engine_snapshot_sp));
15705 if (level.game_engine_type == GAME_ENGINE_TYPE_MM)
15706 SaveSnapshotBuffer(&buffers, ARGS_ADDRESS_AND_SIZEOF(engine_snapshot_mm));
15708 // save further RND engine values
15710 SaveSnapshotBuffer(&buffers, ARGS_ADDRESS_AND_SIZEOF(stored_player));
15711 SaveSnapshotBuffer(&buffers, ARGS_ADDRESS_AND_SIZEOF(game));
15712 SaveSnapshotBuffer(&buffers, ARGS_ADDRESS_AND_SIZEOF(tape));
15714 SaveSnapshotBuffer(&buffers, ARGS_ADDRESS_AND_SIZEOF(FrameCounter));
15715 SaveSnapshotBuffer(&buffers, ARGS_ADDRESS_AND_SIZEOF(TimeFrames));
15716 SaveSnapshotBuffer(&buffers, ARGS_ADDRESS_AND_SIZEOF(TimePlayed));
15717 SaveSnapshotBuffer(&buffers, ARGS_ADDRESS_AND_SIZEOF(TimeLeft));
15718 SaveSnapshotBuffer(&buffers, ARGS_ADDRESS_AND_SIZEOF(TapeTime));
15720 SaveSnapshotBuffer(&buffers, ARGS_ADDRESS_AND_SIZEOF(ScreenMovDir));
15721 SaveSnapshotBuffer(&buffers, ARGS_ADDRESS_AND_SIZEOF(ScreenMovPos));
15722 SaveSnapshotBuffer(&buffers, ARGS_ADDRESS_AND_SIZEOF(ScreenGfxPos));
15724 SaveSnapshotBuffer(&buffers, ARGS_ADDRESS_AND_SIZEOF(ScrollStepSize));
15726 SaveSnapshotBuffer(&buffers, ARGS_ADDRESS_AND_SIZEOF(AmoebaCnt));
15727 SaveSnapshotBuffer(&buffers, ARGS_ADDRESS_AND_SIZEOF(AmoebaCnt2));
15729 SaveSnapshotBuffer(&buffers, ARGS_ADDRESS_AND_SIZEOF(Tile));
15730 SaveSnapshotBuffer(&buffers, ARGS_ADDRESS_AND_SIZEOF(MovPos));
15731 SaveSnapshotBuffer(&buffers, ARGS_ADDRESS_AND_SIZEOF(MovDir));
15732 SaveSnapshotBuffer(&buffers, ARGS_ADDRESS_AND_SIZEOF(MovDelay));
15733 SaveSnapshotBuffer(&buffers, ARGS_ADDRESS_AND_SIZEOF(ChangeDelay));
15734 SaveSnapshotBuffer(&buffers, ARGS_ADDRESS_AND_SIZEOF(ChangePage));
15735 SaveSnapshotBuffer(&buffers, ARGS_ADDRESS_AND_SIZEOF(CustomValue));
15736 SaveSnapshotBuffer(&buffers, ARGS_ADDRESS_AND_SIZEOF(Store));
15737 SaveSnapshotBuffer(&buffers, ARGS_ADDRESS_AND_SIZEOF(Store2));
15738 SaveSnapshotBuffer(&buffers, ARGS_ADDRESS_AND_SIZEOF(StorePlayer));
15739 SaveSnapshotBuffer(&buffers, ARGS_ADDRESS_AND_SIZEOF(Back));
15740 SaveSnapshotBuffer(&buffers, ARGS_ADDRESS_AND_SIZEOF(AmoebaNr));
15741 SaveSnapshotBuffer(&buffers, ARGS_ADDRESS_AND_SIZEOF(WasJustMoving));
15742 SaveSnapshotBuffer(&buffers, ARGS_ADDRESS_AND_SIZEOF(WasJustFalling));
15743 SaveSnapshotBuffer(&buffers, ARGS_ADDRESS_AND_SIZEOF(CheckCollision));
15744 SaveSnapshotBuffer(&buffers, ARGS_ADDRESS_AND_SIZEOF(CheckImpact));
15745 SaveSnapshotBuffer(&buffers, ARGS_ADDRESS_AND_SIZEOF(Stop));
15746 SaveSnapshotBuffer(&buffers, ARGS_ADDRESS_AND_SIZEOF(Pushed));
15748 SaveSnapshotBuffer(&buffers, ARGS_ADDRESS_AND_SIZEOF(ChangeCount));
15749 SaveSnapshotBuffer(&buffers, ARGS_ADDRESS_AND_SIZEOF(ChangeEvent));
15751 SaveSnapshotBuffer(&buffers, ARGS_ADDRESS_AND_SIZEOF(ExplodePhase));
15752 SaveSnapshotBuffer(&buffers, ARGS_ADDRESS_AND_SIZEOF(ExplodeDelay));
15753 SaveSnapshotBuffer(&buffers, ARGS_ADDRESS_AND_SIZEOF(ExplodeField));
15755 SaveSnapshotBuffer(&buffers, ARGS_ADDRESS_AND_SIZEOF(RunnerVisit));
15756 SaveSnapshotBuffer(&buffers, ARGS_ADDRESS_AND_SIZEOF(PlayerVisit));
15758 SaveSnapshotBuffer(&buffers, ARGS_ADDRESS_AND_SIZEOF(GfxFrame));
15759 SaveSnapshotBuffer(&buffers, ARGS_ADDRESS_AND_SIZEOF(GfxRandom));
15760 SaveSnapshotBuffer(&buffers, ARGS_ADDRESS_AND_SIZEOF(GfxElement));
15761 SaveSnapshotBuffer(&buffers, ARGS_ADDRESS_AND_SIZEOF(GfxAction));
15762 SaveSnapshotBuffer(&buffers, ARGS_ADDRESS_AND_SIZEOF(GfxDir));
15764 SaveSnapshotBuffer(&buffers, ARGS_ADDRESS_AND_SIZEOF(scroll_x));
15765 SaveSnapshotBuffer(&buffers, ARGS_ADDRESS_AND_SIZEOF(scroll_y));
15768 ListNode *node = engine_snapshot_list_rnd;
15771 while (node != NULL)
15773 num_bytes += ((struct EngineSnapshotNodeInfo *)node->content)->size;
15778 Debug("game:playing:SaveEngineSnapshotBuffers",
15779 "size of engine snapshot: %d bytes", num_bytes);
15785 void SaveEngineSnapshotSingle(void)
15787 ListNode *buffers = SaveEngineSnapshotBuffers();
15789 // finally save all snapshot buffers to single snapshot
15790 SaveSnapshotSingle(buffers);
15792 // save level identification information
15793 setString(&snapshot_level_identifier, leveldir_current->identifier);
15794 snapshot_level_nr = level_nr;
15797 boolean CheckSaveEngineSnapshotToList(void)
15799 boolean save_snapshot =
15800 ((game.snapshot.mode == SNAPSHOT_MODE_EVERY_STEP) ||
15801 (game.snapshot.mode == SNAPSHOT_MODE_EVERY_MOVE &&
15802 game.snapshot.changed_action) ||
15803 (game.snapshot.mode == SNAPSHOT_MODE_EVERY_COLLECT &&
15804 game.snapshot.collected_item));
15806 game.snapshot.changed_action = FALSE;
15807 game.snapshot.collected_item = FALSE;
15808 game.snapshot.save_snapshot = save_snapshot;
15810 return save_snapshot;
15813 void SaveEngineSnapshotToList(void)
15815 if (game.snapshot.mode == SNAPSHOT_MODE_OFF ||
15819 ListNode *buffers = SaveEngineSnapshotBuffers();
15821 // finally save all snapshot buffers to snapshot list
15822 SaveSnapshotToList(buffers);
15825 void SaveEngineSnapshotToListInitial(void)
15827 FreeEngineSnapshotList();
15829 SaveEngineSnapshotToList();
15832 static void LoadEngineSnapshotValues(void)
15834 // restore special values from snapshot structure
15836 if (level.game_engine_type == GAME_ENGINE_TYPE_RND)
15837 LoadEngineSnapshotValues_RND();
15838 if (level.game_engine_type == GAME_ENGINE_TYPE_EM)
15839 LoadEngineSnapshotValues_EM();
15840 if (level.game_engine_type == GAME_ENGINE_TYPE_SP)
15841 LoadEngineSnapshotValues_SP();
15842 if (level.game_engine_type == GAME_ENGINE_TYPE_MM)
15843 LoadEngineSnapshotValues_MM();
15846 void LoadEngineSnapshotSingle(void)
15848 LoadSnapshotSingle();
15850 LoadEngineSnapshotValues();
15853 static void LoadEngineSnapshot_Undo(int steps)
15855 LoadSnapshotFromList_Older(steps);
15857 LoadEngineSnapshotValues();
15860 static void LoadEngineSnapshot_Redo(int steps)
15862 LoadSnapshotFromList_Newer(steps);
15864 LoadEngineSnapshotValues();
15867 boolean CheckEngineSnapshotSingle(void)
15869 return (strEqual(snapshot_level_identifier, leveldir_current->identifier) &&
15870 snapshot_level_nr == level_nr);
15873 boolean CheckEngineSnapshotList(void)
15875 return CheckSnapshotList();
15879 // ---------- new game button stuff -------------------------------------------
15886 boolean *setup_value;
15887 boolean allowed_on_tape;
15888 boolean is_touch_button;
15890 } gamebutton_info[NUM_GAME_BUTTONS] =
15893 IMG_GFX_GAME_BUTTON_STOP, &game.button.stop,
15894 GAME_CTRL_ID_STOP, NULL,
15895 TRUE, FALSE, "stop game"
15898 IMG_GFX_GAME_BUTTON_PAUSE, &game.button.pause,
15899 GAME_CTRL_ID_PAUSE, NULL,
15900 TRUE, FALSE, "pause game"
15903 IMG_GFX_GAME_BUTTON_PLAY, &game.button.play,
15904 GAME_CTRL_ID_PLAY, NULL,
15905 TRUE, FALSE, "play game"
15908 IMG_GFX_GAME_BUTTON_UNDO, &game.button.undo,
15909 GAME_CTRL_ID_UNDO, NULL,
15910 TRUE, FALSE, "undo step"
15913 IMG_GFX_GAME_BUTTON_REDO, &game.button.redo,
15914 GAME_CTRL_ID_REDO, NULL,
15915 TRUE, FALSE, "redo step"
15918 IMG_GFX_GAME_BUTTON_SAVE, &game.button.save,
15919 GAME_CTRL_ID_SAVE, NULL,
15920 TRUE, FALSE, "save game"
15923 IMG_GFX_GAME_BUTTON_PAUSE2, &game.button.pause2,
15924 GAME_CTRL_ID_PAUSE2, NULL,
15925 TRUE, FALSE, "pause game"
15928 IMG_GFX_GAME_BUTTON_LOAD, &game.button.load,
15929 GAME_CTRL_ID_LOAD, NULL,
15930 TRUE, FALSE, "load game"
15933 IMG_GFX_GAME_BUTTON_PANEL_STOP, &game.button.panel_stop,
15934 GAME_CTRL_ID_PANEL_STOP, NULL,
15935 FALSE, FALSE, "stop game"
15938 IMG_GFX_GAME_BUTTON_PANEL_PAUSE, &game.button.panel_pause,
15939 GAME_CTRL_ID_PANEL_PAUSE, NULL,
15940 FALSE, FALSE, "pause game"
15943 IMG_GFX_GAME_BUTTON_PANEL_PLAY, &game.button.panel_play,
15944 GAME_CTRL_ID_PANEL_PLAY, NULL,
15945 FALSE, FALSE, "play game"
15948 IMG_GFX_GAME_BUTTON_TOUCH_STOP, &game.button.touch_stop,
15949 GAME_CTRL_ID_TOUCH_STOP, NULL,
15950 FALSE, TRUE, "stop game"
15953 IMG_GFX_GAME_BUTTON_TOUCH_PAUSE, &game.button.touch_pause,
15954 GAME_CTRL_ID_TOUCH_PAUSE, NULL,
15955 FALSE, TRUE, "pause game"
15958 IMG_GFX_GAME_BUTTON_SOUND_MUSIC, &game.button.sound_music,
15959 SOUND_CTRL_ID_MUSIC, &setup.sound_music,
15960 TRUE, FALSE, "background music on/off"
15963 IMG_GFX_GAME_BUTTON_SOUND_LOOPS, &game.button.sound_loops,
15964 SOUND_CTRL_ID_LOOPS, &setup.sound_loops,
15965 TRUE, FALSE, "sound loops on/off"
15968 IMG_GFX_GAME_BUTTON_SOUND_SIMPLE, &game.button.sound_simple,
15969 SOUND_CTRL_ID_SIMPLE, &setup.sound_simple,
15970 TRUE, FALSE, "normal sounds on/off"
15973 IMG_GFX_GAME_BUTTON_PANEL_SOUND_MUSIC, &game.button.panel_sound_music,
15974 SOUND_CTRL_ID_PANEL_MUSIC, &setup.sound_music,
15975 FALSE, FALSE, "background music on/off"
15978 IMG_GFX_GAME_BUTTON_PANEL_SOUND_LOOPS, &game.button.panel_sound_loops,
15979 SOUND_CTRL_ID_PANEL_LOOPS, &setup.sound_loops,
15980 FALSE, FALSE, "sound loops on/off"
15983 IMG_GFX_GAME_BUTTON_PANEL_SOUND_SIMPLE, &game.button.panel_sound_simple,
15984 SOUND_CTRL_ID_PANEL_SIMPLE, &setup.sound_simple,
15985 FALSE, FALSE, "normal sounds on/off"
15989 void CreateGameButtons(void)
15993 for (i = 0; i < NUM_GAME_BUTTONS; i++)
15995 int graphic = gamebutton_info[i].graphic;
15996 struct GraphicInfo *gfx = &graphic_info[graphic];
15997 struct XY *pos = gamebutton_info[i].pos;
15998 struct GadgetInfo *gi;
16001 unsigned int event_mask;
16002 boolean is_touch_button = gamebutton_info[i].is_touch_button;
16003 boolean allowed_on_tape = gamebutton_info[i].allowed_on_tape;
16004 boolean on_tape = (tape.show_game_buttons && allowed_on_tape);
16005 int base_x = (is_touch_button ? 0 : on_tape ? VX : DX);
16006 int base_y = (is_touch_button ? 0 : on_tape ? VY : DY);
16007 int gd_x = gfx->src_x;
16008 int gd_y = gfx->src_y;
16009 int gd_xp = gfx->src_x + gfx->pressed_xoffset;
16010 int gd_yp = gfx->src_y + gfx->pressed_yoffset;
16011 int gd_xa = gfx->src_x + gfx->active_xoffset;
16012 int gd_ya = gfx->src_y + gfx->active_yoffset;
16013 int gd_xap = gfx->src_x + gfx->active_xoffset + gfx->pressed_xoffset;
16014 int gd_yap = gfx->src_y + gfx->active_yoffset + gfx->pressed_yoffset;
16015 int x = (is_touch_button ? pos->x : GDI_ACTIVE_POS(pos->x));
16016 int y = (is_touch_button ? pos->y : GDI_ACTIVE_POS(pos->y));
16019 if (gfx->bitmap == NULL)
16021 game_gadget[id] = NULL;
16026 if (id == GAME_CTRL_ID_STOP ||
16027 id == GAME_CTRL_ID_PANEL_STOP ||
16028 id == GAME_CTRL_ID_TOUCH_STOP ||
16029 id == GAME_CTRL_ID_PLAY ||
16030 id == GAME_CTRL_ID_PANEL_PLAY ||
16031 id == GAME_CTRL_ID_SAVE ||
16032 id == GAME_CTRL_ID_LOAD)
16034 button_type = GD_TYPE_NORMAL_BUTTON;
16036 event_mask = GD_EVENT_RELEASED;
16038 else if (id == GAME_CTRL_ID_UNDO ||
16039 id == GAME_CTRL_ID_REDO)
16041 button_type = GD_TYPE_NORMAL_BUTTON;
16043 event_mask = GD_EVENT_PRESSED | GD_EVENT_REPEATED;
16047 button_type = GD_TYPE_CHECK_BUTTON;
16048 checked = (gamebutton_info[i].setup_value != NULL ?
16049 *gamebutton_info[i].setup_value : FALSE);
16050 event_mask = GD_EVENT_PRESSED;
16053 gi = CreateGadget(GDI_CUSTOM_ID, id,
16054 GDI_IMAGE_ID, graphic,
16055 GDI_INFO_TEXT, gamebutton_info[i].infotext,
16058 GDI_WIDTH, gfx->width,
16059 GDI_HEIGHT, gfx->height,
16060 GDI_TYPE, button_type,
16061 GDI_STATE, GD_BUTTON_UNPRESSED,
16062 GDI_CHECKED, checked,
16063 GDI_DESIGN_UNPRESSED, gfx->bitmap, gd_x, gd_y,
16064 GDI_DESIGN_PRESSED, gfx->bitmap, gd_xp, gd_yp,
16065 GDI_ALT_DESIGN_UNPRESSED, gfx->bitmap, gd_xa, gd_ya,
16066 GDI_ALT_DESIGN_PRESSED, gfx->bitmap, gd_xap, gd_yap,
16067 GDI_DIRECT_DRAW, FALSE,
16068 GDI_OVERLAY_TOUCH_BUTTON, is_touch_button,
16069 GDI_EVENT_MASK, event_mask,
16070 GDI_CALLBACK_ACTION, HandleGameButtons,
16074 Fail("cannot create gadget");
16076 game_gadget[id] = gi;
16080 void FreeGameButtons(void)
16084 for (i = 0; i < NUM_GAME_BUTTONS; i++)
16085 FreeGadget(game_gadget[i]);
16088 static void UnmapGameButtonsAtSamePosition(int id)
16092 for (i = 0; i < NUM_GAME_BUTTONS; i++)
16094 gamebutton_info[i].pos->x == gamebutton_info[id].pos->x &&
16095 gamebutton_info[i].pos->y == gamebutton_info[id].pos->y)
16096 UnmapGadget(game_gadget[i]);
16099 static void UnmapGameButtonsAtSamePosition_All(void)
16101 if (setup.show_snapshot_buttons)
16103 UnmapGameButtonsAtSamePosition(GAME_CTRL_ID_SAVE);
16104 UnmapGameButtonsAtSamePosition(GAME_CTRL_ID_PAUSE2);
16105 UnmapGameButtonsAtSamePosition(GAME_CTRL_ID_LOAD);
16109 UnmapGameButtonsAtSamePosition(GAME_CTRL_ID_STOP);
16110 UnmapGameButtonsAtSamePosition(GAME_CTRL_ID_PAUSE);
16111 UnmapGameButtonsAtSamePosition(GAME_CTRL_ID_PLAY);
16113 UnmapGameButtonsAtSamePosition(GAME_CTRL_ID_PANEL_STOP);
16114 UnmapGameButtonsAtSamePosition(GAME_CTRL_ID_PANEL_PAUSE);
16115 UnmapGameButtonsAtSamePosition(GAME_CTRL_ID_PANEL_PLAY);
16119 static void MapGameButtonsAtSamePosition(int id)
16123 for (i = 0; i < NUM_GAME_BUTTONS; i++)
16125 gamebutton_info[i].pos->x == gamebutton_info[id].pos->x &&
16126 gamebutton_info[i].pos->y == gamebutton_info[id].pos->y)
16127 MapGadget(game_gadget[i]);
16129 UnmapGameButtonsAtSamePosition_All();
16132 void MapUndoRedoButtons(void)
16134 UnmapGameButtonsAtSamePosition(GAME_CTRL_ID_UNDO);
16135 UnmapGameButtonsAtSamePosition(GAME_CTRL_ID_REDO);
16137 MapGadget(game_gadget[GAME_CTRL_ID_UNDO]);
16138 MapGadget(game_gadget[GAME_CTRL_ID_REDO]);
16141 void UnmapUndoRedoButtons(void)
16143 UnmapGadget(game_gadget[GAME_CTRL_ID_UNDO]);
16144 UnmapGadget(game_gadget[GAME_CTRL_ID_REDO]);
16146 MapGameButtonsAtSamePosition(GAME_CTRL_ID_UNDO);
16147 MapGameButtonsAtSamePosition(GAME_CTRL_ID_REDO);
16150 void ModifyPauseButtons(void)
16154 GAME_CTRL_ID_PAUSE,
16155 GAME_CTRL_ID_PAUSE2,
16156 GAME_CTRL_ID_PANEL_PAUSE,
16157 GAME_CTRL_ID_TOUCH_PAUSE,
16162 for (i = 0; ids[i] > -1; i++)
16163 ModifyGadget(game_gadget[ids[i]], GDI_CHECKED, tape.pausing, GDI_END);
16166 static void MapGameButtonsExt(boolean on_tape)
16170 for (i = 0; i < NUM_GAME_BUTTONS; i++)
16171 if ((!on_tape || gamebutton_info[i].allowed_on_tape) &&
16172 i != GAME_CTRL_ID_UNDO &&
16173 i != GAME_CTRL_ID_REDO)
16174 MapGadget(game_gadget[i]);
16176 UnmapGameButtonsAtSamePosition_All();
16178 RedrawGameButtons();
16181 static void UnmapGameButtonsExt(boolean on_tape)
16185 for (i = 0; i < NUM_GAME_BUTTONS; i++)
16186 if (!on_tape || gamebutton_info[i].allowed_on_tape)
16187 UnmapGadget(game_gadget[i]);
16190 static void RedrawGameButtonsExt(boolean on_tape)
16194 for (i = 0; i < NUM_GAME_BUTTONS; i++)
16195 if (!on_tape || gamebutton_info[i].allowed_on_tape)
16196 RedrawGadget(game_gadget[i]);
16199 static void SetGadgetState(struct GadgetInfo *gi, boolean state)
16204 gi->checked = state;
16207 static void RedrawSoundButtonGadget(int id)
16209 int id2 = (id == SOUND_CTRL_ID_MUSIC ? SOUND_CTRL_ID_PANEL_MUSIC :
16210 id == SOUND_CTRL_ID_LOOPS ? SOUND_CTRL_ID_PANEL_LOOPS :
16211 id == SOUND_CTRL_ID_SIMPLE ? SOUND_CTRL_ID_PANEL_SIMPLE :
16212 id == SOUND_CTRL_ID_PANEL_MUSIC ? SOUND_CTRL_ID_MUSIC :
16213 id == SOUND_CTRL_ID_PANEL_LOOPS ? SOUND_CTRL_ID_LOOPS :
16214 id == SOUND_CTRL_ID_PANEL_SIMPLE ? SOUND_CTRL_ID_SIMPLE :
16217 SetGadgetState(game_gadget[id2], *gamebutton_info[id2].setup_value);
16218 RedrawGadget(game_gadget[id2]);
16221 void MapGameButtons(void)
16223 MapGameButtonsExt(FALSE);
16226 void UnmapGameButtons(void)
16228 UnmapGameButtonsExt(FALSE);
16231 void RedrawGameButtons(void)
16233 RedrawGameButtonsExt(FALSE);
16236 void MapGameButtonsOnTape(void)
16238 MapGameButtonsExt(TRUE);
16241 void UnmapGameButtonsOnTape(void)
16243 UnmapGameButtonsExt(TRUE);
16246 void RedrawGameButtonsOnTape(void)
16248 RedrawGameButtonsExt(TRUE);
16251 static void GameUndoRedoExt(void)
16253 ClearPlayerAction();
16255 tape.pausing = TRUE;
16258 UpdateAndDisplayGameControlValues();
16260 DrawCompleteVideoDisplay();
16261 DrawVideoDisplay(VIDEO_STATE_TIME_ON, TapeTime);
16262 DrawVideoDisplay(VIDEO_STATE_FRAME_ON, FrameCounter);
16263 DrawVideoDisplay(VIDEO_STATE_1STEP(tape.single_step), 0);
16268 static void GameUndo(int steps)
16270 if (!CheckEngineSnapshotList())
16273 LoadEngineSnapshot_Undo(steps);
16278 static void GameRedo(int steps)
16280 if (!CheckEngineSnapshotList())
16283 LoadEngineSnapshot_Redo(steps);
16288 static void HandleGameButtonsExt(int id, int button)
16290 static boolean game_undo_executed = FALSE;
16291 int steps = BUTTON_STEPSIZE(button);
16292 boolean handle_game_buttons =
16293 (game_status == GAME_MODE_PLAYING ||
16294 (game_status == GAME_MODE_MAIN && tape.show_game_buttons));
16296 if (!handle_game_buttons)
16301 case GAME_CTRL_ID_STOP:
16302 case GAME_CTRL_ID_PANEL_STOP:
16303 case GAME_CTRL_ID_TOUCH_STOP:
16304 if (game_status == GAME_MODE_MAIN)
16310 RequestQuitGame(FALSE);
16314 case GAME_CTRL_ID_PAUSE:
16315 case GAME_CTRL_ID_PAUSE2:
16316 case GAME_CTRL_ID_PANEL_PAUSE:
16317 case GAME_CTRL_ID_TOUCH_PAUSE:
16318 if (network.enabled && game_status == GAME_MODE_PLAYING)
16321 SendToServer_ContinuePlaying();
16323 SendToServer_PausePlaying();
16326 TapeTogglePause(TAPE_TOGGLE_MANUAL);
16328 game_undo_executed = FALSE;
16332 case GAME_CTRL_ID_PLAY:
16333 case GAME_CTRL_ID_PANEL_PLAY:
16334 if (game_status == GAME_MODE_MAIN)
16336 StartGameActions(network.enabled, setup.autorecord, level.random_seed);
16338 else if (tape.pausing)
16340 if (network.enabled)
16341 SendToServer_ContinuePlaying();
16343 TapeTogglePause(TAPE_TOGGLE_MANUAL | TAPE_TOGGLE_PLAY_PAUSE);
16347 case GAME_CTRL_ID_UNDO:
16348 // Important: When using "save snapshot when collecting an item" mode,
16349 // load last (current) snapshot for first "undo" after pressing "pause"
16350 // (else the last-but-one snapshot would be loaded, because the snapshot
16351 // pointer already points to the last snapshot when pressing "pause",
16352 // which is fine for "every step/move" mode, but not for "every collect")
16353 if (game.snapshot.mode == SNAPSHOT_MODE_EVERY_COLLECT &&
16354 !game_undo_executed)
16357 game_undo_executed = TRUE;
16362 case GAME_CTRL_ID_REDO:
16366 case GAME_CTRL_ID_SAVE:
16370 case GAME_CTRL_ID_LOAD:
16374 case SOUND_CTRL_ID_MUSIC:
16375 case SOUND_CTRL_ID_PANEL_MUSIC:
16376 if (setup.sound_music)
16378 setup.sound_music = FALSE;
16382 else if (audio.music_available)
16384 setup.sound = setup.sound_music = TRUE;
16386 SetAudioMode(setup.sound);
16388 if (game_status == GAME_MODE_PLAYING)
16392 RedrawSoundButtonGadget(id);
16396 case SOUND_CTRL_ID_LOOPS:
16397 case SOUND_CTRL_ID_PANEL_LOOPS:
16398 if (setup.sound_loops)
16399 setup.sound_loops = FALSE;
16400 else if (audio.loops_available)
16402 setup.sound = setup.sound_loops = TRUE;
16404 SetAudioMode(setup.sound);
16407 RedrawSoundButtonGadget(id);
16411 case SOUND_CTRL_ID_SIMPLE:
16412 case SOUND_CTRL_ID_PANEL_SIMPLE:
16413 if (setup.sound_simple)
16414 setup.sound_simple = FALSE;
16415 else if (audio.sound_available)
16417 setup.sound = setup.sound_simple = TRUE;
16419 SetAudioMode(setup.sound);
16422 RedrawSoundButtonGadget(id);
16431 static void HandleGameButtons(struct GadgetInfo *gi)
16433 HandleGameButtonsExt(gi->custom_id, gi->event.button);
16436 void HandleSoundButtonKeys(Key key)
16438 if (key == setup.shortcut.sound_simple)
16439 ClickOnGadget(game_gadget[SOUND_CTRL_ID_SIMPLE], MB_LEFTBUTTON);
16440 else if (key == setup.shortcut.sound_loops)
16441 ClickOnGadget(game_gadget[SOUND_CTRL_ID_LOOPS], MB_LEFTBUTTON);
16442 else if (key == setup.shortcut.sound_music)
16443 ClickOnGadget(game_gadget[SOUND_CTRL_ID_MUSIC], MB_LEFTBUTTON);