1 // ============================================================================
2 // Rocks'n'Diamonds - McDuffin Strikes Back!
3 // ----------------------------------------------------------------------------
4 // (c) 1995-2014 by Artsoft Entertainment
7 // https://www.artsoft.org/
8 // ----------------------------------------------------------------------------
10 // ============================================================================
12 #include "libgame/libgame.h"
26 #define DEBUG_INIT_PLAYER 1
27 #define DEBUG_PLAYER_ACTIONS 0
30 #define USE_NEW_AMOEBA_CODE FALSE
33 #define USE_QUICKSAND_BD_ROCK_BUGFIX 0
34 #define USE_QUICKSAND_IMPACT_BUGFIX 0
35 #define USE_DELAYED_GFX_REDRAW 0
36 #define USE_NEW_PLAYER_ASSIGNMENTS 1
38 #if USE_DELAYED_GFX_REDRAW
39 #define TEST_DrawLevelField(x, y) \
40 GfxRedraw[x][y] |= GFX_REDRAW_TILE
41 #define TEST_DrawLevelFieldCrumbled(x, y) \
42 GfxRedraw[x][y] |= GFX_REDRAW_TILE_CRUMBLED
43 #define TEST_DrawLevelFieldCrumbledNeighbours(x, y) \
44 GfxRedraw[x][y] |= GFX_REDRAW_TILE_CRUMBLED_NEIGHBOURS
45 #define TEST_DrawTwinkleOnField(x, y) \
46 GfxRedraw[x][y] |= GFX_REDRAW_TILE_TWINKLED
48 #define TEST_DrawLevelField(x, y) \
50 #define TEST_DrawLevelFieldCrumbled(x, y) \
51 DrawLevelFieldCrumbled(x, y)
52 #define TEST_DrawLevelFieldCrumbledNeighbours(x, y) \
53 DrawLevelFieldCrumbledNeighbours(x, y)
54 #define TEST_DrawTwinkleOnField(x, y) \
55 DrawTwinkleOnField(x, y)
65 #define MP_NO_ACTION 0
68 #define MP_DONT_RUN_INTO (MP_MOVING | MP_ACTION)
72 #define SCROLL_GO_ON 1
74 // for Bang()/Explode()
75 #define EX_PHASE_START 0
76 #define EX_TYPE_NONE 0
77 #define EX_TYPE_NORMAL (1 << 0)
78 #define EX_TYPE_CENTER (1 << 1)
79 #define EX_TYPE_BORDER (1 << 2)
80 #define EX_TYPE_CROSS (1 << 3)
81 #define EX_TYPE_DYNA (1 << 4)
82 #define EX_TYPE_SINGLE_TILE (EX_TYPE_CENTER | EX_TYPE_BORDER)
84 #define PANEL_OFF() (game.panel.active == FALSE)
85 #define PANEL_DEACTIVATED(p) ((p)->x < 0 || (p)->y < 0 || PANEL_OFF())
86 #define PANEL_XPOS(p) (DX + ALIGNED_TEXT_XPOS(p))
87 #define PANEL_YPOS(p) (DY + ALIGNED_TEXT_YPOS(p))
89 // game panel display and control definitions
90 #define GAME_PANEL_LEVEL_NUMBER 0
91 #define GAME_PANEL_GEMS 1
92 #define GAME_PANEL_INVENTORY_COUNT 2
93 #define GAME_PANEL_INVENTORY_FIRST_1 3
94 #define GAME_PANEL_INVENTORY_FIRST_2 4
95 #define GAME_PANEL_INVENTORY_FIRST_3 5
96 #define GAME_PANEL_INVENTORY_FIRST_4 6
97 #define GAME_PANEL_INVENTORY_FIRST_5 7
98 #define GAME_PANEL_INVENTORY_FIRST_6 8
99 #define GAME_PANEL_INVENTORY_FIRST_7 9
100 #define GAME_PANEL_INVENTORY_FIRST_8 10
101 #define GAME_PANEL_INVENTORY_LAST_1 11
102 #define GAME_PANEL_INVENTORY_LAST_2 12
103 #define GAME_PANEL_INVENTORY_LAST_3 13
104 #define GAME_PANEL_INVENTORY_LAST_4 14
105 #define GAME_PANEL_INVENTORY_LAST_5 15
106 #define GAME_PANEL_INVENTORY_LAST_6 16
107 #define GAME_PANEL_INVENTORY_LAST_7 17
108 #define GAME_PANEL_INVENTORY_LAST_8 18
109 #define GAME_PANEL_KEY_1 19
110 #define GAME_PANEL_KEY_2 20
111 #define GAME_PANEL_KEY_3 21
112 #define GAME_PANEL_KEY_4 22
113 #define GAME_PANEL_KEY_5 23
114 #define GAME_PANEL_KEY_6 24
115 #define GAME_PANEL_KEY_7 25
116 #define GAME_PANEL_KEY_8 26
117 #define GAME_PANEL_KEY_WHITE 27
118 #define GAME_PANEL_KEY_WHITE_COUNT 28
119 #define GAME_PANEL_SCORE 29
120 #define GAME_PANEL_HIGHSCORE 30
121 #define GAME_PANEL_TIME 31
122 #define GAME_PANEL_TIME_HH 32
123 #define GAME_PANEL_TIME_MM 33
124 #define GAME_PANEL_TIME_SS 34
125 #define GAME_PANEL_TIME_ANIM 35
126 #define GAME_PANEL_HEALTH 36
127 #define GAME_PANEL_HEALTH_ANIM 37
128 #define GAME_PANEL_FRAME 38
129 #define GAME_PANEL_SHIELD_NORMAL 39
130 #define GAME_PANEL_SHIELD_NORMAL_TIME 40
131 #define GAME_PANEL_SHIELD_DEADLY 41
132 #define GAME_PANEL_SHIELD_DEADLY_TIME 42
133 #define GAME_PANEL_EXIT 43
134 #define GAME_PANEL_EMC_MAGIC_BALL 44
135 #define GAME_PANEL_EMC_MAGIC_BALL_SWITCH 45
136 #define GAME_PANEL_LIGHT_SWITCH 46
137 #define GAME_PANEL_LIGHT_SWITCH_TIME 47
138 #define GAME_PANEL_TIMEGATE_SWITCH 48
139 #define GAME_PANEL_TIMEGATE_SWITCH_TIME 49
140 #define GAME_PANEL_SWITCHGATE_SWITCH 50
141 #define GAME_PANEL_EMC_LENSES 51
142 #define GAME_PANEL_EMC_LENSES_TIME 52
143 #define GAME_PANEL_EMC_MAGNIFIER 53
144 #define GAME_PANEL_EMC_MAGNIFIER_TIME 54
145 #define GAME_PANEL_BALLOON_SWITCH 55
146 #define GAME_PANEL_DYNABOMB_NUMBER 56
147 #define GAME_PANEL_DYNABOMB_SIZE 57
148 #define GAME_PANEL_DYNABOMB_POWER 58
149 #define GAME_PANEL_PENGUINS 59
150 #define GAME_PANEL_SOKOBAN_OBJECTS 60
151 #define GAME_PANEL_SOKOBAN_FIELDS 61
152 #define GAME_PANEL_ROBOT_WHEEL 62
153 #define GAME_PANEL_CONVEYOR_BELT_1 63
154 #define GAME_PANEL_CONVEYOR_BELT_2 64
155 #define GAME_PANEL_CONVEYOR_BELT_3 65
156 #define GAME_PANEL_CONVEYOR_BELT_4 66
157 #define GAME_PANEL_CONVEYOR_BELT_1_SWITCH 67
158 #define GAME_PANEL_CONVEYOR_BELT_2_SWITCH 68
159 #define GAME_PANEL_CONVEYOR_BELT_3_SWITCH 69
160 #define GAME_PANEL_CONVEYOR_BELT_4_SWITCH 70
161 #define GAME_PANEL_MAGIC_WALL 71
162 #define GAME_PANEL_MAGIC_WALL_TIME 72
163 #define GAME_PANEL_GRAVITY_STATE 73
164 #define GAME_PANEL_GRAPHIC_1 74
165 #define GAME_PANEL_GRAPHIC_2 75
166 #define GAME_PANEL_GRAPHIC_3 76
167 #define GAME_PANEL_GRAPHIC_4 77
168 #define GAME_PANEL_GRAPHIC_5 78
169 #define GAME_PANEL_GRAPHIC_6 79
170 #define GAME_PANEL_GRAPHIC_7 80
171 #define GAME_PANEL_GRAPHIC_8 81
172 #define GAME_PANEL_ELEMENT_1 82
173 #define GAME_PANEL_ELEMENT_2 83
174 #define GAME_PANEL_ELEMENT_3 84
175 #define GAME_PANEL_ELEMENT_4 85
176 #define GAME_PANEL_ELEMENT_5 86
177 #define GAME_PANEL_ELEMENT_6 87
178 #define GAME_PANEL_ELEMENT_7 88
179 #define GAME_PANEL_ELEMENT_8 89
180 #define GAME_PANEL_ELEMENT_COUNT_1 90
181 #define GAME_PANEL_ELEMENT_COUNT_2 91
182 #define GAME_PANEL_ELEMENT_COUNT_3 92
183 #define GAME_PANEL_ELEMENT_COUNT_4 93
184 #define GAME_PANEL_ELEMENT_COUNT_5 94
185 #define GAME_PANEL_ELEMENT_COUNT_6 95
186 #define GAME_PANEL_ELEMENT_COUNT_7 96
187 #define GAME_PANEL_ELEMENT_COUNT_8 97
188 #define GAME_PANEL_CE_SCORE_1 98
189 #define GAME_PANEL_CE_SCORE_2 99
190 #define GAME_PANEL_CE_SCORE_3 100
191 #define GAME_PANEL_CE_SCORE_4 101
192 #define GAME_PANEL_CE_SCORE_5 102
193 #define GAME_PANEL_CE_SCORE_6 103
194 #define GAME_PANEL_CE_SCORE_7 104
195 #define GAME_PANEL_CE_SCORE_8 105
196 #define GAME_PANEL_CE_SCORE_1_ELEMENT 106
197 #define GAME_PANEL_CE_SCORE_2_ELEMENT 107
198 #define GAME_PANEL_CE_SCORE_3_ELEMENT 108
199 #define GAME_PANEL_CE_SCORE_4_ELEMENT 109
200 #define GAME_PANEL_CE_SCORE_5_ELEMENT 110
201 #define GAME_PANEL_CE_SCORE_6_ELEMENT 111
202 #define GAME_PANEL_CE_SCORE_7_ELEMENT 112
203 #define GAME_PANEL_CE_SCORE_8_ELEMENT 113
204 #define GAME_PANEL_PLAYER_NAME 114
205 #define GAME_PANEL_LEVEL_NAME 115
206 #define GAME_PANEL_LEVEL_AUTHOR 116
208 #define NUM_GAME_PANEL_CONTROLS 117
210 struct GamePanelOrderInfo
216 static struct GamePanelOrderInfo game_panel_order[NUM_GAME_PANEL_CONTROLS];
218 struct GamePanelControlInfo
222 struct TextPosInfo *pos;
225 int graphic, graphic_active;
227 int value, last_value;
228 int frame, last_frame;
233 static struct GamePanelControlInfo game_panel_controls[] =
236 GAME_PANEL_LEVEL_NUMBER,
237 &game.panel.level_number,
246 GAME_PANEL_INVENTORY_COUNT,
247 &game.panel.inventory_count,
251 GAME_PANEL_INVENTORY_FIRST_1,
252 &game.panel.inventory_first[0],
256 GAME_PANEL_INVENTORY_FIRST_2,
257 &game.panel.inventory_first[1],
261 GAME_PANEL_INVENTORY_FIRST_3,
262 &game.panel.inventory_first[2],
266 GAME_PANEL_INVENTORY_FIRST_4,
267 &game.panel.inventory_first[3],
271 GAME_PANEL_INVENTORY_FIRST_5,
272 &game.panel.inventory_first[4],
276 GAME_PANEL_INVENTORY_FIRST_6,
277 &game.panel.inventory_first[5],
281 GAME_PANEL_INVENTORY_FIRST_7,
282 &game.panel.inventory_first[6],
286 GAME_PANEL_INVENTORY_FIRST_8,
287 &game.panel.inventory_first[7],
291 GAME_PANEL_INVENTORY_LAST_1,
292 &game.panel.inventory_last[0],
296 GAME_PANEL_INVENTORY_LAST_2,
297 &game.panel.inventory_last[1],
301 GAME_PANEL_INVENTORY_LAST_3,
302 &game.panel.inventory_last[2],
306 GAME_PANEL_INVENTORY_LAST_4,
307 &game.panel.inventory_last[3],
311 GAME_PANEL_INVENTORY_LAST_5,
312 &game.panel.inventory_last[4],
316 GAME_PANEL_INVENTORY_LAST_6,
317 &game.panel.inventory_last[5],
321 GAME_PANEL_INVENTORY_LAST_7,
322 &game.panel.inventory_last[6],
326 GAME_PANEL_INVENTORY_LAST_8,
327 &game.panel.inventory_last[7],
371 GAME_PANEL_KEY_WHITE,
372 &game.panel.key_white,
376 GAME_PANEL_KEY_WHITE_COUNT,
377 &game.panel.key_white_count,
386 GAME_PANEL_HIGHSCORE,
387 &game.panel.highscore,
411 GAME_PANEL_TIME_ANIM,
412 &game.panel.time_anim,
415 IMG_GFX_GAME_PANEL_TIME_ANIM,
416 IMG_GFX_GAME_PANEL_TIME_ANIM_ACTIVE
424 GAME_PANEL_HEALTH_ANIM,
425 &game.panel.health_anim,
428 IMG_GFX_GAME_PANEL_HEALTH_ANIM,
429 IMG_GFX_GAME_PANEL_HEALTH_ANIM_ACTIVE
437 GAME_PANEL_SHIELD_NORMAL,
438 &game.panel.shield_normal,
442 GAME_PANEL_SHIELD_NORMAL_TIME,
443 &game.panel.shield_normal_time,
447 GAME_PANEL_SHIELD_DEADLY,
448 &game.panel.shield_deadly,
452 GAME_PANEL_SHIELD_DEADLY_TIME,
453 &game.panel.shield_deadly_time,
462 GAME_PANEL_EMC_MAGIC_BALL,
463 &game.panel.emc_magic_ball,
467 GAME_PANEL_EMC_MAGIC_BALL_SWITCH,
468 &game.panel.emc_magic_ball_switch,
472 GAME_PANEL_LIGHT_SWITCH,
473 &game.panel.light_switch,
477 GAME_PANEL_LIGHT_SWITCH_TIME,
478 &game.panel.light_switch_time,
482 GAME_PANEL_TIMEGATE_SWITCH,
483 &game.panel.timegate_switch,
487 GAME_PANEL_TIMEGATE_SWITCH_TIME,
488 &game.panel.timegate_switch_time,
492 GAME_PANEL_SWITCHGATE_SWITCH,
493 &game.panel.switchgate_switch,
497 GAME_PANEL_EMC_LENSES,
498 &game.panel.emc_lenses,
502 GAME_PANEL_EMC_LENSES_TIME,
503 &game.panel.emc_lenses_time,
507 GAME_PANEL_EMC_MAGNIFIER,
508 &game.panel.emc_magnifier,
512 GAME_PANEL_EMC_MAGNIFIER_TIME,
513 &game.panel.emc_magnifier_time,
517 GAME_PANEL_BALLOON_SWITCH,
518 &game.panel.balloon_switch,
522 GAME_PANEL_DYNABOMB_NUMBER,
523 &game.panel.dynabomb_number,
527 GAME_PANEL_DYNABOMB_SIZE,
528 &game.panel.dynabomb_size,
532 GAME_PANEL_DYNABOMB_POWER,
533 &game.panel.dynabomb_power,
538 &game.panel.penguins,
542 GAME_PANEL_SOKOBAN_OBJECTS,
543 &game.panel.sokoban_objects,
547 GAME_PANEL_SOKOBAN_FIELDS,
548 &game.panel.sokoban_fields,
552 GAME_PANEL_ROBOT_WHEEL,
553 &game.panel.robot_wheel,
557 GAME_PANEL_CONVEYOR_BELT_1,
558 &game.panel.conveyor_belt[0],
562 GAME_PANEL_CONVEYOR_BELT_2,
563 &game.panel.conveyor_belt[1],
567 GAME_PANEL_CONVEYOR_BELT_3,
568 &game.panel.conveyor_belt[2],
572 GAME_PANEL_CONVEYOR_BELT_4,
573 &game.panel.conveyor_belt[3],
577 GAME_PANEL_CONVEYOR_BELT_1_SWITCH,
578 &game.panel.conveyor_belt_switch[0],
582 GAME_PANEL_CONVEYOR_BELT_2_SWITCH,
583 &game.panel.conveyor_belt_switch[1],
587 GAME_PANEL_CONVEYOR_BELT_3_SWITCH,
588 &game.panel.conveyor_belt_switch[2],
592 GAME_PANEL_CONVEYOR_BELT_4_SWITCH,
593 &game.panel.conveyor_belt_switch[3],
597 GAME_PANEL_MAGIC_WALL,
598 &game.panel.magic_wall,
602 GAME_PANEL_MAGIC_WALL_TIME,
603 &game.panel.magic_wall_time,
607 GAME_PANEL_GRAVITY_STATE,
608 &game.panel.gravity_state,
612 GAME_PANEL_GRAPHIC_1,
613 &game.panel.graphic[0],
617 GAME_PANEL_GRAPHIC_2,
618 &game.panel.graphic[1],
622 GAME_PANEL_GRAPHIC_3,
623 &game.panel.graphic[2],
627 GAME_PANEL_GRAPHIC_4,
628 &game.panel.graphic[3],
632 GAME_PANEL_GRAPHIC_5,
633 &game.panel.graphic[4],
637 GAME_PANEL_GRAPHIC_6,
638 &game.panel.graphic[5],
642 GAME_PANEL_GRAPHIC_7,
643 &game.panel.graphic[6],
647 GAME_PANEL_GRAPHIC_8,
648 &game.panel.graphic[7],
652 GAME_PANEL_ELEMENT_1,
653 &game.panel.element[0],
657 GAME_PANEL_ELEMENT_2,
658 &game.panel.element[1],
662 GAME_PANEL_ELEMENT_3,
663 &game.panel.element[2],
667 GAME_PANEL_ELEMENT_4,
668 &game.panel.element[3],
672 GAME_PANEL_ELEMENT_5,
673 &game.panel.element[4],
677 GAME_PANEL_ELEMENT_6,
678 &game.panel.element[5],
682 GAME_PANEL_ELEMENT_7,
683 &game.panel.element[6],
687 GAME_PANEL_ELEMENT_8,
688 &game.panel.element[7],
692 GAME_PANEL_ELEMENT_COUNT_1,
693 &game.panel.element_count[0],
697 GAME_PANEL_ELEMENT_COUNT_2,
698 &game.panel.element_count[1],
702 GAME_PANEL_ELEMENT_COUNT_3,
703 &game.panel.element_count[2],
707 GAME_PANEL_ELEMENT_COUNT_4,
708 &game.panel.element_count[3],
712 GAME_PANEL_ELEMENT_COUNT_5,
713 &game.panel.element_count[4],
717 GAME_PANEL_ELEMENT_COUNT_6,
718 &game.panel.element_count[5],
722 GAME_PANEL_ELEMENT_COUNT_7,
723 &game.panel.element_count[6],
727 GAME_PANEL_ELEMENT_COUNT_8,
728 &game.panel.element_count[7],
732 GAME_PANEL_CE_SCORE_1,
733 &game.panel.ce_score[0],
737 GAME_PANEL_CE_SCORE_2,
738 &game.panel.ce_score[1],
742 GAME_PANEL_CE_SCORE_3,
743 &game.panel.ce_score[2],
747 GAME_PANEL_CE_SCORE_4,
748 &game.panel.ce_score[3],
752 GAME_PANEL_CE_SCORE_5,
753 &game.panel.ce_score[4],
757 GAME_PANEL_CE_SCORE_6,
758 &game.panel.ce_score[5],
762 GAME_PANEL_CE_SCORE_7,
763 &game.panel.ce_score[6],
767 GAME_PANEL_CE_SCORE_8,
768 &game.panel.ce_score[7],
772 GAME_PANEL_CE_SCORE_1_ELEMENT,
773 &game.panel.ce_score_element[0],
777 GAME_PANEL_CE_SCORE_2_ELEMENT,
778 &game.panel.ce_score_element[1],
782 GAME_PANEL_CE_SCORE_3_ELEMENT,
783 &game.panel.ce_score_element[2],
787 GAME_PANEL_CE_SCORE_4_ELEMENT,
788 &game.panel.ce_score_element[3],
792 GAME_PANEL_CE_SCORE_5_ELEMENT,
793 &game.panel.ce_score_element[4],
797 GAME_PANEL_CE_SCORE_6_ELEMENT,
798 &game.panel.ce_score_element[5],
802 GAME_PANEL_CE_SCORE_7_ELEMENT,
803 &game.panel.ce_score_element[6],
807 GAME_PANEL_CE_SCORE_8_ELEMENT,
808 &game.panel.ce_score_element[7],
812 GAME_PANEL_PLAYER_NAME,
813 &game.panel.player_name,
817 GAME_PANEL_LEVEL_NAME,
818 &game.panel.level_name,
822 GAME_PANEL_LEVEL_AUTHOR,
823 &game.panel.level_author,
834 // values for delayed check of falling and moving elements and for collision
835 #define CHECK_DELAY_MOVING 3
836 #define CHECK_DELAY_FALLING CHECK_DELAY_MOVING
837 #define CHECK_DELAY_COLLISION 2
838 #define CHECK_DELAY_IMPACT CHECK_DELAY_COLLISION
840 // values for initial player move delay (initial delay counter value)
841 #define INITIAL_MOVE_DELAY_OFF -1
842 #define INITIAL_MOVE_DELAY_ON 0
844 // values for player movement speed (which is in fact a delay value)
845 #define MOVE_DELAY_MIN_SPEED 32
846 #define MOVE_DELAY_NORMAL_SPEED 8
847 #define MOVE_DELAY_HIGH_SPEED 4
848 #define MOVE_DELAY_MAX_SPEED 1
850 #define DOUBLE_MOVE_DELAY(x) (x = (x < MOVE_DELAY_MIN_SPEED ? x * 2 : x))
851 #define HALVE_MOVE_DELAY(x) (x = (x > MOVE_DELAY_MAX_SPEED ? x / 2 : x))
853 #define DOUBLE_PLAYER_SPEED(p) (HALVE_MOVE_DELAY( (p)->move_delay_value))
854 #define HALVE_PLAYER_SPEED(p) (DOUBLE_MOVE_DELAY((p)->move_delay_value))
856 // values for scroll positions
857 #define SCROLL_POSITION_X(x) ((x) < SBX_Left + MIDPOSX ? SBX_Left : \
858 (x) > SBX_Right + MIDPOSX ? SBX_Right :\
860 #define SCROLL_POSITION_Y(y) ((y) < SBY_Upper + MIDPOSY ? SBY_Upper :\
861 (y) > SBY_Lower + MIDPOSY ? SBY_Lower :\
864 // values for other actions
865 #define MOVE_STEPSIZE_NORMAL (TILEX / MOVE_DELAY_NORMAL_SPEED)
866 #define MOVE_STEPSIZE_MIN (1)
867 #define MOVE_STEPSIZE_MAX (TILEX)
869 #define GET_DX_FROM_DIR(d) ((d) == MV_LEFT ? -1 : (d) == MV_RIGHT ? 1 : 0)
870 #define GET_DY_FROM_DIR(d) ((d) == MV_UP ? -1 : (d) == MV_DOWN ? 1 : 0)
872 #define INIT_GFX_RANDOM() (GetSimpleRandom(1000000))
874 #define GET_NEW_PUSH_DELAY(e) ( (element_info[e].push_delay_fixed) + \
875 RND(element_info[e].push_delay_random))
876 #define GET_NEW_DROP_DELAY(e) ( (element_info[e].drop_delay_fixed) + \
877 RND(element_info[e].drop_delay_random))
878 #define GET_NEW_MOVE_DELAY(e) ( (element_info[e].move_delay_fixed) + \
879 RND(element_info[e].move_delay_random))
880 #define GET_MAX_MOVE_DELAY(e) ( (element_info[e].move_delay_fixed) + \
881 (element_info[e].move_delay_random))
882 #define GET_NEW_STEP_DELAY(e) ( (element_info[e].step_delay_fixed) + \
883 RND(element_info[e].step_delay_random))
884 #define GET_MAX_STEP_DELAY(e) ( (element_info[e].step_delay_fixed) + \
885 (element_info[e].step_delay_random))
886 #define GET_NEW_CE_VALUE(e) ( (element_info[e].ce_value_fixed_initial) +\
887 RND(element_info[e].ce_value_random_initial))
888 #define GET_CE_SCORE(e) ( (element_info[e].collect_score))
889 #define GET_CHANGE_DELAY(c) ( ((c)->delay_fixed * (c)->delay_frames) + \
890 RND((c)->delay_random * (c)->delay_frames))
891 #define GET_CE_DELAY_VALUE(c) ( ((c)->delay_fixed) + \
892 RND((c)->delay_random))
895 #define GET_VALID_RUNTIME_ELEMENT(e) \
896 ((e) >= NUM_RUNTIME_ELEMENTS ? EL_UNKNOWN : (e))
898 #define RESOLVED_REFERENCE_ELEMENT(be, e) \
899 ((be) + (e) - EL_SELF < EL_CUSTOM_START ? EL_CUSTOM_START : \
900 (be) + (e) - EL_SELF > EL_CUSTOM_END ? EL_CUSTOM_END : \
901 (be) + (e) - EL_SELF)
903 #define GET_PLAYER_FROM_BITS(p) \
904 (EL_PLAYER_1 + ((p) != PLAYER_BITS_ANY ? log_2(p) : 0))
906 #define GET_TARGET_ELEMENT(be, e, ch, cv, cs) \
907 ((e) == EL_TRIGGER_PLAYER ? (ch)->actual_trigger_player : \
908 (e) == EL_TRIGGER_ELEMENT ? (ch)->actual_trigger_element : \
909 (e) == EL_TRIGGER_CE_VALUE ? (ch)->actual_trigger_ce_value : \
910 (e) == EL_TRIGGER_CE_SCORE ? (ch)->actual_trigger_ce_score : \
911 (e) == EL_CURRENT_CE_VALUE ? (cv) : \
912 (e) == EL_CURRENT_CE_SCORE ? (cs) : \
913 (e) >= EL_PREV_CE_8 && (e) <= EL_NEXT_CE_8 ? \
914 RESOLVED_REFERENCE_ELEMENT(be, e) : \
917 #define CAN_GROW_INTO(e) \
918 ((e) == EL_SAND || (IS_DIGGABLE(e) && level.grow_into_diggable))
920 #define ELEMENT_CAN_ENTER_FIELD_BASE_X(x, y, condition) \
921 (IN_LEV_FIELD(x, y) && (IS_FREE(x, y) || \
924 #define ELEMENT_CAN_ENTER_FIELD_BASE_2(e, x, y, condition) \
925 (IN_LEV_FIELD(x, y) && (IS_FREE(x, y) || \
926 (CAN_MOVE_INTO_ACID(e) && \
927 Tile[x][y] == EL_ACID) || \
930 #define ELEMENT_CAN_ENTER_FIELD_BASE_3(e, x, y, condition) \
931 (IN_LEV_FIELD(x, y) && (IS_FREE_OR_PLAYER(x, y) || \
932 (CAN_MOVE_INTO_ACID(e) && \
933 Tile[x][y] == EL_ACID) || \
936 #define ELEMENT_CAN_ENTER_FIELD_BASE_4(e, x, y, condition) \
937 (IN_LEV_FIELD(x, y) && (IS_FREE(x, y) || \
939 (CAN_MOVE_INTO_ACID(e) && \
940 Tile[x][y] == EL_ACID) || \
941 (DONT_COLLIDE_WITH(e) && \
943 !PLAYER_ENEMY_PROTECTED(x, y))))
945 #define ELEMENT_CAN_ENTER_FIELD(e, x, y) \
946 ELEMENT_CAN_ENTER_FIELD_BASE_4(e, x, y, 0)
948 #define SATELLITE_CAN_ENTER_FIELD(x, y) \
949 ELEMENT_CAN_ENTER_FIELD_BASE_2(EL_SATELLITE, x, y, 0)
951 #define ANDROID_CAN_ENTER_FIELD(e, x, y) \
952 ELEMENT_CAN_ENTER_FIELD_BASE_2(e, x, y, Tile[x][y] == EL_EMC_PLANT)
954 #define ANDROID_CAN_CLONE_FIELD(x, y) \
955 (IN_LEV_FIELD(x, y) && (CAN_BE_CLONED_BY_ANDROID(Tile[x][y]) || \
956 CAN_BE_CLONED_BY_ANDROID(EL_TRIGGER_ELEMENT)))
958 #define ENEMY_CAN_ENTER_FIELD(e, x, y) \
959 ELEMENT_CAN_ENTER_FIELD_BASE_2(e, x, y, 0)
961 #define YAMYAM_CAN_ENTER_FIELD(e, x, y) \
962 ELEMENT_CAN_ENTER_FIELD_BASE_3(e, x, y, Tile[x][y] == EL_DIAMOND)
964 #define DARK_YAMYAM_CAN_ENTER_FIELD(e, x, y) \
965 ELEMENT_CAN_ENTER_FIELD_BASE_3(e, x,y, IS_FOOD_DARK_YAMYAM(Tile[x][y]))
967 #define PACMAN_CAN_ENTER_FIELD(e, x, y) \
968 ELEMENT_CAN_ENTER_FIELD_BASE_3(e, x, y, IS_AMOEBOID(Tile[x][y]))
970 #define PIG_CAN_ENTER_FIELD(e, x, y) \
971 ELEMENT_CAN_ENTER_FIELD_BASE_2(e, x, y, IS_FOOD_PIG(Tile[x][y]))
973 #define PENGUIN_CAN_ENTER_FIELD(e, x, y) \
974 ELEMENT_CAN_ENTER_FIELD_BASE_2(e, x, y, (Tile[x][y] == EL_EXIT_OPEN || \
975 Tile[x][y] == EL_EM_EXIT_OPEN || \
976 Tile[x][y] == EL_STEEL_EXIT_OPEN || \
977 Tile[x][y] == EL_EM_STEEL_EXIT_OPEN || \
978 IS_FOOD_PENGUIN(Tile[x][y])))
979 #define DRAGON_CAN_ENTER_FIELD(e, x, y) \
980 ELEMENT_CAN_ENTER_FIELD_BASE_2(e, x, y, 0)
982 #define MOLE_CAN_ENTER_FIELD(e, x, y, condition) \
983 ELEMENT_CAN_ENTER_FIELD_BASE_2(e, x, y, (condition))
985 #define SPRING_CAN_ENTER_FIELD(e, x, y) \
986 ELEMENT_CAN_ENTER_FIELD_BASE_2(e, x, y, 0)
988 #define SPRING_CAN_BUMP_FROM_FIELD(x, y) \
989 (IN_LEV_FIELD(x, y) && (Tile[x][y] == EL_EMC_SPRING_BUMPER || \
990 Tile[x][y] == EL_EMC_SPRING_BUMPER_ACTIVE))
992 #define MOVE_ENTER_EL(e) (element_info[e].move_enter_element)
994 #define CE_ENTER_FIELD_COND(e, x, y) \
995 (!IS_PLAYER(x, y) && \
996 IS_EQUAL_OR_IN_GROUP(Tile[x][y], MOVE_ENTER_EL(e)))
998 #define CUSTOM_ELEMENT_CAN_ENTER_FIELD(e, x, y) \
999 ELEMENT_CAN_ENTER_FIELD_BASE_4(e, x, y, CE_ENTER_FIELD_COND(e, x, y))
1001 #define IN_LEV_FIELD_AND_IS_FREE(x, y) (IN_LEV_FIELD(x, y) && IS_FREE(x, y))
1002 #define IN_LEV_FIELD_AND_NOT_FREE(x, y) (IN_LEV_FIELD(x, y) && !IS_FREE(x, y))
1004 #define ACCESS_FROM(e, d) (element_info[e].access_direction &(d))
1005 #define IS_WALKABLE_FROM(e, d) (IS_WALKABLE(e) && ACCESS_FROM(e, d))
1006 #define IS_PASSABLE_FROM(e, d) (IS_PASSABLE(e) && ACCESS_FROM(e, d))
1007 #define IS_ACCESSIBLE_FROM(e, d) (IS_ACCESSIBLE(e) && ACCESS_FROM(e, d))
1009 #define MM_HEALTH(x) (MIN(MAX(0, MAX_HEALTH - (x)), MAX_HEALTH))
1011 // game button identifiers
1012 #define GAME_CTRL_ID_STOP 0
1013 #define GAME_CTRL_ID_PAUSE 1
1014 #define GAME_CTRL_ID_PLAY 2
1015 #define GAME_CTRL_ID_UNDO 3
1016 #define GAME_CTRL_ID_REDO 4
1017 #define GAME_CTRL_ID_SAVE 5
1018 #define GAME_CTRL_ID_PAUSE2 6
1019 #define GAME_CTRL_ID_LOAD 7
1020 #define GAME_CTRL_ID_PANEL_STOP 8
1021 #define GAME_CTRL_ID_PANEL_PAUSE 9
1022 #define GAME_CTRL_ID_PANEL_PLAY 10
1023 #define GAME_CTRL_ID_TOUCH_STOP 11
1024 #define GAME_CTRL_ID_TOUCH_PAUSE 12
1025 #define SOUND_CTRL_ID_MUSIC 13
1026 #define SOUND_CTRL_ID_LOOPS 14
1027 #define SOUND_CTRL_ID_SIMPLE 15
1028 #define SOUND_CTRL_ID_PANEL_MUSIC 16
1029 #define SOUND_CTRL_ID_PANEL_LOOPS 17
1030 #define SOUND_CTRL_ID_PANEL_SIMPLE 18
1032 #define NUM_GAME_BUTTONS 19
1035 // forward declaration for internal use
1037 static void CreateField(int, int, int);
1039 static void ResetGfxAnimation(int, int);
1041 static void SetPlayerWaiting(struct PlayerInfo *, boolean);
1042 static void AdvanceFrameAndPlayerCounters(int);
1044 static boolean MovePlayerOneStep(struct PlayerInfo *, int, int, int, int);
1045 static boolean MovePlayer(struct PlayerInfo *, int, int);
1046 static void ScrollPlayer(struct PlayerInfo *, int);
1047 static void ScrollScreen(struct PlayerInfo *, int);
1049 static int DigField(struct PlayerInfo *, int, int, int, int, int, int, int);
1050 static boolean DigFieldByCE(int, int, int);
1051 static boolean SnapField(struct PlayerInfo *, int, int);
1052 static boolean DropElement(struct PlayerInfo *);
1054 static void InitBeltMovement(void);
1055 static void CloseAllOpenTimegates(void);
1056 static void CheckGravityMovement(struct PlayerInfo *);
1057 static void CheckGravityMovementWhenNotMoving(struct PlayerInfo *);
1058 static void KillPlayerUnlessEnemyProtected(int, int);
1059 static void KillPlayerUnlessExplosionProtected(int, int);
1061 static void TestIfPlayerTouchesCustomElement(int, int);
1062 static void TestIfElementTouchesCustomElement(int, int);
1063 static void TestIfElementHitsCustomElement(int, int, int);
1065 static void HandleElementChange(int, int, int);
1066 static void ExecuteCustomElementAction(int, int, int, int);
1067 static boolean ChangeElement(int, int, int, int);
1069 static boolean CheckTriggeredElementChangeExt(int, int, int, int, int,int,int);
1070 #define CheckTriggeredElementChange(x, y, e, ev) \
1071 CheckTriggeredElementChangeExt(x,y,e,ev, CH_PLAYER_ANY,CH_SIDE_ANY, -1)
1072 #define CheckTriggeredElementChangeByPlayer(x, y, e, ev, p, s) \
1073 CheckTriggeredElementChangeExt(x, y, e, ev, p, s, -1)
1074 #define CheckTriggeredElementChangeBySide(x, y, e, ev, s) \
1075 CheckTriggeredElementChangeExt(x, y, e, ev, CH_PLAYER_ANY, s, -1)
1076 #define CheckTriggeredElementChangeByPage(x, y, e, ev, p) \
1077 CheckTriggeredElementChangeExt(x,y,e,ev, CH_PLAYER_ANY, CH_SIDE_ANY, p)
1078 #define CheckTriggeredElementChangeByMouse(x, y, e, ev, s) \
1079 CheckTriggeredElementChangeExt(x, y, e, ev, CH_PLAYER_ANY, s, -1)
1081 static boolean CheckElementChangeExt(int, int, int, int, int, int, int);
1082 #define CheckElementChange(x, y, e, te, ev) \
1083 CheckElementChangeExt(x, y, e, te, ev, CH_PLAYER_ANY, CH_SIDE_ANY)
1084 #define CheckElementChangeByPlayer(x, y, e, ev, p, s) \
1085 CheckElementChangeExt(x, y, e, EL_EMPTY, ev, p, s)
1086 #define CheckElementChangeBySide(x, y, e, te, ev, s) \
1087 CheckElementChangeExt(x, y, e, te, ev, CH_PLAYER_ANY, s)
1088 #define CheckElementChangeByMouse(x, y, e, ev, s) \
1089 CheckElementChangeExt(x, y, e, EL_UNDEFINED, ev, CH_PLAYER_ANY, s)
1091 static void PlayLevelSound(int, int, int);
1092 static void PlayLevelSoundNearest(int, int, int);
1093 static void PlayLevelSoundAction(int, int, int);
1094 static void PlayLevelSoundElementAction(int, int, int, int);
1095 static void PlayLevelSoundElementActionIfLoop(int, int, int, int);
1096 static void PlayLevelSoundActionIfLoop(int, int, int);
1097 static void StopLevelSoundActionIfLoop(int, int, int);
1098 static void PlayLevelMusic(void);
1099 static void FadeLevelSoundsAndMusic(void);
1101 static void HandleGameButtons(struct GadgetInfo *);
1103 int AmoebaNeighbourNr(int, int);
1104 void AmoebaToDiamond(int, int);
1105 void ContinueMoving(int, int);
1106 void Bang(int, int);
1107 void InitMovDir(int, int);
1108 void InitAmoebaNr(int, int);
1109 void NewHighScore(int);
1111 void TestIfGoodThingHitsBadThing(int, int, int);
1112 void TestIfBadThingHitsGoodThing(int, int, int);
1113 void TestIfPlayerTouchesBadThing(int, int);
1114 void TestIfPlayerRunsIntoBadThing(int, int, int);
1115 void TestIfBadThingTouchesPlayer(int, int);
1116 void TestIfBadThingRunsIntoPlayer(int, int, int);
1117 void TestIfFriendTouchesBadThing(int, int);
1118 void TestIfBadThingTouchesFriend(int, int);
1119 void TestIfBadThingTouchesOtherBadThing(int, int);
1120 void TestIfGoodThingGetsHitByBadThing(int, int, int);
1122 void KillPlayer(struct PlayerInfo *);
1123 void BuryPlayer(struct PlayerInfo *);
1124 void RemovePlayer(struct PlayerInfo *);
1125 void ExitPlayer(struct PlayerInfo *);
1127 static int getInvisibleActiveFromInvisibleElement(int);
1128 static int getInvisibleFromInvisibleActiveElement(int);
1130 static void TestFieldAfterSnapping(int, int, int, int, int);
1132 static struct GadgetInfo *game_gadget[NUM_GAME_BUTTONS];
1134 // for detection of endless loops, caused by custom element programming
1135 // (using maximal playfield width x 10 is just a rough approximation)
1136 #define MAX_ELEMENT_CHANGE_RECURSION_DEPTH (MAX_PLAYFIELD_WIDTH * 10)
1138 #define RECURSION_LOOP_DETECTION_START(e, rc) \
1140 if (recursion_loop_detected) \
1143 if (recursion_loop_depth > MAX_ELEMENT_CHANGE_RECURSION_DEPTH) \
1145 recursion_loop_detected = TRUE; \
1146 recursion_loop_element = (e); \
1149 recursion_loop_depth++; \
1152 #define RECURSION_LOOP_DETECTION_END() \
1154 recursion_loop_depth--; \
1157 static int recursion_loop_depth;
1158 static boolean recursion_loop_detected;
1159 static boolean recursion_loop_element;
1161 static int map_player_action[MAX_PLAYERS];
1164 // ----------------------------------------------------------------------------
1165 // definition of elements that automatically change to other elements after
1166 // a specified time, eventually calling a function when changing
1167 // ----------------------------------------------------------------------------
1169 // forward declaration for changer functions
1170 static void InitBuggyBase(int, int);
1171 static void WarnBuggyBase(int, int);
1173 static void InitTrap(int, int);
1174 static void ActivateTrap(int, int);
1175 static void ChangeActiveTrap(int, int);
1177 static void InitRobotWheel(int, int);
1178 static void RunRobotWheel(int, int);
1179 static void StopRobotWheel(int, int);
1181 static void InitTimegateWheel(int, int);
1182 static void RunTimegateWheel(int, int);
1184 static void InitMagicBallDelay(int, int);
1185 static void ActivateMagicBall(int, int);
1187 struct ChangingElementInfo
1192 void (*pre_change_function)(int x, int y);
1193 void (*change_function)(int x, int y);
1194 void (*post_change_function)(int x, int y);
1197 static struct ChangingElementInfo change_delay_list[] =
1232 EL_STEEL_EXIT_OPENING,
1240 EL_STEEL_EXIT_CLOSING,
1241 EL_STEEL_EXIT_CLOSED,
1264 EL_EM_STEEL_EXIT_OPENING,
1265 EL_EM_STEEL_EXIT_OPEN,
1272 EL_EM_STEEL_EXIT_CLOSING,
1296 EL_SWITCHGATE_OPENING,
1304 EL_SWITCHGATE_CLOSING,
1305 EL_SWITCHGATE_CLOSED,
1312 EL_TIMEGATE_OPENING,
1320 EL_TIMEGATE_CLOSING,
1329 EL_ACID_SPLASH_LEFT,
1337 EL_ACID_SPLASH_RIGHT,
1346 EL_SP_BUGGY_BASE_ACTIVATING,
1353 EL_SP_BUGGY_BASE_ACTIVATING,
1354 EL_SP_BUGGY_BASE_ACTIVE,
1361 EL_SP_BUGGY_BASE_ACTIVE,
1385 EL_ROBOT_WHEEL_ACTIVE,
1393 EL_TIMEGATE_SWITCH_ACTIVE,
1401 EL_DC_TIMEGATE_SWITCH_ACTIVE,
1402 EL_DC_TIMEGATE_SWITCH,
1409 EL_EMC_MAGIC_BALL_ACTIVE,
1410 EL_EMC_MAGIC_BALL_ACTIVE,
1417 EL_EMC_SPRING_BUMPER_ACTIVE,
1418 EL_EMC_SPRING_BUMPER,
1425 EL_DIAGONAL_SHRINKING,
1433 EL_DIAGONAL_GROWING,
1454 int push_delay_fixed, push_delay_random;
1458 { EL_SPRING, 0, 0 },
1459 { EL_BALLOON, 0, 0 },
1461 { EL_SOKOBAN_OBJECT, 2, 0 },
1462 { EL_SOKOBAN_FIELD_FULL, 2, 0 },
1463 { EL_SATELLITE, 2, 0 },
1464 { EL_SP_DISK_YELLOW, 2, 0 },
1466 { EL_UNDEFINED, 0, 0 },
1474 move_stepsize_list[] =
1476 { EL_AMOEBA_DROP, 2 },
1477 { EL_AMOEBA_DROPPING, 2 },
1478 { EL_QUICKSAND_FILLING, 1 },
1479 { EL_QUICKSAND_EMPTYING, 1 },
1480 { EL_QUICKSAND_FAST_FILLING, 2 },
1481 { EL_QUICKSAND_FAST_EMPTYING, 2 },
1482 { EL_MAGIC_WALL_FILLING, 2 },
1483 { EL_MAGIC_WALL_EMPTYING, 2 },
1484 { EL_BD_MAGIC_WALL_FILLING, 2 },
1485 { EL_BD_MAGIC_WALL_EMPTYING, 2 },
1486 { EL_DC_MAGIC_WALL_FILLING, 2 },
1487 { EL_DC_MAGIC_WALL_EMPTYING, 2 },
1489 { EL_UNDEFINED, 0 },
1497 collect_count_list[] =
1500 { EL_BD_DIAMOND, 1 },
1501 { EL_EMERALD_YELLOW, 1 },
1502 { EL_EMERALD_RED, 1 },
1503 { EL_EMERALD_PURPLE, 1 },
1505 { EL_SP_INFOTRON, 1 },
1509 { EL_UNDEFINED, 0 },
1517 access_direction_list[] =
1519 { EL_TUBE_ANY, MV_LEFT | MV_RIGHT | MV_UP | MV_DOWN },
1520 { EL_TUBE_VERTICAL, MV_UP | MV_DOWN },
1521 { EL_TUBE_HORIZONTAL, MV_LEFT | MV_RIGHT },
1522 { EL_TUBE_VERTICAL_LEFT, MV_LEFT | MV_UP | MV_DOWN },
1523 { EL_TUBE_VERTICAL_RIGHT, MV_RIGHT | MV_UP | MV_DOWN },
1524 { EL_TUBE_HORIZONTAL_UP, MV_LEFT | MV_RIGHT | MV_UP },
1525 { EL_TUBE_HORIZONTAL_DOWN, MV_LEFT | MV_RIGHT | MV_DOWN },
1526 { EL_TUBE_LEFT_UP, MV_LEFT | MV_UP },
1527 { EL_TUBE_LEFT_DOWN, MV_LEFT | MV_DOWN },
1528 { EL_TUBE_RIGHT_UP, MV_RIGHT | MV_UP },
1529 { EL_TUBE_RIGHT_DOWN, MV_RIGHT | MV_DOWN },
1531 { EL_SP_PORT_LEFT, MV_RIGHT },
1532 { EL_SP_PORT_RIGHT, MV_LEFT },
1533 { EL_SP_PORT_UP, MV_DOWN },
1534 { EL_SP_PORT_DOWN, MV_UP },
1535 { EL_SP_PORT_HORIZONTAL, MV_LEFT | MV_RIGHT },
1536 { EL_SP_PORT_VERTICAL, MV_UP | MV_DOWN },
1537 { EL_SP_PORT_ANY, MV_LEFT | MV_RIGHT | MV_UP | MV_DOWN },
1538 { EL_SP_GRAVITY_PORT_LEFT, MV_RIGHT },
1539 { EL_SP_GRAVITY_PORT_RIGHT, MV_LEFT },
1540 { EL_SP_GRAVITY_PORT_UP, MV_DOWN },
1541 { EL_SP_GRAVITY_PORT_DOWN, MV_UP },
1542 { EL_SP_GRAVITY_ON_PORT_LEFT, MV_RIGHT },
1543 { EL_SP_GRAVITY_ON_PORT_RIGHT, MV_LEFT },
1544 { EL_SP_GRAVITY_ON_PORT_UP, MV_DOWN },
1545 { EL_SP_GRAVITY_ON_PORT_DOWN, MV_UP },
1546 { EL_SP_GRAVITY_OFF_PORT_LEFT, MV_RIGHT },
1547 { EL_SP_GRAVITY_OFF_PORT_RIGHT, MV_LEFT },
1548 { EL_SP_GRAVITY_OFF_PORT_UP, MV_DOWN },
1549 { EL_SP_GRAVITY_OFF_PORT_DOWN, MV_UP },
1551 { EL_UNDEFINED, MV_NONE }
1554 static boolean trigger_events[MAX_NUM_ELEMENTS][NUM_CHANGE_EVENTS];
1556 #define IS_AUTO_CHANGING(e) (element_info[e].has_change_event[CE_DELAY])
1557 #define IS_JUST_CHANGING(x, y) (ChangeDelay[x][y] != 0)
1558 #define IS_CHANGING(x, y) (IS_AUTO_CHANGING(Tile[x][y]) || \
1559 IS_JUST_CHANGING(x, y))
1561 #define CE_PAGE(e, ce) (element_info[e].event_page[ce])
1563 // static variables for playfield scan mode (scanning forward or backward)
1564 static int playfield_scan_start_x = 0;
1565 static int playfield_scan_start_y = 0;
1566 static int playfield_scan_delta_x = 1;
1567 static int playfield_scan_delta_y = 1;
1569 #define SCAN_PLAYFIELD(x, y) for ((y) = playfield_scan_start_y; \
1570 (y) >= 0 && (y) <= lev_fieldy - 1; \
1571 (y) += playfield_scan_delta_y) \
1572 for ((x) = playfield_scan_start_x; \
1573 (x) >= 0 && (x) <= lev_fieldx - 1; \
1574 (x) += playfield_scan_delta_x)
1577 void DEBUG_SetMaximumDynamite(void)
1581 for (i = 0; i < MAX_INVENTORY_SIZE; i++)
1582 if (local_player->inventory_size < MAX_INVENTORY_SIZE)
1583 local_player->inventory_element[local_player->inventory_size++] =
1588 static void InitPlayfieldScanModeVars(void)
1590 if (game.use_reverse_scan_direction)
1592 playfield_scan_start_x = lev_fieldx - 1;
1593 playfield_scan_start_y = lev_fieldy - 1;
1595 playfield_scan_delta_x = -1;
1596 playfield_scan_delta_y = -1;
1600 playfield_scan_start_x = 0;
1601 playfield_scan_start_y = 0;
1603 playfield_scan_delta_x = 1;
1604 playfield_scan_delta_y = 1;
1608 static void InitPlayfieldScanMode(int mode)
1610 game.use_reverse_scan_direction =
1611 (mode == CA_ARG_SCAN_MODE_REVERSE ? TRUE : FALSE);
1613 InitPlayfieldScanModeVars();
1616 static int get_move_delay_from_stepsize(int move_stepsize)
1619 MIN(MAX(MOVE_STEPSIZE_MIN, move_stepsize), MOVE_STEPSIZE_MAX);
1621 // make sure that stepsize value is always a power of 2
1622 move_stepsize = (1 << log_2(move_stepsize));
1624 return TILEX / move_stepsize;
1627 static void SetPlayerMoveSpeed(struct PlayerInfo *player, int move_stepsize,
1630 int player_nr = player->index_nr;
1631 int move_delay = get_move_delay_from_stepsize(move_stepsize);
1632 boolean cannot_move = (move_stepsize == STEPSIZE_NOT_MOVING ? TRUE : FALSE);
1634 // do no immediately change move delay -- the player might just be moving
1635 player->move_delay_value_next = move_delay;
1637 // information if player can move must be set separately
1638 player->cannot_move = cannot_move;
1642 player->move_delay = game.initial_move_delay[player_nr];
1643 player->move_delay_value = game.initial_move_delay_value[player_nr];
1645 player->move_delay_value_next = -1;
1647 player->move_delay_reset_counter = 0;
1651 void GetPlayerConfig(void)
1653 GameFrameDelay = setup.game_frame_delay;
1655 if (!audio.sound_available)
1656 setup.sound_simple = FALSE;
1658 if (!audio.loops_available)
1659 setup.sound_loops = FALSE;
1661 if (!audio.music_available)
1662 setup.sound_music = FALSE;
1664 if (!video.fullscreen_available)
1665 setup.fullscreen = FALSE;
1667 setup.sound = (setup.sound_simple || setup.sound_loops || setup.sound_music);
1669 SetAudioMode(setup.sound);
1672 int GetElementFromGroupElement(int element)
1674 if (IS_GROUP_ELEMENT(element))
1676 struct ElementGroupInfo *group = element_info[element].group;
1677 int last_anim_random_frame = gfx.anim_random_frame;
1680 if (group->choice_mode == ANIM_RANDOM)
1681 gfx.anim_random_frame = RND(group->num_elements_resolved);
1683 element_pos = getAnimationFrame(group->num_elements_resolved, 1,
1684 group->choice_mode, 0,
1687 if (group->choice_mode == ANIM_RANDOM)
1688 gfx.anim_random_frame = last_anim_random_frame;
1690 group->choice_pos++;
1692 element = group->element_resolved[element_pos];
1698 static void IncrementSokobanFieldsNeeded(void)
1700 if (level.sb_fields_needed)
1701 game.sokoban_fields_still_needed++;
1704 static void IncrementSokobanObjectsNeeded(void)
1706 if (level.sb_objects_needed)
1707 game.sokoban_objects_still_needed++;
1710 static void DecrementSokobanFieldsNeeded(void)
1712 if (game.sokoban_fields_still_needed > 0)
1713 game.sokoban_fields_still_needed--;
1716 static void DecrementSokobanObjectsNeeded(void)
1718 if (game.sokoban_objects_still_needed > 0)
1719 game.sokoban_objects_still_needed--;
1722 static void InitPlayerField(int x, int y, int element, boolean init_game)
1724 if (element == EL_SP_MURPHY)
1728 if (stored_player[0].present)
1730 Tile[x][y] = EL_SP_MURPHY_CLONE;
1736 stored_player[0].initial_element = element;
1737 stored_player[0].use_murphy = TRUE;
1739 if (!level.use_artwork_element[0])
1740 stored_player[0].artwork_element = EL_SP_MURPHY;
1743 Tile[x][y] = EL_PLAYER_1;
1749 struct PlayerInfo *player = &stored_player[Tile[x][y] - EL_PLAYER_1];
1750 int jx = player->jx, jy = player->jy;
1752 player->present = TRUE;
1754 player->block_last_field = (element == EL_SP_MURPHY ?
1755 level.sp_block_last_field :
1756 level.block_last_field);
1758 // ---------- initialize player's last field block delay ------------------
1760 // always start with reliable default value (no adjustment needed)
1761 player->block_delay_adjustment = 0;
1763 // special case 1: in Supaplex, Murphy blocks last field one more frame
1764 if (player->block_last_field && element == EL_SP_MURPHY)
1765 player->block_delay_adjustment = 1;
1767 // special case 2: in game engines before 3.1.1, blocking was different
1768 if (game.use_block_last_field_bug)
1769 player->block_delay_adjustment = (player->block_last_field ? -1 : 1);
1771 if (!network.enabled || player->connected_network)
1773 player->active = TRUE;
1775 // remove potentially duplicate players
1776 if (StorePlayer[jx][jy] == Tile[x][y])
1777 StorePlayer[jx][jy] = 0;
1779 StorePlayer[x][y] = Tile[x][y];
1781 #if DEBUG_INIT_PLAYER
1782 Debug("game:init:player", "- player element %d activated",
1783 player->element_nr);
1784 Debug("game:init:player", " (local player is %d and currently %s)",
1785 local_player->element_nr,
1786 local_player->active ? "active" : "not active");
1790 Tile[x][y] = EL_EMPTY;
1792 player->jx = player->last_jx = x;
1793 player->jy = player->last_jy = y;
1796 // always check if player was just killed and should be reanimated
1798 int player_nr = GET_PLAYER_NR(element);
1799 struct PlayerInfo *player = &stored_player[player_nr];
1801 if (player->active && player->killed)
1802 player->reanimated = TRUE; // if player was just killed, reanimate him
1806 static void InitField(int x, int y, boolean init_game)
1808 int element = Tile[x][y];
1817 InitPlayerField(x, y, element, init_game);
1820 case EL_SOKOBAN_FIELD_PLAYER:
1821 element = Tile[x][y] = EL_PLAYER_1;
1822 InitField(x, y, init_game);
1824 element = Tile[x][y] = EL_SOKOBAN_FIELD_EMPTY;
1825 InitField(x, y, init_game);
1828 case EL_SOKOBAN_FIELD_EMPTY:
1829 IncrementSokobanFieldsNeeded();
1832 case EL_SOKOBAN_OBJECT:
1833 IncrementSokobanObjectsNeeded();
1837 if (x < lev_fieldx-1 && Tile[x+1][y] == EL_ACID)
1838 Tile[x][y] = EL_ACID_POOL_TOPLEFT;
1839 else if (x > 0 && Tile[x-1][y] == EL_ACID)
1840 Tile[x][y] = EL_ACID_POOL_TOPRIGHT;
1841 else if (y > 0 && Tile[x][y-1] == EL_ACID_POOL_TOPLEFT)
1842 Tile[x][y] = EL_ACID_POOL_BOTTOMLEFT;
1843 else if (y > 0 && Tile[x][y-1] == EL_ACID)
1844 Tile[x][y] = EL_ACID_POOL_BOTTOM;
1845 else if (y > 0 && Tile[x][y-1] == EL_ACID_POOL_TOPRIGHT)
1846 Tile[x][y] = EL_ACID_POOL_BOTTOMRIGHT;
1855 case EL_SPACESHIP_RIGHT:
1856 case EL_SPACESHIP_UP:
1857 case EL_SPACESHIP_LEFT:
1858 case EL_SPACESHIP_DOWN:
1859 case EL_BD_BUTTERFLY:
1860 case EL_BD_BUTTERFLY_RIGHT:
1861 case EL_BD_BUTTERFLY_UP:
1862 case EL_BD_BUTTERFLY_LEFT:
1863 case EL_BD_BUTTERFLY_DOWN:
1865 case EL_BD_FIREFLY_RIGHT:
1866 case EL_BD_FIREFLY_UP:
1867 case EL_BD_FIREFLY_LEFT:
1868 case EL_BD_FIREFLY_DOWN:
1869 case EL_PACMAN_RIGHT:
1871 case EL_PACMAN_LEFT:
1872 case EL_PACMAN_DOWN:
1874 case EL_YAMYAM_LEFT:
1875 case EL_YAMYAM_RIGHT:
1877 case EL_YAMYAM_DOWN:
1878 case EL_DARK_YAMYAM:
1881 case EL_SP_SNIKSNAK:
1882 case EL_SP_ELECTRON:
1888 case EL_SPRING_LEFT:
1889 case EL_SPRING_RIGHT:
1893 case EL_AMOEBA_FULL:
1898 case EL_AMOEBA_DROP:
1899 if (y == lev_fieldy - 1)
1901 Tile[x][y] = EL_AMOEBA_GROWING;
1902 Store[x][y] = EL_AMOEBA_WET;
1906 case EL_DYNAMITE_ACTIVE:
1907 case EL_SP_DISK_RED_ACTIVE:
1908 case EL_DYNABOMB_PLAYER_1_ACTIVE:
1909 case EL_DYNABOMB_PLAYER_2_ACTIVE:
1910 case EL_DYNABOMB_PLAYER_3_ACTIVE:
1911 case EL_DYNABOMB_PLAYER_4_ACTIVE:
1912 MovDelay[x][y] = 96;
1915 case EL_EM_DYNAMITE_ACTIVE:
1916 MovDelay[x][y] = 32;
1920 game.lights_still_needed++;
1924 game.friends_still_needed++;
1929 GfxDir[x][y] = MovDir[x][y] = 1 << RND(4);
1932 case EL_CONVEYOR_BELT_1_SWITCH_LEFT:
1933 case EL_CONVEYOR_BELT_1_SWITCH_MIDDLE:
1934 case EL_CONVEYOR_BELT_1_SWITCH_RIGHT:
1935 case EL_CONVEYOR_BELT_2_SWITCH_LEFT:
1936 case EL_CONVEYOR_BELT_2_SWITCH_MIDDLE:
1937 case EL_CONVEYOR_BELT_2_SWITCH_RIGHT:
1938 case EL_CONVEYOR_BELT_3_SWITCH_LEFT:
1939 case EL_CONVEYOR_BELT_3_SWITCH_MIDDLE:
1940 case EL_CONVEYOR_BELT_3_SWITCH_RIGHT:
1941 case EL_CONVEYOR_BELT_4_SWITCH_LEFT:
1942 case EL_CONVEYOR_BELT_4_SWITCH_MIDDLE:
1943 case EL_CONVEYOR_BELT_4_SWITCH_RIGHT:
1946 int belt_nr = getBeltNrFromBeltSwitchElement(Tile[x][y]);
1947 int belt_dir = getBeltDirFromBeltSwitchElement(Tile[x][y]);
1948 int belt_dir_nr = getBeltDirNrFromBeltSwitchElement(Tile[x][y]);
1950 if (game.belt_dir_nr[belt_nr] == 3) // initial value
1952 game.belt_dir[belt_nr] = belt_dir;
1953 game.belt_dir_nr[belt_nr] = belt_dir_nr;
1955 else // more than one switch -- set it like the first switch
1957 Tile[x][y] = Tile[x][y] - belt_dir_nr + game.belt_dir_nr[belt_nr];
1962 case EL_LIGHT_SWITCH_ACTIVE:
1964 game.light_time_left = level.time_light * FRAMES_PER_SECOND;
1967 case EL_INVISIBLE_STEELWALL:
1968 case EL_INVISIBLE_WALL:
1969 case EL_INVISIBLE_SAND:
1970 if (game.light_time_left > 0 ||
1971 game.lenses_time_left > 0)
1972 Tile[x][y] = getInvisibleActiveFromInvisibleElement(element);
1975 case EL_EMC_MAGIC_BALL:
1976 if (game.ball_active)
1977 Tile[x][y] = EL_EMC_MAGIC_BALL_ACTIVE;
1980 case EL_EMC_MAGIC_BALL_SWITCH:
1981 if (game.ball_active)
1982 Tile[x][y] = EL_EMC_MAGIC_BALL_SWITCH_ACTIVE;
1985 case EL_TRIGGER_PLAYER:
1986 case EL_TRIGGER_ELEMENT:
1987 case EL_TRIGGER_CE_VALUE:
1988 case EL_TRIGGER_CE_SCORE:
1990 case EL_ANY_ELEMENT:
1991 case EL_CURRENT_CE_VALUE:
1992 case EL_CURRENT_CE_SCORE:
2009 // reference elements should not be used on the playfield
2010 Tile[x][y] = EL_EMPTY;
2014 if (IS_CUSTOM_ELEMENT(element))
2016 if (CAN_MOVE(element))
2019 if (!element_info[element].use_last_ce_value || init_game)
2020 CustomValue[x][y] = GET_NEW_CE_VALUE(Tile[x][y]);
2022 else if (IS_GROUP_ELEMENT(element))
2024 Tile[x][y] = GetElementFromGroupElement(element);
2026 InitField(x, y, init_game);
2033 CheckTriggeredElementChange(x, y, element, CE_CREATION_OF_X);
2036 static void InitField_WithBug1(int x, int y, boolean init_game)
2038 InitField(x, y, init_game);
2040 // not needed to call InitMovDir() -- already done by InitField()!
2041 if (game.engine_version < VERSION_IDENT(3,1,0,0) &&
2042 CAN_MOVE(Tile[x][y]))
2046 static void InitField_WithBug2(int x, int y, boolean init_game)
2048 int old_element = Tile[x][y];
2050 InitField(x, y, init_game);
2052 // not needed to call InitMovDir() -- already done by InitField()!
2053 if (game.engine_version < VERSION_IDENT(3,1,0,0) &&
2054 CAN_MOVE(old_element) &&
2055 (old_element < EL_MOLE_LEFT || old_element > EL_MOLE_DOWN))
2058 /* this case is in fact a combination of not less than three bugs:
2059 first, it calls InitMovDir() for elements that can move, although this is
2060 already done by InitField(); then, it checks the element that was at this
2061 field _before_ the call to InitField() (which can change it); lastly, it
2062 was not called for "mole with direction" elements, which were treated as
2063 "cannot move" due to (fixed) wrong element initialization in "src/init.c"
2067 static int get_key_element_from_nr(int key_nr)
2069 int key_base_element = (key_nr >= STD_NUM_KEYS ? EL_EMC_KEY_5 - STD_NUM_KEYS :
2070 level.game_engine_type == GAME_ENGINE_TYPE_EM ?
2071 EL_EM_KEY_1 : EL_KEY_1);
2073 return key_base_element + key_nr;
2076 static int get_next_dropped_element(struct PlayerInfo *player)
2078 return (player->inventory_size > 0 ?
2079 player->inventory_element[player->inventory_size - 1] :
2080 player->inventory_infinite_element != EL_UNDEFINED ?
2081 player->inventory_infinite_element :
2082 player->dynabombs_left > 0 ?
2083 EL_DYNABOMB_PLAYER_1_ACTIVE + player->index_nr :
2087 static int get_inventory_element_from_pos(struct PlayerInfo *player, int pos)
2089 // pos >= 0: get element from bottom of the stack;
2090 // pos < 0: get element from top of the stack
2094 int min_inventory_size = -pos;
2095 int inventory_pos = player->inventory_size - min_inventory_size;
2096 int min_dynabombs_left = min_inventory_size - player->inventory_size;
2098 return (player->inventory_size >= min_inventory_size ?
2099 player->inventory_element[inventory_pos] :
2100 player->inventory_infinite_element != EL_UNDEFINED ?
2101 player->inventory_infinite_element :
2102 player->dynabombs_left >= min_dynabombs_left ?
2103 EL_DYNABOMB_PLAYER_1 + player->index_nr :
2108 int min_dynabombs_left = pos + 1;
2109 int min_inventory_size = pos + 1 - player->dynabombs_left;
2110 int inventory_pos = pos - player->dynabombs_left;
2112 return (player->inventory_infinite_element != EL_UNDEFINED ?
2113 player->inventory_infinite_element :
2114 player->dynabombs_left >= min_dynabombs_left ?
2115 EL_DYNABOMB_PLAYER_1 + player->index_nr :
2116 player->inventory_size >= min_inventory_size ?
2117 player->inventory_element[inventory_pos] :
2122 static int compareGamePanelOrderInfo(const void *object1, const void *object2)
2124 const struct GamePanelOrderInfo *gpo1 = (struct GamePanelOrderInfo *)object1;
2125 const struct GamePanelOrderInfo *gpo2 = (struct GamePanelOrderInfo *)object2;
2128 if (gpo1->sort_priority != gpo2->sort_priority)
2129 compare_result = gpo1->sort_priority - gpo2->sort_priority;
2131 compare_result = gpo1->nr - gpo2->nr;
2133 return compare_result;
2136 int getPlayerInventorySize(int player_nr)
2138 if (level.game_engine_type == GAME_ENGINE_TYPE_EM)
2139 return game_em.ply[player_nr]->dynamite;
2140 else if (level.game_engine_type == GAME_ENGINE_TYPE_SP)
2141 return game_sp.red_disk_count;
2143 return stored_player[player_nr].inventory_size;
2146 static void InitGameControlValues(void)
2150 for (i = 0; game_panel_controls[i].nr != -1; i++)
2152 struct GamePanelControlInfo *gpc = &game_panel_controls[i];
2153 struct GamePanelOrderInfo *gpo = &game_panel_order[i];
2154 struct TextPosInfo *pos = gpc->pos;
2156 int type = gpc->type;
2160 Error("'game_panel_controls' structure corrupted at %d", i);
2162 Fail("this should not happen -- please debug");
2165 // force update of game controls after initialization
2166 gpc->value = gpc->last_value = -1;
2167 gpc->frame = gpc->last_frame = -1;
2168 gpc->gfx_frame = -1;
2170 // determine panel value width for later calculation of alignment
2171 if (type == TYPE_INTEGER || type == TYPE_STRING)
2173 pos->width = pos->size * getFontWidth(pos->font);
2174 pos->height = getFontHeight(pos->font);
2176 else if (type == TYPE_ELEMENT)
2178 pos->width = pos->size;
2179 pos->height = pos->size;
2182 // fill structure for game panel draw order
2184 gpo->sort_priority = pos->sort_priority;
2187 // sort game panel controls according to sort_priority and control number
2188 qsort(game_panel_order, NUM_GAME_PANEL_CONTROLS,
2189 sizeof(struct GamePanelOrderInfo), compareGamePanelOrderInfo);
2192 static void UpdatePlayfieldElementCount(void)
2194 boolean use_element_count = FALSE;
2197 // first check if it is needed at all to calculate playfield element count
2198 for (i = GAME_PANEL_ELEMENT_COUNT_1; i <= GAME_PANEL_ELEMENT_COUNT_8; i++)
2199 if (!PANEL_DEACTIVATED(game_panel_controls[i].pos))
2200 use_element_count = TRUE;
2202 if (!use_element_count)
2205 for (i = 0; i < MAX_NUM_ELEMENTS; i++)
2206 element_info[i].element_count = 0;
2208 SCAN_PLAYFIELD(x, y)
2210 element_info[Tile[x][y]].element_count++;
2213 for (i = 0; i < NUM_GROUP_ELEMENTS; i++)
2214 for (j = 0; j < MAX_NUM_ELEMENTS; j++)
2215 if (IS_IN_GROUP(j, i))
2216 element_info[EL_GROUP_START + i].element_count +=
2217 element_info[j].element_count;
2220 static void UpdateGameControlValues(void)
2223 int time = (game.LevelSolved ?
2224 game.LevelSolved_CountingTime :
2225 level.game_engine_type == GAME_ENGINE_TYPE_EM ?
2227 level.game_engine_type == GAME_ENGINE_TYPE_SP ?
2228 game_sp.time_played :
2229 level.game_engine_type == GAME_ENGINE_TYPE_MM ?
2230 game_mm.energy_left :
2231 game.no_time_limit ? TimePlayed : TimeLeft);
2232 int score = (game.LevelSolved ?
2233 game.LevelSolved_CountingScore :
2234 level.game_engine_type == GAME_ENGINE_TYPE_EM ?
2235 game_em.lev->score :
2236 level.game_engine_type == GAME_ENGINE_TYPE_SP ?
2238 level.game_engine_type == GAME_ENGINE_TYPE_MM ?
2241 int gems = (level.game_engine_type == GAME_ENGINE_TYPE_EM ?
2242 game_em.lev->gems_needed :
2243 level.game_engine_type == GAME_ENGINE_TYPE_SP ?
2244 game_sp.infotrons_still_needed :
2245 level.game_engine_type == GAME_ENGINE_TYPE_MM ?
2246 game_mm.kettles_still_needed :
2247 game.gems_still_needed);
2248 int exit_closed = (level.game_engine_type == GAME_ENGINE_TYPE_EM ?
2249 game_em.lev->gems_needed > 0 :
2250 level.game_engine_type == GAME_ENGINE_TYPE_SP ?
2251 game_sp.infotrons_still_needed > 0 :
2252 level.game_engine_type == GAME_ENGINE_TYPE_MM ?
2253 game_mm.kettles_still_needed > 0 ||
2254 game_mm.lights_still_needed > 0 :
2255 game.gems_still_needed > 0 ||
2256 game.sokoban_fields_still_needed > 0 ||
2257 game.sokoban_objects_still_needed > 0 ||
2258 game.lights_still_needed > 0);
2259 int health = (game.LevelSolved ?
2260 game.LevelSolved_CountingHealth :
2261 level.game_engine_type == GAME_ENGINE_TYPE_MM ?
2262 MM_HEALTH(game_mm.laser_overload_value) :
2264 int sync_random_frame = INIT_GFX_RANDOM(); // random, but synchronized
2266 UpdatePlayfieldElementCount();
2268 // update game panel control values
2270 // used instead of "level_nr" (for network games)
2271 game_panel_controls[GAME_PANEL_LEVEL_NUMBER].value = levelset.level_nr;
2272 game_panel_controls[GAME_PANEL_GEMS].value = gems;
2274 game_panel_controls[GAME_PANEL_INVENTORY_COUNT].value = 0;
2275 for (i = 0; i < MAX_NUM_KEYS; i++)
2276 game_panel_controls[GAME_PANEL_KEY_1 + i].value = EL_EMPTY;
2277 game_panel_controls[GAME_PANEL_KEY_WHITE].value = EL_EMPTY;
2278 game_panel_controls[GAME_PANEL_KEY_WHITE_COUNT].value = 0;
2280 if (game.centered_player_nr == -1)
2282 for (i = 0; i < MAX_PLAYERS; i++)
2284 // only one player in Supaplex game engine
2285 if (level.game_engine_type == GAME_ENGINE_TYPE_SP && i > 0)
2288 for (k = 0; k < MAX_NUM_KEYS; k++)
2290 if (level.game_engine_type == GAME_ENGINE_TYPE_EM)
2292 if (game_em.ply[i]->keys & (1 << k))
2293 game_panel_controls[GAME_PANEL_KEY_1 + k].value =
2294 get_key_element_from_nr(k);
2296 else if (stored_player[i].key[k])
2297 game_panel_controls[GAME_PANEL_KEY_1 + k].value =
2298 get_key_element_from_nr(k);
2301 game_panel_controls[GAME_PANEL_INVENTORY_COUNT].value +=
2302 getPlayerInventorySize(i);
2304 if (stored_player[i].num_white_keys > 0)
2305 game_panel_controls[GAME_PANEL_KEY_WHITE].value =
2308 game_panel_controls[GAME_PANEL_KEY_WHITE_COUNT].value +=
2309 stored_player[i].num_white_keys;
2314 int player_nr = game.centered_player_nr;
2316 for (k = 0; k < MAX_NUM_KEYS; k++)
2318 if (level.game_engine_type == GAME_ENGINE_TYPE_EM)
2320 if (game_em.ply[player_nr]->keys & (1 << k))
2321 game_panel_controls[GAME_PANEL_KEY_1 + k].value =
2322 get_key_element_from_nr(k);
2324 else if (stored_player[player_nr].key[k])
2325 game_panel_controls[GAME_PANEL_KEY_1 + k].value =
2326 get_key_element_from_nr(k);
2329 game_panel_controls[GAME_PANEL_INVENTORY_COUNT].value +=
2330 getPlayerInventorySize(player_nr);
2332 if (stored_player[player_nr].num_white_keys > 0)
2333 game_panel_controls[GAME_PANEL_KEY_WHITE].value = EL_DC_KEY_WHITE;
2335 game_panel_controls[GAME_PANEL_KEY_WHITE_COUNT].value +=
2336 stored_player[player_nr].num_white_keys;
2339 // re-arrange keys on game panel, if needed or if defined by style settings
2340 for (i = 0; i < MAX_NUM_KEYS + 1; i++) // all normal keys + white key
2342 int nr = GAME_PANEL_KEY_1 + i;
2343 struct GamePanelControlInfo *gpc = &game_panel_controls[nr];
2344 struct TextPosInfo *pos = gpc->pos;
2346 // skip check if key is not in the player's inventory
2347 if (gpc->value == EL_EMPTY)
2350 // check if keys should be arranged on panel from left to right
2351 if (pos->style == STYLE_LEFTMOST_POSITION)
2353 // check previous key positions (left from current key)
2354 for (k = 0; k < i; k++)
2356 int nr_new = GAME_PANEL_KEY_1 + k;
2358 if (game_panel_controls[nr_new].value == EL_EMPTY)
2360 game_panel_controls[nr_new].value = gpc->value;
2361 gpc->value = EL_EMPTY;
2368 // check if "undefined" keys can be placed at some other position
2369 if (pos->x == -1 && pos->y == -1)
2371 int nr_new = GAME_PANEL_KEY_1 + i % STD_NUM_KEYS;
2373 // 1st try: display key at the same position as normal or EM keys
2374 if (game_panel_controls[nr_new].value == EL_EMPTY)
2376 game_panel_controls[nr_new].value = gpc->value;
2380 // 2nd try: display key at the next free position in the key panel
2381 for (k = 0; k < STD_NUM_KEYS; k++)
2383 nr_new = GAME_PANEL_KEY_1 + k;
2385 if (game_panel_controls[nr_new].value == EL_EMPTY)
2387 game_panel_controls[nr_new].value = gpc->value;
2396 for (i = 0; i < NUM_PANEL_INVENTORY; i++)
2398 game_panel_controls[GAME_PANEL_INVENTORY_FIRST_1 + i].value =
2399 get_inventory_element_from_pos(local_player, i);
2400 game_panel_controls[GAME_PANEL_INVENTORY_LAST_1 + i].value =
2401 get_inventory_element_from_pos(local_player, -i - 1);
2404 game_panel_controls[GAME_PANEL_SCORE].value = score;
2405 game_panel_controls[GAME_PANEL_HIGHSCORE].value = scores.entry[0].score;
2407 game_panel_controls[GAME_PANEL_TIME].value = time;
2409 game_panel_controls[GAME_PANEL_TIME_HH].value = time / 3600;
2410 game_panel_controls[GAME_PANEL_TIME_MM].value = (time / 60) % 60;
2411 game_panel_controls[GAME_PANEL_TIME_SS].value = time % 60;
2413 if (level.time == 0)
2414 game_panel_controls[GAME_PANEL_TIME_ANIM].value = 100;
2416 game_panel_controls[GAME_PANEL_TIME_ANIM].value = time * 100 / level.time;
2418 game_panel_controls[GAME_PANEL_HEALTH].value = health;
2419 game_panel_controls[GAME_PANEL_HEALTH_ANIM].value = health;
2421 game_panel_controls[GAME_PANEL_FRAME].value = FrameCounter;
2423 game_panel_controls[GAME_PANEL_SHIELD_NORMAL].value =
2424 (local_player->shield_normal_time_left > 0 ? EL_SHIELD_NORMAL_ACTIVE :
2426 game_panel_controls[GAME_PANEL_SHIELD_NORMAL_TIME].value =
2427 local_player->shield_normal_time_left;
2428 game_panel_controls[GAME_PANEL_SHIELD_DEADLY].value =
2429 (local_player->shield_deadly_time_left > 0 ? EL_SHIELD_DEADLY_ACTIVE :
2431 game_panel_controls[GAME_PANEL_SHIELD_DEADLY_TIME].value =
2432 local_player->shield_deadly_time_left;
2434 game_panel_controls[GAME_PANEL_EXIT].value =
2435 (exit_closed ? EL_EXIT_CLOSED : EL_EXIT_OPEN);
2437 game_panel_controls[GAME_PANEL_EMC_MAGIC_BALL].value =
2438 (game.ball_active ? EL_EMC_MAGIC_BALL_ACTIVE : EL_EMC_MAGIC_BALL);
2439 game_panel_controls[GAME_PANEL_EMC_MAGIC_BALL_SWITCH].value =
2440 (game.ball_active ? EL_EMC_MAGIC_BALL_SWITCH_ACTIVE :
2441 EL_EMC_MAGIC_BALL_SWITCH);
2443 game_panel_controls[GAME_PANEL_LIGHT_SWITCH].value =
2444 (game.light_time_left > 0 ? EL_LIGHT_SWITCH_ACTIVE : EL_LIGHT_SWITCH);
2445 game_panel_controls[GAME_PANEL_LIGHT_SWITCH_TIME].value =
2446 game.light_time_left;
2448 game_panel_controls[GAME_PANEL_TIMEGATE_SWITCH].value =
2449 (game.timegate_time_left > 0 ? EL_TIMEGATE_OPEN : EL_TIMEGATE_CLOSED);
2450 game_panel_controls[GAME_PANEL_TIMEGATE_SWITCH_TIME].value =
2451 game.timegate_time_left;
2453 game_panel_controls[GAME_PANEL_SWITCHGATE_SWITCH].value =
2454 EL_SWITCHGATE_SWITCH_UP + game.switchgate_pos;
2456 game_panel_controls[GAME_PANEL_EMC_LENSES].value =
2457 (game.lenses_time_left > 0 ? EL_EMC_LENSES : EL_EMPTY);
2458 game_panel_controls[GAME_PANEL_EMC_LENSES_TIME].value =
2459 game.lenses_time_left;
2461 game_panel_controls[GAME_PANEL_EMC_MAGNIFIER].value =
2462 (game.magnify_time_left > 0 ? EL_EMC_MAGNIFIER : EL_EMPTY);
2463 game_panel_controls[GAME_PANEL_EMC_MAGNIFIER_TIME].value =
2464 game.magnify_time_left;
2466 game_panel_controls[GAME_PANEL_BALLOON_SWITCH].value =
2467 (game.wind_direction == MV_LEFT ? EL_BALLOON_SWITCH_LEFT :
2468 game.wind_direction == MV_RIGHT ? EL_BALLOON_SWITCH_RIGHT :
2469 game.wind_direction == MV_UP ? EL_BALLOON_SWITCH_UP :
2470 game.wind_direction == MV_DOWN ? EL_BALLOON_SWITCH_DOWN :
2471 EL_BALLOON_SWITCH_NONE);
2473 game_panel_controls[GAME_PANEL_DYNABOMB_NUMBER].value =
2474 local_player->dynabomb_count;
2475 game_panel_controls[GAME_PANEL_DYNABOMB_SIZE].value =
2476 local_player->dynabomb_size;
2477 game_panel_controls[GAME_PANEL_DYNABOMB_POWER].value =
2478 (local_player->dynabomb_xl ? EL_DYNABOMB_INCREASE_POWER : EL_EMPTY);
2480 game_panel_controls[GAME_PANEL_PENGUINS].value =
2481 game.friends_still_needed;
2483 game_panel_controls[GAME_PANEL_SOKOBAN_OBJECTS].value =
2484 game.sokoban_objects_still_needed;
2485 game_panel_controls[GAME_PANEL_SOKOBAN_FIELDS].value =
2486 game.sokoban_fields_still_needed;
2488 game_panel_controls[GAME_PANEL_ROBOT_WHEEL].value =
2489 (game.robot_wheel_active ? EL_ROBOT_WHEEL_ACTIVE : EL_ROBOT_WHEEL);
2491 for (i = 0; i < NUM_BELTS; i++)
2493 game_panel_controls[GAME_PANEL_CONVEYOR_BELT_1 + i].value =
2494 (game.belt_dir[i] != MV_NONE ? EL_CONVEYOR_BELT_1_MIDDLE_ACTIVE :
2495 EL_CONVEYOR_BELT_1_MIDDLE) + i;
2496 game_panel_controls[GAME_PANEL_CONVEYOR_BELT_1_SWITCH + i].value =
2497 getBeltSwitchElementFromBeltNrAndBeltDir(i, game.belt_dir[i]);
2500 game_panel_controls[GAME_PANEL_MAGIC_WALL].value =
2501 (game.magic_wall_active ? EL_MAGIC_WALL_ACTIVE : EL_MAGIC_WALL);
2502 game_panel_controls[GAME_PANEL_MAGIC_WALL_TIME].value =
2503 game.magic_wall_time_left;
2505 game_panel_controls[GAME_PANEL_GRAVITY_STATE].value =
2506 local_player->gravity;
2508 for (i = 0; i < NUM_PANEL_GRAPHICS; i++)
2509 game_panel_controls[GAME_PANEL_GRAPHIC_1 + i].value = EL_GRAPHIC_1 + i;
2511 for (i = 0; i < NUM_PANEL_ELEMENTS; i++)
2512 game_panel_controls[GAME_PANEL_ELEMENT_1 + i].value =
2513 (IS_DRAWABLE_ELEMENT(game.panel.element[i].id) ?
2514 game.panel.element[i].id : EL_UNDEFINED);
2516 for (i = 0; i < NUM_PANEL_ELEMENTS; i++)
2517 game_panel_controls[GAME_PANEL_ELEMENT_COUNT_1 + i].value =
2518 (IS_VALID_ELEMENT(game.panel.element_count[i].id) ?
2519 element_info[game.panel.element_count[i].id].element_count : 0);
2521 for (i = 0; i < NUM_PANEL_CE_SCORE; i++)
2522 game_panel_controls[GAME_PANEL_CE_SCORE_1 + i].value =
2523 (IS_CUSTOM_ELEMENT(game.panel.ce_score[i].id) ?
2524 element_info[game.panel.ce_score[i].id].collect_score : 0);
2526 for (i = 0; i < NUM_PANEL_CE_SCORE; i++)
2527 game_panel_controls[GAME_PANEL_CE_SCORE_1_ELEMENT + i].value =
2528 (IS_CUSTOM_ELEMENT(game.panel.ce_score_element[i].id) ?
2529 element_info[game.panel.ce_score_element[i].id].collect_score :
2532 game_panel_controls[GAME_PANEL_PLAYER_NAME].value = 0;
2533 game_panel_controls[GAME_PANEL_LEVEL_NAME].value = 0;
2534 game_panel_controls[GAME_PANEL_LEVEL_AUTHOR].value = 0;
2536 // update game panel control frames
2538 for (i = 0; game_panel_controls[i].nr != -1; i++)
2540 struct GamePanelControlInfo *gpc = &game_panel_controls[i];
2542 if (gpc->type == TYPE_ELEMENT)
2544 if (gpc->value != EL_UNDEFINED && gpc->value != EL_EMPTY)
2546 int last_anim_random_frame = gfx.anim_random_frame;
2547 int element = gpc->value;
2548 int graphic = el2panelimg(element);
2549 int init_gfx_random = (graphic_info[graphic].anim_global_sync ?
2550 sync_random_frame : INIT_GFX_RANDOM());
2552 if (gpc->value != gpc->last_value)
2555 gpc->gfx_random = init_gfx_random;
2561 if (ANIM_MODE(graphic) == ANIM_RANDOM &&
2562 IS_NEXT_FRAME(gpc->gfx_frame, graphic))
2563 gpc->gfx_random = init_gfx_random;
2566 if (ANIM_MODE(graphic) == ANIM_RANDOM)
2567 gfx.anim_random_frame = gpc->gfx_random;
2569 if (ANIM_MODE(graphic) == ANIM_CE_SCORE)
2570 gpc->gfx_frame = element_info[element].collect_score;
2572 gpc->frame = getGraphicAnimationFrame(graphic, gpc->gfx_frame);
2574 if (ANIM_MODE(graphic) == ANIM_RANDOM)
2575 gfx.anim_random_frame = last_anim_random_frame;
2578 else if (gpc->type == TYPE_GRAPHIC)
2580 if (gpc->graphic != IMG_UNDEFINED)
2582 int last_anim_random_frame = gfx.anim_random_frame;
2583 int graphic = gpc->graphic;
2584 int init_gfx_random = (graphic_info[graphic].anim_global_sync ?
2585 sync_random_frame : INIT_GFX_RANDOM());
2587 if (gpc->value != gpc->last_value)
2590 gpc->gfx_random = init_gfx_random;
2596 if (ANIM_MODE(graphic) == ANIM_RANDOM &&
2597 IS_NEXT_FRAME(gpc->gfx_frame, graphic))
2598 gpc->gfx_random = init_gfx_random;
2601 if (ANIM_MODE(graphic) == ANIM_RANDOM)
2602 gfx.anim_random_frame = gpc->gfx_random;
2604 gpc->frame = getGraphicAnimationFrame(graphic, gpc->gfx_frame);
2606 if (ANIM_MODE(graphic) == ANIM_RANDOM)
2607 gfx.anim_random_frame = last_anim_random_frame;
2613 static void DisplayGameControlValues(void)
2615 boolean redraw_panel = FALSE;
2618 for (i = 0; game_panel_controls[i].nr != -1; i++)
2620 struct GamePanelControlInfo *gpc = &game_panel_controls[i];
2622 if (PANEL_DEACTIVATED(gpc->pos))
2625 if (gpc->value == gpc->last_value &&
2626 gpc->frame == gpc->last_frame)
2629 redraw_panel = TRUE;
2635 // copy default game door content to main double buffer
2637 // !!! CHECK AGAIN !!!
2638 SetPanelBackground();
2639 // SetDoorBackgroundImage(IMG_BACKGROUND_PANEL);
2640 DrawBackground(DX, DY, DXSIZE, DYSIZE);
2642 // redraw game control buttons
2643 RedrawGameButtons();
2645 SetGameStatus(GAME_MODE_PSEUDO_PANEL);
2647 for (i = 0; i < NUM_GAME_PANEL_CONTROLS; i++)
2649 int nr = game_panel_order[i].nr;
2650 struct GamePanelControlInfo *gpc = &game_panel_controls[nr];
2651 struct TextPosInfo *pos = gpc->pos;
2652 int type = gpc->type;
2653 int value = gpc->value;
2654 int frame = gpc->frame;
2655 int size = pos->size;
2656 int font = pos->font;
2657 boolean draw_masked = pos->draw_masked;
2658 int mask_mode = (draw_masked ? BLIT_MASKED : BLIT_OPAQUE);
2660 if (PANEL_DEACTIVATED(pos))
2663 if (pos->class == get_hash_from_key("extra_panel_items") &&
2664 !setup.prefer_extra_panel_items)
2667 gpc->last_value = value;
2668 gpc->last_frame = frame;
2670 if (type == TYPE_INTEGER)
2672 if (nr == GAME_PANEL_LEVEL_NUMBER ||
2673 nr == GAME_PANEL_TIME)
2675 boolean use_dynamic_size = (size == -1 ? TRUE : FALSE);
2677 if (use_dynamic_size) // use dynamic number of digits
2679 int value_change = (nr == GAME_PANEL_LEVEL_NUMBER ? 100 : 1000);
2680 int size1 = (nr == GAME_PANEL_LEVEL_NUMBER ? 2 : 3);
2681 int size2 = size1 + 1;
2682 int font1 = pos->font;
2683 int font2 = pos->font_alt;
2685 size = (value < value_change ? size1 : size2);
2686 font = (value < value_change ? font1 : font2);
2690 // correct text size if "digits" is zero or less
2692 size = strlen(int2str(value, size));
2694 // dynamically correct text alignment
2695 pos->width = size * getFontWidth(font);
2697 DrawTextExt(drawto, PANEL_XPOS(pos), PANEL_YPOS(pos),
2698 int2str(value, size), font, mask_mode);
2700 else if (type == TYPE_ELEMENT)
2702 int element, graphic;
2706 int dst_x = PANEL_XPOS(pos);
2707 int dst_y = PANEL_YPOS(pos);
2709 if (value != EL_UNDEFINED && value != EL_EMPTY)
2712 graphic = el2panelimg(value);
2715 Debug("game:DisplayGameControlValues", "%d, '%s' [%d]",
2716 element, EL_NAME(element), size);
2719 if (element >= EL_GRAPHIC_1 && element <= EL_GRAPHIC_8 && size == 0)
2722 getSizedGraphicSource(graphic, frame, size, &src_bitmap,
2725 width = graphic_info[graphic].width * size / TILESIZE;
2726 height = graphic_info[graphic].height * size / TILESIZE;
2729 BlitBitmapMasked(src_bitmap, drawto, src_x, src_y, width, height,
2732 BlitBitmap(src_bitmap, drawto, src_x, src_y, width, height,
2736 else if (type == TYPE_GRAPHIC)
2738 int graphic = gpc->graphic;
2739 int graphic_active = gpc->graphic_active;
2743 int dst_x = PANEL_XPOS(pos);
2744 int dst_y = PANEL_YPOS(pos);
2745 boolean skip = (pos->class == get_hash_from_key("mm_engine_only") &&
2746 level.game_engine_type != GAME_ENGINE_TYPE_MM);
2748 if (graphic != IMG_UNDEFINED && !skip)
2750 if (pos->style == STYLE_REVERSE)
2751 value = 100 - value;
2753 getGraphicSource(graphic_active, frame, &src_bitmap, &src_x, &src_y);
2755 if (pos->direction & MV_HORIZONTAL)
2757 width = graphic_info[graphic_active].width * value / 100;
2758 height = graphic_info[graphic_active].height;
2760 if (pos->direction == MV_LEFT)
2762 src_x += graphic_info[graphic_active].width - width;
2763 dst_x += graphic_info[graphic_active].width - width;
2768 width = graphic_info[graphic_active].width;
2769 height = graphic_info[graphic_active].height * value / 100;
2771 if (pos->direction == MV_UP)
2773 src_y += graphic_info[graphic_active].height - height;
2774 dst_y += graphic_info[graphic_active].height - height;
2779 BlitBitmapMasked(src_bitmap, drawto, src_x, src_y, width, height,
2782 BlitBitmap(src_bitmap, drawto, src_x, src_y, width, height,
2785 getGraphicSource(graphic, frame, &src_bitmap, &src_x, &src_y);
2787 if (pos->direction & MV_HORIZONTAL)
2789 if (pos->direction == MV_RIGHT)
2796 dst_x = PANEL_XPOS(pos);
2799 width = graphic_info[graphic].width - width;
2803 if (pos->direction == MV_DOWN)
2810 dst_y = PANEL_YPOS(pos);
2813 height = graphic_info[graphic].height - height;
2817 BlitBitmapMasked(src_bitmap, drawto, src_x, src_y, width, height,
2820 BlitBitmap(src_bitmap, drawto, src_x, src_y, width, height,
2824 else if (type == TYPE_STRING)
2826 boolean active = (value != 0);
2827 char *state_normal = "off";
2828 char *state_active = "on";
2829 char *state = (active ? state_active : state_normal);
2830 char *s = (nr == GAME_PANEL_GRAVITY_STATE ? state :
2831 nr == GAME_PANEL_PLAYER_NAME ? setup.player_name :
2832 nr == GAME_PANEL_LEVEL_NAME ? level.name :
2833 nr == GAME_PANEL_LEVEL_AUTHOR ? level.author : NULL);
2835 if (nr == GAME_PANEL_GRAVITY_STATE)
2837 int font1 = pos->font; // (used for normal state)
2838 int font2 = pos->font_alt; // (used for active state)
2840 font = (active ? font2 : font1);
2849 // don't truncate output if "chars" is zero or less
2852 // dynamically correct text alignment
2853 pos->width = size * getFontWidth(font);
2856 s_cut = getStringCopyN(s, size);
2858 DrawTextExt(drawto, PANEL_XPOS(pos), PANEL_YPOS(pos),
2859 s_cut, font, mask_mode);
2865 redraw_mask |= REDRAW_DOOR_1;
2868 SetGameStatus(GAME_MODE_PLAYING);
2871 void UpdateAndDisplayGameControlValues(void)
2873 if (tape.deactivate_display)
2876 UpdateGameControlValues();
2877 DisplayGameControlValues();
2880 void UpdateGameDoorValues(void)
2882 UpdateGameControlValues();
2885 void DrawGameDoorValues(void)
2887 DisplayGameControlValues();
2891 // ============================================================================
2893 // ----------------------------------------------------------------------------
2894 // initialize game engine due to level / tape version number
2895 // ============================================================================
2897 static void InitGameEngine(void)
2899 int i, j, k, l, x, y;
2901 // set game engine from tape file when re-playing, else from level file
2902 game.engine_version = (tape.playing ? tape.engine_version :
2903 level.game_version);
2905 // set single or multi-player game mode (needed for re-playing tapes)
2906 game.team_mode = setup.team_mode;
2910 int num_players = 0;
2912 for (i = 0; i < MAX_PLAYERS; i++)
2913 if (tape.player_participates[i])
2916 // multi-player tapes contain input data for more than one player
2917 game.team_mode = (num_players > 1);
2921 Debug("game:init:level", "level %d: level.game_version == %06d", level_nr,
2922 level.game_version);
2923 Debug("game:init:level", " tape.file_version == %06d",
2925 Debug("game:init:level", " tape.game_version == %06d",
2927 Debug("game:init:level", " tape.engine_version == %06d",
2928 tape.engine_version);
2929 Debug("game:init:level", " => game.engine_version == %06d [tape mode: %s]",
2930 game.engine_version, (tape.playing ? "PLAYING" : "RECORDING"));
2933 // --------------------------------------------------------------------------
2934 // set flags for bugs and changes according to active game engine version
2935 // --------------------------------------------------------------------------
2939 Fixed property "can fall" for run-time element "EL_AMOEBA_DROPPING"
2941 Bug was introduced in version:
2944 Bug was fixed in version:
2948 In version 2.0.1, a new run-time element "EL_AMOEBA_DROPPING" was added,
2949 but the property "can fall" was missing, which caused some levels to be
2950 unsolvable. This was fixed in version 4.2.0.0.
2952 Affected levels/tapes:
2953 An example for a tape that was fixed by this bugfix is tape 029 from the
2954 level set "rnd_sam_bateman".
2955 The wrong behaviour will still be used for all levels or tapes that were
2956 created/recorded with it. An example for this is tape 023 from the level
2957 set "rnd_gerhard_haeusler", which was recorded with a buggy game engine.
2960 boolean use_amoeba_dropping_cannot_fall_bug =
2961 ((game.engine_version >= VERSION_IDENT(2,0,1,0) &&
2962 game.engine_version < VERSION_IDENT(4,2,0,0)) ||
2964 tape.game_version >= VERSION_IDENT(2,0,1,0) &&
2965 tape.game_version < VERSION_IDENT(4,2,0,0)));
2968 Summary of bugfix/change:
2969 Fixed move speed of elements entering or leaving magic wall.
2971 Fixed/changed in version:
2975 Before 2.0.1, move speed of elements entering or leaving magic wall was
2976 twice as fast as it is now.
2977 Since 2.0.1, this is set to a lower value by using move_stepsize_list[].
2979 Affected levels/tapes:
2980 The first condition is generally needed for all levels/tapes before version
2981 2.0.1, which might use the old behaviour before it was changed; known tapes
2982 that are affected: Tape 014 from the level set "rnd_conor_mancone".
2983 The second condition is an exception from the above case and is needed for
2984 the special case of tapes recorded with game (not engine!) version 2.0.1 or
2985 above, but before it was known that this change would break tapes like the
2986 above and was fixed in 4.2.0.0, so that the changed behaviour was active
2987 although the engine version while recording maybe was before 2.0.1. There
2988 are a lot of tapes that are affected by this exception, like tape 006 from
2989 the level set "rnd_conor_mancone".
2992 boolean use_old_move_stepsize_for_magic_wall =
2993 (game.engine_version < VERSION_IDENT(2,0,1,0) &&
2995 tape.game_version >= VERSION_IDENT(2,0,1,0) &&
2996 tape.game_version < VERSION_IDENT(4,2,0,0)));
2999 Summary of bugfix/change:
3000 Fixed handling for custom elements that change when pushed by the player.
3002 Fixed/changed in version:
3006 Before 3.1.0, custom elements that "change when pushing" changed directly
3007 after the player started pushing them (until then handled in "DigField()").
3008 Since 3.1.0, these custom elements are not changed until the "pushing"
3009 move of the element is finished (now handled in "ContinueMoving()").
3011 Affected levels/tapes:
3012 The first condition is generally needed for all levels/tapes before version
3013 3.1.0, which might use the old behaviour before it was changed; known tapes
3014 that are affected are some tapes from the level set "Walpurgis Gardens" by
3016 The second condition is an exception from the above case and is needed for
3017 the special case of tapes recorded with game (not engine!) version 3.1.0 or
3018 above (including some development versions of 3.1.0), but before it was
3019 known that this change would break tapes like the above and was fixed in
3020 3.1.1, so that the changed behaviour was active although the engine version
3021 while recording maybe was before 3.1.0. There is at least one tape that is
3022 affected by this exception, which is the tape for the one-level set "Bug
3023 Machine" by Juergen Bonhagen.
3026 game.use_change_when_pushing_bug =
3027 (game.engine_version < VERSION_IDENT(3,1,0,0) &&
3029 tape.game_version >= VERSION_IDENT(3,1,0,0) &&
3030 tape.game_version < VERSION_IDENT(3,1,1,0)));
3033 Summary of bugfix/change:
3034 Fixed handling for blocking the field the player leaves when moving.
3036 Fixed/changed in version:
3040 Before 3.1.1, when "block last field when moving" was enabled, the field
3041 the player is leaving when moving was blocked for the time of the move,
3042 and was directly unblocked afterwards. This resulted in the last field
3043 being blocked for exactly one less than the number of frames of one player
3044 move. Additionally, even when blocking was disabled, the last field was
3045 blocked for exactly one frame.
3046 Since 3.1.1, due to changes in player movement handling, the last field
3047 is not blocked at all when blocking is disabled. When blocking is enabled,
3048 the last field is blocked for exactly the number of frames of one player
3049 move. Additionally, if the player is Murphy, the hero of Supaplex, the
3050 last field is blocked for exactly one more than the number of frames of
3053 Affected levels/tapes:
3054 (!!! yet to be determined -- probably many !!!)
3057 game.use_block_last_field_bug =
3058 (game.engine_version < VERSION_IDENT(3,1,1,0));
3060 /* various special flags and settings for native Emerald Mine game engine */
3062 game_em.use_single_button =
3063 (game.engine_version > VERSION_IDENT(4,0,0,2));
3065 game_em.use_snap_key_bug =
3066 (game.engine_version < VERSION_IDENT(4,0,1,0));
3068 game_em.use_random_bug =
3069 (tape.property_bits & TAPE_PROPERTY_EM_RANDOM_BUG);
3071 boolean use_old_em_engine = (game.engine_version < VERSION_IDENT(4,2,0,0));
3073 game_em.use_old_explosions = use_old_em_engine;
3074 game_em.use_old_android = use_old_em_engine;
3075 game_em.use_old_push_elements = use_old_em_engine;
3076 game_em.use_old_push_into_acid = use_old_em_engine;
3078 game_em.use_wrap_around = !use_old_em_engine;
3080 // --------------------------------------------------------------------------
3082 // set maximal allowed number of custom element changes per game frame
3083 game.max_num_changes_per_frame = 1;
3085 // default scan direction: scan playfield from top/left to bottom/right
3086 InitPlayfieldScanMode(CA_ARG_SCAN_MODE_NORMAL);
3088 // dynamically adjust element properties according to game engine version
3089 InitElementPropertiesEngine(game.engine_version);
3091 // ---------- initialize special element properties -------------------------
3093 // "EL_AMOEBA_DROPPING" missed property "can fall" in older game versions
3094 if (use_amoeba_dropping_cannot_fall_bug)
3095 SET_PROPERTY(EL_AMOEBA_DROPPING, EP_CAN_FALL, FALSE);
3097 // ---------- initialize player's initial move delay ------------------------
3099 // dynamically adjust player properties according to level information
3100 for (i = 0; i < MAX_PLAYERS; i++)
3101 game.initial_move_delay_value[i] =
3102 get_move_delay_from_stepsize(level.initial_player_stepsize[i]);
3104 // dynamically adjust player properties according to game engine version
3105 for (i = 0; i < MAX_PLAYERS; i++)
3106 game.initial_move_delay[i] =
3107 (game.engine_version <= VERSION_IDENT(2,0,1,0) ?
3108 game.initial_move_delay_value[i] : 0);
3110 // ---------- initialize player's initial push delay ------------------------
3112 // dynamically adjust player properties according to game engine version
3113 game.initial_push_delay_value =
3114 (game.engine_version < VERSION_IDENT(3,0,7,1) ? 5 : -1);
3116 // ---------- initialize changing elements ----------------------------------
3118 // initialize changing elements information
3119 for (i = 0; i < MAX_NUM_ELEMENTS; i++)
3121 struct ElementInfo *ei = &element_info[i];
3123 // this pointer might have been changed in the level editor
3124 ei->change = &ei->change_page[0];
3126 if (!IS_CUSTOM_ELEMENT(i))
3128 ei->change->target_element = EL_EMPTY_SPACE;
3129 ei->change->delay_fixed = 0;
3130 ei->change->delay_random = 0;
3131 ei->change->delay_frames = 1;
3134 for (j = 0; j < NUM_CHANGE_EVENTS; j++)
3136 ei->has_change_event[j] = FALSE;
3138 ei->event_page_nr[j] = 0;
3139 ei->event_page[j] = &ei->change_page[0];
3143 // add changing elements from pre-defined list
3144 for (i = 0; change_delay_list[i].element != EL_UNDEFINED; i++)
3146 struct ChangingElementInfo *ch_delay = &change_delay_list[i];
3147 struct ElementInfo *ei = &element_info[ch_delay->element];
3149 ei->change->target_element = ch_delay->target_element;
3150 ei->change->delay_fixed = ch_delay->change_delay;
3152 ei->change->pre_change_function = ch_delay->pre_change_function;
3153 ei->change->change_function = ch_delay->change_function;
3154 ei->change->post_change_function = ch_delay->post_change_function;
3156 ei->change->can_change = TRUE;
3157 ei->change->can_change_or_has_action = TRUE;
3159 ei->has_change_event[CE_DELAY] = TRUE;
3161 SET_PROPERTY(ch_delay->element, EP_CAN_CHANGE, TRUE);
3162 SET_PROPERTY(ch_delay->element, EP_CAN_CHANGE_OR_HAS_ACTION, TRUE);
3165 // ---------- initialize internal run-time variables ------------------------
3167 for (i = 0; i < NUM_CUSTOM_ELEMENTS; i++)
3169 struct ElementInfo *ei = &element_info[EL_CUSTOM_START + i];
3171 for (j = 0; j < ei->num_change_pages; j++)
3173 ei->change_page[j].can_change_or_has_action =
3174 (ei->change_page[j].can_change |
3175 ei->change_page[j].has_action);
3179 // add change events from custom element configuration
3180 for (i = 0; i < NUM_CUSTOM_ELEMENTS; i++)
3182 struct ElementInfo *ei = &element_info[EL_CUSTOM_START + i];
3184 for (j = 0; j < ei->num_change_pages; j++)
3186 if (!ei->change_page[j].can_change_or_has_action)
3189 for (k = 0; k < NUM_CHANGE_EVENTS; k++)
3191 // only add event page for the first page found with this event
3192 if (ei->change_page[j].has_event[k] && !(ei->has_change_event[k]))
3194 ei->has_change_event[k] = TRUE;
3196 ei->event_page_nr[k] = j;
3197 ei->event_page[k] = &ei->change_page[j];
3203 // ---------- initialize reference elements in change conditions ------------
3205 for (i = 0; i < NUM_CUSTOM_ELEMENTS; i++)
3207 int element = EL_CUSTOM_START + i;
3208 struct ElementInfo *ei = &element_info[element];
3210 for (j = 0; j < ei->num_change_pages; j++)
3212 int trigger_element = ei->change_page[j].initial_trigger_element;
3214 if (trigger_element >= EL_PREV_CE_8 &&
3215 trigger_element <= EL_NEXT_CE_8)
3216 trigger_element = RESOLVED_REFERENCE_ELEMENT(element, trigger_element);
3218 ei->change_page[j].trigger_element = trigger_element;
3222 // ---------- initialize run-time trigger player and element ----------------
3224 for (i = 0; i < NUM_CUSTOM_ELEMENTS; i++)
3226 struct ElementInfo *ei = &element_info[EL_CUSTOM_START + i];
3228 for (j = 0; j < ei->num_change_pages; j++)
3230 ei->change_page[j].actual_trigger_element = EL_EMPTY;
3231 ei->change_page[j].actual_trigger_player = EL_EMPTY;
3232 ei->change_page[j].actual_trigger_player_bits = CH_PLAYER_NONE;
3233 ei->change_page[j].actual_trigger_side = CH_SIDE_NONE;
3234 ei->change_page[j].actual_trigger_ce_value = 0;
3235 ei->change_page[j].actual_trigger_ce_score = 0;
3239 // ---------- initialize trigger events -------------------------------------
3241 // initialize trigger events information
3242 for (i = 0; i < MAX_NUM_ELEMENTS; i++)
3243 for (j = 0; j < NUM_CHANGE_EVENTS; j++)
3244 trigger_events[i][j] = FALSE;
3246 // add trigger events from element change event properties
3247 for (i = 0; i < MAX_NUM_ELEMENTS; i++)
3249 struct ElementInfo *ei = &element_info[i];
3251 for (j = 0; j < ei->num_change_pages; j++)
3253 if (!ei->change_page[j].can_change_or_has_action)
3256 if (ei->change_page[j].has_event[CE_BY_OTHER_ACTION])
3258 int trigger_element = ei->change_page[j].trigger_element;
3260 for (k = 0; k < NUM_CHANGE_EVENTS; k++)
3262 if (ei->change_page[j].has_event[k])
3264 if (IS_GROUP_ELEMENT(trigger_element))
3266 struct ElementGroupInfo *group =
3267 element_info[trigger_element].group;
3269 for (l = 0; l < group->num_elements_resolved; l++)
3270 trigger_events[group->element_resolved[l]][k] = TRUE;
3272 else if (trigger_element == EL_ANY_ELEMENT)
3273 for (l = 0; l < MAX_NUM_ELEMENTS; l++)
3274 trigger_events[l][k] = TRUE;
3276 trigger_events[trigger_element][k] = TRUE;
3283 // ---------- initialize push delay -----------------------------------------
3285 // initialize push delay values to default
3286 for (i = 0; i < MAX_NUM_ELEMENTS; i++)
3288 if (!IS_CUSTOM_ELEMENT(i))
3290 // set default push delay values (corrected since version 3.0.7-1)
3291 if (game.engine_version < VERSION_IDENT(3,0,7,1))
3293 element_info[i].push_delay_fixed = 2;
3294 element_info[i].push_delay_random = 8;
3298 element_info[i].push_delay_fixed = 8;
3299 element_info[i].push_delay_random = 8;
3304 // set push delay value for certain elements from pre-defined list
3305 for (i = 0; push_delay_list[i].element != EL_UNDEFINED; i++)
3307 int e = push_delay_list[i].element;
3309 element_info[e].push_delay_fixed = push_delay_list[i].push_delay_fixed;
3310 element_info[e].push_delay_random = push_delay_list[i].push_delay_random;
3313 // set push delay value for Supaplex elements for newer engine versions
3314 if (game.engine_version >= VERSION_IDENT(3,1,0,0))
3316 for (i = 0; i < MAX_NUM_ELEMENTS; i++)
3318 if (IS_SP_ELEMENT(i))
3320 // set SP push delay to just enough to push under a falling zonk
3321 int delay = (game.engine_version >= VERSION_IDENT(3,1,1,0) ? 8 : 6);
3323 element_info[i].push_delay_fixed = delay;
3324 element_info[i].push_delay_random = 0;
3329 // ---------- initialize move stepsize --------------------------------------
3331 // initialize move stepsize values to default
3332 for (i = 0; i < MAX_NUM_ELEMENTS; i++)
3333 if (!IS_CUSTOM_ELEMENT(i))
3334 element_info[i].move_stepsize = MOVE_STEPSIZE_NORMAL;
3336 // set move stepsize value for certain elements from pre-defined list
3337 for (i = 0; move_stepsize_list[i].element != EL_UNDEFINED; i++)
3339 int e = move_stepsize_list[i].element;
3341 element_info[e].move_stepsize = move_stepsize_list[i].move_stepsize;
3343 // set move stepsize value for certain elements for older engine versions
3344 if (use_old_move_stepsize_for_magic_wall)
3346 if (e == EL_MAGIC_WALL_FILLING ||
3347 e == EL_MAGIC_WALL_EMPTYING ||
3348 e == EL_BD_MAGIC_WALL_FILLING ||
3349 e == EL_BD_MAGIC_WALL_EMPTYING)
3350 element_info[e].move_stepsize *= 2;
3354 // ---------- initialize collect score --------------------------------------
3356 // initialize collect score values for custom elements from initial value
3357 for (i = 0; i < MAX_NUM_ELEMENTS; i++)
3358 if (IS_CUSTOM_ELEMENT(i))
3359 element_info[i].collect_score = element_info[i].collect_score_initial;
3361 // ---------- initialize collect count --------------------------------------
3363 // initialize collect count values for non-custom elements
3364 for (i = 0; i < MAX_NUM_ELEMENTS; i++)
3365 if (!IS_CUSTOM_ELEMENT(i))
3366 element_info[i].collect_count_initial = 0;
3368 // add collect count values for all elements from pre-defined list
3369 for (i = 0; collect_count_list[i].element != EL_UNDEFINED; i++)
3370 element_info[collect_count_list[i].element].collect_count_initial =
3371 collect_count_list[i].count;
3373 // ---------- initialize access direction -----------------------------------
3375 // initialize access direction values to default (access from every side)
3376 for (i = 0; i < MAX_NUM_ELEMENTS; i++)
3377 if (!IS_CUSTOM_ELEMENT(i))
3378 element_info[i].access_direction = MV_ALL_DIRECTIONS;
3380 // set access direction value for certain elements from pre-defined list
3381 for (i = 0; access_direction_list[i].element != EL_UNDEFINED; i++)
3382 element_info[access_direction_list[i].element].access_direction =
3383 access_direction_list[i].direction;
3385 // ---------- initialize explosion content ----------------------------------
3386 for (i = 0; i < MAX_NUM_ELEMENTS; i++)
3388 if (IS_CUSTOM_ELEMENT(i))
3391 for (y = 0; y < 3; y++) for (x = 0; x < 3; x++)
3393 // (content for EL_YAMYAM set at run-time with game.yamyam_content_nr)
3395 element_info[i].content.e[x][y] =
3396 (i == EL_PLAYER_1 ? EL_EMERALD_YELLOW :
3397 i == EL_PLAYER_2 ? EL_EMERALD_RED :
3398 i == EL_PLAYER_3 ? EL_EMERALD :
3399 i == EL_PLAYER_4 ? EL_EMERALD_PURPLE :
3400 i == EL_MOLE ? EL_EMERALD_RED :
3401 i == EL_PENGUIN ? EL_EMERALD_PURPLE :
3402 i == EL_BUG ? (x == 1 && y == 1 ? EL_DIAMOND : EL_EMERALD) :
3403 i == EL_BD_BUTTERFLY ? EL_BD_DIAMOND :
3404 i == EL_SP_ELECTRON ? EL_SP_INFOTRON :
3405 i == EL_AMOEBA_TO_DIAMOND ? level.amoeba_content :
3406 i == EL_WALL_EMERALD ? EL_EMERALD :
3407 i == EL_WALL_DIAMOND ? EL_DIAMOND :
3408 i == EL_WALL_BD_DIAMOND ? EL_BD_DIAMOND :
3409 i == EL_WALL_EMERALD_YELLOW ? EL_EMERALD_YELLOW :
3410 i == EL_WALL_EMERALD_RED ? EL_EMERALD_RED :
3411 i == EL_WALL_EMERALD_PURPLE ? EL_EMERALD_PURPLE :
3412 i == EL_WALL_PEARL ? EL_PEARL :
3413 i == EL_WALL_CRYSTAL ? EL_CRYSTAL :
3418 // ---------- initialize recursion detection --------------------------------
3419 recursion_loop_depth = 0;
3420 recursion_loop_detected = FALSE;
3421 recursion_loop_element = EL_UNDEFINED;
3423 // ---------- initialize graphics engine ------------------------------------
3424 game.scroll_delay_value =
3425 (game.forced_scroll_delay_value != -1 ? game.forced_scroll_delay_value :
3426 level.game_engine_type == GAME_ENGINE_TYPE_EM &&
3427 !setup.forced_scroll_delay ? 0 :
3428 setup.scroll_delay ? setup.scroll_delay_value : 0);
3429 game.scroll_delay_value =
3430 MIN(MAX(MIN_SCROLL_DELAY, game.scroll_delay_value), MAX_SCROLL_DELAY);
3432 // ---------- initialize game engine snapshots ------------------------------
3433 for (i = 0; i < MAX_PLAYERS; i++)
3434 game.snapshot.last_action[i] = 0;
3435 game.snapshot.changed_action = FALSE;
3436 game.snapshot.collected_item = FALSE;
3437 game.snapshot.mode =
3438 (strEqual(setup.engine_snapshot_mode, STR_SNAPSHOT_MODE_EVERY_STEP) ?
3439 SNAPSHOT_MODE_EVERY_STEP :
3440 strEqual(setup.engine_snapshot_mode, STR_SNAPSHOT_MODE_EVERY_MOVE) ?
3441 SNAPSHOT_MODE_EVERY_MOVE :
3442 strEqual(setup.engine_snapshot_mode, STR_SNAPSHOT_MODE_EVERY_COLLECT) ?
3443 SNAPSHOT_MODE_EVERY_COLLECT : SNAPSHOT_MODE_OFF);
3444 game.snapshot.save_snapshot = FALSE;
3446 // ---------- initialize level time for Supaplex engine ---------------------
3447 // Supaplex levels with time limit currently unsupported -- should be added
3448 if (level.game_engine_type == GAME_ENGINE_TYPE_SP)
3451 // ---------- initialize flags for handling game actions --------------------
3453 // set flags for game actions to default values
3454 game.use_key_actions = TRUE;
3455 game.use_mouse_actions = FALSE;
3457 // when using Mirror Magic game engine, handle mouse events only
3458 if (level.game_engine_type == GAME_ENGINE_TYPE_MM)
3460 game.use_key_actions = FALSE;
3461 game.use_mouse_actions = TRUE;
3464 // check for custom elements with mouse click events
3465 if (level.game_engine_type == GAME_ENGINE_TYPE_RND)
3467 for (i = 0; i < NUM_CUSTOM_ELEMENTS; i++)
3469 int element = EL_CUSTOM_START + i;
3471 if (HAS_CHANGE_EVENT(element, CE_CLICKED_BY_MOUSE) ||
3472 HAS_CHANGE_EVENT(element, CE_PRESSED_BY_MOUSE) ||
3473 HAS_CHANGE_EVENT(element, CE_MOUSE_CLICKED_ON_X) ||
3474 HAS_CHANGE_EVENT(element, CE_MOUSE_PRESSED_ON_X))
3475 game.use_mouse_actions = TRUE;
3480 static int get_num_special_action(int element, int action_first,
3483 int num_special_action = 0;
3486 for (i = action_first; i <= action_last; i++)
3488 boolean found = FALSE;
3490 for (j = 0; j < NUM_DIRECTIONS; j++)
3491 if (el_act_dir2img(element, i, j) !=
3492 el_act_dir2img(element, ACTION_DEFAULT, j))
3496 num_special_action++;
3501 return num_special_action;
3505 // ============================================================================
3507 // ----------------------------------------------------------------------------
3508 // initialize and start new game
3509 // ============================================================================
3511 #if DEBUG_INIT_PLAYER
3512 static void DebugPrintPlayerStatus(char *message)
3519 Debug("game:init:player", "%s:", message);
3521 for (i = 0; i < MAX_PLAYERS; i++)
3523 struct PlayerInfo *player = &stored_player[i];
3525 Debug("game:init:player",
3526 "- player %d: present == %d, connected == %d [%d/%d], active == %d%s",
3530 player->connected_locally,
3531 player->connected_network,
3533 (local_player == player ? " (local player)" : ""));
3540 int full_lev_fieldx = lev_fieldx + (BorderElement != EL_EMPTY ? 2 : 0);
3541 int full_lev_fieldy = lev_fieldy + (BorderElement != EL_EMPTY ? 2 : 0);
3542 int fade_mask = REDRAW_FIELD;
3544 boolean emulate_bd = TRUE; // unless non-BOULDERDASH elements found
3545 boolean emulate_sb = TRUE; // unless non-SOKOBAN elements found
3546 boolean emulate_sp = TRUE; // unless non-SUPAPLEX elements found
3547 int initial_move_dir = MV_DOWN;
3550 // required here to update video display before fading (FIX THIS)
3551 DrawMaskedBorder(REDRAW_DOOR_2);
3553 if (!game.restart_level)
3554 CloseDoor(DOOR_CLOSE_1);
3556 SetGameStatus(GAME_MODE_PLAYING);
3558 if (level_editor_test_game)
3559 FadeSkipNextFadeOut();
3561 FadeSetEnterScreen();
3564 fade_mask = REDRAW_ALL;
3566 FadeLevelSoundsAndMusic();
3568 ExpireSoundLoops(TRUE);
3572 if (level_editor_test_game)
3573 FadeSkipNextFadeIn();
3575 // needed if different viewport properties defined for playing
3576 ChangeViewportPropertiesIfNeeded();
3580 DrawCompleteVideoDisplay();
3582 OpenDoor(GetDoorState() | DOOR_NO_DELAY | DOOR_FORCE_REDRAW);
3585 InitGameControlValues();
3589 // initialize tape actions from game when recording tape
3590 tape.use_key_actions = game.use_key_actions;
3591 tape.use_mouse_actions = game.use_mouse_actions;
3593 // initialize visible playfield size when recording tape (for team mode)
3594 tape.scr_fieldx = SCR_FIELDX;
3595 tape.scr_fieldy = SCR_FIELDY;
3598 // don't play tapes over network
3599 network_playing = (network.enabled && !tape.playing);
3601 for (i = 0; i < MAX_PLAYERS; i++)
3603 struct PlayerInfo *player = &stored_player[i];
3605 player->index_nr = i;
3606 player->index_bit = (1 << i);
3607 player->element_nr = EL_PLAYER_1 + i;
3609 player->present = FALSE;
3610 player->active = FALSE;
3611 player->mapped = FALSE;
3613 player->killed = FALSE;
3614 player->reanimated = FALSE;
3615 player->buried = FALSE;
3618 player->effective_action = 0;
3619 player->programmed_action = 0;
3620 player->snap_action = 0;
3622 player->mouse_action.lx = 0;
3623 player->mouse_action.ly = 0;
3624 player->mouse_action.button = 0;
3625 player->mouse_action.button_hint = 0;
3627 player->effective_mouse_action.lx = 0;
3628 player->effective_mouse_action.ly = 0;
3629 player->effective_mouse_action.button = 0;
3630 player->effective_mouse_action.button_hint = 0;
3632 for (j = 0; j < MAX_NUM_KEYS; j++)
3633 player->key[j] = FALSE;
3635 player->num_white_keys = 0;
3637 player->dynabomb_count = 0;
3638 player->dynabomb_size = 1;
3639 player->dynabombs_left = 0;
3640 player->dynabomb_xl = FALSE;
3642 player->MovDir = initial_move_dir;
3645 player->GfxDir = initial_move_dir;
3646 player->GfxAction = ACTION_DEFAULT;
3648 player->StepFrame = 0;
3650 player->initial_element = player->element_nr;
3651 player->artwork_element =
3652 (level.use_artwork_element[i] ? level.artwork_element[i] :
3653 player->element_nr);
3654 player->use_murphy = FALSE;
3656 player->block_last_field = FALSE; // initialized in InitPlayerField()
3657 player->block_delay_adjustment = 0; // initialized in InitPlayerField()
3659 player->gravity = level.initial_player_gravity[i];
3661 player->can_fall_into_acid = CAN_MOVE_INTO_ACID(player->element_nr);
3663 player->actual_frame_counter = 0;
3665 player->step_counter = 0;
3667 player->last_move_dir = initial_move_dir;
3669 player->is_active = FALSE;
3671 player->is_waiting = FALSE;
3672 player->is_moving = FALSE;
3673 player->is_auto_moving = FALSE;
3674 player->is_digging = FALSE;
3675 player->is_snapping = FALSE;
3676 player->is_collecting = FALSE;
3677 player->is_pushing = FALSE;
3678 player->is_switching = FALSE;
3679 player->is_dropping = FALSE;
3680 player->is_dropping_pressed = FALSE;
3682 player->is_bored = FALSE;
3683 player->is_sleeping = FALSE;
3685 player->was_waiting = TRUE;
3686 player->was_moving = FALSE;
3687 player->was_snapping = FALSE;
3688 player->was_dropping = FALSE;
3690 player->force_dropping = FALSE;
3692 player->frame_counter_bored = -1;
3693 player->frame_counter_sleeping = -1;
3695 player->anim_delay_counter = 0;
3696 player->post_delay_counter = 0;
3698 player->dir_waiting = initial_move_dir;
3699 player->action_waiting = ACTION_DEFAULT;
3700 player->last_action_waiting = ACTION_DEFAULT;
3701 player->special_action_bored = ACTION_DEFAULT;
3702 player->special_action_sleeping = ACTION_DEFAULT;
3704 player->switch_x = -1;
3705 player->switch_y = -1;
3707 player->drop_x = -1;
3708 player->drop_y = -1;
3710 player->show_envelope = 0;
3712 SetPlayerMoveSpeed(player, level.initial_player_stepsize[i], TRUE);
3714 player->push_delay = -1; // initialized when pushing starts
3715 player->push_delay_value = game.initial_push_delay_value;
3717 player->drop_delay = 0;
3718 player->drop_pressed_delay = 0;
3720 player->last_jx = -1;
3721 player->last_jy = -1;
3725 player->shield_normal_time_left = 0;
3726 player->shield_deadly_time_left = 0;
3728 player->last_removed_element = EL_UNDEFINED;
3730 player->inventory_infinite_element = EL_UNDEFINED;
3731 player->inventory_size = 0;
3733 if (level.use_initial_inventory[i])
3735 for (j = 0; j < level.initial_inventory_size[i]; j++)
3737 int element = level.initial_inventory_content[i][j];
3738 int collect_count = element_info[element].collect_count_initial;
3741 if (!IS_CUSTOM_ELEMENT(element))
3744 if (collect_count == 0)
3745 player->inventory_infinite_element = element;
3747 for (k = 0; k < collect_count; k++)
3748 if (player->inventory_size < MAX_INVENTORY_SIZE)
3749 player->inventory_element[player->inventory_size++] = element;
3753 DigField(player, 0, 0, 0, 0, 0, 0, DF_NO_PUSH);
3754 SnapField(player, 0, 0);
3756 map_player_action[i] = i;
3759 network_player_action_received = FALSE;
3761 // initial null action
3762 if (network_playing)
3763 SendToServer_MovePlayer(MV_NONE);
3768 TimeLeft = level.time;
3771 ScreenMovDir = MV_NONE;
3775 ScrollStepSize = 0; // will be correctly initialized by ScrollScreen()
3777 game.robot_wheel_x = -1;
3778 game.robot_wheel_y = -1;
3783 game.all_players_gone = FALSE;
3785 game.LevelSolved = FALSE;
3786 game.GameOver = FALSE;
3788 game.GamePlayed = !tape.playing;
3790 game.LevelSolved_GameWon = FALSE;
3791 game.LevelSolved_GameEnd = FALSE;
3792 game.LevelSolved_SaveTape = FALSE;
3793 game.LevelSolved_SaveScore = FALSE;
3795 game.LevelSolved_CountingTime = 0;
3796 game.LevelSolved_CountingScore = 0;
3797 game.LevelSolved_CountingHealth = 0;
3799 game.panel.active = TRUE;
3801 game.no_time_limit = (level.time == 0);
3803 game.yamyam_content_nr = 0;
3804 game.robot_wheel_active = FALSE;
3805 game.magic_wall_active = FALSE;
3806 game.magic_wall_time_left = 0;
3807 game.light_time_left = 0;
3808 game.timegate_time_left = 0;
3809 game.switchgate_pos = 0;
3810 game.wind_direction = level.wind_direction_initial;
3812 game.time_final = 0;
3813 game.score_time_final = 0;
3816 game.score_final = 0;
3818 game.health = MAX_HEALTH;
3819 game.health_final = MAX_HEALTH;
3821 game.gems_still_needed = level.gems_needed;
3822 game.sokoban_fields_still_needed = 0;
3823 game.sokoban_objects_still_needed = 0;
3824 game.lights_still_needed = 0;
3825 game.players_still_needed = 0;
3826 game.friends_still_needed = 0;
3828 game.lenses_time_left = 0;
3829 game.magnify_time_left = 0;
3831 game.ball_active = level.ball_active_initial;
3832 game.ball_content_nr = 0;
3834 game.explosions_delayed = TRUE;
3836 game.envelope_active = FALSE;
3838 for (i = 0; i < NUM_BELTS; i++)
3840 game.belt_dir[i] = MV_NONE;
3841 game.belt_dir_nr[i] = 3; // not moving, next moving left
3844 for (i = 0; i < MAX_NUM_AMOEBA; i++)
3845 AmoebaCnt[i] = AmoebaCnt2[i] = 0;
3847 #if DEBUG_INIT_PLAYER
3848 DebugPrintPlayerStatus("Player status at level initialization");
3851 SCAN_PLAYFIELD(x, y)
3853 Tile[x][y] = Last[x][y] = level.field[x][y];
3854 MovPos[x][y] = MovDir[x][y] = MovDelay[x][y] = 0;
3855 ChangeDelay[x][y] = 0;
3856 ChangePage[x][y] = -1;
3857 CustomValue[x][y] = 0; // initialized in InitField()
3858 Store[x][y] = Store2[x][y] = StorePlayer[x][y] = Back[x][y] = 0;
3860 WasJustMoving[x][y] = 0;
3861 WasJustFalling[x][y] = 0;
3862 CheckCollision[x][y] = 0;
3863 CheckImpact[x][y] = 0;
3865 Pushed[x][y] = FALSE;
3867 ChangeCount[x][y] = 0;
3868 ChangeEvent[x][y] = -1;
3870 ExplodePhase[x][y] = 0;
3871 ExplodeDelay[x][y] = 0;
3872 ExplodeField[x][y] = EX_TYPE_NONE;
3874 RunnerVisit[x][y] = 0;
3875 PlayerVisit[x][y] = 0;
3878 GfxRandom[x][y] = INIT_GFX_RANDOM();
3879 GfxElement[x][y] = EL_UNDEFINED;
3880 GfxAction[x][y] = ACTION_DEFAULT;
3881 GfxDir[x][y] = MV_NONE;
3882 GfxRedraw[x][y] = GFX_REDRAW_NONE;
3885 SCAN_PLAYFIELD(x, y)
3887 if (emulate_bd && !IS_BD_ELEMENT(Tile[x][y]))
3889 if (emulate_sb && !IS_SB_ELEMENT(Tile[x][y]))
3891 if (emulate_sp && !IS_SP_ELEMENT(Tile[x][y]))
3894 InitField(x, y, TRUE);
3896 ResetGfxAnimation(x, y);
3901 for (i = 0; i < MAX_PLAYERS; i++)
3903 struct PlayerInfo *player = &stored_player[i];
3905 // set number of special actions for bored and sleeping animation
3906 player->num_special_action_bored =
3907 get_num_special_action(player->artwork_element,
3908 ACTION_BORING_1, ACTION_BORING_LAST);
3909 player->num_special_action_sleeping =
3910 get_num_special_action(player->artwork_element,
3911 ACTION_SLEEPING_1, ACTION_SLEEPING_LAST);
3914 game.emulation = (emulate_bd ? EMU_BOULDERDASH :
3915 emulate_sb ? EMU_SOKOBAN :
3916 emulate_sp ? EMU_SUPAPLEX : EMU_NONE);
3918 // initialize type of slippery elements
3919 for (i = 0; i < MAX_NUM_ELEMENTS; i++)
3921 if (!IS_CUSTOM_ELEMENT(i))
3923 // default: elements slip down either to the left or right randomly
3924 element_info[i].slippery_type = SLIPPERY_ANY_RANDOM;
3926 // SP style elements prefer to slip down on the left side
3927 if (game.engine_version >= VERSION_IDENT(3,1,1,0) && IS_SP_ELEMENT(i))
3928 element_info[i].slippery_type = SLIPPERY_ANY_LEFT_RIGHT;
3930 // BD style elements prefer to slip down on the left side
3931 if (game.emulation == EMU_BOULDERDASH)
3932 element_info[i].slippery_type = SLIPPERY_ANY_LEFT_RIGHT;
3936 // initialize explosion and ignition delay
3937 for (i = 0; i < MAX_NUM_ELEMENTS; i++)
3939 if (!IS_CUSTOM_ELEMENT(i))
3942 int delay = (((IS_SP_ELEMENT(i) && i != EL_EMPTY_SPACE) &&
3943 game.engine_version >= VERSION_IDENT(3,1,0,0)) ||
3944 game.emulation == EMU_SUPAPLEX ? 3 : 2);
3945 int last_phase = (num_phase + 1) * delay;
3946 int half_phase = (num_phase / 2) * delay;
3948 element_info[i].explosion_delay = last_phase - 1;
3949 element_info[i].ignition_delay = half_phase;
3951 if (i == EL_BLACK_ORB)
3952 element_info[i].ignition_delay = 1;
3956 // correct non-moving belts to start moving left
3957 for (i = 0; i < NUM_BELTS; i++)
3958 if (game.belt_dir[i] == MV_NONE)
3959 game.belt_dir_nr[i] = 3; // not moving, next moving left
3961 #if USE_NEW_PLAYER_ASSIGNMENTS
3962 // use preferred player also in local single-player mode
3963 if (!network.enabled && !game.team_mode)
3965 int new_index_nr = setup.network_player_nr;
3967 if (new_index_nr >= 0 && new_index_nr < MAX_PLAYERS)
3969 for (i = 0; i < MAX_PLAYERS; i++)
3970 stored_player[i].connected_locally = FALSE;
3972 stored_player[new_index_nr].connected_locally = TRUE;
3976 for (i = 0; i < MAX_PLAYERS; i++)
3978 stored_player[i].connected = FALSE;
3980 // in network game mode, the local player might not be the first player
3981 if (stored_player[i].connected_locally)
3982 local_player = &stored_player[i];
3985 if (!network.enabled)
3986 local_player->connected = TRUE;
3990 for (i = 0; i < MAX_PLAYERS; i++)
3991 stored_player[i].connected = tape.player_participates[i];
3993 else if (network.enabled)
3995 // add team mode players connected over the network (needed for correct
3996 // assignment of player figures from level to locally playing players)
3998 for (i = 0; i < MAX_PLAYERS; i++)
3999 if (stored_player[i].connected_network)
4000 stored_player[i].connected = TRUE;
4002 else if (game.team_mode)
4004 // try to guess locally connected team mode players (needed for correct
4005 // assignment of player figures from level to locally playing players)
4007 for (i = 0; i < MAX_PLAYERS; i++)
4008 if (setup.input[i].use_joystick ||
4009 setup.input[i].key.left != KSYM_UNDEFINED)
4010 stored_player[i].connected = TRUE;
4013 #if DEBUG_INIT_PLAYER
4014 DebugPrintPlayerStatus("Player status after level initialization");
4017 #if DEBUG_INIT_PLAYER
4018 Debug("game:init:player", "Reassigning players ...");
4021 // check if any connected player was not found in playfield
4022 for (i = 0; i < MAX_PLAYERS; i++)
4024 struct PlayerInfo *player = &stored_player[i];
4026 if (player->connected && !player->present)
4028 struct PlayerInfo *field_player = NULL;
4030 #if DEBUG_INIT_PLAYER
4031 Debug("game:init:player",
4032 "- looking for field player for player %d ...", i + 1);
4035 // assign first free player found that is present in the playfield
4037 // first try: look for unmapped playfield player that is not connected
4038 for (j = 0; j < MAX_PLAYERS; j++)
4039 if (field_player == NULL &&
4040 stored_player[j].present &&
4041 !stored_player[j].mapped &&
4042 !stored_player[j].connected)
4043 field_player = &stored_player[j];
4045 // second try: look for *any* unmapped playfield player
4046 for (j = 0; j < MAX_PLAYERS; j++)
4047 if (field_player == NULL &&
4048 stored_player[j].present &&
4049 !stored_player[j].mapped)
4050 field_player = &stored_player[j];
4052 if (field_player != NULL)
4054 int jx = field_player->jx, jy = field_player->jy;
4056 #if DEBUG_INIT_PLAYER
4057 Debug("game:init:player", "- found player %d",
4058 field_player->index_nr + 1);
4061 player->present = FALSE;
4062 player->active = FALSE;
4064 field_player->present = TRUE;
4065 field_player->active = TRUE;
4068 player->initial_element = field_player->initial_element;
4069 player->artwork_element = field_player->artwork_element;
4071 player->block_last_field = field_player->block_last_field;
4072 player->block_delay_adjustment = field_player->block_delay_adjustment;
4075 StorePlayer[jx][jy] = field_player->element_nr;
4077 field_player->jx = field_player->last_jx = jx;
4078 field_player->jy = field_player->last_jy = jy;
4080 if (local_player == player)
4081 local_player = field_player;
4083 map_player_action[field_player->index_nr] = i;
4085 field_player->mapped = TRUE;
4087 #if DEBUG_INIT_PLAYER
4088 Debug("game:init:player", "- map_player_action[%d] == %d",
4089 field_player->index_nr + 1, i + 1);
4094 if (player->connected && player->present)
4095 player->mapped = TRUE;
4098 #if DEBUG_INIT_PLAYER
4099 DebugPrintPlayerStatus("Player status after player assignment (first stage)");
4104 // check if any connected player was not found in playfield
4105 for (i = 0; i < MAX_PLAYERS; i++)
4107 struct PlayerInfo *player = &stored_player[i];
4109 if (player->connected && !player->present)
4111 for (j = 0; j < MAX_PLAYERS; j++)
4113 struct PlayerInfo *field_player = &stored_player[j];
4114 int jx = field_player->jx, jy = field_player->jy;
4116 // assign first free player found that is present in the playfield
4117 if (field_player->present && !field_player->connected)
4119 player->present = TRUE;
4120 player->active = TRUE;
4122 field_player->present = FALSE;
4123 field_player->active = FALSE;
4125 player->initial_element = field_player->initial_element;
4126 player->artwork_element = field_player->artwork_element;
4128 player->block_last_field = field_player->block_last_field;
4129 player->block_delay_adjustment = field_player->block_delay_adjustment;
4131 StorePlayer[jx][jy] = player->element_nr;
4133 player->jx = player->last_jx = jx;
4134 player->jy = player->last_jy = jy;
4144 Debug("game:init:player", "local_player->present == %d",
4145 local_player->present);
4148 // set focus to local player for network games, else to all players
4149 game.centered_player_nr = (network_playing ? local_player->index_nr : -1);
4150 game.centered_player_nr_next = game.centered_player_nr;
4151 game.set_centered_player = FALSE;
4152 game.set_centered_player_wrap = FALSE;
4154 if (network_playing && tape.recording)
4156 // store client dependent player focus when recording network games
4157 tape.centered_player_nr_next = game.centered_player_nr_next;
4158 tape.set_centered_player = TRUE;
4163 // when playing a tape, eliminate all players who do not participate
4165 #if USE_NEW_PLAYER_ASSIGNMENTS
4167 if (!game.team_mode)
4169 for (i = 0; i < MAX_PLAYERS; i++)
4171 if (stored_player[i].active &&
4172 !tape.player_participates[map_player_action[i]])
4174 struct PlayerInfo *player = &stored_player[i];
4175 int jx = player->jx, jy = player->jy;
4177 #if DEBUG_INIT_PLAYER
4178 Debug("game:init:player", "Removing player %d at (%d, %d)",
4182 player->active = FALSE;
4183 StorePlayer[jx][jy] = 0;
4184 Tile[jx][jy] = EL_EMPTY;
4191 for (i = 0; i < MAX_PLAYERS; i++)
4193 if (stored_player[i].active &&
4194 !tape.player_participates[i])
4196 struct PlayerInfo *player = &stored_player[i];
4197 int jx = player->jx, jy = player->jy;
4199 player->active = FALSE;
4200 StorePlayer[jx][jy] = 0;
4201 Tile[jx][jy] = EL_EMPTY;
4206 else if (!network.enabled && !game.team_mode) // && !tape.playing
4208 // when in single player mode, eliminate all but the local player
4210 for (i = 0; i < MAX_PLAYERS; i++)
4212 struct PlayerInfo *player = &stored_player[i];
4214 if (player->active && player != local_player)
4216 int jx = player->jx, jy = player->jy;
4218 player->active = FALSE;
4219 player->present = FALSE;
4221 StorePlayer[jx][jy] = 0;
4222 Tile[jx][jy] = EL_EMPTY;
4227 for (i = 0; i < MAX_PLAYERS; i++)
4228 if (stored_player[i].active)
4229 game.players_still_needed++;
4231 if (level.solved_by_one_player)
4232 game.players_still_needed = 1;
4234 // when recording the game, store which players take part in the game
4237 #if USE_NEW_PLAYER_ASSIGNMENTS
4238 for (i = 0; i < MAX_PLAYERS; i++)
4239 if (stored_player[i].connected)
4240 tape.player_participates[i] = TRUE;
4242 for (i = 0; i < MAX_PLAYERS; i++)
4243 if (stored_player[i].active)
4244 tape.player_participates[i] = TRUE;
4248 #if DEBUG_INIT_PLAYER
4249 DebugPrintPlayerStatus("Player status after player assignment (final stage)");
4252 if (BorderElement == EL_EMPTY)
4255 SBX_Right = lev_fieldx - SCR_FIELDX;
4257 SBY_Lower = lev_fieldy - SCR_FIELDY;
4262 SBX_Right = lev_fieldx - SCR_FIELDX + 1;
4264 SBY_Lower = lev_fieldy - SCR_FIELDY + 1;
4267 if (full_lev_fieldx <= SCR_FIELDX)
4268 SBX_Left = SBX_Right = -1 * (SCR_FIELDX - lev_fieldx) / 2;
4269 if (full_lev_fieldy <= SCR_FIELDY)
4270 SBY_Upper = SBY_Lower = -1 * (SCR_FIELDY - lev_fieldy) / 2;
4272 if (EVEN(SCR_FIELDX) && full_lev_fieldx > SCR_FIELDX)
4274 if (EVEN(SCR_FIELDY) && full_lev_fieldy > SCR_FIELDY)
4277 // if local player not found, look for custom element that might create
4278 // the player (make some assumptions about the right custom element)
4279 if (!local_player->present)
4281 int start_x = 0, start_y = 0;
4282 int found_rating = 0;
4283 int found_element = EL_UNDEFINED;
4284 int player_nr = local_player->index_nr;
4286 SCAN_PLAYFIELD(x, y)
4288 int element = Tile[x][y];
4293 if (level.use_start_element[player_nr] &&
4294 level.start_element[player_nr] == element &&
4301 found_element = element;
4304 if (!IS_CUSTOM_ELEMENT(element))
4307 if (CAN_CHANGE(element))
4309 for (i = 0; i < element_info[element].num_change_pages; i++)
4311 // check for player created from custom element as single target
4312 content = element_info[element].change_page[i].target_element;
4313 is_player = IS_PLAYER_ELEMENT(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 = IS_PLAYER_ELEMENT(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 = IS_PLAYER_ELEMENT(content);
4354 if (is_player && (found_rating < 1 ||
4355 (found_rating == 1 && element < found_element)))
4357 start_x = x + xx - 1;
4358 start_y = y + yy - 1;
4361 found_element = element;
4367 scroll_x = SCROLL_POSITION_X(start_x);
4368 scroll_y = SCROLL_POSITION_Y(start_y);
4372 scroll_x = SCROLL_POSITION_X(local_player->jx);
4373 scroll_y = SCROLL_POSITION_Y(local_player->jy);
4376 // !!! FIX THIS (START) !!!
4377 if (level.game_engine_type == GAME_ENGINE_TYPE_EM)
4379 InitGameEngine_EM();
4381 else if (level.game_engine_type == GAME_ENGINE_TYPE_SP)
4383 InitGameEngine_SP();
4385 else if (level.game_engine_type == GAME_ENGINE_TYPE_MM)
4387 InitGameEngine_MM();
4391 DrawLevel(REDRAW_FIELD);
4394 // after drawing the level, correct some elements
4395 if (game.timegate_time_left == 0)
4396 CloseAllOpenTimegates();
4399 // blit playfield from scroll buffer to normal back buffer for fading in
4400 BlitScreenToBitmap(backbuffer);
4401 // !!! FIX THIS (END) !!!
4403 DrawMaskedBorder(fade_mask);
4408 // full screen redraw is required at this point in the following cases:
4409 // - special editor door undrawn when game was started from level editor
4410 // - drawing area (playfield) was changed and has to be removed completely
4411 redraw_mask = REDRAW_ALL;
4415 if (!game.restart_level)
4417 // copy default game door content to main double buffer
4419 // !!! CHECK AGAIN !!!
4420 SetPanelBackground();
4421 // SetDoorBackgroundImage(IMG_BACKGROUND_PANEL);
4422 DrawBackground(DX, DY, DXSIZE, DYSIZE);
4425 SetPanelBackground();
4426 SetDrawBackgroundMask(REDRAW_DOOR_1);
4428 UpdateAndDisplayGameControlValues();
4430 if (!game.restart_level)
4436 CreateGameButtons();
4441 // copy actual game door content to door double buffer for OpenDoor()
4442 BlitBitmap(drawto, bitmap_db_door_1, DX, DY, DXSIZE, DYSIZE, 0, 0);
4444 OpenDoor(DOOR_OPEN_ALL);
4446 KeyboardAutoRepeatOffUnlessAutoplay();
4448 #if DEBUG_INIT_PLAYER
4449 DebugPrintPlayerStatus("Player status (final)");
4458 if (!game.restart_level && !tape.playing)
4460 LevelStats_incPlayed(level_nr);
4462 SaveLevelSetup_SeriesInfo();
4465 game.restart_level = FALSE;
4466 game.restart_game_message = NULL;
4468 game.request_active = FALSE;
4469 game.request_active_or_moving = FALSE;
4471 if (level.game_engine_type == GAME_ENGINE_TYPE_MM)
4472 InitGameActions_MM();
4474 SaveEngineSnapshotToListInitial();
4476 if (!game.restart_level)
4478 PlaySound(SND_GAME_STARTING);
4480 if (setup.sound_music)
4485 void UpdateEngineValues(int actual_scroll_x, int actual_scroll_y,
4486 int actual_player_x, int actual_player_y)
4488 // this is used for non-R'n'D game engines to update certain engine values
4490 // needed to determine if sounds are played within the visible screen area
4491 scroll_x = actual_scroll_x;
4492 scroll_y = actual_scroll_y;
4494 // needed to get player position for "follow finger" playing input method
4495 local_player->jx = actual_player_x;
4496 local_player->jy = actual_player_y;
4499 void InitMovDir(int x, int y)
4501 int i, element = Tile[x][y];
4502 static int xy[4][2] =
4509 static int direction[3][4] =
4511 { MV_RIGHT, MV_UP, MV_LEFT, MV_DOWN },
4512 { MV_LEFT, MV_DOWN, MV_RIGHT, MV_UP },
4513 { MV_LEFT, MV_RIGHT, MV_UP, MV_DOWN }
4522 Tile[x][y] = EL_BUG;
4523 MovDir[x][y] = direction[0][element - EL_BUG_RIGHT];
4526 case EL_SPACESHIP_RIGHT:
4527 case EL_SPACESHIP_UP:
4528 case EL_SPACESHIP_LEFT:
4529 case EL_SPACESHIP_DOWN:
4530 Tile[x][y] = EL_SPACESHIP;
4531 MovDir[x][y] = direction[0][element - EL_SPACESHIP_RIGHT];
4534 case EL_BD_BUTTERFLY_RIGHT:
4535 case EL_BD_BUTTERFLY_UP:
4536 case EL_BD_BUTTERFLY_LEFT:
4537 case EL_BD_BUTTERFLY_DOWN:
4538 Tile[x][y] = EL_BD_BUTTERFLY;
4539 MovDir[x][y] = direction[0][element - EL_BD_BUTTERFLY_RIGHT];
4542 case EL_BD_FIREFLY_RIGHT:
4543 case EL_BD_FIREFLY_UP:
4544 case EL_BD_FIREFLY_LEFT:
4545 case EL_BD_FIREFLY_DOWN:
4546 Tile[x][y] = EL_BD_FIREFLY;
4547 MovDir[x][y] = direction[0][element - EL_BD_FIREFLY_RIGHT];
4550 case EL_PACMAN_RIGHT:
4552 case EL_PACMAN_LEFT:
4553 case EL_PACMAN_DOWN:
4554 Tile[x][y] = EL_PACMAN;
4555 MovDir[x][y] = direction[0][element - EL_PACMAN_RIGHT];
4558 case EL_YAMYAM_LEFT:
4559 case EL_YAMYAM_RIGHT:
4561 case EL_YAMYAM_DOWN:
4562 Tile[x][y] = EL_YAMYAM;
4563 MovDir[x][y] = direction[2][element - EL_YAMYAM_LEFT];
4566 case EL_SP_SNIKSNAK:
4567 MovDir[x][y] = MV_UP;
4570 case EL_SP_ELECTRON:
4571 MovDir[x][y] = MV_LEFT;
4578 Tile[x][y] = EL_MOLE;
4579 MovDir[x][y] = direction[2][element - EL_MOLE_LEFT];
4582 case EL_SPRING_LEFT:
4583 case EL_SPRING_RIGHT:
4584 Tile[x][y] = EL_SPRING;
4585 MovDir[x][y] = direction[2][element - EL_SPRING_LEFT];
4589 if (IS_CUSTOM_ELEMENT(element))
4591 struct ElementInfo *ei = &element_info[element];
4592 int move_direction_initial = ei->move_direction_initial;
4593 int move_pattern = ei->move_pattern;
4595 if (move_direction_initial == MV_START_PREVIOUS)
4597 if (MovDir[x][y] != MV_NONE)
4600 move_direction_initial = MV_START_AUTOMATIC;
4603 if (move_direction_initial == MV_START_RANDOM)
4604 MovDir[x][y] = 1 << RND(4);
4605 else if (move_direction_initial & MV_ANY_DIRECTION)
4606 MovDir[x][y] = move_direction_initial;
4607 else if (move_pattern == MV_ALL_DIRECTIONS ||
4608 move_pattern == MV_TURNING_LEFT ||
4609 move_pattern == MV_TURNING_RIGHT ||
4610 move_pattern == MV_TURNING_LEFT_RIGHT ||
4611 move_pattern == MV_TURNING_RIGHT_LEFT ||
4612 move_pattern == MV_TURNING_RANDOM)
4613 MovDir[x][y] = 1 << RND(4);
4614 else if (move_pattern == MV_HORIZONTAL)
4615 MovDir[x][y] = (RND(2) ? MV_LEFT : MV_RIGHT);
4616 else if (move_pattern == MV_VERTICAL)
4617 MovDir[x][y] = (RND(2) ? MV_UP : MV_DOWN);
4618 else if (move_pattern & MV_ANY_DIRECTION)
4619 MovDir[x][y] = element_info[element].move_pattern;
4620 else if (move_pattern == MV_ALONG_LEFT_SIDE ||
4621 move_pattern == MV_ALONG_RIGHT_SIDE)
4623 // use random direction as default start direction
4624 if (game.engine_version >= VERSION_IDENT(3,1,0,0))
4625 MovDir[x][y] = 1 << RND(4);
4627 for (i = 0; i < NUM_DIRECTIONS; i++)
4629 int x1 = x + xy[i][0];
4630 int y1 = y + xy[i][1];
4632 if (!IN_LEV_FIELD(x1, y1) || !IS_FREE(x1, y1))
4634 if (move_pattern == MV_ALONG_RIGHT_SIDE)
4635 MovDir[x][y] = direction[0][i];
4637 MovDir[x][y] = direction[1][i];
4646 MovDir[x][y] = 1 << RND(4);
4648 if (element != EL_BUG &&
4649 element != EL_SPACESHIP &&
4650 element != EL_BD_BUTTERFLY &&
4651 element != EL_BD_FIREFLY)
4654 for (i = 0; i < NUM_DIRECTIONS; i++)
4656 int x1 = x + xy[i][0];
4657 int y1 = y + xy[i][1];
4659 if (!IN_LEV_FIELD(x1, y1) || !IS_FREE(x1, y1))
4661 if (element == EL_BUG || element == EL_BD_BUTTERFLY)
4663 MovDir[x][y] = direction[0][i];
4666 else if (element == EL_SPACESHIP || element == EL_BD_FIREFLY ||
4667 element == EL_SP_SNIKSNAK || element == EL_SP_ELECTRON)
4669 MovDir[x][y] = direction[1][i];
4678 GfxDir[x][y] = MovDir[x][y];
4681 void InitAmoebaNr(int x, int y)
4684 int group_nr = AmoebaNeighbourNr(x, y);
4688 for (i = 1; i < MAX_NUM_AMOEBA; i++)
4690 if (AmoebaCnt[i] == 0)
4698 AmoebaNr[x][y] = group_nr;
4699 AmoebaCnt[group_nr]++;
4700 AmoebaCnt2[group_nr]++;
4703 static void LevelSolved(void)
4705 if (level.game_engine_type == GAME_ENGINE_TYPE_RND &&
4706 game.players_still_needed > 0)
4709 game.LevelSolved = TRUE;
4710 game.GameOver = TRUE;
4715 static int time_count_steps;
4716 static int time, time_final;
4717 static float score, score_final; // needed for time score < 10 for 10 seconds
4718 static int health, health_final;
4719 static int game_over_delay_1 = 0;
4720 static int game_over_delay_2 = 0;
4721 static int game_over_delay_3 = 0;
4722 int time_score_base = MIN(MAX(1, level.time_score_base), 10);
4723 float time_score = (float)level.score[SC_TIME_BONUS] / time_score_base;
4725 if (!game.LevelSolved_GameWon)
4729 // do not start end game actions before the player stops moving (to exit)
4730 if (local_player->active && local_player->MovPos)
4733 game.time_final = (game.no_time_limit ? TimePlayed : TimeLeft);
4734 game.score_time_final = (level.use_step_counter ? TimePlayed :
4735 TimePlayed * FRAMES_PER_SECOND + TimeFrames);
4737 game.score_final = (level.game_engine_type == GAME_ENGINE_TYPE_EM ?
4738 game_em.lev->score :
4739 level.game_engine_type == GAME_ENGINE_TYPE_MM ?
4743 game.health_final = (level.game_engine_type == GAME_ENGINE_TYPE_MM ?
4744 MM_HEALTH(game_mm.laser_overload_value) :
4747 game.LevelSolved_CountingTime = game.time_final;
4748 game.LevelSolved_CountingScore = game.score_final;
4749 game.LevelSolved_CountingHealth = game.health_final;
4751 game.LevelSolved_GameWon = TRUE;
4752 game.LevelSolved_SaveTape = tape.recording;
4753 game.LevelSolved_SaveScore = !tape.playing;
4757 LevelStats_incSolved(level_nr);
4759 SaveLevelSetup_SeriesInfo();
4762 if (tape.auto_play) // tape might already be stopped here
4763 tape.auto_play_level_solved = TRUE;
4767 game_over_delay_1 = FRAMES_PER_SECOND; // delay before counting time
4768 game_over_delay_2 = FRAMES_PER_SECOND / 2; // delay before counting health
4769 game_over_delay_3 = FRAMES_PER_SECOND; // delay before ending the game
4771 time = time_final = game.time_final;
4772 score = score_final = game.score_final;
4773 health = health_final = game.health_final;
4777 int time_final_max = 999;
4778 int time_frames_final_max = time_final_max * FRAMES_PER_SECOND;
4779 int time_frames = 0;
4780 int time_frames_left = TimeLeft * FRAMES_PER_SECOND - TimeFrames;
4781 int time_frames_played = TimePlayed * FRAMES_PER_SECOND + TimeFrames;
4786 time_frames = time_frames_left;
4788 else if (game.no_time_limit && TimePlayed < time_final_max)
4790 time_final = time_final_max;
4791 time_frames = time_frames_final_max - time_frames_played;
4794 score_final += time_score * time_frames / FRAMES_PER_SECOND + 0.5;
4796 time_count_steps = MAX(1, ABS(time_final - time) / 100);
4798 if (level.game_engine_type == GAME_ENGINE_TYPE_MM)
4801 score_final += health * time_score;
4804 game.score_final = score_final;
4805 game.health_final = health_final;
4808 if (level_editor_test_game || !setup.count_score_after_game)
4811 score = score_final;
4813 game.LevelSolved_CountingTime = time;
4814 game.LevelSolved_CountingScore = score;
4816 game_panel_controls[GAME_PANEL_TIME].value = time;
4817 game_panel_controls[GAME_PANEL_SCORE].value = score;
4819 DisplayGameControlValues();
4822 if (level.game_engine_type == GAME_ENGINE_TYPE_RND)
4824 // check if last player has left the level
4825 if (game.exit_x >= 0 &&
4828 int x = game.exit_x;
4829 int y = game.exit_y;
4830 int element = Tile[x][y];
4832 // close exit door after last player
4833 if ((game.all_players_gone &&
4834 (element == EL_EXIT_OPEN ||
4835 element == EL_SP_EXIT_OPEN ||
4836 element == EL_STEEL_EXIT_OPEN)) ||
4837 element == EL_EM_EXIT_OPEN ||
4838 element == EL_EM_STEEL_EXIT_OPEN)
4842 (element == EL_EXIT_OPEN ? EL_EXIT_CLOSING :
4843 element == EL_EM_EXIT_OPEN ? EL_EM_EXIT_CLOSING :
4844 element == EL_SP_EXIT_OPEN ? EL_SP_EXIT_CLOSING:
4845 element == EL_STEEL_EXIT_OPEN ? EL_STEEL_EXIT_CLOSING:
4846 EL_EM_STEEL_EXIT_CLOSING);
4848 PlayLevelSoundElementAction(x, y, element, ACTION_CLOSING);
4851 // player disappears
4852 DrawLevelField(x, y);
4855 for (i = 0; i < MAX_PLAYERS; i++)
4857 struct PlayerInfo *player = &stored_player[i];
4859 if (player->present)
4861 RemovePlayer(player);
4863 // player disappears
4864 DrawLevelField(player->jx, player->jy);
4869 PlaySound(SND_GAME_WINNING);
4872 if (setup.count_score_after_game)
4874 if (time != time_final)
4876 if (game_over_delay_1 > 0)
4878 game_over_delay_1--;
4883 int time_to_go = ABS(time_final - time);
4884 int time_count_dir = (time < time_final ? +1 : -1);
4886 if (time_to_go < time_count_steps)
4887 time_count_steps = 1;
4889 time += time_count_steps * time_count_dir;
4890 score += time_count_steps * time_score;
4892 // set final score to correct rounding differences after counting score
4893 if (time == time_final)
4894 score = score_final;
4896 game.LevelSolved_CountingTime = time;
4897 game.LevelSolved_CountingScore = score;
4899 game_panel_controls[GAME_PANEL_TIME].value = time;
4900 game_panel_controls[GAME_PANEL_SCORE].value = score;
4902 DisplayGameControlValues();
4904 if (time == time_final)
4905 StopSound(SND_GAME_LEVELTIME_BONUS);
4906 else if (setup.sound_loops)
4907 PlaySoundLoop(SND_GAME_LEVELTIME_BONUS);
4909 PlaySound(SND_GAME_LEVELTIME_BONUS);
4914 if (health != health_final)
4916 if (game_over_delay_2 > 0)
4918 game_over_delay_2--;
4923 int health_count_dir = (health < health_final ? +1 : -1);
4925 health += health_count_dir;
4926 score += time_score;
4928 game.LevelSolved_CountingHealth = health;
4929 game.LevelSolved_CountingScore = score;
4931 game_panel_controls[GAME_PANEL_HEALTH].value = health;
4932 game_panel_controls[GAME_PANEL_SCORE].value = score;
4934 DisplayGameControlValues();
4936 if (health == health_final)
4937 StopSound(SND_GAME_LEVELTIME_BONUS);
4938 else if (setup.sound_loops)
4939 PlaySoundLoop(SND_GAME_LEVELTIME_BONUS);
4941 PlaySound(SND_GAME_LEVELTIME_BONUS);
4947 game.panel.active = FALSE;
4949 if (game_over_delay_3 > 0)
4951 game_over_delay_3--;
4961 // used instead of "level_nr" (needed for network games)
4962 int last_level_nr = levelset.level_nr;
4964 game.LevelSolved_GameEnd = TRUE;
4966 if (game.LevelSolved_SaveTape)
4968 // make sure that request dialog to save tape does not open door again
4969 if (!global.use_envelope_request)
4970 CloseDoor(DOOR_CLOSE_1);
4972 SaveTapeChecked_LevelSolved(tape.level_nr); // ask to save tape
4974 // set unique basename for score tape (also saved in high score table)
4975 strcpy(tape.score_tape_basename, getScoreTapeBasename(setup.player_name));
4978 // if no tape is to be saved, close both doors simultaneously
4979 CloseDoor(DOOR_CLOSE_ALL);
4981 if (level_editor_test_game)
4983 SetGameStatus(GAME_MODE_MAIN);
4990 if (!game.LevelSolved_SaveScore)
4992 SetGameStatus(GAME_MODE_MAIN);
4999 if (level_nr == leveldir_current->handicap_level)
5001 leveldir_current->handicap_level++;
5003 SaveLevelSetup_SeriesInfo();
5006 // save score and score tape before potentially erasing tape below
5007 NewHighScore(last_level_nr);
5009 if (setup.increment_levels &&
5010 level_nr < leveldir_current->last_level &&
5013 level_nr++; // advance to next level
5014 TapeErase(); // start with empty tape
5016 if (setup.auto_play_next_level)
5018 LoadLevel(level_nr);
5020 SaveLevelSetup_SeriesInfo();
5024 if (scores.last_added >= 0 && setup.show_scores_after_game)
5026 SetGameStatus(GAME_MODE_SCORES);
5028 DrawHallOfFame(last_level_nr);
5030 else if (setup.auto_play_next_level && setup.increment_levels &&
5031 last_level_nr < leveldir_current->last_level &&
5034 StartGameActions(network.enabled, setup.autorecord, level.random_seed);
5038 SetGameStatus(GAME_MODE_MAIN);
5044 static int addScoreEntry(struct ScoreInfo *list, struct ScoreEntry *new_entry,
5045 boolean one_score_entry_per_name)
5049 if (strEqual(new_entry->name, EMPTY_PLAYER_NAME))
5052 for (i = 0; i < MAX_SCORE_ENTRIES; i++)
5054 struct ScoreEntry *entry = &list->entry[i];
5055 boolean score_is_better = (new_entry->score > entry->score);
5056 boolean score_is_equal = (new_entry->score == entry->score);
5057 boolean time_is_better = (new_entry->time < entry->time);
5058 boolean time_is_equal = (new_entry->time == entry->time);
5059 boolean better_by_score = (score_is_better ||
5060 (score_is_equal && time_is_better));
5061 boolean better_by_time = (time_is_better ||
5062 (time_is_equal && score_is_better));
5063 boolean is_better = (level.rate_time_over_score ? better_by_time :
5065 boolean entry_is_empty = (entry->score == 0 &&
5068 // prevent adding server score entries if also existing in local score file
5069 // (special case: historic score entries have an empty tape basename entry)
5070 if (strEqual(new_entry->tape_basename, entry->tape_basename) &&
5071 !strEqual(new_entry->tape_basename, UNDEFINED_FILENAME))
5074 if (is_better || entry_is_empty)
5076 // player has made it to the hall of fame
5078 if (i < MAX_SCORE_ENTRIES - 1)
5080 int m = MAX_SCORE_ENTRIES - 1;
5083 if (one_score_entry_per_name)
5085 for (l = i; l < MAX_SCORE_ENTRIES; l++)
5086 if (strEqual(list->entry[l].name, new_entry->name))
5089 if (m == i) // player's new highscore overwrites his old one
5093 for (l = m; l > i; l--)
5094 list->entry[l] = list->entry[l - 1];
5099 *entry = *new_entry;
5103 else if (one_score_entry_per_name &&
5104 strEqual(entry->name, new_entry->name))
5106 // player already in high score list with better score or time
5115 void NewHighScore(int level_nr)
5117 struct ScoreEntry new_entry = {{ 0 }}; // (prevent warning from GCC bug 53119)
5118 boolean one_per_name = FALSE;
5120 strncpy(new_entry.tape_basename, tape.score_tape_basename, MAX_FILENAME_LEN);
5121 strncpy(new_entry.name, setup.player_name, MAX_PLAYER_NAME_LEN);
5123 new_entry.score = game.score_final;
5124 new_entry.time = game.score_time_final;
5126 LoadScore(level_nr);
5128 scores.last_added = addScoreEntry(&scores, &new_entry, one_per_name);
5130 if (scores.last_added >= 0)
5132 SaveScore(level_nr);
5134 // store last added local score entry (before merging server scores)
5135 scores.last_added_local = scores.last_added;
5138 if (game.LevelSolved_SaveTape)
5140 SaveScoreTape(level_nr);
5141 SaveServerScore(level_nr);
5145 void MergeServerScore(void)
5147 struct ScoreEntry last_added_entry;
5148 boolean one_per_name = FALSE;
5151 if (scores.last_added >= 0)
5152 last_added_entry = scores.entry[scores.last_added];
5154 for (i = 0; i < server_scores.num_entries; i++)
5156 int pos = addScoreEntry(&scores, &server_scores.entry[i], one_per_name);
5158 if (pos >= 0 && pos <= scores.last_added)
5159 scores.last_added++;
5162 if (scores.last_added >= MAX_SCORE_ENTRIES)
5164 scores.last_added = MAX_SCORE_ENTRIES - 1;
5165 scores.force_last_added = TRUE;
5167 scores.entry[scores.last_added] = last_added_entry;
5171 static int getElementMoveStepsizeExt(int x, int y, int direction)
5173 int element = Tile[x][y];
5174 int dx = (direction == MV_LEFT ? -1 : direction == MV_RIGHT ? +1 : 0);
5175 int dy = (direction == MV_UP ? -1 : direction == MV_DOWN ? +1 : 0);
5176 int horiz_move = (dx != 0);
5177 int sign = (horiz_move ? dx : dy);
5178 int step = sign * element_info[element].move_stepsize;
5180 // special values for move stepsize for spring and things on conveyor belt
5183 if (CAN_FALL(element) &&
5184 y < lev_fieldy - 1 && IS_BELT_ACTIVE(Tile[x][y + 1]))
5185 step = sign * MOVE_STEPSIZE_NORMAL / 2;
5186 else if (element == EL_SPRING)
5187 step = sign * MOVE_STEPSIZE_NORMAL * 2;
5193 static int getElementMoveStepsize(int x, int y)
5195 return getElementMoveStepsizeExt(x, y, MovDir[x][y]);
5198 void InitPlayerGfxAnimation(struct PlayerInfo *player, int action, int dir)
5200 if (player->GfxAction != action || player->GfxDir != dir)
5202 player->GfxAction = action;
5203 player->GfxDir = dir;
5205 player->StepFrame = 0;
5209 static void ResetGfxFrame(int x, int y)
5211 // profiling showed that "autotest" spends 10~20% of its time in this function
5212 if (DrawingDeactivatedField())
5215 int element = Tile[x][y];
5216 int graphic = el_act_dir2img(element, GfxAction[x][y], GfxDir[x][y]);
5218 if (graphic_info[graphic].anim_global_sync)
5219 GfxFrame[x][y] = FrameCounter;
5220 else if (ANIM_MODE(graphic) == ANIM_CE_VALUE)
5221 GfxFrame[x][y] = CustomValue[x][y];
5222 else if (ANIM_MODE(graphic) == ANIM_CE_SCORE)
5223 GfxFrame[x][y] = element_info[element].collect_score;
5224 else if (ANIM_MODE(graphic) == ANIM_CE_DELAY)
5225 GfxFrame[x][y] = ChangeDelay[x][y];
5228 static void ResetGfxAnimation(int x, int y)
5230 GfxAction[x][y] = ACTION_DEFAULT;
5231 GfxDir[x][y] = MovDir[x][y];
5234 ResetGfxFrame(x, y);
5237 static void ResetRandomAnimationValue(int x, int y)
5239 GfxRandom[x][y] = INIT_GFX_RANDOM();
5242 static void InitMovingField(int x, int y, int direction)
5244 int element = Tile[x][y];
5245 int dx = (direction == MV_LEFT ? -1 : direction == MV_RIGHT ? +1 : 0);
5246 int dy = (direction == MV_UP ? -1 : direction == MV_DOWN ? +1 : 0);
5249 boolean is_moving_before, is_moving_after;
5251 // check if element was/is moving or being moved before/after mode change
5252 is_moving_before = (WasJustMoving[x][y] != 0);
5253 is_moving_after = (getElementMoveStepsizeExt(x, y, direction) != 0);
5255 // reset animation only for moving elements which change direction of moving
5256 // or which just started or stopped moving
5257 // (else CEs with property "can move" / "not moving" are reset each frame)
5258 if (is_moving_before != is_moving_after ||
5259 direction != MovDir[x][y])
5260 ResetGfxAnimation(x, y);
5262 MovDir[x][y] = direction;
5263 GfxDir[x][y] = direction;
5265 GfxAction[x][y] = (!is_moving_after ? ACTION_WAITING :
5266 direction == MV_DOWN && CAN_FALL(element) ?
5267 ACTION_FALLING : ACTION_MOVING);
5269 // this is needed for CEs with property "can move" / "not moving"
5271 if (is_moving_after)
5273 if (Tile[newx][newy] == EL_EMPTY)
5274 Tile[newx][newy] = EL_BLOCKED;
5276 MovDir[newx][newy] = MovDir[x][y];
5278 CustomValue[newx][newy] = CustomValue[x][y];
5280 GfxFrame[newx][newy] = GfxFrame[x][y];
5281 GfxRandom[newx][newy] = GfxRandom[x][y];
5282 GfxAction[newx][newy] = GfxAction[x][y];
5283 GfxDir[newx][newy] = GfxDir[x][y];
5287 void Moving2Blocked(int x, int y, int *goes_to_x, int *goes_to_y)
5289 int direction = MovDir[x][y];
5290 int newx = x + (direction & MV_LEFT ? -1 : direction & MV_RIGHT ? +1 : 0);
5291 int newy = y + (direction & MV_UP ? -1 : direction & MV_DOWN ? +1 : 0);
5297 void Blocked2Moving(int x, int y, int *comes_from_x, int *comes_from_y)
5299 int oldx = x, oldy = y;
5300 int direction = MovDir[x][y];
5302 if (direction == MV_LEFT)
5304 else if (direction == MV_RIGHT)
5306 else if (direction == MV_UP)
5308 else if (direction == MV_DOWN)
5311 *comes_from_x = oldx;
5312 *comes_from_y = oldy;
5315 static int MovingOrBlocked2Element(int x, int y)
5317 int element = Tile[x][y];
5319 if (element == EL_BLOCKED)
5323 Blocked2Moving(x, y, &oldx, &oldy);
5324 return Tile[oldx][oldy];
5330 static int MovingOrBlocked2ElementIfNotLeaving(int x, int y)
5332 // like MovingOrBlocked2Element(), but if element is moving
5333 // and (x,y) is the field the moving element is just leaving,
5334 // return EL_BLOCKED instead of the element value
5335 int element = Tile[x][y];
5337 if (IS_MOVING(x, y))
5339 if (element == EL_BLOCKED)
5343 Blocked2Moving(x, y, &oldx, &oldy);
5344 return Tile[oldx][oldy];
5353 static void RemoveField(int x, int y)
5355 Tile[x][y] = EL_EMPTY;
5361 CustomValue[x][y] = 0;
5364 ChangeDelay[x][y] = 0;
5365 ChangePage[x][y] = -1;
5366 Pushed[x][y] = FALSE;
5368 GfxElement[x][y] = EL_UNDEFINED;
5369 GfxAction[x][y] = ACTION_DEFAULT;
5370 GfxDir[x][y] = MV_NONE;
5373 static void RemoveMovingField(int x, int y)
5375 int oldx = x, oldy = y, newx = x, newy = y;
5376 int element = Tile[x][y];
5377 int next_element = EL_UNDEFINED;
5379 if (element != EL_BLOCKED && !IS_MOVING(x, y))
5382 if (IS_MOVING(x, y))
5384 Moving2Blocked(x, y, &newx, &newy);
5386 if (Tile[newx][newy] != EL_BLOCKED)
5388 // element is moving, but target field is not free (blocked), but
5389 // already occupied by something different (example: acid pool);
5390 // in this case, only remove the moving field, but not the target
5392 RemoveField(oldx, oldy);
5394 Store[oldx][oldy] = Store2[oldx][oldy] = 0;
5396 TEST_DrawLevelField(oldx, oldy);
5401 else if (element == EL_BLOCKED)
5403 Blocked2Moving(x, y, &oldx, &oldy);
5404 if (!IS_MOVING(oldx, oldy))
5408 if (element == EL_BLOCKED &&
5409 (Tile[oldx][oldy] == EL_QUICKSAND_EMPTYING ||
5410 Tile[oldx][oldy] == EL_QUICKSAND_FAST_EMPTYING ||
5411 Tile[oldx][oldy] == EL_MAGIC_WALL_EMPTYING ||
5412 Tile[oldx][oldy] == EL_BD_MAGIC_WALL_EMPTYING ||
5413 Tile[oldx][oldy] == EL_DC_MAGIC_WALL_EMPTYING ||
5414 Tile[oldx][oldy] == EL_AMOEBA_DROPPING))
5415 next_element = get_next_element(Tile[oldx][oldy]);
5417 RemoveField(oldx, oldy);
5418 RemoveField(newx, newy);
5420 Store[oldx][oldy] = Store2[oldx][oldy] = 0;
5422 if (next_element != EL_UNDEFINED)
5423 Tile[oldx][oldy] = next_element;
5425 TEST_DrawLevelField(oldx, oldy);
5426 TEST_DrawLevelField(newx, newy);
5429 void DrawDynamite(int x, int y)
5431 int sx = SCREENX(x), sy = SCREENY(y);
5432 int graphic = el2img(Tile[x][y]);
5435 if (!IN_SCR_FIELD(sx, sy) || IS_PLAYER(x, y))
5438 if (IS_WALKABLE_INSIDE(Back[x][y]))
5442 DrawLevelElement(x, y, Back[x][y]);
5443 else if (Store[x][y])
5444 DrawLevelElement(x, y, Store[x][y]);
5445 else if (game.use_masked_elements)
5446 DrawLevelElement(x, y, EL_EMPTY);
5448 frame = getGraphicAnimationFrame(graphic, GfxFrame[x][y]);
5450 if (Back[x][y] || Store[x][y] || game.use_masked_elements)
5451 DrawGraphicThruMask(sx, sy, graphic, frame);
5453 DrawGraphic(sx, sy, graphic, frame);
5456 static void CheckDynamite(int x, int y)
5458 if (MovDelay[x][y] != 0) // dynamite is still waiting to explode
5462 if (MovDelay[x][y] != 0)
5465 PlayLevelSoundActionIfLoop(x, y, ACTION_ACTIVE);
5471 StopLevelSoundActionIfLoop(x, y, ACTION_ACTIVE);
5476 static void setMinimalPlayerBoundaries(int *sx1, int *sy1, int *sx2, int *sy2)
5478 boolean num_checked_players = 0;
5481 for (i = 0; i < MAX_PLAYERS; i++)
5483 if (stored_player[i].active)
5485 int sx = stored_player[i].jx;
5486 int sy = stored_player[i].jy;
5488 if (num_checked_players == 0)
5495 *sx1 = MIN(*sx1, sx);
5496 *sy1 = MIN(*sy1, sy);
5497 *sx2 = MAX(*sx2, sx);
5498 *sy2 = MAX(*sy2, sy);
5501 num_checked_players++;
5506 static boolean checkIfAllPlayersFitToScreen_RND(void)
5508 int sx1 = 0, sy1 = 0, sx2 = 0, sy2 = 0;
5510 setMinimalPlayerBoundaries(&sx1, &sy1, &sx2, &sy2);
5512 return (sx2 - sx1 < SCR_FIELDX &&
5513 sy2 - sy1 < SCR_FIELDY);
5516 static void setScreenCenteredToAllPlayers(int *sx, int *sy)
5518 int sx1 = scroll_x, sy1 = scroll_y, sx2 = scroll_x, sy2 = scroll_y;
5520 setMinimalPlayerBoundaries(&sx1, &sy1, &sx2, &sy2);
5522 *sx = (sx1 + sx2) / 2;
5523 *sy = (sy1 + sy2) / 2;
5526 static void DrawRelocateScreen(int old_x, int old_y, int x, int y, int move_dir,
5527 boolean center_screen, boolean quick_relocation)
5529 unsigned int frame_delay_value_old = GetVideoFrameDelay();
5530 boolean ffwd_delay = (tape.playing && tape.fast_forward);
5531 boolean no_delay = (tape.warp_forward);
5532 int frame_delay_value = (ffwd_delay ? FfwdFrameDelay : GameFrameDelay);
5533 int wait_delay_value = (no_delay ? 0 : frame_delay_value);
5534 int new_scroll_x, new_scroll_y;
5536 if (level.lazy_relocation && IN_VIS_FIELD(SCREENX(x), SCREENY(y)))
5538 // case 1: quick relocation inside visible screen (without scrolling)
5545 if (!level.shifted_relocation || center_screen)
5547 // relocation _with_ centering of screen
5549 new_scroll_x = SCROLL_POSITION_X(x);
5550 new_scroll_y = SCROLL_POSITION_Y(y);
5554 // relocation _without_ centering of screen
5556 int center_scroll_x = SCROLL_POSITION_X(old_x);
5557 int center_scroll_y = SCROLL_POSITION_Y(old_y);
5558 int offset_x = x + (scroll_x - center_scroll_x);
5559 int offset_y = y + (scroll_y - center_scroll_y);
5561 // for new screen position, apply previous offset to center position
5562 new_scroll_x = SCROLL_POSITION_X(offset_x);
5563 new_scroll_y = SCROLL_POSITION_Y(offset_y);
5566 if (quick_relocation)
5568 // case 2: quick relocation (redraw without visible scrolling)
5570 scroll_x = new_scroll_x;
5571 scroll_y = new_scroll_y;
5578 // case 3: visible relocation (with scrolling to new position)
5580 ScrollScreen(NULL, SCROLL_GO_ON); // scroll last frame to full tile
5582 SetVideoFrameDelay(wait_delay_value);
5584 while (scroll_x != new_scroll_x || scroll_y != new_scroll_y)
5586 int dx = (new_scroll_x < scroll_x ? +1 : new_scroll_x > scroll_x ? -1 : 0);
5587 int dy = (new_scroll_y < scroll_y ? +1 : new_scroll_y > scroll_y ? -1 : 0);
5589 if (dx == 0 && dy == 0) // no scrolling needed at all
5595 // set values for horizontal/vertical screen scrolling (half tile size)
5596 int dir_x = (dx != 0 ? MV_HORIZONTAL : 0);
5597 int dir_y = (dy != 0 ? MV_VERTICAL : 0);
5598 int pos_x = dx * TILEX / 2;
5599 int pos_y = dy * TILEY / 2;
5600 int fx = getFieldbufferOffsetX_RND(dir_x, pos_x);
5601 int fy = getFieldbufferOffsetY_RND(dir_y, pos_y);
5603 ScrollLevel(dx, dy);
5606 // scroll in two steps of half tile size to make things smoother
5607 BlitScreenToBitmapExt_RND(window, fx, fy);
5609 // scroll second step to align at full tile size
5610 BlitScreenToBitmap(window);
5616 SetVideoFrameDelay(frame_delay_value_old);
5619 static void RelocatePlayer(int jx, int jy, int el_player_raw)
5621 int el_player = GET_PLAYER_ELEMENT(el_player_raw);
5622 int player_nr = GET_PLAYER_NR(el_player);
5623 struct PlayerInfo *player = &stored_player[player_nr];
5624 boolean ffwd_delay = (tape.playing && tape.fast_forward);
5625 boolean no_delay = (tape.warp_forward);
5626 int frame_delay_value = (ffwd_delay ? FfwdFrameDelay : GameFrameDelay);
5627 int wait_delay_value = (no_delay ? 0 : frame_delay_value);
5628 int old_jx = player->jx;
5629 int old_jy = player->jy;
5630 int old_element = Tile[old_jx][old_jy];
5631 int element = Tile[jx][jy];
5632 boolean player_relocated = (old_jx != jx || old_jy != jy);
5634 int move_dir_horiz = (jx < old_jx ? MV_LEFT : jx > old_jx ? MV_RIGHT : 0);
5635 int move_dir_vert = (jy < old_jy ? MV_UP : jy > old_jy ? MV_DOWN : 0);
5636 int enter_side_horiz = MV_DIR_OPPOSITE(move_dir_horiz);
5637 int enter_side_vert = MV_DIR_OPPOSITE(move_dir_vert);
5638 int leave_side_horiz = move_dir_horiz;
5639 int leave_side_vert = move_dir_vert;
5640 int enter_side = enter_side_horiz | enter_side_vert;
5641 int leave_side = leave_side_horiz | leave_side_vert;
5643 if (player->buried) // do not reanimate dead player
5646 if (!player_relocated) // no need to relocate the player
5649 if (IS_PLAYER(jx, jy)) // player already placed at new position
5651 RemoveField(jx, jy); // temporarily remove newly placed player
5652 DrawLevelField(jx, jy);
5655 if (player->present)
5657 while (player->MovPos)
5659 ScrollPlayer(player, SCROLL_GO_ON);
5660 ScrollScreen(NULL, SCROLL_GO_ON);
5662 AdvanceFrameAndPlayerCounters(player->index_nr);
5666 BackToFront_WithFrameDelay(wait_delay_value);
5669 DrawPlayer(player); // needed here only to cleanup last field
5670 DrawLevelField(player->jx, player->jy); // remove player graphic
5672 player->is_moving = FALSE;
5675 if (IS_CUSTOM_ELEMENT(old_element))
5676 CheckElementChangeByPlayer(old_jx, old_jy, old_element,
5678 player->index_bit, leave_side);
5680 CheckTriggeredElementChangeByPlayer(old_jx, old_jy, old_element,
5682 player->index_bit, leave_side);
5684 Tile[jx][jy] = el_player;
5685 InitPlayerField(jx, jy, el_player, TRUE);
5687 /* "InitPlayerField()" above sets Tile[jx][jy] to EL_EMPTY, but it may be
5688 possible that the relocation target field did not contain a player element,
5689 but a walkable element, to which the new player was relocated -- in this
5690 case, restore that (already initialized!) element on the player field */
5691 if (!IS_PLAYER_ELEMENT(element)) // player may be set on walkable element
5693 Tile[jx][jy] = element; // restore previously existing element
5696 // only visually relocate centered player
5697 DrawRelocateScreen(old_jx, old_jy, player->jx, player->jy, player->MovDir,
5698 FALSE, level.instant_relocation);
5700 TestIfPlayerTouchesBadThing(jx, jy);
5701 TestIfPlayerTouchesCustomElement(jx, jy);
5703 if (IS_CUSTOM_ELEMENT(element))
5704 CheckElementChangeByPlayer(jx, jy, element, CE_ENTERED_BY_PLAYER,
5705 player->index_bit, enter_side);
5707 CheckTriggeredElementChangeByPlayer(jx, jy, element, CE_PLAYER_ENTERS_X,
5708 player->index_bit, enter_side);
5710 if (player->is_switching)
5712 /* ensure that relocation while still switching an element does not cause
5713 a new element to be treated as also switched directly after relocation
5714 (this is important for teleporter switches that teleport the player to
5715 a place where another teleporter switch is in the same direction, which
5716 would then incorrectly be treated as immediately switched before the
5717 direction key that caused the switch was released) */
5719 player->switch_x += jx - old_jx;
5720 player->switch_y += jy - old_jy;
5724 static void Explode(int ex, int ey, int phase, int mode)
5730 // !!! eliminate this variable !!!
5731 int delay = (game.emulation == EMU_SUPAPLEX ? 3 : 2);
5733 if (game.explosions_delayed)
5735 ExplodeField[ex][ey] = mode;
5739 if (phase == EX_PHASE_START) // initialize 'Store[][]' field
5741 int center_element = Tile[ex][ey];
5742 int artwork_element, explosion_element; // set these values later
5744 // remove things displayed in background while burning dynamite
5745 if (Back[ex][ey] != EL_EMPTY && !IS_INDESTRUCTIBLE(Back[ex][ey]))
5748 if (IS_MOVING(ex, ey) || IS_BLOCKED(ex, ey))
5750 // put moving element to center field (and let it explode there)
5751 center_element = MovingOrBlocked2Element(ex, ey);
5752 RemoveMovingField(ex, ey);
5753 Tile[ex][ey] = center_element;
5756 // now "center_element" is finally determined -- set related values now
5757 artwork_element = center_element; // for custom player artwork
5758 explosion_element = center_element; // for custom player artwork
5760 if (IS_PLAYER(ex, ey))
5762 int player_nr = GET_PLAYER_NR(StorePlayer[ex][ey]);
5764 artwork_element = stored_player[player_nr].artwork_element;
5766 if (level.use_explosion_element[player_nr])
5768 explosion_element = level.explosion_element[player_nr];
5769 artwork_element = explosion_element;
5773 if (mode == EX_TYPE_NORMAL ||
5774 mode == EX_TYPE_CENTER ||
5775 mode == EX_TYPE_CROSS)
5776 PlayLevelSoundElementAction(ex, ey, artwork_element, ACTION_EXPLODING);
5778 last_phase = element_info[explosion_element].explosion_delay + 1;
5780 for (y = ey - 1; y <= ey + 1; y++) for (x = ex - 1; x <= ex + 1; x++)
5782 int xx = x - ex + 1;
5783 int yy = y - ey + 1;
5786 if (!IN_LEV_FIELD(x, y) ||
5787 (mode & EX_TYPE_SINGLE_TILE && (x != ex || y != ey)) ||
5788 (mode == EX_TYPE_CROSS && (x != ex && y != ey)))
5791 element = Tile[x][y];
5793 if (IS_MOVING(x, y) || IS_BLOCKED(x, y))
5795 element = MovingOrBlocked2Element(x, y);
5797 if (!IS_EXPLOSION_PROOF(element))
5798 RemoveMovingField(x, y);
5801 // indestructible elements can only explode in center (but not flames)
5802 if ((IS_EXPLOSION_PROOF(element) && (x != ex || y != ey ||
5803 mode == EX_TYPE_BORDER)) ||
5804 element == EL_FLAMES)
5807 /* no idea why this was changed from 3.0.8 to 3.1.0 -- this causes buggy
5808 behaviour, for example when touching a yamyam that explodes to rocks
5809 with active deadly shield, a rock is created under the player !!! */
5810 // (case 1 (surely buggy): >= 3.1.0, case 2 (maybe buggy): <= 3.0.8)
5812 if (IS_PLAYER(x, y) && SHIELD_ON(PLAYERINFO(x, y)) &&
5813 (game.engine_version < VERSION_IDENT(3,1,0,0) ||
5814 (x == ex && y == ey && mode != EX_TYPE_BORDER)))
5816 if (IS_PLAYER(x, y) && SHIELD_ON(PLAYERINFO(x, y)))
5819 if (IS_ACTIVE_BOMB(element))
5821 // re-activate things under the bomb like gate or penguin
5822 Tile[x][y] = (Back[x][y] ? Back[x][y] : EL_EMPTY);
5829 // save walkable background elements while explosion on same tile
5830 if (IS_WALKABLE(element) && IS_INDESTRUCTIBLE(element) &&
5831 (x != ex || y != ey || mode == EX_TYPE_BORDER))
5832 Back[x][y] = element;
5834 // ignite explodable elements reached by other explosion
5835 if (element == EL_EXPLOSION)
5836 element = Store2[x][y];
5838 if (AmoebaNr[x][y] &&
5839 (element == EL_AMOEBA_FULL ||
5840 element == EL_BD_AMOEBA ||
5841 element == EL_AMOEBA_GROWING))
5843 AmoebaCnt[AmoebaNr[x][y]]--;
5844 AmoebaCnt2[AmoebaNr[x][y]]--;
5849 if (IS_PLAYER(ex, ey) && !PLAYER_EXPLOSION_PROTECTED(ex, ey))
5851 int player_nr = StorePlayer[ex][ey] - EL_PLAYER_1;
5853 Store[x][y] = EL_PLAYER_IS_EXPLODING_1 + player_nr;
5855 if (PLAYERINFO(ex, ey)->use_murphy)
5856 Store[x][y] = EL_EMPTY;
5859 // !!! check this case -- currently needed for rnd_rado_negundo_v,
5860 // !!! levels 015 018 019 020 021 022 023 026 027 028 !!!
5861 else if (IS_PLAYER_ELEMENT(center_element))
5862 Store[x][y] = EL_EMPTY;
5863 else if (center_element == EL_YAMYAM)
5864 Store[x][y] = level.yamyam_content[game.yamyam_content_nr].e[xx][yy];
5865 else if (element_info[center_element].content.e[xx][yy] != EL_EMPTY)
5866 Store[x][y] = element_info[center_element].content.e[xx][yy];
5868 // needed because EL_BD_BUTTERFLY is not defined as "CAN_EXPLODE"
5869 // (killing EL_BD_BUTTERFLY with dynamite would result in BD diamond
5870 // otherwise) -- FIX THIS !!!
5871 else if (!CAN_EXPLODE(element) && element != EL_BD_BUTTERFLY)
5872 Store[x][y] = element_info[element].content.e[1][1];
5874 else if (!CAN_EXPLODE(element))
5875 Store[x][y] = element_info[element].content.e[1][1];
5878 Store[x][y] = EL_EMPTY;
5880 if (x != ex || y != ey || mode == EX_TYPE_BORDER ||
5881 center_element == EL_AMOEBA_TO_DIAMOND)
5882 Store2[x][y] = element;
5884 Tile[x][y] = EL_EXPLOSION;
5885 GfxElement[x][y] = artwork_element;
5887 ExplodePhase[x][y] = 1;
5888 ExplodeDelay[x][y] = last_phase;
5893 if (center_element == EL_YAMYAM)
5894 game.yamyam_content_nr =
5895 (game.yamyam_content_nr + 1) % level.num_yamyam_contents;
5907 GfxFrame[x][y] = 0; // restart explosion animation
5909 last_phase = ExplodeDelay[x][y];
5911 ExplodePhase[x][y] = (phase < last_phase ? phase + 1 : 0);
5913 // this can happen if the player leaves an explosion just in time
5914 if (GfxElement[x][y] == EL_UNDEFINED)
5915 GfxElement[x][y] = EL_EMPTY;
5917 border_element = Store2[x][y];
5918 if (IS_PLAYER(x, y) && !PLAYER_EXPLOSION_PROTECTED(x, y))
5919 border_element = StorePlayer[x][y];
5921 if (phase == element_info[border_element].ignition_delay ||
5922 phase == last_phase)
5924 boolean border_explosion = FALSE;
5926 if (IS_PLAYER(x, y) && PLAYERINFO(x, y)->present &&
5927 !PLAYER_EXPLOSION_PROTECTED(x, y))
5929 KillPlayerUnlessExplosionProtected(x, y);
5930 border_explosion = TRUE;
5932 else if (CAN_EXPLODE_BY_EXPLOSION(border_element))
5934 Tile[x][y] = Store2[x][y];
5937 border_explosion = TRUE;
5939 else if (border_element == EL_AMOEBA_TO_DIAMOND)
5941 AmoebaToDiamond(x, y);
5943 border_explosion = TRUE;
5946 // if an element just explodes due to another explosion (chain-reaction),
5947 // do not immediately end the new explosion when it was the last frame of
5948 // the explosion (as it would be done in the following "if"-statement!)
5949 if (border_explosion && phase == last_phase)
5953 if (phase == last_phase)
5957 element = Tile[x][y] = Store[x][y];
5958 Store[x][y] = Store2[x][y] = 0;
5959 GfxElement[x][y] = EL_UNDEFINED;
5961 // player can escape from explosions and might therefore be still alive
5962 if (element >= EL_PLAYER_IS_EXPLODING_1 &&
5963 element <= EL_PLAYER_IS_EXPLODING_4)
5965 int player_nr = element - EL_PLAYER_IS_EXPLODING_1;
5966 int explosion_element = EL_PLAYER_1 + player_nr;
5967 int xx = MIN(MAX(0, x - stored_player[player_nr].jx + 1), 2);
5968 int yy = MIN(MAX(0, y - stored_player[player_nr].jy + 1), 2);
5970 if (level.use_explosion_element[player_nr])
5971 explosion_element = level.explosion_element[player_nr];
5973 Tile[x][y] = (stored_player[player_nr].active ? EL_EMPTY :
5974 element_info[explosion_element].content.e[xx][yy]);
5977 // restore probably existing indestructible background element
5978 if (Back[x][y] && IS_INDESTRUCTIBLE(Back[x][y]))
5979 element = Tile[x][y] = Back[x][y];
5982 MovDir[x][y] = MovPos[x][y] = MovDelay[x][y] = 0;
5983 GfxDir[x][y] = MV_NONE;
5984 ChangeDelay[x][y] = 0;
5985 ChangePage[x][y] = -1;
5987 CustomValue[x][y] = 0;
5989 InitField_WithBug2(x, y, FALSE);
5991 TEST_DrawLevelField(x, y);
5993 TestIfElementTouchesCustomElement(x, y);
5995 if (GFX_CRUMBLED(element))
5996 TEST_DrawLevelFieldCrumbledNeighbours(x, y);
5998 if (IS_PLAYER(x, y) && !PLAYERINFO(x, y)->present)
5999 StorePlayer[x][y] = 0;
6001 if (IS_PLAYER_ELEMENT(element))
6002 RelocatePlayer(x, y, element);
6004 else if (IN_SCR_FIELD(SCREENX(x), SCREENY(y)))
6006 int graphic = el_act2img(GfxElement[x][y], ACTION_EXPLODING);
6007 int frame = getGraphicAnimationFrame(graphic, GfxFrame[x][y]);
6010 TEST_DrawLevelFieldCrumbled(x, y);
6012 if (IS_WALKABLE_OVER(Back[x][y]) && Back[x][y] != EL_EMPTY)
6014 DrawLevelElement(x, y, Back[x][y]);
6015 DrawGraphicThruMask(SCREENX(x), SCREENY(y), graphic, frame);
6017 else if (IS_WALKABLE_UNDER(Back[x][y]))
6019 DrawGraphic(SCREENX(x), SCREENY(y), graphic, frame);
6020 DrawLevelElementThruMask(x, y, Back[x][y]);
6022 else if (!IS_WALKABLE_INSIDE(Back[x][y]))
6023 DrawScreenGraphic(SCREENX(x), SCREENY(y), graphic, frame);
6027 static void DynaExplode(int ex, int ey)
6030 int dynabomb_element = Tile[ex][ey];
6031 int dynabomb_size = 1;
6032 boolean dynabomb_xl = FALSE;
6033 struct PlayerInfo *player;
6034 static int xy[4][2] =
6042 if (IS_ACTIVE_BOMB(dynabomb_element))
6044 player = &stored_player[dynabomb_element - EL_DYNABOMB_PLAYER_1_ACTIVE];
6045 dynabomb_size = player->dynabomb_size;
6046 dynabomb_xl = player->dynabomb_xl;
6047 player->dynabombs_left++;
6050 Explode(ex, ey, EX_PHASE_START, EX_TYPE_CENTER);
6052 for (i = 0; i < NUM_DIRECTIONS; i++)
6054 for (j = 1; j <= dynabomb_size; j++)
6056 int x = ex + j * xy[i][0];
6057 int y = ey + j * xy[i][1];
6060 if (!IN_LEV_FIELD(x, y) || IS_INDESTRUCTIBLE(Tile[x][y]))
6063 element = Tile[x][y];
6065 // do not restart explosions of fields with active bombs
6066 if (element == EL_EXPLOSION && IS_ACTIVE_BOMB(Store2[x][y]))
6069 Explode(x, y, EX_PHASE_START, EX_TYPE_BORDER);
6071 if (element != EL_EMPTY && element != EL_EXPLOSION &&
6072 !IS_DIGGABLE(element) && !dynabomb_xl)
6078 void Bang(int x, int y)
6080 int element = MovingOrBlocked2Element(x, y);
6081 int explosion_type = EX_TYPE_NORMAL;
6083 if (IS_PLAYER(x, y) && !PLAYER_EXPLOSION_PROTECTED(x, y))
6085 struct PlayerInfo *player = PLAYERINFO(x, y);
6087 element = Tile[x][y] = player->initial_element;
6089 if (level.use_explosion_element[player->index_nr])
6091 int explosion_element = level.explosion_element[player->index_nr];
6093 if (element_info[explosion_element].explosion_type == EXPLODES_CROSS)
6094 explosion_type = EX_TYPE_CROSS;
6095 else if (element_info[explosion_element].explosion_type == EXPLODES_1X1)
6096 explosion_type = EX_TYPE_CENTER;
6104 case EL_BD_BUTTERFLY:
6107 case EL_DARK_YAMYAM:
6111 RaiseScoreElement(element);
6114 case EL_DYNABOMB_PLAYER_1_ACTIVE:
6115 case EL_DYNABOMB_PLAYER_2_ACTIVE:
6116 case EL_DYNABOMB_PLAYER_3_ACTIVE:
6117 case EL_DYNABOMB_PLAYER_4_ACTIVE:
6118 case EL_DYNABOMB_INCREASE_NUMBER:
6119 case EL_DYNABOMB_INCREASE_SIZE:
6120 case EL_DYNABOMB_INCREASE_POWER:
6121 explosion_type = EX_TYPE_DYNA;
6124 case EL_DC_LANDMINE:
6125 explosion_type = EX_TYPE_CENTER;
6130 case EL_LAMP_ACTIVE:
6131 case EL_AMOEBA_TO_DIAMOND:
6132 if (!IS_PLAYER(x, y)) // penguin and player may be at same field
6133 explosion_type = EX_TYPE_CENTER;
6137 if (element_info[element].explosion_type == EXPLODES_CROSS)
6138 explosion_type = EX_TYPE_CROSS;
6139 else if (element_info[element].explosion_type == EXPLODES_1X1)
6140 explosion_type = EX_TYPE_CENTER;
6144 if (explosion_type == EX_TYPE_DYNA)
6147 Explode(x, y, EX_PHASE_START, explosion_type);
6149 CheckTriggeredElementChange(x, y, element, CE_EXPLOSION_OF_X);
6152 static void SplashAcid(int x, int y)
6154 if (IN_LEV_FIELD(x - 1, y - 1) && IS_FREE(x - 1, y - 1) &&
6155 (!IN_LEV_FIELD(x - 1, y - 2) ||
6156 !CAN_FALL(MovingOrBlocked2Element(x - 1, y - 2))))
6157 Tile[x - 1][y - 1] = EL_ACID_SPLASH_LEFT;
6159 if (IN_LEV_FIELD(x + 1, y - 1) && IS_FREE(x + 1, y - 1) &&
6160 (!IN_LEV_FIELD(x + 1, y - 2) ||
6161 !CAN_FALL(MovingOrBlocked2Element(x + 1, y - 2))))
6162 Tile[x + 1][y - 1] = EL_ACID_SPLASH_RIGHT;
6164 PlayLevelSound(x, y, SND_ACID_SPLASHING);
6167 static void InitBeltMovement(void)
6169 static int belt_base_element[4] =
6171 EL_CONVEYOR_BELT_1_LEFT,
6172 EL_CONVEYOR_BELT_2_LEFT,
6173 EL_CONVEYOR_BELT_3_LEFT,
6174 EL_CONVEYOR_BELT_4_LEFT
6176 static int belt_base_active_element[4] =
6178 EL_CONVEYOR_BELT_1_LEFT_ACTIVE,
6179 EL_CONVEYOR_BELT_2_LEFT_ACTIVE,
6180 EL_CONVEYOR_BELT_3_LEFT_ACTIVE,
6181 EL_CONVEYOR_BELT_4_LEFT_ACTIVE
6186 // set frame order for belt animation graphic according to belt direction
6187 for (i = 0; i < NUM_BELTS; i++)
6191 for (j = 0; j < NUM_BELT_PARTS; j++)
6193 int element = belt_base_active_element[belt_nr] + j;
6194 int graphic_1 = el2img(element);
6195 int graphic_2 = el2panelimg(element);
6197 if (game.belt_dir[i] == MV_LEFT)
6199 graphic_info[graphic_1].anim_mode &= ~ANIM_REVERSE;
6200 graphic_info[graphic_2].anim_mode &= ~ANIM_REVERSE;
6204 graphic_info[graphic_1].anim_mode |= ANIM_REVERSE;
6205 graphic_info[graphic_2].anim_mode |= ANIM_REVERSE;
6210 SCAN_PLAYFIELD(x, y)
6212 int element = Tile[x][y];
6214 for (i = 0; i < NUM_BELTS; i++)
6216 if (IS_BELT(element) && game.belt_dir[i] != MV_NONE)
6218 int e_belt_nr = getBeltNrFromBeltElement(element);
6221 if (e_belt_nr == belt_nr)
6223 int belt_part = Tile[x][y] - belt_base_element[belt_nr];
6225 Tile[x][y] = belt_base_active_element[belt_nr] + belt_part;
6232 static void ToggleBeltSwitch(int x, int y)
6234 static int belt_base_element[4] =
6236 EL_CONVEYOR_BELT_1_LEFT,
6237 EL_CONVEYOR_BELT_2_LEFT,
6238 EL_CONVEYOR_BELT_3_LEFT,
6239 EL_CONVEYOR_BELT_4_LEFT
6241 static int belt_base_active_element[4] =
6243 EL_CONVEYOR_BELT_1_LEFT_ACTIVE,
6244 EL_CONVEYOR_BELT_2_LEFT_ACTIVE,
6245 EL_CONVEYOR_BELT_3_LEFT_ACTIVE,
6246 EL_CONVEYOR_BELT_4_LEFT_ACTIVE
6248 static int belt_base_switch_element[4] =
6250 EL_CONVEYOR_BELT_1_SWITCH_LEFT,
6251 EL_CONVEYOR_BELT_2_SWITCH_LEFT,
6252 EL_CONVEYOR_BELT_3_SWITCH_LEFT,
6253 EL_CONVEYOR_BELT_4_SWITCH_LEFT
6255 static int belt_move_dir[4] =
6263 int element = Tile[x][y];
6264 int belt_nr = getBeltNrFromBeltSwitchElement(element);
6265 int belt_dir_nr = (game.belt_dir_nr[belt_nr] + 1) % 4;
6266 int belt_dir = belt_move_dir[belt_dir_nr];
6269 if (!IS_BELT_SWITCH(element))
6272 game.belt_dir_nr[belt_nr] = belt_dir_nr;
6273 game.belt_dir[belt_nr] = belt_dir;
6275 if (belt_dir_nr == 3)
6278 // set frame order for belt animation graphic according to belt direction
6279 for (i = 0; i < NUM_BELT_PARTS; i++)
6281 int element = belt_base_active_element[belt_nr] + i;
6282 int graphic_1 = el2img(element);
6283 int graphic_2 = el2panelimg(element);
6285 if (belt_dir == MV_LEFT)
6287 graphic_info[graphic_1].anim_mode &= ~ANIM_REVERSE;
6288 graphic_info[graphic_2].anim_mode &= ~ANIM_REVERSE;
6292 graphic_info[graphic_1].anim_mode |= ANIM_REVERSE;
6293 graphic_info[graphic_2].anim_mode |= ANIM_REVERSE;
6297 SCAN_PLAYFIELD(xx, yy)
6299 int element = Tile[xx][yy];
6301 if (IS_BELT_SWITCH(element))
6303 int e_belt_nr = getBeltNrFromBeltSwitchElement(element);
6305 if (e_belt_nr == belt_nr)
6307 Tile[xx][yy] = belt_base_switch_element[belt_nr] + belt_dir_nr;
6308 TEST_DrawLevelField(xx, yy);
6311 else if (IS_BELT(element) && belt_dir != MV_NONE)
6313 int e_belt_nr = getBeltNrFromBeltElement(element);
6315 if (e_belt_nr == belt_nr)
6317 int belt_part = Tile[xx][yy] - belt_base_element[belt_nr];
6319 Tile[xx][yy] = belt_base_active_element[belt_nr] + belt_part;
6320 TEST_DrawLevelField(xx, yy);
6323 else if (IS_BELT_ACTIVE(element) && belt_dir == MV_NONE)
6325 int e_belt_nr = getBeltNrFromBeltActiveElement(element);
6327 if (e_belt_nr == belt_nr)
6329 int belt_part = Tile[xx][yy] - belt_base_active_element[belt_nr];
6331 Tile[xx][yy] = belt_base_element[belt_nr] + belt_part;
6332 TEST_DrawLevelField(xx, yy);
6338 static void ToggleSwitchgateSwitch(int x, int y)
6342 game.switchgate_pos = !game.switchgate_pos;
6344 SCAN_PLAYFIELD(xx, yy)
6346 int element = Tile[xx][yy];
6348 if (element == EL_SWITCHGATE_SWITCH_UP)
6350 Tile[xx][yy] = EL_SWITCHGATE_SWITCH_DOWN;
6351 TEST_DrawLevelField(xx, yy);
6353 else if (element == EL_SWITCHGATE_SWITCH_DOWN)
6355 Tile[xx][yy] = EL_SWITCHGATE_SWITCH_UP;
6356 TEST_DrawLevelField(xx, yy);
6358 else if (element == EL_DC_SWITCHGATE_SWITCH_UP)
6360 Tile[xx][yy] = EL_DC_SWITCHGATE_SWITCH_DOWN;
6361 TEST_DrawLevelField(xx, yy);
6363 else if (element == EL_DC_SWITCHGATE_SWITCH_DOWN)
6365 Tile[xx][yy] = EL_DC_SWITCHGATE_SWITCH_UP;
6366 TEST_DrawLevelField(xx, yy);
6368 else if (element == EL_SWITCHGATE_OPEN ||
6369 element == EL_SWITCHGATE_OPENING)
6371 Tile[xx][yy] = EL_SWITCHGATE_CLOSING;
6373 PlayLevelSoundAction(xx, yy, ACTION_CLOSING);
6375 else if (element == EL_SWITCHGATE_CLOSED ||
6376 element == EL_SWITCHGATE_CLOSING)
6378 Tile[xx][yy] = EL_SWITCHGATE_OPENING;
6380 PlayLevelSoundAction(xx, yy, ACTION_OPENING);
6385 static int getInvisibleActiveFromInvisibleElement(int element)
6387 return (element == EL_INVISIBLE_STEELWALL ? EL_INVISIBLE_STEELWALL_ACTIVE :
6388 element == EL_INVISIBLE_WALL ? EL_INVISIBLE_WALL_ACTIVE :
6389 element == EL_INVISIBLE_SAND ? EL_INVISIBLE_SAND_ACTIVE :
6393 static int getInvisibleFromInvisibleActiveElement(int element)
6395 return (element == EL_INVISIBLE_STEELWALL_ACTIVE ? EL_INVISIBLE_STEELWALL :
6396 element == EL_INVISIBLE_WALL_ACTIVE ? EL_INVISIBLE_WALL :
6397 element == EL_INVISIBLE_SAND_ACTIVE ? EL_INVISIBLE_SAND :
6401 static void RedrawAllLightSwitchesAndInvisibleElements(void)
6405 SCAN_PLAYFIELD(x, y)
6407 int element = Tile[x][y];
6409 if (element == EL_LIGHT_SWITCH &&
6410 game.light_time_left > 0)
6412 Tile[x][y] = EL_LIGHT_SWITCH_ACTIVE;
6413 TEST_DrawLevelField(x, y);
6415 else if (element == EL_LIGHT_SWITCH_ACTIVE &&
6416 game.light_time_left == 0)
6418 Tile[x][y] = EL_LIGHT_SWITCH;
6419 TEST_DrawLevelField(x, y);
6421 else if (element == EL_EMC_DRIPPER &&
6422 game.light_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.light_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.light_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.light_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 RedrawAllInvisibleElementsForLenses(void)
6466 SCAN_PLAYFIELD(x, y)
6468 int element = Tile[x][y];
6470 if (element == EL_EMC_DRIPPER &&
6471 game.lenses_time_left > 0)
6473 Tile[x][y] = EL_EMC_DRIPPER_ACTIVE;
6474 TEST_DrawLevelField(x, y);
6476 else if (element == EL_EMC_DRIPPER_ACTIVE &&
6477 game.lenses_time_left == 0)
6479 Tile[x][y] = EL_EMC_DRIPPER;
6480 TEST_DrawLevelField(x, y);
6482 else if (element == EL_INVISIBLE_STEELWALL ||
6483 element == EL_INVISIBLE_WALL ||
6484 element == EL_INVISIBLE_SAND)
6486 if (game.lenses_time_left > 0)
6487 Tile[x][y] = getInvisibleActiveFromInvisibleElement(element);
6489 TEST_DrawLevelField(x, y);
6491 // uncrumble neighbour fields, if needed
6492 if (element == EL_INVISIBLE_SAND)
6493 TEST_DrawLevelFieldCrumbledNeighbours(x, y);
6495 else if (element == EL_INVISIBLE_STEELWALL_ACTIVE ||
6496 element == EL_INVISIBLE_WALL_ACTIVE ||
6497 element == EL_INVISIBLE_SAND_ACTIVE)
6499 if (game.lenses_time_left == 0)
6500 Tile[x][y] = getInvisibleFromInvisibleActiveElement(element);
6502 TEST_DrawLevelField(x, y);
6504 // re-crumble neighbour fields, if needed
6505 if (element == EL_INVISIBLE_SAND)
6506 TEST_DrawLevelFieldCrumbledNeighbours(x, y);
6511 static void RedrawAllInvisibleElementsForMagnifier(void)
6515 SCAN_PLAYFIELD(x, y)
6517 int element = Tile[x][y];
6519 if (element == EL_EMC_FAKE_GRASS &&
6520 game.magnify_time_left > 0)
6522 Tile[x][y] = EL_EMC_FAKE_GRASS_ACTIVE;
6523 TEST_DrawLevelField(x, y);
6525 else if (element == EL_EMC_FAKE_GRASS_ACTIVE &&
6526 game.magnify_time_left == 0)
6528 Tile[x][y] = EL_EMC_FAKE_GRASS;
6529 TEST_DrawLevelField(x, y);
6531 else if (IS_GATE_GRAY(element) &&
6532 game.magnify_time_left > 0)
6534 Tile[x][y] = (IS_RND_GATE_GRAY(element) ?
6535 element - EL_GATE_1_GRAY + EL_GATE_1_GRAY_ACTIVE :
6536 IS_EM_GATE_GRAY(element) ?
6537 element - EL_EM_GATE_1_GRAY + EL_EM_GATE_1_GRAY_ACTIVE :
6538 IS_EMC_GATE_GRAY(element) ?
6539 element - EL_EMC_GATE_5_GRAY + EL_EMC_GATE_5_GRAY_ACTIVE :
6540 IS_DC_GATE_GRAY(element) ?
6541 EL_DC_GATE_WHITE_GRAY_ACTIVE :
6543 TEST_DrawLevelField(x, y);
6545 else if (IS_GATE_GRAY_ACTIVE(element) &&
6546 game.magnify_time_left == 0)
6548 Tile[x][y] = (IS_RND_GATE_GRAY_ACTIVE(element) ?
6549 element - EL_GATE_1_GRAY_ACTIVE + EL_GATE_1_GRAY :
6550 IS_EM_GATE_GRAY_ACTIVE(element) ?
6551 element - EL_EM_GATE_1_GRAY_ACTIVE + EL_EM_GATE_1_GRAY :
6552 IS_EMC_GATE_GRAY_ACTIVE(element) ?
6553 element - EL_EMC_GATE_5_GRAY_ACTIVE + EL_EMC_GATE_5_GRAY :
6554 IS_DC_GATE_GRAY_ACTIVE(element) ?
6555 EL_DC_GATE_WHITE_GRAY :
6557 TEST_DrawLevelField(x, y);
6562 static void ToggleLightSwitch(int x, int y)
6564 int element = Tile[x][y];
6566 game.light_time_left =
6567 (element == EL_LIGHT_SWITCH ?
6568 level.time_light * FRAMES_PER_SECOND : 0);
6570 RedrawAllLightSwitchesAndInvisibleElements();
6573 static void ActivateTimegateSwitch(int x, int y)
6577 game.timegate_time_left = level.time_timegate * FRAMES_PER_SECOND;
6579 SCAN_PLAYFIELD(xx, yy)
6581 int element = Tile[xx][yy];
6583 if (element == EL_TIMEGATE_CLOSED ||
6584 element == EL_TIMEGATE_CLOSING)
6586 Tile[xx][yy] = EL_TIMEGATE_OPENING;
6587 PlayLevelSound(xx, yy, SND_CLASS_TIMEGATE_OPENING);
6591 else if (element == EL_TIMEGATE_SWITCH_ACTIVE)
6593 Tile[xx][yy] = EL_TIMEGATE_SWITCH;
6594 TEST_DrawLevelField(xx, yy);
6600 Tile[x][y] = (Tile[x][y] == EL_TIMEGATE_SWITCH ? EL_TIMEGATE_SWITCH_ACTIVE :
6601 EL_DC_TIMEGATE_SWITCH_ACTIVE);
6604 static void Impact(int x, int y)
6606 boolean last_line = (y == lev_fieldy - 1);
6607 boolean object_hit = FALSE;
6608 boolean impact = (last_line || object_hit);
6609 int element = Tile[x][y];
6610 int smashed = EL_STEELWALL;
6612 if (!last_line) // check if element below was hit
6614 if (Tile[x][y + 1] == EL_PLAYER_IS_LEAVING)
6617 object_hit = (!IS_FREE(x, y + 1) && (!IS_MOVING(x, y + 1) ||
6618 MovDir[x][y + 1] != MV_DOWN ||
6619 MovPos[x][y + 1] <= TILEY / 2));
6621 // do not smash moving elements that left the smashed field in time
6622 if (game.engine_version >= VERSION_IDENT(2,2,0,7) && IS_MOVING(x, y + 1) &&
6623 ABS(MovPos[x][y + 1] + getElementMoveStepsize(x, y + 1)) >= TILEX)
6626 #if USE_QUICKSAND_IMPACT_BUGFIX
6627 if (Tile[x][y + 1] == EL_QUICKSAND_EMPTYING && object_hit == FALSE)
6629 RemoveMovingField(x, y + 1);
6630 Tile[x][y + 1] = EL_QUICKSAND_EMPTY;
6631 Tile[x][y + 2] = EL_ROCK;
6632 TEST_DrawLevelField(x, y + 2);
6637 if (Tile[x][y + 1] == EL_QUICKSAND_FAST_EMPTYING && object_hit == FALSE)
6639 RemoveMovingField(x, y + 1);
6640 Tile[x][y + 1] = EL_QUICKSAND_FAST_EMPTY;
6641 Tile[x][y + 2] = EL_ROCK;
6642 TEST_DrawLevelField(x, y + 2);
6649 smashed = MovingOrBlocked2Element(x, y + 1);
6651 impact = (last_line || object_hit);
6654 if (!last_line && smashed == EL_ACID) // element falls into acid
6656 SplashAcid(x, y + 1);
6660 // !!! not sufficient for all cases -- see EL_PEARL below !!!
6661 // only reset graphic animation if graphic really changes after impact
6663 el_act_dir2img(element, GfxAction[x][y], MV_DOWN) != el2img(element))
6665 ResetGfxAnimation(x, y);
6666 TEST_DrawLevelField(x, y);
6669 if (impact && CAN_EXPLODE_IMPACT(element))
6674 else if (impact && element == EL_PEARL &&
6675 smashed != EL_DC_MAGIC_WALL && smashed != EL_DC_MAGIC_WALL_ACTIVE)
6677 ResetGfxAnimation(x, y);
6679 Tile[x][y] = EL_PEARL_BREAKING;
6680 PlayLevelSound(x, y, SND_PEARL_BREAKING);
6683 else if (impact && CheckElementChange(x, y, element, smashed, CE_IMPACT))
6685 PlayLevelSoundElementAction(x, y, element, ACTION_IMPACT);
6690 if (impact && element == EL_AMOEBA_DROP)
6692 if (object_hit && IS_PLAYER(x, y + 1))
6693 KillPlayerUnlessEnemyProtected(x, y + 1);
6694 else if (object_hit && smashed == EL_PENGUIN)
6698 Tile[x][y] = EL_AMOEBA_GROWING;
6699 Store[x][y] = EL_AMOEBA_WET;
6701 ResetRandomAnimationValue(x, y);
6706 if (object_hit) // check which object was hit
6708 if ((CAN_PASS_MAGIC_WALL(element) &&
6709 (smashed == EL_MAGIC_WALL ||
6710 smashed == EL_BD_MAGIC_WALL)) ||
6711 (CAN_PASS_DC_MAGIC_WALL(element) &&
6712 smashed == EL_DC_MAGIC_WALL))
6715 int activated_magic_wall =
6716 (smashed == EL_MAGIC_WALL ? EL_MAGIC_WALL_ACTIVE :
6717 smashed == EL_BD_MAGIC_WALL ? EL_BD_MAGIC_WALL_ACTIVE :
6718 EL_DC_MAGIC_WALL_ACTIVE);
6720 // activate magic wall / mill
6721 SCAN_PLAYFIELD(xx, yy)
6723 if (Tile[xx][yy] == smashed)
6724 Tile[xx][yy] = activated_magic_wall;
6727 game.magic_wall_time_left = level.time_magic_wall * FRAMES_PER_SECOND;
6728 game.magic_wall_active = TRUE;
6730 PlayLevelSound(x, y, (smashed == EL_MAGIC_WALL ?
6731 SND_MAGIC_WALL_ACTIVATING :
6732 smashed == EL_BD_MAGIC_WALL ?
6733 SND_BD_MAGIC_WALL_ACTIVATING :
6734 SND_DC_MAGIC_WALL_ACTIVATING));
6737 if (IS_PLAYER(x, y + 1))
6739 if (CAN_SMASH_PLAYER(element))
6741 KillPlayerUnlessEnemyProtected(x, y + 1);
6745 else if (smashed == EL_PENGUIN)
6747 if (CAN_SMASH_PLAYER(element))
6753 else if (element == EL_BD_DIAMOND)
6755 if (IS_CLASSIC_ENEMY(smashed) && IS_BD_ELEMENT(smashed))
6761 else if (((element == EL_SP_INFOTRON ||
6762 element == EL_SP_ZONK) &&
6763 (smashed == EL_SP_SNIKSNAK ||
6764 smashed == EL_SP_ELECTRON ||
6765 smashed == EL_SP_DISK_ORANGE)) ||
6766 (element == EL_SP_INFOTRON &&
6767 smashed == EL_SP_DISK_YELLOW))
6772 else if (CAN_SMASH_EVERYTHING(element))
6774 if (IS_CLASSIC_ENEMY(smashed) ||
6775 CAN_EXPLODE_SMASHED(smashed))
6780 else if (!IS_MOVING(x, y + 1) && !IS_BLOCKED(x, y + 1))
6782 if (smashed == EL_LAMP ||
6783 smashed == EL_LAMP_ACTIVE)
6788 else if (smashed == EL_NUT)
6790 Tile[x][y + 1] = EL_NUT_BREAKING;
6791 PlayLevelSound(x, y, SND_NUT_BREAKING);
6792 RaiseScoreElement(EL_NUT);
6795 else if (smashed == EL_PEARL)
6797 ResetGfxAnimation(x, y);
6799 Tile[x][y + 1] = EL_PEARL_BREAKING;
6800 PlayLevelSound(x, y, SND_PEARL_BREAKING);
6803 else if (smashed == EL_DIAMOND)
6805 Tile[x][y + 1] = EL_DIAMOND_BREAKING;
6806 PlayLevelSound(x, y, SND_DIAMOND_BREAKING);
6809 else if (IS_BELT_SWITCH(smashed))
6811 ToggleBeltSwitch(x, y + 1);
6813 else if (smashed == EL_SWITCHGATE_SWITCH_UP ||
6814 smashed == EL_SWITCHGATE_SWITCH_DOWN ||
6815 smashed == EL_DC_SWITCHGATE_SWITCH_UP ||
6816 smashed == EL_DC_SWITCHGATE_SWITCH_DOWN)
6818 ToggleSwitchgateSwitch(x, y + 1);
6820 else if (smashed == EL_LIGHT_SWITCH ||
6821 smashed == EL_LIGHT_SWITCH_ACTIVE)
6823 ToggleLightSwitch(x, y + 1);
6827 CheckElementChange(x, y + 1, smashed, element, CE_SMASHED);
6829 CheckElementChangeBySide(x, y + 1, smashed, element,
6830 CE_SWITCHED, CH_SIDE_TOP);
6831 CheckTriggeredElementChangeBySide(x, y + 1, smashed, CE_SWITCH_OF_X,
6837 CheckElementChange(x, y + 1, smashed, element, CE_SMASHED);
6842 // play sound of magic wall / mill
6844 (Tile[x][y + 1] == EL_MAGIC_WALL_ACTIVE ||
6845 Tile[x][y + 1] == EL_BD_MAGIC_WALL_ACTIVE ||
6846 Tile[x][y + 1] == EL_DC_MAGIC_WALL_ACTIVE))
6848 if (Tile[x][y + 1] == EL_MAGIC_WALL_ACTIVE)
6849 PlayLevelSound(x, y, SND_MAGIC_WALL_FILLING);
6850 else if (Tile[x][y + 1] == EL_BD_MAGIC_WALL_ACTIVE)
6851 PlayLevelSound(x, y, SND_BD_MAGIC_WALL_FILLING);
6852 else if (Tile[x][y + 1] == EL_DC_MAGIC_WALL_ACTIVE)
6853 PlayLevelSound(x, y, SND_DC_MAGIC_WALL_FILLING);
6858 // play sound of object that hits the ground
6859 if (last_line || object_hit)
6860 PlayLevelSoundElementAction(x, y, element, ACTION_IMPACT);
6863 static void TurnRoundExt(int x, int y)
6875 { 0, 0 }, { 0, 0 }, { 0, 0 },
6880 int left, right, back;
6884 { MV_DOWN, MV_UP, MV_RIGHT },
6885 { MV_UP, MV_DOWN, MV_LEFT },
6887 { MV_LEFT, MV_RIGHT, MV_DOWN },
6891 { MV_RIGHT, MV_LEFT, MV_UP }
6894 int element = Tile[x][y];
6895 int move_pattern = element_info[element].move_pattern;
6897 int old_move_dir = MovDir[x][y];
6898 int left_dir = turn[old_move_dir].left;
6899 int right_dir = turn[old_move_dir].right;
6900 int back_dir = turn[old_move_dir].back;
6902 int left_dx = move_xy[left_dir].dx, left_dy = move_xy[left_dir].dy;
6903 int right_dx = move_xy[right_dir].dx, right_dy = move_xy[right_dir].dy;
6904 int move_dx = move_xy[old_move_dir].dx, move_dy = move_xy[old_move_dir].dy;
6905 int back_dx = move_xy[back_dir].dx, back_dy = move_xy[back_dir].dy;
6907 int left_x = x + left_dx, left_y = y + left_dy;
6908 int right_x = x + right_dx, right_y = y + right_dy;
6909 int move_x = x + move_dx, move_y = y + move_dy;
6913 if (element == EL_BUG || element == EL_BD_BUTTERFLY)
6915 TestIfBadThingTouchesOtherBadThing(x, y);
6917 if (ENEMY_CAN_ENTER_FIELD(element, right_x, right_y))
6918 MovDir[x][y] = right_dir;
6919 else if (!ENEMY_CAN_ENTER_FIELD(element, move_x, move_y))
6920 MovDir[x][y] = left_dir;
6922 if (element == EL_BUG && MovDir[x][y] != old_move_dir)
6924 else if (element == EL_BD_BUTTERFLY) // && MovDir[x][y] == left_dir)
6927 else if (element == EL_SPACESHIP || element == EL_BD_FIREFLY)
6929 TestIfBadThingTouchesOtherBadThing(x, y);
6931 if (ENEMY_CAN_ENTER_FIELD(element, left_x, left_y))
6932 MovDir[x][y] = left_dir;
6933 else if (!ENEMY_CAN_ENTER_FIELD(element, move_x, move_y))
6934 MovDir[x][y] = right_dir;
6936 if (element == EL_SPACESHIP && MovDir[x][y] != old_move_dir)
6938 else if (element == EL_BD_FIREFLY) // && MovDir[x][y] == right_dir)
6941 else if (element == EL_SP_SNIKSNAK || element == EL_SP_ELECTRON)
6943 TestIfBadThingTouchesOtherBadThing(x, y);
6945 if (ELEMENT_CAN_ENTER_FIELD_BASE_4(element, left_x, left_y, 0))
6946 MovDir[x][y] = left_dir;
6947 else if (!ELEMENT_CAN_ENTER_FIELD_BASE_4(element, move_x, move_y, 0))
6948 MovDir[x][y] = right_dir;
6950 if (MovDir[x][y] != old_move_dir)
6953 else if (element == EL_YAMYAM)
6955 boolean can_turn_left = YAMYAM_CAN_ENTER_FIELD(element, left_x, left_y);
6956 boolean can_turn_right = YAMYAM_CAN_ENTER_FIELD(element, right_x, right_y);
6958 if (can_turn_left && can_turn_right)
6959 MovDir[x][y] = (RND(3) ? (RND(2) ? left_dir : right_dir) : back_dir);
6960 else if (can_turn_left)
6961 MovDir[x][y] = (RND(2) ? left_dir : back_dir);
6962 else if (can_turn_right)
6963 MovDir[x][y] = (RND(2) ? right_dir : back_dir);
6965 MovDir[x][y] = back_dir;
6967 MovDelay[x][y] = 16 + 16 * RND(3);
6969 else if (element == EL_DARK_YAMYAM)
6971 boolean can_turn_left = DARK_YAMYAM_CAN_ENTER_FIELD(element,
6973 boolean can_turn_right = DARK_YAMYAM_CAN_ENTER_FIELD(element,
6976 if (can_turn_left && can_turn_right)
6977 MovDir[x][y] = (RND(3) ? (RND(2) ? left_dir : right_dir) : back_dir);
6978 else if (can_turn_left)
6979 MovDir[x][y] = (RND(2) ? left_dir : back_dir);
6980 else if (can_turn_right)
6981 MovDir[x][y] = (RND(2) ? right_dir : back_dir);
6983 MovDir[x][y] = back_dir;
6985 MovDelay[x][y] = 16 + 16 * RND(3);
6987 else if (element == EL_PACMAN)
6989 boolean can_turn_left = PACMAN_CAN_ENTER_FIELD(element, left_x, left_y);
6990 boolean can_turn_right = PACMAN_CAN_ENTER_FIELD(element, right_x, right_y);
6992 if (can_turn_left && can_turn_right)
6993 MovDir[x][y] = (RND(3) ? (RND(2) ? left_dir : right_dir) : back_dir);
6994 else if (can_turn_left)
6995 MovDir[x][y] = (RND(2) ? left_dir : back_dir);
6996 else if (can_turn_right)
6997 MovDir[x][y] = (RND(2) ? right_dir : back_dir);
6999 MovDir[x][y] = back_dir;
7001 MovDelay[x][y] = 6 + RND(40);
7003 else if (element == EL_PIG)
7005 boolean can_turn_left = PIG_CAN_ENTER_FIELD(element, left_x, left_y);
7006 boolean can_turn_right = PIG_CAN_ENTER_FIELD(element, right_x, right_y);
7007 boolean can_move_on = PIG_CAN_ENTER_FIELD(element, move_x, move_y);
7008 boolean should_turn_left, should_turn_right, should_move_on;
7010 int rnd = RND(rnd_value);
7012 should_turn_left = (can_turn_left &&
7014 IN_LEV_FIELD_AND_NOT_FREE(x + back_dx + left_dx,
7015 y + back_dy + left_dy)));
7016 should_turn_right = (can_turn_right &&
7018 IN_LEV_FIELD_AND_NOT_FREE(x + back_dx + right_dx,
7019 y + back_dy + right_dy)));
7020 should_move_on = (can_move_on &&
7023 IN_LEV_FIELD_AND_NOT_FREE(x + move_dx + left_dx,
7024 y + move_dy + left_dy) ||
7025 IN_LEV_FIELD_AND_NOT_FREE(x + move_dx + right_dx,
7026 y + move_dy + right_dy)));
7028 if (should_turn_left || should_turn_right || should_move_on)
7030 if (should_turn_left && should_turn_right && should_move_on)
7031 MovDir[x][y] = (rnd < rnd_value / 3 ? left_dir :
7032 rnd < 2 * rnd_value / 3 ? right_dir :
7034 else if (should_turn_left && should_turn_right)
7035 MovDir[x][y] = (rnd < rnd_value / 2 ? left_dir : right_dir);
7036 else if (should_turn_left && should_move_on)
7037 MovDir[x][y] = (rnd < rnd_value / 2 ? left_dir : old_move_dir);
7038 else if (should_turn_right && should_move_on)
7039 MovDir[x][y] = (rnd < rnd_value / 2 ? right_dir : old_move_dir);
7040 else if (should_turn_left)
7041 MovDir[x][y] = left_dir;
7042 else if (should_turn_right)
7043 MovDir[x][y] = right_dir;
7044 else if (should_move_on)
7045 MovDir[x][y] = old_move_dir;
7047 else if (can_move_on && rnd > rnd_value / 8)
7048 MovDir[x][y] = old_move_dir;
7049 else if (can_turn_left && can_turn_right)
7050 MovDir[x][y] = (rnd < rnd_value / 2 ? left_dir : right_dir);
7051 else if (can_turn_left && rnd > rnd_value / 8)
7052 MovDir[x][y] = left_dir;
7053 else if (can_turn_right && rnd > rnd_value/8)
7054 MovDir[x][y] = right_dir;
7056 MovDir[x][y] = back_dir;
7058 xx = x + move_xy[MovDir[x][y]].dx;
7059 yy = y + move_xy[MovDir[x][y]].dy;
7061 if (!IN_LEV_FIELD(xx, yy) ||
7062 (!IS_FREE(xx, yy) && !IS_FOOD_PIG(Tile[xx][yy])))
7063 MovDir[x][y] = old_move_dir;
7067 else if (element == EL_DRAGON)
7069 boolean can_turn_left = DRAGON_CAN_ENTER_FIELD(element, left_x, left_y);
7070 boolean can_turn_right = DRAGON_CAN_ENTER_FIELD(element, right_x, right_y);
7071 boolean can_move_on = DRAGON_CAN_ENTER_FIELD(element, move_x, move_y);
7073 int rnd = RND(rnd_value);
7075 if (can_move_on && rnd > rnd_value / 8)
7076 MovDir[x][y] = old_move_dir;
7077 else if (can_turn_left && can_turn_right)
7078 MovDir[x][y] = (rnd < rnd_value / 2 ? left_dir : right_dir);
7079 else if (can_turn_left && rnd > rnd_value / 8)
7080 MovDir[x][y] = left_dir;
7081 else if (can_turn_right && rnd > rnd_value / 8)
7082 MovDir[x][y] = right_dir;
7084 MovDir[x][y] = back_dir;
7086 xx = x + move_xy[MovDir[x][y]].dx;
7087 yy = y + move_xy[MovDir[x][y]].dy;
7089 if (!IN_LEV_FIELD_AND_IS_FREE(xx, yy))
7090 MovDir[x][y] = old_move_dir;
7094 else if (element == EL_MOLE)
7096 boolean can_move_on =
7097 (MOLE_CAN_ENTER_FIELD(element, move_x, move_y,
7098 IS_AMOEBOID(Tile[move_x][move_y]) ||
7099 Tile[move_x][move_y] == EL_AMOEBA_SHRINKING));
7102 boolean can_turn_left =
7103 (MOLE_CAN_ENTER_FIELD(element, left_x, left_y,
7104 IS_AMOEBOID(Tile[left_x][left_y])));
7106 boolean can_turn_right =
7107 (MOLE_CAN_ENTER_FIELD(element, right_x, right_y,
7108 IS_AMOEBOID(Tile[right_x][right_y])));
7110 if (can_turn_left && can_turn_right)
7111 MovDir[x][y] = (RND(2) ? left_dir : right_dir);
7112 else if (can_turn_left)
7113 MovDir[x][y] = left_dir;
7115 MovDir[x][y] = right_dir;
7118 if (MovDir[x][y] != old_move_dir)
7121 else if (element == EL_BALLOON)
7123 MovDir[x][y] = game.wind_direction;
7126 else if (element == EL_SPRING)
7128 if (MovDir[x][y] & MV_HORIZONTAL)
7130 if (SPRING_CAN_BUMP_FROM_FIELD(move_x, move_y) &&
7131 !SPRING_CAN_ENTER_FIELD(element, x, y + 1))
7133 Tile[move_x][move_y] = EL_EMC_SPRING_BUMPER_ACTIVE;
7134 ResetGfxAnimation(move_x, move_y);
7135 TEST_DrawLevelField(move_x, move_y);
7137 MovDir[x][y] = back_dir;
7139 else if (!SPRING_CAN_ENTER_FIELD(element, move_x, move_y) ||
7140 SPRING_CAN_ENTER_FIELD(element, x, y + 1))
7141 MovDir[x][y] = MV_NONE;
7146 else if (element == EL_ROBOT ||
7147 element == EL_SATELLITE ||
7148 element == EL_PENGUIN ||
7149 element == EL_EMC_ANDROID)
7151 int attr_x = -1, attr_y = -1;
7153 if (game.all_players_gone)
7155 attr_x = game.exit_x;
7156 attr_y = game.exit_y;
7162 for (i = 0; i < MAX_PLAYERS; i++)
7164 struct PlayerInfo *player = &stored_player[i];
7165 int jx = player->jx, jy = player->jy;
7167 if (!player->active)
7171 ABS(jx - x) + ABS(jy - y) < ABS(attr_x - x) + ABS(attr_y - y))
7179 if (element == EL_ROBOT &&
7180 game.robot_wheel_x >= 0 &&
7181 game.robot_wheel_y >= 0 &&
7182 (Tile[game.robot_wheel_x][game.robot_wheel_y] == EL_ROBOT_WHEEL_ACTIVE ||
7183 game.engine_version < VERSION_IDENT(3,1,0,0)))
7185 attr_x = game.robot_wheel_x;
7186 attr_y = game.robot_wheel_y;
7189 if (element == EL_PENGUIN)
7192 static int xy[4][2] =
7200 for (i = 0; i < NUM_DIRECTIONS; i++)
7202 int ex = x + xy[i][0];
7203 int ey = y + xy[i][1];
7205 if (IN_LEV_FIELD(ex, ey) && (Tile[ex][ey] == EL_EXIT_OPEN ||
7206 Tile[ex][ey] == EL_EM_EXIT_OPEN ||
7207 Tile[ex][ey] == EL_STEEL_EXIT_OPEN ||
7208 Tile[ex][ey] == EL_EM_STEEL_EXIT_OPEN))
7217 MovDir[x][y] = MV_NONE;
7219 MovDir[x][y] |= (game.all_players_gone ? MV_RIGHT : MV_LEFT);
7220 else if (attr_x > x)
7221 MovDir[x][y] |= (game.all_players_gone ? MV_LEFT : MV_RIGHT);
7223 MovDir[x][y] |= (game.all_players_gone ? MV_DOWN : MV_UP);
7224 else if (attr_y > y)
7225 MovDir[x][y] |= (game.all_players_gone ? MV_UP : MV_DOWN);
7227 if (element == EL_ROBOT)
7231 if (MovDir[x][y] & MV_HORIZONTAL && MovDir[x][y] & MV_VERTICAL)
7232 MovDir[x][y] &= (RND(2) ? MV_HORIZONTAL : MV_VERTICAL);
7233 Moving2Blocked(x, y, &newx, &newy);
7235 if (IN_LEV_FIELD(newx, newy) && IS_FREE_OR_PLAYER(newx, newy))
7236 MovDelay[x][y] = 8 + 8 * !RND(3);
7238 MovDelay[x][y] = 16;
7240 else if (element == EL_PENGUIN)
7246 if (MovDir[x][y] & MV_HORIZONTAL && MovDir[x][y] & MV_VERTICAL)
7248 boolean first_horiz = RND(2);
7249 int new_move_dir = MovDir[x][y];
7252 new_move_dir & (first_horiz ? MV_HORIZONTAL : MV_VERTICAL);
7253 Moving2Blocked(x, y, &newx, &newy);
7255 if (PENGUIN_CAN_ENTER_FIELD(element, newx, newy))
7259 new_move_dir & (!first_horiz ? MV_HORIZONTAL : MV_VERTICAL);
7260 Moving2Blocked(x, y, &newx, &newy);
7262 if (PENGUIN_CAN_ENTER_FIELD(element, newx, newy))
7265 MovDir[x][y] = old_move_dir;
7269 else if (element == EL_SATELLITE)
7275 if (MovDir[x][y] & MV_HORIZONTAL && MovDir[x][y] & MV_VERTICAL)
7277 boolean first_horiz = RND(2);
7278 int new_move_dir = MovDir[x][y];
7281 new_move_dir & (first_horiz ? MV_HORIZONTAL : MV_VERTICAL);
7282 Moving2Blocked(x, y, &newx, &newy);
7284 if (SATELLITE_CAN_ENTER_FIELD(newx, newy))
7288 new_move_dir & (!first_horiz ? MV_HORIZONTAL : MV_VERTICAL);
7289 Moving2Blocked(x, y, &newx, &newy);
7291 if (SATELLITE_CAN_ENTER_FIELD(newx, newy))
7294 MovDir[x][y] = old_move_dir;
7298 else if (element == EL_EMC_ANDROID)
7300 static int check_pos[16] =
7302 -1, // 0 => (invalid)
7305 -1, // 3 => (invalid)
7307 0, // 5 => MV_LEFT | MV_UP
7308 2, // 6 => MV_RIGHT | MV_UP
7309 -1, // 7 => (invalid)
7311 6, // 9 => MV_LEFT | MV_DOWN
7312 4, // 10 => MV_RIGHT | MV_DOWN
7313 -1, // 11 => (invalid)
7314 -1, // 12 => (invalid)
7315 -1, // 13 => (invalid)
7316 -1, // 14 => (invalid)
7317 -1, // 15 => (invalid)
7325 { -1, -1, MV_LEFT | MV_UP },
7327 { +1, -1, MV_RIGHT | MV_UP },
7328 { +1, 0, MV_RIGHT },
7329 { +1, +1, MV_RIGHT | MV_DOWN },
7331 { -1, +1, MV_LEFT | MV_DOWN },
7334 int start_pos, check_order;
7335 boolean can_clone = FALSE;
7338 // check if there is any free field around current position
7339 for (i = 0; i < 8; i++)
7341 int newx = x + check_xy[i].dx;
7342 int newy = y + check_xy[i].dy;
7344 if (IN_LEV_FIELD_AND_IS_FREE(newx, newy))
7352 if (can_clone) // randomly find an element to clone
7356 start_pos = check_pos[RND(8)];
7357 check_order = (RND(2) ? -1 : +1);
7359 for (i = 0; i < 8; i++)
7361 int pos_raw = start_pos + i * check_order;
7362 int pos = (pos_raw + 8) % 8;
7363 int newx = x + check_xy[pos].dx;
7364 int newy = y + check_xy[pos].dy;
7366 if (ANDROID_CAN_CLONE_FIELD(newx, newy))
7368 element_info[element].move_leave_type = LEAVE_TYPE_LIMITED;
7369 element_info[element].move_leave_element = EL_TRIGGER_ELEMENT;
7371 Store[x][y] = Tile[newx][newy];
7380 if (can_clone) // randomly find a direction to move
7384 start_pos = check_pos[RND(8)];
7385 check_order = (RND(2) ? -1 : +1);
7387 for (i = 0; i < 8; i++)
7389 int pos_raw = start_pos + i * check_order;
7390 int pos = (pos_raw + 8) % 8;
7391 int newx = x + check_xy[pos].dx;
7392 int newy = y + check_xy[pos].dy;
7393 int new_move_dir = check_xy[pos].dir;
7395 if (IN_LEV_FIELD_AND_IS_FREE(newx, newy))
7397 MovDir[x][y] = new_move_dir;
7398 MovDelay[x][y] = level.android_clone_time * 8 + 1;
7407 if (can_clone) // cloning and moving successful
7410 // cannot clone -- try to move towards player
7412 start_pos = check_pos[MovDir[x][y] & 0x0f];
7413 check_order = (RND(2) ? -1 : +1);
7415 for (i = 0; i < 3; i++)
7417 // first check start_pos, then previous/next or (next/previous) pos
7418 int pos_raw = start_pos + (i < 2 ? i : -1) * check_order;
7419 int pos = (pos_raw + 8) % 8;
7420 int newx = x + check_xy[pos].dx;
7421 int newy = y + check_xy[pos].dy;
7422 int new_move_dir = check_xy[pos].dir;
7424 if (IS_PLAYER(newx, newy))
7427 if (ANDROID_CAN_ENTER_FIELD(element, newx, newy))
7429 MovDir[x][y] = new_move_dir;
7430 MovDelay[x][y] = level.android_move_time * 8 + 1;
7437 else if (move_pattern == MV_TURNING_LEFT ||
7438 move_pattern == MV_TURNING_RIGHT ||
7439 move_pattern == MV_TURNING_LEFT_RIGHT ||
7440 move_pattern == MV_TURNING_RIGHT_LEFT ||
7441 move_pattern == MV_TURNING_RANDOM ||
7442 move_pattern == MV_ALL_DIRECTIONS)
7444 boolean can_turn_left =
7445 CUSTOM_ELEMENT_CAN_ENTER_FIELD(element, left_x, left_y);
7446 boolean can_turn_right =
7447 CUSTOM_ELEMENT_CAN_ENTER_FIELD(element, right_x,right_y);
7449 if (element_info[element].move_stepsize == 0) // "not moving"
7452 if (move_pattern == MV_TURNING_LEFT)
7453 MovDir[x][y] = left_dir;
7454 else if (move_pattern == MV_TURNING_RIGHT)
7455 MovDir[x][y] = right_dir;
7456 else if (move_pattern == MV_TURNING_LEFT_RIGHT)
7457 MovDir[x][y] = (can_turn_left || !can_turn_right ? left_dir : right_dir);
7458 else if (move_pattern == MV_TURNING_RIGHT_LEFT)
7459 MovDir[x][y] = (can_turn_right || !can_turn_left ? right_dir : left_dir);
7460 else if (move_pattern == MV_TURNING_RANDOM)
7461 MovDir[x][y] = (can_turn_left && !can_turn_right ? left_dir :
7462 can_turn_right && !can_turn_left ? right_dir :
7463 RND(2) ? left_dir : right_dir);
7464 else if (can_turn_left && can_turn_right)
7465 MovDir[x][y] = (RND(3) ? (RND(2) ? left_dir : right_dir) : back_dir);
7466 else if (can_turn_left)
7467 MovDir[x][y] = (RND(2) ? left_dir : back_dir);
7468 else if (can_turn_right)
7469 MovDir[x][y] = (RND(2) ? right_dir : back_dir);
7471 MovDir[x][y] = back_dir;
7473 MovDelay[x][y] = GET_NEW_MOVE_DELAY(element);
7475 else if (move_pattern == MV_HORIZONTAL ||
7476 move_pattern == MV_VERTICAL)
7478 if (move_pattern & old_move_dir)
7479 MovDir[x][y] = back_dir;
7480 else if (move_pattern == MV_HORIZONTAL)
7481 MovDir[x][y] = (RND(2) ? MV_LEFT : MV_RIGHT);
7482 else if (move_pattern == MV_VERTICAL)
7483 MovDir[x][y] = (RND(2) ? MV_UP : MV_DOWN);
7485 MovDelay[x][y] = GET_NEW_MOVE_DELAY(element);
7487 else if (move_pattern & MV_ANY_DIRECTION)
7489 MovDir[x][y] = move_pattern;
7490 MovDelay[x][y] = GET_NEW_MOVE_DELAY(element);
7492 else if (move_pattern & MV_WIND_DIRECTION)
7494 MovDir[x][y] = game.wind_direction;
7495 MovDelay[x][y] = GET_NEW_MOVE_DELAY(element);
7497 else if (move_pattern == MV_ALONG_LEFT_SIDE)
7499 if (CUSTOM_ELEMENT_CAN_ENTER_FIELD(element, left_x, left_y))
7500 MovDir[x][y] = left_dir;
7501 else if (!CUSTOM_ELEMENT_CAN_ENTER_FIELD(element, move_x, move_y))
7502 MovDir[x][y] = right_dir;
7504 if (MovDir[x][y] != old_move_dir)
7505 MovDelay[x][y] = GET_NEW_MOVE_DELAY(element);
7507 else if (move_pattern == MV_ALONG_RIGHT_SIDE)
7509 if (CUSTOM_ELEMENT_CAN_ENTER_FIELD(element, right_x, right_y))
7510 MovDir[x][y] = right_dir;
7511 else if (!CUSTOM_ELEMENT_CAN_ENTER_FIELD(element, move_x, move_y))
7512 MovDir[x][y] = left_dir;
7514 if (MovDir[x][y] != old_move_dir)
7515 MovDelay[x][y] = GET_NEW_MOVE_DELAY(element);
7517 else if (move_pattern == MV_TOWARDS_PLAYER ||
7518 move_pattern == MV_AWAY_FROM_PLAYER)
7520 int attr_x = -1, attr_y = -1;
7522 boolean move_away = (move_pattern == MV_AWAY_FROM_PLAYER);
7524 if (game.all_players_gone)
7526 attr_x = game.exit_x;
7527 attr_y = game.exit_y;
7533 for (i = 0; i < MAX_PLAYERS; i++)
7535 struct PlayerInfo *player = &stored_player[i];
7536 int jx = player->jx, jy = player->jy;
7538 if (!player->active)
7542 ABS(jx - x) + ABS(jy - y) < ABS(attr_x - x) + ABS(attr_y - y))
7550 MovDir[x][y] = MV_NONE;
7552 MovDir[x][y] |= (move_away ? MV_RIGHT : MV_LEFT);
7553 else if (attr_x > x)
7554 MovDir[x][y] |= (move_away ? MV_LEFT : MV_RIGHT);
7556 MovDir[x][y] |= (move_away ? MV_DOWN : MV_UP);
7557 else if (attr_y > y)
7558 MovDir[x][y] |= (move_away ? MV_UP : MV_DOWN);
7560 MovDelay[x][y] = GET_NEW_MOVE_DELAY(element);
7562 if (MovDir[x][y] & MV_HORIZONTAL && MovDir[x][y] & MV_VERTICAL)
7564 boolean first_horiz = RND(2);
7565 int new_move_dir = MovDir[x][y];
7567 if (element_info[element].move_stepsize == 0) // "not moving"
7569 first_horiz = (ABS(attr_x - x) >= ABS(attr_y - y));
7570 MovDir[x][y] &= (first_horiz ? MV_HORIZONTAL : MV_VERTICAL);
7576 new_move_dir & (first_horiz ? MV_HORIZONTAL : MV_VERTICAL);
7577 Moving2Blocked(x, y, &newx, &newy);
7579 if (CUSTOM_ELEMENT_CAN_ENTER_FIELD(element, newx, newy))
7583 new_move_dir & (!first_horiz ? MV_HORIZONTAL : MV_VERTICAL);
7584 Moving2Blocked(x, y, &newx, &newy);
7586 if (CUSTOM_ELEMENT_CAN_ENTER_FIELD(element, newx, newy))
7589 MovDir[x][y] = old_move_dir;
7592 else if (move_pattern == MV_WHEN_PUSHED ||
7593 move_pattern == MV_WHEN_DROPPED)
7595 if (!CUSTOM_ELEMENT_CAN_ENTER_FIELD(element, move_x, move_y))
7596 MovDir[x][y] = MV_NONE;
7600 else if (move_pattern & MV_MAZE_RUNNER_STYLE)
7602 static int test_xy[7][2] =
7612 static int test_dir[7] =
7622 boolean hunter_mode = (move_pattern == MV_MAZE_HUNTER);
7623 int move_preference = -1000000; // start with very low preference
7624 int new_move_dir = MV_NONE;
7625 int start_test = RND(4);
7628 for (i = 0; i < NUM_DIRECTIONS; i++)
7630 int move_dir = test_dir[start_test + i];
7631 int move_dir_preference;
7633 xx = x + test_xy[start_test + i][0];
7634 yy = y + test_xy[start_test + i][1];
7636 if (hunter_mode && IN_LEV_FIELD(xx, yy) &&
7637 (IS_PLAYER(xx, yy) || Tile[xx][yy] == EL_PLAYER_IS_LEAVING))
7639 new_move_dir = move_dir;
7644 if (!CUSTOM_ELEMENT_CAN_ENTER_FIELD(element, xx, yy))
7647 move_dir_preference = -1 * RunnerVisit[xx][yy];
7648 if (hunter_mode && PlayerVisit[xx][yy] > 0)
7649 move_dir_preference = PlayerVisit[xx][yy];
7651 if (move_dir_preference > move_preference)
7653 // prefer field that has not been visited for the longest time
7654 move_preference = move_dir_preference;
7655 new_move_dir = move_dir;
7657 else if (move_dir_preference == move_preference &&
7658 move_dir == old_move_dir)
7660 // prefer last direction when all directions are preferred equally
7661 move_preference = move_dir_preference;
7662 new_move_dir = move_dir;
7666 MovDir[x][y] = new_move_dir;
7667 if (old_move_dir != new_move_dir)
7668 MovDelay[x][y] = GET_NEW_MOVE_DELAY(element);
7672 static void TurnRound(int x, int y)
7674 int direction = MovDir[x][y];
7678 GfxDir[x][y] = MovDir[x][y];
7680 if (direction != MovDir[x][y])
7684 GfxAction[x][y] = ACTION_TURNING_FROM_LEFT + MV_DIR_TO_BIT(direction);
7686 ResetGfxFrame(x, y);
7689 static boolean JustBeingPushed(int x, int y)
7693 for (i = 0; i < MAX_PLAYERS; i++)
7695 struct PlayerInfo *player = &stored_player[i];
7697 if (player->active && player->is_pushing && player->MovPos)
7699 int next_jx = player->jx + (player->jx - player->last_jx);
7700 int next_jy = player->jy + (player->jy - player->last_jy);
7702 if (x == next_jx && y == next_jy)
7710 static void StartMoving(int x, int y)
7712 boolean started_moving = FALSE; // some elements can fall _and_ move
7713 int element = Tile[x][y];
7718 if (MovDelay[x][y] == 0)
7719 GfxAction[x][y] = ACTION_DEFAULT;
7721 if (CAN_FALL(element) && y < lev_fieldy - 1)
7723 if ((x > 0 && IS_PLAYER(x - 1, y)) ||
7724 (x < lev_fieldx - 1 && IS_PLAYER(x + 1, y)))
7725 if (JustBeingPushed(x, y))
7728 if (element == EL_QUICKSAND_FULL)
7730 if (IS_FREE(x, y + 1))
7732 InitMovingField(x, y, MV_DOWN);
7733 started_moving = TRUE;
7735 Tile[x][y] = EL_QUICKSAND_EMPTYING;
7736 #if USE_QUICKSAND_BD_ROCK_BUGFIX
7737 if (Store[x][y] != EL_ROCK && Store[x][y] != EL_BD_ROCK)
7738 Store[x][y] = EL_ROCK;
7740 Store[x][y] = EL_ROCK;
7743 PlayLevelSoundAction(x, y, ACTION_EMPTYING);
7745 else if (Tile[x][y + 1] == EL_QUICKSAND_EMPTY)
7747 if (!MovDelay[x][y])
7749 MovDelay[x][y] = TILEY + 1;
7751 ResetGfxAnimation(x, y);
7752 ResetGfxAnimation(x, y + 1);
7757 DrawLevelElement(x, y, EL_QUICKSAND_EMPTYING);
7758 DrawLevelElement(x, y + 1, EL_QUICKSAND_FILLING);
7765 Tile[x][y] = EL_QUICKSAND_EMPTY;
7766 Tile[x][y + 1] = EL_QUICKSAND_FULL;
7767 Store[x][y + 1] = Store[x][y];
7770 PlayLevelSoundAction(x, y, ACTION_FILLING);
7772 else if (Tile[x][y + 1] == EL_QUICKSAND_FAST_EMPTY)
7774 if (!MovDelay[x][y])
7776 MovDelay[x][y] = TILEY + 1;
7778 ResetGfxAnimation(x, y);
7779 ResetGfxAnimation(x, y + 1);
7784 DrawLevelElement(x, y, EL_QUICKSAND_EMPTYING);
7785 DrawLevelElement(x, y + 1, EL_QUICKSAND_FAST_FILLING);
7792 Tile[x][y] = EL_QUICKSAND_EMPTY;
7793 Tile[x][y + 1] = EL_QUICKSAND_FAST_FULL;
7794 Store[x][y + 1] = Store[x][y];
7797 PlayLevelSoundAction(x, y, ACTION_FILLING);
7800 else if (element == EL_QUICKSAND_FAST_FULL)
7802 if (IS_FREE(x, y + 1))
7804 InitMovingField(x, y, MV_DOWN);
7805 started_moving = TRUE;
7807 Tile[x][y] = EL_QUICKSAND_FAST_EMPTYING;
7808 #if USE_QUICKSAND_BD_ROCK_BUGFIX
7809 if (Store[x][y] != EL_ROCK && Store[x][y] != EL_BD_ROCK)
7810 Store[x][y] = EL_ROCK;
7812 Store[x][y] = EL_ROCK;
7815 PlayLevelSoundAction(x, y, ACTION_EMPTYING);
7817 else if (Tile[x][y + 1] == EL_QUICKSAND_FAST_EMPTY)
7819 if (!MovDelay[x][y])
7821 MovDelay[x][y] = TILEY + 1;
7823 ResetGfxAnimation(x, y);
7824 ResetGfxAnimation(x, y + 1);
7829 DrawLevelElement(x, y, EL_QUICKSAND_FAST_EMPTYING);
7830 DrawLevelElement(x, y + 1, EL_QUICKSAND_FAST_FILLING);
7837 Tile[x][y] = EL_QUICKSAND_FAST_EMPTY;
7838 Tile[x][y + 1] = EL_QUICKSAND_FAST_FULL;
7839 Store[x][y + 1] = Store[x][y];
7842 PlayLevelSoundAction(x, y, ACTION_FILLING);
7844 else if (Tile[x][y + 1] == EL_QUICKSAND_EMPTY)
7846 if (!MovDelay[x][y])
7848 MovDelay[x][y] = TILEY + 1;
7850 ResetGfxAnimation(x, y);
7851 ResetGfxAnimation(x, y + 1);
7856 DrawLevelElement(x, y, EL_QUICKSAND_FAST_EMPTYING);
7857 DrawLevelElement(x, y + 1, EL_QUICKSAND_FILLING);
7864 Tile[x][y] = EL_QUICKSAND_FAST_EMPTY;
7865 Tile[x][y + 1] = EL_QUICKSAND_FULL;
7866 Store[x][y + 1] = Store[x][y];
7869 PlayLevelSoundAction(x, y, ACTION_FILLING);
7872 else if ((element == EL_ROCK || element == EL_BD_ROCK) &&
7873 Tile[x][y + 1] == EL_QUICKSAND_EMPTY)
7875 InitMovingField(x, y, MV_DOWN);
7876 started_moving = TRUE;
7878 Tile[x][y] = EL_QUICKSAND_FILLING;
7879 Store[x][y] = element;
7881 PlayLevelSoundAction(x, y, ACTION_FILLING);
7883 else if ((element == EL_ROCK || element == EL_BD_ROCK) &&
7884 Tile[x][y + 1] == EL_QUICKSAND_FAST_EMPTY)
7886 InitMovingField(x, y, MV_DOWN);
7887 started_moving = TRUE;
7889 Tile[x][y] = EL_QUICKSAND_FAST_FILLING;
7890 Store[x][y] = element;
7892 PlayLevelSoundAction(x, y, ACTION_FILLING);
7894 else if (element == EL_MAGIC_WALL_FULL)
7896 if (IS_FREE(x, y + 1))
7898 InitMovingField(x, y, MV_DOWN);
7899 started_moving = TRUE;
7901 Tile[x][y] = EL_MAGIC_WALL_EMPTYING;
7902 Store[x][y] = EL_CHANGED(Store[x][y]);
7904 else if (Tile[x][y + 1] == EL_MAGIC_WALL_ACTIVE)
7906 if (!MovDelay[x][y])
7907 MovDelay[x][y] = TILEY / 4 + 1;
7916 Tile[x][y] = EL_MAGIC_WALL_ACTIVE;
7917 Tile[x][y + 1] = EL_MAGIC_WALL_FULL;
7918 Store[x][y + 1] = EL_CHANGED(Store[x][y]);
7922 else if (element == EL_BD_MAGIC_WALL_FULL)
7924 if (IS_FREE(x, y + 1))
7926 InitMovingField(x, y, MV_DOWN);
7927 started_moving = TRUE;
7929 Tile[x][y] = EL_BD_MAGIC_WALL_EMPTYING;
7930 Store[x][y] = EL_CHANGED_BD(Store[x][y]);
7932 else if (Tile[x][y + 1] == EL_BD_MAGIC_WALL_ACTIVE)
7934 if (!MovDelay[x][y])
7935 MovDelay[x][y] = TILEY / 4 + 1;
7944 Tile[x][y] = EL_BD_MAGIC_WALL_ACTIVE;
7945 Tile[x][y + 1] = EL_BD_MAGIC_WALL_FULL;
7946 Store[x][y + 1] = EL_CHANGED_BD(Store[x][y]);
7950 else if (element == EL_DC_MAGIC_WALL_FULL)
7952 if (IS_FREE(x, y + 1))
7954 InitMovingField(x, y, MV_DOWN);
7955 started_moving = TRUE;
7957 Tile[x][y] = EL_DC_MAGIC_WALL_EMPTYING;
7958 Store[x][y] = EL_CHANGED_DC(Store[x][y]);
7960 else if (Tile[x][y + 1] == EL_DC_MAGIC_WALL_ACTIVE)
7962 if (!MovDelay[x][y])
7963 MovDelay[x][y] = TILEY / 4 + 1;
7972 Tile[x][y] = EL_DC_MAGIC_WALL_ACTIVE;
7973 Tile[x][y + 1] = EL_DC_MAGIC_WALL_FULL;
7974 Store[x][y + 1] = EL_CHANGED_DC(Store[x][y]);
7978 else if ((CAN_PASS_MAGIC_WALL(element) &&
7979 (Tile[x][y + 1] == EL_MAGIC_WALL_ACTIVE ||
7980 Tile[x][y + 1] == EL_BD_MAGIC_WALL_ACTIVE)) ||
7981 (CAN_PASS_DC_MAGIC_WALL(element) &&
7982 (Tile[x][y + 1] == EL_DC_MAGIC_WALL_ACTIVE)))
7985 InitMovingField(x, y, MV_DOWN);
7986 started_moving = TRUE;
7989 (Tile[x][y + 1] == EL_MAGIC_WALL_ACTIVE ? EL_MAGIC_WALL_FILLING :
7990 Tile[x][y + 1] == EL_BD_MAGIC_WALL_ACTIVE ? EL_BD_MAGIC_WALL_FILLING :
7991 EL_DC_MAGIC_WALL_FILLING);
7992 Store[x][y] = element;
7994 else if (CAN_FALL(element) && Tile[x][y + 1] == EL_ACID)
7996 SplashAcid(x, y + 1);
7998 InitMovingField(x, y, MV_DOWN);
7999 started_moving = TRUE;
8001 Store[x][y] = EL_ACID;
8004 (game.engine_version >= VERSION_IDENT(3,1,0,0) &&
8005 CheckImpact[x][y] && !IS_FREE(x, y + 1)) ||
8006 (game.engine_version >= VERSION_IDENT(3,0,7,0) &&
8007 CAN_FALL(element) && WasJustFalling[x][y] &&
8008 (Tile[x][y + 1] == EL_BLOCKED || IS_PLAYER(x, y + 1))) ||
8010 (game.engine_version < VERSION_IDENT(2,2,0,7) &&
8011 CAN_FALL(element) && WasJustMoving[x][y] && !Pushed[x][y + 1] &&
8012 (Tile[x][y + 1] == EL_BLOCKED)))
8014 /* this is needed for a special case not covered by calling "Impact()"
8015 from "ContinueMoving()": if an element moves to a tile directly below
8016 another element which was just falling on that tile (which was empty
8017 in the previous frame), the falling element above would just stop
8018 instead of smashing the element below (in previous version, the above
8019 element was just checked for "moving" instead of "falling", resulting
8020 in incorrect smashes caused by horizontal movement of the above
8021 element; also, the case of the player being the element to smash was
8022 simply not covered here... :-/ ) */
8024 CheckCollision[x][y] = 0;
8025 CheckImpact[x][y] = 0;
8029 else if (IS_FREE(x, y + 1) && element == EL_SPRING && level.use_spring_bug)
8031 if (MovDir[x][y] == MV_NONE)
8033 InitMovingField(x, y, MV_DOWN);
8034 started_moving = TRUE;
8037 else if (IS_FREE(x, y + 1) || Tile[x][y + 1] == EL_DIAMOND_BREAKING)
8039 if (WasJustFalling[x][y]) // prevent animation from being restarted
8040 MovDir[x][y] = MV_DOWN;
8042 InitMovingField(x, y, MV_DOWN);
8043 started_moving = TRUE;
8045 else if (element == EL_AMOEBA_DROP)
8047 Tile[x][y] = EL_AMOEBA_GROWING;
8048 Store[x][y] = EL_AMOEBA_WET;
8050 else if (((IS_SLIPPERY(Tile[x][y + 1]) && !IS_PLAYER(x, y + 1)) ||
8051 (IS_EM_SLIPPERY_WALL(Tile[x][y + 1]) && IS_GEM(element))) &&
8052 !IS_FALLING(x, y + 1) && !WasJustMoving[x][y + 1] &&
8053 element != EL_DX_SUPABOMB && element != EL_SP_DISK_ORANGE)
8055 boolean can_fall_left = (x > 0 && IS_FREE(x - 1, y) &&
8056 (IS_FREE(x - 1, y + 1) ||
8057 Tile[x - 1][y + 1] == EL_ACID));
8058 boolean can_fall_right = (x < lev_fieldx - 1 && IS_FREE(x + 1, y) &&
8059 (IS_FREE(x + 1, y + 1) ||
8060 Tile[x + 1][y + 1] == EL_ACID));
8061 boolean can_fall_any = (can_fall_left || can_fall_right);
8062 boolean can_fall_both = (can_fall_left && can_fall_right);
8063 int slippery_type = element_info[Tile[x][y + 1]].slippery_type;
8065 if (can_fall_any && slippery_type != SLIPPERY_ANY_RANDOM)
8067 if (slippery_type == SLIPPERY_ANY_LEFT_RIGHT && can_fall_both)
8068 can_fall_right = FALSE;
8069 else if (slippery_type == SLIPPERY_ANY_RIGHT_LEFT && can_fall_both)
8070 can_fall_left = FALSE;
8071 else if (slippery_type == SLIPPERY_ONLY_LEFT)
8072 can_fall_right = FALSE;
8073 else if (slippery_type == SLIPPERY_ONLY_RIGHT)
8074 can_fall_left = FALSE;
8076 can_fall_any = (can_fall_left || can_fall_right);
8077 can_fall_both = FALSE;
8082 if (element == EL_BD_ROCK || element == EL_BD_DIAMOND)
8083 can_fall_right = FALSE; // slip down on left side
8085 can_fall_left = !(can_fall_right = RND(2));
8087 can_fall_both = FALSE;
8092 // if not determined otherwise, prefer left side for slipping down
8093 InitMovingField(x, y, can_fall_left ? MV_LEFT : MV_RIGHT);
8094 started_moving = TRUE;
8097 else if (IS_BELT_ACTIVE(Tile[x][y + 1]))
8099 boolean left_is_free = (x > 0 && IS_FREE(x - 1, y));
8100 boolean right_is_free = (x < lev_fieldx - 1 && IS_FREE(x + 1, y));
8101 int belt_nr = getBeltNrFromBeltActiveElement(Tile[x][y + 1]);
8102 int belt_dir = game.belt_dir[belt_nr];
8104 if ((belt_dir == MV_LEFT && left_is_free) ||
8105 (belt_dir == MV_RIGHT && right_is_free))
8107 int nextx = (belt_dir == MV_LEFT ? x - 1 : x + 1);
8109 InitMovingField(x, y, belt_dir);
8110 started_moving = TRUE;
8112 Pushed[x][y] = TRUE;
8113 Pushed[nextx][y] = TRUE;
8115 GfxAction[x][y] = ACTION_DEFAULT;
8119 MovDir[x][y] = 0; // if element was moving, stop it
8124 // not "else if" because of elements that can fall and move (EL_SPRING)
8125 if (CAN_MOVE(element) && !started_moving)
8127 int move_pattern = element_info[element].move_pattern;
8130 Moving2Blocked(x, y, &newx, &newy);
8132 if (IS_PUSHABLE(element) && JustBeingPushed(x, y))
8135 if (game.engine_version >= VERSION_IDENT(3,1,0,0) &&
8136 CheckCollision[x][y] && !IN_LEV_FIELD_AND_IS_FREE(newx, newy))
8138 WasJustMoving[x][y] = 0;
8139 CheckCollision[x][y] = 0;
8141 TestIfElementHitsCustomElement(x, y, MovDir[x][y]);
8143 if (Tile[x][y] != element) // element has changed
8147 if (!MovDelay[x][y]) // start new movement phase
8149 // all objects that can change their move direction after each step
8150 // (YAMYAM, DARK_YAMYAM and PACMAN go straight until they hit a wall
8152 if (element != EL_YAMYAM &&
8153 element != EL_DARK_YAMYAM &&
8154 element != EL_PACMAN &&
8155 !(move_pattern & MV_ANY_DIRECTION) &&
8156 move_pattern != MV_TURNING_LEFT &&
8157 move_pattern != MV_TURNING_RIGHT &&
8158 move_pattern != MV_TURNING_LEFT_RIGHT &&
8159 move_pattern != MV_TURNING_RIGHT_LEFT &&
8160 move_pattern != MV_TURNING_RANDOM)
8164 if (MovDelay[x][y] && (element == EL_BUG ||
8165 element == EL_SPACESHIP ||
8166 element == EL_SP_SNIKSNAK ||
8167 element == EL_SP_ELECTRON ||
8168 element == EL_MOLE))
8169 TEST_DrawLevelField(x, y);
8173 if (MovDelay[x][y]) // wait some time before next movement
8177 if (element == EL_ROBOT ||
8178 element == EL_YAMYAM ||
8179 element == EL_DARK_YAMYAM)
8181 DrawLevelElementAnimationIfNeeded(x, y, element);
8182 PlayLevelSoundAction(x, y, ACTION_WAITING);
8184 else if (element == EL_SP_ELECTRON)
8185 DrawLevelElementAnimationIfNeeded(x, y, element);
8186 else if (element == EL_DRAGON)
8189 int dir = MovDir[x][y];
8190 int dx = (dir == MV_LEFT ? -1 : dir == MV_RIGHT ? +1 : 0);
8191 int dy = (dir == MV_UP ? -1 : dir == MV_DOWN ? +1 : 0);
8192 int graphic = (dir == MV_LEFT ? IMG_FLAMES_1_LEFT :
8193 dir == MV_RIGHT ? IMG_FLAMES_1_RIGHT :
8194 dir == MV_UP ? IMG_FLAMES_1_UP :
8195 dir == MV_DOWN ? IMG_FLAMES_1_DOWN : IMG_EMPTY);
8196 int frame = getGraphicAnimationFrame(graphic, GfxFrame[x][y]);
8198 GfxAction[x][y] = ACTION_ATTACKING;
8200 if (IS_PLAYER(x, y))
8201 DrawPlayerField(x, y);
8203 TEST_DrawLevelField(x, y);
8205 PlayLevelSoundActionIfLoop(x, y, ACTION_ATTACKING);
8207 for (i = 1; i <= 3; i++)
8209 int xx = x + i * dx;
8210 int yy = y + i * dy;
8211 int sx = SCREENX(xx);
8212 int sy = SCREENY(yy);
8213 int flame_graphic = graphic + (i - 1);
8215 if (!IN_LEV_FIELD(xx, yy) || IS_DRAGONFIRE_PROOF(Tile[xx][yy]))
8220 int flamed = MovingOrBlocked2Element(xx, yy);
8222 if (IS_CLASSIC_ENEMY(flamed) || CAN_EXPLODE_BY_DRAGONFIRE(flamed))
8225 RemoveMovingField(xx, yy);
8227 ChangeDelay[xx][yy] = 0;
8229 Tile[xx][yy] = EL_FLAMES;
8231 if (IN_SCR_FIELD(sx, sy))
8233 TEST_DrawLevelFieldCrumbled(xx, yy);
8234 DrawGraphic(sx, sy, flame_graphic, frame);
8239 if (Tile[xx][yy] == EL_FLAMES)
8240 Tile[xx][yy] = EL_EMPTY;
8241 TEST_DrawLevelField(xx, yy);
8246 if (MovDelay[x][y]) // element still has to wait some time
8248 PlayLevelSoundAction(x, y, ACTION_WAITING);
8254 // now make next step
8256 Moving2Blocked(x, y, &newx, &newy); // get next screen position
8258 if (DONT_COLLIDE_WITH(element) &&
8259 IN_LEV_FIELD(newx, newy) && IS_PLAYER(newx, newy) &&
8260 !PLAYER_ENEMY_PROTECTED(newx, newy))
8262 TestIfBadThingRunsIntoPlayer(x, y, MovDir[x][y]);
8267 else if (CAN_MOVE_INTO_ACID(element) &&
8268 IN_LEV_FIELD(newx, newy) && Tile[newx][newy] == EL_ACID &&
8269 !IS_MV_DIAGONAL(MovDir[x][y]) &&
8270 (MovDir[x][y] == MV_DOWN ||
8271 game.engine_version >= VERSION_IDENT(3,1,0,0)))
8273 SplashAcid(newx, newy);
8274 Store[x][y] = EL_ACID;
8276 else if (element == EL_PENGUIN && IN_LEV_FIELD(newx, newy))
8278 if (Tile[newx][newy] == EL_EXIT_OPEN ||
8279 Tile[newx][newy] == EL_EM_EXIT_OPEN ||
8280 Tile[newx][newy] == EL_STEEL_EXIT_OPEN ||
8281 Tile[newx][newy] == EL_EM_STEEL_EXIT_OPEN)
8284 TEST_DrawLevelField(x, y);
8286 PlayLevelSound(newx, newy, SND_PENGUIN_PASSING);
8287 if (IN_SCR_FIELD(SCREENX(newx), SCREENY(newy)))
8288 DrawGraphicThruMask(SCREENX(newx),SCREENY(newy), el2img(element), 0);
8290 game.friends_still_needed--;
8291 if (!game.friends_still_needed &&
8293 game.all_players_gone)
8298 else if (IS_FOOD_PENGUIN(Tile[newx][newy]))
8300 if (DigField(local_player, x, y, newx, newy, 0,0, DF_DIG) == MP_MOVING)
8301 TEST_DrawLevelField(newx, newy);
8303 GfxDir[x][y] = MovDir[x][y] = MV_NONE;
8305 else if (!IS_FREE(newx, newy))
8307 GfxAction[x][y] = ACTION_WAITING;
8309 if (IS_PLAYER(x, y))
8310 DrawPlayerField(x, y);
8312 TEST_DrawLevelField(x, y);
8317 else if (element == EL_PIG && IN_LEV_FIELD(newx, newy))
8319 if (IS_FOOD_PIG(Tile[newx][newy]))
8321 if (IS_MOVING(newx, newy))
8322 RemoveMovingField(newx, newy);
8325 Tile[newx][newy] = EL_EMPTY;
8326 TEST_DrawLevelField(newx, newy);
8329 PlayLevelSound(x, y, SND_PIG_DIGGING);
8331 else if (!IS_FREE(newx, newy))
8333 if (IS_PLAYER(x, y))
8334 DrawPlayerField(x, y);
8336 TEST_DrawLevelField(x, y);
8341 else if (element == EL_EMC_ANDROID && IN_LEV_FIELD(newx, newy))
8343 if (Store[x][y] != EL_EMPTY)
8345 boolean can_clone = FALSE;
8348 // check if element to clone is still there
8349 for (yy = y - 1; yy <= y + 1; yy++) for (xx = x - 1; xx <= x + 1; xx++)
8351 if (IN_LEV_FIELD(xx, yy) && Tile[xx][yy] == Store[x][y])
8359 // cannot clone or target field not free anymore -- do not clone
8360 if (!can_clone || !ANDROID_CAN_ENTER_FIELD(element, newx, newy))
8361 Store[x][y] = EL_EMPTY;
8364 if (ANDROID_CAN_ENTER_FIELD(element, newx, newy))
8366 if (IS_MV_DIAGONAL(MovDir[x][y]))
8368 int diagonal_move_dir = MovDir[x][y];
8369 int stored = Store[x][y];
8370 int change_delay = 8;
8373 // android is moving diagonally
8375 CreateField(x, y, EL_DIAGONAL_SHRINKING);
8377 Store[x][y] = (stored == EL_ACID ? EL_EMPTY : stored);
8378 GfxElement[x][y] = EL_EMC_ANDROID;
8379 GfxAction[x][y] = ACTION_SHRINKING;
8380 GfxDir[x][y] = diagonal_move_dir;
8381 ChangeDelay[x][y] = change_delay;
8383 graphic = el_act_dir2img(GfxElement[x][y], GfxAction[x][y],
8386 DrawLevelGraphicAnimation(x, y, graphic);
8387 PlayLevelSoundAction(x, y, ACTION_SHRINKING);
8389 if (Tile[newx][newy] == EL_ACID)
8391 SplashAcid(newx, newy);
8396 CreateField(newx, newy, EL_DIAGONAL_GROWING);
8398 Store[newx][newy] = EL_EMC_ANDROID;
8399 GfxElement[newx][newy] = EL_EMC_ANDROID;
8400 GfxAction[newx][newy] = ACTION_GROWING;
8401 GfxDir[newx][newy] = diagonal_move_dir;
8402 ChangeDelay[newx][newy] = change_delay;
8404 graphic = el_act_dir2img(GfxElement[newx][newy],
8405 GfxAction[newx][newy], GfxDir[newx][newy]);
8407 DrawLevelGraphicAnimation(newx, newy, graphic);
8408 PlayLevelSoundAction(newx, newy, ACTION_GROWING);
8414 Tile[newx][newy] = EL_EMPTY;
8415 TEST_DrawLevelField(newx, newy);
8417 PlayLevelSoundAction(x, y, ACTION_DIGGING);
8420 else if (!IS_FREE(newx, newy))
8425 else if (IS_CUSTOM_ELEMENT(element) &&
8426 CUSTOM_ELEMENT_CAN_ENTER_FIELD(element, newx, newy))
8428 if (!DigFieldByCE(newx, newy, element))
8431 if (move_pattern & MV_MAZE_RUNNER_STYLE)
8433 RunnerVisit[x][y] = FrameCounter;
8434 PlayerVisit[x][y] /= 8; // expire player visit path
8437 else if (element == EL_DRAGON && IN_LEV_FIELD(newx, newy))
8439 if (!IS_FREE(newx, newy))
8441 if (IS_PLAYER(x, y))
8442 DrawPlayerField(x, y);
8444 TEST_DrawLevelField(x, y);
8450 boolean wanna_flame = !RND(10);
8451 int dx = newx - x, dy = newy - y;
8452 int newx1 = newx + 1 * dx, newy1 = newy + 1 * dy;
8453 int newx2 = newx + 2 * dx, newy2 = newy + 2 * dy;
8454 int element1 = (IN_LEV_FIELD(newx1, newy1) ?
8455 MovingOrBlocked2Element(newx1, newy1) : EL_STEELWALL);
8456 int element2 = (IN_LEV_FIELD(newx2, newy2) ?
8457 MovingOrBlocked2Element(newx2, newy2) : EL_STEELWALL);
8460 IS_CLASSIC_ENEMY(element1) ||
8461 IS_CLASSIC_ENEMY(element2)) &&
8462 element1 != EL_DRAGON && element2 != EL_DRAGON &&
8463 element1 != EL_FLAMES && element2 != EL_FLAMES)
8465 ResetGfxAnimation(x, y);
8466 GfxAction[x][y] = ACTION_ATTACKING;
8468 if (IS_PLAYER(x, y))
8469 DrawPlayerField(x, y);
8471 TEST_DrawLevelField(x, y);
8473 PlayLevelSound(x, y, SND_DRAGON_ATTACKING);
8475 MovDelay[x][y] = 50;
8477 Tile[newx][newy] = EL_FLAMES;
8478 if (IN_LEV_FIELD(newx1, newy1) && Tile[newx1][newy1] == EL_EMPTY)
8479 Tile[newx1][newy1] = EL_FLAMES;
8480 if (IN_LEV_FIELD(newx2, newy2) && Tile[newx2][newy2] == EL_EMPTY)
8481 Tile[newx2][newy2] = EL_FLAMES;
8487 else if (element == EL_YAMYAM && IN_LEV_FIELD(newx, newy) &&
8488 Tile[newx][newy] == EL_DIAMOND)
8490 if (IS_MOVING(newx, newy))
8491 RemoveMovingField(newx, newy);
8494 Tile[newx][newy] = EL_EMPTY;
8495 TEST_DrawLevelField(newx, newy);
8498 PlayLevelSound(x, y, SND_YAMYAM_DIGGING);
8500 else if (element == EL_DARK_YAMYAM && IN_LEV_FIELD(newx, newy) &&
8501 IS_FOOD_DARK_YAMYAM(Tile[newx][newy]))
8503 if (AmoebaNr[newx][newy])
8505 AmoebaCnt2[AmoebaNr[newx][newy]]--;
8506 if (Tile[newx][newy] == EL_AMOEBA_FULL ||
8507 Tile[newx][newy] == EL_BD_AMOEBA)
8508 AmoebaCnt[AmoebaNr[newx][newy]]--;
8511 if (IS_MOVING(newx, newy))
8513 RemoveMovingField(newx, newy);
8517 Tile[newx][newy] = EL_EMPTY;
8518 TEST_DrawLevelField(newx, newy);
8521 PlayLevelSound(x, y, SND_DARK_YAMYAM_DIGGING);
8523 else if ((element == EL_PACMAN || element == EL_MOLE)
8524 && IN_LEV_FIELD(newx, newy) && IS_AMOEBOID(Tile[newx][newy]))
8526 if (AmoebaNr[newx][newy])
8528 AmoebaCnt2[AmoebaNr[newx][newy]]--;
8529 if (Tile[newx][newy] == EL_AMOEBA_FULL ||
8530 Tile[newx][newy] == EL_BD_AMOEBA)
8531 AmoebaCnt[AmoebaNr[newx][newy]]--;
8534 if (element == EL_MOLE)
8536 Tile[newx][newy] = EL_AMOEBA_SHRINKING;
8537 PlayLevelSound(x, y, SND_MOLE_DIGGING);
8539 ResetGfxAnimation(x, y);
8540 GfxAction[x][y] = ACTION_DIGGING;
8541 TEST_DrawLevelField(x, y);
8543 MovDelay[newx][newy] = 0; // start amoeba shrinking delay
8545 return; // wait for shrinking amoeba
8547 else // element == EL_PACMAN
8549 Tile[newx][newy] = EL_EMPTY;
8550 TEST_DrawLevelField(newx, newy);
8551 PlayLevelSound(x, y, SND_PACMAN_DIGGING);
8554 else if (element == EL_MOLE && IN_LEV_FIELD(newx, newy) &&
8555 (Tile[newx][newy] == EL_AMOEBA_SHRINKING ||
8556 (Tile[newx][newy] == EL_EMPTY && Stop[newx][newy])))
8558 // wait for shrinking amoeba to completely disappear
8561 else if (!IN_LEV_FIELD(newx, newy) || !IS_FREE(newx, newy))
8563 // object was running against a wall
8567 if (GFX_ELEMENT(element) != EL_SAND) // !!! FIX THIS (crumble) !!!
8568 DrawLevelElementAnimation(x, y, element);
8570 if (DONT_TOUCH(element))
8571 TestIfBadThingTouchesPlayer(x, y);
8576 InitMovingField(x, y, MovDir[x][y]);
8578 PlayLevelSoundAction(x, y, ACTION_MOVING);
8582 ContinueMoving(x, y);
8585 void ContinueMoving(int x, int y)
8587 int element = Tile[x][y];
8588 struct ElementInfo *ei = &element_info[element];
8589 int direction = MovDir[x][y];
8590 int dx = (direction == MV_LEFT ? -1 : direction == MV_RIGHT ? +1 : 0);
8591 int dy = (direction == MV_UP ? -1 : direction == MV_DOWN ? +1 : 0);
8592 int newx = x + dx, newy = y + dy;
8593 int stored = Store[x][y];
8594 int stored_new = Store[newx][newy];
8595 boolean pushed_by_player = (Pushed[x][y] && IS_PLAYER(x, y));
8596 boolean pushed_by_conveyor = (Pushed[x][y] && !IS_PLAYER(x, y));
8597 boolean last_line = (newy == lev_fieldy - 1);
8598 boolean use_step_delay = (GET_MAX_STEP_DELAY(element) != 0);
8600 if (pushed_by_player) // special case: moving object pushed by player
8602 MovPos[x][y] = SIGN(MovPos[x][y]) * (TILEX - ABS(PLAYERINFO(x,y)->MovPos));
8604 else if (use_step_delay) // special case: moving object has step delay
8606 if (!MovDelay[x][y])
8607 MovPos[x][y] += getElementMoveStepsize(x, y);
8612 MovDelay[x][y] = GET_NEW_STEP_DELAY(element);
8616 TEST_DrawLevelField(x, y);
8618 return; // element is still waiting
8621 else // normal case: generically moving object
8623 MovPos[x][y] += getElementMoveStepsize(x, y);
8626 if (ABS(MovPos[x][y]) < TILEX)
8628 TEST_DrawLevelField(x, y);
8630 return; // element is still moving
8633 // element reached destination field
8635 Tile[x][y] = EL_EMPTY;
8636 Tile[newx][newy] = element;
8637 MovPos[x][y] = 0; // force "not moving" for "crumbled sand"
8639 if (Store[x][y] == EL_ACID) // element is moving into acid pool
8641 element = Tile[newx][newy] = EL_ACID;
8643 else if (element == EL_MOLE)
8645 Tile[x][y] = EL_SAND;
8647 TEST_DrawLevelFieldCrumbledNeighbours(x, y);
8649 else if (element == EL_QUICKSAND_FILLING)
8651 element = Tile[newx][newy] = get_next_element(element);
8652 Store[newx][newy] = Store[x][y];
8654 else if (element == EL_QUICKSAND_EMPTYING)
8656 Tile[x][y] = get_next_element(element);
8657 element = Tile[newx][newy] = Store[x][y];
8659 else if (element == EL_QUICKSAND_FAST_FILLING)
8661 element = Tile[newx][newy] = get_next_element(element);
8662 Store[newx][newy] = Store[x][y];
8664 else if (element == EL_QUICKSAND_FAST_EMPTYING)
8666 Tile[x][y] = get_next_element(element);
8667 element = Tile[newx][newy] = Store[x][y];
8669 else if (element == EL_MAGIC_WALL_FILLING)
8671 element = Tile[newx][newy] = get_next_element(element);
8672 if (!game.magic_wall_active)
8673 element = Tile[newx][newy] = EL_MAGIC_WALL_DEAD;
8674 Store[newx][newy] = Store[x][y];
8676 else if (element == EL_MAGIC_WALL_EMPTYING)
8678 Tile[x][y] = get_next_element(element);
8679 if (!game.magic_wall_active)
8680 Tile[x][y] = EL_MAGIC_WALL_DEAD;
8681 element = Tile[newx][newy] = Store[x][y];
8683 InitField(newx, newy, FALSE);
8685 else if (element == EL_BD_MAGIC_WALL_FILLING)
8687 element = Tile[newx][newy] = get_next_element(element);
8688 if (!game.magic_wall_active)
8689 element = Tile[newx][newy] = EL_BD_MAGIC_WALL_DEAD;
8690 Store[newx][newy] = Store[x][y];
8692 else if (element == EL_BD_MAGIC_WALL_EMPTYING)
8694 Tile[x][y] = get_next_element(element);
8695 if (!game.magic_wall_active)
8696 Tile[x][y] = EL_BD_MAGIC_WALL_DEAD;
8697 element = Tile[newx][newy] = Store[x][y];
8699 InitField(newx, newy, FALSE);
8701 else if (element == EL_DC_MAGIC_WALL_FILLING)
8703 element = Tile[newx][newy] = get_next_element(element);
8704 if (!game.magic_wall_active)
8705 element = Tile[newx][newy] = EL_DC_MAGIC_WALL_DEAD;
8706 Store[newx][newy] = Store[x][y];
8708 else if (element == EL_DC_MAGIC_WALL_EMPTYING)
8710 Tile[x][y] = get_next_element(element);
8711 if (!game.magic_wall_active)
8712 Tile[x][y] = EL_DC_MAGIC_WALL_DEAD;
8713 element = Tile[newx][newy] = Store[x][y];
8715 InitField(newx, newy, FALSE);
8717 else if (element == EL_AMOEBA_DROPPING)
8719 Tile[x][y] = get_next_element(element);
8720 element = Tile[newx][newy] = Store[x][y];
8722 else if (element == EL_SOKOBAN_OBJECT)
8725 Tile[x][y] = Back[x][y];
8727 if (Back[newx][newy])
8728 Tile[newx][newy] = EL_SOKOBAN_FIELD_FULL;
8730 Back[x][y] = Back[newx][newy] = 0;
8733 Store[x][y] = EL_EMPTY;
8738 MovDelay[newx][newy] = 0;
8740 if (CAN_CHANGE_OR_HAS_ACTION(element))
8742 // copy element change control values to new field
8743 ChangeDelay[newx][newy] = ChangeDelay[x][y];
8744 ChangePage[newx][newy] = ChangePage[x][y];
8745 ChangeCount[newx][newy] = ChangeCount[x][y];
8746 ChangeEvent[newx][newy] = ChangeEvent[x][y];
8749 CustomValue[newx][newy] = CustomValue[x][y];
8751 ChangeDelay[x][y] = 0;
8752 ChangePage[x][y] = -1;
8753 ChangeCount[x][y] = 0;
8754 ChangeEvent[x][y] = -1;
8756 CustomValue[x][y] = 0;
8758 // copy animation control values to new field
8759 GfxFrame[newx][newy] = GfxFrame[x][y];
8760 GfxRandom[newx][newy] = GfxRandom[x][y]; // keep same random value
8761 GfxAction[newx][newy] = GfxAction[x][y]; // keep action one frame
8762 GfxDir[newx][newy] = GfxDir[x][y]; // keep element direction
8764 Pushed[x][y] = Pushed[newx][newy] = FALSE;
8766 // some elements can leave other elements behind after moving
8767 if (ei->move_leave_element != EL_EMPTY &&
8768 (ei->move_leave_type == LEAVE_TYPE_UNLIMITED || stored != EL_EMPTY) &&
8769 (!IS_PLAYER(x, y) || IS_WALKABLE(ei->move_leave_element)))
8771 int move_leave_element = ei->move_leave_element;
8773 // this makes it possible to leave the removed element again
8774 if (ei->move_leave_element == EL_TRIGGER_ELEMENT)
8775 move_leave_element = (stored == EL_ACID ? EL_EMPTY : stored);
8777 Tile[x][y] = move_leave_element;
8779 if (element_info[Tile[x][y]].move_direction_initial == MV_START_PREVIOUS)
8780 MovDir[x][y] = direction;
8782 InitField(x, y, FALSE);
8784 if (GFX_CRUMBLED(Tile[x][y]))
8785 TEST_DrawLevelFieldCrumbledNeighbours(x, y);
8787 if (IS_PLAYER_ELEMENT(move_leave_element))
8788 RelocatePlayer(x, y, move_leave_element);
8791 // do this after checking for left-behind element
8792 ResetGfxAnimation(x, y); // reset animation values for old field
8794 if (!CAN_MOVE(element) ||
8795 (CAN_FALL(element) && direction == MV_DOWN &&
8796 (element == EL_SPRING ||
8797 element_info[element].move_pattern == MV_WHEN_PUSHED ||
8798 element_info[element].move_pattern == MV_WHEN_DROPPED)))
8799 GfxDir[x][y] = MovDir[newx][newy] = 0;
8801 TEST_DrawLevelField(x, y);
8802 TEST_DrawLevelField(newx, newy);
8804 Stop[newx][newy] = TRUE; // ignore this element until the next frame
8806 // prevent pushed element from moving on in pushed direction
8807 if (pushed_by_player && CAN_MOVE(element) &&
8808 element_info[element].move_pattern & MV_ANY_DIRECTION &&
8809 !(element_info[element].move_pattern & direction))
8810 TurnRound(newx, newy);
8812 // prevent elements on conveyor belt from moving on in last direction
8813 if (pushed_by_conveyor && CAN_FALL(element) &&
8814 direction & MV_HORIZONTAL)
8815 MovDir[newx][newy] = 0;
8817 if (!pushed_by_player)
8819 int nextx = newx + dx, nexty = newy + dy;
8820 boolean check_collision_again = IN_LEV_FIELD_AND_IS_FREE(nextx, nexty);
8822 WasJustMoving[newx][newy] = CHECK_DELAY_MOVING;
8824 if (CAN_FALL(element) && direction == MV_DOWN)
8825 WasJustFalling[newx][newy] = CHECK_DELAY_FALLING;
8827 if ((!CAN_FALL(element) || direction == MV_DOWN) && check_collision_again)
8828 CheckCollision[newx][newy] = CHECK_DELAY_COLLISION;
8830 if (CAN_FALL(element) && direction == MV_DOWN && check_collision_again)
8831 CheckImpact[newx][newy] = CHECK_DELAY_IMPACT;
8834 if (DONT_TOUCH(element)) // object may be nasty to player or others
8836 TestIfBadThingTouchesPlayer(newx, newy);
8837 TestIfBadThingTouchesFriend(newx, newy);
8839 if (!IS_CUSTOM_ELEMENT(element))
8840 TestIfBadThingTouchesOtherBadThing(newx, newy);
8842 else if (element == EL_PENGUIN)
8843 TestIfFriendTouchesBadThing(newx, newy);
8845 if (DONT_GET_HIT_BY(element))
8847 TestIfGoodThingGetsHitByBadThing(newx, newy, direction);
8850 // give the player one last chance (one more frame) to move away
8851 if (CAN_FALL(element) && direction == MV_DOWN &&
8852 (last_line || (!IS_FREE(x, newy + 1) &&
8853 (!IS_PLAYER(x, newy + 1) ||
8854 game.engine_version < VERSION_IDENT(3,1,1,0)))))
8857 if (pushed_by_player && !game.use_change_when_pushing_bug)
8859 int push_side = MV_DIR_OPPOSITE(direction);
8860 struct PlayerInfo *player = PLAYERINFO(x, y);
8862 CheckElementChangeByPlayer(newx, newy, element, CE_PUSHED_BY_PLAYER,
8863 player->index_bit, push_side);
8864 CheckTriggeredElementChangeByPlayer(newx,newy, element, CE_PLAYER_PUSHES_X,
8865 player->index_bit, push_side);
8868 if (element == EL_EMC_ANDROID && pushed_by_player) // make another move
8869 MovDelay[newx][newy] = 1;
8871 CheckTriggeredElementChangeBySide(x, y, element, CE_MOVE_OF_X, direction);
8873 TestIfElementTouchesCustomElement(x, y); // empty or new element
8874 TestIfElementHitsCustomElement(newx, newy, direction);
8875 TestIfPlayerTouchesCustomElement(newx, newy);
8876 TestIfElementTouchesCustomElement(newx, newy);
8878 if (IS_CUSTOM_ELEMENT(element) && ei->move_enter_element != EL_EMPTY &&
8879 IS_EQUAL_OR_IN_GROUP(stored_new, ei->move_enter_element))
8880 CheckElementChangeBySide(newx, newy, element, stored_new, CE_DIGGING_X,
8881 MV_DIR_OPPOSITE(direction));
8884 int AmoebaNeighbourNr(int ax, int ay)
8887 int element = Tile[ax][ay];
8889 static int xy[4][2] =
8897 for (i = 0; i < NUM_DIRECTIONS; i++)
8899 int x = ax + xy[i][0];
8900 int y = ay + xy[i][1];
8902 if (!IN_LEV_FIELD(x, y))
8905 if (Tile[x][y] == element && AmoebaNr[x][y] > 0)
8906 group_nr = AmoebaNr[x][y];
8912 static void AmoebaMerge(int ax, int ay)
8914 int i, x, y, xx, yy;
8915 int new_group_nr = AmoebaNr[ax][ay];
8916 static int xy[4][2] =
8924 if (new_group_nr == 0)
8927 for (i = 0; i < NUM_DIRECTIONS; i++)
8932 if (!IN_LEV_FIELD(x, y))
8935 if ((Tile[x][y] == EL_AMOEBA_FULL ||
8936 Tile[x][y] == EL_BD_AMOEBA ||
8937 Tile[x][y] == EL_AMOEBA_DEAD) &&
8938 AmoebaNr[x][y] != new_group_nr)
8940 int old_group_nr = AmoebaNr[x][y];
8942 if (old_group_nr == 0)
8945 AmoebaCnt[new_group_nr] += AmoebaCnt[old_group_nr];
8946 AmoebaCnt[old_group_nr] = 0;
8947 AmoebaCnt2[new_group_nr] += AmoebaCnt2[old_group_nr];
8948 AmoebaCnt2[old_group_nr] = 0;
8950 SCAN_PLAYFIELD(xx, yy)
8952 if (AmoebaNr[xx][yy] == old_group_nr)
8953 AmoebaNr[xx][yy] = new_group_nr;
8959 void AmoebaToDiamond(int ax, int ay)
8963 if (Tile[ax][ay] == EL_AMOEBA_DEAD)
8965 int group_nr = AmoebaNr[ax][ay];
8970 Debug("game:playing:AmoebaToDiamond", "ax = %d, ay = %d", ax, ay);
8971 Debug("game:playing:AmoebaToDiamond", "This should never happen!");
8977 SCAN_PLAYFIELD(x, y)
8979 if (Tile[x][y] == EL_AMOEBA_DEAD && AmoebaNr[x][y] == group_nr)
8982 Tile[x][y] = EL_AMOEBA_TO_DIAMOND;
8986 PlayLevelSound(ax, ay, (IS_GEM(level.amoeba_content) ?
8987 SND_AMOEBA_TURNING_TO_GEM :
8988 SND_AMOEBA_TURNING_TO_ROCK));
8993 static int xy[4][2] =
9001 for (i = 0; i < NUM_DIRECTIONS; i++)
9006 if (!IN_LEV_FIELD(x, y))
9009 if (Tile[x][y] == EL_AMOEBA_TO_DIAMOND)
9011 PlayLevelSound(x, y, (IS_GEM(level.amoeba_content) ?
9012 SND_AMOEBA_TURNING_TO_GEM :
9013 SND_AMOEBA_TURNING_TO_ROCK));
9020 static void AmoebaToDiamondBD(int ax, int ay, int new_element)
9023 int group_nr = AmoebaNr[ax][ay];
9024 boolean done = FALSE;
9029 Debug("game:playing:AmoebaToDiamondBD", "ax = %d, ay = %d", ax, ay);
9030 Debug("game:playing:AmoebaToDiamondBD", "This should never happen!");
9036 SCAN_PLAYFIELD(x, y)
9038 if (AmoebaNr[x][y] == group_nr &&
9039 (Tile[x][y] == EL_AMOEBA_DEAD ||
9040 Tile[x][y] == EL_BD_AMOEBA ||
9041 Tile[x][y] == EL_AMOEBA_GROWING))
9044 Tile[x][y] = new_element;
9045 InitField(x, y, FALSE);
9046 TEST_DrawLevelField(x, y);
9052 PlayLevelSound(ax, ay, (new_element == EL_BD_ROCK ?
9053 SND_BD_AMOEBA_TURNING_TO_ROCK :
9054 SND_BD_AMOEBA_TURNING_TO_GEM));
9057 static void AmoebaGrowing(int x, int y)
9059 static unsigned int sound_delay = 0;
9060 static unsigned int sound_delay_value = 0;
9062 if (!MovDelay[x][y]) // start new growing cycle
9066 if (DelayReached(&sound_delay, sound_delay_value))
9068 PlayLevelSoundElementAction(x, y, Store[x][y], ACTION_GROWING);
9069 sound_delay_value = 30;
9073 if (MovDelay[x][y]) // wait some time before growing bigger
9076 if (MovDelay[x][y]/2 && IN_SCR_FIELD(SCREENX(x), SCREENY(y)))
9078 int frame = getGraphicAnimationFrame(IMG_AMOEBA_GROWING,
9079 6 - MovDelay[x][y]);
9081 DrawGraphic(SCREENX(x), SCREENY(y), IMG_AMOEBA_GROWING, frame);
9084 if (!MovDelay[x][y])
9086 Tile[x][y] = Store[x][y];
9088 TEST_DrawLevelField(x, y);
9093 static void AmoebaShrinking(int x, int y)
9095 static unsigned int sound_delay = 0;
9096 static unsigned int sound_delay_value = 0;
9098 if (!MovDelay[x][y]) // start new shrinking cycle
9102 if (DelayReached(&sound_delay, sound_delay_value))
9103 sound_delay_value = 30;
9106 if (MovDelay[x][y]) // wait some time before shrinking
9109 if (MovDelay[x][y]/2 && IN_SCR_FIELD(SCREENX(x), SCREENY(y)))
9111 int frame = getGraphicAnimationFrame(IMG_AMOEBA_SHRINKING,
9112 6 - MovDelay[x][y]);
9114 DrawGraphic(SCREENX(x), SCREENY(y), IMG_AMOEBA_SHRINKING, frame);
9117 if (!MovDelay[x][y])
9119 Tile[x][y] = EL_EMPTY;
9120 TEST_DrawLevelField(x, y);
9122 // don't let mole enter this field in this cycle;
9123 // (give priority to objects falling to this field from above)
9129 static void AmoebaReproduce(int ax, int ay)
9132 int element = Tile[ax][ay];
9133 int graphic = el2img(element);
9134 int newax = ax, neway = ay;
9135 boolean can_drop = (element == EL_AMOEBA_WET || element == EL_EMC_DRIPPER);
9136 static int xy[4][2] =
9144 if (!level.amoeba_speed && element != EL_EMC_DRIPPER)
9146 Tile[ax][ay] = EL_AMOEBA_DEAD;
9147 TEST_DrawLevelField(ax, ay);
9151 if (IS_ANIMATED(graphic))
9152 DrawLevelGraphicAnimationIfNeeded(ax, ay, graphic);
9154 if (!MovDelay[ax][ay]) // start making new amoeba field
9155 MovDelay[ax][ay] = RND(FRAMES_PER_SECOND * 25 / (1 + level.amoeba_speed));
9157 if (MovDelay[ax][ay]) // wait some time before making new amoeba
9160 if (MovDelay[ax][ay])
9164 if (can_drop) // EL_AMOEBA_WET or EL_EMC_DRIPPER
9167 int x = ax + xy[start][0];
9168 int y = ay + xy[start][1];
9170 if (!IN_LEV_FIELD(x, y))
9173 if (IS_FREE(x, y) ||
9174 CAN_GROW_INTO(Tile[x][y]) ||
9175 Tile[x][y] == EL_QUICKSAND_EMPTY ||
9176 Tile[x][y] == EL_QUICKSAND_FAST_EMPTY)
9182 if (newax == ax && neway == ay)
9185 else // normal or "filled" (BD style) amoeba
9188 boolean waiting_for_player = FALSE;
9190 for (i = 0; i < NUM_DIRECTIONS; i++)
9192 int j = (start + i) % 4;
9193 int x = ax + xy[j][0];
9194 int y = ay + xy[j][1];
9196 if (!IN_LEV_FIELD(x, y))
9199 if (IS_FREE(x, y) ||
9200 CAN_GROW_INTO(Tile[x][y]) ||
9201 Tile[x][y] == EL_QUICKSAND_EMPTY ||
9202 Tile[x][y] == EL_QUICKSAND_FAST_EMPTY)
9208 else if (IS_PLAYER(x, y))
9209 waiting_for_player = TRUE;
9212 if (newax == ax && neway == ay) // amoeba cannot grow
9214 if (i == 4 && (!waiting_for_player || element == EL_BD_AMOEBA))
9216 Tile[ax][ay] = EL_AMOEBA_DEAD;
9217 TEST_DrawLevelField(ax, ay);
9218 AmoebaCnt[AmoebaNr[ax][ay]]--;
9220 if (AmoebaCnt[AmoebaNr[ax][ay]] <= 0) // amoeba is completely dead
9222 if (element == EL_AMOEBA_FULL)
9223 AmoebaToDiamond(ax, ay);
9224 else if (element == EL_BD_AMOEBA)
9225 AmoebaToDiamondBD(ax, ay, level.amoeba_content);
9230 else if (element == EL_AMOEBA_FULL || element == EL_BD_AMOEBA)
9232 // amoeba gets larger by growing in some direction
9234 int new_group_nr = AmoebaNr[ax][ay];
9237 if (new_group_nr == 0)
9239 Debug("game:playing:AmoebaReproduce", "newax = %d, neway = %d",
9241 Debug("game:playing:AmoebaReproduce", "This should never happen!");
9247 AmoebaNr[newax][neway] = new_group_nr;
9248 AmoebaCnt[new_group_nr]++;
9249 AmoebaCnt2[new_group_nr]++;
9251 // if amoeba touches other amoeba(s) after growing, unify them
9252 AmoebaMerge(newax, neway);
9254 if (element == EL_BD_AMOEBA && AmoebaCnt2[new_group_nr] >= 200)
9256 AmoebaToDiamondBD(newax, neway, EL_BD_ROCK);
9262 if (!can_drop || neway < ay || !IS_FREE(newax, neway) ||
9263 (neway == lev_fieldy - 1 && newax != ax))
9265 Tile[newax][neway] = EL_AMOEBA_GROWING; // creation of new amoeba
9266 Store[newax][neway] = element;
9268 else if (neway == ay || element == EL_EMC_DRIPPER)
9270 Tile[newax][neway] = EL_AMOEBA_DROP; // drop left/right of amoeba
9272 PlayLevelSoundAction(newax, neway, ACTION_GROWING);
9276 InitMovingField(ax, ay, MV_DOWN); // drop dripping from amoeba
9277 Tile[ax][ay] = EL_AMOEBA_DROPPING;
9278 Store[ax][ay] = EL_AMOEBA_DROP;
9279 ContinueMoving(ax, ay);
9283 TEST_DrawLevelField(newax, neway);
9286 static void Life(int ax, int ay)
9290 int element = Tile[ax][ay];
9291 int graphic = el2img(element);
9292 int *life_parameter = (element == EL_GAME_OF_LIFE ? level.game_of_life :
9294 boolean changed = FALSE;
9296 if (IS_ANIMATED(graphic))
9297 DrawLevelGraphicAnimationIfNeeded(ax, ay, graphic);
9302 if (!MovDelay[ax][ay]) // start new "game of life" cycle
9303 MovDelay[ax][ay] = life_time;
9305 if (MovDelay[ax][ay]) // wait some time before next cycle
9308 if (MovDelay[ax][ay])
9312 for (y1 = -1; y1 < 2; y1++) for (x1 = -1; x1 < 2; x1++)
9314 int xx = ax+x1, yy = ay+y1;
9315 int old_element = Tile[xx][yy];
9316 int num_neighbours = 0;
9318 if (!IN_LEV_FIELD(xx, yy))
9321 for (y2 = -1; y2 < 2; y2++) for (x2 = -1; x2 < 2; x2++)
9323 int x = xx+x2, y = yy+y2;
9325 if (!IN_LEV_FIELD(x, y) || (x == xx && y == yy))
9328 boolean is_player_cell = (element == EL_GAME_OF_LIFE && IS_PLAYER(x, y));
9329 boolean is_neighbour = FALSE;
9331 if (level.use_life_bugs)
9333 (((Tile[x][y] == element || is_player_cell) && !Stop[x][y]) ||
9334 (IS_FREE(x, y) && Stop[x][y]));
9337 (Last[x][y] == element || is_player_cell);
9343 boolean is_free = FALSE;
9345 if (level.use_life_bugs)
9346 is_free = (IS_FREE(xx, yy));
9348 is_free = (IS_FREE(xx, yy) && Last[xx][yy] == EL_EMPTY);
9350 if (xx == ax && yy == ay) // field in the middle
9352 if (num_neighbours < life_parameter[0] ||
9353 num_neighbours > life_parameter[1])
9355 Tile[xx][yy] = EL_EMPTY;
9356 if (Tile[xx][yy] != old_element)
9357 TEST_DrawLevelField(xx, yy);
9358 Stop[xx][yy] = TRUE;
9362 else if (is_free || CAN_GROW_INTO(Tile[xx][yy]))
9363 { // free border field
9364 if (num_neighbours >= life_parameter[2] &&
9365 num_neighbours <= life_parameter[3])
9367 Tile[xx][yy] = element;
9368 MovDelay[xx][yy] = (element == EL_GAME_OF_LIFE ? 0 : life_time-1);
9369 if (Tile[xx][yy] != old_element)
9370 TEST_DrawLevelField(xx, yy);
9371 Stop[xx][yy] = TRUE;
9378 PlayLevelSound(ax, ay, element == EL_BIOMAZE ? SND_BIOMAZE_GROWING :
9379 SND_GAME_OF_LIFE_GROWING);
9382 static void InitRobotWheel(int x, int y)
9384 ChangeDelay[x][y] = level.time_wheel * FRAMES_PER_SECOND;
9387 static void RunRobotWheel(int x, int y)
9389 PlayLevelSound(x, y, SND_ROBOT_WHEEL_ACTIVE);
9392 static void StopRobotWheel(int x, int y)
9394 if (game.robot_wheel_x == x &&
9395 game.robot_wheel_y == y)
9397 game.robot_wheel_x = -1;
9398 game.robot_wheel_y = -1;
9399 game.robot_wheel_active = FALSE;
9403 static void InitTimegateWheel(int x, int y)
9405 ChangeDelay[x][y] = level.time_timegate * FRAMES_PER_SECOND;
9408 static void RunTimegateWheel(int x, int y)
9410 PlayLevelSound(x, y, SND_CLASS_TIMEGATE_SWITCH_ACTIVE);
9413 static void InitMagicBallDelay(int x, int y)
9415 ChangeDelay[x][y] = (level.ball_time + 1) * 8 + 1;
9418 static void ActivateMagicBall(int bx, int by)
9422 if (level.ball_random)
9424 int pos_border = RND(8); // select one of the eight border elements
9425 int pos_content = (pos_border > 3 ? pos_border + 1 : pos_border);
9426 int xx = pos_content % 3;
9427 int yy = pos_content / 3;
9432 if (IN_LEV_FIELD(x, y) && Tile[x][y] == EL_EMPTY)
9433 CreateField(x, y, level.ball_content[game.ball_content_nr].e[xx][yy]);
9437 for (y = by - 1; y <= by + 1; y++) for (x = bx - 1; x <= bx + 1; x++)
9439 int xx = x - bx + 1;
9440 int yy = y - by + 1;
9442 if (IN_LEV_FIELD(x, y) && Tile[x][y] == EL_EMPTY)
9443 CreateField(x, y, level.ball_content[game.ball_content_nr].e[xx][yy]);
9447 game.ball_content_nr = (game.ball_content_nr + 1) % level.num_ball_contents;
9450 static void CheckExit(int x, int y)
9452 if (game.gems_still_needed > 0 ||
9453 game.sokoban_fields_still_needed > 0 ||
9454 game.sokoban_objects_still_needed > 0 ||
9455 game.lights_still_needed > 0)
9457 int element = Tile[x][y];
9458 int graphic = el2img(element);
9460 if (IS_ANIMATED(graphic))
9461 DrawLevelGraphicAnimationIfNeeded(x, y, graphic);
9466 // do not re-open exit door closed after last player
9467 if (game.all_players_gone)
9470 Tile[x][y] = EL_EXIT_OPENING;
9472 PlayLevelSoundNearest(x, y, SND_CLASS_EXIT_OPENING);
9475 static void CheckExitEM(int x, int y)
9477 if (game.gems_still_needed > 0 ||
9478 game.sokoban_fields_still_needed > 0 ||
9479 game.sokoban_objects_still_needed > 0 ||
9480 game.lights_still_needed > 0)
9482 int element = Tile[x][y];
9483 int graphic = el2img(element);
9485 if (IS_ANIMATED(graphic))
9486 DrawLevelGraphicAnimationIfNeeded(x, y, graphic);
9491 // do not re-open exit door closed after last player
9492 if (game.all_players_gone)
9495 Tile[x][y] = EL_EM_EXIT_OPENING;
9497 PlayLevelSoundNearest(x, y, SND_CLASS_EM_EXIT_OPENING);
9500 static void CheckExitSteel(int x, int y)
9502 if (game.gems_still_needed > 0 ||
9503 game.sokoban_fields_still_needed > 0 ||
9504 game.sokoban_objects_still_needed > 0 ||
9505 game.lights_still_needed > 0)
9507 int element = Tile[x][y];
9508 int graphic = el2img(element);
9510 if (IS_ANIMATED(graphic))
9511 DrawLevelGraphicAnimationIfNeeded(x, y, graphic);
9516 // do not re-open exit door closed after last player
9517 if (game.all_players_gone)
9520 Tile[x][y] = EL_STEEL_EXIT_OPENING;
9522 PlayLevelSoundNearest(x, y, SND_CLASS_STEEL_EXIT_OPENING);
9525 static void CheckExitSteelEM(int x, int y)
9527 if (game.gems_still_needed > 0 ||
9528 game.sokoban_fields_still_needed > 0 ||
9529 game.sokoban_objects_still_needed > 0 ||
9530 game.lights_still_needed > 0)
9532 int element = Tile[x][y];
9533 int graphic = el2img(element);
9535 if (IS_ANIMATED(graphic))
9536 DrawLevelGraphicAnimationIfNeeded(x, y, graphic);
9541 // do not re-open exit door closed after last player
9542 if (game.all_players_gone)
9545 Tile[x][y] = EL_EM_STEEL_EXIT_OPENING;
9547 PlayLevelSoundNearest(x, y, SND_CLASS_EM_STEEL_EXIT_OPENING);
9550 static void CheckExitSP(int x, int y)
9552 if (game.gems_still_needed > 0)
9554 int element = Tile[x][y];
9555 int graphic = el2img(element);
9557 if (IS_ANIMATED(graphic))
9558 DrawLevelGraphicAnimationIfNeeded(x, y, graphic);
9563 // do not re-open exit door closed after last player
9564 if (game.all_players_gone)
9567 Tile[x][y] = EL_SP_EXIT_OPENING;
9569 PlayLevelSoundNearest(x, y, SND_CLASS_SP_EXIT_OPENING);
9572 static void CloseAllOpenTimegates(void)
9576 SCAN_PLAYFIELD(x, y)
9578 int element = Tile[x][y];
9580 if (element == EL_TIMEGATE_OPEN || element == EL_TIMEGATE_OPENING)
9582 Tile[x][y] = EL_TIMEGATE_CLOSING;
9584 PlayLevelSoundAction(x, y, ACTION_CLOSING);
9589 static void DrawTwinkleOnField(int x, int y)
9591 if (!IN_SCR_FIELD(SCREENX(x), SCREENY(y)) || IS_MOVING(x, y))
9594 if (Tile[x][y] == EL_BD_DIAMOND)
9597 if (MovDelay[x][y] == 0) // next animation frame
9598 MovDelay[x][y] = 11 * !GetSimpleRandom(500);
9600 if (MovDelay[x][y] != 0) // wait some time before next frame
9604 DrawLevelElementAnimation(x, y, Tile[x][y]);
9606 if (MovDelay[x][y] != 0)
9608 int frame = getGraphicAnimationFrame(IMG_TWINKLE_WHITE,
9609 10 - MovDelay[x][y]);
9611 DrawGraphicThruMask(SCREENX(x), SCREENY(y), IMG_TWINKLE_WHITE, frame);
9616 static void MauerWaechst(int x, int y)
9620 if (!MovDelay[x][y]) // next animation frame
9621 MovDelay[x][y] = 3 * delay;
9623 if (MovDelay[x][y]) // wait some time before next frame
9627 if (IN_SCR_FIELD(SCREENX(x), SCREENY(y)))
9629 int graphic = el_dir2img(Tile[x][y], GfxDir[x][y]);
9630 int frame = getGraphicAnimationFrame(graphic, 17 - MovDelay[x][y]);
9632 DrawGraphic(SCREENX(x), SCREENY(y), graphic, frame);
9635 if (!MovDelay[x][y])
9637 if (MovDir[x][y] == MV_LEFT)
9639 if (IN_LEV_FIELD(x - 1, y) && IS_WALL(Tile[x - 1][y]))
9640 TEST_DrawLevelField(x - 1, y);
9642 else if (MovDir[x][y] == MV_RIGHT)
9644 if (IN_LEV_FIELD(x + 1, y) && IS_WALL(Tile[x + 1][y]))
9645 TEST_DrawLevelField(x + 1, y);
9647 else if (MovDir[x][y] == MV_UP)
9649 if (IN_LEV_FIELD(x, y - 1) && IS_WALL(Tile[x][y - 1]))
9650 TEST_DrawLevelField(x, y - 1);
9654 if (IN_LEV_FIELD(x, y + 1) && IS_WALL(Tile[x][y + 1]))
9655 TEST_DrawLevelField(x, y + 1);
9658 Tile[x][y] = Store[x][y];
9660 GfxDir[x][y] = MovDir[x][y] = MV_NONE;
9661 TEST_DrawLevelField(x, y);
9666 static void MauerAbleger(int ax, int ay)
9668 int element = Tile[ax][ay];
9669 int graphic = el2img(element);
9670 boolean oben_frei = FALSE, unten_frei = FALSE;
9671 boolean links_frei = FALSE, rechts_frei = FALSE;
9672 boolean oben_massiv = FALSE, unten_massiv = FALSE;
9673 boolean links_massiv = FALSE, rechts_massiv = FALSE;
9674 boolean new_wall = FALSE;
9676 if (IS_ANIMATED(graphic))
9677 DrawLevelGraphicAnimationIfNeeded(ax, ay, graphic);
9679 if (!MovDelay[ax][ay]) // start building new wall
9680 MovDelay[ax][ay] = 6;
9682 if (MovDelay[ax][ay]) // wait some time before building new wall
9685 if (MovDelay[ax][ay])
9689 if (IN_LEV_FIELD(ax, ay-1) && IS_FREE(ax, ay-1))
9691 if (IN_LEV_FIELD(ax, ay+1) && IS_FREE(ax, ay+1))
9693 if (IN_LEV_FIELD(ax-1, ay) && IS_FREE(ax-1, ay))
9695 if (IN_LEV_FIELD(ax+1, ay) && IS_FREE(ax+1, ay))
9698 if (element == EL_EXPANDABLE_WALL_VERTICAL ||
9699 element == EL_EXPANDABLE_WALL_ANY)
9703 Tile[ax][ay-1] = EL_EXPANDABLE_WALL_GROWING;
9704 Store[ax][ay-1] = element;
9705 GfxDir[ax][ay-1] = MovDir[ax][ay-1] = MV_UP;
9706 if (IN_SCR_FIELD(SCREENX(ax), SCREENY(ay-1)))
9707 DrawGraphic(SCREENX(ax), SCREENY(ay - 1),
9708 IMG_EXPANDABLE_WALL_GROWING_UP, 0);
9713 Tile[ax][ay+1] = EL_EXPANDABLE_WALL_GROWING;
9714 Store[ax][ay+1] = element;
9715 GfxDir[ax][ay+1] = MovDir[ax][ay+1] = MV_DOWN;
9716 if (IN_SCR_FIELD(SCREENX(ax), SCREENY(ay+1)))
9717 DrawGraphic(SCREENX(ax), SCREENY(ay + 1),
9718 IMG_EXPANDABLE_WALL_GROWING_DOWN, 0);
9723 if (element == EL_EXPANDABLE_WALL_HORIZONTAL ||
9724 element == EL_EXPANDABLE_WALL_ANY ||
9725 element == EL_EXPANDABLE_WALL ||
9726 element == EL_BD_EXPANDABLE_WALL)
9730 Tile[ax-1][ay] = EL_EXPANDABLE_WALL_GROWING;
9731 Store[ax-1][ay] = element;
9732 GfxDir[ax-1][ay] = MovDir[ax-1][ay] = MV_LEFT;
9733 if (IN_SCR_FIELD(SCREENX(ax-1), SCREENY(ay)))
9734 DrawGraphic(SCREENX(ax - 1), SCREENY(ay),
9735 IMG_EXPANDABLE_WALL_GROWING_LEFT, 0);
9741 Tile[ax+1][ay] = EL_EXPANDABLE_WALL_GROWING;
9742 Store[ax+1][ay] = element;
9743 GfxDir[ax+1][ay] = MovDir[ax+1][ay] = MV_RIGHT;
9744 if (IN_SCR_FIELD(SCREENX(ax+1), SCREENY(ay)))
9745 DrawGraphic(SCREENX(ax + 1), SCREENY(ay),
9746 IMG_EXPANDABLE_WALL_GROWING_RIGHT, 0);
9751 if (element == EL_EXPANDABLE_WALL && (links_frei || rechts_frei))
9752 TEST_DrawLevelField(ax, ay);
9754 if (!IN_LEV_FIELD(ax, ay-1) || IS_WALL(Tile[ax][ay-1]))
9756 if (!IN_LEV_FIELD(ax, ay+1) || IS_WALL(Tile[ax][ay+1]))
9757 unten_massiv = TRUE;
9758 if (!IN_LEV_FIELD(ax-1, ay) || IS_WALL(Tile[ax-1][ay]))
9759 links_massiv = TRUE;
9760 if (!IN_LEV_FIELD(ax+1, ay) || IS_WALL(Tile[ax+1][ay]))
9761 rechts_massiv = TRUE;
9763 if (((oben_massiv && unten_massiv) ||
9764 element == EL_EXPANDABLE_WALL_HORIZONTAL ||
9765 element == EL_EXPANDABLE_WALL) &&
9766 ((links_massiv && rechts_massiv) ||
9767 element == EL_EXPANDABLE_WALL_VERTICAL))
9768 Tile[ax][ay] = EL_WALL;
9771 PlayLevelSoundAction(ax, ay, ACTION_GROWING);
9774 static void MauerAblegerStahl(int ax, int ay)
9776 int element = Tile[ax][ay];
9777 int graphic = el2img(element);
9778 boolean oben_frei = FALSE, unten_frei = FALSE;
9779 boolean links_frei = FALSE, rechts_frei = FALSE;
9780 boolean oben_massiv = FALSE, unten_massiv = FALSE;
9781 boolean links_massiv = FALSE, rechts_massiv = FALSE;
9782 boolean new_wall = FALSE;
9784 if (IS_ANIMATED(graphic))
9785 DrawLevelGraphicAnimationIfNeeded(ax, ay, graphic);
9787 if (!MovDelay[ax][ay]) // start building new wall
9788 MovDelay[ax][ay] = 6;
9790 if (MovDelay[ax][ay]) // wait some time before building new wall
9793 if (MovDelay[ax][ay])
9797 if (IN_LEV_FIELD(ax, ay-1) && IS_FREE(ax, ay-1))
9799 if (IN_LEV_FIELD(ax, ay+1) && IS_FREE(ax, ay+1))
9801 if (IN_LEV_FIELD(ax-1, ay) && IS_FREE(ax-1, ay))
9803 if (IN_LEV_FIELD(ax+1, ay) && IS_FREE(ax+1, ay))
9806 if (element == EL_EXPANDABLE_STEELWALL_VERTICAL ||
9807 element == EL_EXPANDABLE_STEELWALL_ANY)
9811 Tile[ax][ay-1] = EL_EXPANDABLE_STEELWALL_GROWING;
9812 Store[ax][ay-1] = element;
9813 GfxDir[ax][ay-1] = MovDir[ax][ay-1] = MV_UP;
9814 if (IN_SCR_FIELD(SCREENX(ax), SCREENY(ay-1)))
9815 DrawGraphic(SCREENX(ax), SCREENY(ay - 1),
9816 IMG_EXPANDABLE_STEELWALL_GROWING_UP, 0);
9821 Tile[ax][ay+1] = EL_EXPANDABLE_STEELWALL_GROWING;
9822 Store[ax][ay+1] = element;
9823 GfxDir[ax][ay+1] = MovDir[ax][ay+1] = MV_DOWN;
9824 if (IN_SCR_FIELD(SCREENX(ax), SCREENY(ay+1)))
9825 DrawGraphic(SCREENX(ax), SCREENY(ay + 1),
9826 IMG_EXPANDABLE_STEELWALL_GROWING_DOWN, 0);
9831 if (element == EL_EXPANDABLE_STEELWALL_HORIZONTAL ||
9832 element == EL_EXPANDABLE_STEELWALL_ANY)
9836 Tile[ax-1][ay] = EL_EXPANDABLE_STEELWALL_GROWING;
9837 Store[ax-1][ay] = element;
9838 GfxDir[ax-1][ay] = MovDir[ax-1][ay] = MV_LEFT;
9839 if (IN_SCR_FIELD(SCREENX(ax-1), SCREENY(ay)))
9840 DrawGraphic(SCREENX(ax - 1), SCREENY(ay),
9841 IMG_EXPANDABLE_STEELWALL_GROWING_LEFT, 0);
9847 Tile[ax+1][ay] = EL_EXPANDABLE_STEELWALL_GROWING;
9848 Store[ax+1][ay] = element;
9849 GfxDir[ax+1][ay] = MovDir[ax+1][ay] = MV_RIGHT;
9850 if (IN_SCR_FIELD(SCREENX(ax+1), SCREENY(ay)))
9851 DrawGraphic(SCREENX(ax + 1), SCREENY(ay),
9852 IMG_EXPANDABLE_STEELWALL_GROWING_RIGHT, 0);
9857 if (!IN_LEV_FIELD(ax, ay-1) || IS_WALL(Tile[ax][ay-1]))
9859 if (!IN_LEV_FIELD(ax, ay+1) || IS_WALL(Tile[ax][ay+1]))
9860 unten_massiv = TRUE;
9861 if (!IN_LEV_FIELD(ax-1, ay) || IS_WALL(Tile[ax-1][ay]))
9862 links_massiv = TRUE;
9863 if (!IN_LEV_FIELD(ax+1, ay) || IS_WALL(Tile[ax+1][ay]))
9864 rechts_massiv = TRUE;
9866 if (((oben_massiv && unten_massiv) ||
9867 element == EL_EXPANDABLE_STEELWALL_HORIZONTAL) &&
9868 ((links_massiv && rechts_massiv) ||
9869 element == EL_EXPANDABLE_STEELWALL_VERTICAL))
9870 Tile[ax][ay] = EL_STEELWALL;
9873 PlayLevelSoundAction(ax, ay, ACTION_GROWING);
9876 static void CheckForDragon(int x, int y)
9879 boolean dragon_found = FALSE;
9880 static int xy[4][2] =
9888 for (i = 0; i < NUM_DIRECTIONS; i++)
9890 for (j = 0; j < 4; j++)
9892 int xx = x + j * xy[i][0], yy = y + j * xy[i][1];
9894 if (IN_LEV_FIELD(xx, yy) &&
9895 (Tile[xx][yy] == EL_FLAMES || Tile[xx][yy] == EL_DRAGON))
9897 if (Tile[xx][yy] == EL_DRAGON)
9898 dragon_found = TRUE;
9907 for (i = 0; i < NUM_DIRECTIONS; i++)
9909 for (j = 0; j < 3; j++)
9911 int xx = x + j * xy[i][0], yy = y + j * xy[i][1];
9913 if (IN_LEV_FIELD(xx, yy) && Tile[xx][yy] == EL_FLAMES)
9915 Tile[xx][yy] = EL_EMPTY;
9916 TEST_DrawLevelField(xx, yy);
9925 static void InitBuggyBase(int x, int y)
9927 int element = Tile[x][y];
9928 int activating_delay = FRAMES_PER_SECOND / 4;
9931 (element == EL_SP_BUGGY_BASE ?
9932 2 * FRAMES_PER_SECOND + RND(5 * FRAMES_PER_SECOND) - activating_delay :
9933 element == EL_SP_BUGGY_BASE_ACTIVATING ?
9935 element == EL_SP_BUGGY_BASE_ACTIVE ?
9936 1 * FRAMES_PER_SECOND + RND(1 * FRAMES_PER_SECOND) : 1);
9939 static void WarnBuggyBase(int x, int y)
9942 static int xy[4][2] =
9950 for (i = 0; i < NUM_DIRECTIONS; i++)
9952 int xx = x + xy[i][0];
9953 int yy = y + xy[i][1];
9955 if (IN_LEV_FIELD(xx, yy) && IS_PLAYER(xx, yy))
9957 PlayLevelSound(x, y, SND_SP_BUGGY_BASE_ACTIVE);
9964 static void InitTrap(int x, int y)
9966 ChangeDelay[x][y] = 2 * FRAMES_PER_SECOND + RND(5 * FRAMES_PER_SECOND);
9969 static void ActivateTrap(int x, int y)
9971 PlayLevelSound(x, y, SND_TRAP_ACTIVATING);
9974 static void ChangeActiveTrap(int x, int y)
9976 int graphic = IMG_TRAP_ACTIVE;
9978 // if new animation frame was drawn, correct crumbled sand border
9979 if (IS_NEW_FRAME(GfxFrame[x][y], graphic))
9980 TEST_DrawLevelFieldCrumbled(x, y);
9983 static int getSpecialActionElement(int element, int number, int base_element)
9985 return (element != EL_EMPTY ? element :
9986 number != -1 ? base_element + number - 1 :
9990 static int getModifiedActionNumber(int value_old, int operator, int operand,
9991 int value_min, int value_max)
9993 int value_new = (operator == CA_MODE_SET ? operand :
9994 operator == CA_MODE_ADD ? value_old + operand :
9995 operator == CA_MODE_SUBTRACT ? value_old - operand :
9996 operator == CA_MODE_MULTIPLY ? value_old * operand :
9997 operator == CA_MODE_DIVIDE ? value_old / MAX(1, operand) :
9998 operator == CA_MODE_MODULO ? value_old % MAX(1, operand) :
10001 return (value_new < value_min ? value_min :
10002 value_new > value_max ? value_max :
10006 static void ExecuteCustomElementAction(int x, int y, int element, int page)
10008 struct ElementInfo *ei = &element_info[element];
10009 struct ElementChangeInfo *change = &ei->change_page[page];
10010 int target_element = change->target_element;
10011 int action_type = change->action_type;
10012 int action_mode = change->action_mode;
10013 int action_arg = change->action_arg;
10014 int action_element = change->action_element;
10017 if (!change->has_action)
10020 // ---------- determine action paramater values -----------------------------
10022 int level_time_value =
10023 (level.time > 0 ? TimeLeft :
10026 int action_arg_element_raw =
10027 (action_arg == CA_ARG_PLAYER_TRIGGER ? change->actual_trigger_player :
10028 action_arg == CA_ARG_ELEMENT_TRIGGER ? change->actual_trigger_element :
10029 action_arg == CA_ARG_ELEMENT_TARGET ? change->target_element :
10030 action_arg == CA_ARG_ELEMENT_ACTION ? change->action_element :
10031 action_arg == CA_ARG_INVENTORY_RM_TRIGGER ? change->actual_trigger_element:
10032 action_arg == CA_ARG_INVENTORY_RM_TARGET ? change->target_element :
10033 action_arg == CA_ARG_INVENTORY_RM_ACTION ? change->action_element :
10035 int action_arg_element = GetElementFromGroupElement(action_arg_element_raw);
10037 int action_arg_direction =
10038 (action_arg >= CA_ARG_DIRECTION_LEFT &&
10039 action_arg <= CA_ARG_DIRECTION_DOWN ? action_arg - CA_ARG_DIRECTION :
10040 action_arg == CA_ARG_DIRECTION_TRIGGER ?
10041 change->actual_trigger_side :
10042 action_arg == CA_ARG_DIRECTION_TRIGGER_BACK ?
10043 MV_DIR_OPPOSITE(change->actual_trigger_side) :
10046 int action_arg_number_min =
10047 (action_type == CA_SET_PLAYER_SPEED ? STEPSIZE_NOT_MOVING :
10050 int action_arg_number_max =
10051 (action_type == CA_SET_PLAYER_SPEED ? STEPSIZE_EVEN_FASTER :
10052 action_type == CA_SET_LEVEL_GEMS ? 999 :
10053 action_type == CA_SET_LEVEL_TIME ? 9999 :
10054 action_type == CA_SET_LEVEL_SCORE ? 99999 :
10055 action_type == CA_SET_CE_VALUE ? 9999 :
10056 action_type == CA_SET_CE_SCORE ? 9999 :
10059 int action_arg_number_reset =
10060 (action_type == CA_SET_PLAYER_SPEED ? level.initial_player_stepsize[0] :
10061 action_type == CA_SET_LEVEL_GEMS ? level.gems_needed :
10062 action_type == CA_SET_LEVEL_TIME ? level.time :
10063 action_type == CA_SET_LEVEL_SCORE ? 0 :
10064 action_type == CA_SET_CE_VALUE ? GET_NEW_CE_VALUE(element) :
10065 action_type == CA_SET_CE_SCORE ? 0 :
10068 int action_arg_number =
10069 (action_arg <= CA_ARG_MAX ? action_arg :
10070 action_arg >= CA_ARG_SPEED_NOT_MOVING &&
10071 action_arg <= CA_ARG_SPEED_EVEN_FASTER ? (action_arg - CA_ARG_SPEED) :
10072 action_arg == CA_ARG_SPEED_RESET ? action_arg_number_reset :
10073 action_arg == CA_ARG_NUMBER_MIN ? action_arg_number_min :
10074 action_arg == CA_ARG_NUMBER_MAX ? action_arg_number_max :
10075 action_arg == CA_ARG_NUMBER_RESET ? action_arg_number_reset :
10076 action_arg == CA_ARG_NUMBER_CE_VALUE ? CustomValue[x][y] :
10077 action_arg == CA_ARG_NUMBER_CE_SCORE ? ei->collect_score :
10078 action_arg == CA_ARG_NUMBER_CE_DELAY ? GET_CE_DELAY_VALUE(change) :
10079 action_arg == CA_ARG_NUMBER_LEVEL_TIME ? level_time_value :
10080 action_arg == CA_ARG_NUMBER_LEVEL_GEMS ? game.gems_still_needed :
10081 action_arg == CA_ARG_NUMBER_LEVEL_SCORE ? game.score :
10082 action_arg == CA_ARG_ELEMENT_CV_TARGET ? GET_NEW_CE_VALUE(target_element):
10083 action_arg == CA_ARG_ELEMENT_CV_TRIGGER ? change->actual_trigger_ce_value:
10084 action_arg == CA_ARG_ELEMENT_CV_ACTION ? GET_NEW_CE_VALUE(action_element):
10085 action_arg == CA_ARG_ELEMENT_CS_TARGET ? GET_CE_SCORE(target_element) :
10086 action_arg == CA_ARG_ELEMENT_CS_TRIGGER ? change->actual_trigger_ce_score:
10087 action_arg == CA_ARG_ELEMENT_CS_ACTION ? GET_CE_SCORE(action_element) :
10088 action_arg == CA_ARG_ELEMENT_NR_TARGET ? change->target_element :
10089 action_arg == CA_ARG_ELEMENT_NR_TRIGGER ? change->actual_trigger_element :
10090 action_arg == CA_ARG_ELEMENT_NR_ACTION ? change->action_element :
10093 int action_arg_number_old =
10094 (action_type == CA_SET_LEVEL_GEMS ? game.gems_still_needed :
10095 action_type == CA_SET_LEVEL_TIME ? TimeLeft :
10096 action_type == CA_SET_LEVEL_SCORE ? game.score :
10097 action_type == CA_SET_CE_VALUE ? CustomValue[x][y] :
10098 action_type == CA_SET_CE_SCORE ? ei->collect_score :
10101 int action_arg_number_new =
10102 getModifiedActionNumber(action_arg_number_old,
10103 action_mode, action_arg_number,
10104 action_arg_number_min, action_arg_number_max);
10106 int trigger_player_bits =
10107 (change->actual_trigger_player_bits != CH_PLAYER_NONE ?
10108 change->actual_trigger_player_bits : change->trigger_player);
10110 int action_arg_player_bits =
10111 (action_arg >= CA_ARG_PLAYER_1 &&
10112 action_arg <= CA_ARG_PLAYER_4 ? action_arg - CA_ARG_PLAYER :
10113 action_arg == CA_ARG_PLAYER_TRIGGER ? trigger_player_bits :
10114 action_arg == CA_ARG_PLAYER_ACTION ? 1 << GET_PLAYER_NR(action_element) :
10117 // ---------- execute action -----------------------------------------------
10119 switch (action_type)
10126 // ---------- level actions ----------------------------------------------
10128 case CA_RESTART_LEVEL:
10130 game.restart_level = TRUE;
10135 case CA_SHOW_ENVELOPE:
10137 int element = getSpecialActionElement(action_arg_element,
10138 action_arg_number, EL_ENVELOPE_1);
10140 if (IS_ENVELOPE(element))
10141 local_player->show_envelope = element;
10146 case CA_SET_LEVEL_TIME:
10148 if (level.time > 0) // only modify limited time value
10150 TimeLeft = action_arg_number_new;
10152 game_panel_controls[GAME_PANEL_TIME].value = TimeLeft;
10154 DisplayGameControlValues();
10156 if (!TimeLeft && setup.time_limit)
10157 for (i = 0; i < MAX_PLAYERS; i++)
10158 KillPlayer(&stored_player[i]);
10164 case CA_SET_LEVEL_SCORE:
10166 game.score = action_arg_number_new;
10168 game_panel_controls[GAME_PANEL_SCORE].value = game.score;
10170 DisplayGameControlValues();
10175 case CA_SET_LEVEL_GEMS:
10177 game.gems_still_needed = action_arg_number_new;
10179 game.snapshot.collected_item = TRUE;
10181 game_panel_controls[GAME_PANEL_GEMS].value = game.gems_still_needed;
10183 DisplayGameControlValues();
10188 case CA_SET_LEVEL_WIND:
10190 game.wind_direction = action_arg_direction;
10195 case CA_SET_LEVEL_RANDOM_SEED:
10197 // ensure that setting a new random seed while playing is predictable
10198 InitRND(action_arg_number_new ? action_arg_number_new : RND(1000000) + 1);
10203 // ---------- player actions ---------------------------------------------
10205 case CA_MOVE_PLAYER:
10206 case CA_MOVE_PLAYER_NEW:
10208 // automatically move to the next field in specified direction
10209 for (i = 0; i < MAX_PLAYERS; i++)
10210 if (trigger_player_bits & (1 << i))
10211 if (action_type == CA_MOVE_PLAYER ||
10212 stored_player[i].MovPos == 0)
10213 stored_player[i].programmed_action = action_arg_direction;
10218 case CA_EXIT_PLAYER:
10220 for (i = 0; i < MAX_PLAYERS; i++)
10221 if (action_arg_player_bits & (1 << i))
10222 ExitPlayer(&stored_player[i]);
10224 if (game.players_still_needed == 0)
10230 case CA_KILL_PLAYER:
10232 for (i = 0; i < MAX_PLAYERS; i++)
10233 if (action_arg_player_bits & (1 << i))
10234 KillPlayer(&stored_player[i]);
10239 case CA_SET_PLAYER_KEYS:
10241 int key_state = (action_mode == CA_MODE_ADD ? TRUE : FALSE);
10242 int element = getSpecialActionElement(action_arg_element,
10243 action_arg_number, EL_KEY_1);
10245 if (IS_KEY(element))
10247 for (i = 0; i < MAX_PLAYERS; i++)
10249 if (trigger_player_bits & (1 << i))
10251 stored_player[i].key[KEY_NR(element)] = key_state;
10253 DrawGameDoorValues();
10261 case CA_SET_PLAYER_SPEED:
10263 for (i = 0; i < MAX_PLAYERS; i++)
10265 if (trigger_player_bits & (1 << i))
10267 int move_stepsize = TILEX / stored_player[i].move_delay_value;
10269 if (action_arg == CA_ARG_SPEED_FASTER &&
10270 stored_player[i].cannot_move)
10272 action_arg_number = STEPSIZE_VERY_SLOW;
10274 else if (action_arg == CA_ARG_SPEED_SLOWER ||
10275 action_arg == CA_ARG_SPEED_FASTER)
10277 action_arg_number = 2;
10278 action_mode = (action_arg == CA_ARG_SPEED_SLOWER ? CA_MODE_DIVIDE :
10281 else if (action_arg == CA_ARG_NUMBER_RESET)
10283 action_arg_number = level.initial_player_stepsize[i];
10287 getModifiedActionNumber(move_stepsize,
10290 action_arg_number_min,
10291 action_arg_number_max);
10293 SetPlayerMoveSpeed(&stored_player[i], move_stepsize, FALSE);
10300 case CA_SET_PLAYER_SHIELD:
10302 for (i = 0; i < MAX_PLAYERS; i++)
10304 if (trigger_player_bits & (1 << i))
10306 if (action_arg == CA_ARG_SHIELD_OFF)
10308 stored_player[i].shield_normal_time_left = 0;
10309 stored_player[i].shield_deadly_time_left = 0;
10311 else if (action_arg == CA_ARG_SHIELD_NORMAL)
10313 stored_player[i].shield_normal_time_left = 999999;
10315 else if (action_arg == CA_ARG_SHIELD_DEADLY)
10317 stored_player[i].shield_normal_time_left = 999999;
10318 stored_player[i].shield_deadly_time_left = 999999;
10326 case CA_SET_PLAYER_GRAVITY:
10328 for (i = 0; i < MAX_PLAYERS; i++)
10330 if (trigger_player_bits & (1 << i))
10332 stored_player[i].gravity =
10333 (action_arg == CA_ARG_GRAVITY_OFF ? FALSE :
10334 action_arg == CA_ARG_GRAVITY_ON ? TRUE :
10335 action_arg == CA_ARG_GRAVITY_TOGGLE ? !stored_player[i].gravity :
10336 stored_player[i].gravity);
10343 case CA_SET_PLAYER_ARTWORK:
10345 for (i = 0; i < MAX_PLAYERS; i++)
10347 if (trigger_player_bits & (1 << i))
10349 int artwork_element = action_arg_element;
10351 if (action_arg == CA_ARG_ELEMENT_RESET)
10353 (level.use_artwork_element[i] ? level.artwork_element[i] :
10354 stored_player[i].element_nr);
10356 if (stored_player[i].artwork_element != artwork_element)
10357 stored_player[i].Frame = 0;
10359 stored_player[i].artwork_element = artwork_element;
10361 SetPlayerWaiting(&stored_player[i], FALSE);
10363 // set number of special actions for bored and sleeping animation
10364 stored_player[i].num_special_action_bored =
10365 get_num_special_action(artwork_element,
10366 ACTION_BORING_1, ACTION_BORING_LAST);
10367 stored_player[i].num_special_action_sleeping =
10368 get_num_special_action(artwork_element,
10369 ACTION_SLEEPING_1, ACTION_SLEEPING_LAST);
10376 case CA_SET_PLAYER_INVENTORY:
10378 for (i = 0; i < MAX_PLAYERS; i++)
10380 struct PlayerInfo *player = &stored_player[i];
10383 if (trigger_player_bits & (1 << i))
10385 int inventory_element = action_arg_element;
10387 if (action_arg == CA_ARG_ELEMENT_TARGET ||
10388 action_arg == CA_ARG_ELEMENT_TRIGGER ||
10389 action_arg == CA_ARG_ELEMENT_ACTION)
10391 int element = inventory_element;
10392 int collect_count = element_info[element].collect_count_initial;
10394 if (!IS_CUSTOM_ELEMENT(element))
10397 if (collect_count == 0)
10398 player->inventory_infinite_element = element;
10400 for (k = 0; k < collect_count; k++)
10401 if (player->inventory_size < MAX_INVENTORY_SIZE)
10402 player->inventory_element[player->inventory_size++] =
10405 else if (action_arg == CA_ARG_INVENTORY_RM_TARGET ||
10406 action_arg == CA_ARG_INVENTORY_RM_TRIGGER ||
10407 action_arg == CA_ARG_INVENTORY_RM_ACTION)
10409 if (player->inventory_infinite_element != EL_UNDEFINED &&
10410 IS_EQUAL_OR_IN_GROUP(player->inventory_infinite_element,
10411 action_arg_element_raw))
10412 player->inventory_infinite_element = EL_UNDEFINED;
10414 for (k = 0, j = 0; j < player->inventory_size; j++)
10416 if (!IS_EQUAL_OR_IN_GROUP(player->inventory_element[j],
10417 action_arg_element_raw))
10418 player->inventory_element[k++] = player->inventory_element[j];
10421 player->inventory_size = k;
10423 else if (action_arg == CA_ARG_INVENTORY_RM_FIRST)
10425 if (player->inventory_size > 0)
10427 for (j = 0; j < player->inventory_size - 1; j++)
10428 player->inventory_element[j] = player->inventory_element[j + 1];
10430 player->inventory_size--;
10433 else if (action_arg == CA_ARG_INVENTORY_RM_LAST)
10435 if (player->inventory_size > 0)
10436 player->inventory_size--;
10438 else if (action_arg == CA_ARG_INVENTORY_RM_ALL)
10440 player->inventory_infinite_element = EL_UNDEFINED;
10441 player->inventory_size = 0;
10443 else if (action_arg == CA_ARG_INVENTORY_RESET)
10445 player->inventory_infinite_element = EL_UNDEFINED;
10446 player->inventory_size = 0;
10448 if (level.use_initial_inventory[i])
10450 for (j = 0; j < level.initial_inventory_size[i]; j++)
10452 int element = level.initial_inventory_content[i][j];
10453 int collect_count = element_info[element].collect_count_initial;
10455 if (!IS_CUSTOM_ELEMENT(element))
10458 if (collect_count == 0)
10459 player->inventory_infinite_element = element;
10461 for (k = 0; k < collect_count; k++)
10462 if (player->inventory_size < MAX_INVENTORY_SIZE)
10463 player->inventory_element[player->inventory_size++] =
10474 // ---------- CE actions -------------------------------------------------
10476 case CA_SET_CE_VALUE:
10478 int last_ce_value = CustomValue[x][y];
10480 CustomValue[x][y] = action_arg_number_new;
10482 if (CustomValue[x][y] != last_ce_value)
10484 CheckElementChange(x, y, element, EL_UNDEFINED, CE_VALUE_CHANGES);
10485 CheckTriggeredElementChange(x, y, element, CE_VALUE_CHANGES_OF_X);
10487 if (CustomValue[x][y] == 0)
10489 // reset change counter (else CE_VALUE_GETS_ZERO would not work)
10490 ChangeCount[x][y] = 0; // allow at least one more change
10492 CheckElementChange(x, y, element, EL_UNDEFINED, CE_VALUE_GETS_ZERO);
10493 CheckTriggeredElementChange(x, y, element, CE_VALUE_GETS_ZERO_OF_X);
10500 case CA_SET_CE_SCORE:
10502 int last_ce_score = ei->collect_score;
10504 ei->collect_score = action_arg_number_new;
10506 if (ei->collect_score != last_ce_score)
10508 CheckElementChange(x, y, element, EL_UNDEFINED, CE_SCORE_CHANGES);
10509 CheckTriggeredElementChange(x, y, element, CE_SCORE_CHANGES_OF_X);
10511 if (ei->collect_score == 0)
10515 // reset change counter (else CE_SCORE_GETS_ZERO would not work)
10516 ChangeCount[x][y] = 0; // allow at least one more change
10518 CheckElementChange(x, y, element, EL_UNDEFINED, CE_SCORE_GETS_ZERO);
10519 CheckTriggeredElementChange(x, y, element, CE_SCORE_GETS_ZERO_OF_X);
10522 This is a very special case that seems to be a mixture between
10523 CheckElementChange() and CheckTriggeredElementChange(): while
10524 the first one only affects single elements that are triggered
10525 directly, the second one affects multiple elements in the playfield
10526 that are triggered indirectly by another element. This is a third
10527 case: Changing the CE score always affects multiple identical CEs,
10528 so every affected CE must be checked, not only the single CE for
10529 which the CE score was changed in the first place (as every instance
10530 of that CE shares the same CE score, and therefore also can change)!
10532 SCAN_PLAYFIELD(xx, yy)
10534 if (Tile[xx][yy] == element)
10535 CheckElementChange(xx, yy, element, EL_UNDEFINED,
10536 CE_SCORE_GETS_ZERO);
10544 case CA_SET_CE_ARTWORK:
10546 int artwork_element = action_arg_element;
10547 boolean reset_frame = FALSE;
10550 if (action_arg == CA_ARG_ELEMENT_RESET)
10551 artwork_element = (ei->use_gfx_element ? ei->gfx_element_initial :
10554 if (ei->gfx_element != artwork_element)
10555 reset_frame = TRUE;
10557 ei->gfx_element = artwork_element;
10559 SCAN_PLAYFIELD(xx, yy)
10561 if (Tile[xx][yy] == element)
10565 ResetGfxAnimation(xx, yy);
10566 ResetRandomAnimationValue(xx, yy);
10569 TEST_DrawLevelField(xx, yy);
10576 // ---------- engine actions ---------------------------------------------
10578 case CA_SET_ENGINE_SCAN_MODE:
10580 InitPlayfieldScanMode(action_arg);
10590 static void CreateFieldExt(int x, int y, int element, boolean is_change)
10592 int old_element = Tile[x][y];
10593 int new_element = GetElementFromGroupElement(element);
10594 int previous_move_direction = MovDir[x][y];
10595 int last_ce_value = CustomValue[x][y];
10596 boolean player_explosion_protected = PLAYER_EXPLOSION_PROTECTED(x, y);
10597 boolean new_element_is_player = IS_PLAYER_ELEMENT(new_element);
10598 boolean add_player_onto_element = (new_element_is_player &&
10599 new_element != EL_SOKOBAN_FIELD_PLAYER &&
10600 IS_WALKABLE(old_element));
10602 if (!add_player_onto_element)
10604 if (IS_MOVING(x, y) || IS_BLOCKED(x, y))
10605 RemoveMovingField(x, y);
10609 Tile[x][y] = new_element;
10611 if (element_info[new_element].move_direction_initial == MV_START_PREVIOUS)
10612 MovDir[x][y] = previous_move_direction;
10614 if (element_info[new_element].use_last_ce_value)
10615 CustomValue[x][y] = last_ce_value;
10617 InitField_WithBug1(x, y, FALSE);
10619 new_element = Tile[x][y]; // element may have changed
10621 ResetGfxAnimation(x, y);
10622 ResetRandomAnimationValue(x, y);
10624 TEST_DrawLevelField(x, y);
10626 if (GFX_CRUMBLED(new_element))
10627 TEST_DrawLevelFieldCrumbledNeighbours(x, y);
10630 // check if element under the player changes from accessible to unaccessible
10631 // (needed for special case of dropping element which then changes)
10632 // (must be checked after creating new element for walkable group elements)
10633 if (IS_PLAYER(x, y) && !player_explosion_protected &&
10634 IS_ACCESSIBLE(old_element) && !IS_ACCESSIBLE(new_element))
10641 // "ChangeCount" not set yet to allow "entered by player" change one time
10642 if (new_element_is_player)
10643 RelocatePlayer(x, y, new_element);
10646 ChangeCount[x][y]++; // count number of changes in the same frame
10648 TestIfBadThingTouchesPlayer(x, y);
10649 TestIfPlayerTouchesCustomElement(x, y);
10650 TestIfElementTouchesCustomElement(x, y);
10653 static void CreateField(int x, int y, int element)
10655 CreateFieldExt(x, y, element, FALSE);
10658 static void CreateElementFromChange(int x, int y, int element)
10660 element = GET_VALID_RUNTIME_ELEMENT(element);
10662 if (game.engine_version >= VERSION_IDENT(3,2,0,7))
10664 int old_element = Tile[x][y];
10666 // prevent changed element from moving in same engine frame
10667 // unless both old and new element can either fall or move
10668 if ((!CAN_FALL(old_element) || !CAN_FALL(element)) &&
10669 (!CAN_MOVE(old_element) || !CAN_MOVE(element)))
10673 CreateFieldExt(x, y, element, TRUE);
10676 static boolean ChangeElement(int x, int y, int element, int page)
10678 struct ElementInfo *ei = &element_info[element];
10679 struct ElementChangeInfo *change = &ei->change_page[page];
10680 int ce_value = CustomValue[x][y];
10681 int ce_score = ei->collect_score;
10682 int target_element;
10683 int old_element = Tile[x][y];
10685 // always use default change event to prevent running into a loop
10686 if (ChangeEvent[x][y] == -1)
10687 ChangeEvent[x][y] = CE_DELAY;
10689 if (ChangeEvent[x][y] == CE_DELAY)
10691 // reset actual trigger element, trigger player and action element
10692 change->actual_trigger_element = EL_EMPTY;
10693 change->actual_trigger_player = EL_EMPTY;
10694 change->actual_trigger_player_bits = CH_PLAYER_NONE;
10695 change->actual_trigger_side = CH_SIDE_NONE;
10696 change->actual_trigger_ce_value = 0;
10697 change->actual_trigger_ce_score = 0;
10700 // do not change elements more than a specified maximum number of changes
10701 if (ChangeCount[x][y] >= game.max_num_changes_per_frame)
10704 ChangeCount[x][y]++; // count number of changes in the same frame
10706 if (change->explode)
10713 if (change->use_target_content)
10715 boolean complete_replace = TRUE;
10716 boolean can_replace[3][3];
10719 for (yy = 0; yy < 3; yy++) for (xx = 0; xx < 3 ; xx++)
10722 boolean is_walkable;
10723 boolean is_diggable;
10724 boolean is_collectible;
10725 boolean is_removable;
10726 boolean is_destructible;
10727 int ex = x + xx - 1;
10728 int ey = y + yy - 1;
10729 int content_element = change->target_content.e[xx][yy];
10732 can_replace[xx][yy] = TRUE;
10734 if (ex == x && ey == y) // do not check changing element itself
10737 if (content_element == EL_EMPTY_SPACE)
10739 can_replace[xx][yy] = FALSE; // do not replace border with space
10744 if (!IN_LEV_FIELD(ex, ey))
10746 can_replace[xx][yy] = FALSE;
10747 complete_replace = FALSE;
10754 if (IS_MOVING(ex, ey) || IS_BLOCKED(ex, ey))
10755 e = MovingOrBlocked2Element(ex, ey);
10757 is_empty = (IS_FREE(ex, ey) ||
10758 (IS_FREE_OR_PLAYER(ex, ey) && IS_WALKABLE(content_element)));
10760 is_walkable = (is_empty || IS_WALKABLE(e));
10761 is_diggable = (is_empty || IS_DIGGABLE(e));
10762 is_collectible = (is_empty || IS_COLLECTIBLE(e));
10763 is_destructible = (is_empty || !IS_INDESTRUCTIBLE(e));
10764 is_removable = (is_diggable || is_collectible);
10766 can_replace[xx][yy] =
10767 (((change->replace_when == CP_WHEN_EMPTY && is_empty) ||
10768 (change->replace_when == CP_WHEN_WALKABLE && is_walkable) ||
10769 (change->replace_when == CP_WHEN_DIGGABLE && is_diggable) ||
10770 (change->replace_when == CP_WHEN_COLLECTIBLE && is_collectible) ||
10771 (change->replace_when == CP_WHEN_REMOVABLE && is_removable) ||
10772 (change->replace_when == CP_WHEN_DESTRUCTIBLE && is_destructible)) &&
10773 !(IS_PLAYER(ex, ey) && IS_PLAYER_ELEMENT(content_element)));
10775 if (!can_replace[xx][yy])
10776 complete_replace = FALSE;
10779 if (!change->only_if_complete || complete_replace)
10781 boolean something_has_changed = FALSE;
10783 if (change->only_if_complete && change->use_random_replace &&
10784 RND(100) < change->random_percentage)
10787 for (yy = 0; yy < 3; yy++) for (xx = 0; xx < 3 ; xx++)
10789 int ex = x + xx - 1;
10790 int ey = y + yy - 1;
10791 int content_element;
10793 if (can_replace[xx][yy] && (!change->use_random_replace ||
10794 RND(100) < change->random_percentage))
10796 if (IS_MOVING(ex, ey) || IS_BLOCKED(ex, ey))
10797 RemoveMovingField(ex, ey);
10799 ChangeEvent[ex][ey] = ChangeEvent[x][y];
10801 content_element = change->target_content.e[xx][yy];
10802 target_element = GET_TARGET_ELEMENT(element, content_element, change,
10803 ce_value, ce_score);
10805 CreateElementFromChange(ex, ey, target_element);
10807 something_has_changed = TRUE;
10809 // for symmetry reasons, freeze newly created border elements
10810 if (ex != x || ey != y)
10811 Stop[ex][ey] = TRUE; // no more moving in this frame
10815 if (something_has_changed)
10817 PlayLevelSoundElementAction(x, y, element, ACTION_CHANGING);
10818 PlayLevelSoundElementAction(x, y, element, ACTION_PAGE_1 + page);
10824 target_element = GET_TARGET_ELEMENT(element, change->target_element, change,
10825 ce_value, ce_score);
10827 if (element == EL_DIAGONAL_GROWING ||
10828 element == EL_DIAGONAL_SHRINKING)
10830 target_element = Store[x][y];
10832 Store[x][y] = EL_EMPTY;
10835 // special case: element changes to player (and may be kept if walkable)
10836 if (IS_PLAYER_ELEMENT(target_element) && !level.keep_walkable_ce)
10837 CreateElementFromChange(x, y, EL_EMPTY);
10839 CreateElementFromChange(x, y, target_element);
10841 PlayLevelSoundElementAction(x, y, element, ACTION_CHANGING);
10842 PlayLevelSoundElementAction(x, y, element, ACTION_PAGE_1 + page);
10845 // this uses direct change before indirect change
10846 CheckTriggeredElementChangeByPage(x, y, old_element, CE_CHANGE_OF_X, page);
10851 static void HandleElementChange(int x, int y, int page)
10853 int element = MovingOrBlocked2Element(x, y);
10854 struct ElementInfo *ei = &element_info[element];
10855 struct ElementChangeInfo *change = &ei->change_page[page];
10856 boolean handle_action_before_change = FALSE;
10859 if (!CAN_CHANGE_OR_HAS_ACTION(element) &&
10860 !CAN_CHANGE_OR_HAS_ACTION(Back[x][y]))
10862 Debug("game:playing:HandleElementChange", "%d,%d: element = %d ('%s')",
10863 x, y, element, element_info[element].token_name);
10864 Debug("game:playing:HandleElementChange", "This should never happen!");
10868 // this can happen with classic bombs on walkable, changing elements
10869 if (!CAN_CHANGE_OR_HAS_ACTION(element))
10874 if (ChangeDelay[x][y] == 0) // initialize element change
10876 ChangeDelay[x][y] = GET_CHANGE_DELAY(change) + 1;
10878 if (change->can_change)
10880 // !!! not clear why graphic animation should be reset at all here !!!
10881 // !!! UPDATE: but is needed for correct Snake Bite tail animation !!!
10882 // !!! SOLUTION: do not reset if graphics engine set to 4 or above !!!
10885 GRAPHICAL BUG ADDRESSED BY CHECKING GRAPHICS ENGINE VERSION:
10887 When using an animation frame delay of 1 (this only happens with
10888 "sp_zonk.moving.left/right" in the classic graphics), the default
10889 (non-moving) animation shows wrong animation frames (while the
10890 moving animation, like "sp_zonk.moving.left/right", is correct,
10891 so this graphical bug never shows up with the classic graphics).
10892 For an animation with 4 frames, this causes wrong frames 0,0,1,2
10893 be drawn instead of the correct frames 0,1,2,3. This is caused by
10894 "GfxFrame[][]" being reset *twice* (in two successive frames) after
10895 an element change: First when the change delay ("ChangeDelay[][]")
10896 counter has reached zero after decrementing, then a second time in
10897 the next frame (after "GfxFrame[][]" was already incremented) when
10898 "ChangeDelay[][]" is reset to the initial delay value again.
10900 This causes frame 0 to be drawn twice, while the last frame won't
10901 be drawn anymore, resulting in the wrong frame sequence 0,0,1,2.
10903 As some animations may already be cleverly designed around this bug
10904 (at least the "Snake Bite" snake tail animation does this), it cannot
10905 simply be fixed here without breaking such existing animations.
10906 Unfortunately, it cannot easily be detected if a graphics set was
10907 designed "before" or "after" the bug was fixed. As a workaround,
10908 a new graphics set option "game.graphics_engine_version" was added
10909 to be able to specify the game's major release version for which the
10910 graphics set was designed, which can then be used to decide if the
10911 bugfix should be used (version 4 and above) or not (version 3 or
10912 below, or if no version was specified at all, as with old sets).
10914 (The wrong/fixed animation frames can be tested with the test level set
10915 "test_gfxframe" and level "000", which contains a specially prepared
10916 custom element at level position (x/y) == (11/9) which uses the zonk
10917 animation mentioned above. Using "game.graphics_engine_version: 4"
10918 fixes the wrong animation frames, showing the correct frames 0,1,2,3.
10919 This can also be seen from the debug output for this test element.)
10922 // when a custom element is about to change (for example by change delay),
10923 // do not reset graphic animation when the custom element is moving
10924 if (game.graphics_engine_version < 4 &&
10927 ResetGfxAnimation(x, y);
10928 ResetRandomAnimationValue(x, y);
10931 if (change->pre_change_function)
10932 change->pre_change_function(x, y);
10936 ChangeDelay[x][y]--;
10938 if (ChangeDelay[x][y] != 0) // continue element change
10940 if (change->can_change)
10942 int graphic = el_act_dir2img(element, GfxAction[x][y], GfxDir[x][y]);
10944 if (IS_ANIMATED(graphic))
10945 DrawLevelGraphicAnimationIfNeeded(x, y, graphic);
10947 if (change->change_function)
10948 change->change_function(x, y);
10951 else // finish element change
10953 if (ChangePage[x][y] != -1) // remember page from delayed change
10955 page = ChangePage[x][y];
10956 ChangePage[x][y] = -1;
10958 change = &ei->change_page[page];
10961 if (IS_MOVING(x, y)) // never change a running system ;-)
10963 ChangeDelay[x][y] = 1; // try change after next move step
10964 ChangePage[x][y] = page; // remember page to use for change
10969 // special case: set new level random seed before changing element
10970 if (change->has_action && change->action_type == CA_SET_LEVEL_RANDOM_SEED)
10971 handle_action_before_change = TRUE;
10973 if (change->has_action && handle_action_before_change)
10974 ExecuteCustomElementAction(x, y, element, page);
10976 if (change->can_change)
10978 if (ChangeElement(x, y, element, page))
10980 if (change->post_change_function)
10981 change->post_change_function(x, y);
10985 if (change->has_action && !handle_action_before_change)
10986 ExecuteCustomElementAction(x, y, element, page);
10990 static boolean CheckTriggeredElementChangeExt(int trigger_x, int trigger_y,
10991 int trigger_element,
10993 int trigger_player,
10997 boolean change_done_any = FALSE;
10998 int trigger_page_bits = (trigger_page < 0 ? CH_PAGE_ANY : 1 << trigger_page);
11001 if (!(trigger_events[trigger_element][trigger_event]))
11004 RECURSION_LOOP_DETECTION_START(trigger_element, FALSE);
11006 for (i = 0; i < NUM_CUSTOM_ELEMENTS; i++)
11008 int element = EL_CUSTOM_START + i;
11009 boolean change_done = FALSE;
11012 if (!CAN_CHANGE_OR_HAS_ACTION(element) ||
11013 !HAS_ANY_CHANGE_EVENT(element, trigger_event))
11016 for (p = 0; p < element_info[element].num_change_pages; p++)
11018 struct ElementChangeInfo *change = &element_info[element].change_page[p];
11020 if (change->can_change_or_has_action &&
11021 change->has_event[trigger_event] &&
11022 change->trigger_side & trigger_side &&
11023 change->trigger_player & trigger_player &&
11024 change->trigger_page & trigger_page_bits &&
11025 IS_EQUAL_OR_IN_GROUP(trigger_element, change->trigger_element))
11027 change->actual_trigger_element = trigger_element;
11028 change->actual_trigger_player = GET_PLAYER_FROM_BITS(trigger_player);
11029 change->actual_trigger_player_bits = trigger_player;
11030 change->actual_trigger_side = trigger_side;
11031 change->actual_trigger_ce_value = CustomValue[trigger_x][trigger_y];
11032 change->actual_trigger_ce_score = GET_CE_SCORE(trigger_element);
11034 if ((change->can_change && !change_done) || change->has_action)
11038 SCAN_PLAYFIELD(x, y)
11040 if (Tile[x][y] == element)
11042 if (change->can_change && !change_done)
11044 // if element already changed in this frame, not only prevent
11045 // another element change (checked in ChangeElement()), but
11046 // also prevent additional element actions for this element
11048 if (ChangeCount[x][y] >= game.max_num_changes_per_frame &&
11049 !level.use_action_after_change_bug)
11052 ChangeDelay[x][y] = 1;
11053 ChangeEvent[x][y] = trigger_event;
11055 HandleElementChange(x, y, p);
11057 else if (change->has_action)
11059 // if element already changed in this frame, not only prevent
11060 // another element change (checked in ChangeElement()), but
11061 // also prevent additional element actions for this element
11063 if (ChangeCount[x][y] >= game.max_num_changes_per_frame &&
11064 !level.use_action_after_change_bug)
11067 ExecuteCustomElementAction(x, y, element, p);
11068 PlayLevelSoundElementAction(x, y, element, ACTION_PAGE_1 + p);
11073 if (change->can_change)
11075 change_done = TRUE;
11076 change_done_any = TRUE;
11083 RECURSION_LOOP_DETECTION_END();
11085 return change_done_any;
11088 static boolean CheckElementChangeExt(int x, int y,
11090 int trigger_element,
11092 int trigger_player,
11095 boolean change_done = FALSE;
11098 if (!CAN_CHANGE_OR_HAS_ACTION(element) ||
11099 !HAS_ANY_CHANGE_EVENT(element, trigger_event))
11102 if (Tile[x][y] == EL_BLOCKED)
11104 Blocked2Moving(x, y, &x, &y);
11105 element = Tile[x][y];
11108 // check if element has already changed or is about to change after moving
11109 if ((game.engine_version < VERSION_IDENT(3,2,0,7) &&
11110 Tile[x][y] != element) ||
11112 (game.engine_version >= VERSION_IDENT(3,2,0,7) &&
11113 (ChangeCount[x][y] >= game.max_num_changes_per_frame ||
11114 ChangePage[x][y] != -1)))
11117 RECURSION_LOOP_DETECTION_START(trigger_element, FALSE);
11119 for (p = 0; p < element_info[element].num_change_pages; p++)
11121 struct ElementChangeInfo *change = &element_info[element].change_page[p];
11123 /* check trigger element for all events where the element that is checked
11124 for changing interacts with a directly adjacent element -- this is
11125 different to element changes that affect other elements to change on the
11126 whole playfield (which is handeld by CheckTriggeredElementChangeExt()) */
11127 boolean check_trigger_element =
11128 (trigger_event == CE_TOUCHING_X ||
11129 trigger_event == CE_HITTING_X ||
11130 trigger_event == CE_HIT_BY_X ||
11131 trigger_event == CE_DIGGING_X); // this one was forgotten until 3.2.3
11133 if (change->can_change_or_has_action &&
11134 change->has_event[trigger_event] &&
11135 change->trigger_side & trigger_side &&
11136 change->trigger_player & trigger_player &&
11137 (!check_trigger_element ||
11138 IS_EQUAL_OR_IN_GROUP(trigger_element, change->trigger_element)))
11140 change->actual_trigger_element = trigger_element;
11141 change->actual_trigger_player = GET_PLAYER_FROM_BITS(trigger_player);
11142 change->actual_trigger_player_bits = trigger_player;
11143 change->actual_trigger_side = trigger_side;
11144 change->actual_trigger_ce_value = CustomValue[x][y];
11145 change->actual_trigger_ce_score = GET_CE_SCORE(trigger_element);
11147 // special case: trigger element not at (x,y) position for some events
11148 if (check_trigger_element)
11160 { 0, 0 }, { 0, 0 }, { 0, 0 },
11164 int xx = x + move_xy[MV_DIR_OPPOSITE(trigger_side)].dx;
11165 int yy = y + move_xy[MV_DIR_OPPOSITE(trigger_side)].dy;
11167 change->actual_trigger_ce_value = CustomValue[xx][yy];
11168 change->actual_trigger_ce_score = GET_CE_SCORE(trigger_element);
11171 if (change->can_change && !change_done)
11173 ChangeDelay[x][y] = 1;
11174 ChangeEvent[x][y] = trigger_event;
11176 HandleElementChange(x, y, p);
11178 change_done = TRUE;
11180 else if (change->has_action)
11182 ExecuteCustomElementAction(x, y, element, p);
11183 PlayLevelSoundElementAction(x, y, element, ACTION_PAGE_1 + p);
11188 RECURSION_LOOP_DETECTION_END();
11190 return change_done;
11193 static void PlayPlayerSound(struct PlayerInfo *player)
11195 int jx = player->jx, jy = player->jy;
11196 int sound_element = player->artwork_element;
11197 int last_action = player->last_action_waiting;
11198 int action = player->action_waiting;
11200 if (player->is_waiting)
11202 if (action != last_action)
11203 PlayLevelSoundElementAction(jx, jy, sound_element, action);
11205 PlayLevelSoundElementActionIfLoop(jx, jy, sound_element, action);
11209 if (action != last_action)
11210 StopSound(element_info[sound_element].sound[last_action]);
11212 if (last_action == ACTION_SLEEPING)
11213 PlayLevelSoundElementAction(jx, jy, sound_element, ACTION_AWAKENING);
11217 static void PlayAllPlayersSound(void)
11221 for (i = 0; i < MAX_PLAYERS; i++)
11222 if (stored_player[i].active)
11223 PlayPlayerSound(&stored_player[i]);
11226 static void SetPlayerWaiting(struct PlayerInfo *player, boolean is_waiting)
11228 boolean last_waiting = player->is_waiting;
11229 int move_dir = player->MovDir;
11231 player->dir_waiting = move_dir;
11232 player->last_action_waiting = player->action_waiting;
11236 if (!last_waiting) // not waiting -> waiting
11238 player->is_waiting = TRUE;
11240 player->frame_counter_bored =
11242 game.player_boring_delay_fixed +
11243 GetSimpleRandom(game.player_boring_delay_random);
11244 player->frame_counter_sleeping =
11246 game.player_sleeping_delay_fixed +
11247 GetSimpleRandom(game.player_sleeping_delay_random);
11249 InitPlayerGfxAnimation(player, ACTION_WAITING, move_dir);
11252 if (game.player_sleeping_delay_fixed +
11253 game.player_sleeping_delay_random > 0 &&
11254 player->anim_delay_counter == 0 &&
11255 player->post_delay_counter == 0 &&
11256 FrameCounter >= player->frame_counter_sleeping)
11257 player->is_sleeping = TRUE;
11258 else if (game.player_boring_delay_fixed +
11259 game.player_boring_delay_random > 0 &&
11260 FrameCounter >= player->frame_counter_bored)
11261 player->is_bored = TRUE;
11263 player->action_waiting = (player->is_sleeping ? ACTION_SLEEPING :
11264 player->is_bored ? ACTION_BORING :
11267 if (player->is_sleeping && player->use_murphy)
11269 // special case for sleeping Murphy when leaning against non-free tile
11271 if (!IN_LEV_FIELD(player->jx - 1, player->jy) ||
11272 (Tile[player->jx - 1][player->jy] != EL_EMPTY &&
11273 !IS_MOVING(player->jx - 1, player->jy)))
11274 move_dir = MV_LEFT;
11275 else if (!IN_LEV_FIELD(player->jx + 1, player->jy) ||
11276 (Tile[player->jx + 1][player->jy] != EL_EMPTY &&
11277 !IS_MOVING(player->jx + 1, player->jy)))
11278 move_dir = MV_RIGHT;
11280 player->is_sleeping = FALSE;
11282 player->dir_waiting = move_dir;
11285 if (player->is_sleeping)
11287 if (player->num_special_action_sleeping > 0)
11289 if (player->anim_delay_counter == 0 && player->post_delay_counter == 0)
11291 int last_special_action = player->special_action_sleeping;
11292 int num_special_action = player->num_special_action_sleeping;
11293 int special_action =
11294 (last_special_action == ACTION_DEFAULT ? ACTION_SLEEPING_1 :
11295 last_special_action == ACTION_SLEEPING ? ACTION_SLEEPING :
11296 last_special_action < ACTION_SLEEPING_1 + num_special_action - 1 ?
11297 last_special_action + 1 : ACTION_SLEEPING);
11298 int special_graphic =
11299 el_act_dir2img(player->artwork_element, special_action, move_dir);
11301 player->anim_delay_counter =
11302 graphic_info[special_graphic].anim_delay_fixed +
11303 GetSimpleRandom(graphic_info[special_graphic].anim_delay_random);
11304 player->post_delay_counter =
11305 graphic_info[special_graphic].post_delay_fixed +
11306 GetSimpleRandom(graphic_info[special_graphic].post_delay_random);
11308 player->special_action_sleeping = special_action;
11311 if (player->anim_delay_counter > 0)
11313 player->action_waiting = player->special_action_sleeping;
11314 player->anim_delay_counter--;
11316 else if (player->post_delay_counter > 0)
11318 player->post_delay_counter--;
11322 else if (player->is_bored)
11324 if (player->num_special_action_bored > 0)
11326 if (player->anim_delay_counter == 0 && player->post_delay_counter == 0)
11328 int special_action =
11329 ACTION_BORING_1 + GetSimpleRandom(player->num_special_action_bored);
11330 int special_graphic =
11331 el_act_dir2img(player->artwork_element, special_action, move_dir);
11333 player->anim_delay_counter =
11334 graphic_info[special_graphic].anim_delay_fixed +
11335 GetSimpleRandom(graphic_info[special_graphic].anim_delay_random);
11336 player->post_delay_counter =
11337 graphic_info[special_graphic].post_delay_fixed +
11338 GetSimpleRandom(graphic_info[special_graphic].post_delay_random);
11340 player->special_action_bored = special_action;
11343 if (player->anim_delay_counter > 0)
11345 player->action_waiting = player->special_action_bored;
11346 player->anim_delay_counter--;
11348 else if (player->post_delay_counter > 0)
11350 player->post_delay_counter--;
11355 else if (last_waiting) // waiting -> not waiting
11357 player->is_waiting = FALSE;
11358 player->is_bored = FALSE;
11359 player->is_sleeping = FALSE;
11361 player->frame_counter_bored = -1;
11362 player->frame_counter_sleeping = -1;
11364 player->anim_delay_counter = 0;
11365 player->post_delay_counter = 0;
11367 player->dir_waiting = player->MovDir;
11368 player->action_waiting = ACTION_DEFAULT;
11370 player->special_action_bored = ACTION_DEFAULT;
11371 player->special_action_sleeping = ACTION_DEFAULT;
11375 static void CheckSaveEngineSnapshot(struct PlayerInfo *player)
11377 if ((!player->is_moving && player->was_moving) ||
11378 (player->MovPos == 0 && player->was_moving) ||
11379 (player->is_snapping && !player->was_snapping) ||
11380 (player->is_dropping && !player->was_dropping))
11382 if (!CheckSaveEngineSnapshotToList())
11385 player->was_moving = FALSE;
11386 player->was_snapping = TRUE;
11387 player->was_dropping = TRUE;
11391 if (player->is_moving)
11392 player->was_moving = TRUE;
11394 if (!player->is_snapping)
11395 player->was_snapping = FALSE;
11397 if (!player->is_dropping)
11398 player->was_dropping = FALSE;
11401 static struct MouseActionInfo mouse_action_last = { 0 };
11402 struct MouseActionInfo mouse_action = player->effective_mouse_action;
11403 boolean new_released = (!mouse_action.button && mouse_action_last.button);
11406 CheckSaveEngineSnapshotToList();
11408 mouse_action_last = mouse_action;
11411 static void CheckSingleStepMode(struct PlayerInfo *player)
11413 if (tape.single_step && tape.recording && !tape.pausing)
11415 // as it is called "single step mode", just return to pause mode when the
11416 // player stopped moving after one tile (or never starts moving at all)
11417 // (reverse logic needed here in case single step mode used in team mode)
11418 if (player->is_moving ||
11419 player->is_pushing ||
11420 player->is_dropping_pressed ||
11421 player->effective_mouse_action.button)
11422 game.enter_single_step_mode = FALSE;
11425 CheckSaveEngineSnapshot(player);
11428 static byte PlayerActions(struct PlayerInfo *player, byte player_action)
11430 int left = player_action & JOY_LEFT;
11431 int right = player_action & JOY_RIGHT;
11432 int up = player_action & JOY_UP;
11433 int down = player_action & JOY_DOWN;
11434 int button1 = player_action & JOY_BUTTON_1;
11435 int button2 = player_action & JOY_BUTTON_2;
11436 int dx = (left ? -1 : right ? 1 : 0);
11437 int dy = (up ? -1 : down ? 1 : 0);
11439 if (!player->active || tape.pausing)
11445 SnapField(player, dx, dy);
11449 DropElement(player);
11451 MovePlayer(player, dx, dy);
11454 CheckSingleStepMode(player);
11456 SetPlayerWaiting(player, FALSE);
11458 return player_action;
11462 // no actions for this player (no input at player's configured device)
11464 DigField(player, 0, 0, 0, 0, 0, 0, DF_NO_PUSH);
11465 SnapField(player, 0, 0);
11466 CheckGravityMovementWhenNotMoving(player);
11468 if (player->MovPos == 0)
11469 SetPlayerWaiting(player, TRUE);
11471 if (player->MovPos == 0) // needed for tape.playing
11472 player->is_moving = FALSE;
11474 player->is_dropping = FALSE;
11475 player->is_dropping_pressed = FALSE;
11476 player->drop_pressed_delay = 0;
11478 CheckSingleStepMode(player);
11484 static void SetMouseActionFromTapeAction(struct MouseActionInfo *mouse_action,
11487 if (!tape.use_mouse_actions)
11490 mouse_action->lx = tape_action[TAPE_ACTION_LX];
11491 mouse_action->ly = tape_action[TAPE_ACTION_LY];
11492 mouse_action->button = tape_action[TAPE_ACTION_BUTTON];
11495 static void SetTapeActionFromMouseAction(byte *tape_action,
11496 struct MouseActionInfo *mouse_action)
11498 if (!tape.use_mouse_actions)
11501 tape_action[TAPE_ACTION_LX] = mouse_action->lx;
11502 tape_action[TAPE_ACTION_LY] = mouse_action->ly;
11503 tape_action[TAPE_ACTION_BUTTON] = mouse_action->button;
11506 static void CheckLevelSolved(void)
11508 if (level.game_engine_type == GAME_ENGINE_TYPE_EM)
11510 if (game_em.level_solved &&
11511 !game_em.game_over) // game won
11515 game_em.game_over = TRUE;
11517 game.all_players_gone = TRUE;
11520 if (game_em.game_over) // game lost
11521 game.all_players_gone = TRUE;
11523 else if (level.game_engine_type == GAME_ENGINE_TYPE_SP)
11525 if (game_sp.level_solved &&
11526 !game_sp.game_over) // game won
11530 game_sp.game_over = TRUE;
11532 game.all_players_gone = TRUE;
11535 if (game_sp.game_over) // game lost
11536 game.all_players_gone = TRUE;
11538 else if (level.game_engine_type == GAME_ENGINE_TYPE_MM)
11540 if (game_mm.level_solved &&
11541 !game_mm.game_over) // game won
11545 game_mm.game_over = TRUE;
11547 game.all_players_gone = TRUE;
11550 if (game_mm.game_over) // game lost
11551 game.all_players_gone = TRUE;
11555 static void CheckLevelTime(void)
11559 if (TimeFrames >= FRAMES_PER_SECOND)
11564 for (i = 0; i < MAX_PLAYERS; i++)
11566 struct PlayerInfo *player = &stored_player[i];
11568 if (SHIELD_ON(player))
11570 player->shield_normal_time_left--;
11572 if (player->shield_deadly_time_left > 0)
11573 player->shield_deadly_time_left--;
11577 if (!game.LevelSolved && !level.use_step_counter)
11585 if (TimeLeft <= 10 && setup.time_limit)
11586 PlaySound(SND_GAME_RUNNING_OUT_OF_TIME);
11588 /* this does not make sense: game_panel_controls[GAME_PANEL_TIME].value
11589 is reset from other values in UpdateGameDoorValues() -- FIX THIS */
11591 game_panel_controls[GAME_PANEL_TIME].value = TimeLeft;
11593 if (!TimeLeft && setup.time_limit)
11595 if (level.game_engine_type == GAME_ENGINE_TYPE_EM)
11596 game_em.lev->killed_out_of_time = TRUE;
11598 for (i = 0; i < MAX_PLAYERS; i++)
11599 KillPlayer(&stored_player[i]);
11602 else if (game.no_time_limit && !game.all_players_gone)
11604 game_panel_controls[GAME_PANEL_TIME].value = TimePlayed;
11607 game_em.lev->time = (game.no_time_limit ? TimePlayed : TimeLeft);
11610 if (tape.recording || tape.playing)
11611 DrawVideoDisplay(VIDEO_STATE_TIME_ON, TapeTime);
11614 if (tape.recording || tape.playing)
11615 DrawVideoDisplay(VIDEO_STATE_FRAME_ON, FrameCounter);
11617 UpdateAndDisplayGameControlValues();
11620 void AdvanceFrameAndPlayerCounters(int player_nr)
11624 // advance frame counters (global frame counter and time frame counter)
11628 // advance player counters (counters for move delay, move animation etc.)
11629 for (i = 0; i < MAX_PLAYERS; i++)
11631 boolean advance_player_counters = (player_nr == -1 || player_nr == i);
11632 int move_delay_value = stored_player[i].move_delay_value;
11633 int move_frames = MOVE_DELAY_NORMAL_SPEED / move_delay_value;
11635 if (!advance_player_counters) // not all players may be affected
11638 if (move_frames == 0) // less than one move per game frame
11640 int stepsize = TILEX / move_delay_value;
11641 int delay = move_delay_value / MOVE_DELAY_NORMAL_SPEED;
11642 int count = (stored_player[i].is_moving ?
11643 ABS(stored_player[i].MovPos) / stepsize : FrameCounter);
11645 if (count % delay == 0)
11649 stored_player[i].Frame += move_frames;
11651 if (stored_player[i].MovPos != 0)
11652 stored_player[i].StepFrame += move_frames;
11654 if (stored_player[i].move_delay > 0)
11655 stored_player[i].move_delay--;
11657 // due to bugs in previous versions, counter must count up, not down
11658 if (stored_player[i].push_delay != -1)
11659 stored_player[i].push_delay++;
11661 if (stored_player[i].drop_delay > 0)
11662 stored_player[i].drop_delay--;
11664 if (stored_player[i].is_dropping_pressed)
11665 stored_player[i].drop_pressed_delay++;
11669 void StartGameActions(boolean init_network_game, boolean record_tape,
11672 unsigned int new_random_seed = InitRND(random_seed);
11675 TapeStartRecording(new_random_seed);
11677 if (init_network_game)
11679 SendToServer_LevelFile();
11680 SendToServer_StartPlaying();
11688 static void GameActionsExt(void)
11691 static unsigned int game_frame_delay = 0;
11693 unsigned int game_frame_delay_value;
11694 byte *recorded_player_action;
11695 byte summarized_player_action = 0;
11696 byte tape_action[MAX_TAPE_ACTIONS] = { 0 };
11699 // detect endless loops, caused by custom element programming
11700 if (recursion_loop_detected && recursion_loop_depth == 0)
11702 char *message = getStringCat3("Internal Error! Element ",
11703 EL_NAME(recursion_loop_element),
11704 " caused endless loop! Quit the game?");
11706 Warn("element '%s' caused endless loop in game engine",
11707 EL_NAME(recursion_loop_element));
11709 RequestQuitGameExt(FALSE, level_editor_test_game, message);
11711 recursion_loop_detected = FALSE; // if game should be continued
11718 if (game.restart_level)
11719 StartGameActions(network.enabled, setup.autorecord, level.random_seed);
11721 CheckLevelSolved();
11723 if (game.LevelSolved && !game.LevelSolved_GameEnd)
11726 if (game.all_players_gone && !TAPE_IS_STOPPED(tape))
11729 if (game_status != GAME_MODE_PLAYING) // status might have changed
11732 game_frame_delay_value =
11733 (tape.playing && tape.fast_forward ? FfwdFrameDelay : GameFrameDelay);
11735 if (tape.playing && tape.warp_forward && !tape.pausing)
11736 game_frame_delay_value = 0;
11738 SetVideoFrameDelay(game_frame_delay_value);
11740 // (de)activate virtual buttons depending on current game status
11741 if (strEqual(setup.touch.control_type, TOUCH_CONTROL_VIRTUAL_BUTTONS))
11743 if (game.all_players_gone) // if no players there to be controlled anymore
11744 SetOverlayActive(FALSE);
11745 else if (!tape.playing) // if game continues after tape stopped playing
11746 SetOverlayActive(TRUE);
11751 // ---------- main game synchronization point ----------
11753 int skip = WaitUntilDelayReached(&game_frame_delay, game_frame_delay_value);
11755 Debug("game:playing:skip", "skip == %d", skip);
11758 // ---------- main game synchronization point ----------
11760 WaitUntilDelayReached(&game_frame_delay, game_frame_delay_value);
11764 if (network_playing && !network_player_action_received)
11766 // try to get network player actions in time
11768 // last chance to get network player actions without main loop delay
11769 HandleNetworking();
11771 // game was quit by network peer
11772 if (game_status != GAME_MODE_PLAYING)
11775 // check if network player actions still missing and game still running
11776 if (!network_player_action_received && !checkGameEnded())
11777 return; // failed to get network player actions in time
11779 // do not yet reset "network_player_action_received" (for tape.pausing)
11785 // at this point we know that we really continue executing the game
11787 network_player_action_received = FALSE;
11789 // when playing tape, read previously recorded player input from tape data
11790 recorded_player_action = (tape.playing ? TapePlayAction() : NULL);
11792 local_player->effective_mouse_action = local_player->mouse_action;
11794 if (recorded_player_action != NULL)
11795 SetMouseActionFromTapeAction(&local_player->effective_mouse_action,
11796 recorded_player_action);
11798 // TapePlayAction() may return NULL when toggling to "pause before death"
11802 if (tape.set_centered_player)
11804 game.centered_player_nr_next = tape.centered_player_nr_next;
11805 game.set_centered_player = TRUE;
11808 for (i = 0; i < MAX_PLAYERS; i++)
11810 summarized_player_action |= stored_player[i].action;
11812 if (!network_playing && (game.team_mode || tape.playing))
11813 stored_player[i].effective_action = stored_player[i].action;
11816 if (network_playing && !checkGameEnded())
11817 SendToServer_MovePlayer(summarized_player_action);
11819 // summarize all actions at local players mapped input device position
11820 // (this allows using different input devices in single player mode)
11821 if (!network.enabled && !game.team_mode)
11822 stored_player[map_player_action[local_player->index_nr]].effective_action =
11823 summarized_player_action;
11825 // summarize all actions at centered player in local team mode
11826 if (tape.recording &&
11827 setup.team_mode && !network.enabled &&
11828 setup.input_on_focus &&
11829 game.centered_player_nr != -1)
11831 for (i = 0; i < MAX_PLAYERS; i++)
11832 stored_player[map_player_action[i]].effective_action =
11833 (i == game.centered_player_nr ? summarized_player_action : 0);
11836 if (recorded_player_action != NULL)
11837 for (i = 0; i < MAX_PLAYERS; i++)
11838 stored_player[i].effective_action = recorded_player_action[i];
11840 for (i = 0; i < MAX_PLAYERS; i++)
11842 tape_action[i] = stored_player[i].effective_action;
11844 /* (this may happen in the RND game engine if a player was not present on
11845 the playfield on level start, but appeared later from a custom element */
11846 if (setup.team_mode &&
11849 !tape.player_participates[i])
11850 tape.player_participates[i] = TRUE;
11853 SetTapeActionFromMouseAction(tape_action,
11854 &local_player->effective_mouse_action);
11856 // only record actions from input devices, but not programmed actions
11857 if (tape.recording)
11858 TapeRecordAction(tape_action);
11860 // remember if game was played (especially after tape stopped playing)
11861 if (!tape.playing && summarized_player_action)
11862 game.GamePlayed = TRUE;
11864 #if USE_NEW_PLAYER_ASSIGNMENTS
11865 // !!! also map player actions in single player mode !!!
11866 // if (game.team_mode)
11869 byte mapped_action[MAX_PLAYERS];
11871 #if DEBUG_PLAYER_ACTIONS
11872 for (i = 0; i < MAX_PLAYERS; i++)
11873 DebugContinued("", "%d, ", stored_player[i].effective_action);
11876 for (i = 0; i < MAX_PLAYERS; i++)
11877 mapped_action[i] = stored_player[map_player_action[i]].effective_action;
11879 for (i = 0; i < MAX_PLAYERS; i++)
11880 stored_player[i].effective_action = mapped_action[i];
11882 #if DEBUG_PLAYER_ACTIONS
11883 DebugContinued("", "=> ");
11884 for (i = 0; i < MAX_PLAYERS; i++)
11885 DebugContinued("", "%d, ", stored_player[i].effective_action);
11886 DebugContinued("game:playing:player", "\n");
11889 #if DEBUG_PLAYER_ACTIONS
11892 for (i = 0; i < MAX_PLAYERS; i++)
11893 DebugContinued("", "%d, ", stored_player[i].effective_action);
11894 DebugContinued("game:playing:player", "\n");
11899 for (i = 0; i < MAX_PLAYERS; i++)
11901 // allow engine snapshot in case of changed movement attempt
11902 if ((game.snapshot.last_action[i] & KEY_MOTION) !=
11903 (stored_player[i].effective_action & KEY_MOTION))
11904 game.snapshot.changed_action = TRUE;
11906 // allow engine snapshot in case of snapping/dropping attempt
11907 if ((game.snapshot.last_action[i] & KEY_BUTTON) == 0 &&
11908 (stored_player[i].effective_action & KEY_BUTTON) != 0)
11909 game.snapshot.changed_action = TRUE;
11911 game.snapshot.last_action[i] = stored_player[i].effective_action;
11914 if (level.game_engine_type == GAME_ENGINE_TYPE_EM)
11916 GameActions_EM_Main();
11918 else if (level.game_engine_type == GAME_ENGINE_TYPE_SP)
11920 GameActions_SP_Main();
11922 else if (level.game_engine_type == GAME_ENGINE_TYPE_MM)
11924 GameActions_MM_Main();
11928 GameActions_RND_Main();
11931 BlitScreenToBitmap(backbuffer);
11933 CheckLevelSolved();
11936 AdvanceFrameAndPlayerCounters(-1); // advance counters for all players
11938 if (global.show_frames_per_second)
11940 static unsigned int fps_counter = 0;
11941 static int fps_frames = 0;
11942 unsigned int fps_delay_ms = Counter() - fps_counter;
11946 if (fps_delay_ms >= 500) // calculate FPS every 0.5 seconds
11948 global.frames_per_second = 1000 * (float)fps_frames / fps_delay_ms;
11951 fps_counter = Counter();
11953 // always draw FPS to screen after FPS value was updated
11954 redraw_mask |= REDRAW_FPS;
11957 // only draw FPS if no screen areas are deactivated (invisible warp mode)
11958 if (GetDrawDeactivationMask() == REDRAW_NONE)
11959 redraw_mask |= REDRAW_FPS;
11963 static void GameActions_CheckSaveEngineSnapshot(void)
11965 if (!game.snapshot.save_snapshot)
11968 // clear flag for saving snapshot _before_ saving snapshot
11969 game.snapshot.save_snapshot = FALSE;
11971 SaveEngineSnapshotToList();
11974 void GameActions(void)
11978 GameActions_CheckSaveEngineSnapshot();
11981 void GameActions_EM_Main(void)
11983 byte effective_action[MAX_PLAYERS];
11984 boolean warp_mode = (tape.playing && tape.warp_forward && !tape.pausing);
11987 for (i = 0; i < MAX_PLAYERS; i++)
11988 effective_action[i] = stored_player[i].effective_action;
11990 GameActions_EM(effective_action, warp_mode);
11993 void GameActions_SP_Main(void)
11995 byte effective_action[MAX_PLAYERS];
11996 boolean warp_mode = (tape.playing && tape.warp_forward && !tape.pausing);
11999 for (i = 0; i < MAX_PLAYERS; i++)
12000 effective_action[i] = stored_player[i].effective_action;
12002 GameActions_SP(effective_action, warp_mode);
12004 for (i = 0; i < MAX_PLAYERS; i++)
12006 if (stored_player[i].force_dropping)
12007 stored_player[i].action |= KEY_BUTTON_DROP;
12009 stored_player[i].force_dropping = FALSE;
12013 void GameActions_MM_Main(void)
12015 boolean warp_mode = (tape.playing && tape.warp_forward && !tape.pausing);
12017 GameActions_MM(local_player->effective_mouse_action, warp_mode);
12020 void GameActions_RND_Main(void)
12025 void GameActions_RND(void)
12027 static struct MouseActionInfo mouse_action_last = { 0 };
12028 struct MouseActionInfo mouse_action = local_player->effective_mouse_action;
12029 int magic_wall_x = 0, magic_wall_y = 0;
12030 int i, x, y, element, graphic, last_gfx_frame;
12032 InitPlayfieldScanModeVars();
12034 if (game.engine_version >= VERSION_IDENT(3,2,0,7))
12036 SCAN_PLAYFIELD(x, y)
12038 ChangeCount[x][y] = 0;
12039 ChangeEvent[x][y] = -1;
12043 if (game.set_centered_player)
12045 boolean all_players_fit_to_screen = checkIfAllPlayersFitToScreen_RND();
12047 // switching to "all players" only possible if all players fit to screen
12048 if (game.centered_player_nr_next == -1 && !all_players_fit_to_screen)
12050 game.centered_player_nr_next = game.centered_player_nr;
12051 game.set_centered_player = FALSE;
12054 // do not switch focus to non-existing (or non-active) player
12055 if (game.centered_player_nr_next >= 0 &&
12056 !stored_player[game.centered_player_nr_next].active)
12058 game.centered_player_nr_next = game.centered_player_nr;
12059 game.set_centered_player = FALSE;
12063 if (game.set_centered_player &&
12064 ScreenMovPos == 0) // screen currently aligned at tile position
12068 if (game.centered_player_nr_next == -1)
12070 setScreenCenteredToAllPlayers(&sx, &sy);
12074 sx = stored_player[game.centered_player_nr_next].jx;
12075 sy = stored_player[game.centered_player_nr_next].jy;
12078 game.centered_player_nr = game.centered_player_nr_next;
12079 game.set_centered_player = FALSE;
12081 DrawRelocateScreen(0, 0, sx, sy, MV_NONE, TRUE, setup.quick_switch);
12082 DrawGameDoorValues();
12085 // check single step mode (set flag and clear again if any player is active)
12086 game.enter_single_step_mode =
12087 (tape.single_step && tape.recording && !tape.pausing);
12089 for (i = 0; i < MAX_PLAYERS; i++)
12091 int actual_player_action = stored_player[i].effective_action;
12094 /* !!! THIS BREAKS THE FOLLOWING TAPES: !!!
12095 - rnd_equinox_tetrachloride 048
12096 - rnd_equinox_tetrachloride_ii 096
12097 - rnd_emanuel_schmieg 002
12098 - doctor_sloan_ww 001, 020
12100 if (stored_player[i].MovPos == 0)
12101 CheckGravityMovement(&stored_player[i]);
12104 // overwrite programmed action with tape action
12105 if (stored_player[i].programmed_action)
12106 actual_player_action = stored_player[i].programmed_action;
12108 PlayerActions(&stored_player[i], actual_player_action);
12110 ScrollPlayer(&stored_player[i], SCROLL_GO_ON);
12113 // single step pause mode may already have been toggled by "ScrollPlayer()"
12114 if (game.enter_single_step_mode && !tape.pausing)
12115 TapeTogglePause(TAPE_TOGGLE_AUTOMATIC);
12117 ScrollScreen(NULL, SCROLL_GO_ON);
12119 /* for backwards compatibility, the following code emulates a fixed bug that
12120 occured when pushing elements (causing elements that just made their last
12121 pushing step to already (if possible) make their first falling step in the
12122 same game frame, which is bad); this code is also needed to use the famous
12123 "spring push bug" which is used in older levels and might be wanted to be
12124 used also in newer levels, but in this case the buggy pushing code is only
12125 affecting the "spring" element and no other elements */
12127 if (game.engine_version < VERSION_IDENT(2,2,0,7) || level.use_spring_bug)
12129 for (i = 0; i < MAX_PLAYERS; i++)
12131 struct PlayerInfo *player = &stored_player[i];
12132 int x = player->jx;
12133 int y = player->jy;
12135 if (player->active && player->is_pushing && player->is_moving &&
12137 (game.engine_version < VERSION_IDENT(2,2,0,7) ||
12138 Tile[x][y] == EL_SPRING))
12140 ContinueMoving(x, y);
12142 // continue moving after pushing (this is actually a bug)
12143 if (!IS_MOVING(x, y))
12144 Stop[x][y] = FALSE;
12149 SCAN_PLAYFIELD(x, y)
12151 Last[x][y] = Tile[x][y];
12153 ChangeCount[x][y] = 0;
12154 ChangeEvent[x][y] = -1;
12156 // this must be handled before main playfield loop
12157 if (Tile[x][y] == EL_PLAYER_IS_LEAVING)
12160 if (MovDelay[x][y] <= 0)
12164 if (Tile[x][y] == EL_ELEMENT_SNAPPING)
12167 if (MovDelay[x][y] <= 0)
12169 int element = Store[x][y];
12170 int move_direction = MovDir[x][y];
12171 int player_index_bit = Store2[x][y];
12177 TEST_DrawLevelField(x, y);
12179 TestFieldAfterSnapping(x, y, element, move_direction, player_index_bit);
12181 if (IS_ENVELOPE(element))
12182 local_player->show_envelope = element;
12187 if (ChangePage[x][y] != -1 && ChangeDelay[x][y] != 1)
12189 Debug("game:playing:GameActions_RND", "x = %d, y = %d: ChangePage != -1",
12191 Debug("game:playing:GameActions_RND", "This should never happen!");
12193 ChangePage[x][y] = -1;
12197 Stop[x][y] = FALSE;
12198 if (WasJustMoving[x][y] > 0)
12199 WasJustMoving[x][y]--;
12200 if (WasJustFalling[x][y] > 0)
12201 WasJustFalling[x][y]--;
12202 if (CheckCollision[x][y] > 0)
12203 CheckCollision[x][y]--;
12204 if (CheckImpact[x][y] > 0)
12205 CheckImpact[x][y]--;
12209 /* reset finished pushing action (not done in ContinueMoving() to allow
12210 continuous pushing animation for elements with zero push delay) */
12211 if (GfxAction[x][y] == ACTION_PUSHING && !IS_MOVING(x, y))
12213 ResetGfxAnimation(x, y);
12214 TEST_DrawLevelField(x, y);
12218 if (IS_BLOCKED(x, y))
12222 Blocked2Moving(x, y, &oldx, &oldy);
12223 if (!IS_MOVING(oldx, oldy))
12225 Debug("game:playing:GameActions_RND", "(BLOCKED => MOVING) context corrupted!");
12226 Debug("game:playing:GameActions_RND", "BLOCKED: x = %d, y = %d", x, y);
12227 Debug("game:playing:GameActions_RND", "!MOVING: oldx = %d, oldy = %d", oldx, oldy);
12228 Debug("game:playing:GameActions_RND", "This should never happen!");
12234 if (mouse_action.button)
12236 int new_button = (mouse_action.button && mouse_action_last.button == 0);
12237 int ch_button = CH_SIDE_FROM_BUTTON(mouse_action.button);
12239 x = mouse_action.lx;
12240 y = mouse_action.ly;
12241 element = Tile[x][y];
12245 CheckElementChangeByMouse(x, y, element, CE_CLICKED_BY_MOUSE, ch_button);
12246 CheckTriggeredElementChangeByMouse(x, y, element, CE_MOUSE_CLICKED_ON_X,
12250 CheckElementChangeByMouse(x, y, element, CE_PRESSED_BY_MOUSE, ch_button);
12251 CheckTriggeredElementChangeByMouse(x, y, element, CE_MOUSE_PRESSED_ON_X,
12255 SCAN_PLAYFIELD(x, y)
12257 element = Tile[x][y];
12258 graphic = el_act_dir2img(element, GfxAction[x][y], GfxDir[x][y]);
12259 last_gfx_frame = GfxFrame[x][y];
12261 ResetGfxFrame(x, y);
12263 if (GfxFrame[x][y] != last_gfx_frame && !Stop[x][y])
12264 DrawLevelGraphicAnimation(x, y, graphic);
12266 if (ANIM_MODE(graphic) == ANIM_RANDOM &&
12267 IS_NEXT_FRAME(GfxFrame[x][y], graphic))
12268 ResetRandomAnimationValue(x, y);
12270 SetRandomAnimationValue(x, y);
12272 PlayLevelSoundActionIfLoop(x, y, GfxAction[x][y]);
12274 if (IS_INACTIVE(element))
12276 if (IS_ANIMATED(graphic))
12277 DrawLevelGraphicAnimationIfNeeded(x, y, graphic);
12282 // this may take place after moving, so 'element' may have changed
12283 if (IS_CHANGING(x, y) &&
12284 (game.engine_version < VERSION_IDENT(3,0,7,1) || !Stop[x][y]))
12286 int page = element_info[element].event_page_nr[CE_DELAY];
12288 HandleElementChange(x, y, page);
12290 element = Tile[x][y];
12291 graphic = el_act_dir2img(element, GfxAction[x][y], GfxDir[x][y]);
12294 if (!IS_MOVING(x, y) && (CAN_FALL(element) || CAN_MOVE(element)))
12298 element = Tile[x][y];
12299 graphic = el_act_dir2img(element, GfxAction[x][y], GfxDir[x][y]);
12301 if (IS_ANIMATED(graphic) &&
12302 !IS_MOVING(x, y) &&
12304 DrawLevelGraphicAnimationIfNeeded(x, y, graphic);
12306 if (IS_GEM(element) || element == EL_SP_INFOTRON)
12307 TEST_DrawTwinkleOnField(x, y);
12309 else if (element == EL_ACID)
12312 DrawLevelGraphicAnimationIfNeeded(x, y, graphic);
12314 else if ((element == EL_EXIT_OPEN ||
12315 element == EL_EM_EXIT_OPEN ||
12316 element == EL_SP_EXIT_OPEN ||
12317 element == EL_STEEL_EXIT_OPEN ||
12318 element == EL_EM_STEEL_EXIT_OPEN ||
12319 element == EL_SP_TERMINAL ||
12320 element == EL_SP_TERMINAL_ACTIVE ||
12321 element == EL_EXTRA_TIME ||
12322 element == EL_SHIELD_NORMAL ||
12323 element == EL_SHIELD_DEADLY) &&
12324 IS_ANIMATED(graphic))
12325 DrawLevelGraphicAnimationIfNeeded(x, y, graphic);
12326 else if (IS_MOVING(x, y))
12327 ContinueMoving(x, y);
12328 else if (IS_ACTIVE_BOMB(element))
12329 CheckDynamite(x, y);
12330 else if (element == EL_AMOEBA_GROWING)
12331 AmoebaGrowing(x, y);
12332 else if (element == EL_AMOEBA_SHRINKING)
12333 AmoebaShrinking(x, y);
12335 #if !USE_NEW_AMOEBA_CODE
12336 else if (IS_AMOEBALIVE(element))
12337 AmoebaReproduce(x, y);
12340 else if (element == EL_GAME_OF_LIFE || element == EL_BIOMAZE)
12342 else if (element == EL_EXIT_CLOSED)
12344 else if (element == EL_EM_EXIT_CLOSED)
12346 else if (element == EL_STEEL_EXIT_CLOSED)
12347 CheckExitSteel(x, y);
12348 else if (element == EL_EM_STEEL_EXIT_CLOSED)
12349 CheckExitSteelEM(x, y);
12350 else if (element == EL_SP_EXIT_CLOSED)
12352 else if (element == EL_EXPANDABLE_WALL_GROWING ||
12353 element == EL_EXPANDABLE_STEELWALL_GROWING)
12354 MauerWaechst(x, y);
12355 else if (element == EL_EXPANDABLE_WALL ||
12356 element == EL_EXPANDABLE_WALL_HORIZONTAL ||
12357 element == EL_EXPANDABLE_WALL_VERTICAL ||
12358 element == EL_EXPANDABLE_WALL_ANY ||
12359 element == EL_BD_EXPANDABLE_WALL)
12360 MauerAbleger(x, y);
12361 else if (element == EL_EXPANDABLE_STEELWALL_HORIZONTAL ||
12362 element == EL_EXPANDABLE_STEELWALL_VERTICAL ||
12363 element == EL_EXPANDABLE_STEELWALL_ANY)
12364 MauerAblegerStahl(x, y);
12365 else if (element == EL_FLAMES)
12366 CheckForDragon(x, y);
12367 else if (element == EL_EXPLOSION)
12368 ; // drawing of correct explosion animation is handled separately
12369 else if (element == EL_ELEMENT_SNAPPING ||
12370 element == EL_DIAGONAL_SHRINKING ||
12371 element == EL_DIAGONAL_GROWING)
12373 graphic = el_act_dir2img(GfxElement[x][y], GfxAction[x][y],GfxDir[x][y]);
12375 DrawLevelGraphicAnimationIfNeeded(x, y, graphic);
12377 else if (IS_ANIMATED(graphic) && !IS_CHANGING(x, y))
12378 DrawLevelGraphicAnimationIfNeeded(x, y, graphic);
12380 if (IS_BELT_ACTIVE(element))
12381 PlayLevelSoundAction(x, y, ACTION_ACTIVE);
12383 if (game.magic_wall_active)
12385 int jx = local_player->jx, jy = local_player->jy;
12387 // play the element sound at the position nearest to the player
12388 if ((element == EL_MAGIC_WALL_FULL ||
12389 element == EL_MAGIC_WALL_ACTIVE ||
12390 element == EL_MAGIC_WALL_EMPTYING ||
12391 element == EL_BD_MAGIC_WALL_FULL ||
12392 element == EL_BD_MAGIC_WALL_ACTIVE ||
12393 element == EL_BD_MAGIC_WALL_EMPTYING ||
12394 element == EL_DC_MAGIC_WALL_FULL ||
12395 element == EL_DC_MAGIC_WALL_ACTIVE ||
12396 element == EL_DC_MAGIC_WALL_EMPTYING) &&
12397 ABS(x - jx) + ABS(y - jy) <
12398 ABS(magic_wall_x - jx) + ABS(magic_wall_y - jy))
12406 #if USE_NEW_AMOEBA_CODE
12407 // new experimental amoeba growth stuff
12408 if (!(FrameCounter % 8))
12410 static unsigned int random = 1684108901;
12412 for (i = 0; i < level.amoeba_speed * 28 / 8; i++)
12414 x = RND(lev_fieldx);
12415 y = RND(lev_fieldy);
12416 element = Tile[x][y];
12418 if (!IS_PLAYER(x,y) &&
12419 (element == EL_EMPTY ||
12420 CAN_GROW_INTO(element) ||
12421 element == EL_QUICKSAND_EMPTY ||
12422 element == EL_QUICKSAND_FAST_EMPTY ||
12423 element == EL_ACID_SPLASH_LEFT ||
12424 element == EL_ACID_SPLASH_RIGHT))
12426 if ((IN_LEV_FIELD(x, y-1) && Tile[x][y-1] == EL_AMOEBA_WET) ||
12427 (IN_LEV_FIELD(x-1, y) && Tile[x-1][y] == EL_AMOEBA_WET) ||
12428 (IN_LEV_FIELD(x+1, y) && Tile[x+1][y] == EL_AMOEBA_WET) ||
12429 (IN_LEV_FIELD(x, y+1) && Tile[x][y+1] == EL_AMOEBA_WET))
12430 Tile[x][y] = EL_AMOEBA_DROP;
12433 random = random * 129 + 1;
12438 game.explosions_delayed = FALSE;
12440 SCAN_PLAYFIELD(x, y)
12442 element = Tile[x][y];
12444 if (ExplodeField[x][y])
12445 Explode(x, y, EX_PHASE_START, ExplodeField[x][y]);
12446 else if (element == EL_EXPLOSION)
12447 Explode(x, y, ExplodePhase[x][y], EX_TYPE_NORMAL);
12449 ExplodeField[x][y] = EX_TYPE_NONE;
12452 game.explosions_delayed = TRUE;
12454 if (game.magic_wall_active)
12456 if (!(game.magic_wall_time_left % 4))
12458 int element = Tile[magic_wall_x][magic_wall_y];
12460 if (element == EL_BD_MAGIC_WALL_FULL ||
12461 element == EL_BD_MAGIC_WALL_ACTIVE ||
12462 element == EL_BD_MAGIC_WALL_EMPTYING)
12463 PlayLevelSound(magic_wall_x, magic_wall_y, SND_BD_MAGIC_WALL_ACTIVE);
12464 else if (element == EL_DC_MAGIC_WALL_FULL ||
12465 element == EL_DC_MAGIC_WALL_ACTIVE ||
12466 element == EL_DC_MAGIC_WALL_EMPTYING)
12467 PlayLevelSound(magic_wall_x, magic_wall_y, SND_DC_MAGIC_WALL_ACTIVE);
12469 PlayLevelSound(magic_wall_x, magic_wall_y, SND_MAGIC_WALL_ACTIVE);
12472 if (game.magic_wall_time_left > 0)
12474 game.magic_wall_time_left--;
12476 if (!game.magic_wall_time_left)
12478 SCAN_PLAYFIELD(x, y)
12480 element = Tile[x][y];
12482 if (element == EL_MAGIC_WALL_ACTIVE ||
12483 element == EL_MAGIC_WALL_FULL)
12485 Tile[x][y] = EL_MAGIC_WALL_DEAD;
12486 TEST_DrawLevelField(x, y);
12488 else if (element == EL_BD_MAGIC_WALL_ACTIVE ||
12489 element == EL_BD_MAGIC_WALL_FULL)
12491 Tile[x][y] = EL_BD_MAGIC_WALL_DEAD;
12492 TEST_DrawLevelField(x, y);
12494 else if (element == EL_DC_MAGIC_WALL_ACTIVE ||
12495 element == EL_DC_MAGIC_WALL_FULL)
12497 Tile[x][y] = EL_DC_MAGIC_WALL_DEAD;
12498 TEST_DrawLevelField(x, y);
12502 game.magic_wall_active = FALSE;
12507 if (game.light_time_left > 0)
12509 game.light_time_left--;
12511 if (game.light_time_left == 0)
12512 RedrawAllLightSwitchesAndInvisibleElements();
12515 if (game.timegate_time_left > 0)
12517 game.timegate_time_left--;
12519 if (game.timegate_time_left == 0)
12520 CloseAllOpenTimegates();
12523 if (game.lenses_time_left > 0)
12525 game.lenses_time_left--;
12527 if (game.lenses_time_left == 0)
12528 RedrawAllInvisibleElementsForLenses();
12531 if (game.magnify_time_left > 0)
12533 game.magnify_time_left--;
12535 if (game.magnify_time_left == 0)
12536 RedrawAllInvisibleElementsForMagnifier();
12539 for (i = 0; i < MAX_PLAYERS; i++)
12541 struct PlayerInfo *player = &stored_player[i];
12543 if (SHIELD_ON(player))
12545 if (player->shield_deadly_time_left)
12546 PlayLevelSound(player->jx, player->jy, SND_SHIELD_DEADLY_ACTIVE);
12547 else if (player->shield_normal_time_left)
12548 PlayLevelSound(player->jx, player->jy, SND_SHIELD_NORMAL_ACTIVE);
12552 #if USE_DELAYED_GFX_REDRAW
12553 SCAN_PLAYFIELD(x, y)
12555 if (GfxRedraw[x][y] != GFX_REDRAW_NONE)
12557 /* !!! PROBLEM: THIS REDRAWS THE PLAYFIELD _AFTER_ THE SCAN, BUT TILES
12558 !!! MAY HAVE CHANGED AFTER BEING DRAWN DURING PLAYFIELD SCAN !!! */
12560 if (GfxRedraw[x][y] & GFX_REDRAW_TILE)
12561 DrawLevelField(x, y);
12563 if (GfxRedraw[x][y] & GFX_REDRAW_TILE_CRUMBLED)
12564 DrawLevelFieldCrumbled(x, y);
12566 if (GfxRedraw[x][y] & GFX_REDRAW_TILE_CRUMBLED_NEIGHBOURS)
12567 DrawLevelFieldCrumbledNeighbours(x, y);
12569 if (GfxRedraw[x][y] & GFX_REDRAW_TILE_TWINKLED)
12570 DrawTwinkleOnField(x, y);
12573 GfxRedraw[x][y] = GFX_REDRAW_NONE;
12578 PlayAllPlayersSound();
12580 for (i = 0; i < MAX_PLAYERS; i++)
12582 struct PlayerInfo *player = &stored_player[i];
12584 if (player->show_envelope != 0 && (!player->active ||
12585 player->MovPos == 0))
12587 ShowEnvelope(player->show_envelope - EL_ENVELOPE_1);
12589 player->show_envelope = 0;
12593 // use random number generator in every frame to make it less predictable
12594 if (game.engine_version >= VERSION_IDENT(3,1,1,0))
12597 mouse_action_last = mouse_action;
12600 static boolean AllPlayersInSight(struct PlayerInfo *player, int x, int y)
12602 int min_x = x, min_y = y, max_x = x, max_y = y;
12603 int scr_fieldx = getScreenFieldSizeX();
12604 int scr_fieldy = getScreenFieldSizeY();
12607 for (i = 0; i < MAX_PLAYERS; i++)
12609 int jx = stored_player[i].jx, jy = stored_player[i].jy;
12611 if (!stored_player[i].active || &stored_player[i] == player)
12614 min_x = MIN(min_x, jx);
12615 min_y = MIN(min_y, jy);
12616 max_x = MAX(max_x, jx);
12617 max_y = MAX(max_y, jy);
12620 return (max_x - min_x < scr_fieldx && max_y - min_y < scr_fieldy);
12623 static boolean AllPlayersInVisibleScreen(void)
12627 for (i = 0; i < MAX_PLAYERS; i++)
12629 int jx = stored_player[i].jx, jy = stored_player[i].jy;
12631 if (!stored_player[i].active)
12634 if (!IN_VIS_FIELD(SCREENX(jx), SCREENY(jy)))
12641 void ScrollLevel(int dx, int dy)
12643 int scroll_offset = 2 * TILEX_VAR;
12646 BlitBitmap(drawto_field, drawto_field,
12647 FX + TILEX_VAR * (dx == -1) - scroll_offset,
12648 FY + TILEY_VAR * (dy == -1) - scroll_offset,
12649 SXSIZE - TILEX_VAR * (dx != 0) + 2 * scroll_offset,
12650 SYSIZE - TILEY_VAR * (dy != 0) + 2 * scroll_offset,
12651 FX + TILEX_VAR * (dx == 1) - scroll_offset,
12652 FY + TILEY_VAR * (dy == 1) - scroll_offset);
12656 x = (dx == 1 ? BX1 : BX2);
12657 for (y = BY1; y <= BY2; y++)
12658 DrawScreenField(x, y);
12663 y = (dy == 1 ? BY1 : BY2);
12664 for (x = BX1; x <= BX2; x++)
12665 DrawScreenField(x, y);
12668 redraw_mask |= REDRAW_FIELD;
12671 static boolean canFallDown(struct PlayerInfo *player)
12673 int jx = player->jx, jy = player->jy;
12675 return (IN_LEV_FIELD(jx, jy + 1) &&
12676 (IS_FREE(jx, jy + 1) ||
12677 (Tile[jx][jy + 1] == EL_ACID && player->can_fall_into_acid)) &&
12678 IS_WALKABLE_FROM(Tile[jx][jy], MV_DOWN) &&
12679 !IS_WALKABLE_INSIDE(Tile[jx][jy]));
12682 static boolean canPassField(int x, int y, int move_dir)
12684 int opposite_dir = MV_DIR_OPPOSITE(move_dir);
12685 int dx = (move_dir & MV_LEFT ? -1 : move_dir & MV_RIGHT ? +1 : 0);
12686 int dy = (move_dir & MV_UP ? -1 : move_dir & MV_DOWN ? +1 : 0);
12687 int nextx = x + dx;
12688 int nexty = y + dy;
12689 int element = Tile[x][y];
12691 return (IS_PASSABLE_FROM(element, opposite_dir) &&
12692 !CAN_MOVE(element) &&
12693 IN_LEV_FIELD(nextx, nexty) && !IS_PLAYER(nextx, nexty) &&
12694 IS_WALKABLE_FROM(Tile[nextx][nexty], move_dir) &&
12695 (level.can_pass_to_walkable || IS_FREE(nextx, nexty)));
12698 static boolean canMoveToValidFieldWithGravity(int x, int y, int move_dir)
12700 int opposite_dir = MV_DIR_OPPOSITE(move_dir);
12701 int dx = (move_dir & MV_LEFT ? -1 : move_dir & MV_RIGHT ? +1 : 0);
12702 int dy = (move_dir & MV_UP ? -1 : move_dir & MV_DOWN ? +1 : 0);
12706 return (IN_LEV_FIELD(newx, newy) && !IS_FREE_OR_PLAYER(newx, newy) &&
12707 IS_GRAVITY_REACHABLE(Tile[newx][newy]) &&
12708 (IS_DIGGABLE(Tile[newx][newy]) ||
12709 IS_WALKABLE_FROM(Tile[newx][newy], opposite_dir) ||
12710 canPassField(newx, newy, move_dir)));
12713 static void CheckGravityMovement(struct PlayerInfo *player)
12715 if (player->gravity && !player->programmed_action)
12717 int move_dir_horizontal = player->effective_action & MV_HORIZONTAL;
12718 int move_dir_vertical = player->effective_action & MV_VERTICAL;
12719 boolean player_is_snapping = (player->effective_action & JOY_BUTTON_1);
12720 int jx = player->jx, jy = player->jy;
12721 boolean player_is_moving_to_valid_field =
12722 (!player_is_snapping &&
12723 (canMoveToValidFieldWithGravity(jx, jy, move_dir_horizontal) ||
12724 canMoveToValidFieldWithGravity(jx, jy, move_dir_vertical)));
12725 boolean player_can_fall_down = canFallDown(player);
12727 if (player_can_fall_down &&
12728 !player_is_moving_to_valid_field)
12729 player->programmed_action = MV_DOWN;
12733 static void CheckGravityMovementWhenNotMoving(struct PlayerInfo *player)
12735 return CheckGravityMovement(player);
12737 if (player->gravity && !player->programmed_action)
12739 int jx = player->jx, jy = player->jy;
12740 boolean field_under_player_is_free =
12741 (IN_LEV_FIELD(jx, jy + 1) && IS_FREE(jx, jy + 1));
12742 boolean player_is_standing_on_valid_field =
12743 (IS_WALKABLE_INSIDE(Tile[jx][jy]) ||
12744 (IS_WALKABLE(Tile[jx][jy]) &&
12745 !(element_info[Tile[jx][jy]].access_direction & MV_DOWN)));
12747 if (field_under_player_is_free && !player_is_standing_on_valid_field)
12748 player->programmed_action = MV_DOWN;
12753 MovePlayerOneStep()
12754 -----------------------------------------------------------------------------
12755 dx, dy: direction (non-diagonal) to try to move the player to
12756 real_dx, real_dy: direction as read from input device (can be diagonal)
12759 boolean MovePlayerOneStep(struct PlayerInfo *player,
12760 int dx, int dy, int real_dx, int real_dy)
12762 int jx = player->jx, jy = player->jy;
12763 int new_jx = jx + dx, new_jy = jy + dy;
12765 boolean player_can_move = !player->cannot_move;
12767 if (!player->active || (!dx && !dy))
12768 return MP_NO_ACTION;
12770 player->MovDir = (dx < 0 ? MV_LEFT :
12771 dx > 0 ? MV_RIGHT :
12773 dy > 0 ? MV_DOWN : MV_NONE);
12775 if (!IN_LEV_FIELD(new_jx, new_jy))
12776 return MP_NO_ACTION;
12778 if (!player_can_move)
12780 if (player->MovPos == 0)
12782 player->is_moving = FALSE;
12783 player->is_digging = FALSE;
12784 player->is_collecting = FALSE;
12785 player->is_snapping = FALSE;
12786 player->is_pushing = FALSE;
12790 if (!network.enabled && game.centered_player_nr == -1 &&
12791 !AllPlayersInSight(player, new_jx, new_jy))
12792 return MP_NO_ACTION;
12794 can_move = DigField(player, jx, jy, new_jx, new_jy, real_dx,real_dy, DF_DIG);
12795 if (can_move != MP_MOVING)
12798 // check if DigField() has caused relocation of the player
12799 if (player->jx != jx || player->jy != jy)
12800 return MP_NO_ACTION; // <-- !!! CHECK THIS [-> MP_ACTION ?] !!!
12802 StorePlayer[jx][jy] = 0;
12803 player->last_jx = jx;
12804 player->last_jy = jy;
12805 player->jx = new_jx;
12806 player->jy = new_jy;
12807 StorePlayer[new_jx][new_jy] = player->element_nr;
12809 if (player->move_delay_value_next != -1)
12811 player->move_delay_value = player->move_delay_value_next;
12812 player->move_delay_value_next = -1;
12816 (dx > 0 || dy > 0 ? -1 : 1) * (TILEX - TILEX / player->move_delay_value);
12818 player->step_counter++;
12820 PlayerVisit[jx][jy] = FrameCounter;
12822 player->is_moving = TRUE;
12825 // should better be called in MovePlayer(), but this breaks some tapes
12826 ScrollPlayer(player, SCROLL_INIT);
12832 boolean MovePlayer(struct PlayerInfo *player, int dx, int dy)
12834 int jx = player->jx, jy = player->jy;
12835 int old_jx = jx, old_jy = jy;
12836 int moved = MP_NO_ACTION;
12838 if (!player->active)
12843 if (player->MovPos == 0)
12845 player->is_moving = FALSE;
12846 player->is_digging = FALSE;
12847 player->is_collecting = FALSE;
12848 player->is_snapping = FALSE;
12849 player->is_pushing = FALSE;
12855 if (player->move_delay > 0)
12858 player->move_delay = -1; // set to "uninitialized" value
12860 // store if player is automatically moved to next field
12861 player->is_auto_moving = (player->programmed_action != MV_NONE);
12863 // remove the last programmed player action
12864 player->programmed_action = 0;
12866 if (player->MovPos)
12868 // should only happen if pre-1.2 tape recordings are played
12869 // this is only for backward compatibility
12871 int original_move_delay_value = player->move_delay_value;
12874 Debug("game:playing:MovePlayer",
12875 "THIS SHOULD ONLY HAPPEN WITH PRE-1.2 LEVEL TAPES. [%d]",
12879 // scroll remaining steps with finest movement resolution
12880 player->move_delay_value = MOVE_DELAY_NORMAL_SPEED;
12882 while (player->MovPos)
12884 ScrollPlayer(player, SCROLL_GO_ON);
12885 ScrollScreen(NULL, SCROLL_GO_ON);
12887 AdvanceFrameAndPlayerCounters(player->index_nr);
12890 BackToFront_WithFrameDelay(0);
12893 player->move_delay_value = original_move_delay_value;
12896 player->is_active = FALSE;
12898 if (player->last_move_dir & MV_HORIZONTAL)
12900 if (!(moved |= MovePlayerOneStep(player, 0, dy, dx, dy)))
12901 moved |= MovePlayerOneStep(player, dx, 0, dx, dy);
12905 if (!(moved |= MovePlayerOneStep(player, dx, 0, dx, dy)))
12906 moved |= MovePlayerOneStep(player, 0, dy, dx, dy);
12909 if (!moved && !player->is_active)
12911 player->is_moving = FALSE;
12912 player->is_digging = FALSE;
12913 player->is_collecting = FALSE;
12914 player->is_snapping = FALSE;
12915 player->is_pushing = FALSE;
12921 if (moved & MP_MOVING && !ScreenMovPos &&
12922 (player->index_nr == game.centered_player_nr ||
12923 game.centered_player_nr == -1))
12925 int old_scroll_x = scroll_x, old_scroll_y = scroll_y;
12927 if (!IN_VIS_FIELD(SCREENX(jx), SCREENY(jy)))
12929 // actual player has left the screen -- scroll in that direction
12930 if (jx != old_jx) // player has moved horizontally
12931 scroll_x += (jx - old_jx);
12932 else // player has moved vertically
12933 scroll_y += (jy - old_jy);
12937 int offset_raw = game.scroll_delay_value;
12939 if (jx != old_jx) // player has moved horizontally
12941 int offset = MIN(offset_raw, (SCR_FIELDX - 2) / 2);
12942 int offset_x = offset * (player->MovDir == MV_LEFT ? +1 : -1);
12943 int new_scroll_x = jx - MIDPOSX + offset_x;
12945 if ((player->MovDir == MV_LEFT && scroll_x > new_scroll_x) ||
12946 (player->MovDir == MV_RIGHT && scroll_x < new_scroll_x))
12947 scroll_x = new_scroll_x;
12949 // don't scroll over playfield boundaries
12950 scroll_x = MIN(MAX(SBX_Left, scroll_x), SBX_Right);
12952 // don't scroll more than one field at a time
12953 scroll_x = old_scroll_x + SIGN(scroll_x - old_scroll_x);
12955 // don't scroll against the player's moving direction
12956 if ((player->MovDir == MV_LEFT && scroll_x > old_scroll_x) ||
12957 (player->MovDir == MV_RIGHT && scroll_x < old_scroll_x))
12958 scroll_x = old_scroll_x;
12960 else // player has moved vertically
12962 int offset = MIN(offset_raw, (SCR_FIELDY - 2) / 2);
12963 int offset_y = offset * (player->MovDir == MV_UP ? +1 : -1);
12964 int new_scroll_y = jy - MIDPOSY + offset_y;
12966 if ((player->MovDir == MV_UP && scroll_y > new_scroll_y) ||
12967 (player->MovDir == MV_DOWN && scroll_y < new_scroll_y))
12968 scroll_y = new_scroll_y;
12970 // don't scroll over playfield boundaries
12971 scroll_y = MIN(MAX(SBY_Upper, scroll_y), SBY_Lower);
12973 // don't scroll more than one field at a time
12974 scroll_y = old_scroll_y + SIGN(scroll_y - old_scroll_y);
12976 // don't scroll against the player's moving direction
12977 if ((player->MovDir == MV_UP && scroll_y > old_scroll_y) ||
12978 (player->MovDir == MV_DOWN && scroll_y < old_scroll_y))
12979 scroll_y = old_scroll_y;
12983 if (scroll_x != old_scroll_x || scroll_y != old_scroll_y)
12985 if (!network.enabled && game.centered_player_nr == -1 &&
12986 !AllPlayersInVisibleScreen())
12988 scroll_x = old_scroll_x;
12989 scroll_y = old_scroll_y;
12993 ScrollScreen(player, SCROLL_INIT);
12994 ScrollLevel(old_scroll_x - scroll_x, old_scroll_y - scroll_y);
12999 player->StepFrame = 0;
13001 if (moved & MP_MOVING)
13003 if (old_jx != jx && old_jy == jy)
13004 player->MovDir = (old_jx < jx ? MV_RIGHT : MV_LEFT);
13005 else if (old_jx == jx && old_jy != jy)
13006 player->MovDir = (old_jy < jy ? MV_DOWN : MV_UP);
13008 TEST_DrawLevelField(jx, jy); // for "crumbled sand"
13010 player->last_move_dir = player->MovDir;
13011 player->is_moving = TRUE;
13012 player->is_snapping = FALSE;
13013 player->is_switching = FALSE;
13014 player->is_dropping = FALSE;
13015 player->is_dropping_pressed = FALSE;
13016 player->drop_pressed_delay = 0;
13019 // should better be called here than above, but this breaks some tapes
13020 ScrollPlayer(player, SCROLL_INIT);
13025 CheckGravityMovementWhenNotMoving(player);
13027 player->is_moving = FALSE;
13029 /* at this point, the player is allowed to move, but cannot move right now
13030 (e.g. because of something blocking the way) -- ensure that the player
13031 is also allowed to move in the next frame (in old versions before 3.1.1,
13032 the player was forced to wait again for eight frames before next try) */
13034 if (game.engine_version >= VERSION_IDENT(3,1,1,0))
13035 player->move_delay = 0; // allow direct movement in the next frame
13038 if (player->move_delay == -1) // not yet initialized by DigField()
13039 player->move_delay = player->move_delay_value;
13041 if (game.engine_version < VERSION_IDENT(3,0,7,0))
13043 TestIfPlayerTouchesBadThing(jx, jy);
13044 TestIfPlayerTouchesCustomElement(jx, jy);
13047 if (!player->active)
13048 RemovePlayer(player);
13053 void ScrollPlayer(struct PlayerInfo *player, int mode)
13055 int jx = player->jx, jy = player->jy;
13056 int last_jx = player->last_jx, last_jy = player->last_jy;
13057 int move_stepsize = TILEX / player->move_delay_value;
13059 if (!player->active)
13062 if (player->MovPos == 0 && mode == SCROLL_GO_ON) // player not moving
13065 if (mode == SCROLL_INIT)
13067 player->actual_frame_counter = FrameCounter;
13068 player->GfxPos = move_stepsize * (player->MovPos / move_stepsize);
13070 if ((player->block_last_field || player->block_delay_adjustment > 0) &&
13071 Tile[last_jx][last_jy] == EL_EMPTY)
13073 int last_field_block_delay = 0; // start with no blocking at all
13074 int block_delay_adjustment = player->block_delay_adjustment;
13076 // if player blocks last field, add delay for exactly one move
13077 if (player->block_last_field)
13079 last_field_block_delay += player->move_delay_value;
13081 // when blocking enabled, prevent moving up despite gravity
13082 if (player->gravity && player->MovDir == MV_UP)
13083 block_delay_adjustment = -1;
13086 // add block delay adjustment (also possible when not blocking)
13087 last_field_block_delay += block_delay_adjustment;
13089 Tile[last_jx][last_jy] = EL_PLAYER_IS_LEAVING;
13090 MovDelay[last_jx][last_jy] = last_field_block_delay + 1;
13093 if (player->MovPos != 0) // player has not yet reached destination
13096 else if (!FrameReached(&player->actual_frame_counter, 1))
13099 if (player->MovPos != 0)
13101 player->MovPos += (player->MovPos > 0 ? -1 : 1) * move_stepsize;
13102 player->GfxPos = move_stepsize * (player->MovPos / move_stepsize);
13104 // before DrawPlayer() to draw correct player graphic for this case
13105 if (player->MovPos == 0)
13106 CheckGravityMovement(player);
13109 if (player->MovPos == 0) // player reached destination field
13111 if (player->move_delay_reset_counter > 0)
13113 player->move_delay_reset_counter--;
13115 if (player->move_delay_reset_counter == 0)
13117 // continue with normal speed after quickly moving through gate
13118 HALVE_PLAYER_SPEED(player);
13120 // be able to make the next move without delay
13121 player->move_delay = 0;
13125 player->last_jx = jx;
13126 player->last_jy = jy;
13128 if (Tile[jx][jy] == EL_EXIT_OPEN ||
13129 Tile[jx][jy] == EL_EM_EXIT_OPEN ||
13130 Tile[jx][jy] == EL_EM_EXIT_OPENING ||
13131 Tile[jx][jy] == EL_STEEL_EXIT_OPEN ||
13132 Tile[jx][jy] == EL_EM_STEEL_EXIT_OPEN ||
13133 Tile[jx][jy] == EL_EM_STEEL_EXIT_OPENING ||
13134 Tile[jx][jy] == EL_SP_EXIT_OPEN ||
13135 Tile[jx][jy] == EL_SP_EXIT_OPENING) // <-- special case
13137 ExitPlayer(player);
13139 if (game.players_still_needed == 0 &&
13140 (game.friends_still_needed == 0 ||
13141 IS_SP_ELEMENT(Tile[jx][jy])))
13145 // this breaks one level: "machine", level 000
13147 int move_direction = player->MovDir;
13148 int enter_side = MV_DIR_OPPOSITE(move_direction);
13149 int leave_side = move_direction;
13150 int old_jx = last_jx;
13151 int old_jy = last_jy;
13152 int old_element = Tile[old_jx][old_jy];
13153 int new_element = Tile[jx][jy];
13155 if (IS_CUSTOM_ELEMENT(old_element))
13156 CheckElementChangeByPlayer(old_jx, old_jy, old_element,
13158 player->index_bit, leave_side);
13160 CheckTriggeredElementChangeByPlayer(old_jx, old_jy, old_element,
13161 CE_PLAYER_LEAVES_X,
13162 player->index_bit, leave_side);
13164 if (IS_CUSTOM_ELEMENT(new_element))
13165 CheckElementChangeByPlayer(jx, jy, new_element, CE_ENTERED_BY_PLAYER,
13166 player->index_bit, enter_side);
13168 CheckTriggeredElementChangeByPlayer(jx, jy, new_element,
13169 CE_PLAYER_ENTERS_X,
13170 player->index_bit, enter_side);
13172 CheckTriggeredElementChangeBySide(jx, jy, player->initial_element,
13173 CE_MOVE_OF_X, move_direction);
13176 if (game.engine_version >= VERSION_IDENT(3,0,7,0))
13178 TestIfPlayerTouchesBadThing(jx, jy);
13179 TestIfPlayerTouchesCustomElement(jx, jy);
13181 /* needed because pushed element has not yet reached its destination,
13182 so it would trigger a change event at its previous field location */
13183 if (!player->is_pushing)
13184 TestIfElementTouchesCustomElement(jx, jy); // for empty space
13186 if (level.finish_dig_collect &&
13187 (player->is_digging || player->is_collecting))
13189 int last_element = player->last_removed_element;
13190 int move_direction = player->MovDir;
13191 int enter_side = MV_DIR_OPPOSITE(move_direction);
13192 int change_event = (player->is_digging ? CE_PLAYER_DIGS_X :
13193 CE_PLAYER_COLLECTS_X);
13195 CheckTriggeredElementChangeByPlayer(jx, jy, last_element, change_event,
13196 player->index_bit, enter_side);
13198 player->last_removed_element = EL_UNDEFINED;
13201 if (!player->active)
13202 RemovePlayer(player);
13205 if (level.use_step_counter)
13215 if (TimeLeft <= 10 && setup.time_limit && !game.LevelSolved)
13216 PlaySound(SND_GAME_RUNNING_OUT_OF_TIME);
13218 game_panel_controls[GAME_PANEL_TIME].value = TimeLeft;
13220 DisplayGameControlValues();
13222 if (!TimeLeft && setup.time_limit && !game.LevelSolved)
13223 for (i = 0; i < MAX_PLAYERS; i++)
13224 KillPlayer(&stored_player[i]);
13226 else if (game.no_time_limit && !game.all_players_gone)
13228 game_panel_controls[GAME_PANEL_TIME].value = TimePlayed;
13230 DisplayGameControlValues();
13234 if (tape.single_step && tape.recording && !tape.pausing &&
13235 !player->programmed_action)
13236 TapeTogglePause(TAPE_TOGGLE_AUTOMATIC);
13238 if (!player->programmed_action)
13239 CheckSaveEngineSnapshot(player);
13243 void ScrollScreen(struct PlayerInfo *player, int mode)
13245 static unsigned int screen_frame_counter = 0;
13247 if (mode == SCROLL_INIT)
13249 // set scrolling step size according to actual player's moving speed
13250 ScrollStepSize = TILEX / player->move_delay_value;
13252 screen_frame_counter = FrameCounter;
13253 ScreenMovDir = player->MovDir;
13254 ScreenMovPos = player->MovPos;
13255 ScreenGfxPos = ScrollStepSize * (ScreenMovPos / ScrollStepSize);
13258 else if (!FrameReached(&screen_frame_counter, 1))
13263 ScreenMovPos += (ScreenMovPos > 0 ? -1 : 1) * ScrollStepSize;
13264 ScreenGfxPos = ScrollStepSize * (ScreenMovPos / ScrollStepSize);
13265 redraw_mask |= REDRAW_FIELD;
13268 ScreenMovDir = MV_NONE;
13271 void TestIfPlayerTouchesCustomElement(int x, int y)
13273 static int xy[4][2] =
13280 static int trigger_sides[4][2] =
13282 // center side border side
13283 { CH_SIDE_TOP, CH_SIDE_BOTTOM }, // check top
13284 { CH_SIDE_LEFT, CH_SIDE_RIGHT }, // check left
13285 { CH_SIDE_RIGHT, CH_SIDE_LEFT }, // check right
13286 { CH_SIDE_BOTTOM, CH_SIDE_TOP } // check bottom
13288 static int touch_dir[4] =
13290 MV_LEFT | MV_RIGHT,
13295 int center_element = Tile[x][y]; // should always be non-moving!
13298 for (i = 0; i < NUM_DIRECTIONS; i++)
13300 int xx = x + xy[i][0];
13301 int yy = y + xy[i][1];
13302 int center_side = trigger_sides[i][0];
13303 int border_side = trigger_sides[i][1];
13304 int border_element;
13306 if (!IN_LEV_FIELD(xx, yy))
13309 if (IS_PLAYER(x, y)) // player found at center element
13311 struct PlayerInfo *player = PLAYERINFO(x, y);
13313 if (game.engine_version < VERSION_IDENT(3,0,7,0))
13314 border_element = Tile[xx][yy]; // may be moving!
13315 else if (!IS_MOVING(xx, yy) && !IS_BLOCKED(xx, yy))
13316 border_element = Tile[xx][yy];
13317 else if (MovDir[xx][yy] & touch_dir[i]) // elements are touching
13318 border_element = MovingOrBlocked2Element(xx, yy);
13320 continue; // center and border element do not touch
13322 CheckElementChangeByPlayer(xx, yy, border_element, CE_TOUCHED_BY_PLAYER,
13323 player->index_bit, border_side);
13324 CheckTriggeredElementChangeByPlayer(xx, yy, border_element,
13325 CE_PLAYER_TOUCHES_X,
13326 player->index_bit, border_side);
13329 /* use player element that is initially defined in the level playfield,
13330 not the player element that corresponds to the runtime player number
13331 (example: a level that contains EL_PLAYER_3 as the only player would
13332 incorrectly give EL_PLAYER_1 for "player->element_nr") */
13333 int player_element = PLAYERINFO(x, y)->initial_element;
13335 CheckElementChangeBySide(xx, yy, border_element, player_element,
13336 CE_TOUCHING_X, border_side);
13339 else if (IS_PLAYER(xx, yy)) // player found at border element
13341 struct PlayerInfo *player = PLAYERINFO(xx, yy);
13343 if (game.engine_version >= VERSION_IDENT(3,0,7,0))
13345 if (player->MovPos != 0 && !(player->MovDir & touch_dir[i]))
13346 continue; // center and border element do not touch
13349 CheckElementChangeByPlayer(x, y, center_element, CE_TOUCHED_BY_PLAYER,
13350 player->index_bit, center_side);
13351 CheckTriggeredElementChangeByPlayer(x, y, center_element,
13352 CE_PLAYER_TOUCHES_X,
13353 player->index_bit, center_side);
13356 /* use player element that is initially defined in the level playfield,
13357 not the player element that corresponds to the runtime player number
13358 (example: a level that contains EL_PLAYER_3 as the only player would
13359 incorrectly give EL_PLAYER_1 for "player->element_nr") */
13360 int player_element = PLAYERINFO(xx, yy)->initial_element;
13362 CheckElementChangeBySide(x, y, center_element, player_element,
13363 CE_TOUCHING_X, center_side);
13371 void TestIfElementTouchesCustomElement(int x, int y)
13373 static int xy[4][2] =
13380 static int trigger_sides[4][2] =
13382 // center side border side
13383 { CH_SIDE_TOP, CH_SIDE_BOTTOM }, // check top
13384 { CH_SIDE_LEFT, CH_SIDE_RIGHT }, // check left
13385 { CH_SIDE_RIGHT, CH_SIDE_LEFT }, // check right
13386 { CH_SIDE_BOTTOM, CH_SIDE_TOP } // check bottom
13388 static int touch_dir[4] =
13390 MV_LEFT | MV_RIGHT,
13395 boolean change_center_element = FALSE;
13396 int center_element = Tile[x][y]; // should always be non-moving!
13397 int border_element_old[NUM_DIRECTIONS];
13400 for (i = 0; i < NUM_DIRECTIONS; i++)
13402 int xx = x + xy[i][0];
13403 int yy = y + xy[i][1];
13404 int border_element;
13406 border_element_old[i] = -1;
13408 if (!IN_LEV_FIELD(xx, yy))
13411 if (game.engine_version < VERSION_IDENT(3,0,7,0))
13412 border_element = Tile[xx][yy]; // may be moving!
13413 else if (!IS_MOVING(xx, yy) && !IS_BLOCKED(xx, yy))
13414 border_element = Tile[xx][yy];
13415 else if (MovDir[xx][yy] & touch_dir[i]) // elements are touching
13416 border_element = MovingOrBlocked2Element(xx, yy);
13418 continue; // center and border element do not touch
13420 border_element_old[i] = border_element;
13423 for (i = 0; i < NUM_DIRECTIONS; i++)
13425 int xx = x + xy[i][0];
13426 int yy = y + xy[i][1];
13427 int center_side = trigger_sides[i][0];
13428 int border_element = border_element_old[i];
13430 if (border_element == -1)
13433 // check for change of border element
13434 CheckElementChangeBySide(xx, yy, border_element, center_element,
13435 CE_TOUCHING_X, center_side);
13437 // (center element cannot be player, so we dont have to check this here)
13440 for (i = 0; i < NUM_DIRECTIONS; i++)
13442 int xx = x + xy[i][0];
13443 int yy = y + xy[i][1];
13444 int border_side = trigger_sides[i][1];
13445 int border_element = border_element_old[i];
13447 if (border_element == -1)
13450 // check for change of center element (but change it only once)
13451 if (!change_center_element)
13452 change_center_element =
13453 CheckElementChangeBySide(x, y, center_element, border_element,
13454 CE_TOUCHING_X, border_side);
13456 if (IS_PLAYER(xx, yy))
13458 /* use player element that is initially defined in the level playfield,
13459 not the player element that corresponds to the runtime player number
13460 (example: a level that contains EL_PLAYER_3 as the only player would
13461 incorrectly give EL_PLAYER_1 for "player->element_nr") */
13462 int player_element = PLAYERINFO(xx, yy)->initial_element;
13464 CheckElementChangeBySide(x, y, center_element, player_element,
13465 CE_TOUCHING_X, border_side);
13470 void TestIfElementHitsCustomElement(int x, int y, int direction)
13472 int dx = (direction == MV_LEFT ? -1 : direction == MV_RIGHT ? +1 : 0);
13473 int dy = (direction == MV_UP ? -1 : direction == MV_DOWN ? +1 : 0);
13474 int hitx = x + dx, hity = y + dy;
13475 int hitting_element = Tile[x][y];
13476 int touched_element;
13478 if (IN_LEV_FIELD(hitx, hity) && IS_FREE(hitx, hity))
13481 touched_element = (IN_LEV_FIELD(hitx, hity) ?
13482 MovingOrBlocked2Element(hitx, hity) : EL_STEELWALL);
13484 if (IN_LEV_FIELD(hitx, hity))
13486 int opposite_direction = MV_DIR_OPPOSITE(direction);
13487 int hitting_side = direction;
13488 int touched_side = opposite_direction;
13489 boolean object_hit = (!IS_MOVING(hitx, hity) ||
13490 MovDir[hitx][hity] != direction ||
13491 ABS(MovPos[hitx][hity]) <= TILEY / 2);
13497 CheckElementChangeBySide(x, y, hitting_element, touched_element,
13498 CE_HITTING_X, touched_side);
13500 CheckElementChangeBySide(hitx, hity, touched_element, hitting_element,
13501 CE_HIT_BY_X, hitting_side);
13503 CheckElementChangeBySide(hitx, hity, touched_element, hitting_element,
13504 CE_HIT_BY_SOMETHING, opposite_direction);
13506 if (IS_PLAYER(hitx, hity))
13508 /* use player element that is initially defined in the level playfield,
13509 not the player element that corresponds to the runtime player number
13510 (example: a level that contains EL_PLAYER_3 as the only player would
13511 incorrectly give EL_PLAYER_1 for "player->element_nr") */
13512 int player_element = PLAYERINFO(hitx, hity)->initial_element;
13514 CheckElementChangeBySide(x, y, hitting_element, player_element,
13515 CE_HITTING_X, touched_side);
13520 // "hitting something" is also true when hitting the playfield border
13521 CheckElementChangeBySide(x, y, hitting_element, touched_element,
13522 CE_HITTING_SOMETHING, direction);
13525 void TestIfGoodThingHitsBadThing(int good_x, int good_y, int good_move_dir)
13527 int i, kill_x = -1, kill_y = -1;
13529 int bad_element = -1;
13530 static int test_xy[4][2] =
13537 static int test_dir[4] =
13545 for (i = 0; i < NUM_DIRECTIONS; i++)
13547 int test_x, test_y, test_move_dir, test_element;
13549 test_x = good_x + test_xy[i][0];
13550 test_y = good_y + test_xy[i][1];
13552 if (!IN_LEV_FIELD(test_x, test_y))
13556 (IS_MOVING(test_x, test_y) ? MovDir[test_x][test_y] : MV_NONE);
13558 test_element = MovingOrBlocked2ElementIfNotLeaving(test_x, test_y);
13560 /* 1st case: good thing is moving towards DONT_RUN_INTO style bad thing;
13561 2nd case: DONT_TOUCH style bad thing does not move away from good thing
13563 if ((DONT_RUN_INTO(test_element) && good_move_dir == test_dir[i]) ||
13564 (DONT_TOUCH(test_element) && test_move_dir != test_dir[i]))
13568 bad_element = test_element;
13574 if (kill_x != -1 || kill_y != -1)
13576 if (IS_PLAYER(good_x, good_y))
13578 struct PlayerInfo *player = PLAYERINFO(good_x, good_y);
13580 if (player->shield_deadly_time_left > 0 &&
13581 !IS_INDESTRUCTIBLE(bad_element))
13582 Bang(kill_x, kill_y);
13583 else if (!PLAYER_ENEMY_PROTECTED(good_x, good_y))
13584 KillPlayer(player);
13587 Bang(good_x, good_y);
13591 void TestIfBadThingHitsGoodThing(int bad_x, int bad_y, int bad_move_dir)
13593 int i, kill_x = -1, kill_y = -1;
13594 int bad_element = Tile[bad_x][bad_y];
13595 static int test_xy[4][2] =
13602 static int touch_dir[4] =
13604 MV_LEFT | MV_RIGHT,
13609 static int test_dir[4] =
13617 if (bad_element == EL_EXPLOSION) // skip just exploding bad things
13620 for (i = 0; i < NUM_DIRECTIONS; i++)
13622 int test_x, test_y, test_move_dir, test_element;
13624 test_x = bad_x + test_xy[i][0];
13625 test_y = bad_y + test_xy[i][1];
13627 if (!IN_LEV_FIELD(test_x, test_y))
13631 (IS_MOVING(test_x, test_y) ? MovDir[test_x][test_y] : MV_NONE);
13633 test_element = Tile[test_x][test_y];
13635 /* 1st case: good thing is moving towards DONT_RUN_INTO style bad thing;
13636 2nd case: DONT_TOUCH style bad thing does not move away from good thing
13638 if ((DONT_RUN_INTO(bad_element) && bad_move_dir == test_dir[i]) ||
13639 (DONT_TOUCH(bad_element) && test_move_dir != test_dir[i]))
13641 // good thing is player or penguin that does not move away
13642 if (IS_PLAYER(test_x, test_y))
13644 struct PlayerInfo *player = PLAYERINFO(test_x, test_y);
13646 if (bad_element == EL_ROBOT && player->is_moving)
13647 continue; // robot does not kill player if he is moving
13649 if (game.engine_version >= VERSION_IDENT(3,0,7,0))
13651 if (player->MovPos != 0 && !(player->MovDir & touch_dir[i]))
13652 continue; // center and border element do not touch
13660 else if (test_element == EL_PENGUIN)
13670 if (kill_x != -1 || kill_y != -1)
13672 if (IS_PLAYER(kill_x, kill_y))
13674 struct PlayerInfo *player = PLAYERINFO(kill_x, kill_y);
13676 if (player->shield_deadly_time_left > 0 &&
13677 !IS_INDESTRUCTIBLE(bad_element))
13678 Bang(bad_x, bad_y);
13679 else if (!PLAYER_ENEMY_PROTECTED(kill_x, kill_y))
13680 KillPlayer(player);
13683 Bang(kill_x, kill_y);
13687 void TestIfGoodThingGetsHitByBadThing(int bad_x, int bad_y, int bad_move_dir)
13689 int bad_element = Tile[bad_x][bad_y];
13690 int dx = (bad_move_dir == MV_LEFT ? -1 : bad_move_dir == MV_RIGHT ? +1 : 0);
13691 int dy = (bad_move_dir == MV_UP ? -1 : bad_move_dir == MV_DOWN ? +1 : 0);
13692 int test_x = bad_x + dx, test_y = bad_y + dy;
13693 int test_move_dir, test_element;
13694 int kill_x = -1, kill_y = -1;
13696 if (!IN_LEV_FIELD(test_x, test_y))
13700 (IS_MOVING(test_x, test_y) ? MovDir[test_x][test_y] : MV_NONE);
13702 test_element = Tile[test_x][test_y];
13704 if (test_move_dir != bad_move_dir)
13706 // good thing can be player or penguin that does not move away
13707 if (IS_PLAYER(test_x, test_y))
13709 struct PlayerInfo *player = PLAYERINFO(test_x, test_y);
13711 /* (note: in comparison to DONT_RUN_TO and DONT_TOUCH, also handle the
13712 player as being hit when he is moving towards the bad thing, because
13713 the "get hit by" condition would be lost after the player stops) */
13714 if (player->MovPos != 0 && player->MovDir == bad_move_dir)
13715 return; // player moves away from bad thing
13720 else if (test_element == EL_PENGUIN)
13727 if (kill_x != -1 || kill_y != -1)
13729 if (IS_PLAYER(kill_x, kill_y))
13731 struct PlayerInfo *player = PLAYERINFO(kill_x, kill_y);
13733 if (player->shield_deadly_time_left > 0 &&
13734 !IS_INDESTRUCTIBLE(bad_element))
13735 Bang(bad_x, bad_y);
13736 else if (!PLAYER_ENEMY_PROTECTED(kill_x, kill_y))
13737 KillPlayer(player);
13740 Bang(kill_x, kill_y);
13744 void TestIfPlayerTouchesBadThing(int x, int y)
13746 TestIfGoodThingHitsBadThing(x, y, MV_NONE);
13749 void TestIfPlayerRunsIntoBadThing(int x, int y, int move_dir)
13751 TestIfGoodThingHitsBadThing(x, y, move_dir);
13754 void TestIfBadThingTouchesPlayer(int x, int y)
13756 TestIfBadThingHitsGoodThing(x, y, MV_NONE);
13759 void TestIfBadThingRunsIntoPlayer(int x, int y, int move_dir)
13761 TestIfBadThingHitsGoodThing(x, y, move_dir);
13764 void TestIfFriendTouchesBadThing(int x, int y)
13766 TestIfGoodThingHitsBadThing(x, y, MV_NONE);
13769 void TestIfBadThingTouchesFriend(int x, int y)
13771 TestIfBadThingHitsGoodThing(x, y, MV_NONE);
13774 void TestIfBadThingTouchesOtherBadThing(int bad_x, int bad_y)
13776 int i, kill_x = bad_x, kill_y = bad_y;
13777 static int xy[4][2] =
13785 for (i = 0; i < NUM_DIRECTIONS; i++)
13789 x = bad_x + xy[i][0];
13790 y = bad_y + xy[i][1];
13791 if (!IN_LEV_FIELD(x, y))
13794 element = Tile[x][y];
13795 if (IS_AMOEBOID(element) || element == EL_GAME_OF_LIFE ||
13796 element == EL_AMOEBA_GROWING || element == EL_AMOEBA_DROP)
13804 if (kill_x != bad_x || kill_y != bad_y)
13805 Bang(bad_x, bad_y);
13808 void KillPlayer(struct PlayerInfo *player)
13810 int jx = player->jx, jy = player->jy;
13812 if (!player->active)
13816 Debug("game:playing:KillPlayer",
13817 "0: killed == %d, active == %d, reanimated == %d",
13818 player->killed, player->active, player->reanimated);
13821 /* the following code was introduced to prevent an infinite loop when calling
13823 -> CheckTriggeredElementChangeExt()
13824 -> ExecuteCustomElementAction()
13826 -> (infinitely repeating the above sequence of function calls)
13827 which occurs when killing the player while having a CE with the setting
13828 "kill player X when explosion of <player X>"; the solution using a new
13829 field "player->killed" was chosen for backwards compatibility, although
13830 clever use of the fields "player->active" etc. would probably also work */
13832 if (player->killed)
13836 player->killed = TRUE;
13838 // remove accessible field at the player's position
13839 Tile[jx][jy] = EL_EMPTY;
13841 // deactivate shield (else Bang()/Explode() would not work right)
13842 player->shield_normal_time_left = 0;
13843 player->shield_deadly_time_left = 0;
13846 Debug("game:playing:KillPlayer",
13847 "1: killed == %d, active == %d, reanimated == %d",
13848 player->killed, player->active, player->reanimated);
13854 Debug("game:playing:KillPlayer",
13855 "2: killed == %d, active == %d, reanimated == %d",
13856 player->killed, player->active, player->reanimated);
13859 if (player->reanimated) // killed player may have been reanimated
13860 player->killed = player->reanimated = FALSE;
13862 BuryPlayer(player);
13865 static void KillPlayerUnlessEnemyProtected(int x, int y)
13867 if (!PLAYER_ENEMY_PROTECTED(x, y))
13868 KillPlayer(PLAYERINFO(x, y));
13871 static void KillPlayerUnlessExplosionProtected(int x, int y)
13873 if (!PLAYER_EXPLOSION_PROTECTED(x, y))
13874 KillPlayer(PLAYERINFO(x, y));
13877 void BuryPlayer(struct PlayerInfo *player)
13879 int jx = player->jx, jy = player->jy;
13881 if (!player->active)
13884 PlayLevelSoundElementAction(jx, jy, player->artwork_element, ACTION_DYING);
13885 PlayLevelSound(jx, jy, SND_GAME_LOSING);
13887 RemovePlayer(player);
13889 player->buried = TRUE;
13891 if (game.all_players_gone)
13892 game.GameOver = TRUE;
13895 void RemovePlayer(struct PlayerInfo *player)
13897 int jx = player->jx, jy = player->jy;
13898 int i, found = FALSE;
13900 player->present = FALSE;
13901 player->active = FALSE;
13903 // required for some CE actions (even if the player is not active anymore)
13904 player->MovPos = 0;
13906 if (!ExplodeField[jx][jy])
13907 StorePlayer[jx][jy] = 0;
13909 if (player->is_moving)
13910 TEST_DrawLevelField(player->last_jx, player->last_jy);
13912 for (i = 0; i < MAX_PLAYERS; i++)
13913 if (stored_player[i].active)
13918 game.all_players_gone = TRUE;
13919 game.GameOver = TRUE;
13922 game.exit_x = game.robot_wheel_x = jx;
13923 game.exit_y = game.robot_wheel_y = jy;
13926 void ExitPlayer(struct PlayerInfo *player)
13928 DrawPlayer(player); // needed here only to cleanup last field
13929 RemovePlayer(player);
13931 if (game.players_still_needed > 0)
13932 game.players_still_needed--;
13935 static void SetFieldForSnapping(int x, int y, int element, int direction,
13936 int player_index_bit)
13938 struct ElementInfo *ei = &element_info[element];
13939 int direction_bit = MV_DIR_TO_BIT(direction);
13940 int graphic_snapping = ei->direction_graphic[ACTION_SNAPPING][direction_bit];
13941 int action = (graphic_snapping != IMG_EMPTY_SPACE ? ACTION_SNAPPING :
13942 IS_DIGGABLE(element) ? ACTION_DIGGING : ACTION_COLLECTING);
13944 Tile[x][y] = EL_ELEMENT_SNAPPING;
13945 MovDelay[x][y] = MOVE_DELAY_NORMAL_SPEED + 1 - 1;
13946 MovDir[x][y] = direction;
13947 Store[x][y] = element;
13948 Store2[x][y] = player_index_bit;
13950 ResetGfxAnimation(x, y);
13952 GfxElement[x][y] = element;
13953 GfxAction[x][y] = action;
13954 GfxDir[x][y] = direction;
13955 GfxFrame[x][y] = -1;
13958 static void TestFieldAfterSnapping(int x, int y, int element, int direction,
13959 int player_index_bit)
13961 TestIfElementTouchesCustomElement(x, y); // for empty space
13963 if (level.finish_dig_collect)
13965 int dig_side = MV_DIR_OPPOSITE(direction);
13967 CheckTriggeredElementChangeByPlayer(x, y, element, CE_PLAYER_SNAPS_X,
13968 player_index_bit, dig_side);
13973 =============================================================================
13974 checkDiagonalPushing()
13975 -----------------------------------------------------------------------------
13976 check if diagonal input device direction results in pushing of object
13977 (by checking if the alternative direction is walkable, diggable, ...)
13978 =============================================================================
13981 static boolean checkDiagonalPushing(struct PlayerInfo *player,
13982 int x, int y, int real_dx, int real_dy)
13984 int jx, jy, dx, dy, xx, yy;
13986 if (real_dx == 0 || real_dy == 0) // no diagonal direction => push
13989 // diagonal direction: check alternative direction
13994 xx = jx + (dx == 0 ? real_dx : 0);
13995 yy = jy + (dy == 0 ? real_dy : 0);
13997 return (!IN_LEV_FIELD(xx, yy) || IS_SOLID_FOR_PUSHING(Tile[xx][yy]));
14001 =============================================================================
14003 -----------------------------------------------------------------------------
14004 x, y: field next to player (non-diagonal) to try to dig to
14005 real_dx, real_dy: direction as read from input device (can be diagonal)
14006 =============================================================================
14009 static int DigField(struct PlayerInfo *player,
14010 int oldx, int oldy, int x, int y,
14011 int real_dx, int real_dy, int mode)
14013 boolean is_player = (IS_PLAYER(oldx, oldy) || mode != DF_DIG);
14014 boolean player_was_pushing = player->is_pushing;
14015 boolean player_can_move = (!player->cannot_move && mode != DF_SNAP);
14016 boolean player_can_move_or_snap = (!player->cannot_move || mode == DF_SNAP);
14017 int jx = oldx, jy = oldy;
14018 int dx = x - jx, dy = y - jy;
14019 int nextx = x + dx, nexty = y + dy;
14020 int move_direction = (dx == -1 ? MV_LEFT :
14021 dx == +1 ? MV_RIGHT :
14023 dy == +1 ? MV_DOWN : MV_NONE);
14024 int opposite_direction = MV_DIR_OPPOSITE(move_direction);
14025 int dig_side = MV_DIR_OPPOSITE(move_direction);
14026 int old_element = Tile[jx][jy];
14027 int element = MovingOrBlocked2ElementIfNotLeaving(x, y);
14030 if (is_player) // function can also be called by EL_PENGUIN
14032 if (player->MovPos == 0)
14034 player->is_digging = FALSE;
14035 player->is_collecting = FALSE;
14038 if (player->MovPos == 0) // last pushing move finished
14039 player->is_pushing = FALSE;
14041 if (mode == DF_NO_PUSH) // player just stopped pushing
14043 player->is_switching = FALSE;
14044 player->push_delay = -1;
14046 return MP_NO_ACTION;
14050 if (IS_TUBE(Back[jx][jy]) && game.engine_version >= VERSION_IDENT(2,2,0,0))
14051 old_element = Back[jx][jy];
14053 // in case of element dropped at player position, check background
14054 else if (Back[jx][jy] != EL_EMPTY &&
14055 game.engine_version >= VERSION_IDENT(2,2,0,0))
14056 old_element = Back[jx][jy];
14058 if (IS_WALKABLE(old_element) && !ACCESS_FROM(old_element, move_direction))
14059 return MP_NO_ACTION; // field has no opening in this direction
14061 if (IS_PASSABLE(old_element) && !ACCESS_FROM(old_element,opposite_direction))
14062 return MP_NO_ACTION; // field has no opening in this direction
14064 if (player_can_move && element == EL_ACID && move_direction == MV_DOWN)
14068 Tile[jx][jy] = player->artwork_element;
14069 InitMovingField(jx, jy, MV_DOWN);
14070 Store[jx][jy] = EL_ACID;
14071 ContinueMoving(jx, jy);
14072 BuryPlayer(player);
14074 return MP_DONT_RUN_INTO;
14077 if (player_can_move && DONT_RUN_INTO(element))
14079 TestIfPlayerRunsIntoBadThing(jx, jy, player->MovDir);
14081 return MP_DONT_RUN_INTO;
14084 if (IS_MOVING(x, y) || IS_PLAYER(x, y))
14085 return MP_NO_ACTION;
14087 collect_count = element_info[element].collect_count_initial;
14089 if (!is_player && !IS_COLLECTIBLE(element)) // penguin cannot collect it
14090 return MP_NO_ACTION;
14092 if (game.engine_version < VERSION_IDENT(2,2,0,0))
14093 player_can_move = player_can_move_or_snap;
14095 if (mode == DF_SNAP && !IS_SNAPPABLE(element) &&
14096 game.engine_version >= VERSION_IDENT(2,2,0,0))
14098 CheckElementChangeByPlayer(x, y, element, CE_SNAPPED_BY_PLAYER,
14099 player->index_bit, dig_side);
14100 CheckTriggeredElementChangeByPlayer(x, y, element, CE_PLAYER_SNAPS_X,
14101 player->index_bit, dig_side);
14103 if (element == EL_DC_LANDMINE)
14106 if (Tile[x][y] != element) // field changed by snapping
14109 return MP_NO_ACTION;
14112 if (player->gravity && is_player && !player->is_auto_moving &&
14113 canFallDown(player) && move_direction != MV_DOWN &&
14114 !canMoveToValidFieldWithGravity(jx, jy, move_direction))
14115 return MP_NO_ACTION; // player cannot walk here due to gravity
14117 if (player_can_move &&
14118 IS_WALKABLE(element) && ACCESS_FROM(element, opposite_direction))
14120 int sound_element = SND_ELEMENT(element);
14121 int sound_action = ACTION_WALKING;
14123 if (IS_RND_GATE(element))
14125 if (!player->key[RND_GATE_NR(element)])
14126 return MP_NO_ACTION;
14128 else if (IS_RND_GATE_GRAY(element))
14130 if (!player->key[RND_GATE_GRAY_NR(element)])
14131 return MP_NO_ACTION;
14133 else if (IS_RND_GATE_GRAY_ACTIVE(element))
14135 if (!player->key[RND_GATE_GRAY_ACTIVE_NR(element)])
14136 return MP_NO_ACTION;
14138 else if (element == EL_EXIT_OPEN ||
14139 element == EL_EM_EXIT_OPEN ||
14140 element == EL_EM_EXIT_OPENING ||
14141 element == EL_STEEL_EXIT_OPEN ||
14142 element == EL_EM_STEEL_EXIT_OPEN ||
14143 element == EL_EM_STEEL_EXIT_OPENING ||
14144 element == EL_SP_EXIT_OPEN ||
14145 element == EL_SP_EXIT_OPENING)
14147 sound_action = ACTION_PASSING; // player is passing exit
14149 else if (element == EL_EMPTY)
14151 sound_action = ACTION_MOVING; // nothing to walk on
14154 // play sound from background or player, whatever is available
14155 if (element_info[sound_element].sound[sound_action] != SND_UNDEFINED)
14156 PlayLevelSoundElementAction(x, y, sound_element, sound_action);
14158 PlayLevelSoundElementAction(x, y, player->artwork_element, sound_action);
14160 else if (player_can_move &&
14161 IS_PASSABLE(element) && canPassField(x, y, move_direction))
14163 if (!ACCESS_FROM(element, opposite_direction))
14164 return MP_NO_ACTION; // field not accessible from this direction
14166 if (CAN_MOVE(element)) // only fixed elements can be passed!
14167 return MP_NO_ACTION;
14169 if (IS_EM_GATE(element))
14171 if (!player->key[EM_GATE_NR(element)])
14172 return MP_NO_ACTION;
14174 else if (IS_EM_GATE_GRAY(element))
14176 if (!player->key[EM_GATE_GRAY_NR(element)])
14177 return MP_NO_ACTION;
14179 else if (IS_EM_GATE_GRAY_ACTIVE(element))
14181 if (!player->key[EM_GATE_GRAY_ACTIVE_NR(element)])
14182 return MP_NO_ACTION;
14184 else if (IS_EMC_GATE(element))
14186 if (!player->key[EMC_GATE_NR(element)])
14187 return MP_NO_ACTION;
14189 else if (IS_EMC_GATE_GRAY(element))
14191 if (!player->key[EMC_GATE_GRAY_NR(element)])
14192 return MP_NO_ACTION;
14194 else if (IS_EMC_GATE_GRAY_ACTIVE(element))
14196 if (!player->key[EMC_GATE_GRAY_ACTIVE_NR(element)])
14197 return MP_NO_ACTION;
14199 else if (element == EL_DC_GATE_WHITE ||
14200 element == EL_DC_GATE_WHITE_GRAY ||
14201 element == EL_DC_GATE_WHITE_GRAY_ACTIVE)
14203 if (player->num_white_keys == 0)
14204 return MP_NO_ACTION;
14206 player->num_white_keys--;
14208 else if (IS_SP_PORT(element))
14210 if (element == EL_SP_GRAVITY_PORT_LEFT ||
14211 element == EL_SP_GRAVITY_PORT_RIGHT ||
14212 element == EL_SP_GRAVITY_PORT_UP ||
14213 element == EL_SP_GRAVITY_PORT_DOWN)
14214 player->gravity = !player->gravity;
14215 else if (element == EL_SP_GRAVITY_ON_PORT_LEFT ||
14216 element == EL_SP_GRAVITY_ON_PORT_RIGHT ||
14217 element == EL_SP_GRAVITY_ON_PORT_UP ||
14218 element == EL_SP_GRAVITY_ON_PORT_DOWN)
14219 player->gravity = TRUE;
14220 else if (element == EL_SP_GRAVITY_OFF_PORT_LEFT ||
14221 element == EL_SP_GRAVITY_OFF_PORT_RIGHT ||
14222 element == EL_SP_GRAVITY_OFF_PORT_UP ||
14223 element == EL_SP_GRAVITY_OFF_PORT_DOWN)
14224 player->gravity = FALSE;
14227 // automatically move to the next field with double speed
14228 player->programmed_action = move_direction;
14230 if (player->move_delay_reset_counter == 0)
14232 player->move_delay_reset_counter = 2; // two double speed steps
14234 DOUBLE_PLAYER_SPEED(player);
14237 PlayLevelSoundAction(x, y, ACTION_PASSING);
14239 else if (player_can_move_or_snap && IS_DIGGABLE(element))
14243 if (mode != DF_SNAP)
14245 GfxElement[x][y] = GFX_ELEMENT(element);
14246 player->is_digging = TRUE;
14249 PlayLevelSoundElementAction(x, y, element, ACTION_DIGGING);
14251 // use old behaviour for old levels (digging)
14252 if (!level.finish_dig_collect)
14254 CheckTriggeredElementChangeByPlayer(x, y, element, CE_PLAYER_DIGS_X,
14255 player->index_bit, dig_side);
14257 // if digging triggered player relocation, finish digging tile
14258 if (mode == DF_DIG && (player->jx != jx || player->jy != jy))
14259 SetFieldForSnapping(x, y, element, move_direction, player->index_bit);
14262 if (mode == DF_SNAP)
14264 if (level.block_snap_field)
14265 SetFieldForSnapping(x, y, element, move_direction, player->index_bit);
14267 TestFieldAfterSnapping(x, y, element, move_direction, player->index_bit);
14269 // use old behaviour for old levels (snapping)
14270 if (!level.finish_dig_collect)
14271 CheckTriggeredElementChangeByPlayer(x, y, element, CE_PLAYER_SNAPS_X,
14272 player->index_bit, dig_side);
14275 else if (player_can_move_or_snap && IS_COLLECTIBLE(element))
14279 if (is_player && mode != DF_SNAP)
14281 GfxElement[x][y] = element;
14282 player->is_collecting = TRUE;
14285 if (element == EL_SPEED_PILL)
14287 player->move_delay_value = MOVE_DELAY_HIGH_SPEED;
14289 else if (element == EL_EXTRA_TIME && level.time > 0)
14291 TimeLeft += level.extra_time;
14293 game_panel_controls[GAME_PANEL_TIME].value = TimeLeft;
14295 DisplayGameControlValues();
14297 else if (element == EL_SHIELD_NORMAL || element == EL_SHIELD_DEADLY)
14299 player->shield_normal_time_left += level.shield_normal_time;
14300 if (element == EL_SHIELD_DEADLY)
14301 player->shield_deadly_time_left += level.shield_deadly_time;
14303 else if (element == EL_DYNAMITE ||
14304 element == EL_EM_DYNAMITE ||
14305 element == EL_SP_DISK_RED)
14307 if (player->inventory_size < MAX_INVENTORY_SIZE)
14308 player->inventory_element[player->inventory_size++] = element;
14310 DrawGameDoorValues();
14312 else if (element == EL_DYNABOMB_INCREASE_NUMBER)
14314 player->dynabomb_count++;
14315 player->dynabombs_left++;
14317 else if (element == EL_DYNABOMB_INCREASE_SIZE)
14319 player->dynabomb_size++;
14321 else if (element == EL_DYNABOMB_INCREASE_POWER)
14323 player->dynabomb_xl = TRUE;
14325 else if (IS_KEY(element))
14327 player->key[KEY_NR(element)] = TRUE;
14329 DrawGameDoorValues();
14331 else if (element == EL_DC_KEY_WHITE)
14333 player->num_white_keys++;
14335 // display white keys?
14336 // DrawGameDoorValues();
14338 else if (IS_ENVELOPE(element))
14340 boolean wait_for_snapping = (mode == DF_SNAP && level.block_snap_field);
14342 if (!wait_for_snapping)
14343 player->show_envelope = element;
14345 else if (element == EL_EMC_LENSES)
14347 game.lenses_time_left = level.lenses_time * FRAMES_PER_SECOND;
14349 RedrawAllInvisibleElementsForLenses();
14351 else if (element == EL_EMC_MAGNIFIER)
14353 game.magnify_time_left = level.magnify_time * FRAMES_PER_SECOND;
14355 RedrawAllInvisibleElementsForMagnifier();
14357 else if (IS_DROPPABLE(element) ||
14358 IS_THROWABLE(element)) // can be collected and dropped
14362 if (collect_count == 0)
14363 player->inventory_infinite_element = element;
14365 for (i = 0; i < collect_count; i++)
14366 if (player->inventory_size < MAX_INVENTORY_SIZE)
14367 player->inventory_element[player->inventory_size++] = element;
14369 DrawGameDoorValues();
14371 else if (collect_count > 0)
14373 game.gems_still_needed -= collect_count;
14374 if (game.gems_still_needed < 0)
14375 game.gems_still_needed = 0;
14377 game.snapshot.collected_item = TRUE;
14379 game_panel_controls[GAME_PANEL_GEMS].value = game.gems_still_needed;
14381 DisplayGameControlValues();
14384 RaiseScoreElement(element);
14385 PlayLevelSoundElementAction(x, y, element, ACTION_COLLECTING);
14387 // use old behaviour for old levels (collecting)
14388 if (!level.finish_dig_collect && is_player)
14390 CheckTriggeredElementChangeByPlayer(x, y, element, CE_PLAYER_COLLECTS_X,
14391 player->index_bit, dig_side);
14393 // if collecting triggered player relocation, finish collecting tile
14394 if (mode == DF_DIG && (player->jx != jx || player->jy != jy))
14395 SetFieldForSnapping(x, y, element, move_direction, player->index_bit);
14398 if (mode == DF_SNAP)
14400 if (level.block_snap_field)
14401 SetFieldForSnapping(x, y, element, move_direction, player->index_bit);
14403 TestFieldAfterSnapping(x, y, element, move_direction, player->index_bit);
14405 // use old behaviour for old levels (snapping)
14406 if (!level.finish_dig_collect)
14407 CheckTriggeredElementChangeByPlayer(x, y, element, CE_PLAYER_SNAPS_X,
14408 player->index_bit, dig_side);
14411 else if (player_can_move_or_snap && IS_PUSHABLE(element))
14413 if (mode == DF_SNAP && element != EL_BD_ROCK)
14414 return MP_NO_ACTION;
14416 if (CAN_FALL(element) && dy)
14417 return MP_NO_ACTION;
14419 if (CAN_FALL(element) && IN_LEV_FIELD(x, y + 1) && IS_FREE(x, y + 1) &&
14420 !(element == EL_SPRING && level.use_spring_bug))
14421 return MP_NO_ACTION;
14423 if (CAN_MOVE(element) && GET_MAX_MOVE_DELAY(element) == 0 &&
14424 ((move_direction & MV_VERTICAL &&
14425 ((element_info[element].move_pattern & MV_LEFT &&
14426 IN_LEV_FIELD(x - 1, y) && IS_FREE(x - 1, y)) ||
14427 (element_info[element].move_pattern & MV_RIGHT &&
14428 IN_LEV_FIELD(x + 1, y) && IS_FREE(x + 1, y)))) ||
14429 (move_direction & MV_HORIZONTAL &&
14430 ((element_info[element].move_pattern & MV_UP &&
14431 IN_LEV_FIELD(x, y - 1) && IS_FREE(x, y - 1)) ||
14432 (element_info[element].move_pattern & MV_DOWN &&
14433 IN_LEV_FIELD(x, y + 1) && IS_FREE(x, y + 1))))))
14434 return MP_NO_ACTION;
14436 // do not push elements already moving away faster than player
14437 if (CAN_MOVE(element) && MovDir[x][y] == move_direction &&
14438 ABS(getElementMoveStepsize(x, y)) > MOVE_STEPSIZE_NORMAL)
14439 return MP_NO_ACTION;
14441 if (game.engine_version >= VERSION_IDENT(3,1,0,0))
14443 if (player->push_delay_value == -1 || !player_was_pushing)
14444 player->push_delay_value = GET_NEW_PUSH_DELAY(element);
14446 else if (game.engine_version >= VERSION_IDENT(3,0,7,1))
14448 if (player->push_delay_value == -1)
14449 player->push_delay_value = GET_NEW_PUSH_DELAY(element);
14451 else if (game.engine_version >= VERSION_IDENT(2,2,0,7))
14453 if (!player->is_pushing)
14454 player->push_delay_value = GET_NEW_PUSH_DELAY(element);
14457 player->is_pushing = TRUE;
14458 player->is_active = TRUE;
14460 if (!(IN_LEV_FIELD(nextx, nexty) &&
14461 (IS_FREE(nextx, nexty) ||
14462 (IS_SB_ELEMENT(element) &&
14463 Tile[nextx][nexty] == EL_SOKOBAN_FIELD_EMPTY) ||
14464 (IS_CUSTOM_ELEMENT(element) &&
14465 CUSTOM_ELEMENT_CAN_ENTER_FIELD(element, nextx, nexty)))))
14466 return MP_NO_ACTION;
14468 if (!checkDiagonalPushing(player, x, y, real_dx, real_dy))
14469 return MP_NO_ACTION;
14471 if (player->push_delay == -1) // new pushing; restart delay
14472 player->push_delay = 0;
14474 if (player->push_delay < player->push_delay_value &&
14475 !(tape.playing && tape.file_version < FILE_VERSION_2_0) &&
14476 element != EL_SPRING && element != EL_BALLOON)
14478 // make sure that there is no move delay before next try to push
14479 if (game.engine_version >= VERSION_IDENT(3,0,7,1))
14480 player->move_delay = 0;
14482 return MP_NO_ACTION;
14485 if (IS_CUSTOM_ELEMENT(element) &&
14486 CUSTOM_ELEMENT_CAN_ENTER_FIELD(element, nextx, nexty))
14488 if (!DigFieldByCE(nextx, nexty, element))
14489 return MP_NO_ACTION;
14492 if (IS_SB_ELEMENT(element))
14494 boolean sokoban_task_solved = FALSE;
14496 if (element == EL_SOKOBAN_FIELD_FULL)
14498 Back[x][y] = EL_SOKOBAN_FIELD_EMPTY;
14500 IncrementSokobanFieldsNeeded();
14501 IncrementSokobanObjectsNeeded();
14504 if (Tile[nextx][nexty] == EL_SOKOBAN_FIELD_EMPTY)
14506 Back[nextx][nexty] = EL_SOKOBAN_FIELD_EMPTY;
14508 DecrementSokobanFieldsNeeded();
14509 DecrementSokobanObjectsNeeded();
14511 // sokoban object was pushed from empty field to sokoban field
14512 if (Back[x][y] == EL_EMPTY)
14513 sokoban_task_solved = TRUE;
14516 Tile[x][y] = EL_SOKOBAN_OBJECT;
14518 if (Back[x][y] == Back[nextx][nexty])
14519 PlayLevelSoundAction(x, y, ACTION_PUSHING);
14520 else if (Back[x][y] != 0)
14521 PlayLevelSoundElementAction(x, y, EL_SOKOBAN_FIELD_FULL,
14524 PlayLevelSoundElementAction(nextx, nexty, EL_SOKOBAN_FIELD_EMPTY,
14527 if (sokoban_task_solved &&
14528 game.sokoban_fields_still_needed == 0 &&
14529 game.sokoban_objects_still_needed == 0 &&
14530 (game.emulation == EMU_SOKOBAN || level.auto_exit_sokoban))
14532 game.players_still_needed = 0;
14536 PlayLevelSound(x, y, SND_GAME_SOKOBAN_SOLVING);
14540 PlayLevelSoundElementAction(x, y, element, ACTION_PUSHING);
14542 InitMovingField(x, y, move_direction);
14543 GfxAction[x][y] = ACTION_PUSHING;
14545 if (mode == DF_SNAP)
14546 ContinueMoving(x, y);
14548 MovPos[x][y] = (dx != 0 ? dx : dy);
14550 Pushed[x][y] = TRUE;
14551 Pushed[nextx][nexty] = TRUE;
14553 if (game.engine_version < VERSION_IDENT(2,2,0,7))
14554 player->push_delay_value = GET_NEW_PUSH_DELAY(element);
14556 player->push_delay_value = -1; // get new value later
14558 // check for element change _after_ element has been pushed
14559 if (game.use_change_when_pushing_bug)
14561 CheckElementChangeByPlayer(x, y, element, CE_PUSHED_BY_PLAYER,
14562 player->index_bit, dig_side);
14563 CheckTriggeredElementChangeByPlayer(x, y, element, CE_PLAYER_PUSHES_X,
14564 player->index_bit, dig_side);
14567 else if (IS_SWITCHABLE(element))
14569 if (PLAYER_SWITCHING(player, x, y))
14571 CheckTriggeredElementChangeByPlayer(x, y, element, CE_PLAYER_PRESSES_X,
14572 player->index_bit, dig_side);
14577 player->is_switching = TRUE;
14578 player->switch_x = x;
14579 player->switch_y = y;
14581 PlayLevelSoundElementAction(x, y, element, ACTION_ACTIVATING);
14583 if (element == EL_ROBOT_WHEEL)
14585 Tile[x][y] = EL_ROBOT_WHEEL_ACTIVE;
14587 game.robot_wheel_x = x;
14588 game.robot_wheel_y = y;
14589 game.robot_wheel_active = TRUE;
14591 TEST_DrawLevelField(x, y);
14593 else if (element == EL_SP_TERMINAL)
14597 SCAN_PLAYFIELD(xx, yy)
14599 if (Tile[xx][yy] == EL_SP_DISK_YELLOW)
14603 else if (Tile[xx][yy] == EL_SP_TERMINAL)
14605 Tile[xx][yy] = EL_SP_TERMINAL_ACTIVE;
14607 ResetGfxAnimation(xx, yy);
14608 TEST_DrawLevelField(xx, yy);
14612 else if (IS_BELT_SWITCH(element))
14614 ToggleBeltSwitch(x, y);
14616 else if (element == EL_SWITCHGATE_SWITCH_UP ||
14617 element == EL_SWITCHGATE_SWITCH_DOWN ||
14618 element == EL_DC_SWITCHGATE_SWITCH_UP ||
14619 element == EL_DC_SWITCHGATE_SWITCH_DOWN)
14621 ToggleSwitchgateSwitch(x, y);
14623 else if (element == EL_LIGHT_SWITCH ||
14624 element == EL_LIGHT_SWITCH_ACTIVE)
14626 ToggleLightSwitch(x, y);
14628 else if (element == EL_TIMEGATE_SWITCH ||
14629 element == EL_DC_TIMEGATE_SWITCH)
14631 ActivateTimegateSwitch(x, y);
14633 else if (element == EL_BALLOON_SWITCH_LEFT ||
14634 element == EL_BALLOON_SWITCH_RIGHT ||
14635 element == EL_BALLOON_SWITCH_UP ||
14636 element == EL_BALLOON_SWITCH_DOWN ||
14637 element == EL_BALLOON_SWITCH_NONE ||
14638 element == EL_BALLOON_SWITCH_ANY)
14640 game.wind_direction = (element == EL_BALLOON_SWITCH_LEFT ? MV_LEFT :
14641 element == EL_BALLOON_SWITCH_RIGHT ? MV_RIGHT :
14642 element == EL_BALLOON_SWITCH_UP ? MV_UP :
14643 element == EL_BALLOON_SWITCH_DOWN ? MV_DOWN :
14644 element == EL_BALLOON_SWITCH_NONE ? MV_NONE :
14647 else if (element == EL_LAMP)
14649 Tile[x][y] = EL_LAMP_ACTIVE;
14650 game.lights_still_needed--;
14652 ResetGfxAnimation(x, y);
14653 TEST_DrawLevelField(x, y);
14655 else if (element == EL_TIME_ORB_FULL)
14657 Tile[x][y] = EL_TIME_ORB_EMPTY;
14659 if (level.time > 0 || level.use_time_orb_bug)
14661 TimeLeft += level.time_orb_time;
14662 game.no_time_limit = FALSE;
14664 game_panel_controls[GAME_PANEL_TIME].value = TimeLeft;
14666 DisplayGameControlValues();
14669 ResetGfxAnimation(x, y);
14670 TEST_DrawLevelField(x, y);
14672 else if (element == EL_EMC_MAGIC_BALL_SWITCH ||
14673 element == EL_EMC_MAGIC_BALL_SWITCH_ACTIVE)
14677 game.ball_active = !game.ball_active;
14679 SCAN_PLAYFIELD(xx, yy)
14681 int e = Tile[xx][yy];
14683 if (game.ball_active)
14685 if (e == EL_EMC_MAGIC_BALL)
14686 CreateField(xx, yy, EL_EMC_MAGIC_BALL_ACTIVE);
14687 else if (e == EL_EMC_MAGIC_BALL_SWITCH)
14688 CreateField(xx, yy, EL_EMC_MAGIC_BALL_SWITCH_ACTIVE);
14692 if (e == EL_EMC_MAGIC_BALL_ACTIVE)
14693 CreateField(xx, yy, EL_EMC_MAGIC_BALL);
14694 else if (e == EL_EMC_MAGIC_BALL_SWITCH_ACTIVE)
14695 CreateField(xx, yy, EL_EMC_MAGIC_BALL_SWITCH);
14700 CheckTriggeredElementChangeByPlayer(x, y, element, CE_SWITCH_OF_X,
14701 player->index_bit, dig_side);
14703 CheckTriggeredElementChangeByPlayer(x, y, element, CE_PLAYER_SWITCHES_X,
14704 player->index_bit, dig_side);
14706 CheckTriggeredElementChangeByPlayer(x, y, element, CE_PLAYER_PRESSES_X,
14707 player->index_bit, dig_side);
14713 if (!PLAYER_SWITCHING(player, x, y))
14715 player->is_switching = TRUE;
14716 player->switch_x = x;
14717 player->switch_y = y;
14719 CheckElementChangeByPlayer(x, y, element, CE_SWITCHED,
14720 player->index_bit, dig_side);
14721 CheckTriggeredElementChangeByPlayer(x, y, element, CE_SWITCH_OF_X,
14722 player->index_bit, dig_side);
14724 CheckElementChangeByPlayer(x, y, element, CE_SWITCHED_BY_PLAYER,
14725 player->index_bit, dig_side);
14726 CheckTriggeredElementChangeByPlayer(x, y, element, CE_PLAYER_SWITCHES_X,
14727 player->index_bit, dig_side);
14730 CheckElementChangeByPlayer(x, y, element, CE_PRESSED_BY_PLAYER,
14731 player->index_bit, dig_side);
14732 CheckTriggeredElementChangeByPlayer(x, y, element, CE_PLAYER_PRESSES_X,
14733 player->index_bit, dig_side);
14735 return MP_NO_ACTION;
14738 player->push_delay = -1;
14740 if (is_player) // function can also be called by EL_PENGUIN
14742 if (Tile[x][y] != element) // really digged/collected something
14744 player->is_collecting = !player->is_digging;
14745 player->is_active = TRUE;
14747 player->last_removed_element = element;
14754 static boolean DigFieldByCE(int x, int y, int digging_element)
14756 int element = Tile[x][y];
14758 if (!IS_FREE(x, y))
14760 int action = (IS_DIGGABLE(element) ? ACTION_DIGGING :
14761 IS_COLLECTIBLE(element) ? ACTION_COLLECTING :
14764 // no element can dig solid indestructible elements
14765 if (IS_INDESTRUCTIBLE(element) &&
14766 !IS_DIGGABLE(element) &&
14767 !IS_COLLECTIBLE(element))
14770 if (AmoebaNr[x][y] &&
14771 (element == EL_AMOEBA_FULL ||
14772 element == EL_BD_AMOEBA ||
14773 element == EL_AMOEBA_GROWING))
14775 AmoebaCnt[AmoebaNr[x][y]]--;
14776 AmoebaCnt2[AmoebaNr[x][y]]--;
14779 if (IS_MOVING(x, y))
14780 RemoveMovingField(x, y);
14784 TEST_DrawLevelField(x, y);
14787 // if digged element was about to explode, prevent the explosion
14788 ExplodeField[x][y] = EX_TYPE_NONE;
14790 PlayLevelSoundAction(x, y, action);
14793 Store[x][y] = EL_EMPTY;
14795 // this makes it possible to leave the removed element again
14796 if (IS_EQUAL_OR_IN_GROUP(element, MOVE_ENTER_EL(digging_element)))
14797 Store[x][y] = element;
14802 static boolean SnapField(struct PlayerInfo *player, int dx, int dy)
14804 int jx = player->jx, jy = player->jy;
14805 int x = jx + dx, y = jy + dy;
14806 int snap_direction = (dx == -1 ? MV_LEFT :
14807 dx == +1 ? MV_RIGHT :
14809 dy == +1 ? MV_DOWN : MV_NONE);
14810 boolean can_continue_snapping = (level.continuous_snapping &&
14811 WasJustFalling[x][y] < CHECK_DELAY_FALLING);
14813 if (player->MovPos != 0 && game.engine_version >= VERSION_IDENT(2,2,0,0))
14816 if (!player->active || !IN_LEV_FIELD(x, y))
14824 if (player->MovPos == 0)
14825 player->is_pushing = FALSE;
14827 player->is_snapping = FALSE;
14829 if (player->MovPos == 0)
14831 player->is_moving = FALSE;
14832 player->is_digging = FALSE;
14833 player->is_collecting = FALSE;
14839 // prevent snapping with already pressed snap key when not allowed
14840 if (player->is_snapping && !can_continue_snapping)
14843 player->MovDir = snap_direction;
14845 if (player->MovPos == 0)
14847 player->is_moving = FALSE;
14848 player->is_digging = FALSE;
14849 player->is_collecting = FALSE;
14852 player->is_dropping = FALSE;
14853 player->is_dropping_pressed = FALSE;
14854 player->drop_pressed_delay = 0;
14856 if (DigField(player, jx, jy, x, y, 0, 0, DF_SNAP) == MP_NO_ACTION)
14859 player->is_snapping = TRUE;
14860 player->is_active = TRUE;
14862 if (player->MovPos == 0)
14864 player->is_moving = FALSE;
14865 player->is_digging = FALSE;
14866 player->is_collecting = FALSE;
14869 if (player->MovPos != 0) // prevent graphic bugs in versions < 2.2.0
14870 TEST_DrawLevelField(player->last_jx, player->last_jy);
14872 TEST_DrawLevelField(x, y);
14877 static boolean DropElement(struct PlayerInfo *player)
14879 int old_element, new_element;
14880 int dropx = player->jx, dropy = player->jy;
14881 int drop_direction = player->MovDir;
14882 int drop_side = drop_direction;
14883 int drop_element = get_next_dropped_element(player);
14885 /* do not drop an element on top of another element; when holding drop key
14886 pressed without moving, dropped element must move away before the next
14887 element can be dropped (this is especially important if the next element
14888 is dynamite, which can be placed on background for historical reasons) */
14889 if (PLAYER_DROPPING(player, dropx, dropy) && Tile[dropx][dropy] != EL_EMPTY)
14892 if (IS_THROWABLE(drop_element))
14894 dropx += GET_DX_FROM_DIR(drop_direction);
14895 dropy += GET_DY_FROM_DIR(drop_direction);
14897 if (!IN_LEV_FIELD(dropx, dropy))
14901 old_element = Tile[dropx][dropy]; // old element at dropping position
14902 new_element = drop_element; // default: no change when dropping
14904 // check if player is active, not moving and ready to drop
14905 if (!player->active || player->MovPos || player->drop_delay > 0)
14908 // check if player has anything that can be dropped
14909 if (new_element == EL_UNDEFINED)
14912 // only set if player has anything that can be dropped
14913 player->is_dropping_pressed = TRUE;
14915 // check if drop key was pressed long enough for EM style dynamite
14916 if (new_element == EL_EM_DYNAMITE && player->drop_pressed_delay < 40)
14919 // check if anything can be dropped at the current position
14920 if (IS_ACTIVE_BOMB(old_element) || old_element == EL_EXPLOSION)
14923 // collected custom elements can only be dropped on empty fields
14924 if (IS_CUSTOM_ELEMENT(new_element) && old_element != EL_EMPTY)
14927 if (old_element != EL_EMPTY)
14928 Back[dropx][dropy] = old_element; // store old element on this field
14930 ResetGfxAnimation(dropx, dropy);
14931 ResetRandomAnimationValue(dropx, dropy);
14933 if (player->inventory_size > 0 ||
14934 player->inventory_infinite_element != EL_UNDEFINED)
14936 if (player->inventory_size > 0)
14938 player->inventory_size--;
14940 DrawGameDoorValues();
14942 if (new_element == EL_DYNAMITE)
14943 new_element = EL_DYNAMITE_ACTIVE;
14944 else if (new_element == EL_EM_DYNAMITE)
14945 new_element = EL_EM_DYNAMITE_ACTIVE;
14946 else if (new_element == EL_SP_DISK_RED)
14947 new_element = EL_SP_DISK_RED_ACTIVE;
14950 Tile[dropx][dropy] = new_element;
14952 if (IN_SCR_FIELD(SCREENX(dropx), SCREENY(dropy)))
14953 DrawGraphicThruMask(SCREENX(dropx), SCREENY(dropy),
14954 el2img(Tile[dropx][dropy]), 0);
14956 PlayLevelSoundAction(dropx, dropy, ACTION_DROPPING);
14958 // needed if previous element just changed to "empty" in the last frame
14959 ChangeCount[dropx][dropy] = 0; // allow at least one more change
14961 CheckElementChangeByPlayer(dropx, dropy, new_element, CE_DROPPED_BY_PLAYER,
14962 player->index_bit, drop_side);
14963 CheckTriggeredElementChangeByPlayer(dropx, dropy, new_element,
14965 player->index_bit, drop_side);
14967 TestIfElementTouchesCustomElement(dropx, dropy);
14969 else // player is dropping a dyna bomb
14971 player->dynabombs_left--;
14973 Tile[dropx][dropy] = new_element;
14975 if (IN_SCR_FIELD(SCREENX(dropx), SCREENY(dropy)))
14976 DrawGraphicThruMask(SCREENX(dropx), SCREENY(dropy),
14977 el2img(Tile[dropx][dropy]), 0);
14979 PlayLevelSoundAction(dropx, dropy, ACTION_DROPPING);
14982 if (Tile[dropx][dropy] == new_element) // uninitialized unless CE change
14983 InitField_WithBug1(dropx, dropy, FALSE);
14985 new_element = Tile[dropx][dropy]; // element might have changed
14987 if (IS_CUSTOM_ELEMENT(new_element) && CAN_MOVE(new_element) &&
14988 element_info[new_element].move_pattern == MV_WHEN_DROPPED)
14990 if (element_info[new_element].move_direction_initial == MV_START_AUTOMATIC)
14991 MovDir[dropx][dropy] = drop_direction;
14993 ChangeCount[dropx][dropy] = 0; // allow at least one more change
14995 // do not cause impact style collision by dropping elements that can fall
14996 CheckCollision[dropx][dropy] = CHECK_DELAY_COLLISION;
14999 player->drop_delay = GET_NEW_DROP_DELAY(drop_element);
15000 player->is_dropping = TRUE;
15002 player->drop_pressed_delay = 0;
15003 player->is_dropping_pressed = FALSE;
15005 player->drop_x = dropx;
15006 player->drop_y = dropy;
15011 // ----------------------------------------------------------------------------
15012 // game sound playing functions
15013 // ----------------------------------------------------------------------------
15015 static int *loop_sound_frame = NULL;
15016 static int *loop_sound_volume = NULL;
15018 void InitPlayLevelSound(void)
15020 int num_sounds = getSoundListSize();
15022 checked_free(loop_sound_frame);
15023 checked_free(loop_sound_volume);
15025 loop_sound_frame = checked_calloc(num_sounds * sizeof(int));
15026 loop_sound_volume = checked_calloc(num_sounds * sizeof(int));
15029 static void PlayLevelSound(int x, int y, int nr)
15031 int sx = SCREENX(x), sy = SCREENY(y);
15032 int volume, stereo_position;
15033 int max_distance = 8;
15034 int type = (IS_LOOP_SOUND(nr) ? SND_CTRL_PLAY_LOOP : SND_CTRL_PLAY_SOUND);
15036 if ((!setup.sound_simple && !IS_LOOP_SOUND(nr)) ||
15037 (!setup.sound_loops && IS_LOOP_SOUND(nr)))
15040 if (!IN_LEV_FIELD(x, y) ||
15041 sx < -max_distance || sx >= SCR_FIELDX + max_distance ||
15042 sy < -max_distance || sy >= SCR_FIELDY + max_distance)
15045 volume = SOUND_MAX_VOLUME;
15047 if (!IN_SCR_FIELD(sx, sy))
15049 int dx = ABS(sx - SCR_FIELDX / 2) - SCR_FIELDX / 2;
15050 int dy = ABS(sy - SCR_FIELDY / 2) - SCR_FIELDY / 2;
15052 volume -= volume * (dx > dy ? dx : dy) / max_distance;
15055 stereo_position = (SOUND_MAX_LEFT +
15056 (sx + max_distance) * SOUND_MAX_LEFT2RIGHT /
15057 (SCR_FIELDX + 2 * max_distance));
15059 if (IS_LOOP_SOUND(nr))
15061 /* This assures that quieter loop sounds do not overwrite louder ones,
15062 while restarting sound volume comparison with each new game frame. */
15064 if (loop_sound_volume[nr] > volume && loop_sound_frame[nr] == FrameCounter)
15067 loop_sound_volume[nr] = volume;
15068 loop_sound_frame[nr] = FrameCounter;
15071 PlaySoundExt(nr, volume, stereo_position, type);
15074 static void PlayLevelSoundNearest(int x, int y, int sound_action)
15076 PlayLevelSound(x < LEVELX(BX1) ? LEVELX(BX1) :
15077 x > LEVELX(BX2) ? LEVELX(BX2) : x,
15078 y < LEVELY(BY1) ? LEVELY(BY1) :
15079 y > LEVELY(BY2) ? LEVELY(BY2) : y,
15083 static void PlayLevelSoundAction(int x, int y, int action)
15085 PlayLevelSoundElementAction(x, y, Tile[x][y], action);
15088 static void PlayLevelSoundElementAction(int x, int y, int element, int action)
15090 int sound_effect = element_info[SND_ELEMENT(element)].sound[action];
15092 if (sound_effect != SND_UNDEFINED)
15093 PlayLevelSound(x, y, sound_effect);
15096 static void PlayLevelSoundElementActionIfLoop(int x, int y, int element,
15099 int sound_effect = element_info[SND_ELEMENT(element)].sound[action];
15101 if (sound_effect != SND_UNDEFINED && IS_LOOP_SOUND(sound_effect))
15102 PlayLevelSound(x, y, sound_effect);
15105 static void PlayLevelSoundActionIfLoop(int x, int y, int action)
15107 int sound_effect = element_info[SND_ELEMENT(Tile[x][y])].sound[action];
15109 if (sound_effect != SND_UNDEFINED && IS_LOOP_SOUND(sound_effect))
15110 PlayLevelSound(x, y, sound_effect);
15113 static void StopLevelSoundActionIfLoop(int x, int y, int action)
15115 int sound_effect = element_info[SND_ELEMENT(Tile[x][y])].sound[action];
15117 if (sound_effect != SND_UNDEFINED && IS_LOOP_SOUND(sound_effect))
15118 StopSound(sound_effect);
15121 static int getLevelMusicNr(void)
15123 if (levelset.music[level_nr] != MUS_UNDEFINED)
15124 return levelset.music[level_nr]; // from config file
15126 return MAP_NOCONF_MUSIC(level_nr); // from music dir
15129 static void FadeLevelSounds(void)
15134 static void FadeLevelMusic(void)
15136 int music_nr = getLevelMusicNr();
15137 char *curr_music = getCurrentlyPlayingMusicFilename();
15138 char *next_music = getMusicInfoEntryFilename(music_nr);
15140 if (!strEqual(curr_music, next_music))
15144 void FadeLevelSoundsAndMusic(void)
15150 static void PlayLevelMusic(void)
15152 int music_nr = getLevelMusicNr();
15153 char *curr_music = getCurrentlyPlayingMusicFilename();
15154 char *next_music = getMusicInfoEntryFilename(music_nr);
15156 if (!strEqual(curr_music, next_music))
15157 PlayMusicLoop(music_nr);
15160 void PlayLevelSound_EM(int xx, int yy, int element_em, int sample)
15162 int element = (element_em > -1 ? map_element_EM_to_RND_game(element_em) : 0);
15164 int x = xx - offset;
15165 int y = yy - offset;
15170 PlayLevelSoundElementAction(x, y, element, ACTION_WALKING);
15174 PlayLevelSoundElementAction(x, y, element, ACTION_PUSHING);
15178 PlayLevelSoundElementAction(x, y, element, ACTION_IMPACT);
15182 PlayLevelSoundElementAction(x, y, element, ACTION_IMPACT);
15186 PlayLevelSoundElementAction(x, y, element, ACTION_BREAKING);
15190 PlayLevelSoundElementAction(x, y, element, ACTION_MOVING);
15194 PlayLevelSoundElementAction(x, y, element, ACTION_MOVING);
15197 case SOUND_android_clone:
15198 PlayLevelSoundElementAction(x, y, element, ACTION_DROPPING);
15201 case SOUND_android_move:
15202 PlayLevelSoundElementAction(x, y, element, ACTION_MOVING);
15206 PlayLevelSoundElementAction(x, y, element, ACTION_IMPACT);
15210 PlayLevelSoundElementAction(x, y, element, ACTION_EATING);
15214 PlayLevelSoundElementAction(x, y, element, ACTION_WAITING);
15217 case SOUND_eater_eat:
15218 PlayLevelSoundElementAction(x, y, element, ACTION_DIGGING);
15222 PlayLevelSoundElementAction(x, y, element, ACTION_MOVING);
15225 case SOUND_collect:
15226 PlayLevelSoundElementAction(x, y, element, ACTION_COLLECTING);
15229 case SOUND_diamond:
15230 PlayLevelSoundElementAction(x, y, element, ACTION_IMPACT);
15234 // !!! CHECK THIS !!!
15236 PlayLevelSoundElementAction(x, y, element, ACTION_BREAKING);
15238 PlayLevelSoundElementAction(x, y, element, ACTION_SMASHED_BY_ROCK);
15242 case SOUND_wonderfall:
15243 PlayLevelSoundElementAction(x, y, element, ACTION_FILLING);
15247 PlayLevelSoundElementAction(x, y, element, ACTION_IMPACT);
15251 PlayLevelSoundElementAction(x, y, element, ACTION_PUSHING);
15255 PlayLevelSoundElementAction(x, y, element, ACTION_DIGGING);
15259 PlayLevelSoundElementAction(x, y, element, ACTION_SPLASHING);
15263 PlayLevelSoundElementAction(x, y, element, ACTION_DROPPING);
15267 PlayLevelSoundElementAction(x, y, element, ACTION_GROWING);
15271 PlayLevelSoundElementAction(x, y, element, ACTION_ACTIVE);
15275 PlayLevelSoundElementAction(x, y, element, ACTION_PASSING);
15278 case SOUND_exit_open:
15279 PlayLevelSoundElementAction(x, y, element, ACTION_OPENING);
15282 case SOUND_exit_leave:
15283 PlayLevelSoundElementAction(x, y, element, ACTION_PASSING);
15286 case SOUND_dynamite:
15287 PlayLevelSoundElementAction(x, y, element, ACTION_DROPPING);
15291 PlayLevelSoundElementAction(x, y, element, ACTION_ACTIVE);
15295 PlayLevelSoundElementAction(x, y, element, ACTION_ACTIVATING);
15299 PlayLevelSoundElementAction(x, y, element, ACTION_ACTIVE);
15303 PlayLevelSoundElementAction(x, y, element, ACTION_EXPLODING);
15307 PlayLevelSoundElementAction(x, y, element, ACTION_DYING);
15311 PlaySound(SND_GAME_RUNNING_OUT_OF_TIME);
15315 PlayLevelSoundElementAction(x, y, element, ACTION_DEFAULT);
15320 void PlayLevelSound_SP(int xx, int yy, int element_sp, int action_sp)
15322 int element = map_element_SP_to_RND(element_sp);
15323 int action = map_action_SP_to_RND(action_sp);
15324 int offset = (setup.sp_show_border_elements ? 0 : 1);
15325 int x = xx - offset;
15326 int y = yy - offset;
15328 PlayLevelSoundElementAction(x, y, element, action);
15331 void PlayLevelSound_MM(int xx, int yy, int element_mm, int action_mm)
15333 int element = map_element_MM_to_RND(element_mm);
15334 int action = map_action_MM_to_RND(action_mm);
15336 int x = xx - offset;
15337 int y = yy - offset;
15339 if (!IS_MM_ELEMENT(element))
15340 element = EL_MM_DEFAULT;
15342 PlayLevelSoundElementAction(x, y, element, action);
15345 void PlaySound_MM(int sound_mm)
15347 int sound = map_sound_MM_to_RND(sound_mm);
15349 if (sound == SND_UNDEFINED)
15355 void PlaySoundLoop_MM(int sound_mm)
15357 int sound = map_sound_MM_to_RND(sound_mm);
15359 if (sound == SND_UNDEFINED)
15362 PlaySoundLoop(sound);
15365 void StopSound_MM(int sound_mm)
15367 int sound = map_sound_MM_to_RND(sound_mm);
15369 if (sound == SND_UNDEFINED)
15375 void RaiseScore(int value)
15377 game.score += value;
15379 game_panel_controls[GAME_PANEL_SCORE].value = game.score;
15381 DisplayGameControlValues();
15384 void RaiseScoreElement(int element)
15389 case EL_BD_DIAMOND:
15390 case EL_EMERALD_YELLOW:
15391 case EL_EMERALD_RED:
15392 case EL_EMERALD_PURPLE:
15393 case EL_SP_INFOTRON:
15394 RaiseScore(level.score[SC_EMERALD]);
15397 RaiseScore(level.score[SC_DIAMOND]);
15400 RaiseScore(level.score[SC_CRYSTAL]);
15403 RaiseScore(level.score[SC_PEARL]);
15406 case EL_BD_BUTTERFLY:
15407 case EL_SP_ELECTRON:
15408 RaiseScore(level.score[SC_BUG]);
15411 case EL_BD_FIREFLY:
15412 case EL_SP_SNIKSNAK:
15413 RaiseScore(level.score[SC_SPACESHIP]);
15416 case EL_DARK_YAMYAM:
15417 RaiseScore(level.score[SC_YAMYAM]);
15420 RaiseScore(level.score[SC_ROBOT]);
15423 RaiseScore(level.score[SC_PACMAN]);
15426 RaiseScore(level.score[SC_NUT]);
15429 case EL_EM_DYNAMITE:
15430 case EL_SP_DISK_RED:
15431 case EL_DYNABOMB_INCREASE_NUMBER:
15432 case EL_DYNABOMB_INCREASE_SIZE:
15433 case EL_DYNABOMB_INCREASE_POWER:
15434 RaiseScore(level.score[SC_DYNAMITE]);
15436 case EL_SHIELD_NORMAL:
15437 case EL_SHIELD_DEADLY:
15438 RaiseScore(level.score[SC_SHIELD]);
15440 case EL_EXTRA_TIME:
15441 RaiseScore(level.extra_time_score);
15455 case EL_DC_KEY_WHITE:
15456 RaiseScore(level.score[SC_KEY]);
15459 RaiseScore(element_info[element].collect_score);
15464 void RequestQuitGameExt(boolean skip_request, boolean quick_quit, char *message)
15466 if (skip_request || Request(message, REQ_ASK | REQ_STAY_CLOSED))
15470 // prevent short reactivation of overlay buttons while closing door
15471 SetOverlayActive(FALSE);
15473 // door may still be open due to skipped or envelope style request
15474 CloseDoor(DOOR_CLOSE_1);
15477 if (network.enabled)
15478 SendToServer_StopPlaying(NETWORK_STOP_BY_PLAYER);
15482 FadeSkipNextFadeIn();
15484 SetGameStatus(GAME_MODE_MAIN);
15489 else // continue playing the game
15491 if (tape.playing && tape.deactivate_display)
15492 TapeDeactivateDisplayOff(TRUE);
15494 OpenDoor(DOOR_OPEN_1 | DOOR_COPY_BACK);
15496 if (tape.playing && tape.deactivate_display)
15497 TapeDeactivateDisplayOn();
15501 void RequestQuitGame(boolean escape_key_pressed)
15503 boolean ask_on_escape = (setup.ask_on_escape && setup.ask_on_quit_game);
15504 boolean quick_quit = ((escape_key_pressed && !ask_on_escape) ||
15505 level_editor_test_game);
15506 boolean skip_request = (game.all_players_gone || !setup.ask_on_quit_game ||
15509 RequestQuitGameExt(skip_request, quick_quit,
15510 "Do you really want to quit the game?");
15513 void RequestRestartGame(char *message)
15515 game.restart_game_message = NULL;
15517 boolean has_started_game = hasStartedNetworkGame();
15518 int request_mode = (has_started_game ? REQ_ASK : REQ_CONFIRM);
15520 if (Request(message, request_mode | REQ_STAY_CLOSED) && has_started_game)
15522 StartGameActions(network.enabled, setup.autorecord, level.random_seed);
15526 // needed in case of envelope request to close game panel
15527 CloseDoor(DOOR_CLOSE_1);
15529 SetGameStatus(GAME_MODE_MAIN);
15535 void CheckGameOver(void)
15537 static boolean last_game_over = FALSE;
15538 static int game_over_delay = 0;
15539 int game_over_delay_value = 50;
15540 boolean game_over = checkGameFailed();
15542 // do not handle game over if request dialog is already active
15543 if (game.request_active)
15546 // do not ask to play again if game was never actually played
15547 if (!game.GamePlayed)
15552 last_game_over = FALSE;
15553 game_over_delay = game_over_delay_value;
15558 if (game_over_delay > 0)
15565 if (last_game_over != game_over)
15566 game.restart_game_message = (hasStartedNetworkGame() ?
15567 "Game over! Play it again?" :
15570 last_game_over = game_over;
15573 boolean checkGameSolved(void)
15575 // set for all game engines if level was solved
15576 return game.LevelSolved_GameEnd;
15579 boolean checkGameFailed(void)
15581 if (level.game_engine_type == GAME_ENGINE_TYPE_EM)
15582 return (game_em.game_over && !game_em.level_solved);
15583 else if (level.game_engine_type == GAME_ENGINE_TYPE_SP)
15584 return (game_sp.game_over && !game_sp.level_solved);
15585 else if (level.game_engine_type == GAME_ENGINE_TYPE_MM)
15586 return (game_mm.game_over && !game_mm.level_solved);
15587 else // GAME_ENGINE_TYPE_RND
15588 return (game.GameOver && !game.LevelSolved);
15591 boolean checkGameEnded(void)
15593 return (checkGameSolved() || checkGameFailed());
15597 // ----------------------------------------------------------------------------
15598 // random generator functions
15599 // ----------------------------------------------------------------------------
15601 unsigned int InitEngineRandom_RND(int seed)
15603 game.num_random_calls = 0;
15605 return InitEngineRandom(seed);
15608 unsigned int RND(int max)
15612 game.num_random_calls++;
15614 return GetEngineRandom(max);
15621 // ----------------------------------------------------------------------------
15622 // game engine snapshot handling functions
15623 // ----------------------------------------------------------------------------
15625 struct EngineSnapshotInfo
15627 // runtime values for custom element collect score
15628 int collect_score[NUM_CUSTOM_ELEMENTS];
15630 // runtime values for group element choice position
15631 int choice_pos[NUM_GROUP_ELEMENTS];
15633 // runtime values for belt position animations
15634 int belt_graphic[4][NUM_BELT_PARTS];
15635 int belt_anim_mode[4][NUM_BELT_PARTS];
15638 static struct EngineSnapshotInfo engine_snapshot_rnd;
15639 static char *snapshot_level_identifier = NULL;
15640 static int snapshot_level_nr = -1;
15642 static void SaveEngineSnapshotValues_RND(void)
15644 static int belt_base_active_element[4] =
15646 EL_CONVEYOR_BELT_1_LEFT_ACTIVE,
15647 EL_CONVEYOR_BELT_2_LEFT_ACTIVE,
15648 EL_CONVEYOR_BELT_3_LEFT_ACTIVE,
15649 EL_CONVEYOR_BELT_4_LEFT_ACTIVE
15653 for (i = 0; i < NUM_CUSTOM_ELEMENTS; i++)
15655 int element = EL_CUSTOM_START + i;
15657 engine_snapshot_rnd.collect_score[i] = element_info[element].collect_score;
15660 for (i = 0; i < NUM_GROUP_ELEMENTS; i++)
15662 int element = EL_GROUP_START + i;
15664 engine_snapshot_rnd.choice_pos[i] = element_info[element].group->choice_pos;
15667 for (i = 0; i < 4; i++)
15669 for (j = 0; j < NUM_BELT_PARTS; j++)
15671 int element = belt_base_active_element[i] + j;
15672 int graphic = el2img(element);
15673 int anim_mode = graphic_info[graphic].anim_mode;
15675 engine_snapshot_rnd.belt_graphic[i][j] = graphic;
15676 engine_snapshot_rnd.belt_anim_mode[i][j] = anim_mode;
15681 static void LoadEngineSnapshotValues_RND(void)
15683 unsigned int num_random_calls = game.num_random_calls;
15686 for (i = 0; i < NUM_CUSTOM_ELEMENTS; i++)
15688 int element = EL_CUSTOM_START + i;
15690 element_info[element].collect_score = engine_snapshot_rnd.collect_score[i];
15693 for (i = 0; i < NUM_GROUP_ELEMENTS; i++)
15695 int element = EL_GROUP_START + i;
15697 element_info[element].group->choice_pos = engine_snapshot_rnd.choice_pos[i];
15700 for (i = 0; i < 4; i++)
15702 for (j = 0; j < NUM_BELT_PARTS; j++)
15704 int graphic = engine_snapshot_rnd.belt_graphic[i][j];
15705 int anim_mode = engine_snapshot_rnd.belt_anim_mode[i][j];
15707 graphic_info[graphic].anim_mode = anim_mode;
15711 if (level.game_engine_type == GAME_ENGINE_TYPE_RND)
15713 InitRND(tape.random_seed);
15714 for (i = 0; i < num_random_calls; i++)
15718 if (game.num_random_calls != num_random_calls)
15720 Error("number of random calls out of sync");
15721 Error("number of random calls should be %d", num_random_calls);
15722 Error("number of random calls is %d", game.num_random_calls);
15724 Fail("this should not happen -- please debug");
15728 void FreeEngineSnapshotSingle(void)
15730 FreeSnapshotSingle();
15732 setString(&snapshot_level_identifier, NULL);
15733 snapshot_level_nr = -1;
15736 void FreeEngineSnapshotList(void)
15738 FreeSnapshotList();
15741 static ListNode *SaveEngineSnapshotBuffers(void)
15743 ListNode *buffers = NULL;
15745 // copy some special values to a structure better suited for the snapshot
15747 if (level.game_engine_type == GAME_ENGINE_TYPE_RND)
15748 SaveEngineSnapshotValues_RND();
15749 if (level.game_engine_type == GAME_ENGINE_TYPE_EM)
15750 SaveEngineSnapshotValues_EM();
15751 if (level.game_engine_type == GAME_ENGINE_TYPE_SP)
15752 SaveEngineSnapshotValues_SP(&buffers);
15753 if (level.game_engine_type == GAME_ENGINE_TYPE_MM)
15754 SaveEngineSnapshotValues_MM(&buffers);
15756 // save values stored in special snapshot structure
15758 if (level.game_engine_type == GAME_ENGINE_TYPE_RND)
15759 SaveSnapshotBuffer(&buffers, ARGS_ADDRESS_AND_SIZEOF(engine_snapshot_rnd));
15760 if (level.game_engine_type == GAME_ENGINE_TYPE_EM)
15761 SaveSnapshotBuffer(&buffers, ARGS_ADDRESS_AND_SIZEOF(engine_snapshot_em));
15762 if (level.game_engine_type == GAME_ENGINE_TYPE_SP)
15763 SaveSnapshotBuffer(&buffers, ARGS_ADDRESS_AND_SIZEOF(engine_snapshot_sp));
15764 if (level.game_engine_type == GAME_ENGINE_TYPE_MM)
15765 SaveSnapshotBuffer(&buffers, ARGS_ADDRESS_AND_SIZEOF(engine_snapshot_mm));
15767 // save further RND engine values
15769 SaveSnapshotBuffer(&buffers, ARGS_ADDRESS_AND_SIZEOF(stored_player));
15770 SaveSnapshotBuffer(&buffers, ARGS_ADDRESS_AND_SIZEOF(game));
15771 SaveSnapshotBuffer(&buffers, ARGS_ADDRESS_AND_SIZEOF(tape));
15773 SaveSnapshotBuffer(&buffers, ARGS_ADDRESS_AND_SIZEOF(FrameCounter));
15774 SaveSnapshotBuffer(&buffers, ARGS_ADDRESS_AND_SIZEOF(TimeFrames));
15775 SaveSnapshotBuffer(&buffers, ARGS_ADDRESS_AND_SIZEOF(TimePlayed));
15776 SaveSnapshotBuffer(&buffers, ARGS_ADDRESS_AND_SIZEOF(TimeLeft));
15777 SaveSnapshotBuffer(&buffers, ARGS_ADDRESS_AND_SIZEOF(TapeTime));
15779 SaveSnapshotBuffer(&buffers, ARGS_ADDRESS_AND_SIZEOF(ScreenMovDir));
15780 SaveSnapshotBuffer(&buffers, ARGS_ADDRESS_AND_SIZEOF(ScreenMovPos));
15781 SaveSnapshotBuffer(&buffers, ARGS_ADDRESS_AND_SIZEOF(ScreenGfxPos));
15783 SaveSnapshotBuffer(&buffers, ARGS_ADDRESS_AND_SIZEOF(ScrollStepSize));
15785 SaveSnapshotBuffer(&buffers, ARGS_ADDRESS_AND_SIZEOF(AmoebaCnt));
15786 SaveSnapshotBuffer(&buffers, ARGS_ADDRESS_AND_SIZEOF(AmoebaCnt2));
15788 SaveSnapshotBuffer(&buffers, ARGS_ADDRESS_AND_SIZEOF(Tile));
15789 SaveSnapshotBuffer(&buffers, ARGS_ADDRESS_AND_SIZEOF(MovPos));
15790 SaveSnapshotBuffer(&buffers, ARGS_ADDRESS_AND_SIZEOF(MovDir));
15791 SaveSnapshotBuffer(&buffers, ARGS_ADDRESS_AND_SIZEOF(MovDelay));
15792 SaveSnapshotBuffer(&buffers, ARGS_ADDRESS_AND_SIZEOF(ChangeDelay));
15793 SaveSnapshotBuffer(&buffers, ARGS_ADDRESS_AND_SIZEOF(ChangePage));
15794 SaveSnapshotBuffer(&buffers, ARGS_ADDRESS_AND_SIZEOF(CustomValue));
15795 SaveSnapshotBuffer(&buffers, ARGS_ADDRESS_AND_SIZEOF(Store));
15796 SaveSnapshotBuffer(&buffers, ARGS_ADDRESS_AND_SIZEOF(Store2));
15797 SaveSnapshotBuffer(&buffers, ARGS_ADDRESS_AND_SIZEOF(StorePlayer));
15798 SaveSnapshotBuffer(&buffers, ARGS_ADDRESS_AND_SIZEOF(Back));
15799 SaveSnapshotBuffer(&buffers, ARGS_ADDRESS_AND_SIZEOF(AmoebaNr));
15800 SaveSnapshotBuffer(&buffers, ARGS_ADDRESS_AND_SIZEOF(WasJustMoving));
15801 SaveSnapshotBuffer(&buffers, ARGS_ADDRESS_AND_SIZEOF(WasJustFalling));
15802 SaveSnapshotBuffer(&buffers, ARGS_ADDRESS_AND_SIZEOF(CheckCollision));
15803 SaveSnapshotBuffer(&buffers, ARGS_ADDRESS_AND_SIZEOF(CheckImpact));
15804 SaveSnapshotBuffer(&buffers, ARGS_ADDRESS_AND_SIZEOF(Stop));
15805 SaveSnapshotBuffer(&buffers, ARGS_ADDRESS_AND_SIZEOF(Pushed));
15807 SaveSnapshotBuffer(&buffers, ARGS_ADDRESS_AND_SIZEOF(ChangeCount));
15808 SaveSnapshotBuffer(&buffers, ARGS_ADDRESS_AND_SIZEOF(ChangeEvent));
15810 SaveSnapshotBuffer(&buffers, ARGS_ADDRESS_AND_SIZEOF(ExplodePhase));
15811 SaveSnapshotBuffer(&buffers, ARGS_ADDRESS_AND_SIZEOF(ExplodeDelay));
15812 SaveSnapshotBuffer(&buffers, ARGS_ADDRESS_AND_SIZEOF(ExplodeField));
15814 SaveSnapshotBuffer(&buffers, ARGS_ADDRESS_AND_SIZEOF(RunnerVisit));
15815 SaveSnapshotBuffer(&buffers, ARGS_ADDRESS_AND_SIZEOF(PlayerVisit));
15817 SaveSnapshotBuffer(&buffers, ARGS_ADDRESS_AND_SIZEOF(GfxFrame));
15818 SaveSnapshotBuffer(&buffers, ARGS_ADDRESS_AND_SIZEOF(GfxRandom));
15819 SaveSnapshotBuffer(&buffers, ARGS_ADDRESS_AND_SIZEOF(GfxElement));
15820 SaveSnapshotBuffer(&buffers, ARGS_ADDRESS_AND_SIZEOF(GfxAction));
15821 SaveSnapshotBuffer(&buffers, ARGS_ADDRESS_AND_SIZEOF(GfxDir));
15823 SaveSnapshotBuffer(&buffers, ARGS_ADDRESS_AND_SIZEOF(scroll_x));
15824 SaveSnapshotBuffer(&buffers, ARGS_ADDRESS_AND_SIZEOF(scroll_y));
15827 ListNode *node = engine_snapshot_list_rnd;
15830 while (node != NULL)
15832 num_bytes += ((struct EngineSnapshotNodeInfo *)node->content)->size;
15837 Debug("game:playing:SaveEngineSnapshotBuffers",
15838 "size of engine snapshot: %d bytes", num_bytes);
15844 void SaveEngineSnapshotSingle(void)
15846 ListNode *buffers = SaveEngineSnapshotBuffers();
15848 // finally save all snapshot buffers to single snapshot
15849 SaveSnapshotSingle(buffers);
15851 // save level identification information
15852 setString(&snapshot_level_identifier, leveldir_current->identifier);
15853 snapshot_level_nr = level_nr;
15856 boolean CheckSaveEngineSnapshotToList(void)
15858 boolean save_snapshot =
15859 ((game.snapshot.mode == SNAPSHOT_MODE_EVERY_STEP) ||
15860 (game.snapshot.mode == SNAPSHOT_MODE_EVERY_MOVE &&
15861 game.snapshot.changed_action) ||
15862 (game.snapshot.mode == SNAPSHOT_MODE_EVERY_COLLECT &&
15863 game.snapshot.collected_item));
15865 game.snapshot.changed_action = FALSE;
15866 game.snapshot.collected_item = FALSE;
15867 game.snapshot.save_snapshot = save_snapshot;
15869 return save_snapshot;
15872 void SaveEngineSnapshotToList(void)
15874 if (game.snapshot.mode == SNAPSHOT_MODE_OFF ||
15878 ListNode *buffers = SaveEngineSnapshotBuffers();
15880 // finally save all snapshot buffers to snapshot list
15881 SaveSnapshotToList(buffers);
15884 void SaveEngineSnapshotToListInitial(void)
15886 FreeEngineSnapshotList();
15888 SaveEngineSnapshotToList();
15891 static void LoadEngineSnapshotValues(void)
15893 // restore special values from snapshot structure
15895 if (level.game_engine_type == GAME_ENGINE_TYPE_RND)
15896 LoadEngineSnapshotValues_RND();
15897 if (level.game_engine_type == GAME_ENGINE_TYPE_EM)
15898 LoadEngineSnapshotValues_EM();
15899 if (level.game_engine_type == GAME_ENGINE_TYPE_SP)
15900 LoadEngineSnapshotValues_SP();
15901 if (level.game_engine_type == GAME_ENGINE_TYPE_MM)
15902 LoadEngineSnapshotValues_MM();
15905 void LoadEngineSnapshotSingle(void)
15907 LoadSnapshotSingle();
15909 LoadEngineSnapshotValues();
15912 static void LoadEngineSnapshot_Undo(int steps)
15914 LoadSnapshotFromList_Older(steps);
15916 LoadEngineSnapshotValues();
15919 static void LoadEngineSnapshot_Redo(int steps)
15921 LoadSnapshotFromList_Newer(steps);
15923 LoadEngineSnapshotValues();
15926 boolean CheckEngineSnapshotSingle(void)
15928 return (strEqual(snapshot_level_identifier, leveldir_current->identifier) &&
15929 snapshot_level_nr == level_nr);
15932 boolean CheckEngineSnapshotList(void)
15934 return CheckSnapshotList();
15938 // ---------- new game button stuff -------------------------------------------
15945 boolean *setup_value;
15946 boolean allowed_on_tape;
15947 boolean is_touch_button;
15949 } gamebutton_info[NUM_GAME_BUTTONS] =
15952 IMG_GFX_GAME_BUTTON_STOP, &game.button.stop,
15953 GAME_CTRL_ID_STOP, NULL,
15954 TRUE, FALSE, "stop game"
15957 IMG_GFX_GAME_BUTTON_PAUSE, &game.button.pause,
15958 GAME_CTRL_ID_PAUSE, NULL,
15959 TRUE, FALSE, "pause game"
15962 IMG_GFX_GAME_BUTTON_PLAY, &game.button.play,
15963 GAME_CTRL_ID_PLAY, NULL,
15964 TRUE, FALSE, "play game"
15967 IMG_GFX_GAME_BUTTON_UNDO, &game.button.undo,
15968 GAME_CTRL_ID_UNDO, NULL,
15969 TRUE, FALSE, "undo step"
15972 IMG_GFX_GAME_BUTTON_REDO, &game.button.redo,
15973 GAME_CTRL_ID_REDO, NULL,
15974 TRUE, FALSE, "redo step"
15977 IMG_GFX_GAME_BUTTON_SAVE, &game.button.save,
15978 GAME_CTRL_ID_SAVE, NULL,
15979 TRUE, FALSE, "save game"
15982 IMG_GFX_GAME_BUTTON_PAUSE2, &game.button.pause2,
15983 GAME_CTRL_ID_PAUSE2, NULL,
15984 TRUE, FALSE, "pause game"
15987 IMG_GFX_GAME_BUTTON_LOAD, &game.button.load,
15988 GAME_CTRL_ID_LOAD, NULL,
15989 TRUE, FALSE, "load game"
15992 IMG_GFX_GAME_BUTTON_PANEL_STOP, &game.button.panel_stop,
15993 GAME_CTRL_ID_PANEL_STOP, NULL,
15994 FALSE, FALSE, "stop game"
15997 IMG_GFX_GAME_BUTTON_PANEL_PAUSE, &game.button.panel_pause,
15998 GAME_CTRL_ID_PANEL_PAUSE, NULL,
15999 FALSE, FALSE, "pause game"
16002 IMG_GFX_GAME_BUTTON_PANEL_PLAY, &game.button.panel_play,
16003 GAME_CTRL_ID_PANEL_PLAY, NULL,
16004 FALSE, FALSE, "play game"
16007 IMG_GFX_GAME_BUTTON_TOUCH_STOP, &game.button.touch_stop,
16008 GAME_CTRL_ID_TOUCH_STOP, NULL,
16009 FALSE, TRUE, "stop game"
16012 IMG_GFX_GAME_BUTTON_TOUCH_PAUSE, &game.button.touch_pause,
16013 GAME_CTRL_ID_TOUCH_PAUSE, NULL,
16014 FALSE, TRUE, "pause game"
16017 IMG_GFX_GAME_BUTTON_SOUND_MUSIC, &game.button.sound_music,
16018 SOUND_CTRL_ID_MUSIC, &setup.sound_music,
16019 TRUE, FALSE, "background music on/off"
16022 IMG_GFX_GAME_BUTTON_SOUND_LOOPS, &game.button.sound_loops,
16023 SOUND_CTRL_ID_LOOPS, &setup.sound_loops,
16024 TRUE, FALSE, "sound loops on/off"
16027 IMG_GFX_GAME_BUTTON_SOUND_SIMPLE, &game.button.sound_simple,
16028 SOUND_CTRL_ID_SIMPLE, &setup.sound_simple,
16029 TRUE, FALSE, "normal sounds on/off"
16032 IMG_GFX_GAME_BUTTON_PANEL_SOUND_MUSIC, &game.button.panel_sound_music,
16033 SOUND_CTRL_ID_PANEL_MUSIC, &setup.sound_music,
16034 FALSE, FALSE, "background music on/off"
16037 IMG_GFX_GAME_BUTTON_PANEL_SOUND_LOOPS, &game.button.panel_sound_loops,
16038 SOUND_CTRL_ID_PANEL_LOOPS, &setup.sound_loops,
16039 FALSE, FALSE, "sound loops on/off"
16042 IMG_GFX_GAME_BUTTON_PANEL_SOUND_SIMPLE, &game.button.panel_sound_simple,
16043 SOUND_CTRL_ID_PANEL_SIMPLE, &setup.sound_simple,
16044 FALSE, FALSE, "normal sounds on/off"
16048 void CreateGameButtons(void)
16052 for (i = 0; i < NUM_GAME_BUTTONS; i++)
16054 int graphic = gamebutton_info[i].graphic;
16055 struct GraphicInfo *gfx = &graphic_info[graphic];
16056 struct XY *pos = gamebutton_info[i].pos;
16057 struct GadgetInfo *gi;
16060 unsigned int event_mask;
16061 boolean is_touch_button = gamebutton_info[i].is_touch_button;
16062 boolean allowed_on_tape = gamebutton_info[i].allowed_on_tape;
16063 boolean on_tape = (tape.show_game_buttons && allowed_on_tape);
16064 int base_x = (is_touch_button ? 0 : on_tape ? VX : DX);
16065 int base_y = (is_touch_button ? 0 : on_tape ? VY : DY);
16066 int gd_x = gfx->src_x;
16067 int gd_y = gfx->src_y;
16068 int gd_xp = gfx->src_x + gfx->pressed_xoffset;
16069 int gd_yp = gfx->src_y + gfx->pressed_yoffset;
16070 int gd_xa = gfx->src_x + gfx->active_xoffset;
16071 int gd_ya = gfx->src_y + gfx->active_yoffset;
16072 int gd_xap = gfx->src_x + gfx->active_xoffset + gfx->pressed_xoffset;
16073 int gd_yap = gfx->src_y + gfx->active_yoffset + gfx->pressed_yoffset;
16074 int x = (is_touch_button ? pos->x : GDI_ACTIVE_POS(pos->x));
16075 int y = (is_touch_button ? pos->y : GDI_ACTIVE_POS(pos->y));
16078 if (gfx->bitmap == NULL)
16080 game_gadget[id] = NULL;
16085 if (id == GAME_CTRL_ID_STOP ||
16086 id == GAME_CTRL_ID_PANEL_STOP ||
16087 id == GAME_CTRL_ID_TOUCH_STOP ||
16088 id == GAME_CTRL_ID_PLAY ||
16089 id == GAME_CTRL_ID_PANEL_PLAY ||
16090 id == GAME_CTRL_ID_SAVE ||
16091 id == GAME_CTRL_ID_LOAD)
16093 button_type = GD_TYPE_NORMAL_BUTTON;
16095 event_mask = GD_EVENT_RELEASED;
16097 else if (id == GAME_CTRL_ID_UNDO ||
16098 id == GAME_CTRL_ID_REDO)
16100 button_type = GD_TYPE_NORMAL_BUTTON;
16102 event_mask = GD_EVENT_PRESSED | GD_EVENT_REPEATED;
16106 button_type = GD_TYPE_CHECK_BUTTON;
16107 checked = (gamebutton_info[i].setup_value != NULL ?
16108 *gamebutton_info[i].setup_value : FALSE);
16109 event_mask = GD_EVENT_PRESSED;
16112 gi = CreateGadget(GDI_CUSTOM_ID, id,
16113 GDI_IMAGE_ID, graphic,
16114 GDI_INFO_TEXT, gamebutton_info[i].infotext,
16117 GDI_WIDTH, gfx->width,
16118 GDI_HEIGHT, gfx->height,
16119 GDI_TYPE, button_type,
16120 GDI_STATE, GD_BUTTON_UNPRESSED,
16121 GDI_CHECKED, checked,
16122 GDI_DESIGN_UNPRESSED, gfx->bitmap, gd_x, gd_y,
16123 GDI_DESIGN_PRESSED, gfx->bitmap, gd_xp, gd_yp,
16124 GDI_ALT_DESIGN_UNPRESSED, gfx->bitmap, gd_xa, gd_ya,
16125 GDI_ALT_DESIGN_PRESSED, gfx->bitmap, gd_xap, gd_yap,
16126 GDI_DIRECT_DRAW, FALSE,
16127 GDI_OVERLAY_TOUCH_BUTTON, is_touch_button,
16128 GDI_EVENT_MASK, event_mask,
16129 GDI_CALLBACK_ACTION, HandleGameButtons,
16133 Fail("cannot create gadget");
16135 game_gadget[id] = gi;
16139 void FreeGameButtons(void)
16143 for (i = 0; i < NUM_GAME_BUTTONS; i++)
16144 FreeGadget(game_gadget[i]);
16147 static void UnmapGameButtonsAtSamePosition(int id)
16151 for (i = 0; i < NUM_GAME_BUTTONS; i++)
16153 gamebutton_info[i].pos->x == gamebutton_info[id].pos->x &&
16154 gamebutton_info[i].pos->y == gamebutton_info[id].pos->y)
16155 UnmapGadget(game_gadget[i]);
16158 static void UnmapGameButtonsAtSamePosition_All(void)
16160 if (setup.show_snapshot_buttons)
16162 UnmapGameButtonsAtSamePosition(GAME_CTRL_ID_SAVE);
16163 UnmapGameButtonsAtSamePosition(GAME_CTRL_ID_PAUSE2);
16164 UnmapGameButtonsAtSamePosition(GAME_CTRL_ID_LOAD);
16168 UnmapGameButtonsAtSamePosition(GAME_CTRL_ID_STOP);
16169 UnmapGameButtonsAtSamePosition(GAME_CTRL_ID_PAUSE);
16170 UnmapGameButtonsAtSamePosition(GAME_CTRL_ID_PLAY);
16172 UnmapGameButtonsAtSamePosition(GAME_CTRL_ID_PANEL_STOP);
16173 UnmapGameButtonsAtSamePosition(GAME_CTRL_ID_PANEL_PAUSE);
16174 UnmapGameButtonsAtSamePosition(GAME_CTRL_ID_PANEL_PLAY);
16178 static void MapGameButtonsAtSamePosition(int id)
16182 for (i = 0; i < NUM_GAME_BUTTONS; i++)
16184 gamebutton_info[i].pos->x == gamebutton_info[id].pos->x &&
16185 gamebutton_info[i].pos->y == gamebutton_info[id].pos->y)
16186 MapGadget(game_gadget[i]);
16188 UnmapGameButtonsAtSamePosition_All();
16191 void MapUndoRedoButtons(void)
16193 UnmapGameButtonsAtSamePosition(GAME_CTRL_ID_UNDO);
16194 UnmapGameButtonsAtSamePosition(GAME_CTRL_ID_REDO);
16196 MapGadget(game_gadget[GAME_CTRL_ID_UNDO]);
16197 MapGadget(game_gadget[GAME_CTRL_ID_REDO]);
16200 void UnmapUndoRedoButtons(void)
16202 UnmapGadget(game_gadget[GAME_CTRL_ID_UNDO]);
16203 UnmapGadget(game_gadget[GAME_CTRL_ID_REDO]);
16205 MapGameButtonsAtSamePosition(GAME_CTRL_ID_UNDO);
16206 MapGameButtonsAtSamePosition(GAME_CTRL_ID_REDO);
16209 void ModifyPauseButtons(void)
16213 GAME_CTRL_ID_PAUSE,
16214 GAME_CTRL_ID_PAUSE2,
16215 GAME_CTRL_ID_PANEL_PAUSE,
16216 GAME_CTRL_ID_TOUCH_PAUSE,
16221 for (i = 0; ids[i] > -1; i++)
16222 ModifyGadget(game_gadget[ids[i]], GDI_CHECKED, tape.pausing, GDI_END);
16225 static void MapGameButtonsExt(boolean on_tape)
16229 for (i = 0; i < NUM_GAME_BUTTONS; i++)
16230 if ((!on_tape || gamebutton_info[i].allowed_on_tape) &&
16231 i != GAME_CTRL_ID_UNDO &&
16232 i != GAME_CTRL_ID_REDO)
16233 MapGadget(game_gadget[i]);
16235 UnmapGameButtonsAtSamePosition_All();
16237 RedrawGameButtons();
16240 static void UnmapGameButtonsExt(boolean on_tape)
16244 for (i = 0; i < NUM_GAME_BUTTONS; i++)
16245 if (!on_tape || gamebutton_info[i].allowed_on_tape)
16246 UnmapGadget(game_gadget[i]);
16249 static void RedrawGameButtonsExt(boolean on_tape)
16253 for (i = 0; i < NUM_GAME_BUTTONS; i++)
16254 if (!on_tape || gamebutton_info[i].allowed_on_tape)
16255 RedrawGadget(game_gadget[i]);
16258 static void SetGadgetState(struct GadgetInfo *gi, boolean state)
16263 gi->checked = state;
16266 static void RedrawSoundButtonGadget(int id)
16268 int id2 = (id == SOUND_CTRL_ID_MUSIC ? SOUND_CTRL_ID_PANEL_MUSIC :
16269 id == SOUND_CTRL_ID_LOOPS ? SOUND_CTRL_ID_PANEL_LOOPS :
16270 id == SOUND_CTRL_ID_SIMPLE ? SOUND_CTRL_ID_PANEL_SIMPLE :
16271 id == SOUND_CTRL_ID_PANEL_MUSIC ? SOUND_CTRL_ID_MUSIC :
16272 id == SOUND_CTRL_ID_PANEL_LOOPS ? SOUND_CTRL_ID_LOOPS :
16273 id == SOUND_CTRL_ID_PANEL_SIMPLE ? SOUND_CTRL_ID_SIMPLE :
16276 SetGadgetState(game_gadget[id2], *gamebutton_info[id2].setup_value);
16277 RedrawGadget(game_gadget[id2]);
16280 void MapGameButtons(void)
16282 MapGameButtonsExt(FALSE);
16285 void UnmapGameButtons(void)
16287 UnmapGameButtonsExt(FALSE);
16290 void RedrawGameButtons(void)
16292 RedrawGameButtonsExt(FALSE);
16295 void MapGameButtonsOnTape(void)
16297 MapGameButtonsExt(TRUE);
16300 void UnmapGameButtonsOnTape(void)
16302 UnmapGameButtonsExt(TRUE);
16305 void RedrawGameButtonsOnTape(void)
16307 RedrawGameButtonsExt(TRUE);
16310 static void GameUndoRedoExt(void)
16312 ClearPlayerAction();
16314 tape.pausing = TRUE;
16317 UpdateAndDisplayGameControlValues();
16319 DrawCompleteVideoDisplay();
16320 DrawVideoDisplay(VIDEO_STATE_TIME_ON, TapeTime);
16321 DrawVideoDisplay(VIDEO_STATE_FRAME_ON, FrameCounter);
16322 DrawVideoDisplay(VIDEO_STATE_1STEP(tape.single_step), 0);
16327 static void GameUndo(int steps)
16329 if (!CheckEngineSnapshotList())
16332 LoadEngineSnapshot_Undo(steps);
16337 static void GameRedo(int steps)
16339 if (!CheckEngineSnapshotList())
16342 LoadEngineSnapshot_Redo(steps);
16347 static void HandleGameButtonsExt(int id, int button)
16349 static boolean game_undo_executed = FALSE;
16350 int steps = BUTTON_STEPSIZE(button);
16351 boolean handle_game_buttons =
16352 (game_status == GAME_MODE_PLAYING ||
16353 (game_status == GAME_MODE_MAIN && tape.show_game_buttons));
16355 if (!handle_game_buttons)
16360 case GAME_CTRL_ID_STOP:
16361 case GAME_CTRL_ID_PANEL_STOP:
16362 case GAME_CTRL_ID_TOUCH_STOP:
16363 if (game_status == GAME_MODE_MAIN)
16369 RequestQuitGame(FALSE);
16373 case GAME_CTRL_ID_PAUSE:
16374 case GAME_CTRL_ID_PAUSE2:
16375 case GAME_CTRL_ID_PANEL_PAUSE:
16376 case GAME_CTRL_ID_TOUCH_PAUSE:
16377 if (network.enabled && game_status == GAME_MODE_PLAYING)
16380 SendToServer_ContinuePlaying();
16382 SendToServer_PausePlaying();
16385 TapeTogglePause(TAPE_TOGGLE_MANUAL);
16387 game_undo_executed = FALSE;
16391 case GAME_CTRL_ID_PLAY:
16392 case GAME_CTRL_ID_PANEL_PLAY:
16393 if (game_status == GAME_MODE_MAIN)
16395 StartGameActions(network.enabled, setup.autorecord, level.random_seed);
16397 else if (tape.pausing)
16399 if (network.enabled)
16400 SendToServer_ContinuePlaying();
16402 TapeTogglePause(TAPE_TOGGLE_MANUAL | TAPE_TOGGLE_PLAY_PAUSE);
16406 case GAME_CTRL_ID_UNDO:
16407 // Important: When using "save snapshot when collecting an item" mode,
16408 // load last (current) snapshot for first "undo" after pressing "pause"
16409 // (else the last-but-one snapshot would be loaded, because the snapshot
16410 // pointer already points to the last snapshot when pressing "pause",
16411 // which is fine for "every step/move" mode, but not for "every collect")
16412 if (game.snapshot.mode == SNAPSHOT_MODE_EVERY_COLLECT &&
16413 !game_undo_executed)
16416 game_undo_executed = TRUE;
16421 case GAME_CTRL_ID_REDO:
16425 case GAME_CTRL_ID_SAVE:
16429 case GAME_CTRL_ID_LOAD:
16433 case SOUND_CTRL_ID_MUSIC:
16434 case SOUND_CTRL_ID_PANEL_MUSIC:
16435 if (setup.sound_music)
16437 setup.sound_music = FALSE;
16441 else if (audio.music_available)
16443 setup.sound = setup.sound_music = TRUE;
16445 SetAudioMode(setup.sound);
16447 if (game_status == GAME_MODE_PLAYING)
16451 RedrawSoundButtonGadget(id);
16455 case SOUND_CTRL_ID_LOOPS:
16456 case SOUND_CTRL_ID_PANEL_LOOPS:
16457 if (setup.sound_loops)
16458 setup.sound_loops = FALSE;
16459 else if (audio.loops_available)
16461 setup.sound = setup.sound_loops = TRUE;
16463 SetAudioMode(setup.sound);
16466 RedrawSoundButtonGadget(id);
16470 case SOUND_CTRL_ID_SIMPLE:
16471 case SOUND_CTRL_ID_PANEL_SIMPLE:
16472 if (setup.sound_simple)
16473 setup.sound_simple = FALSE;
16474 else if (audio.sound_available)
16476 setup.sound = setup.sound_simple = TRUE;
16478 SetAudioMode(setup.sound);
16481 RedrawSoundButtonGadget(id);
16490 static void HandleGameButtons(struct GadgetInfo *gi)
16492 HandleGameButtonsExt(gi->custom_id, gi->event.button);
16495 void HandleSoundButtonKeys(Key key)
16497 if (key == setup.shortcut.sound_simple)
16498 ClickOnGadget(game_gadget[SOUND_CTRL_ID_SIMPLE], MB_LEFTBUTTON);
16499 else if (key == setup.shortcut.sound_loops)
16500 ClickOnGadget(game_gadget[SOUND_CTRL_ID_LOOPS], MB_LEFTBUTTON);
16501 else if (key == setup.shortcut.sound_music)
16502 ClickOnGadget(game_gadget[SOUND_CTRL_ID_MUSIC], MB_LEFTBUTTON);