1 // ============================================================================
2 // Rocks'n'Diamonds - McDuffin Strikes Back!
3 // ----------------------------------------------------------------------------
4 // (c) 1995-2014 by Artsoft Entertainment
7 // https://www.artsoft.org/
8 // ----------------------------------------------------------------------------
10 // ============================================================================
12 #include "libgame/libgame.h"
26 #define DEBUG_INIT_PLAYER 1
27 #define DEBUG_PLAYER_ACTIONS 0
30 #define USE_NEW_AMOEBA_CODE FALSE
33 #define USE_QUICKSAND_BD_ROCK_BUGFIX 0
34 #define USE_QUICKSAND_IMPACT_BUGFIX 0
35 #define USE_DELAYED_GFX_REDRAW 0
36 #define USE_NEW_PLAYER_ASSIGNMENTS 1
38 #if USE_DELAYED_GFX_REDRAW
39 #define TEST_DrawLevelField(x, y) \
40 GfxRedraw[x][y] |= GFX_REDRAW_TILE
41 #define TEST_DrawLevelFieldCrumbled(x, y) \
42 GfxRedraw[x][y] |= GFX_REDRAW_TILE_CRUMBLED
43 #define TEST_DrawLevelFieldCrumbledNeighbours(x, y) \
44 GfxRedraw[x][y] |= GFX_REDRAW_TILE_CRUMBLED_NEIGHBOURS
45 #define TEST_DrawTwinkleOnField(x, y) \
46 GfxRedraw[x][y] |= GFX_REDRAW_TILE_TWINKLED
48 #define TEST_DrawLevelField(x, y) \
50 #define TEST_DrawLevelFieldCrumbled(x, y) \
51 DrawLevelFieldCrumbled(x, y)
52 #define TEST_DrawLevelFieldCrumbledNeighbours(x, y) \
53 DrawLevelFieldCrumbledNeighbours(x, y)
54 #define TEST_DrawTwinkleOnField(x, y) \
55 DrawTwinkleOnField(x, y)
65 #define MP_NO_ACTION 0
68 #define MP_DONT_RUN_INTO (MP_MOVING | MP_ACTION)
72 #define SCROLL_GO_ON 1
74 // for Bang()/Explode()
75 #define EX_PHASE_START 0
76 #define EX_TYPE_NONE 0
77 #define EX_TYPE_NORMAL (1 << 0)
78 #define EX_TYPE_CENTER (1 << 1)
79 #define EX_TYPE_BORDER (1 << 2)
80 #define EX_TYPE_CROSS (1 << 3)
81 #define EX_TYPE_DYNA (1 << 4)
82 #define EX_TYPE_SINGLE_TILE (EX_TYPE_CENTER | EX_TYPE_BORDER)
84 #define PANEL_OFF() (game.panel.active == FALSE)
85 #define PANEL_DEACTIVATED(p) ((p)->x < 0 || (p)->y < 0 || PANEL_OFF())
86 #define PANEL_XPOS(p) (DX + ALIGNED_TEXT_XPOS(p))
87 #define PANEL_YPOS(p) (DY + ALIGNED_TEXT_YPOS(p))
89 // game panel display and control definitions
90 #define GAME_PANEL_LEVEL_NUMBER 0
91 #define GAME_PANEL_GEMS 1
92 #define GAME_PANEL_INVENTORY_COUNT 2
93 #define GAME_PANEL_INVENTORY_FIRST_1 3
94 #define GAME_PANEL_INVENTORY_FIRST_2 4
95 #define GAME_PANEL_INVENTORY_FIRST_3 5
96 #define GAME_PANEL_INVENTORY_FIRST_4 6
97 #define GAME_PANEL_INVENTORY_FIRST_5 7
98 #define GAME_PANEL_INVENTORY_FIRST_6 8
99 #define GAME_PANEL_INVENTORY_FIRST_7 9
100 #define GAME_PANEL_INVENTORY_FIRST_8 10
101 #define GAME_PANEL_INVENTORY_LAST_1 11
102 #define GAME_PANEL_INVENTORY_LAST_2 12
103 #define GAME_PANEL_INVENTORY_LAST_3 13
104 #define GAME_PANEL_INVENTORY_LAST_4 14
105 #define GAME_PANEL_INVENTORY_LAST_5 15
106 #define GAME_PANEL_INVENTORY_LAST_6 16
107 #define GAME_PANEL_INVENTORY_LAST_7 17
108 #define GAME_PANEL_INVENTORY_LAST_8 18
109 #define GAME_PANEL_KEY_1 19
110 #define GAME_PANEL_KEY_2 20
111 #define GAME_PANEL_KEY_3 21
112 #define GAME_PANEL_KEY_4 22
113 #define GAME_PANEL_KEY_5 23
114 #define GAME_PANEL_KEY_6 24
115 #define GAME_PANEL_KEY_7 25
116 #define GAME_PANEL_KEY_8 26
117 #define GAME_PANEL_KEY_WHITE 27
118 #define GAME_PANEL_KEY_WHITE_COUNT 28
119 #define GAME_PANEL_SCORE 29
120 #define GAME_PANEL_HIGHSCORE 30
121 #define GAME_PANEL_TIME 31
122 #define GAME_PANEL_TIME_HH 32
123 #define GAME_PANEL_TIME_MM 33
124 #define GAME_PANEL_TIME_SS 34
125 #define GAME_PANEL_TIME_ANIM 35
126 #define GAME_PANEL_HEALTH 36
127 #define GAME_PANEL_HEALTH_ANIM 37
128 #define GAME_PANEL_FRAME 38
129 #define GAME_PANEL_SHIELD_NORMAL 39
130 #define GAME_PANEL_SHIELD_NORMAL_TIME 40
131 #define GAME_PANEL_SHIELD_DEADLY 41
132 #define GAME_PANEL_SHIELD_DEADLY_TIME 42
133 #define GAME_PANEL_EXIT 43
134 #define GAME_PANEL_EMC_MAGIC_BALL 44
135 #define GAME_PANEL_EMC_MAGIC_BALL_SWITCH 45
136 #define GAME_PANEL_LIGHT_SWITCH 46
137 #define GAME_PANEL_LIGHT_SWITCH_TIME 47
138 #define GAME_PANEL_TIMEGATE_SWITCH 48
139 #define GAME_PANEL_TIMEGATE_SWITCH_TIME 49
140 #define GAME_PANEL_SWITCHGATE_SWITCH 50
141 #define GAME_PANEL_EMC_LENSES 51
142 #define GAME_PANEL_EMC_LENSES_TIME 52
143 #define GAME_PANEL_EMC_MAGNIFIER 53
144 #define GAME_PANEL_EMC_MAGNIFIER_TIME 54
145 #define GAME_PANEL_BALLOON_SWITCH 55
146 #define GAME_PANEL_DYNABOMB_NUMBER 56
147 #define GAME_PANEL_DYNABOMB_SIZE 57
148 #define GAME_PANEL_DYNABOMB_POWER 58
149 #define GAME_PANEL_PENGUINS 59
150 #define GAME_PANEL_SOKOBAN_OBJECTS 60
151 #define GAME_PANEL_SOKOBAN_FIELDS 61
152 #define GAME_PANEL_ROBOT_WHEEL 62
153 #define GAME_PANEL_CONVEYOR_BELT_1 63
154 #define GAME_PANEL_CONVEYOR_BELT_2 64
155 #define GAME_PANEL_CONVEYOR_BELT_3 65
156 #define GAME_PANEL_CONVEYOR_BELT_4 66
157 #define GAME_PANEL_CONVEYOR_BELT_1_SWITCH 67
158 #define GAME_PANEL_CONVEYOR_BELT_2_SWITCH 68
159 #define GAME_PANEL_CONVEYOR_BELT_3_SWITCH 69
160 #define GAME_PANEL_CONVEYOR_BELT_4_SWITCH 70
161 #define GAME_PANEL_MAGIC_WALL 71
162 #define GAME_PANEL_MAGIC_WALL_TIME 72
163 #define GAME_PANEL_GRAVITY_STATE 73
164 #define GAME_PANEL_GRAPHIC_1 74
165 #define GAME_PANEL_GRAPHIC_2 75
166 #define GAME_PANEL_GRAPHIC_3 76
167 #define GAME_PANEL_GRAPHIC_4 77
168 #define GAME_PANEL_GRAPHIC_5 78
169 #define GAME_PANEL_GRAPHIC_6 79
170 #define GAME_PANEL_GRAPHIC_7 80
171 #define GAME_PANEL_GRAPHIC_8 81
172 #define GAME_PANEL_ELEMENT_1 82
173 #define GAME_PANEL_ELEMENT_2 83
174 #define GAME_PANEL_ELEMENT_3 84
175 #define GAME_PANEL_ELEMENT_4 85
176 #define GAME_PANEL_ELEMENT_5 86
177 #define GAME_PANEL_ELEMENT_6 87
178 #define GAME_PANEL_ELEMENT_7 88
179 #define GAME_PANEL_ELEMENT_8 89
180 #define GAME_PANEL_ELEMENT_COUNT_1 90
181 #define GAME_PANEL_ELEMENT_COUNT_2 91
182 #define GAME_PANEL_ELEMENT_COUNT_3 92
183 #define GAME_PANEL_ELEMENT_COUNT_4 93
184 #define GAME_PANEL_ELEMENT_COUNT_5 94
185 #define GAME_PANEL_ELEMENT_COUNT_6 95
186 #define GAME_PANEL_ELEMENT_COUNT_7 96
187 #define GAME_PANEL_ELEMENT_COUNT_8 97
188 #define GAME_PANEL_CE_SCORE_1 98
189 #define GAME_PANEL_CE_SCORE_2 99
190 #define GAME_PANEL_CE_SCORE_3 100
191 #define GAME_PANEL_CE_SCORE_4 101
192 #define GAME_PANEL_CE_SCORE_5 102
193 #define GAME_PANEL_CE_SCORE_6 103
194 #define GAME_PANEL_CE_SCORE_7 104
195 #define GAME_PANEL_CE_SCORE_8 105
196 #define GAME_PANEL_CE_SCORE_1_ELEMENT 106
197 #define GAME_PANEL_CE_SCORE_2_ELEMENT 107
198 #define GAME_PANEL_CE_SCORE_3_ELEMENT 108
199 #define GAME_PANEL_CE_SCORE_4_ELEMENT 109
200 #define GAME_PANEL_CE_SCORE_5_ELEMENT 110
201 #define GAME_PANEL_CE_SCORE_6_ELEMENT 111
202 #define GAME_PANEL_CE_SCORE_7_ELEMENT 112
203 #define GAME_PANEL_CE_SCORE_8_ELEMENT 113
204 #define GAME_PANEL_PLAYER_NAME 114
205 #define GAME_PANEL_LEVEL_NAME 115
206 #define GAME_PANEL_LEVEL_AUTHOR 116
208 #define NUM_GAME_PANEL_CONTROLS 117
210 struct GamePanelOrderInfo
216 static struct GamePanelOrderInfo game_panel_order[NUM_GAME_PANEL_CONTROLS];
218 struct GamePanelControlInfo
222 struct TextPosInfo *pos;
225 int graphic, graphic_active;
227 int value, last_value;
228 int frame, last_frame;
233 static struct GamePanelControlInfo game_panel_controls[] =
236 GAME_PANEL_LEVEL_NUMBER,
237 &game.panel.level_number,
246 GAME_PANEL_INVENTORY_COUNT,
247 &game.panel.inventory_count,
251 GAME_PANEL_INVENTORY_FIRST_1,
252 &game.panel.inventory_first[0],
256 GAME_PANEL_INVENTORY_FIRST_2,
257 &game.panel.inventory_first[1],
261 GAME_PANEL_INVENTORY_FIRST_3,
262 &game.panel.inventory_first[2],
266 GAME_PANEL_INVENTORY_FIRST_4,
267 &game.panel.inventory_first[3],
271 GAME_PANEL_INVENTORY_FIRST_5,
272 &game.panel.inventory_first[4],
276 GAME_PANEL_INVENTORY_FIRST_6,
277 &game.panel.inventory_first[5],
281 GAME_PANEL_INVENTORY_FIRST_7,
282 &game.panel.inventory_first[6],
286 GAME_PANEL_INVENTORY_FIRST_8,
287 &game.panel.inventory_first[7],
291 GAME_PANEL_INVENTORY_LAST_1,
292 &game.panel.inventory_last[0],
296 GAME_PANEL_INVENTORY_LAST_2,
297 &game.panel.inventory_last[1],
301 GAME_PANEL_INVENTORY_LAST_3,
302 &game.panel.inventory_last[2],
306 GAME_PANEL_INVENTORY_LAST_4,
307 &game.panel.inventory_last[3],
311 GAME_PANEL_INVENTORY_LAST_5,
312 &game.panel.inventory_last[4],
316 GAME_PANEL_INVENTORY_LAST_6,
317 &game.panel.inventory_last[5],
321 GAME_PANEL_INVENTORY_LAST_7,
322 &game.panel.inventory_last[6],
326 GAME_PANEL_INVENTORY_LAST_8,
327 &game.panel.inventory_last[7],
371 GAME_PANEL_KEY_WHITE,
372 &game.panel.key_white,
376 GAME_PANEL_KEY_WHITE_COUNT,
377 &game.panel.key_white_count,
386 GAME_PANEL_HIGHSCORE,
387 &game.panel.highscore,
411 GAME_PANEL_TIME_ANIM,
412 &game.panel.time_anim,
415 IMG_GFX_GAME_PANEL_TIME_ANIM,
416 IMG_GFX_GAME_PANEL_TIME_ANIM_ACTIVE
424 GAME_PANEL_HEALTH_ANIM,
425 &game.panel.health_anim,
428 IMG_GFX_GAME_PANEL_HEALTH_ANIM,
429 IMG_GFX_GAME_PANEL_HEALTH_ANIM_ACTIVE
437 GAME_PANEL_SHIELD_NORMAL,
438 &game.panel.shield_normal,
442 GAME_PANEL_SHIELD_NORMAL_TIME,
443 &game.panel.shield_normal_time,
447 GAME_PANEL_SHIELD_DEADLY,
448 &game.panel.shield_deadly,
452 GAME_PANEL_SHIELD_DEADLY_TIME,
453 &game.panel.shield_deadly_time,
462 GAME_PANEL_EMC_MAGIC_BALL,
463 &game.panel.emc_magic_ball,
467 GAME_PANEL_EMC_MAGIC_BALL_SWITCH,
468 &game.panel.emc_magic_ball_switch,
472 GAME_PANEL_LIGHT_SWITCH,
473 &game.panel.light_switch,
477 GAME_PANEL_LIGHT_SWITCH_TIME,
478 &game.panel.light_switch_time,
482 GAME_PANEL_TIMEGATE_SWITCH,
483 &game.panel.timegate_switch,
487 GAME_PANEL_TIMEGATE_SWITCH_TIME,
488 &game.panel.timegate_switch_time,
492 GAME_PANEL_SWITCHGATE_SWITCH,
493 &game.panel.switchgate_switch,
497 GAME_PANEL_EMC_LENSES,
498 &game.panel.emc_lenses,
502 GAME_PANEL_EMC_LENSES_TIME,
503 &game.panel.emc_lenses_time,
507 GAME_PANEL_EMC_MAGNIFIER,
508 &game.panel.emc_magnifier,
512 GAME_PANEL_EMC_MAGNIFIER_TIME,
513 &game.panel.emc_magnifier_time,
517 GAME_PANEL_BALLOON_SWITCH,
518 &game.panel.balloon_switch,
522 GAME_PANEL_DYNABOMB_NUMBER,
523 &game.panel.dynabomb_number,
527 GAME_PANEL_DYNABOMB_SIZE,
528 &game.panel.dynabomb_size,
532 GAME_PANEL_DYNABOMB_POWER,
533 &game.panel.dynabomb_power,
538 &game.panel.penguins,
542 GAME_PANEL_SOKOBAN_OBJECTS,
543 &game.panel.sokoban_objects,
547 GAME_PANEL_SOKOBAN_FIELDS,
548 &game.panel.sokoban_fields,
552 GAME_PANEL_ROBOT_WHEEL,
553 &game.panel.robot_wheel,
557 GAME_PANEL_CONVEYOR_BELT_1,
558 &game.panel.conveyor_belt[0],
562 GAME_PANEL_CONVEYOR_BELT_2,
563 &game.panel.conveyor_belt[1],
567 GAME_PANEL_CONVEYOR_BELT_3,
568 &game.panel.conveyor_belt[2],
572 GAME_PANEL_CONVEYOR_BELT_4,
573 &game.panel.conveyor_belt[3],
577 GAME_PANEL_CONVEYOR_BELT_1_SWITCH,
578 &game.panel.conveyor_belt_switch[0],
582 GAME_PANEL_CONVEYOR_BELT_2_SWITCH,
583 &game.panel.conveyor_belt_switch[1],
587 GAME_PANEL_CONVEYOR_BELT_3_SWITCH,
588 &game.panel.conveyor_belt_switch[2],
592 GAME_PANEL_CONVEYOR_BELT_4_SWITCH,
593 &game.panel.conveyor_belt_switch[3],
597 GAME_PANEL_MAGIC_WALL,
598 &game.panel.magic_wall,
602 GAME_PANEL_MAGIC_WALL_TIME,
603 &game.panel.magic_wall_time,
607 GAME_PANEL_GRAVITY_STATE,
608 &game.panel.gravity_state,
612 GAME_PANEL_GRAPHIC_1,
613 &game.panel.graphic[0],
617 GAME_PANEL_GRAPHIC_2,
618 &game.panel.graphic[1],
622 GAME_PANEL_GRAPHIC_3,
623 &game.panel.graphic[2],
627 GAME_PANEL_GRAPHIC_4,
628 &game.panel.graphic[3],
632 GAME_PANEL_GRAPHIC_5,
633 &game.panel.graphic[4],
637 GAME_PANEL_GRAPHIC_6,
638 &game.panel.graphic[5],
642 GAME_PANEL_GRAPHIC_7,
643 &game.panel.graphic[6],
647 GAME_PANEL_GRAPHIC_8,
648 &game.panel.graphic[7],
652 GAME_PANEL_ELEMENT_1,
653 &game.panel.element[0],
657 GAME_PANEL_ELEMENT_2,
658 &game.panel.element[1],
662 GAME_PANEL_ELEMENT_3,
663 &game.panel.element[2],
667 GAME_PANEL_ELEMENT_4,
668 &game.panel.element[3],
672 GAME_PANEL_ELEMENT_5,
673 &game.panel.element[4],
677 GAME_PANEL_ELEMENT_6,
678 &game.panel.element[5],
682 GAME_PANEL_ELEMENT_7,
683 &game.panel.element[6],
687 GAME_PANEL_ELEMENT_8,
688 &game.panel.element[7],
692 GAME_PANEL_ELEMENT_COUNT_1,
693 &game.panel.element_count[0],
697 GAME_PANEL_ELEMENT_COUNT_2,
698 &game.panel.element_count[1],
702 GAME_PANEL_ELEMENT_COUNT_3,
703 &game.panel.element_count[2],
707 GAME_PANEL_ELEMENT_COUNT_4,
708 &game.panel.element_count[3],
712 GAME_PANEL_ELEMENT_COUNT_5,
713 &game.panel.element_count[4],
717 GAME_PANEL_ELEMENT_COUNT_6,
718 &game.panel.element_count[5],
722 GAME_PANEL_ELEMENT_COUNT_7,
723 &game.panel.element_count[6],
727 GAME_PANEL_ELEMENT_COUNT_8,
728 &game.panel.element_count[7],
732 GAME_PANEL_CE_SCORE_1,
733 &game.panel.ce_score[0],
737 GAME_PANEL_CE_SCORE_2,
738 &game.panel.ce_score[1],
742 GAME_PANEL_CE_SCORE_3,
743 &game.panel.ce_score[2],
747 GAME_PANEL_CE_SCORE_4,
748 &game.panel.ce_score[3],
752 GAME_PANEL_CE_SCORE_5,
753 &game.panel.ce_score[4],
757 GAME_PANEL_CE_SCORE_6,
758 &game.panel.ce_score[5],
762 GAME_PANEL_CE_SCORE_7,
763 &game.panel.ce_score[6],
767 GAME_PANEL_CE_SCORE_8,
768 &game.panel.ce_score[7],
772 GAME_PANEL_CE_SCORE_1_ELEMENT,
773 &game.panel.ce_score_element[0],
777 GAME_PANEL_CE_SCORE_2_ELEMENT,
778 &game.panel.ce_score_element[1],
782 GAME_PANEL_CE_SCORE_3_ELEMENT,
783 &game.panel.ce_score_element[2],
787 GAME_PANEL_CE_SCORE_4_ELEMENT,
788 &game.panel.ce_score_element[3],
792 GAME_PANEL_CE_SCORE_5_ELEMENT,
793 &game.panel.ce_score_element[4],
797 GAME_PANEL_CE_SCORE_6_ELEMENT,
798 &game.panel.ce_score_element[5],
802 GAME_PANEL_CE_SCORE_7_ELEMENT,
803 &game.panel.ce_score_element[6],
807 GAME_PANEL_CE_SCORE_8_ELEMENT,
808 &game.panel.ce_score_element[7],
812 GAME_PANEL_PLAYER_NAME,
813 &game.panel.player_name,
817 GAME_PANEL_LEVEL_NAME,
818 &game.panel.level_name,
822 GAME_PANEL_LEVEL_AUTHOR,
823 &game.panel.level_author,
834 // values for delayed check of falling and moving elements and for collision
835 #define CHECK_DELAY_MOVING 3
836 #define CHECK_DELAY_FALLING CHECK_DELAY_MOVING
837 #define CHECK_DELAY_COLLISION 2
838 #define CHECK_DELAY_IMPACT CHECK_DELAY_COLLISION
840 // values for initial player move delay (initial delay counter value)
841 #define INITIAL_MOVE_DELAY_OFF -1
842 #define INITIAL_MOVE_DELAY_ON 0
844 // values for player movement speed (which is in fact a delay value)
845 #define MOVE_DELAY_MIN_SPEED 32
846 #define MOVE_DELAY_NORMAL_SPEED 8
847 #define MOVE_DELAY_HIGH_SPEED 4
848 #define MOVE_DELAY_MAX_SPEED 1
850 #define DOUBLE_MOVE_DELAY(x) (x = (x < MOVE_DELAY_MIN_SPEED ? x * 2 : x))
851 #define HALVE_MOVE_DELAY(x) (x = (x > MOVE_DELAY_MAX_SPEED ? x / 2 : x))
853 #define DOUBLE_PLAYER_SPEED(p) (HALVE_MOVE_DELAY( (p)->move_delay_value))
854 #define HALVE_PLAYER_SPEED(p) (DOUBLE_MOVE_DELAY((p)->move_delay_value))
856 // values for scroll positions
857 #define SCROLL_POSITION_X(x) ((x) < SBX_Left + MIDPOSX ? SBX_Left : \
858 (x) > SBX_Right + MIDPOSX ? SBX_Right :\
860 #define SCROLL_POSITION_Y(y) ((y) < SBY_Upper + MIDPOSY ? SBY_Upper :\
861 (y) > SBY_Lower + MIDPOSY ? SBY_Lower :\
864 // values for other actions
865 #define MOVE_STEPSIZE_NORMAL (TILEX / MOVE_DELAY_NORMAL_SPEED)
866 #define MOVE_STEPSIZE_MIN (1)
867 #define MOVE_STEPSIZE_MAX (TILEX)
869 #define GET_DX_FROM_DIR(d) ((d) == MV_LEFT ? -1 : (d) == MV_RIGHT ? 1 : 0)
870 #define GET_DY_FROM_DIR(d) ((d) == MV_UP ? -1 : (d) == MV_DOWN ? 1 : 0)
872 #define INIT_GFX_RANDOM() (GetSimpleRandom(1000000))
874 #define GET_NEW_PUSH_DELAY(e) ( (element_info[e].push_delay_fixed) + \
875 RND(element_info[e].push_delay_random))
876 #define GET_NEW_DROP_DELAY(e) ( (element_info[e].drop_delay_fixed) + \
877 RND(element_info[e].drop_delay_random))
878 #define GET_NEW_MOVE_DELAY(e) ( (element_info[e].move_delay_fixed) + \
879 RND(element_info[e].move_delay_random))
880 #define GET_MAX_MOVE_DELAY(e) ( (element_info[e].move_delay_fixed) + \
881 (element_info[e].move_delay_random))
882 #define GET_NEW_STEP_DELAY(e) ( (element_info[e].step_delay_fixed) + \
883 RND(element_info[e].step_delay_random))
884 #define GET_MAX_STEP_DELAY(e) ( (element_info[e].step_delay_fixed) + \
885 (element_info[e].step_delay_random))
886 #define GET_NEW_CE_VALUE(e) ( (element_info[e].ce_value_fixed_initial) +\
887 RND(element_info[e].ce_value_random_initial))
888 #define GET_CE_SCORE(e) ( (element_info[e].collect_score))
889 #define GET_CHANGE_DELAY(c) ( ((c)->delay_fixed * (c)->delay_frames) + \
890 RND((c)->delay_random * (c)->delay_frames))
891 #define GET_CE_DELAY_VALUE(c) ( ((c)->delay_fixed) + \
892 RND((c)->delay_random))
895 #define GET_VALID_RUNTIME_ELEMENT(e) \
896 ((e) >= NUM_RUNTIME_ELEMENTS ? EL_UNKNOWN : (e))
898 #define RESOLVED_REFERENCE_ELEMENT(be, e) \
899 ((be) + (e) - EL_SELF < EL_CUSTOM_START ? EL_CUSTOM_START : \
900 (be) + (e) - EL_SELF > EL_CUSTOM_END ? EL_CUSTOM_END : \
901 (be) + (e) - EL_SELF)
903 #define GET_PLAYER_FROM_BITS(p) \
904 (EL_PLAYER_1 + ((p) != PLAYER_BITS_ANY ? log_2(p) : 0))
906 #define GET_TARGET_ELEMENT(be, e, ch, cv, cs) \
907 ((e) == EL_TRIGGER_PLAYER ? (ch)->actual_trigger_player : \
908 (e) == EL_TRIGGER_ELEMENT ? (ch)->actual_trigger_element : \
909 (e) == EL_TRIGGER_CE_VALUE ? (ch)->actual_trigger_ce_value : \
910 (e) == EL_TRIGGER_CE_SCORE ? (ch)->actual_trigger_ce_score : \
911 (e) == EL_CURRENT_CE_VALUE ? (cv) : \
912 (e) == EL_CURRENT_CE_SCORE ? (cs) : \
913 (e) >= EL_PREV_CE_8 && (e) <= EL_NEXT_CE_8 ? \
914 RESOLVED_REFERENCE_ELEMENT(be, e) : \
917 #define CAN_GROW_INTO(e) \
918 ((e) == EL_SAND || (IS_DIGGABLE(e) && level.grow_into_diggable))
920 #define ELEMENT_CAN_ENTER_FIELD_BASE_X(x, y, condition) \
921 (IN_LEV_FIELD(x, y) && (IS_FREE(x, y) || \
924 #define ELEMENT_CAN_ENTER_FIELD_BASE_2(e, x, y, condition) \
925 (IN_LEV_FIELD(x, y) && (IS_FREE(x, y) || \
926 (CAN_MOVE_INTO_ACID(e) && \
927 Tile[x][y] == EL_ACID) || \
930 #define ELEMENT_CAN_ENTER_FIELD_BASE_3(e, x, y, condition) \
931 (IN_LEV_FIELD(x, y) && (IS_FREE_OR_PLAYER(x, y) || \
932 (CAN_MOVE_INTO_ACID(e) && \
933 Tile[x][y] == EL_ACID) || \
936 #define ELEMENT_CAN_ENTER_FIELD_BASE_4(e, x, y, condition) \
937 (IN_LEV_FIELD(x, y) && (IS_FREE(x, y) || \
939 (CAN_MOVE_INTO_ACID(e) && \
940 Tile[x][y] == EL_ACID) || \
941 (DONT_COLLIDE_WITH(e) && \
943 !PLAYER_ENEMY_PROTECTED(x, y))))
945 #define ELEMENT_CAN_ENTER_FIELD(e, x, y) \
946 ELEMENT_CAN_ENTER_FIELD_BASE_4(e, x, y, 0)
948 #define SATELLITE_CAN_ENTER_FIELD(x, y) \
949 ELEMENT_CAN_ENTER_FIELD_BASE_2(EL_SATELLITE, x, y, 0)
951 #define ANDROID_CAN_ENTER_FIELD(e, x, y) \
952 ELEMENT_CAN_ENTER_FIELD_BASE_2(e, x, y, Tile[x][y] == EL_EMC_PLANT)
954 #define ANDROID_CAN_CLONE_FIELD(x, y) \
955 (IN_LEV_FIELD(x, y) && (CAN_BE_CLONED_BY_ANDROID(Tile[x][y]) || \
956 CAN_BE_CLONED_BY_ANDROID(EL_TRIGGER_ELEMENT)))
958 #define ENEMY_CAN_ENTER_FIELD(e, x, y) \
959 ELEMENT_CAN_ENTER_FIELD_BASE_2(e, x, y, 0)
961 #define YAMYAM_CAN_ENTER_FIELD(e, x, y) \
962 ELEMENT_CAN_ENTER_FIELD_BASE_3(e, x, y, Tile[x][y] == EL_DIAMOND)
964 #define DARK_YAMYAM_CAN_ENTER_FIELD(e, x, y) \
965 ELEMENT_CAN_ENTER_FIELD_BASE_3(e, x,y, IS_FOOD_DARK_YAMYAM(Tile[x][y]))
967 #define PACMAN_CAN_ENTER_FIELD(e, x, y) \
968 ELEMENT_CAN_ENTER_FIELD_BASE_3(e, x, y, IS_AMOEBOID(Tile[x][y]))
970 #define PIG_CAN_ENTER_FIELD(e, x, y) \
971 ELEMENT_CAN_ENTER_FIELD_BASE_2(e, x, y, IS_FOOD_PIG(Tile[x][y]))
973 #define PENGUIN_CAN_ENTER_FIELD(e, x, y) \
974 ELEMENT_CAN_ENTER_FIELD_BASE_2(e, x, y, (Tile[x][y] == EL_EXIT_OPEN || \
975 Tile[x][y] == EL_EM_EXIT_OPEN || \
976 Tile[x][y] == EL_STEEL_EXIT_OPEN || \
977 Tile[x][y] == EL_EM_STEEL_EXIT_OPEN || \
978 IS_FOOD_PENGUIN(Tile[x][y])))
979 #define DRAGON_CAN_ENTER_FIELD(e, x, y) \
980 ELEMENT_CAN_ENTER_FIELD_BASE_2(e, x, y, 0)
982 #define MOLE_CAN_ENTER_FIELD(e, x, y, condition) \
983 ELEMENT_CAN_ENTER_FIELD_BASE_2(e, x, y, (condition))
985 #define SPRING_CAN_ENTER_FIELD(e, x, y) \
986 ELEMENT_CAN_ENTER_FIELD_BASE_2(e, x, y, 0)
988 #define SPRING_CAN_BUMP_FROM_FIELD(x, y) \
989 (IN_LEV_FIELD(x, y) && (Tile[x][y] == EL_EMC_SPRING_BUMPER || \
990 Tile[x][y] == EL_EMC_SPRING_BUMPER_ACTIVE))
992 #define MOVE_ENTER_EL(e) (element_info[e].move_enter_element)
994 #define CE_ENTER_FIELD_COND(e, x, y) \
995 (!IS_PLAYER(x, y) && \
996 IS_EQUAL_OR_IN_GROUP(Tile[x][y], MOVE_ENTER_EL(e)))
998 #define CUSTOM_ELEMENT_CAN_ENTER_FIELD(e, x, y) \
999 ELEMENT_CAN_ENTER_FIELD_BASE_4(e, x, y, CE_ENTER_FIELD_COND(e, x, y))
1001 #define IN_LEV_FIELD_AND_IS_FREE(x, y) (IN_LEV_FIELD(x, y) && IS_FREE(x, y))
1002 #define IN_LEV_FIELD_AND_NOT_FREE(x, y) (IN_LEV_FIELD(x, y) && !IS_FREE(x, y))
1004 #define ACCESS_FROM(e, d) (element_info[e].access_direction &(d))
1005 #define IS_WALKABLE_FROM(e, d) (IS_WALKABLE(e) && ACCESS_FROM(e, d))
1006 #define IS_PASSABLE_FROM(e, d) (IS_PASSABLE(e) && ACCESS_FROM(e, d))
1007 #define IS_ACCESSIBLE_FROM(e, d) (IS_ACCESSIBLE(e) && ACCESS_FROM(e, d))
1009 #define MM_HEALTH(x) (MIN(MAX(0, MAX_HEALTH - (x)), MAX_HEALTH))
1011 // game button identifiers
1012 #define GAME_CTRL_ID_STOP 0
1013 #define GAME_CTRL_ID_PAUSE 1
1014 #define GAME_CTRL_ID_PLAY 2
1015 #define GAME_CTRL_ID_UNDO 3
1016 #define GAME_CTRL_ID_REDO 4
1017 #define GAME_CTRL_ID_SAVE 5
1018 #define GAME_CTRL_ID_PAUSE2 6
1019 #define GAME_CTRL_ID_LOAD 7
1020 #define GAME_CTRL_ID_PANEL_STOP 8
1021 #define GAME_CTRL_ID_PANEL_PAUSE 9
1022 #define GAME_CTRL_ID_PANEL_PLAY 10
1023 #define GAME_CTRL_ID_TOUCH_STOP 11
1024 #define GAME_CTRL_ID_TOUCH_PAUSE 12
1025 #define SOUND_CTRL_ID_MUSIC 13
1026 #define SOUND_CTRL_ID_LOOPS 14
1027 #define SOUND_CTRL_ID_SIMPLE 15
1028 #define SOUND_CTRL_ID_PANEL_MUSIC 16
1029 #define SOUND_CTRL_ID_PANEL_LOOPS 17
1030 #define SOUND_CTRL_ID_PANEL_SIMPLE 18
1032 #define NUM_GAME_BUTTONS 19
1035 // forward declaration for internal use
1037 static void CreateField(int, int, int);
1039 static void ResetGfxAnimation(int, int);
1041 static void SetPlayerWaiting(struct PlayerInfo *, boolean);
1042 static void AdvanceFrameAndPlayerCounters(int);
1044 static boolean MovePlayerOneStep(struct PlayerInfo *, int, int, int, int);
1045 static boolean MovePlayer(struct PlayerInfo *, int, int);
1046 static void ScrollPlayer(struct PlayerInfo *, int);
1047 static void ScrollScreen(struct PlayerInfo *, int);
1049 static int DigField(struct PlayerInfo *, int, int, int, int, int, int, int);
1050 static boolean DigFieldByCE(int, int, int);
1051 static boolean SnapField(struct PlayerInfo *, int, int);
1052 static boolean DropElement(struct PlayerInfo *);
1054 static void InitBeltMovement(void);
1055 static void CloseAllOpenTimegates(void);
1056 static void CheckGravityMovement(struct PlayerInfo *);
1057 static void CheckGravityMovementWhenNotMoving(struct PlayerInfo *);
1058 static void KillPlayerUnlessEnemyProtected(int, int);
1059 static void KillPlayerUnlessExplosionProtected(int, int);
1061 static void TestIfPlayerTouchesCustomElement(int, int);
1062 static void TestIfElementTouchesCustomElement(int, int);
1063 static void TestIfElementHitsCustomElement(int, int, int);
1065 static void HandleElementChange(int, int, int);
1066 static void ExecuteCustomElementAction(int, int, int, int);
1067 static boolean ChangeElement(int, int, int, int);
1069 static boolean CheckTriggeredElementChangeExt(int, int, int, int, int,int,int);
1070 #define CheckTriggeredElementChange(x, y, e, ev) \
1071 CheckTriggeredElementChangeExt(x,y,e,ev, CH_PLAYER_ANY,CH_SIDE_ANY, -1)
1072 #define CheckTriggeredElementChangeByPlayer(x, y, e, ev, p, s) \
1073 CheckTriggeredElementChangeExt(x, y, e, ev, p, s, -1)
1074 #define CheckTriggeredElementChangeBySide(x, y, e, ev, s) \
1075 CheckTriggeredElementChangeExt(x, y, e, ev, CH_PLAYER_ANY, s, -1)
1076 #define CheckTriggeredElementChangeByPage(x, y, e, ev, p) \
1077 CheckTriggeredElementChangeExt(x,y,e,ev, CH_PLAYER_ANY, CH_SIDE_ANY, p)
1078 #define CheckTriggeredElementChangeByMouse(x, y, e, ev, s) \
1079 CheckTriggeredElementChangeExt(x, y, e, ev, CH_PLAYER_ANY, s, -1)
1081 static boolean CheckElementChangeExt(int, int, int, int, int, int, int);
1082 #define CheckElementChange(x, y, e, te, ev) \
1083 CheckElementChangeExt(x, y, e, te, ev, CH_PLAYER_ANY, CH_SIDE_ANY)
1084 #define CheckElementChangeByPlayer(x, y, e, ev, p, s) \
1085 CheckElementChangeExt(x, y, e, EL_EMPTY, ev, p, s)
1086 #define CheckElementChangeBySide(x, y, e, te, ev, s) \
1087 CheckElementChangeExt(x, y, e, te, ev, CH_PLAYER_ANY, s)
1088 #define CheckElementChangeByMouse(x, y, e, ev, s) \
1089 CheckElementChangeExt(x, y, e, EL_UNDEFINED, ev, CH_PLAYER_ANY, s)
1091 static void PlayLevelSound(int, int, int);
1092 static void PlayLevelSoundNearest(int, int, int);
1093 static void PlayLevelSoundAction(int, int, int);
1094 static void PlayLevelSoundElementAction(int, int, int, int);
1095 static void PlayLevelSoundElementActionIfLoop(int, int, int, int);
1096 static void PlayLevelSoundActionIfLoop(int, int, int);
1097 static void StopLevelSoundActionIfLoop(int, int, int);
1098 static void PlayLevelMusic(void);
1099 static void FadeLevelSoundsAndMusic(void);
1101 static void HandleGameButtons(struct GadgetInfo *);
1103 int AmoebaNeighbourNr(int, int);
1104 void AmoebaToDiamond(int, int);
1105 void ContinueMoving(int, int);
1106 void Bang(int, int);
1107 void InitMovDir(int, int);
1108 void InitAmoebaNr(int, int);
1109 int NewHighScore(int);
1111 void TestIfGoodThingHitsBadThing(int, int, int);
1112 void TestIfBadThingHitsGoodThing(int, int, int);
1113 void TestIfPlayerTouchesBadThing(int, int);
1114 void TestIfPlayerRunsIntoBadThing(int, int, int);
1115 void TestIfBadThingTouchesPlayer(int, int);
1116 void TestIfBadThingRunsIntoPlayer(int, int, int);
1117 void TestIfFriendTouchesBadThing(int, int);
1118 void TestIfBadThingTouchesFriend(int, int);
1119 void TestIfBadThingTouchesOtherBadThing(int, int);
1120 void TestIfGoodThingGetsHitByBadThing(int, int, int);
1122 void KillPlayer(struct PlayerInfo *);
1123 void BuryPlayer(struct PlayerInfo *);
1124 void RemovePlayer(struct PlayerInfo *);
1125 void ExitPlayer(struct PlayerInfo *);
1127 static int getInvisibleActiveFromInvisibleElement(int);
1128 static int getInvisibleFromInvisibleActiveElement(int);
1130 static void TestFieldAfterSnapping(int, int, int, int, int);
1132 static struct GadgetInfo *game_gadget[NUM_GAME_BUTTONS];
1134 // for detection of endless loops, caused by custom element programming
1135 // (using maximal playfield width x 10 is just a rough approximation)
1136 #define MAX_ELEMENT_CHANGE_RECURSION_DEPTH (MAX_PLAYFIELD_WIDTH * 10)
1138 #define RECURSION_LOOP_DETECTION_START(e, rc) \
1140 if (recursion_loop_detected) \
1143 if (recursion_loop_depth > MAX_ELEMENT_CHANGE_RECURSION_DEPTH) \
1145 recursion_loop_detected = TRUE; \
1146 recursion_loop_element = (e); \
1149 recursion_loop_depth++; \
1152 #define RECURSION_LOOP_DETECTION_END() \
1154 recursion_loop_depth--; \
1157 static int recursion_loop_depth;
1158 static boolean recursion_loop_detected;
1159 static boolean recursion_loop_element;
1161 static int map_player_action[MAX_PLAYERS];
1164 // ----------------------------------------------------------------------------
1165 // definition of elements that automatically change to other elements after
1166 // a specified time, eventually calling a function when changing
1167 // ----------------------------------------------------------------------------
1169 // forward declaration for changer functions
1170 static void InitBuggyBase(int, int);
1171 static void WarnBuggyBase(int, int);
1173 static void InitTrap(int, int);
1174 static void ActivateTrap(int, int);
1175 static void ChangeActiveTrap(int, int);
1177 static void InitRobotWheel(int, int);
1178 static void RunRobotWheel(int, int);
1179 static void StopRobotWheel(int, int);
1181 static void InitTimegateWheel(int, int);
1182 static void RunTimegateWheel(int, int);
1184 static void InitMagicBallDelay(int, int);
1185 static void ActivateMagicBall(int, int);
1187 struct ChangingElementInfo
1192 void (*pre_change_function)(int x, int y);
1193 void (*change_function)(int x, int y);
1194 void (*post_change_function)(int x, int y);
1197 static struct ChangingElementInfo change_delay_list[] =
1232 EL_STEEL_EXIT_OPENING,
1240 EL_STEEL_EXIT_CLOSING,
1241 EL_STEEL_EXIT_CLOSED,
1264 EL_EM_STEEL_EXIT_OPENING,
1265 EL_EM_STEEL_EXIT_OPEN,
1272 EL_EM_STEEL_EXIT_CLOSING,
1296 EL_SWITCHGATE_OPENING,
1304 EL_SWITCHGATE_CLOSING,
1305 EL_SWITCHGATE_CLOSED,
1312 EL_TIMEGATE_OPENING,
1320 EL_TIMEGATE_CLOSING,
1329 EL_ACID_SPLASH_LEFT,
1337 EL_ACID_SPLASH_RIGHT,
1346 EL_SP_BUGGY_BASE_ACTIVATING,
1353 EL_SP_BUGGY_BASE_ACTIVATING,
1354 EL_SP_BUGGY_BASE_ACTIVE,
1361 EL_SP_BUGGY_BASE_ACTIVE,
1385 EL_ROBOT_WHEEL_ACTIVE,
1393 EL_TIMEGATE_SWITCH_ACTIVE,
1401 EL_DC_TIMEGATE_SWITCH_ACTIVE,
1402 EL_DC_TIMEGATE_SWITCH,
1409 EL_EMC_MAGIC_BALL_ACTIVE,
1410 EL_EMC_MAGIC_BALL_ACTIVE,
1417 EL_EMC_SPRING_BUMPER_ACTIVE,
1418 EL_EMC_SPRING_BUMPER,
1425 EL_DIAGONAL_SHRINKING,
1433 EL_DIAGONAL_GROWING,
1454 int push_delay_fixed, push_delay_random;
1458 { EL_SPRING, 0, 0 },
1459 { EL_BALLOON, 0, 0 },
1461 { EL_SOKOBAN_OBJECT, 2, 0 },
1462 { EL_SOKOBAN_FIELD_FULL, 2, 0 },
1463 { EL_SATELLITE, 2, 0 },
1464 { EL_SP_DISK_YELLOW, 2, 0 },
1466 { EL_UNDEFINED, 0, 0 },
1474 move_stepsize_list[] =
1476 { EL_AMOEBA_DROP, 2 },
1477 { EL_AMOEBA_DROPPING, 2 },
1478 { EL_QUICKSAND_FILLING, 1 },
1479 { EL_QUICKSAND_EMPTYING, 1 },
1480 { EL_QUICKSAND_FAST_FILLING, 2 },
1481 { EL_QUICKSAND_FAST_EMPTYING, 2 },
1482 { EL_MAGIC_WALL_FILLING, 2 },
1483 { EL_MAGIC_WALL_EMPTYING, 2 },
1484 { EL_BD_MAGIC_WALL_FILLING, 2 },
1485 { EL_BD_MAGIC_WALL_EMPTYING, 2 },
1486 { EL_DC_MAGIC_WALL_FILLING, 2 },
1487 { EL_DC_MAGIC_WALL_EMPTYING, 2 },
1489 { EL_UNDEFINED, 0 },
1497 collect_count_list[] =
1500 { EL_BD_DIAMOND, 1 },
1501 { EL_EMERALD_YELLOW, 1 },
1502 { EL_EMERALD_RED, 1 },
1503 { EL_EMERALD_PURPLE, 1 },
1505 { EL_SP_INFOTRON, 1 },
1509 { EL_UNDEFINED, 0 },
1517 access_direction_list[] =
1519 { EL_TUBE_ANY, MV_LEFT | MV_RIGHT | MV_UP | MV_DOWN },
1520 { EL_TUBE_VERTICAL, MV_UP | MV_DOWN },
1521 { EL_TUBE_HORIZONTAL, MV_LEFT | MV_RIGHT },
1522 { EL_TUBE_VERTICAL_LEFT, MV_LEFT | MV_UP | MV_DOWN },
1523 { EL_TUBE_VERTICAL_RIGHT, MV_RIGHT | MV_UP | MV_DOWN },
1524 { EL_TUBE_HORIZONTAL_UP, MV_LEFT | MV_RIGHT | MV_UP },
1525 { EL_TUBE_HORIZONTAL_DOWN, MV_LEFT | MV_RIGHT | MV_DOWN },
1526 { EL_TUBE_LEFT_UP, MV_LEFT | MV_UP },
1527 { EL_TUBE_LEFT_DOWN, MV_LEFT | MV_DOWN },
1528 { EL_TUBE_RIGHT_UP, MV_RIGHT | MV_UP },
1529 { EL_TUBE_RIGHT_DOWN, MV_RIGHT | MV_DOWN },
1531 { EL_SP_PORT_LEFT, MV_RIGHT },
1532 { EL_SP_PORT_RIGHT, MV_LEFT },
1533 { EL_SP_PORT_UP, MV_DOWN },
1534 { EL_SP_PORT_DOWN, MV_UP },
1535 { EL_SP_PORT_HORIZONTAL, MV_LEFT | MV_RIGHT },
1536 { EL_SP_PORT_VERTICAL, MV_UP | MV_DOWN },
1537 { EL_SP_PORT_ANY, MV_LEFT | MV_RIGHT | MV_UP | MV_DOWN },
1538 { EL_SP_GRAVITY_PORT_LEFT, MV_RIGHT },
1539 { EL_SP_GRAVITY_PORT_RIGHT, MV_LEFT },
1540 { EL_SP_GRAVITY_PORT_UP, MV_DOWN },
1541 { EL_SP_GRAVITY_PORT_DOWN, MV_UP },
1542 { EL_SP_GRAVITY_ON_PORT_LEFT, MV_RIGHT },
1543 { EL_SP_GRAVITY_ON_PORT_RIGHT, MV_LEFT },
1544 { EL_SP_GRAVITY_ON_PORT_UP, MV_DOWN },
1545 { EL_SP_GRAVITY_ON_PORT_DOWN, MV_UP },
1546 { EL_SP_GRAVITY_OFF_PORT_LEFT, MV_RIGHT },
1547 { EL_SP_GRAVITY_OFF_PORT_RIGHT, MV_LEFT },
1548 { EL_SP_GRAVITY_OFF_PORT_UP, MV_DOWN },
1549 { EL_SP_GRAVITY_OFF_PORT_DOWN, MV_UP },
1551 { EL_UNDEFINED, MV_NONE }
1554 static boolean trigger_events[MAX_NUM_ELEMENTS][NUM_CHANGE_EVENTS];
1556 #define IS_AUTO_CHANGING(e) (element_info[e].has_change_event[CE_DELAY])
1557 #define IS_JUST_CHANGING(x, y) (ChangeDelay[x][y] != 0)
1558 #define IS_CHANGING(x, y) (IS_AUTO_CHANGING(Tile[x][y]) || \
1559 IS_JUST_CHANGING(x, y))
1561 #define CE_PAGE(e, ce) (element_info[e].event_page[ce])
1563 // static variables for playfield scan mode (scanning forward or backward)
1564 static int playfield_scan_start_x = 0;
1565 static int playfield_scan_start_y = 0;
1566 static int playfield_scan_delta_x = 1;
1567 static int playfield_scan_delta_y = 1;
1569 #define SCAN_PLAYFIELD(x, y) for ((y) = playfield_scan_start_y; \
1570 (y) >= 0 && (y) <= lev_fieldy - 1; \
1571 (y) += playfield_scan_delta_y) \
1572 for ((x) = playfield_scan_start_x; \
1573 (x) >= 0 && (x) <= lev_fieldx - 1; \
1574 (x) += playfield_scan_delta_x)
1577 void DEBUG_SetMaximumDynamite(void)
1581 for (i = 0; i < MAX_INVENTORY_SIZE; i++)
1582 if (local_player->inventory_size < MAX_INVENTORY_SIZE)
1583 local_player->inventory_element[local_player->inventory_size++] =
1588 static void InitPlayfieldScanModeVars(void)
1590 if (game.use_reverse_scan_direction)
1592 playfield_scan_start_x = lev_fieldx - 1;
1593 playfield_scan_start_y = lev_fieldy - 1;
1595 playfield_scan_delta_x = -1;
1596 playfield_scan_delta_y = -1;
1600 playfield_scan_start_x = 0;
1601 playfield_scan_start_y = 0;
1603 playfield_scan_delta_x = 1;
1604 playfield_scan_delta_y = 1;
1608 static void InitPlayfieldScanMode(int mode)
1610 game.use_reverse_scan_direction =
1611 (mode == CA_ARG_SCAN_MODE_REVERSE ? TRUE : FALSE);
1613 InitPlayfieldScanModeVars();
1616 static int get_move_delay_from_stepsize(int move_stepsize)
1619 MIN(MAX(MOVE_STEPSIZE_MIN, move_stepsize), MOVE_STEPSIZE_MAX);
1621 // make sure that stepsize value is always a power of 2
1622 move_stepsize = (1 << log_2(move_stepsize));
1624 return TILEX / move_stepsize;
1627 static void SetPlayerMoveSpeed(struct PlayerInfo *player, int move_stepsize,
1630 int player_nr = player->index_nr;
1631 int move_delay = get_move_delay_from_stepsize(move_stepsize);
1632 boolean cannot_move = (move_stepsize == STEPSIZE_NOT_MOVING ? TRUE : FALSE);
1634 // do no immediately change move delay -- the player might just be moving
1635 player->move_delay_value_next = move_delay;
1637 // information if player can move must be set separately
1638 player->cannot_move = cannot_move;
1642 player->move_delay = game.initial_move_delay[player_nr];
1643 player->move_delay_value = game.initial_move_delay_value[player_nr];
1645 player->move_delay_value_next = -1;
1647 player->move_delay_reset_counter = 0;
1651 void GetPlayerConfig(void)
1653 GameFrameDelay = setup.game_frame_delay;
1655 if (!audio.sound_available)
1656 setup.sound_simple = FALSE;
1658 if (!audio.loops_available)
1659 setup.sound_loops = FALSE;
1661 if (!audio.music_available)
1662 setup.sound_music = FALSE;
1664 if (!video.fullscreen_available)
1665 setup.fullscreen = FALSE;
1667 setup.sound = (setup.sound_simple || setup.sound_loops || setup.sound_music);
1669 SetAudioMode(setup.sound);
1672 int GetElementFromGroupElement(int element)
1674 if (IS_GROUP_ELEMENT(element))
1676 struct ElementGroupInfo *group = element_info[element].group;
1677 int last_anim_random_frame = gfx.anim_random_frame;
1680 if (group->choice_mode == ANIM_RANDOM)
1681 gfx.anim_random_frame = RND(group->num_elements_resolved);
1683 element_pos = getAnimationFrame(group->num_elements_resolved, 1,
1684 group->choice_mode, 0,
1687 if (group->choice_mode == ANIM_RANDOM)
1688 gfx.anim_random_frame = last_anim_random_frame;
1690 group->choice_pos++;
1692 element = group->element_resolved[element_pos];
1698 static void IncrementSokobanFieldsNeeded(void)
1700 if (level.sb_fields_needed)
1701 game.sokoban_fields_still_needed++;
1704 static void IncrementSokobanObjectsNeeded(void)
1706 if (level.sb_objects_needed)
1707 game.sokoban_objects_still_needed++;
1710 static void DecrementSokobanFieldsNeeded(void)
1712 if (game.sokoban_fields_still_needed > 0)
1713 game.sokoban_fields_still_needed--;
1716 static void DecrementSokobanObjectsNeeded(void)
1718 if (game.sokoban_objects_still_needed > 0)
1719 game.sokoban_objects_still_needed--;
1722 static void InitPlayerField(int x, int y, int element, boolean init_game)
1724 if (element == EL_SP_MURPHY)
1728 if (stored_player[0].present)
1730 Tile[x][y] = EL_SP_MURPHY_CLONE;
1736 stored_player[0].initial_element = element;
1737 stored_player[0].use_murphy = TRUE;
1739 if (!level.use_artwork_element[0])
1740 stored_player[0].artwork_element = EL_SP_MURPHY;
1743 Tile[x][y] = EL_PLAYER_1;
1749 struct PlayerInfo *player = &stored_player[Tile[x][y] - EL_PLAYER_1];
1750 int jx = player->jx, jy = player->jy;
1752 player->present = TRUE;
1754 player->block_last_field = (element == EL_SP_MURPHY ?
1755 level.sp_block_last_field :
1756 level.block_last_field);
1758 // ---------- initialize player's last field block delay ------------------
1760 // always start with reliable default value (no adjustment needed)
1761 player->block_delay_adjustment = 0;
1763 // special case 1: in Supaplex, Murphy blocks last field one more frame
1764 if (player->block_last_field && element == EL_SP_MURPHY)
1765 player->block_delay_adjustment = 1;
1767 // special case 2: in game engines before 3.1.1, blocking was different
1768 if (game.use_block_last_field_bug)
1769 player->block_delay_adjustment = (player->block_last_field ? -1 : 1);
1771 if (!network.enabled || player->connected_network)
1773 player->active = TRUE;
1775 // remove potentially duplicate players
1776 if (StorePlayer[jx][jy] == Tile[x][y])
1777 StorePlayer[jx][jy] = 0;
1779 StorePlayer[x][y] = Tile[x][y];
1781 #if DEBUG_INIT_PLAYER
1782 Debug("game:init:player", "- player element %d activated",
1783 player->element_nr);
1784 Debug("game:init:player", " (local player is %d and currently %s)",
1785 local_player->element_nr,
1786 local_player->active ? "active" : "not active");
1790 Tile[x][y] = EL_EMPTY;
1792 player->jx = player->last_jx = x;
1793 player->jy = player->last_jy = y;
1796 // always check if player was just killed and should be reanimated
1798 int player_nr = GET_PLAYER_NR(element);
1799 struct PlayerInfo *player = &stored_player[player_nr];
1801 if (player->active && player->killed)
1802 player->reanimated = TRUE; // if player was just killed, reanimate him
1806 static void InitField(int x, int y, boolean init_game)
1808 int element = Tile[x][y];
1817 InitPlayerField(x, y, element, init_game);
1820 case EL_SOKOBAN_FIELD_PLAYER:
1821 element = Tile[x][y] = EL_PLAYER_1;
1822 InitField(x, y, init_game);
1824 element = Tile[x][y] = EL_SOKOBAN_FIELD_EMPTY;
1825 InitField(x, y, init_game);
1828 case EL_SOKOBAN_FIELD_EMPTY:
1829 IncrementSokobanFieldsNeeded();
1832 case EL_SOKOBAN_OBJECT:
1833 IncrementSokobanObjectsNeeded();
1837 if (x < lev_fieldx-1 && Tile[x+1][y] == EL_ACID)
1838 Tile[x][y] = EL_ACID_POOL_TOPLEFT;
1839 else if (x > 0 && Tile[x-1][y] == EL_ACID)
1840 Tile[x][y] = EL_ACID_POOL_TOPRIGHT;
1841 else if (y > 0 && Tile[x][y-1] == EL_ACID_POOL_TOPLEFT)
1842 Tile[x][y] = EL_ACID_POOL_BOTTOMLEFT;
1843 else if (y > 0 && Tile[x][y-1] == EL_ACID)
1844 Tile[x][y] = EL_ACID_POOL_BOTTOM;
1845 else if (y > 0 && Tile[x][y-1] == EL_ACID_POOL_TOPRIGHT)
1846 Tile[x][y] = EL_ACID_POOL_BOTTOMRIGHT;
1855 case EL_SPACESHIP_RIGHT:
1856 case EL_SPACESHIP_UP:
1857 case EL_SPACESHIP_LEFT:
1858 case EL_SPACESHIP_DOWN:
1859 case EL_BD_BUTTERFLY:
1860 case EL_BD_BUTTERFLY_RIGHT:
1861 case EL_BD_BUTTERFLY_UP:
1862 case EL_BD_BUTTERFLY_LEFT:
1863 case EL_BD_BUTTERFLY_DOWN:
1865 case EL_BD_FIREFLY_RIGHT:
1866 case EL_BD_FIREFLY_UP:
1867 case EL_BD_FIREFLY_LEFT:
1868 case EL_BD_FIREFLY_DOWN:
1869 case EL_PACMAN_RIGHT:
1871 case EL_PACMAN_LEFT:
1872 case EL_PACMAN_DOWN:
1874 case EL_YAMYAM_LEFT:
1875 case EL_YAMYAM_RIGHT:
1877 case EL_YAMYAM_DOWN:
1878 case EL_DARK_YAMYAM:
1881 case EL_SP_SNIKSNAK:
1882 case EL_SP_ELECTRON:
1888 case EL_SPRING_LEFT:
1889 case EL_SPRING_RIGHT:
1893 case EL_AMOEBA_FULL:
1898 case EL_AMOEBA_DROP:
1899 if (y == lev_fieldy - 1)
1901 Tile[x][y] = EL_AMOEBA_GROWING;
1902 Store[x][y] = EL_AMOEBA_WET;
1906 case EL_DYNAMITE_ACTIVE:
1907 case EL_SP_DISK_RED_ACTIVE:
1908 case EL_DYNABOMB_PLAYER_1_ACTIVE:
1909 case EL_DYNABOMB_PLAYER_2_ACTIVE:
1910 case EL_DYNABOMB_PLAYER_3_ACTIVE:
1911 case EL_DYNABOMB_PLAYER_4_ACTIVE:
1912 MovDelay[x][y] = 96;
1915 case EL_EM_DYNAMITE_ACTIVE:
1916 MovDelay[x][y] = 32;
1920 game.lights_still_needed++;
1924 game.friends_still_needed++;
1929 GfxDir[x][y] = MovDir[x][y] = 1 << RND(4);
1932 case EL_CONVEYOR_BELT_1_SWITCH_LEFT:
1933 case EL_CONVEYOR_BELT_1_SWITCH_MIDDLE:
1934 case EL_CONVEYOR_BELT_1_SWITCH_RIGHT:
1935 case EL_CONVEYOR_BELT_2_SWITCH_LEFT:
1936 case EL_CONVEYOR_BELT_2_SWITCH_MIDDLE:
1937 case EL_CONVEYOR_BELT_2_SWITCH_RIGHT:
1938 case EL_CONVEYOR_BELT_3_SWITCH_LEFT:
1939 case EL_CONVEYOR_BELT_3_SWITCH_MIDDLE:
1940 case EL_CONVEYOR_BELT_3_SWITCH_RIGHT:
1941 case EL_CONVEYOR_BELT_4_SWITCH_LEFT:
1942 case EL_CONVEYOR_BELT_4_SWITCH_MIDDLE:
1943 case EL_CONVEYOR_BELT_4_SWITCH_RIGHT:
1946 int belt_nr = getBeltNrFromBeltSwitchElement(Tile[x][y]);
1947 int belt_dir = getBeltDirFromBeltSwitchElement(Tile[x][y]);
1948 int belt_dir_nr = getBeltDirNrFromBeltSwitchElement(Tile[x][y]);
1950 if (game.belt_dir_nr[belt_nr] == 3) // initial value
1952 game.belt_dir[belt_nr] = belt_dir;
1953 game.belt_dir_nr[belt_nr] = belt_dir_nr;
1955 else // more than one switch -- set it like the first switch
1957 Tile[x][y] = Tile[x][y] - belt_dir_nr + game.belt_dir_nr[belt_nr];
1962 case EL_LIGHT_SWITCH_ACTIVE:
1964 game.light_time_left = level.time_light * FRAMES_PER_SECOND;
1967 case EL_INVISIBLE_STEELWALL:
1968 case EL_INVISIBLE_WALL:
1969 case EL_INVISIBLE_SAND:
1970 if (game.light_time_left > 0 ||
1971 game.lenses_time_left > 0)
1972 Tile[x][y] = getInvisibleActiveFromInvisibleElement(element);
1975 case EL_EMC_MAGIC_BALL:
1976 if (game.ball_active)
1977 Tile[x][y] = EL_EMC_MAGIC_BALL_ACTIVE;
1980 case EL_EMC_MAGIC_BALL_SWITCH:
1981 if (game.ball_active)
1982 Tile[x][y] = EL_EMC_MAGIC_BALL_SWITCH_ACTIVE;
1985 case EL_TRIGGER_PLAYER:
1986 case EL_TRIGGER_ELEMENT:
1987 case EL_TRIGGER_CE_VALUE:
1988 case EL_TRIGGER_CE_SCORE:
1990 case EL_ANY_ELEMENT:
1991 case EL_CURRENT_CE_VALUE:
1992 case EL_CURRENT_CE_SCORE:
2009 // reference elements should not be used on the playfield
2010 Tile[x][y] = EL_EMPTY;
2014 if (IS_CUSTOM_ELEMENT(element))
2016 if (CAN_MOVE(element))
2019 if (!element_info[element].use_last_ce_value || init_game)
2020 CustomValue[x][y] = GET_NEW_CE_VALUE(Tile[x][y]);
2022 else if (IS_GROUP_ELEMENT(element))
2024 Tile[x][y] = GetElementFromGroupElement(element);
2026 InitField(x, y, init_game);
2033 CheckTriggeredElementChange(x, y, element, CE_CREATION_OF_X);
2036 static void InitField_WithBug1(int x, int y, boolean init_game)
2038 InitField(x, y, init_game);
2040 // not needed to call InitMovDir() -- already done by InitField()!
2041 if (game.engine_version < VERSION_IDENT(3,1,0,0) &&
2042 CAN_MOVE(Tile[x][y]))
2046 static void InitField_WithBug2(int x, int y, boolean init_game)
2048 int old_element = Tile[x][y];
2050 InitField(x, y, init_game);
2052 // not needed to call InitMovDir() -- already done by InitField()!
2053 if (game.engine_version < VERSION_IDENT(3,1,0,0) &&
2054 CAN_MOVE(old_element) &&
2055 (old_element < EL_MOLE_LEFT || old_element > EL_MOLE_DOWN))
2058 /* this case is in fact a combination of not less than three bugs:
2059 first, it calls InitMovDir() for elements that can move, although this is
2060 already done by InitField(); then, it checks the element that was at this
2061 field _before_ the call to InitField() (which can change it); lastly, it
2062 was not called for "mole with direction" elements, which were treated as
2063 "cannot move" due to (fixed) wrong element initialization in "src/init.c"
2067 static int get_key_element_from_nr(int key_nr)
2069 int key_base_element = (key_nr >= STD_NUM_KEYS ? EL_EMC_KEY_5 - STD_NUM_KEYS :
2070 level.game_engine_type == GAME_ENGINE_TYPE_EM ?
2071 EL_EM_KEY_1 : EL_KEY_1);
2073 return key_base_element + key_nr;
2076 static int get_next_dropped_element(struct PlayerInfo *player)
2078 return (player->inventory_size > 0 ?
2079 player->inventory_element[player->inventory_size - 1] :
2080 player->inventory_infinite_element != EL_UNDEFINED ?
2081 player->inventory_infinite_element :
2082 player->dynabombs_left > 0 ?
2083 EL_DYNABOMB_PLAYER_1_ACTIVE + player->index_nr :
2087 static int get_inventory_element_from_pos(struct PlayerInfo *player, int pos)
2089 // pos >= 0: get element from bottom of the stack;
2090 // pos < 0: get element from top of the stack
2094 int min_inventory_size = -pos;
2095 int inventory_pos = player->inventory_size - min_inventory_size;
2096 int min_dynabombs_left = min_inventory_size - player->inventory_size;
2098 return (player->inventory_size >= min_inventory_size ?
2099 player->inventory_element[inventory_pos] :
2100 player->inventory_infinite_element != EL_UNDEFINED ?
2101 player->inventory_infinite_element :
2102 player->dynabombs_left >= min_dynabombs_left ?
2103 EL_DYNABOMB_PLAYER_1 + player->index_nr :
2108 int min_dynabombs_left = pos + 1;
2109 int min_inventory_size = pos + 1 - player->dynabombs_left;
2110 int inventory_pos = pos - player->dynabombs_left;
2112 return (player->inventory_infinite_element != EL_UNDEFINED ?
2113 player->inventory_infinite_element :
2114 player->dynabombs_left >= min_dynabombs_left ?
2115 EL_DYNABOMB_PLAYER_1 + player->index_nr :
2116 player->inventory_size >= min_inventory_size ?
2117 player->inventory_element[inventory_pos] :
2122 static int compareGamePanelOrderInfo(const void *object1, const void *object2)
2124 const struct GamePanelOrderInfo *gpo1 = (struct GamePanelOrderInfo *)object1;
2125 const struct GamePanelOrderInfo *gpo2 = (struct GamePanelOrderInfo *)object2;
2128 if (gpo1->sort_priority != gpo2->sort_priority)
2129 compare_result = gpo1->sort_priority - gpo2->sort_priority;
2131 compare_result = gpo1->nr - gpo2->nr;
2133 return compare_result;
2136 int getPlayerInventorySize(int player_nr)
2138 if (level.game_engine_type == GAME_ENGINE_TYPE_EM)
2139 return game_em.ply[player_nr]->dynamite;
2140 else if (level.game_engine_type == GAME_ENGINE_TYPE_SP)
2141 return game_sp.red_disk_count;
2143 return stored_player[player_nr].inventory_size;
2146 static void InitGameControlValues(void)
2150 for (i = 0; game_panel_controls[i].nr != -1; i++)
2152 struct GamePanelControlInfo *gpc = &game_panel_controls[i];
2153 struct GamePanelOrderInfo *gpo = &game_panel_order[i];
2154 struct TextPosInfo *pos = gpc->pos;
2156 int type = gpc->type;
2160 Error("'game_panel_controls' structure corrupted at %d", i);
2162 Fail("this should not happen -- please debug");
2165 // force update of game controls after initialization
2166 gpc->value = gpc->last_value = -1;
2167 gpc->frame = gpc->last_frame = -1;
2168 gpc->gfx_frame = -1;
2170 // determine panel value width for later calculation of alignment
2171 if (type == TYPE_INTEGER || type == TYPE_STRING)
2173 pos->width = pos->size * getFontWidth(pos->font);
2174 pos->height = getFontHeight(pos->font);
2176 else if (type == TYPE_ELEMENT)
2178 pos->width = pos->size;
2179 pos->height = pos->size;
2182 // fill structure for game panel draw order
2184 gpo->sort_priority = pos->sort_priority;
2187 // sort game panel controls according to sort_priority and control number
2188 qsort(game_panel_order, NUM_GAME_PANEL_CONTROLS,
2189 sizeof(struct GamePanelOrderInfo), compareGamePanelOrderInfo);
2192 static void UpdatePlayfieldElementCount(void)
2194 boolean use_element_count = FALSE;
2197 // first check if it is needed at all to calculate playfield element count
2198 for (i = GAME_PANEL_ELEMENT_COUNT_1; i <= GAME_PANEL_ELEMENT_COUNT_8; i++)
2199 if (!PANEL_DEACTIVATED(game_panel_controls[i].pos))
2200 use_element_count = TRUE;
2202 if (!use_element_count)
2205 for (i = 0; i < MAX_NUM_ELEMENTS; i++)
2206 element_info[i].element_count = 0;
2208 SCAN_PLAYFIELD(x, y)
2210 element_info[Tile[x][y]].element_count++;
2213 for (i = 0; i < NUM_GROUP_ELEMENTS; i++)
2214 for (j = 0; j < MAX_NUM_ELEMENTS; j++)
2215 if (IS_IN_GROUP(j, i))
2216 element_info[EL_GROUP_START + i].element_count +=
2217 element_info[j].element_count;
2220 static void UpdateGameControlValues(void)
2223 int time = (game.LevelSolved ?
2224 game.LevelSolved_CountingTime :
2225 level.game_engine_type == GAME_ENGINE_TYPE_EM ?
2227 level.game_engine_type == GAME_ENGINE_TYPE_SP ?
2228 game_sp.time_played :
2229 level.game_engine_type == GAME_ENGINE_TYPE_MM ?
2230 game_mm.energy_left :
2231 game.no_time_limit ? TimePlayed : TimeLeft);
2232 int score = (game.LevelSolved ?
2233 game.LevelSolved_CountingScore :
2234 level.game_engine_type == GAME_ENGINE_TYPE_EM ?
2235 game_em.lev->score :
2236 level.game_engine_type == GAME_ENGINE_TYPE_SP ?
2238 level.game_engine_type == GAME_ENGINE_TYPE_MM ?
2241 int gems = (level.game_engine_type == GAME_ENGINE_TYPE_EM ?
2242 game_em.lev->gems_needed :
2243 level.game_engine_type == GAME_ENGINE_TYPE_SP ?
2244 game_sp.infotrons_still_needed :
2245 level.game_engine_type == GAME_ENGINE_TYPE_MM ?
2246 game_mm.kettles_still_needed :
2247 game.gems_still_needed);
2248 int exit_closed = (level.game_engine_type == GAME_ENGINE_TYPE_EM ?
2249 game_em.lev->gems_needed > 0 :
2250 level.game_engine_type == GAME_ENGINE_TYPE_SP ?
2251 game_sp.infotrons_still_needed > 0 :
2252 level.game_engine_type == GAME_ENGINE_TYPE_MM ?
2253 game_mm.kettles_still_needed > 0 ||
2254 game_mm.lights_still_needed > 0 :
2255 game.gems_still_needed > 0 ||
2256 game.sokoban_fields_still_needed > 0 ||
2257 game.sokoban_objects_still_needed > 0 ||
2258 game.lights_still_needed > 0);
2259 int health = (game.LevelSolved ?
2260 game.LevelSolved_CountingHealth :
2261 level.game_engine_type == GAME_ENGINE_TYPE_MM ?
2262 MM_HEALTH(game_mm.laser_overload_value) :
2264 int sync_random_frame = INIT_GFX_RANDOM(); // random, but synchronized
2266 UpdatePlayfieldElementCount();
2268 // update game panel control values
2270 // used instead of "level_nr" (for network games)
2271 game_panel_controls[GAME_PANEL_LEVEL_NUMBER].value = levelset.level_nr;
2272 game_panel_controls[GAME_PANEL_GEMS].value = gems;
2274 game_panel_controls[GAME_PANEL_INVENTORY_COUNT].value = 0;
2275 for (i = 0; i < MAX_NUM_KEYS; i++)
2276 game_panel_controls[GAME_PANEL_KEY_1 + i].value = EL_EMPTY;
2277 game_panel_controls[GAME_PANEL_KEY_WHITE].value = EL_EMPTY;
2278 game_panel_controls[GAME_PANEL_KEY_WHITE_COUNT].value = 0;
2280 if (game.centered_player_nr == -1)
2282 for (i = 0; i < MAX_PLAYERS; i++)
2284 // only one player in Supaplex game engine
2285 if (level.game_engine_type == GAME_ENGINE_TYPE_SP && i > 0)
2288 for (k = 0; k < MAX_NUM_KEYS; k++)
2290 if (level.game_engine_type == GAME_ENGINE_TYPE_EM)
2292 if (game_em.ply[i]->keys & (1 << k))
2293 game_panel_controls[GAME_PANEL_KEY_1 + k].value =
2294 get_key_element_from_nr(k);
2296 else if (stored_player[i].key[k])
2297 game_panel_controls[GAME_PANEL_KEY_1 + k].value =
2298 get_key_element_from_nr(k);
2301 game_panel_controls[GAME_PANEL_INVENTORY_COUNT].value +=
2302 getPlayerInventorySize(i);
2304 if (stored_player[i].num_white_keys > 0)
2305 game_panel_controls[GAME_PANEL_KEY_WHITE].value =
2308 game_panel_controls[GAME_PANEL_KEY_WHITE_COUNT].value +=
2309 stored_player[i].num_white_keys;
2314 int player_nr = game.centered_player_nr;
2316 for (k = 0; k < MAX_NUM_KEYS; k++)
2318 if (level.game_engine_type == GAME_ENGINE_TYPE_EM)
2320 if (game_em.ply[player_nr]->keys & (1 << k))
2321 game_panel_controls[GAME_PANEL_KEY_1 + k].value =
2322 get_key_element_from_nr(k);
2324 else if (stored_player[player_nr].key[k])
2325 game_panel_controls[GAME_PANEL_KEY_1 + k].value =
2326 get_key_element_from_nr(k);
2329 game_panel_controls[GAME_PANEL_INVENTORY_COUNT].value +=
2330 getPlayerInventorySize(player_nr);
2332 if (stored_player[player_nr].num_white_keys > 0)
2333 game_panel_controls[GAME_PANEL_KEY_WHITE].value = EL_DC_KEY_WHITE;
2335 game_panel_controls[GAME_PANEL_KEY_WHITE_COUNT].value +=
2336 stored_player[player_nr].num_white_keys;
2339 // re-arrange keys on game panel, if needed or if defined by style settings
2340 for (i = 0; i < MAX_NUM_KEYS + 1; i++) // all normal keys + white key
2342 int nr = GAME_PANEL_KEY_1 + i;
2343 struct GamePanelControlInfo *gpc = &game_panel_controls[nr];
2344 struct TextPosInfo *pos = gpc->pos;
2346 // skip check if key is not in the player's inventory
2347 if (gpc->value == EL_EMPTY)
2350 // check if keys should be arranged on panel from left to right
2351 if (pos->style == STYLE_LEFTMOST_POSITION)
2353 // check previous key positions (left from current key)
2354 for (k = 0; k < i; k++)
2356 int nr_new = GAME_PANEL_KEY_1 + k;
2358 if (game_panel_controls[nr_new].value == EL_EMPTY)
2360 game_panel_controls[nr_new].value = gpc->value;
2361 gpc->value = EL_EMPTY;
2368 // check if "undefined" keys can be placed at some other position
2369 if (pos->x == -1 && pos->y == -1)
2371 int nr_new = GAME_PANEL_KEY_1 + i % STD_NUM_KEYS;
2373 // 1st try: display key at the same position as normal or EM keys
2374 if (game_panel_controls[nr_new].value == EL_EMPTY)
2376 game_panel_controls[nr_new].value = gpc->value;
2380 // 2nd try: display key at the next free position in the key panel
2381 for (k = 0; k < STD_NUM_KEYS; k++)
2383 nr_new = GAME_PANEL_KEY_1 + k;
2385 if (game_panel_controls[nr_new].value == EL_EMPTY)
2387 game_panel_controls[nr_new].value = gpc->value;
2396 for (i = 0; i < NUM_PANEL_INVENTORY; i++)
2398 game_panel_controls[GAME_PANEL_INVENTORY_FIRST_1 + i].value =
2399 get_inventory_element_from_pos(local_player, i);
2400 game_panel_controls[GAME_PANEL_INVENTORY_LAST_1 + i].value =
2401 get_inventory_element_from_pos(local_player, -i - 1);
2404 game_panel_controls[GAME_PANEL_SCORE].value = score;
2405 game_panel_controls[GAME_PANEL_HIGHSCORE].value = scores.entry[0].score;
2407 game_panel_controls[GAME_PANEL_TIME].value = time;
2409 game_panel_controls[GAME_PANEL_TIME_HH].value = time / 3600;
2410 game_panel_controls[GAME_PANEL_TIME_MM].value = (time / 60) % 60;
2411 game_panel_controls[GAME_PANEL_TIME_SS].value = time % 60;
2413 if (level.time == 0)
2414 game_panel_controls[GAME_PANEL_TIME_ANIM].value = 100;
2416 game_panel_controls[GAME_PANEL_TIME_ANIM].value = time * 100 / level.time;
2418 game_panel_controls[GAME_PANEL_HEALTH].value = health;
2419 game_panel_controls[GAME_PANEL_HEALTH_ANIM].value = health;
2421 game_panel_controls[GAME_PANEL_FRAME].value = FrameCounter;
2423 game_panel_controls[GAME_PANEL_SHIELD_NORMAL].value =
2424 (local_player->shield_normal_time_left > 0 ? EL_SHIELD_NORMAL_ACTIVE :
2426 game_panel_controls[GAME_PANEL_SHIELD_NORMAL_TIME].value =
2427 local_player->shield_normal_time_left;
2428 game_panel_controls[GAME_PANEL_SHIELD_DEADLY].value =
2429 (local_player->shield_deadly_time_left > 0 ? EL_SHIELD_DEADLY_ACTIVE :
2431 game_panel_controls[GAME_PANEL_SHIELD_DEADLY_TIME].value =
2432 local_player->shield_deadly_time_left;
2434 game_panel_controls[GAME_PANEL_EXIT].value =
2435 (exit_closed ? EL_EXIT_CLOSED : EL_EXIT_OPEN);
2437 game_panel_controls[GAME_PANEL_EMC_MAGIC_BALL].value =
2438 (game.ball_active ? EL_EMC_MAGIC_BALL_ACTIVE : EL_EMC_MAGIC_BALL);
2439 game_panel_controls[GAME_PANEL_EMC_MAGIC_BALL_SWITCH].value =
2440 (game.ball_active ? EL_EMC_MAGIC_BALL_SWITCH_ACTIVE :
2441 EL_EMC_MAGIC_BALL_SWITCH);
2443 game_panel_controls[GAME_PANEL_LIGHT_SWITCH].value =
2444 (game.light_time_left > 0 ? EL_LIGHT_SWITCH_ACTIVE : EL_LIGHT_SWITCH);
2445 game_panel_controls[GAME_PANEL_LIGHT_SWITCH_TIME].value =
2446 game.light_time_left;
2448 game_panel_controls[GAME_PANEL_TIMEGATE_SWITCH].value =
2449 (game.timegate_time_left > 0 ? EL_TIMEGATE_OPEN : EL_TIMEGATE_CLOSED);
2450 game_panel_controls[GAME_PANEL_TIMEGATE_SWITCH_TIME].value =
2451 game.timegate_time_left;
2453 game_panel_controls[GAME_PANEL_SWITCHGATE_SWITCH].value =
2454 EL_SWITCHGATE_SWITCH_UP + game.switchgate_pos;
2456 game_panel_controls[GAME_PANEL_EMC_LENSES].value =
2457 (game.lenses_time_left > 0 ? EL_EMC_LENSES : EL_EMPTY);
2458 game_panel_controls[GAME_PANEL_EMC_LENSES_TIME].value =
2459 game.lenses_time_left;
2461 game_panel_controls[GAME_PANEL_EMC_MAGNIFIER].value =
2462 (game.magnify_time_left > 0 ? EL_EMC_MAGNIFIER : EL_EMPTY);
2463 game_panel_controls[GAME_PANEL_EMC_MAGNIFIER_TIME].value =
2464 game.magnify_time_left;
2466 game_panel_controls[GAME_PANEL_BALLOON_SWITCH].value =
2467 (game.wind_direction == MV_LEFT ? EL_BALLOON_SWITCH_LEFT :
2468 game.wind_direction == MV_RIGHT ? EL_BALLOON_SWITCH_RIGHT :
2469 game.wind_direction == MV_UP ? EL_BALLOON_SWITCH_UP :
2470 game.wind_direction == MV_DOWN ? EL_BALLOON_SWITCH_DOWN :
2471 EL_BALLOON_SWITCH_NONE);
2473 game_panel_controls[GAME_PANEL_DYNABOMB_NUMBER].value =
2474 local_player->dynabomb_count;
2475 game_panel_controls[GAME_PANEL_DYNABOMB_SIZE].value =
2476 local_player->dynabomb_size;
2477 game_panel_controls[GAME_PANEL_DYNABOMB_POWER].value =
2478 (local_player->dynabomb_xl ? EL_DYNABOMB_INCREASE_POWER : EL_EMPTY);
2480 game_panel_controls[GAME_PANEL_PENGUINS].value =
2481 game.friends_still_needed;
2483 game_panel_controls[GAME_PANEL_SOKOBAN_OBJECTS].value =
2484 game.sokoban_objects_still_needed;
2485 game_panel_controls[GAME_PANEL_SOKOBAN_FIELDS].value =
2486 game.sokoban_fields_still_needed;
2488 game_panel_controls[GAME_PANEL_ROBOT_WHEEL].value =
2489 (game.robot_wheel_active ? EL_ROBOT_WHEEL_ACTIVE : EL_ROBOT_WHEEL);
2491 for (i = 0; i < NUM_BELTS; i++)
2493 game_panel_controls[GAME_PANEL_CONVEYOR_BELT_1 + i].value =
2494 (game.belt_dir[i] != MV_NONE ? EL_CONVEYOR_BELT_1_MIDDLE_ACTIVE :
2495 EL_CONVEYOR_BELT_1_MIDDLE) + i;
2496 game_panel_controls[GAME_PANEL_CONVEYOR_BELT_1_SWITCH + i].value =
2497 getBeltSwitchElementFromBeltNrAndBeltDir(i, game.belt_dir[i]);
2500 game_panel_controls[GAME_PANEL_MAGIC_WALL].value =
2501 (game.magic_wall_active ? EL_MAGIC_WALL_ACTIVE : EL_MAGIC_WALL);
2502 game_panel_controls[GAME_PANEL_MAGIC_WALL_TIME].value =
2503 game.magic_wall_time_left;
2505 game_panel_controls[GAME_PANEL_GRAVITY_STATE].value =
2506 local_player->gravity;
2508 for (i = 0; i < NUM_PANEL_GRAPHICS; i++)
2509 game_panel_controls[GAME_PANEL_GRAPHIC_1 + i].value = EL_GRAPHIC_1 + i;
2511 for (i = 0; i < NUM_PANEL_ELEMENTS; i++)
2512 game_panel_controls[GAME_PANEL_ELEMENT_1 + i].value =
2513 (IS_DRAWABLE_ELEMENT(game.panel.element[i].id) ?
2514 game.panel.element[i].id : EL_UNDEFINED);
2516 for (i = 0; i < NUM_PANEL_ELEMENTS; i++)
2517 game_panel_controls[GAME_PANEL_ELEMENT_COUNT_1 + i].value =
2518 (IS_VALID_ELEMENT(game.panel.element_count[i].id) ?
2519 element_info[game.panel.element_count[i].id].element_count : 0);
2521 for (i = 0; i < NUM_PANEL_CE_SCORE; i++)
2522 game_panel_controls[GAME_PANEL_CE_SCORE_1 + i].value =
2523 (IS_CUSTOM_ELEMENT(game.panel.ce_score[i].id) ?
2524 element_info[game.panel.ce_score[i].id].collect_score : 0);
2526 for (i = 0; i < NUM_PANEL_CE_SCORE; i++)
2527 game_panel_controls[GAME_PANEL_CE_SCORE_1_ELEMENT + i].value =
2528 (IS_CUSTOM_ELEMENT(game.panel.ce_score_element[i].id) ?
2529 element_info[game.panel.ce_score_element[i].id].collect_score :
2532 game_panel_controls[GAME_PANEL_PLAYER_NAME].value = 0;
2533 game_panel_controls[GAME_PANEL_LEVEL_NAME].value = 0;
2534 game_panel_controls[GAME_PANEL_LEVEL_AUTHOR].value = 0;
2536 // update game panel control frames
2538 for (i = 0; game_panel_controls[i].nr != -1; i++)
2540 struct GamePanelControlInfo *gpc = &game_panel_controls[i];
2542 if (gpc->type == TYPE_ELEMENT)
2544 if (gpc->value != EL_UNDEFINED && gpc->value != EL_EMPTY)
2546 int last_anim_random_frame = gfx.anim_random_frame;
2547 int element = gpc->value;
2548 int graphic = el2panelimg(element);
2549 int init_gfx_random = (graphic_info[graphic].anim_global_sync ?
2550 sync_random_frame : INIT_GFX_RANDOM());
2552 if (gpc->value != gpc->last_value)
2555 gpc->gfx_random = init_gfx_random;
2561 if (ANIM_MODE(graphic) == ANIM_RANDOM &&
2562 IS_NEXT_FRAME(gpc->gfx_frame, graphic))
2563 gpc->gfx_random = init_gfx_random;
2566 if (ANIM_MODE(graphic) == ANIM_RANDOM)
2567 gfx.anim_random_frame = gpc->gfx_random;
2569 if (ANIM_MODE(graphic) == ANIM_CE_SCORE)
2570 gpc->gfx_frame = element_info[element].collect_score;
2572 gpc->frame = getGraphicAnimationFrame(graphic, gpc->gfx_frame);
2574 if (ANIM_MODE(graphic) == ANIM_RANDOM)
2575 gfx.anim_random_frame = last_anim_random_frame;
2578 else if (gpc->type == TYPE_GRAPHIC)
2580 if (gpc->graphic != IMG_UNDEFINED)
2582 int last_anim_random_frame = gfx.anim_random_frame;
2583 int graphic = gpc->graphic;
2584 int init_gfx_random = (graphic_info[graphic].anim_global_sync ?
2585 sync_random_frame : INIT_GFX_RANDOM());
2587 if (gpc->value != gpc->last_value)
2590 gpc->gfx_random = init_gfx_random;
2596 if (ANIM_MODE(graphic) == ANIM_RANDOM &&
2597 IS_NEXT_FRAME(gpc->gfx_frame, graphic))
2598 gpc->gfx_random = init_gfx_random;
2601 if (ANIM_MODE(graphic) == ANIM_RANDOM)
2602 gfx.anim_random_frame = gpc->gfx_random;
2604 gpc->frame = getGraphicAnimationFrame(graphic, gpc->gfx_frame);
2606 if (ANIM_MODE(graphic) == ANIM_RANDOM)
2607 gfx.anim_random_frame = last_anim_random_frame;
2613 static void DisplayGameControlValues(void)
2615 boolean redraw_panel = FALSE;
2618 for (i = 0; game_panel_controls[i].nr != -1; i++)
2620 struct GamePanelControlInfo *gpc = &game_panel_controls[i];
2622 if (PANEL_DEACTIVATED(gpc->pos))
2625 if (gpc->value == gpc->last_value &&
2626 gpc->frame == gpc->last_frame)
2629 redraw_panel = TRUE;
2635 // copy default game door content to main double buffer
2637 // !!! CHECK AGAIN !!!
2638 SetPanelBackground();
2639 // SetDoorBackgroundImage(IMG_BACKGROUND_PANEL);
2640 DrawBackground(DX, DY, DXSIZE, DYSIZE);
2642 // redraw game control buttons
2643 RedrawGameButtons();
2645 SetGameStatus(GAME_MODE_PSEUDO_PANEL);
2647 for (i = 0; i < NUM_GAME_PANEL_CONTROLS; i++)
2649 int nr = game_panel_order[i].nr;
2650 struct GamePanelControlInfo *gpc = &game_panel_controls[nr];
2651 struct TextPosInfo *pos = gpc->pos;
2652 int type = gpc->type;
2653 int value = gpc->value;
2654 int frame = gpc->frame;
2655 int size = pos->size;
2656 int font = pos->font;
2657 boolean draw_masked = pos->draw_masked;
2658 int mask_mode = (draw_masked ? BLIT_MASKED : BLIT_OPAQUE);
2660 if (PANEL_DEACTIVATED(pos))
2663 if (pos->class == get_hash_from_key("extra_panel_items") &&
2664 !setup.prefer_extra_panel_items)
2667 gpc->last_value = value;
2668 gpc->last_frame = frame;
2670 if (type == TYPE_INTEGER)
2672 if (nr == GAME_PANEL_LEVEL_NUMBER ||
2673 nr == GAME_PANEL_TIME)
2675 boolean use_dynamic_size = (size == -1 ? TRUE : FALSE);
2677 if (use_dynamic_size) // use dynamic number of digits
2679 int value_change = (nr == GAME_PANEL_LEVEL_NUMBER ? 100 : 1000);
2680 int size1 = (nr == GAME_PANEL_LEVEL_NUMBER ? 2 : 3);
2681 int size2 = size1 + 1;
2682 int font1 = pos->font;
2683 int font2 = pos->font_alt;
2685 size = (value < value_change ? size1 : size2);
2686 font = (value < value_change ? font1 : font2);
2690 // correct text size if "digits" is zero or less
2692 size = strlen(int2str(value, size));
2694 // dynamically correct text alignment
2695 pos->width = size * getFontWidth(font);
2697 DrawTextExt(drawto, PANEL_XPOS(pos), PANEL_YPOS(pos),
2698 int2str(value, size), font, mask_mode);
2700 else if (type == TYPE_ELEMENT)
2702 int element, graphic;
2706 int dst_x = PANEL_XPOS(pos);
2707 int dst_y = PANEL_YPOS(pos);
2709 if (value != EL_UNDEFINED && value != EL_EMPTY)
2712 graphic = el2panelimg(value);
2715 Debug("game:DisplayGameControlValues", "%d, '%s' [%d]",
2716 element, EL_NAME(element), size);
2719 if (element >= EL_GRAPHIC_1 && element <= EL_GRAPHIC_8 && size == 0)
2722 getSizedGraphicSource(graphic, frame, size, &src_bitmap,
2725 width = graphic_info[graphic].width * size / TILESIZE;
2726 height = graphic_info[graphic].height * size / TILESIZE;
2729 BlitBitmapMasked(src_bitmap, drawto, src_x, src_y, width, height,
2732 BlitBitmap(src_bitmap, drawto, src_x, src_y, width, height,
2736 else if (type == TYPE_GRAPHIC)
2738 int graphic = gpc->graphic;
2739 int graphic_active = gpc->graphic_active;
2743 int dst_x = PANEL_XPOS(pos);
2744 int dst_y = PANEL_YPOS(pos);
2745 boolean skip = (pos->class == get_hash_from_key("mm_engine_only") &&
2746 level.game_engine_type != GAME_ENGINE_TYPE_MM);
2748 if (graphic != IMG_UNDEFINED && !skip)
2750 if (pos->style == STYLE_REVERSE)
2751 value = 100 - value;
2753 getGraphicSource(graphic_active, frame, &src_bitmap, &src_x, &src_y);
2755 if (pos->direction & MV_HORIZONTAL)
2757 width = graphic_info[graphic_active].width * value / 100;
2758 height = graphic_info[graphic_active].height;
2760 if (pos->direction == MV_LEFT)
2762 src_x += graphic_info[graphic_active].width - width;
2763 dst_x += graphic_info[graphic_active].width - width;
2768 width = graphic_info[graphic_active].width;
2769 height = graphic_info[graphic_active].height * value / 100;
2771 if (pos->direction == MV_UP)
2773 src_y += graphic_info[graphic_active].height - height;
2774 dst_y += graphic_info[graphic_active].height - height;
2779 BlitBitmapMasked(src_bitmap, drawto, src_x, src_y, width, height,
2782 BlitBitmap(src_bitmap, drawto, src_x, src_y, width, height,
2785 getGraphicSource(graphic, frame, &src_bitmap, &src_x, &src_y);
2787 if (pos->direction & MV_HORIZONTAL)
2789 if (pos->direction == MV_RIGHT)
2796 dst_x = PANEL_XPOS(pos);
2799 width = graphic_info[graphic].width - width;
2803 if (pos->direction == MV_DOWN)
2810 dst_y = PANEL_YPOS(pos);
2813 height = graphic_info[graphic].height - height;
2817 BlitBitmapMasked(src_bitmap, drawto, src_x, src_y, width, height,
2820 BlitBitmap(src_bitmap, drawto, src_x, src_y, width, height,
2824 else if (type == TYPE_STRING)
2826 boolean active = (value != 0);
2827 char *state_normal = "off";
2828 char *state_active = "on";
2829 char *state = (active ? state_active : state_normal);
2830 char *s = (nr == GAME_PANEL_GRAVITY_STATE ? state :
2831 nr == GAME_PANEL_PLAYER_NAME ? setup.player_name :
2832 nr == GAME_PANEL_LEVEL_NAME ? level.name :
2833 nr == GAME_PANEL_LEVEL_AUTHOR ? level.author : NULL);
2835 if (nr == GAME_PANEL_GRAVITY_STATE)
2837 int font1 = pos->font; // (used for normal state)
2838 int font2 = pos->font_alt; // (used for active state)
2840 font = (active ? font2 : font1);
2849 // don't truncate output if "chars" is zero or less
2852 // dynamically correct text alignment
2853 pos->width = size * getFontWidth(font);
2856 s_cut = getStringCopyN(s, size);
2858 DrawTextExt(drawto, PANEL_XPOS(pos), PANEL_YPOS(pos),
2859 s_cut, font, mask_mode);
2865 redraw_mask |= REDRAW_DOOR_1;
2868 SetGameStatus(GAME_MODE_PLAYING);
2871 void UpdateAndDisplayGameControlValues(void)
2873 if (tape.deactivate_display)
2876 UpdateGameControlValues();
2877 DisplayGameControlValues();
2880 void UpdateGameDoorValues(void)
2882 UpdateGameControlValues();
2885 void DrawGameDoorValues(void)
2887 DisplayGameControlValues();
2891 // ============================================================================
2893 // ----------------------------------------------------------------------------
2894 // initialize game engine due to level / tape version number
2895 // ============================================================================
2897 static void InitGameEngine(void)
2899 int i, j, k, l, x, y;
2901 // set game engine from tape file when re-playing, else from level file
2902 game.engine_version = (tape.playing ? tape.engine_version :
2903 level.game_version);
2905 // set single or multi-player game mode (needed for re-playing tapes)
2906 game.team_mode = setup.team_mode;
2910 int num_players = 0;
2912 for (i = 0; i < MAX_PLAYERS; i++)
2913 if (tape.player_participates[i])
2916 // multi-player tapes contain input data for more than one player
2917 game.team_mode = (num_players > 1);
2921 Debug("game:init:level", "level %d: level.game_version == %06d", level_nr,
2922 level.game_version);
2923 Debug("game:init:level", " tape.file_version == %06d",
2925 Debug("game:init:level", " tape.game_version == %06d",
2927 Debug("game:init:level", " tape.engine_version == %06d",
2928 tape.engine_version);
2929 Debug("game:init:level", " => game.engine_version == %06d [tape mode: %s]",
2930 game.engine_version, (tape.playing ? "PLAYING" : "RECORDING"));
2933 // --------------------------------------------------------------------------
2934 // set flags for bugs and changes according to active game engine version
2935 // --------------------------------------------------------------------------
2939 Fixed property "can fall" for run-time element "EL_AMOEBA_DROPPING"
2941 Bug was introduced in version:
2944 Bug was fixed in version:
2948 In version 2.0.1, a new run-time element "EL_AMOEBA_DROPPING" was added,
2949 but the property "can fall" was missing, which caused some levels to be
2950 unsolvable. This was fixed in version 4.2.0.0.
2952 Affected levels/tapes:
2953 An example for a tape that was fixed by this bugfix is tape 029 from the
2954 level set "rnd_sam_bateman".
2955 The wrong behaviour will still be used for all levels or tapes that were
2956 created/recorded with it. An example for this is tape 023 from the level
2957 set "rnd_gerhard_haeusler", which was recorded with a buggy game engine.
2960 boolean use_amoeba_dropping_cannot_fall_bug =
2961 ((game.engine_version >= VERSION_IDENT(2,0,1,0) &&
2962 game.engine_version < VERSION_IDENT(4,2,0,0)) ||
2964 tape.game_version >= VERSION_IDENT(2,0,1,0) &&
2965 tape.game_version < VERSION_IDENT(4,2,0,0)));
2968 Summary of bugfix/change:
2969 Fixed move speed of elements entering or leaving magic wall.
2971 Fixed/changed in version:
2975 Before 2.0.1, move speed of elements entering or leaving magic wall was
2976 twice as fast as it is now.
2977 Since 2.0.1, this is set to a lower value by using move_stepsize_list[].
2979 Affected levels/tapes:
2980 The first condition is generally needed for all levels/tapes before version
2981 2.0.1, which might use the old behaviour before it was changed; known tapes
2982 that are affected: Tape 014 from the level set "rnd_conor_mancone".
2983 The second condition is an exception from the above case and is needed for
2984 the special case of tapes recorded with game (not engine!) version 2.0.1 or
2985 above, but before it was known that this change would break tapes like the
2986 above and was fixed in 4.2.0.0, so that the changed behaviour was active
2987 although the engine version while recording maybe was before 2.0.1. There
2988 are a lot of tapes that are affected by this exception, like tape 006 from
2989 the level set "rnd_conor_mancone".
2992 boolean use_old_move_stepsize_for_magic_wall =
2993 (game.engine_version < VERSION_IDENT(2,0,1,0) &&
2995 tape.game_version >= VERSION_IDENT(2,0,1,0) &&
2996 tape.game_version < VERSION_IDENT(4,2,0,0)));
2999 Summary of bugfix/change:
3000 Fixed handling for custom elements that change when pushed by the player.
3002 Fixed/changed in version:
3006 Before 3.1.0, custom elements that "change when pushing" changed directly
3007 after the player started pushing them (until then handled in "DigField()").
3008 Since 3.1.0, these custom elements are not changed until the "pushing"
3009 move of the element is finished (now handled in "ContinueMoving()").
3011 Affected levels/tapes:
3012 The first condition is generally needed for all levels/tapes before version
3013 3.1.0, which might use the old behaviour before it was changed; known tapes
3014 that are affected are some tapes from the level set "Walpurgis Gardens" by
3016 The second condition is an exception from the above case and is needed for
3017 the special case of tapes recorded with game (not engine!) version 3.1.0 or
3018 above (including some development versions of 3.1.0), but before it was
3019 known that this change would break tapes like the above and was fixed in
3020 3.1.1, so that the changed behaviour was active although the engine version
3021 while recording maybe was before 3.1.0. There is at least one tape that is
3022 affected by this exception, which is the tape for the one-level set "Bug
3023 Machine" by Juergen Bonhagen.
3026 game.use_change_when_pushing_bug =
3027 (game.engine_version < VERSION_IDENT(3,1,0,0) &&
3029 tape.game_version >= VERSION_IDENT(3,1,0,0) &&
3030 tape.game_version < VERSION_IDENT(3,1,1,0)));
3033 Summary of bugfix/change:
3034 Fixed handling for blocking the field the player leaves when moving.
3036 Fixed/changed in version:
3040 Before 3.1.1, when "block last field when moving" was enabled, the field
3041 the player is leaving when moving was blocked for the time of the move,
3042 and was directly unblocked afterwards. This resulted in the last field
3043 being blocked for exactly one less than the number of frames of one player
3044 move. Additionally, even when blocking was disabled, the last field was
3045 blocked for exactly one frame.
3046 Since 3.1.1, due to changes in player movement handling, the last field
3047 is not blocked at all when blocking is disabled. When blocking is enabled,
3048 the last field is blocked for exactly the number of frames of one player
3049 move. Additionally, if the player is Murphy, the hero of Supaplex, the
3050 last field is blocked for exactly one more than the number of frames of
3053 Affected levels/tapes:
3054 (!!! yet to be determined -- probably many !!!)
3057 game.use_block_last_field_bug =
3058 (game.engine_version < VERSION_IDENT(3,1,1,0));
3060 /* various special flags and settings for native Emerald Mine game engine */
3062 game_em.use_single_button =
3063 (game.engine_version > VERSION_IDENT(4,0,0,2));
3065 game_em.use_snap_key_bug =
3066 (game.engine_version < VERSION_IDENT(4,0,1,0));
3068 game_em.use_random_bug =
3069 (tape.property_bits & TAPE_PROPERTY_EM_RANDOM_BUG);
3071 boolean use_old_em_engine = (game.engine_version < VERSION_IDENT(4,2,0,0));
3073 game_em.use_old_explosions = use_old_em_engine;
3074 game_em.use_old_android = use_old_em_engine;
3075 game_em.use_old_push_elements = use_old_em_engine;
3076 game_em.use_old_push_into_acid = use_old_em_engine;
3078 game_em.use_wrap_around = !use_old_em_engine;
3080 // --------------------------------------------------------------------------
3082 // set maximal allowed number of custom element changes per game frame
3083 game.max_num_changes_per_frame = 1;
3085 // default scan direction: scan playfield from top/left to bottom/right
3086 InitPlayfieldScanMode(CA_ARG_SCAN_MODE_NORMAL);
3088 // dynamically adjust element properties according to game engine version
3089 InitElementPropertiesEngine(game.engine_version);
3091 // ---------- initialize special element properties -------------------------
3093 // "EL_AMOEBA_DROPPING" missed property "can fall" in older game versions
3094 if (use_amoeba_dropping_cannot_fall_bug)
3095 SET_PROPERTY(EL_AMOEBA_DROPPING, EP_CAN_FALL, FALSE);
3097 // ---------- initialize player's initial move delay ------------------------
3099 // dynamically adjust player properties according to level information
3100 for (i = 0; i < MAX_PLAYERS; i++)
3101 game.initial_move_delay_value[i] =
3102 get_move_delay_from_stepsize(level.initial_player_stepsize[i]);
3104 // dynamically adjust player properties according to game engine version
3105 for (i = 0; i < MAX_PLAYERS; i++)
3106 game.initial_move_delay[i] =
3107 (game.engine_version <= VERSION_IDENT(2,0,1,0) ?
3108 game.initial_move_delay_value[i] : 0);
3110 // ---------- initialize player's initial push delay ------------------------
3112 // dynamically adjust player properties according to game engine version
3113 game.initial_push_delay_value =
3114 (game.engine_version < VERSION_IDENT(3,0,7,1) ? 5 : -1);
3116 // ---------- initialize changing elements ----------------------------------
3118 // initialize changing elements information
3119 for (i = 0; i < MAX_NUM_ELEMENTS; i++)
3121 struct ElementInfo *ei = &element_info[i];
3123 // this pointer might have been changed in the level editor
3124 ei->change = &ei->change_page[0];
3126 if (!IS_CUSTOM_ELEMENT(i))
3128 ei->change->target_element = EL_EMPTY_SPACE;
3129 ei->change->delay_fixed = 0;
3130 ei->change->delay_random = 0;
3131 ei->change->delay_frames = 1;
3134 for (j = 0; j < NUM_CHANGE_EVENTS; j++)
3136 ei->has_change_event[j] = FALSE;
3138 ei->event_page_nr[j] = 0;
3139 ei->event_page[j] = &ei->change_page[0];
3143 // add changing elements from pre-defined list
3144 for (i = 0; change_delay_list[i].element != EL_UNDEFINED; i++)
3146 struct ChangingElementInfo *ch_delay = &change_delay_list[i];
3147 struct ElementInfo *ei = &element_info[ch_delay->element];
3149 ei->change->target_element = ch_delay->target_element;
3150 ei->change->delay_fixed = ch_delay->change_delay;
3152 ei->change->pre_change_function = ch_delay->pre_change_function;
3153 ei->change->change_function = ch_delay->change_function;
3154 ei->change->post_change_function = ch_delay->post_change_function;
3156 ei->change->can_change = TRUE;
3157 ei->change->can_change_or_has_action = TRUE;
3159 ei->has_change_event[CE_DELAY] = TRUE;
3161 SET_PROPERTY(ch_delay->element, EP_CAN_CHANGE, TRUE);
3162 SET_PROPERTY(ch_delay->element, EP_CAN_CHANGE_OR_HAS_ACTION, TRUE);
3165 // ---------- initialize internal run-time variables ------------------------
3167 for (i = 0; i < NUM_CUSTOM_ELEMENTS; i++)
3169 struct ElementInfo *ei = &element_info[EL_CUSTOM_START + i];
3171 for (j = 0; j < ei->num_change_pages; j++)
3173 ei->change_page[j].can_change_or_has_action =
3174 (ei->change_page[j].can_change |
3175 ei->change_page[j].has_action);
3179 // add change events from custom element configuration
3180 for (i = 0; i < NUM_CUSTOM_ELEMENTS; i++)
3182 struct ElementInfo *ei = &element_info[EL_CUSTOM_START + i];
3184 for (j = 0; j < ei->num_change_pages; j++)
3186 if (!ei->change_page[j].can_change_or_has_action)
3189 for (k = 0; k < NUM_CHANGE_EVENTS; k++)
3191 // only add event page for the first page found with this event
3192 if (ei->change_page[j].has_event[k] && !(ei->has_change_event[k]))
3194 ei->has_change_event[k] = TRUE;
3196 ei->event_page_nr[k] = j;
3197 ei->event_page[k] = &ei->change_page[j];
3203 // ---------- initialize reference elements in change conditions ------------
3205 for (i = 0; i < NUM_CUSTOM_ELEMENTS; i++)
3207 int element = EL_CUSTOM_START + i;
3208 struct ElementInfo *ei = &element_info[element];
3210 for (j = 0; j < ei->num_change_pages; j++)
3212 int trigger_element = ei->change_page[j].initial_trigger_element;
3214 if (trigger_element >= EL_PREV_CE_8 &&
3215 trigger_element <= EL_NEXT_CE_8)
3216 trigger_element = RESOLVED_REFERENCE_ELEMENT(element, trigger_element);
3218 ei->change_page[j].trigger_element = trigger_element;
3222 // ---------- initialize run-time trigger player and element ----------------
3224 for (i = 0; i < NUM_CUSTOM_ELEMENTS; i++)
3226 struct ElementInfo *ei = &element_info[EL_CUSTOM_START + i];
3228 for (j = 0; j < ei->num_change_pages; j++)
3230 ei->change_page[j].actual_trigger_element = EL_EMPTY;
3231 ei->change_page[j].actual_trigger_player = EL_EMPTY;
3232 ei->change_page[j].actual_trigger_player_bits = CH_PLAYER_NONE;
3233 ei->change_page[j].actual_trigger_side = CH_SIDE_NONE;
3234 ei->change_page[j].actual_trigger_ce_value = 0;
3235 ei->change_page[j].actual_trigger_ce_score = 0;
3239 // ---------- initialize trigger events -------------------------------------
3241 // initialize trigger events information
3242 for (i = 0; i < MAX_NUM_ELEMENTS; i++)
3243 for (j = 0; j < NUM_CHANGE_EVENTS; j++)
3244 trigger_events[i][j] = FALSE;
3246 // add trigger events from element change event properties
3247 for (i = 0; i < MAX_NUM_ELEMENTS; i++)
3249 struct ElementInfo *ei = &element_info[i];
3251 for (j = 0; j < ei->num_change_pages; j++)
3253 if (!ei->change_page[j].can_change_or_has_action)
3256 if (ei->change_page[j].has_event[CE_BY_OTHER_ACTION])
3258 int trigger_element = ei->change_page[j].trigger_element;
3260 for (k = 0; k < NUM_CHANGE_EVENTS; k++)
3262 if (ei->change_page[j].has_event[k])
3264 if (IS_GROUP_ELEMENT(trigger_element))
3266 struct ElementGroupInfo *group =
3267 element_info[trigger_element].group;
3269 for (l = 0; l < group->num_elements_resolved; l++)
3270 trigger_events[group->element_resolved[l]][k] = TRUE;
3272 else if (trigger_element == EL_ANY_ELEMENT)
3273 for (l = 0; l < MAX_NUM_ELEMENTS; l++)
3274 trigger_events[l][k] = TRUE;
3276 trigger_events[trigger_element][k] = TRUE;
3283 // ---------- initialize push delay -----------------------------------------
3285 // initialize push delay values to default
3286 for (i = 0; i < MAX_NUM_ELEMENTS; i++)
3288 if (!IS_CUSTOM_ELEMENT(i))
3290 // set default push delay values (corrected since version 3.0.7-1)
3291 if (game.engine_version < VERSION_IDENT(3,0,7,1))
3293 element_info[i].push_delay_fixed = 2;
3294 element_info[i].push_delay_random = 8;
3298 element_info[i].push_delay_fixed = 8;
3299 element_info[i].push_delay_random = 8;
3304 // set push delay value for certain elements from pre-defined list
3305 for (i = 0; push_delay_list[i].element != EL_UNDEFINED; i++)
3307 int e = push_delay_list[i].element;
3309 element_info[e].push_delay_fixed = push_delay_list[i].push_delay_fixed;
3310 element_info[e].push_delay_random = push_delay_list[i].push_delay_random;
3313 // set push delay value for Supaplex elements for newer engine versions
3314 if (game.engine_version >= VERSION_IDENT(3,1,0,0))
3316 for (i = 0; i < MAX_NUM_ELEMENTS; i++)
3318 if (IS_SP_ELEMENT(i))
3320 // set SP push delay to just enough to push under a falling zonk
3321 int delay = (game.engine_version >= VERSION_IDENT(3,1,1,0) ? 8 : 6);
3323 element_info[i].push_delay_fixed = delay;
3324 element_info[i].push_delay_random = 0;
3329 // ---------- initialize move stepsize --------------------------------------
3331 // initialize move stepsize values to default
3332 for (i = 0; i < MAX_NUM_ELEMENTS; i++)
3333 if (!IS_CUSTOM_ELEMENT(i))
3334 element_info[i].move_stepsize = MOVE_STEPSIZE_NORMAL;
3336 // set move stepsize value for certain elements from pre-defined list
3337 for (i = 0; move_stepsize_list[i].element != EL_UNDEFINED; i++)
3339 int e = move_stepsize_list[i].element;
3341 element_info[e].move_stepsize = move_stepsize_list[i].move_stepsize;
3343 // set move stepsize value for certain elements for older engine versions
3344 if (use_old_move_stepsize_for_magic_wall)
3346 if (e == EL_MAGIC_WALL_FILLING ||
3347 e == EL_MAGIC_WALL_EMPTYING ||
3348 e == EL_BD_MAGIC_WALL_FILLING ||
3349 e == EL_BD_MAGIC_WALL_EMPTYING)
3350 element_info[e].move_stepsize *= 2;
3354 // ---------- initialize collect score --------------------------------------
3356 // initialize collect score values for custom elements from initial value
3357 for (i = 0; i < MAX_NUM_ELEMENTS; i++)
3358 if (IS_CUSTOM_ELEMENT(i))
3359 element_info[i].collect_score = element_info[i].collect_score_initial;
3361 // ---------- initialize collect count --------------------------------------
3363 // initialize collect count values for non-custom elements
3364 for (i = 0; i < MAX_NUM_ELEMENTS; i++)
3365 if (!IS_CUSTOM_ELEMENT(i))
3366 element_info[i].collect_count_initial = 0;
3368 // add collect count values for all elements from pre-defined list
3369 for (i = 0; collect_count_list[i].element != EL_UNDEFINED; i++)
3370 element_info[collect_count_list[i].element].collect_count_initial =
3371 collect_count_list[i].count;
3373 // ---------- initialize access direction -----------------------------------
3375 // initialize access direction values to default (access from every side)
3376 for (i = 0; i < MAX_NUM_ELEMENTS; i++)
3377 if (!IS_CUSTOM_ELEMENT(i))
3378 element_info[i].access_direction = MV_ALL_DIRECTIONS;
3380 // set access direction value for certain elements from pre-defined list
3381 for (i = 0; access_direction_list[i].element != EL_UNDEFINED; i++)
3382 element_info[access_direction_list[i].element].access_direction =
3383 access_direction_list[i].direction;
3385 // ---------- initialize explosion content ----------------------------------
3386 for (i = 0; i < MAX_NUM_ELEMENTS; i++)
3388 if (IS_CUSTOM_ELEMENT(i))
3391 for (y = 0; y < 3; y++) for (x = 0; x < 3; x++)
3393 // (content for EL_YAMYAM set at run-time with game.yamyam_content_nr)
3395 element_info[i].content.e[x][y] =
3396 (i == EL_PLAYER_1 ? EL_EMERALD_YELLOW :
3397 i == EL_PLAYER_2 ? EL_EMERALD_RED :
3398 i == EL_PLAYER_3 ? EL_EMERALD :
3399 i == EL_PLAYER_4 ? EL_EMERALD_PURPLE :
3400 i == EL_MOLE ? EL_EMERALD_RED :
3401 i == EL_PENGUIN ? EL_EMERALD_PURPLE :
3402 i == EL_BUG ? (x == 1 && y == 1 ? EL_DIAMOND : EL_EMERALD) :
3403 i == EL_BD_BUTTERFLY ? EL_BD_DIAMOND :
3404 i == EL_SP_ELECTRON ? EL_SP_INFOTRON :
3405 i == EL_AMOEBA_TO_DIAMOND ? level.amoeba_content :
3406 i == EL_WALL_EMERALD ? EL_EMERALD :
3407 i == EL_WALL_DIAMOND ? EL_DIAMOND :
3408 i == EL_WALL_BD_DIAMOND ? EL_BD_DIAMOND :
3409 i == EL_WALL_EMERALD_YELLOW ? EL_EMERALD_YELLOW :
3410 i == EL_WALL_EMERALD_RED ? EL_EMERALD_RED :
3411 i == EL_WALL_EMERALD_PURPLE ? EL_EMERALD_PURPLE :
3412 i == EL_WALL_PEARL ? EL_PEARL :
3413 i == EL_WALL_CRYSTAL ? EL_CRYSTAL :
3418 // ---------- initialize recursion detection --------------------------------
3419 recursion_loop_depth = 0;
3420 recursion_loop_detected = FALSE;
3421 recursion_loop_element = EL_UNDEFINED;
3423 // ---------- initialize graphics engine ------------------------------------
3424 game.scroll_delay_value =
3425 (game.forced_scroll_delay_value != -1 ? game.forced_scroll_delay_value :
3426 level.game_engine_type == GAME_ENGINE_TYPE_EM &&
3427 !setup.forced_scroll_delay ? 0 :
3428 setup.scroll_delay ? setup.scroll_delay_value : 0);
3429 game.scroll_delay_value =
3430 MIN(MAX(MIN_SCROLL_DELAY, game.scroll_delay_value), MAX_SCROLL_DELAY);
3432 // ---------- initialize game engine snapshots ------------------------------
3433 for (i = 0; i < MAX_PLAYERS; i++)
3434 game.snapshot.last_action[i] = 0;
3435 game.snapshot.changed_action = FALSE;
3436 game.snapshot.collected_item = FALSE;
3437 game.snapshot.mode =
3438 (strEqual(setup.engine_snapshot_mode, STR_SNAPSHOT_MODE_EVERY_STEP) ?
3439 SNAPSHOT_MODE_EVERY_STEP :
3440 strEqual(setup.engine_snapshot_mode, STR_SNAPSHOT_MODE_EVERY_MOVE) ?
3441 SNAPSHOT_MODE_EVERY_MOVE :
3442 strEqual(setup.engine_snapshot_mode, STR_SNAPSHOT_MODE_EVERY_COLLECT) ?
3443 SNAPSHOT_MODE_EVERY_COLLECT : SNAPSHOT_MODE_OFF);
3444 game.snapshot.save_snapshot = FALSE;
3446 // ---------- initialize level time for Supaplex engine ---------------------
3447 // Supaplex levels with time limit currently unsupported -- should be added
3448 if (level.game_engine_type == GAME_ENGINE_TYPE_SP)
3451 // ---------- initialize flags for handling game actions --------------------
3453 // set flags for game actions to default values
3454 game.use_key_actions = TRUE;
3455 game.use_mouse_actions = FALSE;
3457 // when using Mirror Magic game engine, handle mouse events only
3458 if (level.game_engine_type == GAME_ENGINE_TYPE_MM)
3460 game.use_key_actions = FALSE;
3461 game.use_mouse_actions = TRUE;
3464 // check for custom elements with mouse click events
3465 if (level.game_engine_type == GAME_ENGINE_TYPE_RND)
3467 for (i = 0; i < NUM_CUSTOM_ELEMENTS; i++)
3469 int element = EL_CUSTOM_START + i;
3471 if (HAS_CHANGE_EVENT(element, CE_CLICKED_BY_MOUSE) ||
3472 HAS_CHANGE_EVENT(element, CE_PRESSED_BY_MOUSE) ||
3473 HAS_CHANGE_EVENT(element, CE_MOUSE_CLICKED_ON_X) ||
3474 HAS_CHANGE_EVENT(element, CE_MOUSE_PRESSED_ON_X))
3475 game.use_mouse_actions = TRUE;
3480 static int get_num_special_action(int element, int action_first,
3483 int num_special_action = 0;
3486 for (i = action_first; i <= action_last; i++)
3488 boolean found = FALSE;
3490 for (j = 0; j < NUM_DIRECTIONS; j++)
3491 if (el_act_dir2img(element, i, j) !=
3492 el_act_dir2img(element, ACTION_DEFAULT, j))
3496 num_special_action++;
3501 return num_special_action;
3505 // ============================================================================
3507 // ----------------------------------------------------------------------------
3508 // initialize and start new game
3509 // ============================================================================
3511 #if DEBUG_INIT_PLAYER
3512 static void DebugPrintPlayerStatus(char *message)
3519 Debug("game:init:player", "%s:", message);
3521 for (i = 0; i < MAX_PLAYERS; i++)
3523 struct PlayerInfo *player = &stored_player[i];
3525 Debug("game:init:player",
3526 "- player %d: present == %d, connected == %d [%d/%d], active == %d%s",
3530 player->connected_locally,
3531 player->connected_network,
3533 (local_player == player ? " (local player)" : ""));
3540 int full_lev_fieldx = lev_fieldx + (BorderElement != EL_EMPTY ? 2 : 0);
3541 int full_lev_fieldy = lev_fieldy + (BorderElement != EL_EMPTY ? 2 : 0);
3542 int fade_mask = REDRAW_FIELD;
3544 boolean emulate_bd = TRUE; // unless non-BOULDERDASH elements found
3545 boolean emulate_sb = TRUE; // unless non-SOKOBAN elements found
3546 boolean emulate_sp = TRUE; // unless non-SUPAPLEX elements found
3547 int initial_move_dir = MV_DOWN;
3550 // required here to update video display before fading (FIX THIS)
3551 DrawMaskedBorder(REDRAW_DOOR_2);
3553 if (!game.restart_level)
3554 CloseDoor(DOOR_CLOSE_1);
3556 SetGameStatus(GAME_MODE_PLAYING);
3558 if (level_editor_test_game)
3559 FadeSkipNextFadeOut();
3561 FadeSetEnterScreen();
3564 fade_mask = REDRAW_ALL;
3566 FadeLevelSoundsAndMusic();
3568 ExpireSoundLoops(TRUE);
3572 if (level_editor_test_game)
3573 FadeSkipNextFadeIn();
3575 // needed if different viewport properties defined for playing
3576 ChangeViewportPropertiesIfNeeded();
3580 DrawCompleteVideoDisplay();
3582 OpenDoor(GetDoorState() | DOOR_NO_DELAY | DOOR_FORCE_REDRAW);
3585 InitGameControlValues();
3589 // initialize tape actions from game when recording tape
3590 tape.use_key_actions = game.use_key_actions;
3591 tape.use_mouse_actions = game.use_mouse_actions;
3593 // initialize visible playfield size when recording tape (for team mode)
3594 tape.scr_fieldx = SCR_FIELDX;
3595 tape.scr_fieldy = SCR_FIELDY;
3598 // don't play tapes over network
3599 network_playing = (network.enabled && !tape.playing);
3601 for (i = 0; i < MAX_PLAYERS; i++)
3603 struct PlayerInfo *player = &stored_player[i];
3605 player->index_nr = i;
3606 player->index_bit = (1 << i);
3607 player->element_nr = EL_PLAYER_1 + i;
3609 player->present = FALSE;
3610 player->active = FALSE;
3611 player->mapped = FALSE;
3613 player->killed = FALSE;
3614 player->reanimated = FALSE;
3615 player->buried = FALSE;
3618 player->effective_action = 0;
3619 player->programmed_action = 0;
3620 player->snap_action = 0;
3622 player->mouse_action.lx = 0;
3623 player->mouse_action.ly = 0;
3624 player->mouse_action.button = 0;
3625 player->mouse_action.button_hint = 0;
3627 player->effective_mouse_action.lx = 0;
3628 player->effective_mouse_action.ly = 0;
3629 player->effective_mouse_action.button = 0;
3630 player->effective_mouse_action.button_hint = 0;
3632 for (j = 0; j < MAX_NUM_KEYS; j++)
3633 player->key[j] = FALSE;
3635 player->num_white_keys = 0;
3637 player->dynabomb_count = 0;
3638 player->dynabomb_size = 1;
3639 player->dynabombs_left = 0;
3640 player->dynabomb_xl = FALSE;
3642 player->MovDir = initial_move_dir;
3645 player->GfxDir = initial_move_dir;
3646 player->GfxAction = ACTION_DEFAULT;
3648 player->StepFrame = 0;
3650 player->initial_element = player->element_nr;
3651 player->artwork_element =
3652 (level.use_artwork_element[i] ? level.artwork_element[i] :
3653 player->element_nr);
3654 player->use_murphy = FALSE;
3656 player->block_last_field = FALSE; // initialized in InitPlayerField()
3657 player->block_delay_adjustment = 0; // initialized in InitPlayerField()
3659 player->gravity = level.initial_player_gravity[i];
3661 player->can_fall_into_acid = CAN_MOVE_INTO_ACID(player->element_nr);
3663 player->actual_frame_counter = 0;
3665 player->step_counter = 0;
3667 player->last_move_dir = initial_move_dir;
3669 player->is_active = FALSE;
3671 player->is_waiting = FALSE;
3672 player->is_moving = FALSE;
3673 player->is_auto_moving = FALSE;
3674 player->is_digging = FALSE;
3675 player->is_snapping = FALSE;
3676 player->is_collecting = FALSE;
3677 player->is_pushing = FALSE;
3678 player->is_switching = FALSE;
3679 player->is_dropping = FALSE;
3680 player->is_dropping_pressed = FALSE;
3682 player->is_bored = FALSE;
3683 player->is_sleeping = FALSE;
3685 player->was_waiting = TRUE;
3686 player->was_moving = FALSE;
3687 player->was_snapping = FALSE;
3688 player->was_dropping = FALSE;
3690 player->force_dropping = FALSE;
3692 player->frame_counter_bored = -1;
3693 player->frame_counter_sleeping = -1;
3695 player->anim_delay_counter = 0;
3696 player->post_delay_counter = 0;
3698 player->dir_waiting = initial_move_dir;
3699 player->action_waiting = ACTION_DEFAULT;
3700 player->last_action_waiting = ACTION_DEFAULT;
3701 player->special_action_bored = ACTION_DEFAULT;
3702 player->special_action_sleeping = ACTION_DEFAULT;
3704 player->switch_x = -1;
3705 player->switch_y = -1;
3707 player->drop_x = -1;
3708 player->drop_y = -1;
3710 player->show_envelope = 0;
3712 SetPlayerMoveSpeed(player, level.initial_player_stepsize[i], TRUE);
3714 player->push_delay = -1; // initialized when pushing starts
3715 player->push_delay_value = game.initial_push_delay_value;
3717 player->drop_delay = 0;
3718 player->drop_pressed_delay = 0;
3720 player->last_jx = -1;
3721 player->last_jy = -1;
3725 player->shield_normal_time_left = 0;
3726 player->shield_deadly_time_left = 0;
3728 player->last_removed_element = EL_UNDEFINED;
3730 player->inventory_infinite_element = EL_UNDEFINED;
3731 player->inventory_size = 0;
3733 if (level.use_initial_inventory[i])
3735 for (j = 0; j < level.initial_inventory_size[i]; j++)
3737 int element = level.initial_inventory_content[i][j];
3738 int collect_count = element_info[element].collect_count_initial;
3741 if (!IS_CUSTOM_ELEMENT(element))
3744 if (collect_count == 0)
3745 player->inventory_infinite_element = element;
3747 for (k = 0; k < collect_count; k++)
3748 if (player->inventory_size < MAX_INVENTORY_SIZE)
3749 player->inventory_element[player->inventory_size++] = element;
3753 DigField(player, 0, 0, 0, 0, 0, 0, DF_NO_PUSH);
3754 SnapField(player, 0, 0);
3756 map_player_action[i] = i;
3759 network_player_action_received = FALSE;
3761 // initial null action
3762 if (network_playing)
3763 SendToServer_MovePlayer(MV_NONE);
3768 TimeLeft = level.time;
3771 ScreenMovDir = MV_NONE;
3775 ScrollStepSize = 0; // will be correctly initialized by ScrollScreen()
3777 game.robot_wheel_x = -1;
3778 game.robot_wheel_y = -1;
3783 game.all_players_gone = FALSE;
3785 game.LevelSolved = FALSE;
3786 game.GameOver = FALSE;
3788 game.GamePlayed = !tape.playing;
3790 game.LevelSolved_GameWon = FALSE;
3791 game.LevelSolved_GameEnd = FALSE;
3792 game.LevelSolved_SaveTape = FALSE;
3793 game.LevelSolved_SaveScore = FALSE;
3795 game.LevelSolved_CountingTime = 0;
3796 game.LevelSolved_CountingScore = 0;
3797 game.LevelSolved_CountingHealth = 0;
3799 game.panel.active = TRUE;
3801 game.no_time_limit = (level.time == 0);
3803 game.yamyam_content_nr = 0;
3804 game.robot_wheel_active = FALSE;
3805 game.magic_wall_active = FALSE;
3806 game.magic_wall_time_left = 0;
3807 game.light_time_left = 0;
3808 game.timegate_time_left = 0;
3809 game.switchgate_pos = 0;
3810 game.wind_direction = level.wind_direction_initial;
3812 game.time_final = 0;
3813 game.score_time_final = 0;
3816 game.score_final = 0;
3818 game.health = MAX_HEALTH;
3819 game.health_final = MAX_HEALTH;
3821 game.gems_still_needed = level.gems_needed;
3822 game.sokoban_fields_still_needed = 0;
3823 game.sokoban_objects_still_needed = 0;
3824 game.lights_still_needed = 0;
3825 game.players_still_needed = 0;
3826 game.friends_still_needed = 0;
3828 game.lenses_time_left = 0;
3829 game.magnify_time_left = 0;
3831 game.ball_active = level.ball_active_initial;
3832 game.ball_content_nr = 0;
3834 game.explosions_delayed = TRUE;
3836 game.envelope_active = FALSE;
3838 for (i = 0; i < NUM_BELTS; i++)
3840 game.belt_dir[i] = MV_NONE;
3841 game.belt_dir_nr[i] = 3; // not moving, next moving left
3844 for (i = 0; i < MAX_NUM_AMOEBA; i++)
3845 AmoebaCnt[i] = AmoebaCnt2[i] = 0;
3847 #if DEBUG_INIT_PLAYER
3848 DebugPrintPlayerStatus("Player status at level initialization");
3851 SCAN_PLAYFIELD(x, y)
3853 Tile[x][y] = Last[x][y] = level.field[x][y];
3854 MovPos[x][y] = MovDir[x][y] = MovDelay[x][y] = 0;
3855 ChangeDelay[x][y] = 0;
3856 ChangePage[x][y] = -1;
3857 CustomValue[x][y] = 0; // initialized in InitField()
3858 Store[x][y] = Store2[x][y] = StorePlayer[x][y] = Back[x][y] = 0;
3860 WasJustMoving[x][y] = 0;
3861 WasJustFalling[x][y] = 0;
3862 CheckCollision[x][y] = 0;
3863 CheckImpact[x][y] = 0;
3865 Pushed[x][y] = FALSE;
3867 ChangeCount[x][y] = 0;
3868 ChangeEvent[x][y] = -1;
3870 ExplodePhase[x][y] = 0;
3871 ExplodeDelay[x][y] = 0;
3872 ExplodeField[x][y] = EX_TYPE_NONE;
3874 RunnerVisit[x][y] = 0;
3875 PlayerVisit[x][y] = 0;
3878 GfxRandom[x][y] = INIT_GFX_RANDOM();
3879 GfxElement[x][y] = EL_UNDEFINED;
3880 GfxAction[x][y] = ACTION_DEFAULT;
3881 GfxDir[x][y] = MV_NONE;
3882 GfxRedraw[x][y] = GFX_REDRAW_NONE;
3885 SCAN_PLAYFIELD(x, y)
3887 if (emulate_bd && !IS_BD_ELEMENT(Tile[x][y]))
3889 if (emulate_sb && !IS_SB_ELEMENT(Tile[x][y]))
3891 if (emulate_sp && !IS_SP_ELEMENT(Tile[x][y]))
3894 InitField(x, y, TRUE);
3896 ResetGfxAnimation(x, y);
3901 for (i = 0; i < MAX_PLAYERS; i++)
3903 struct PlayerInfo *player = &stored_player[i];
3905 // set number of special actions for bored and sleeping animation
3906 player->num_special_action_bored =
3907 get_num_special_action(player->artwork_element,
3908 ACTION_BORING_1, ACTION_BORING_LAST);
3909 player->num_special_action_sleeping =
3910 get_num_special_action(player->artwork_element,
3911 ACTION_SLEEPING_1, ACTION_SLEEPING_LAST);
3914 game.emulation = (emulate_bd ? EMU_BOULDERDASH :
3915 emulate_sb ? EMU_SOKOBAN :
3916 emulate_sp ? EMU_SUPAPLEX : EMU_NONE);
3918 // initialize type of slippery elements
3919 for (i = 0; i < MAX_NUM_ELEMENTS; i++)
3921 if (!IS_CUSTOM_ELEMENT(i))
3923 // default: elements slip down either to the left or right randomly
3924 element_info[i].slippery_type = SLIPPERY_ANY_RANDOM;
3926 // SP style elements prefer to slip down on the left side
3927 if (game.engine_version >= VERSION_IDENT(3,1,1,0) && IS_SP_ELEMENT(i))
3928 element_info[i].slippery_type = SLIPPERY_ANY_LEFT_RIGHT;
3930 // BD style elements prefer to slip down on the left side
3931 if (game.emulation == EMU_BOULDERDASH)
3932 element_info[i].slippery_type = SLIPPERY_ANY_LEFT_RIGHT;
3936 // initialize explosion and ignition delay
3937 for (i = 0; i < MAX_NUM_ELEMENTS; i++)
3939 if (!IS_CUSTOM_ELEMENT(i))
3942 int delay = (((IS_SP_ELEMENT(i) && i != EL_EMPTY_SPACE) &&
3943 game.engine_version >= VERSION_IDENT(3,1,0,0)) ||
3944 game.emulation == EMU_SUPAPLEX ? 3 : 2);
3945 int last_phase = (num_phase + 1) * delay;
3946 int half_phase = (num_phase / 2) * delay;
3948 element_info[i].explosion_delay = last_phase - 1;
3949 element_info[i].ignition_delay = half_phase;
3951 if (i == EL_BLACK_ORB)
3952 element_info[i].ignition_delay = 1;
3956 // correct non-moving belts to start moving left
3957 for (i = 0; i < NUM_BELTS; i++)
3958 if (game.belt_dir[i] == MV_NONE)
3959 game.belt_dir_nr[i] = 3; // not moving, next moving left
3961 #if USE_NEW_PLAYER_ASSIGNMENTS
3962 // use preferred player also in local single-player mode
3963 if (!network.enabled && !game.team_mode)
3965 int new_index_nr = setup.network_player_nr;
3967 if (new_index_nr >= 0 && new_index_nr < MAX_PLAYERS)
3969 for (i = 0; i < MAX_PLAYERS; i++)
3970 stored_player[i].connected_locally = FALSE;
3972 stored_player[new_index_nr].connected_locally = TRUE;
3976 for (i = 0; i < MAX_PLAYERS; i++)
3978 stored_player[i].connected = FALSE;
3980 // in network game mode, the local player might not be the first player
3981 if (stored_player[i].connected_locally)
3982 local_player = &stored_player[i];
3985 if (!network.enabled)
3986 local_player->connected = TRUE;
3990 for (i = 0; i < MAX_PLAYERS; i++)
3991 stored_player[i].connected = tape.player_participates[i];
3993 else if (network.enabled)
3995 // add team mode players connected over the network (needed for correct
3996 // assignment of player figures from level to locally playing players)
3998 for (i = 0; i < MAX_PLAYERS; i++)
3999 if (stored_player[i].connected_network)
4000 stored_player[i].connected = TRUE;
4002 else if (game.team_mode)
4004 // try to guess locally connected team mode players (needed for correct
4005 // assignment of player figures from level to locally playing players)
4007 for (i = 0; i < MAX_PLAYERS; i++)
4008 if (setup.input[i].use_joystick ||
4009 setup.input[i].key.left != KSYM_UNDEFINED)
4010 stored_player[i].connected = TRUE;
4013 #if DEBUG_INIT_PLAYER
4014 DebugPrintPlayerStatus("Player status after level initialization");
4017 #if DEBUG_INIT_PLAYER
4018 Debug("game:init:player", "Reassigning players ...");
4021 // check if any connected player was not found in playfield
4022 for (i = 0; i < MAX_PLAYERS; i++)
4024 struct PlayerInfo *player = &stored_player[i];
4026 if (player->connected && !player->present)
4028 struct PlayerInfo *field_player = NULL;
4030 #if DEBUG_INIT_PLAYER
4031 Debug("game:init:player",
4032 "- looking for field player for player %d ...", i + 1);
4035 // assign first free player found that is present in the playfield
4037 // first try: look for unmapped playfield player that is not connected
4038 for (j = 0; j < MAX_PLAYERS; j++)
4039 if (field_player == NULL &&
4040 stored_player[j].present &&
4041 !stored_player[j].mapped &&
4042 !stored_player[j].connected)
4043 field_player = &stored_player[j];
4045 // second try: look for *any* unmapped playfield player
4046 for (j = 0; j < MAX_PLAYERS; j++)
4047 if (field_player == NULL &&
4048 stored_player[j].present &&
4049 !stored_player[j].mapped)
4050 field_player = &stored_player[j];
4052 if (field_player != NULL)
4054 int jx = field_player->jx, jy = field_player->jy;
4056 #if DEBUG_INIT_PLAYER
4057 Debug("game:init:player", "- found player %d",
4058 field_player->index_nr + 1);
4061 player->present = FALSE;
4062 player->active = FALSE;
4064 field_player->present = TRUE;
4065 field_player->active = TRUE;
4068 player->initial_element = field_player->initial_element;
4069 player->artwork_element = field_player->artwork_element;
4071 player->block_last_field = field_player->block_last_field;
4072 player->block_delay_adjustment = field_player->block_delay_adjustment;
4075 StorePlayer[jx][jy] = field_player->element_nr;
4077 field_player->jx = field_player->last_jx = jx;
4078 field_player->jy = field_player->last_jy = jy;
4080 if (local_player == player)
4081 local_player = field_player;
4083 map_player_action[field_player->index_nr] = i;
4085 field_player->mapped = TRUE;
4087 #if DEBUG_INIT_PLAYER
4088 Debug("game:init:player", "- map_player_action[%d] == %d",
4089 field_player->index_nr + 1, i + 1);
4094 if (player->connected && player->present)
4095 player->mapped = TRUE;
4098 #if DEBUG_INIT_PLAYER
4099 DebugPrintPlayerStatus("Player status after player assignment (first stage)");
4104 // check if any connected player was not found in playfield
4105 for (i = 0; i < MAX_PLAYERS; i++)
4107 struct PlayerInfo *player = &stored_player[i];
4109 if (player->connected && !player->present)
4111 for (j = 0; j < MAX_PLAYERS; j++)
4113 struct PlayerInfo *field_player = &stored_player[j];
4114 int jx = field_player->jx, jy = field_player->jy;
4116 // assign first free player found that is present in the playfield
4117 if (field_player->present && !field_player->connected)
4119 player->present = TRUE;
4120 player->active = TRUE;
4122 field_player->present = FALSE;
4123 field_player->active = FALSE;
4125 player->initial_element = field_player->initial_element;
4126 player->artwork_element = field_player->artwork_element;
4128 player->block_last_field = field_player->block_last_field;
4129 player->block_delay_adjustment = field_player->block_delay_adjustment;
4131 StorePlayer[jx][jy] = player->element_nr;
4133 player->jx = player->last_jx = jx;
4134 player->jy = player->last_jy = jy;
4144 Debug("game:init:player", "local_player->present == %d",
4145 local_player->present);
4148 // set focus to local player for network games, else to all players
4149 game.centered_player_nr = (network_playing ? local_player->index_nr : -1);
4150 game.centered_player_nr_next = game.centered_player_nr;
4151 game.set_centered_player = FALSE;
4152 game.set_centered_player_wrap = FALSE;
4154 if (network_playing && tape.recording)
4156 // store client dependent player focus when recording network games
4157 tape.centered_player_nr_next = game.centered_player_nr_next;
4158 tape.set_centered_player = TRUE;
4163 // when playing a tape, eliminate all players who do not participate
4165 #if USE_NEW_PLAYER_ASSIGNMENTS
4167 if (!game.team_mode)
4169 for (i = 0; i < MAX_PLAYERS; i++)
4171 if (stored_player[i].active &&
4172 !tape.player_participates[map_player_action[i]])
4174 struct PlayerInfo *player = &stored_player[i];
4175 int jx = player->jx, jy = player->jy;
4177 #if DEBUG_INIT_PLAYER
4178 Debug("game:init:player", "Removing player %d at (%d, %d)",
4182 player->active = FALSE;
4183 StorePlayer[jx][jy] = 0;
4184 Tile[jx][jy] = EL_EMPTY;
4191 for (i = 0; i < MAX_PLAYERS; i++)
4193 if (stored_player[i].active &&
4194 !tape.player_participates[i])
4196 struct PlayerInfo *player = &stored_player[i];
4197 int jx = player->jx, jy = player->jy;
4199 player->active = FALSE;
4200 StorePlayer[jx][jy] = 0;
4201 Tile[jx][jy] = EL_EMPTY;
4206 else if (!network.enabled && !game.team_mode) // && !tape.playing
4208 // when in single player mode, eliminate all but the local player
4210 for (i = 0; i < MAX_PLAYERS; i++)
4212 struct PlayerInfo *player = &stored_player[i];
4214 if (player->active && player != local_player)
4216 int jx = player->jx, jy = player->jy;
4218 player->active = FALSE;
4219 player->present = FALSE;
4221 StorePlayer[jx][jy] = 0;
4222 Tile[jx][jy] = EL_EMPTY;
4227 for (i = 0; i < MAX_PLAYERS; i++)
4228 if (stored_player[i].active)
4229 game.players_still_needed++;
4231 if (level.solved_by_one_player)
4232 game.players_still_needed = 1;
4234 // when recording the game, store which players take part in the game
4237 #if USE_NEW_PLAYER_ASSIGNMENTS
4238 for (i = 0; i < MAX_PLAYERS; i++)
4239 if (stored_player[i].connected)
4240 tape.player_participates[i] = TRUE;
4242 for (i = 0; i < MAX_PLAYERS; i++)
4243 if (stored_player[i].active)
4244 tape.player_participates[i] = TRUE;
4248 #if DEBUG_INIT_PLAYER
4249 DebugPrintPlayerStatus("Player status after player assignment (final stage)");
4252 if (BorderElement == EL_EMPTY)
4255 SBX_Right = lev_fieldx - SCR_FIELDX;
4257 SBY_Lower = lev_fieldy - SCR_FIELDY;
4262 SBX_Right = lev_fieldx - SCR_FIELDX + 1;
4264 SBY_Lower = lev_fieldy - SCR_FIELDY + 1;
4267 if (full_lev_fieldx <= SCR_FIELDX)
4268 SBX_Left = SBX_Right = -1 * (SCR_FIELDX - lev_fieldx) / 2;
4269 if (full_lev_fieldy <= SCR_FIELDY)
4270 SBY_Upper = SBY_Lower = -1 * (SCR_FIELDY - lev_fieldy) / 2;
4272 if (EVEN(SCR_FIELDX) && full_lev_fieldx > SCR_FIELDX)
4274 if (EVEN(SCR_FIELDY) && full_lev_fieldy > SCR_FIELDY)
4277 // if local player not found, look for custom element that might create
4278 // the player (make some assumptions about the right custom element)
4279 if (!local_player->present)
4281 int start_x = 0, start_y = 0;
4282 int found_rating = 0;
4283 int found_element = EL_UNDEFINED;
4284 int player_nr = local_player->index_nr;
4286 SCAN_PLAYFIELD(x, y)
4288 int element = Tile[x][y];
4293 if (level.use_start_element[player_nr] &&
4294 level.start_element[player_nr] == element &&
4301 found_element = element;
4304 if (!IS_CUSTOM_ELEMENT(element))
4307 if (CAN_CHANGE(element))
4309 for (i = 0; i < element_info[element].num_change_pages; i++)
4311 // check for player created from custom element as single target
4312 content = element_info[element].change_page[i].target_element;
4313 is_player = ELEM_IS_PLAYER(content);
4315 if (is_player && (found_rating < 3 ||
4316 (found_rating == 3 && element < found_element)))
4322 found_element = element;
4327 for (yy = 0; yy < 3; yy++) for (xx = 0; xx < 3; xx++)
4329 // check for player created from custom element as explosion content
4330 content = element_info[element].content.e[xx][yy];
4331 is_player = ELEM_IS_PLAYER(content);
4333 if (is_player && (found_rating < 2 ||
4334 (found_rating == 2 && element < found_element)))
4336 start_x = x + xx - 1;
4337 start_y = y + yy - 1;
4340 found_element = element;
4343 if (!CAN_CHANGE(element))
4346 for (i = 0; i < element_info[element].num_change_pages; i++)
4348 // check for player created from custom element as extended target
4350 element_info[element].change_page[i].target_content.e[xx][yy];
4352 is_player = ELEM_IS_PLAYER(content);
4354 if (is_player && (found_rating < 1 ||
4355 (found_rating == 1 && element < found_element)))
4357 start_x = x + xx - 1;
4358 start_y = y + yy - 1;
4361 found_element = element;
4367 scroll_x = SCROLL_POSITION_X(start_x);
4368 scroll_y = SCROLL_POSITION_Y(start_y);
4372 scroll_x = SCROLL_POSITION_X(local_player->jx);
4373 scroll_y = SCROLL_POSITION_Y(local_player->jy);
4376 // !!! FIX THIS (START) !!!
4377 if (level.game_engine_type == GAME_ENGINE_TYPE_EM)
4379 InitGameEngine_EM();
4381 else if (level.game_engine_type == GAME_ENGINE_TYPE_SP)
4383 InitGameEngine_SP();
4385 else if (level.game_engine_type == GAME_ENGINE_TYPE_MM)
4387 InitGameEngine_MM();
4391 DrawLevel(REDRAW_FIELD);
4394 // after drawing the level, correct some elements
4395 if (game.timegate_time_left == 0)
4396 CloseAllOpenTimegates();
4399 // blit playfield from scroll buffer to normal back buffer for fading in
4400 BlitScreenToBitmap(backbuffer);
4401 // !!! FIX THIS (END) !!!
4403 DrawMaskedBorder(fade_mask);
4408 // full screen redraw is required at this point in the following cases:
4409 // - special editor door undrawn when game was started from level editor
4410 // - drawing area (playfield) was changed and has to be removed completely
4411 redraw_mask = REDRAW_ALL;
4415 if (!game.restart_level)
4417 // copy default game door content to main double buffer
4419 // !!! CHECK AGAIN !!!
4420 SetPanelBackground();
4421 // SetDoorBackgroundImage(IMG_BACKGROUND_PANEL);
4422 DrawBackground(DX, DY, DXSIZE, DYSIZE);
4425 SetPanelBackground();
4426 SetDrawBackgroundMask(REDRAW_DOOR_1);
4428 UpdateAndDisplayGameControlValues();
4430 if (!game.restart_level)
4436 CreateGameButtons();
4441 // copy actual game door content to door double buffer for OpenDoor()
4442 BlitBitmap(drawto, bitmap_db_door_1, DX, DY, DXSIZE, DYSIZE, 0, 0);
4444 OpenDoor(DOOR_OPEN_ALL);
4446 KeyboardAutoRepeatOffUnlessAutoplay();
4448 #if DEBUG_INIT_PLAYER
4449 DebugPrintPlayerStatus("Player status (final)");
4458 if (!game.restart_level && !tape.playing)
4460 LevelStats_incPlayed(level_nr);
4462 SaveLevelSetup_SeriesInfo();
4465 game.restart_level = FALSE;
4466 game.restart_game_message = NULL;
4468 game.request_active = FALSE;
4469 game.request_active_or_moving = FALSE;
4471 if (level.game_engine_type == GAME_ENGINE_TYPE_MM)
4472 InitGameActions_MM();
4474 SaveEngineSnapshotToListInitial();
4476 if (!game.restart_level)
4478 PlaySound(SND_GAME_STARTING);
4480 if (setup.sound_music)
4485 void UpdateEngineValues(int actual_scroll_x, int actual_scroll_y,
4486 int actual_player_x, int actual_player_y)
4488 // this is used for non-R'n'D game engines to update certain engine values
4490 // needed to determine if sounds are played within the visible screen area
4491 scroll_x = actual_scroll_x;
4492 scroll_y = actual_scroll_y;
4494 // needed to get player position for "follow finger" playing input method
4495 local_player->jx = actual_player_x;
4496 local_player->jy = actual_player_y;
4499 void InitMovDir(int x, int y)
4501 int i, element = Tile[x][y];
4502 static int xy[4][2] =
4509 static int direction[3][4] =
4511 { MV_RIGHT, MV_UP, MV_LEFT, MV_DOWN },
4512 { MV_LEFT, MV_DOWN, MV_RIGHT, MV_UP },
4513 { MV_LEFT, MV_RIGHT, MV_UP, MV_DOWN }
4522 Tile[x][y] = EL_BUG;
4523 MovDir[x][y] = direction[0][element - EL_BUG_RIGHT];
4526 case EL_SPACESHIP_RIGHT:
4527 case EL_SPACESHIP_UP:
4528 case EL_SPACESHIP_LEFT:
4529 case EL_SPACESHIP_DOWN:
4530 Tile[x][y] = EL_SPACESHIP;
4531 MovDir[x][y] = direction[0][element - EL_SPACESHIP_RIGHT];
4534 case EL_BD_BUTTERFLY_RIGHT:
4535 case EL_BD_BUTTERFLY_UP:
4536 case EL_BD_BUTTERFLY_LEFT:
4537 case EL_BD_BUTTERFLY_DOWN:
4538 Tile[x][y] = EL_BD_BUTTERFLY;
4539 MovDir[x][y] = direction[0][element - EL_BD_BUTTERFLY_RIGHT];
4542 case EL_BD_FIREFLY_RIGHT:
4543 case EL_BD_FIREFLY_UP:
4544 case EL_BD_FIREFLY_LEFT:
4545 case EL_BD_FIREFLY_DOWN:
4546 Tile[x][y] = EL_BD_FIREFLY;
4547 MovDir[x][y] = direction[0][element - EL_BD_FIREFLY_RIGHT];
4550 case EL_PACMAN_RIGHT:
4552 case EL_PACMAN_LEFT:
4553 case EL_PACMAN_DOWN:
4554 Tile[x][y] = EL_PACMAN;
4555 MovDir[x][y] = direction[0][element - EL_PACMAN_RIGHT];
4558 case EL_YAMYAM_LEFT:
4559 case EL_YAMYAM_RIGHT:
4561 case EL_YAMYAM_DOWN:
4562 Tile[x][y] = EL_YAMYAM;
4563 MovDir[x][y] = direction[2][element - EL_YAMYAM_LEFT];
4566 case EL_SP_SNIKSNAK:
4567 MovDir[x][y] = MV_UP;
4570 case EL_SP_ELECTRON:
4571 MovDir[x][y] = MV_LEFT;
4578 Tile[x][y] = EL_MOLE;
4579 MovDir[x][y] = direction[2][element - EL_MOLE_LEFT];
4582 case EL_SPRING_LEFT:
4583 case EL_SPRING_RIGHT:
4584 Tile[x][y] = EL_SPRING;
4585 MovDir[x][y] = direction[2][element - EL_SPRING_LEFT];
4589 if (IS_CUSTOM_ELEMENT(element))
4591 struct ElementInfo *ei = &element_info[element];
4592 int move_direction_initial = ei->move_direction_initial;
4593 int move_pattern = ei->move_pattern;
4595 if (move_direction_initial == MV_START_PREVIOUS)
4597 if (MovDir[x][y] != MV_NONE)
4600 move_direction_initial = MV_START_AUTOMATIC;
4603 if (move_direction_initial == MV_START_RANDOM)
4604 MovDir[x][y] = 1 << RND(4);
4605 else if (move_direction_initial & MV_ANY_DIRECTION)
4606 MovDir[x][y] = move_direction_initial;
4607 else if (move_pattern == MV_ALL_DIRECTIONS ||
4608 move_pattern == MV_TURNING_LEFT ||
4609 move_pattern == MV_TURNING_RIGHT ||
4610 move_pattern == MV_TURNING_LEFT_RIGHT ||
4611 move_pattern == MV_TURNING_RIGHT_LEFT ||
4612 move_pattern == MV_TURNING_RANDOM)
4613 MovDir[x][y] = 1 << RND(4);
4614 else if (move_pattern == MV_HORIZONTAL)
4615 MovDir[x][y] = (RND(2) ? MV_LEFT : MV_RIGHT);
4616 else if (move_pattern == MV_VERTICAL)
4617 MovDir[x][y] = (RND(2) ? MV_UP : MV_DOWN);
4618 else if (move_pattern & MV_ANY_DIRECTION)
4619 MovDir[x][y] = element_info[element].move_pattern;
4620 else if (move_pattern == MV_ALONG_LEFT_SIDE ||
4621 move_pattern == MV_ALONG_RIGHT_SIDE)
4623 // use random direction as default start direction
4624 if (game.engine_version >= VERSION_IDENT(3,1,0,0))
4625 MovDir[x][y] = 1 << RND(4);
4627 for (i = 0; i < NUM_DIRECTIONS; i++)
4629 int x1 = x + xy[i][0];
4630 int y1 = y + xy[i][1];
4632 if (!IN_LEV_FIELD(x1, y1) || !IS_FREE(x1, y1))
4634 if (move_pattern == MV_ALONG_RIGHT_SIDE)
4635 MovDir[x][y] = direction[0][i];
4637 MovDir[x][y] = direction[1][i];
4646 MovDir[x][y] = 1 << RND(4);
4648 if (element != EL_BUG &&
4649 element != EL_SPACESHIP &&
4650 element != EL_BD_BUTTERFLY &&
4651 element != EL_BD_FIREFLY)
4654 for (i = 0; i < NUM_DIRECTIONS; i++)
4656 int x1 = x + xy[i][0];
4657 int y1 = y + xy[i][1];
4659 if (!IN_LEV_FIELD(x1, y1) || !IS_FREE(x1, y1))
4661 if (element == EL_BUG || element == EL_BD_BUTTERFLY)
4663 MovDir[x][y] = direction[0][i];
4666 else if (element == EL_SPACESHIP || element == EL_BD_FIREFLY ||
4667 element == EL_SP_SNIKSNAK || element == EL_SP_ELECTRON)
4669 MovDir[x][y] = direction[1][i];
4678 GfxDir[x][y] = MovDir[x][y];
4681 void InitAmoebaNr(int x, int y)
4684 int group_nr = AmoebaNeighbourNr(x, y);
4688 for (i = 1; i < MAX_NUM_AMOEBA; i++)
4690 if (AmoebaCnt[i] == 0)
4698 AmoebaNr[x][y] = group_nr;
4699 AmoebaCnt[group_nr]++;
4700 AmoebaCnt2[group_nr]++;
4703 static void LevelSolved(void)
4705 if (level.game_engine_type == GAME_ENGINE_TYPE_RND &&
4706 game.players_still_needed > 0)
4709 game.LevelSolved = TRUE;
4710 game.GameOver = TRUE;
4715 static int time_count_steps;
4716 static int time, time_final;
4717 static float score, score_final; // needed for time score < 10 for 10 seconds
4718 static int health, health_final;
4719 static int game_over_delay_1 = 0;
4720 static int game_over_delay_2 = 0;
4721 static int game_over_delay_3 = 0;
4722 int time_score_base = MIN(MAX(1, level.time_score_base), 10);
4723 float time_score = (float)level.score[SC_TIME_BONUS] / time_score_base;
4725 if (!game.LevelSolved_GameWon)
4729 // do not start end game actions before the player stops moving (to exit)
4730 if (local_player->active && local_player->MovPos)
4733 game.time_final = (game.no_time_limit ? TimePlayed : TimeLeft);
4734 game.score_time_final = (level.use_step_counter ? TimePlayed :
4735 TimePlayed * FRAMES_PER_SECOND + TimeFrames);
4737 game.score_final = (level.game_engine_type == GAME_ENGINE_TYPE_EM ?
4738 game_em.lev->score :
4739 level.game_engine_type == GAME_ENGINE_TYPE_MM ?
4743 game.health_final = (level.game_engine_type == GAME_ENGINE_TYPE_MM ?
4744 MM_HEALTH(game_mm.laser_overload_value) :
4747 game.LevelSolved_CountingTime = game.time_final;
4748 game.LevelSolved_CountingScore = game.score_final;
4749 game.LevelSolved_CountingHealth = game.health_final;
4751 game.LevelSolved_GameWon = TRUE;
4752 game.LevelSolved_SaveTape = tape.recording;
4753 game.LevelSolved_SaveScore = !tape.playing;
4757 LevelStats_incSolved(level_nr);
4759 SaveLevelSetup_SeriesInfo();
4762 if (tape.auto_play) // tape might already be stopped here
4763 tape.auto_play_level_solved = TRUE;
4767 game_over_delay_1 = FRAMES_PER_SECOND; // delay before counting time
4768 game_over_delay_2 = FRAMES_PER_SECOND / 2; // delay before counting health
4769 game_over_delay_3 = FRAMES_PER_SECOND; // delay before ending the game
4771 time = time_final = game.time_final;
4772 score = score_final = game.score_final;
4773 health = health_final = game.health_final;
4777 int time_final_max = 999;
4778 int time_frames_final_max = time_final_max * FRAMES_PER_SECOND;
4779 int time_frames = 0;
4780 int time_frames_left = TimeLeft * FRAMES_PER_SECOND - TimeFrames;
4781 int time_frames_played = TimePlayed * FRAMES_PER_SECOND + TimeFrames;
4786 time_frames = time_frames_left;
4788 else if (game.no_time_limit && TimePlayed < time_final_max)
4790 time_final = time_final_max;
4791 time_frames = time_frames_final_max - time_frames_played;
4794 score_final += time_score * time_frames / FRAMES_PER_SECOND + 0.5;
4796 time_count_steps = MAX(1, ABS(time_final - time) / 100);
4798 if (level.game_engine_type == GAME_ENGINE_TYPE_MM)
4801 score_final += health * time_score;
4804 game.score_final = score_final;
4805 game.health_final = health_final;
4808 if (level_editor_test_game || !setup.count_score_after_game)
4811 score = score_final;
4813 game.LevelSolved_CountingTime = time;
4814 game.LevelSolved_CountingScore = score;
4816 game_panel_controls[GAME_PANEL_TIME].value = time;
4817 game_panel_controls[GAME_PANEL_SCORE].value = score;
4819 DisplayGameControlValues();
4822 if (level.game_engine_type == GAME_ENGINE_TYPE_RND)
4824 // check if last player has left the level
4825 if (game.exit_x >= 0 &&
4828 int x = game.exit_x;
4829 int y = game.exit_y;
4830 int element = Tile[x][y];
4832 // close exit door after last player
4833 if ((game.all_players_gone &&
4834 (element == EL_EXIT_OPEN ||
4835 element == EL_SP_EXIT_OPEN ||
4836 element == EL_STEEL_EXIT_OPEN)) ||
4837 element == EL_EM_EXIT_OPEN ||
4838 element == EL_EM_STEEL_EXIT_OPEN)
4842 (element == EL_EXIT_OPEN ? EL_EXIT_CLOSING :
4843 element == EL_EM_EXIT_OPEN ? EL_EM_EXIT_CLOSING :
4844 element == EL_SP_EXIT_OPEN ? EL_SP_EXIT_CLOSING:
4845 element == EL_STEEL_EXIT_OPEN ? EL_STEEL_EXIT_CLOSING:
4846 EL_EM_STEEL_EXIT_CLOSING);
4848 PlayLevelSoundElementAction(x, y, element, ACTION_CLOSING);
4851 // player disappears
4852 DrawLevelField(x, y);
4855 for (i = 0; i < MAX_PLAYERS; i++)
4857 struct PlayerInfo *player = &stored_player[i];
4859 if (player->present)
4861 RemovePlayer(player);
4863 // player disappears
4864 DrawLevelField(player->jx, player->jy);
4869 PlaySound(SND_GAME_WINNING);
4872 if (setup.count_score_after_game)
4874 if (time != time_final)
4876 if (game_over_delay_1 > 0)
4878 game_over_delay_1--;
4883 int time_to_go = ABS(time_final - time);
4884 int time_count_dir = (time < time_final ? +1 : -1);
4886 if (time_to_go < time_count_steps)
4887 time_count_steps = 1;
4889 time += time_count_steps * time_count_dir;
4890 score += time_count_steps * time_score;
4892 // set final score to correct rounding differences after counting score
4893 if (time == time_final)
4894 score = score_final;
4896 game.LevelSolved_CountingTime = time;
4897 game.LevelSolved_CountingScore = score;
4899 game_panel_controls[GAME_PANEL_TIME].value = time;
4900 game_panel_controls[GAME_PANEL_SCORE].value = score;
4902 DisplayGameControlValues();
4904 if (time == time_final)
4905 StopSound(SND_GAME_LEVELTIME_BONUS);
4906 else if (setup.sound_loops)
4907 PlaySoundLoop(SND_GAME_LEVELTIME_BONUS);
4909 PlaySound(SND_GAME_LEVELTIME_BONUS);
4914 if (health != health_final)
4916 if (game_over_delay_2 > 0)
4918 game_over_delay_2--;
4923 int health_count_dir = (health < health_final ? +1 : -1);
4925 health += health_count_dir;
4926 score += time_score;
4928 game.LevelSolved_CountingHealth = health;
4929 game.LevelSolved_CountingScore = score;
4931 game_panel_controls[GAME_PANEL_HEALTH].value = health;
4932 game_panel_controls[GAME_PANEL_SCORE].value = score;
4934 DisplayGameControlValues();
4936 if (health == health_final)
4937 StopSound(SND_GAME_LEVELTIME_BONUS);
4938 else if (setup.sound_loops)
4939 PlaySoundLoop(SND_GAME_LEVELTIME_BONUS);
4941 PlaySound(SND_GAME_LEVELTIME_BONUS);
4947 game.panel.active = FALSE;
4949 if (game_over_delay_3 > 0)
4951 game_over_delay_3--;
4961 // used instead of "level_nr" (needed for network games)
4962 int last_level_nr = levelset.level_nr;
4963 int highlight_position;
4965 game.LevelSolved_GameEnd = TRUE;
4967 if (game.LevelSolved_SaveTape)
4969 // make sure that request dialog to save tape does not open door again
4970 if (!global.use_envelope_request)
4971 CloseDoor(DOOR_CLOSE_1);
4973 SaveTapeChecked_LevelSolved(tape.level_nr); // ask to save tape
4975 // set unique basename for score tape (also saved in high score table)
4976 strcpy(tape.score_tape_basename, getScoreTapeBasename(setup.player_name));
4979 // if no tape is to be saved, close both doors simultaneously
4980 CloseDoor(DOOR_CLOSE_ALL);
4982 if (level_editor_test_game)
4984 SetGameStatus(GAME_MODE_MAIN);
4991 if (!game.LevelSolved_SaveScore)
4993 SetGameStatus(GAME_MODE_MAIN);
5000 if (level_nr == leveldir_current->handicap_level)
5002 leveldir_current->handicap_level++;
5004 SaveLevelSetup_SeriesInfo();
5007 // save score and score tape before potentially erasing tape below
5008 highlight_position = NewHighScore(last_level_nr);
5010 if (setup.increment_levels &&
5011 level_nr < leveldir_current->last_level &&
5014 level_nr++; // advance to next level
5015 TapeErase(); // start with empty tape
5017 if (setup.auto_play_next_level)
5019 LoadLevel(level_nr);
5021 SaveLevelSetup_SeriesInfo();
5025 if (highlight_position >= 0 && setup.show_scores_after_game)
5027 SetGameStatus(GAME_MODE_SCORES);
5029 DrawHallOfFame(last_level_nr, highlight_position);
5031 else if (setup.auto_play_next_level && setup.increment_levels &&
5032 last_level_nr < leveldir_current->last_level &&
5035 StartGameActions(network.enabled, setup.autorecord, level.random_seed);
5039 SetGameStatus(GAME_MODE_MAIN);
5045 static int addScoreEntry(struct ScoreInfo *list, struct ScoreEntry *new_entry)
5047 boolean one_score_entry_per_name = !program.many_scores_per_name;
5050 if (strEqual(setup.player_name, EMPTY_PLAYER_NAME))
5053 for (i = 0; i < MAX_SCORE_ENTRIES; i++)
5055 struct ScoreEntry *entry = &list->entry[i];
5056 boolean score_is_better = (new_entry->score > entry->score);
5057 boolean score_is_equal = (new_entry->score == entry->score);
5058 boolean time_is_better = (new_entry->time < entry->time);
5059 boolean time_is_equal = (new_entry->time == entry->time);
5060 boolean better_by_score = (score_is_better ||
5061 (score_is_equal && time_is_better));
5062 boolean better_by_time = (time_is_better ||
5063 (time_is_equal && score_is_better));
5064 boolean is_better = (level.rate_time_over_score ? better_by_time :
5066 boolean entry_is_empty = (entry->score == 0 &&
5069 if (is_better || entry_is_empty)
5071 // player has made it to the hall of fame
5073 if (i < MAX_SCORE_ENTRIES - 1)
5075 int m = MAX_SCORE_ENTRIES - 1;
5078 if (one_score_entry_per_name)
5080 for (l = i; l < MAX_SCORE_ENTRIES; l++)
5081 if (strEqual(list->entry[l].name, setup.player_name))
5084 if (m == i) // player's new highscore overwrites his old one
5088 for (l = m; l > i; l--)
5089 list->entry[l] = list->entry[l - 1];
5094 *entry = *new_entry;
5098 else if (one_score_entry_per_name &&
5099 strEqual(entry->name, setup.player_name))
5101 // player already in high score list with better score or time
5110 int NewHighScore(int level_nr)
5112 struct ScoreEntry new_entry = {{ 0 }}; // (prevent warning from GCC bug 53119)
5114 strncpy(new_entry.tape_basename, tape.score_tape_basename, MAX_FILENAME_LEN);
5115 strncpy(new_entry.name, setup.player_name, MAX_PLAYER_NAME_LEN);
5117 new_entry.score = game.score_final;
5118 new_entry.time = game.score_time_final;
5120 LoadScore(level_nr);
5122 scores.last_added = addScoreEntry(&scores, &new_entry);
5124 if (scores.last_added >= 0)
5126 SaveScore(level_nr);
5128 if (game.LevelSolved_SaveTape)
5130 SaveScoreTape(level_nr);
5131 SaveServerScore(level_nr);
5135 return scores.last_added;
5138 static int getElementMoveStepsizeExt(int x, int y, int direction)
5140 int element = Tile[x][y];
5141 int dx = (direction == MV_LEFT ? -1 : direction == MV_RIGHT ? +1 : 0);
5142 int dy = (direction == MV_UP ? -1 : direction == MV_DOWN ? +1 : 0);
5143 int horiz_move = (dx != 0);
5144 int sign = (horiz_move ? dx : dy);
5145 int step = sign * element_info[element].move_stepsize;
5147 // special values for move stepsize for spring and things on conveyor belt
5150 if (CAN_FALL(element) &&
5151 y < lev_fieldy - 1 && IS_BELT_ACTIVE(Tile[x][y + 1]))
5152 step = sign * MOVE_STEPSIZE_NORMAL / 2;
5153 else if (element == EL_SPRING)
5154 step = sign * MOVE_STEPSIZE_NORMAL * 2;
5160 static int getElementMoveStepsize(int x, int y)
5162 return getElementMoveStepsizeExt(x, y, MovDir[x][y]);
5165 void InitPlayerGfxAnimation(struct PlayerInfo *player, int action, int dir)
5167 if (player->GfxAction != action || player->GfxDir != dir)
5169 player->GfxAction = action;
5170 player->GfxDir = dir;
5172 player->StepFrame = 0;
5176 static void ResetGfxFrame(int x, int y)
5178 // profiling showed that "autotest" spends 10~20% of its time in this function
5179 if (DrawingDeactivatedField())
5182 int element = Tile[x][y];
5183 int graphic = el_act_dir2img(element, GfxAction[x][y], GfxDir[x][y]);
5185 if (graphic_info[graphic].anim_global_sync)
5186 GfxFrame[x][y] = FrameCounter;
5187 else if (ANIM_MODE(graphic) == ANIM_CE_VALUE)
5188 GfxFrame[x][y] = CustomValue[x][y];
5189 else if (ANIM_MODE(graphic) == ANIM_CE_SCORE)
5190 GfxFrame[x][y] = element_info[element].collect_score;
5191 else if (ANIM_MODE(graphic) == ANIM_CE_DELAY)
5192 GfxFrame[x][y] = ChangeDelay[x][y];
5195 static void ResetGfxAnimation(int x, int y)
5197 GfxAction[x][y] = ACTION_DEFAULT;
5198 GfxDir[x][y] = MovDir[x][y];
5201 ResetGfxFrame(x, y);
5204 static void ResetRandomAnimationValue(int x, int y)
5206 GfxRandom[x][y] = INIT_GFX_RANDOM();
5209 static void InitMovingField(int x, int y, int direction)
5211 int element = Tile[x][y];
5212 int dx = (direction == MV_LEFT ? -1 : direction == MV_RIGHT ? +1 : 0);
5213 int dy = (direction == MV_UP ? -1 : direction == MV_DOWN ? +1 : 0);
5216 boolean is_moving_before, is_moving_after;
5218 // check if element was/is moving or being moved before/after mode change
5219 is_moving_before = (WasJustMoving[x][y] != 0);
5220 is_moving_after = (getElementMoveStepsizeExt(x, y, direction) != 0);
5222 // reset animation only for moving elements which change direction of moving
5223 // or which just started or stopped moving
5224 // (else CEs with property "can move" / "not moving" are reset each frame)
5225 if (is_moving_before != is_moving_after ||
5226 direction != MovDir[x][y])
5227 ResetGfxAnimation(x, y);
5229 MovDir[x][y] = direction;
5230 GfxDir[x][y] = direction;
5232 GfxAction[x][y] = (!is_moving_after ? ACTION_WAITING :
5233 direction == MV_DOWN && CAN_FALL(element) ?
5234 ACTION_FALLING : ACTION_MOVING);
5236 // this is needed for CEs with property "can move" / "not moving"
5238 if (is_moving_after)
5240 if (Tile[newx][newy] == EL_EMPTY)
5241 Tile[newx][newy] = EL_BLOCKED;
5243 MovDir[newx][newy] = MovDir[x][y];
5245 CustomValue[newx][newy] = CustomValue[x][y];
5247 GfxFrame[newx][newy] = GfxFrame[x][y];
5248 GfxRandom[newx][newy] = GfxRandom[x][y];
5249 GfxAction[newx][newy] = GfxAction[x][y];
5250 GfxDir[newx][newy] = GfxDir[x][y];
5254 void Moving2Blocked(int x, int y, int *goes_to_x, int *goes_to_y)
5256 int direction = MovDir[x][y];
5257 int newx = x + (direction & MV_LEFT ? -1 : direction & MV_RIGHT ? +1 : 0);
5258 int newy = y + (direction & MV_UP ? -1 : direction & MV_DOWN ? +1 : 0);
5264 void Blocked2Moving(int x, int y, int *comes_from_x, int *comes_from_y)
5266 int oldx = x, oldy = y;
5267 int direction = MovDir[x][y];
5269 if (direction == MV_LEFT)
5271 else if (direction == MV_RIGHT)
5273 else if (direction == MV_UP)
5275 else if (direction == MV_DOWN)
5278 *comes_from_x = oldx;
5279 *comes_from_y = oldy;
5282 static int MovingOrBlocked2Element(int x, int y)
5284 int element = Tile[x][y];
5286 if (element == EL_BLOCKED)
5290 Blocked2Moving(x, y, &oldx, &oldy);
5291 return Tile[oldx][oldy];
5297 static int MovingOrBlocked2ElementIfNotLeaving(int x, int y)
5299 // like MovingOrBlocked2Element(), but if element is moving
5300 // and (x,y) is the field the moving element is just leaving,
5301 // return EL_BLOCKED instead of the element value
5302 int element = Tile[x][y];
5304 if (IS_MOVING(x, y))
5306 if (element == EL_BLOCKED)
5310 Blocked2Moving(x, y, &oldx, &oldy);
5311 return Tile[oldx][oldy];
5320 static void RemoveField(int x, int y)
5322 Tile[x][y] = EL_EMPTY;
5328 CustomValue[x][y] = 0;
5331 ChangeDelay[x][y] = 0;
5332 ChangePage[x][y] = -1;
5333 Pushed[x][y] = FALSE;
5335 GfxElement[x][y] = EL_UNDEFINED;
5336 GfxAction[x][y] = ACTION_DEFAULT;
5337 GfxDir[x][y] = MV_NONE;
5340 static void RemoveMovingField(int x, int y)
5342 int oldx = x, oldy = y, newx = x, newy = y;
5343 int element = Tile[x][y];
5344 int next_element = EL_UNDEFINED;
5346 if (element != EL_BLOCKED && !IS_MOVING(x, y))
5349 if (IS_MOVING(x, y))
5351 Moving2Blocked(x, y, &newx, &newy);
5353 if (Tile[newx][newy] != EL_BLOCKED)
5355 // element is moving, but target field is not free (blocked), but
5356 // already occupied by something different (example: acid pool);
5357 // in this case, only remove the moving field, but not the target
5359 RemoveField(oldx, oldy);
5361 Store[oldx][oldy] = Store2[oldx][oldy] = 0;
5363 TEST_DrawLevelField(oldx, oldy);
5368 else if (element == EL_BLOCKED)
5370 Blocked2Moving(x, y, &oldx, &oldy);
5371 if (!IS_MOVING(oldx, oldy))
5375 if (element == EL_BLOCKED &&
5376 (Tile[oldx][oldy] == EL_QUICKSAND_EMPTYING ||
5377 Tile[oldx][oldy] == EL_QUICKSAND_FAST_EMPTYING ||
5378 Tile[oldx][oldy] == EL_MAGIC_WALL_EMPTYING ||
5379 Tile[oldx][oldy] == EL_BD_MAGIC_WALL_EMPTYING ||
5380 Tile[oldx][oldy] == EL_DC_MAGIC_WALL_EMPTYING ||
5381 Tile[oldx][oldy] == EL_AMOEBA_DROPPING))
5382 next_element = get_next_element(Tile[oldx][oldy]);
5384 RemoveField(oldx, oldy);
5385 RemoveField(newx, newy);
5387 Store[oldx][oldy] = Store2[oldx][oldy] = 0;
5389 if (next_element != EL_UNDEFINED)
5390 Tile[oldx][oldy] = next_element;
5392 TEST_DrawLevelField(oldx, oldy);
5393 TEST_DrawLevelField(newx, newy);
5396 void DrawDynamite(int x, int y)
5398 int sx = SCREENX(x), sy = SCREENY(y);
5399 int graphic = el2img(Tile[x][y]);
5402 if (!IN_SCR_FIELD(sx, sy) || IS_PLAYER(x, y))
5405 if (IS_WALKABLE_INSIDE(Back[x][y]))
5409 DrawLevelElement(x, y, Back[x][y]);
5410 else if (Store[x][y])
5411 DrawLevelElement(x, y, Store[x][y]);
5412 else if (game.use_masked_elements)
5413 DrawLevelElement(x, y, EL_EMPTY);
5415 frame = getGraphicAnimationFrame(graphic, GfxFrame[x][y]);
5417 if (Back[x][y] || Store[x][y] || game.use_masked_elements)
5418 DrawGraphicThruMask(sx, sy, graphic, frame);
5420 DrawGraphic(sx, sy, graphic, frame);
5423 static void CheckDynamite(int x, int y)
5425 if (MovDelay[x][y] != 0) // dynamite is still waiting to explode
5429 if (MovDelay[x][y] != 0)
5432 PlayLevelSoundActionIfLoop(x, y, ACTION_ACTIVE);
5438 StopLevelSoundActionIfLoop(x, y, ACTION_ACTIVE);
5443 static void setMinimalPlayerBoundaries(int *sx1, int *sy1, int *sx2, int *sy2)
5445 boolean num_checked_players = 0;
5448 for (i = 0; i < MAX_PLAYERS; i++)
5450 if (stored_player[i].active)
5452 int sx = stored_player[i].jx;
5453 int sy = stored_player[i].jy;
5455 if (num_checked_players == 0)
5462 *sx1 = MIN(*sx1, sx);
5463 *sy1 = MIN(*sy1, sy);
5464 *sx2 = MAX(*sx2, sx);
5465 *sy2 = MAX(*sy2, sy);
5468 num_checked_players++;
5473 static boolean checkIfAllPlayersFitToScreen_RND(void)
5475 int sx1 = 0, sy1 = 0, sx2 = 0, sy2 = 0;
5477 setMinimalPlayerBoundaries(&sx1, &sy1, &sx2, &sy2);
5479 return (sx2 - sx1 < SCR_FIELDX &&
5480 sy2 - sy1 < SCR_FIELDY);
5483 static void setScreenCenteredToAllPlayers(int *sx, int *sy)
5485 int sx1 = scroll_x, sy1 = scroll_y, sx2 = scroll_x, sy2 = scroll_y;
5487 setMinimalPlayerBoundaries(&sx1, &sy1, &sx2, &sy2);
5489 *sx = (sx1 + sx2) / 2;
5490 *sy = (sy1 + sy2) / 2;
5493 static void DrawRelocateScreen(int old_x, int old_y, int x, int y, int move_dir,
5494 boolean center_screen, boolean quick_relocation)
5496 unsigned int frame_delay_value_old = GetVideoFrameDelay();
5497 boolean ffwd_delay = (tape.playing && tape.fast_forward);
5498 boolean no_delay = (tape.warp_forward);
5499 int frame_delay_value = (ffwd_delay ? FfwdFrameDelay : GameFrameDelay);
5500 int wait_delay_value = (no_delay ? 0 : frame_delay_value);
5501 int new_scroll_x, new_scroll_y;
5503 if (level.lazy_relocation && IN_VIS_FIELD(SCREENX(x), SCREENY(y)))
5505 // case 1: quick relocation inside visible screen (without scrolling)
5512 if (!level.shifted_relocation || center_screen)
5514 // relocation _with_ centering of screen
5516 new_scroll_x = SCROLL_POSITION_X(x);
5517 new_scroll_y = SCROLL_POSITION_Y(y);
5521 // relocation _without_ centering of screen
5523 int center_scroll_x = SCROLL_POSITION_X(old_x);
5524 int center_scroll_y = SCROLL_POSITION_Y(old_y);
5525 int offset_x = x + (scroll_x - center_scroll_x);
5526 int offset_y = y + (scroll_y - center_scroll_y);
5528 // for new screen position, apply previous offset to center position
5529 new_scroll_x = SCROLL_POSITION_X(offset_x);
5530 new_scroll_y = SCROLL_POSITION_Y(offset_y);
5533 if (quick_relocation)
5535 // case 2: quick relocation (redraw without visible scrolling)
5537 scroll_x = new_scroll_x;
5538 scroll_y = new_scroll_y;
5545 // case 3: visible relocation (with scrolling to new position)
5547 ScrollScreen(NULL, SCROLL_GO_ON); // scroll last frame to full tile
5549 SetVideoFrameDelay(wait_delay_value);
5551 while (scroll_x != new_scroll_x || scroll_y != new_scroll_y)
5553 int dx = (new_scroll_x < scroll_x ? +1 : new_scroll_x > scroll_x ? -1 : 0);
5554 int dy = (new_scroll_y < scroll_y ? +1 : new_scroll_y > scroll_y ? -1 : 0);
5556 if (dx == 0 && dy == 0) // no scrolling needed at all
5562 // set values for horizontal/vertical screen scrolling (half tile size)
5563 int dir_x = (dx != 0 ? MV_HORIZONTAL : 0);
5564 int dir_y = (dy != 0 ? MV_VERTICAL : 0);
5565 int pos_x = dx * TILEX / 2;
5566 int pos_y = dy * TILEY / 2;
5567 int fx = getFieldbufferOffsetX_RND(dir_x, pos_x);
5568 int fy = getFieldbufferOffsetY_RND(dir_y, pos_y);
5570 ScrollLevel(dx, dy);
5573 // scroll in two steps of half tile size to make things smoother
5574 BlitScreenToBitmapExt_RND(window, fx, fy);
5576 // scroll second step to align at full tile size
5577 BlitScreenToBitmap(window);
5583 SetVideoFrameDelay(frame_delay_value_old);
5586 static void RelocatePlayer(int jx, int jy, int el_player_raw)
5588 int el_player = GET_PLAYER_ELEMENT(el_player_raw);
5589 int player_nr = GET_PLAYER_NR(el_player);
5590 struct PlayerInfo *player = &stored_player[player_nr];
5591 boolean ffwd_delay = (tape.playing && tape.fast_forward);
5592 boolean no_delay = (tape.warp_forward);
5593 int frame_delay_value = (ffwd_delay ? FfwdFrameDelay : GameFrameDelay);
5594 int wait_delay_value = (no_delay ? 0 : frame_delay_value);
5595 int old_jx = player->jx;
5596 int old_jy = player->jy;
5597 int old_element = Tile[old_jx][old_jy];
5598 int element = Tile[jx][jy];
5599 boolean player_relocated = (old_jx != jx || old_jy != jy);
5601 int move_dir_horiz = (jx < old_jx ? MV_LEFT : jx > old_jx ? MV_RIGHT : 0);
5602 int move_dir_vert = (jy < old_jy ? MV_UP : jy > old_jy ? MV_DOWN : 0);
5603 int enter_side_horiz = MV_DIR_OPPOSITE(move_dir_horiz);
5604 int enter_side_vert = MV_DIR_OPPOSITE(move_dir_vert);
5605 int leave_side_horiz = move_dir_horiz;
5606 int leave_side_vert = move_dir_vert;
5607 int enter_side = enter_side_horiz | enter_side_vert;
5608 int leave_side = leave_side_horiz | leave_side_vert;
5610 if (player->buried) // do not reanimate dead player
5613 if (!player_relocated) // no need to relocate the player
5616 if (IS_PLAYER(jx, jy)) // player already placed at new position
5618 RemoveField(jx, jy); // temporarily remove newly placed player
5619 DrawLevelField(jx, jy);
5622 if (player->present)
5624 while (player->MovPos)
5626 ScrollPlayer(player, SCROLL_GO_ON);
5627 ScrollScreen(NULL, SCROLL_GO_ON);
5629 AdvanceFrameAndPlayerCounters(player->index_nr);
5633 BackToFront_WithFrameDelay(wait_delay_value);
5636 DrawPlayer(player); // needed here only to cleanup last field
5637 DrawLevelField(player->jx, player->jy); // remove player graphic
5639 player->is_moving = FALSE;
5642 if (IS_CUSTOM_ELEMENT(old_element))
5643 CheckElementChangeByPlayer(old_jx, old_jy, old_element,
5645 player->index_bit, leave_side);
5647 CheckTriggeredElementChangeByPlayer(old_jx, old_jy, old_element,
5649 player->index_bit, leave_side);
5651 Tile[jx][jy] = el_player;
5652 InitPlayerField(jx, jy, el_player, TRUE);
5654 /* "InitPlayerField()" above sets Tile[jx][jy] to EL_EMPTY, but it may be
5655 possible that the relocation target field did not contain a player element,
5656 but a walkable element, to which the new player was relocated -- in this
5657 case, restore that (already initialized!) element on the player field */
5658 if (!ELEM_IS_PLAYER(element)) // player may be set on walkable element
5660 Tile[jx][jy] = element; // restore previously existing element
5663 // only visually relocate centered player
5664 DrawRelocateScreen(old_jx, old_jy, player->jx, player->jy, player->MovDir,
5665 FALSE, level.instant_relocation);
5667 TestIfPlayerTouchesBadThing(jx, jy);
5668 TestIfPlayerTouchesCustomElement(jx, jy);
5670 if (IS_CUSTOM_ELEMENT(element))
5671 CheckElementChangeByPlayer(jx, jy, element, CE_ENTERED_BY_PLAYER,
5672 player->index_bit, enter_side);
5674 CheckTriggeredElementChangeByPlayer(jx, jy, element, CE_PLAYER_ENTERS_X,
5675 player->index_bit, enter_side);
5677 if (player->is_switching)
5679 /* ensure that relocation while still switching an element does not cause
5680 a new element to be treated as also switched directly after relocation
5681 (this is important for teleporter switches that teleport the player to
5682 a place where another teleporter switch is in the same direction, which
5683 would then incorrectly be treated as immediately switched before the
5684 direction key that caused the switch was released) */
5686 player->switch_x += jx - old_jx;
5687 player->switch_y += jy - old_jy;
5691 static void Explode(int ex, int ey, int phase, int mode)
5697 // !!! eliminate this variable !!!
5698 int delay = (game.emulation == EMU_SUPAPLEX ? 3 : 2);
5700 if (game.explosions_delayed)
5702 ExplodeField[ex][ey] = mode;
5706 if (phase == EX_PHASE_START) // initialize 'Store[][]' field
5708 int center_element = Tile[ex][ey];
5709 int artwork_element, explosion_element; // set these values later
5711 // remove things displayed in background while burning dynamite
5712 if (Back[ex][ey] != EL_EMPTY && !IS_INDESTRUCTIBLE(Back[ex][ey]))
5715 if (IS_MOVING(ex, ey) || IS_BLOCKED(ex, ey))
5717 // put moving element to center field (and let it explode there)
5718 center_element = MovingOrBlocked2Element(ex, ey);
5719 RemoveMovingField(ex, ey);
5720 Tile[ex][ey] = center_element;
5723 // now "center_element" is finally determined -- set related values now
5724 artwork_element = center_element; // for custom player artwork
5725 explosion_element = center_element; // for custom player artwork
5727 if (IS_PLAYER(ex, ey))
5729 int player_nr = GET_PLAYER_NR(StorePlayer[ex][ey]);
5731 artwork_element = stored_player[player_nr].artwork_element;
5733 if (level.use_explosion_element[player_nr])
5735 explosion_element = level.explosion_element[player_nr];
5736 artwork_element = explosion_element;
5740 if (mode == EX_TYPE_NORMAL ||
5741 mode == EX_TYPE_CENTER ||
5742 mode == EX_TYPE_CROSS)
5743 PlayLevelSoundElementAction(ex, ey, artwork_element, ACTION_EXPLODING);
5745 last_phase = element_info[explosion_element].explosion_delay + 1;
5747 for (y = ey - 1; y <= ey + 1; y++) for (x = ex - 1; x <= ex + 1; x++)
5749 int xx = x - ex + 1;
5750 int yy = y - ey + 1;
5753 if (!IN_LEV_FIELD(x, y) ||
5754 (mode & EX_TYPE_SINGLE_TILE && (x != ex || y != ey)) ||
5755 (mode == EX_TYPE_CROSS && (x != ex && y != ey)))
5758 element = Tile[x][y];
5760 if (IS_MOVING(x, y) || IS_BLOCKED(x, y))
5762 element = MovingOrBlocked2Element(x, y);
5764 if (!IS_EXPLOSION_PROOF(element))
5765 RemoveMovingField(x, y);
5768 // indestructible elements can only explode in center (but not flames)
5769 if ((IS_EXPLOSION_PROOF(element) && (x != ex || y != ey ||
5770 mode == EX_TYPE_BORDER)) ||
5771 element == EL_FLAMES)
5774 /* no idea why this was changed from 3.0.8 to 3.1.0 -- this causes buggy
5775 behaviour, for example when touching a yamyam that explodes to rocks
5776 with active deadly shield, a rock is created under the player !!! */
5777 // (case 1 (surely buggy): >= 3.1.0, case 2 (maybe buggy): <= 3.0.8)
5779 if (IS_PLAYER(x, y) && SHIELD_ON(PLAYERINFO(x, y)) &&
5780 (game.engine_version < VERSION_IDENT(3,1,0,0) ||
5781 (x == ex && y == ey && mode != EX_TYPE_BORDER)))
5783 if (IS_PLAYER(x, y) && SHIELD_ON(PLAYERINFO(x, y)))
5786 if (IS_ACTIVE_BOMB(element))
5788 // re-activate things under the bomb like gate or penguin
5789 Tile[x][y] = (Back[x][y] ? Back[x][y] : EL_EMPTY);
5796 // save walkable background elements while explosion on same tile
5797 if (IS_WALKABLE(element) && IS_INDESTRUCTIBLE(element) &&
5798 (x != ex || y != ey || mode == EX_TYPE_BORDER))
5799 Back[x][y] = element;
5801 // ignite explodable elements reached by other explosion
5802 if (element == EL_EXPLOSION)
5803 element = Store2[x][y];
5805 if (AmoebaNr[x][y] &&
5806 (element == EL_AMOEBA_FULL ||
5807 element == EL_BD_AMOEBA ||
5808 element == EL_AMOEBA_GROWING))
5810 AmoebaCnt[AmoebaNr[x][y]]--;
5811 AmoebaCnt2[AmoebaNr[x][y]]--;
5816 if (IS_PLAYER(ex, ey) && !PLAYER_EXPLOSION_PROTECTED(ex, ey))
5818 int player_nr = StorePlayer[ex][ey] - EL_PLAYER_1;
5820 Store[x][y] = EL_PLAYER_IS_EXPLODING_1 + player_nr;
5822 if (PLAYERINFO(ex, ey)->use_murphy)
5823 Store[x][y] = EL_EMPTY;
5826 // !!! check this case -- currently needed for rnd_rado_negundo_v,
5827 // !!! levels 015 018 019 020 021 022 023 026 027 028 !!!
5828 else if (ELEM_IS_PLAYER(center_element))
5829 Store[x][y] = EL_EMPTY;
5830 else if (center_element == EL_YAMYAM)
5831 Store[x][y] = level.yamyam_content[game.yamyam_content_nr].e[xx][yy];
5832 else if (element_info[center_element].content.e[xx][yy] != EL_EMPTY)
5833 Store[x][y] = element_info[center_element].content.e[xx][yy];
5835 // needed because EL_BD_BUTTERFLY is not defined as "CAN_EXPLODE"
5836 // (killing EL_BD_BUTTERFLY with dynamite would result in BD diamond
5837 // otherwise) -- FIX THIS !!!
5838 else if (!CAN_EXPLODE(element) && element != EL_BD_BUTTERFLY)
5839 Store[x][y] = element_info[element].content.e[1][1];
5841 else if (!CAN_EXPLODE(element))
5842 Store[x][y] = element_info[element].content.e[1][1];
5845 Store[x][y] = EL_EMPTY;
5847 if (x != ex || y != ey || mode == EX_TYPE_BORDER ||
5848 center_element == EL_AMOEBA_TO_DIAMOND)
5849 Store2[x][y] = element;
5851 Tile[x][y] = EL_EXPLOSION;
5852 GfxElement[x][y] = artwork_element;
5854 ExplodePhase[x][y] = 1;
5855 ExplodeDelay[x][y] = last_phase;
5860 if (center_element == EL_YAMYAM)
5861 game.yamyam_content_nr =
5862 (game.yamyam_content_nr + 1) % level.num_yamyam_contents;
5874 GfxFrame[x][y] = 0; // restart explosion animation
5876 last_phase = ExplodeDelay[x][y];
5878 ExplodePhase[x][y] = (phase < last_phase ? phase + 1 : 0);
5880 // this can happen if the player leaves an explosion just in time
5881 if (GfxElement[x][y] == EL_UNDEFINED)
5882 GfxElement[x][y] = EL_EMPTY;
5884 border_element = Store2[x][y];
5885 if (IS_PLAYER(x, y) && !PLAYER_EXPLOSION_PROTECTED(x, y))
5886 border_element = StorePlayer[x][y];
5888 if (phase == element_info[border_element].ignition_delay ||
5889 phase == last_phase)
5891 boolean border_explosion = FALSE;
5893 if (IS_PLAYER(x, y) && PLAYERINFO(x, y)->present &&
5894 !PLAYER_EXPLOSION_PROTECTED(x, y))
5896 KillPlayerUnlessExplosionProtected(x, y);
5897 border_explosion = TRUE;
5899 else if (CAN_EXPLODE_BY_EXPLOSION(border_element))
5901 Tile[x][y] = Store2[x][y];
5904 border_explosion = TRUE;
5906 else if (border_element == EL_AMOEBA_TO_DIAMOND)
5908 AmoebaToDiamond(x, y);
5910 border_explosion = TRUE;
5913 // if an element just explodes due to another explosion (chain-reaction),
5914 // do not immediately end the new explosion when it was the last frame of
5915 // the explosion (as it would be done in the following "if"-statement!)
5916 if (border_explosion && phase == last_phase)
5920 if (phase == last_phase)
5924 element = Tile[x][y] = Store[x][y];
5925 Store[x][y] = Store2[x][y] = 0;
5926 GfxElement[x][y] = EL_UNDEFINED;
5928 // player can escape from explosions and might therefore be still alive
5929 if (element >= EL_PLAYER_IS_EXPLODING_1 &&
5930 element <= EL_PLAYER_IS_EXPLODING_4)
5932 int player_nr = element - EL_PLAYER_IS_EXPLODING_1;
5933 int explosion_element = EL_PLAYER_1 + player_nr;
5934 int xx = MIN(MAX(0, x - stored_player[player_nr].jx + 1), 2);
5935 int yy = MIN(MAX(0, y - stored_player[player_nr].jy + 1), 2);
5937 if (level.use_explosion_element[player_nr])
5938 explosion_element = level.explosion_element[player_nr];
5940 Tile[x][y] = (stored_player[player_nr].active ? EL_EMPTY :
5941 element_info[explosion_element].content.e[xx][yy]);
5944 // restore probably existing indestructible background element
5945 if (Back[x][y] && IS_INDESTRUCTIBLE(Back[x][y]))
5946 element = Tile[x][y] = Back[x][y];
5949 MovDir[x][y] = MovPos[x][y] = MovDelay[x][y] = 0;
5950 GfxDir[x][y] = MV_NONE;
5951 ChangeDelay[x][y] = 0;
5952 ChangePage[x][y] = -1;
5954 CustomValue[x][y] = 0;
5956 InitField_WithBug2(x, y, FALSE);
5958 TEST_DrawLevelField(x, y);
5960 TestIfElementTouchesCustomElement(x, y);
5962 if (GFX_CRUMBLED(element))
5963 TEST_DrawLevelFieldCrumbledNeighbours(x, y);
5965 if (IS_PLAYER(x, y) && !PLAYERINFO(x, y)->present)
5966 StorePlayer[x][y] = 0;
5968 if (ELEM_IS_PLAYER(element))
5969 RelocatePlayer(x, y, element);
5971 else if (IN_SCR_FIELD(SCREENX(x), SCREENY(y)))
5973 int graphic = el_act2img(GfxElement[x][y], ACTION_EXPLODING);
5974 int frame = getGraphicAnimationFrame(graphic, GfxFrame[x][y]);
5977 TEST_DrawLevelFieldCrumbled(x, y);
5979 if (IS_WALKABLE_OVER(Back[x][y]) && Back[x][y] != EL_EMPTY)
5981 DrawLevelElement(x, y, Back[x][y]);
5982 DrawGraphicThruMask(SCREENX(x), SCREENY(y), graphic, frame);
5984 else if (IS_WALKABLE_UNDER(Back[x][y]))
5986 DrawGraphic(SCREENX(x), SCREENY(y), graphic, frame);
5987 DrawLevelElementThruMask(x, y, Back[x][y]);
5989 else if (!IS_WALKABLE_INSIDE(Back[x][y]))
5990 DrawScreenGraphic(SCREENX(x), SCREENY(y), graphic, frame);
5994 static void DynaExplode(int ex, int ey)
5997 int dynabomb_element = Tile[ex][ey];
5998 int dynabomb_size = 1;
5999 boolean dynabomb_xl = FALSE;
6000 struct PlayerInfo *player;
6001 static int xy[4][2] =
6009 if (IS_ACTIVE_BOMB(dynabomb_element))
6011 player = &stored_player[dynabomb_element - EL_DYNABOMB_PLAYER_1_ACTIVE];
6012 dynabomb_size = player->dynabomb_size;
6013 dynabomb_xl = player->dynabomb_xl;
6014 player->dynabombs_left++;
6017 Explode(ex, ey, EX_PHASE_START, EX_TYPE_CENTER);
6019 for (i = 0; i < NUM_DIRECTIONS; i++)
6021 for (j = 1; j <= dynabomb_size; j++)
6023 int x = ex + j * xy[i][0];
6024 int y = ey + j * xy[i][1];
6027 if (!IN_LEV_FIELD(x, y) || IS_INDESTRUCTIBLE(Tile[x][y]))
6030 element = Tile[x][y];
6032 // do not restart explosions of fields with active bombs
6033 if (element == EL_EXPLOSION && IS_ACTIVE_BOMB(Store2[x][y]))
6036 Explode(x, y, EX_PHASE_START, EX_TYPE_BORDER);
6038 if (element != EL_EMPTY && element != EL_EXPLOSION &&
6039 !IS_DIGGABLE(element) && !dynabomb_xl)
6045 void Bang(int x, int y)
6047 int element = MovingOrBlocked2Element(x, y);
6048 int explosion_type = EX_TYPE_NORMAL;
6050 if (IS_PLAYER(x, y) && !PLAYER_EXPLOSION_PROTECTED(x, y))
6052 struct PlayerInfo *player = PLAYERINFO(x, y);
6054 element = Tile[x][y] = player->initial_element;
6056 if (level.use_explosion_element[player->index_nr])
6058 int explosion_element = level.explosion_element[player->index_nr];
6060 if (element_info[explosion_element].explosion_type == EXPLODES_CROSS)
6061 explosion_type = EX_TYPE_CROSS;
6062 else if (element_info[explosion_element].explosion_type == EXPLODES_1X1)
6063 explosion_type = EX_TYPE_CENTER;
6071 case EL_BD_BUTTERFLY:
6074 case EL_DARK_YAMYAM:
6078 RaiseScoreElement(element);
6081 case EL_DYNABOMB_PLAYER_1_ACTIVE:
6082 case EL_DYNABOMB_PLAYER_2_ACTIVE:
6083 case EL_DYNABOMB_PLAYER_3_ACTIVE:
6084 case EL_DYNABOMB_PLAYER_4_ACTIVE:
6085 case EL_DYNABOMB_INCREASE_NUMBER:
6086 case EL_DYNABOMB_INCREASE_SIZE:
6087 case EL_DYNABOMB_INCREASE_POWER:
6088 explosion_type = EX_TYPE_DYNA;
6091 case EL_DC_LANDMINE:
6092 explosion_type = EX_TYPE_CENTER;
6097 case EL_LAMP_ACTIVE:
6098 case EL_AMOEBA_TO_DIAMOND:
6099 if (!IS_PLAYER(x, y)) // penguin and player may be at same field
6100 explosion_type = EX_TYPE_CENTER;
6104 if (element_info[element].explosion_type == EXPLODES_CROSS)
6105 explosion_type = EX_TYPE_CROSS;
6106 else if (element_info[element].explosion_type == EXPLODES_1X1)
6107 explosion_type = EX_TYPE_CENTER;
6111 if (explosion_type == EX_TYPE_DYNA)
6114 Explode(x, y, EX_PHASE_START, explosion_type);
6116 CheckTriggeredElementChange(x, y, element, CE_EXPLOSION_OF_X);
6119 static void SplashAcid(int x, int y)
6121 if (IN_LEV_FIELD(x - 1, y - 1) && IS_FREE(x - 1, y - 1) &&
6122 (!IN_LEV_FIELD(x - 1, y - 2) ||
6123 !CAN_FALL(MovingOrBlocked2Element(x - 1, y - 2))))
6124 Tile[x - 1][y - 1] = EL_ACID_SPLASH_LEFT;
6126 if (IN_LEV_FIELD(x + 1, y - 1) && IS_FREE(x + 1, y - 1) &&
6127 (!IN_LEV_FIELD(x + 1, y - 2) ||
6128 !CAN_FALL(MovingOrBlocked2Element(x + 1, y - 2))))
6129 Tile[x + 1][y - 1] = EL_ACID_SPLASH_RIGHT;
6131 PlayLevelSound(x, y, SND_ACID_SPLASHING);
6134 static void InitBeltMovement(void)
6136 static int belt_base_element[4] =
6138 EL_CONVEYOR_BELT_1_LEFT,
6139 EL_CONVEYOR_BELT_2_LEFT,
6140 EL_CONVEYOR_BELT_3_LEFT,
6141 EL_CONVEYOR_BELT_4_LEFT
6143 static int belt_base_active_element[4] =
6145 EL_CONVEYOR_BELT_1_LEFT_ACTIVE,
6146 EL_CONVEYOR_BELT_2_LEFT_ACTIVE,
6147 EL_CONVEYOR_BELT_3_LEFT_ACTIVE,
6148 EL_CONVEYOR_BELT_4_LEFT_ACTIVE
6153 // set frame order for belt animation graphic according to belt direction
6154 for (i = 0; i < NUM_BELTS; i++)
6158 for (j = 0; j < NUM_BELT_PARTS; j++)
6160 int element = belt_base_active_element[belt_nr] + j;
6161 int graphic_1 = el2img(element);
6162 int graphic_2 = el2panelimg(element);
6164 if (game.belt_dir[i] == MV_LEFT)
6166 graphic_info[graphic_1].anim_mode &= ~ANIM_REVERSE;
6167 graphic_info[graphic_2].anim_mode &= ~ANIM_REVERSE;
6171 graphic_info[graphic_1].anim_mode |= ANIM_REVERSE;
6172 graphic_info[graphic_2].anim_mode |= ANIM_REVERSE;
6177 SCAN_PLAYFIELD(x, y)
6179 int element = Tile[x][y];
6181 for (i = 0; i < NUM_BELTS; i++)
6183 if (IS_BELT(element) && game.belt_dir[i] != MV_NONE)
6185 int e_belt_nr = getBeltNrFromBeltElement(element);
6188 if (e_belt_nr == belt_nr)
6190 int belt_part = Tile[x][y] - belt_base_element[belt_nr];
6192 Tile[x][y] = belt_base_active_element[belt_nr] + belt_part;
6199 static void ToggleBeltSwitch(int x, int y)
6201 static int belt_base_element[4] =
6203 EL_CONVEYOR_BELT_1_LEFT,
6204 EL_CONVEYOR_BELT_2_LEFT,
6205 EL_CONVEYOR_BELT_3_LEFT,
6206 EL_CONVEYOR_BELT_4_LEFT
6208 static int belt_base_active_element[4] =
6210 EL_CONVEYOR_BELT_1_LEFT_ACTIVE,
6211 EL_CONVEYOR_BELT_2_LEFT_ACTIVE,
6212 EL_CONVEYOR_BELT_3_LEFT_ACTIVE,
6213 EL_CONVEYOR_BELT_4_LEFT_ACTIVE
6215 static int belt_base_switch_element[4] =
6217 EL_CONVEYOR_BELT_1_SWITCH_LEFT,
6218 EL_CONVEYOR_BELT_2_SWITCH_LEFT,
6219 EL_CONVEYOR_BELT_3_SWITCH_LEFT,
6220 EL_CONVEYOR_BELT_4_SWITCH_LEFT
6222 static int belt_move_dir[4] =
6230 int element = Tile[x][y];
6231 int belt_nr = getBeltNrFromBeltSwitchElement(element);
6232 int belt_dir_nr = (game.belt_dir_nr[belt_nr] + 1) % 4;
6233 int belt_dir = belt_move_dir[belt_dir_nr];
6236 if (!IS_BELT_SWITCH(element))
6239 game.belt_dir_nr[belt_nr] = belt_dir_nr;
6240 game.belt_dir[belt_nr] = belt_dir;
6242 if (belt_dir_nr == 3)
6245 // set frame order for belt animation graphic according to belt direction
6246 for (i = 0; i < NUM_BELT_PARTS; i++)
6248 int element = belt_base_active_element[belt_nr] + i;
6249 int graphic_1 = el2img(element);
6250 int graphic_2 = el2panelimg(element);
6252 if (belt_dir == MV_LEFT)
6254 graphic_info[graphic_1].anim_mode &= ~ANIM_REVERSE;
6255 graphic_info[graphic_2].anim_mode &= ~ANIM_REVERSE;
6259 graphic_info[graphic_1].anim_mode |= ANIM_REVERSE;
6260 graphic_info[graphic_2].anim_mode |= ANIM_REVERSE;
6264 SCAN_PLAYFIELD(xx, yy)
6266 int element = Tile[xx][yy];
6268 if (IS_BELT_SWITCH(element))
6270 int e_belt_nr = getBeltNrFromBeltSwitchElement(element);
6272 if (e_belt_nr == belt_nr)
6274 Tile[xx][yy] = belt_base_switch_element[belt_nr] + belt_dir_nr;
6275 TEST_DrawLevelField(xx, yy);
6278 else if (IS_BELT(element) && belt_dir != MV_NONE)
6280 int e_belt_nr = getBeltNrFromBeltElement(element);
6282 if (e_belt_nr == belt_nr)
6284 int belt_part = Tile[xx][yy] - belt_base_element[belt_nr];
6286 Tile[xx][yy] = belt_base_active_element[belt_nr] + belt_part;
6287 TEST_DrawLevelField(xx, yy);
6290 else if (IS_BELT_ACTIVE(element) && belt_dir == MV_NONE)
6292 int e_belt_nr = getBeltNrFromBeltActiveElement(element);
6294 if (e_belt_nr == belt_nr)
6296 int belt_part = Tile[xx][yy] - belt_base_active_element[belt_nr];
6298 Tile[xx][yy] = belt_base_element[belt_nr] + belt_part;
6299 TEST_DrawLevelField(xx, yy);
6305 static void ToggleSwitchgateSwitch(int x, int y)
6309 game.switchgate_pos = !game.switchgate_pos;
6311 SCAN_PLAYFIELD(xx, yy)
6313 int element = Tile[xx][yy];
6315 if (element == EL_SWITCHGATE_SWITCH_UP)
6317 Tile[xx][yy] = EL_SWITCHGATE_SWITCH_DOWN;
6318 TEST_DrawLevelField(xx, yy);
6320 else if (element == EL_SWITCHGATE_SWITCH_DOWN)
6322 Tile[xx][yy] = EL_SWITCHGATE_SWITCH_UP;
6323 TEST_DrawLevelField(xx, yy);
6325 else if (element == EL_DC_SWITCHGATE_SWITCH_UP)
6327 Tile[xx][yy] = EL_DC_SWITCHGATE_SWITCH_DOWN;
6328 TEST_DrawLevelField(xx, yy);
6330 else if (element == EL_DC_SWITCHGATE_SWITCH_DOWN)
6332 Tile[xx][yy] = EL_DC_SWITCHGATE_SWITCH_UP;
6333 TEST_DrawLevelField(xx, yy);
6335 else if (element == EL_SWITCHGATE_OPEN ||
6336 element == EL_SWITCHGATE_OPENING)
6338 Tile[xx][yy] = EL_SWITCHGATE_CLOSING;
6340 PlayLevelSoundAction(xx, yy, ACTION_CLOSING);
6342 else if (element == EL_SWITCHGATE_CLOSED ||
6343 element == EL_SWITCHGATE_CLOSING)
6345 Tile[xx][yy] = EL_SWITCHGATE_OPENING;
6347 PlayLevelSoundAction(xx, yy, ACTION_OPENING);
6352 static int getInvisibleActiveFromInvisibleElement(int element)
6354 return (element == EL_INVISIBLE_STEELWALL ? EL_INVISIBLE_STEELWALL_ACTIVE :
6355 element == EL_INVISIBLE_WALL ? EL_INVISIBLE_WALL_ACTIVE :
6356 element == EL_INVISIBLE_SAND ? EL_INVISIBLE_SAND_ACTIVE :
6360 static int getInvisibleFromInvisibleActiveElement(int element)
6362 return (element == EL_INVISIBLE_STEELWALL_ACTIVE ? EL_INVISIBLE_STEELWALL :
6363 element == EL_INVISIBLE_WALL_ACTIVE ? EL_INVISIBLE_WALL :
6364 element == EL_INVISIBLE_SAND_ACTIVE ? EL_INVISIBLE_SAND :
6368 static void RedrawAllLightSwitchesAndInvisibleElements(void)
6372 SCAN_PLAYFIELD(x, y)
6374 int element = Tile[x][y];
6376 if (element == EL_LIGHT_SWITCH &&
6377 game.light_time_left > 0)
6379 Tile[x][y] = EL_LIGHT_SWITCH_ACTIVE;
6380 TEST_DrawLevelField(x, y);
6382 else if (element == EL_LIGHT_SWITCH_ACTIVE &&
6383 game.light_time_left == 0)
6385 Tile[x][y] = EL_LIGHT_SWITCH;
6386 TEST_DrawLevelField(x, y);
6388 else if (element == EL_EMC_DRIPPER &&
6389 game.light_time_left > 0)
6391 Tile[x][y] = EL_EMC_DRIPPER_ACTIVE;
6392 TEST_DrawLevelField(x, y);
6394 else if (element == EL_EMC_DRIPPER_ACTIVE &&
6395 game.light_time_left == 0)
6397 Tile[x][y] = EL_EMC_DRIPPER;
6398 TEST_DrawLevelField(x, y);
6400 else if (element == EL_INVISIBLE_STEELWALL ||
6401 element == EL_INVISIBLE_WALL ||
6402 element == EL_INVISIBLE_SAND)
6404 if (game.light_time_left > 0)
6405 Tile[x][y] = getInvisibleActiveFromInvisibleElement(element);
6407 TEST_DrawLevelField(x, y);
6409 // uncrumble neighbour fields, if needed
6410 if (element == EL_INVISIBLE_SAND)
6411 TEST_DrawLevelFieldCrumbledNeighbours(x, y);
6413 else if (element == EL_INVISIBLE_STEELWALL_ACTIVE ||
6414 element == EL_INVISIBLE_WALL_ACTIVE ||
6415 element == EL_INVISIBLE_SAND_ACTIVE)
6417 if (game.light_time_left == 0)
6418 Tile[x][y] = getInvisibleFromInvisibleActiveElement(element);
6420 TEST_DrawLevelField(x, y);
6422 // re-crumble neighbour fields, if needed
6423 if (element == EL_INVISIBLE_SAND)
6424 TEST_DrawLevelFieldCrumbledNeighbours(x, y);
6429 static void RedrawAllInvisibleElementsForLenses(void)
6433 SCAN_PLAYFIELD(x, y)
6435 int element = Tile[x][y];
6437 if (element == EL_EMC_DRIPPER &&
6438 game.lenses_time_left > 0)
6440 Tile[x][y] = EL_EMC_DRIPPER_ACTIVE;
6441 TEST_DrawLevelField(x, y);
6443 else if (element == EL_EMC_DRIPPER_ACTIVE &&
6444 game.lenses_time_left == 0)
6446 Tile[x][y] = EL_EMC_DRIPPER;
6447 TEST_DrawLevelField(x, y);
6449 else if (element == EL_INVISIBLE_STEELWALL ||
6450 element == EL_INVISIBLE_WALL ||
6451 element == EL_INVISIBLE_SAND)
6453 if (game.lenses_time_left > 0)
6454 Tile[x][y] = getInvisibleActiveFromInvisibleElement(element);
6456 TEST_DrawLevelField(x, y);
6458 // uncrumble neighbour fields, if needed
6459 if (element == EL_INVISIBLE_SAND)
6460 TEST_DrawLevelFieldCrumbledNeighbours(x, y);
6462 else if (element == EL_INVISIBLE_STEELWALL_ACTIVE ||
6463 element == EL_INVISIBLE_WALL_ACTIVE ||
6464 element == EL_INVISIBLE_SAND_ACTIVE)
6466 if (game.lenses_time_left == 0)
6467 Tile[x][y] = getInvisibleFromInvisibleActiveElement(element);
6469 TEST_DrawLevelField(x, y);
6471 // re-crumble neighbour fields, if needed
6472 if (element == EL_INVISIBLE_SAND)
6473 TEST_DrawLevelFieldCrumbledNeighbours(x, y);
6478 static void RedrawAllInvisibleElementsForMagnifier(void)
6482 SCAN_PLAYFIELD(x, y)
6484 int element = Tile[x][y];
6486 if (element == EL_EMC_FAKE_GRASS &&
6487 game.magnify_time_left > 0)
6489 Tile[x][y] = EL_EMC_FAKE_GRASS_ACTIVE;
6490 TEST_DrawLevelField(x, y);
6492 else if (element == EL_EMC_FAKE_GRASS_ACTIVE &&
6493 game.magnify_time_left == 0)
6495 Tile[x][y] = EL_EMC_FAKE_GRASS;
6496 TEST_DrawLevelField(x, y);
6498 else if (IS_GATE_GRAY(element) &&
6499 game.magnify_time_left > 0)
6501 Tile[x][y] = (IS_RND_GATE_GRAY(element) ?
6502 element - EL_GATE_1_GRAY + EL_GATE_1_GRAY_ACTIVE :
6503 IS_EM_GATE_GRAY(element) ?
6504 element - EL_EM_GATE_1_GRAY + EL_EM_GATE_1_GRAY_ACTIVE :
6505 IS_EMC_GATE_GRAY(element) ?
6506 element - EL_EMC_GATE_5_GRAY + EL_EMC_GATE_5_GRAY_ACTIVE :
6507 IS_DC_GATE_GRAY(element) ?
6508 EL_DC_GATE_WHITE_GRAY_ACTIVE :
6510 TEST_DrawLevelField(x, y);
6512 else if (IS_GATE_GRAY_ACTIVE(element) &&
6513 game.magnify_time_left == 0)
6515 Tile[x][y] = (IS_RND_GATE_GRAY_ACTIVE(element) ?
6516 element - EL_GATE_1_GRAY_ACTIVE + EL_GATE_1_GRAY :
6517 IS_EM_GATE_GRAY_ACTIVE(element) ?
6518 element - EL_EM_GATE_1_GRAY_ACTIVE + EL_EM_GATE_1_GRAY :
6519 IS_EMC_GATE_GRAY_ACTIVE(element) ?
6520 element - EL_EMC_GATE_5_GRAY_ACTIVE + EL_EMC_GATE_5_GRAY :
6521 IS_DC_GATE_GRAY_ACTIVE(element) ?
6522 EL_DC_GATE_WHITE_GRAY :
6524 TEST_DrawLevelField(x, y);
6529 static void ToggleLightSwitch(int x, int y)
6531 int element = Tile[x][y];
6533 game.light_time_left =
6534 (element == EL_LIGHT_SWITCH ?
6535 level.time_light * FRAMES_PER_SECOND : 0);
6537 RedrawAllLightSwitchesAndInvisibleElements();
6540 static void ActivateTimegateSwitch(int x, int y)
6544 game.timegate_time_left = level.time_timegate * FRAMES_PER_SECOND;
6546 SCAN_PLAYFIELD(xx, yy)
6548 int element = Tile[xx][yy];
6550 if (element == EL_TIMEGATE_CLOSED ||
6551 element == EL_TIMEGATE_CLOSING)
6553 Tile[xx][yy] = EL_TIMEGATE_OPENING;
6554 PlayLevelSound(xx, yy, SND_CLASS_TIMEGATE_OPENING);
6558 else if (element == EL_TIMEGATE_SWITCH_ACTIVE)
6560 Tile[xx][yy] = EL_TIMEGATE_SWITCH;
6561 TEST_DrawLevelField(xx, yy);
6567 Tile[x][y] = (Tile[x][y] == EL_TIMEGATE_SWITCH ? EL_TIMEGATE_SWITCH_ACTIVE :
6568 EL_DC_TIMEGATE_SWITCH_ACTIVE);
6571 static void Impact(int x, int y)
6573 boolean last_line = (y == lev_fieldy - 1);
6574 boolean object_hit = FALSE;
6575 boolean impact = (last_line || object_hit);
6576 int element = Tile[x][y];
6577 int smashed = EL_STEELWALL;
6579 if (!last_line) // check if element below was hit
6581 if (Tile[x][y + 1] == EL_PLAYER_IS_LEAVING)
6584 object_hit = (!IS_FREE(x, y + 1) && (!IS_MOVING(x, y + 1) ||
6585 MovDir[x][y + 1] != MV_DOWN ||
6586 MovPos[x][y + 1] <= TILEY / 2));
6588 // do not smash moving elements that left the smashed field in time
6589 if (game.engine_version >= VERSION_IDENT(2,2,0,7) && IS_MOVING(x, y + 1) &&
6590 ABS(MovPos[x][y + 1] + getElementMoveStepsize(x, y + 1)) >= TILEX)
6593 #if USE_QUICKSAND_IMPACT_BUGFIX
6594 if (Tile[x][y + 1] == EL_QUICKSAND_EMPTYING && object_hit == FALSE)
6596 RemoveMovingField(x, y + 1);
6597 Tile[x][y + 1] = EL_QUICKSAND_EMPTY;
6598 Tile[x][y + 2] = EL_ROCK;
6599 TEST_DrawLevelField(x, y + 2);
6604 if (Tile[x][y + 1] == EL_QUICKSAND_FAST_EMPTYING && object_hit == FALSE)
6606 RemoveMovingField(x, y + 1);
6607 Tile[x][y + 1] = EL_QUICKSAND_FAST_EMPTY;
6608 Tile[x][y + 2] = EL_ROCK;
6609 TEST_DrawLevelField(x, y + 2);
6616 smashed = MovingOrBlocked2Element(x, y + 1);
6618 impact = (last_line || object_hit);
6621 if (!last_line && smashed == EL_ACID) // element falls into acid
6623 SplashAcid(x, y + 1);
6627 // !!! not sufficient for all cases -- see EL_PEARL below !!!
6628 // only reset graphic animation if graphic really changes after impact
6630 el_act_dir2img(element, GfxAction[x][y], MV_DOWN) != el2img(element))
6632 ResetGfxAnimation(x, y);
6633 TEST_DrawLevelField(x, y);
6636 if (impact && CAN_EXPLODE_IMPACT(element))
6641 else if (impact && element == EL_PEARL &&
6642 smashed != EL_DC_MAGIC_WALL && smashed != EL_DC_MAGIC_WALL_ACTIVE)
6644 ResetGfxAnimation(x, y);
6646 Tile[x][y] = EL_PEARL_BREAKING;
6647 PlayLevelSound(x, y, SND_PEARL_BREAKING);
6650 else if (impact && CheckElementChange(x, y, element, smashed, CE_IMPACT))
6652 PlayLevelSoundElementAction(x, y, element, ACTION_IMPACT);
6657 if (impact && element == EL_AMOEBA_DROP)
6659 if (object_hit && IS_PLAYER(x, y + 1))
6660 KillPlayerUnlessEnemyProtected(x, y + 1);
6661 else if (object_hit && smashed == EL_PENGUIN)
6665 Tile[x][y] = EL_AMOEBA_GROWING;
6666 Store[x][y] = EL_AMOEBA_WET;
6668 ResetRandomAnimationValue(x, y);
6673 if (object_hit) // check which object was hit
6675 if ((CAN_PASS_MAGIC_WALL(element) &&
6676 (smashed == EL_MAGIC_WALL ||
6677 smashed == EL_BD_MAGIC_WALL)) ||
6678 (CAN_PASS_DC_MAGIC_WALL(element) &&
6679 smashed == EL_DC_MAGIC_WALL))
6682 int activated_magic_wall =
6683 (smashed == EL_MAGIC_WALL ? EL_MAGIC_WALL_ACTIVE :
6684 smashed == EL_BD_MAGIC_WALL ? EL_BD_MAGIC_WALL_ACTIVE :
6685 EL_DC_MAGIC_WALL_ACTIVE);
6687 // activate magic wall / mill
6688 SCAN_PLAYFIELD(xx, yy)
6690 if (Tile[xx][yy] == smashed)
6691 Tile[xx][yy] = activated_magic_wall;
6694 game.magic_wall_time_left = level.time_magic_wall * FRAMES_PER_SECOND;
6695 game.magic_wall_active = TRUE;
6697 PlayLevelSound(x, y, (smashed == EL_MAGIC_WALL ?
6698 SND_MAGIC_WALL_ACTIVATING :
6699 smashed == EL_BD_MAGIC_WALL ?
6700 SND_BD_MAGIC_WALL_ACTIVATING :
6701 SND_DC_MAGIC_WALL_ACTIVATING));
6704 if (IS_PLAYER(x, y + 1))
6706 if (CAN_SMASH_PLAYER(element))
6708 KillPlayerUnlessEnemyProtected(x, y + 1);
6712 else if (smashed == EL_PENGUIN)
6714 if (CAN_SMASH_PLAYER(element))
6720 else if (element == EL_BD_DIAMOND)
6722 if (IS_CLASSIC_ENEMY(smashed) && IS_BD_ELEMENT(smashed))
6728 else if (((element == EL_SP_INFOTRON ||
6729 element == EL_SP_ZONK) &&
6730 (smashed == EL_SP_SNIKSNAK ||
6731 smashed == EL_SP_ELECTRON ||
6732 smashed == EL_SP_DISK_ORANGE)) ||
6733 (element == EL_SP_INFOTRON &&
6734 smashed == EL_SP_DISK_YELLOW))
6739 else if (CAN_SMASH_EVERYTHING(element))
6741 if (IS_CLASSIC_ENEMY(smashed) ||
6742 CAN_EXPLODE_SMASHED(smashed))
6747 else if (!IS_MOVING(x, y + 1) && !IS_BLOCKED(x, y + 1))
6749 if (smashed == EL_LAMP ||
6750 smashed == EL_LAMP_ACTIVE)
6755 else if (smashed == EL_NUT)
6757 Tile[x][y + 1] = EL_NUT_BREAKING;
6758 PlayLevelSound(x, y, SND_NUT_BREAKING);
6759 RaiseScoreElement(EL_NUT);
6762 else if (smashed == EL_PEARL)
6764 ResetGfxAnimation(x, y);
6766 Tile[x][y + 1] = EL_PEARL_BREAKING;
6767 PlayLevelSound(x, y, SND_PEARL_BREAKING);
6770 else if (smashed == EL_DIAMOND)
6772 Tile[x][y + 1] = EL_DIAMOND_BREAKING;
6773 PlayLevelSound(x, y, SND_DIAMOND_BREAKING);
6776 else if (IS_BELT_SWITCH(smashed))
6778 ToggleBeltSwitch(x, y + 1);
6780 else if (smashed == EL_SWITCHGATE_SWITCH_UP ||
6781 smashed == EL_SWITCHGATE_SWITCH_DOWN ||
6782 smashed == EL_DC_SWITCHGATE_SWITCH_UP ||
6783 smashed == EL_DC_SWITCHGATE_SWITCH_DOWN)
6785 ToggleSwitchgateSwitch(x, y + 1);
6787 else if (smashed == EL_LIGHT_SWITCH ||
6788 smashed == EL_LIGHT_SWITCH_ACTIVE)
6790 ToggleLightSwitch(x, y + 1);
6794 CheckElementChange(x, y + 1, smashed, element, CE_SMASHED);
6796 CheckElementChangeBySide(x, y + 1, smashed, element,
6797 CE_SWITCHED, CH_SIDE_TOP);
6798 CheckTriggeredElementChangeBySide(x, y + 1, smashed, CE_SWITCH_OF_X,
6804 CheckElementChange(x, y + 1, smashed, element, CE_SMASHED);
6809 // play sound of magic wall / mill
6811 (Tile[x][y + 1] == EL_MAGIC_WALL_ACTIVE ||
6812 Tile[x][y + 1] == EL_BD_MAGIC_WALL_ACTIVE ||
6813 Tile[x][y + 1] == EL_DC_MAGIC_WALL_ACTIVE))
6815 if (Tile[x][y + 1] == EL_MAGIC_WALL_ACTIVE)
6816 PlayLevelSound(x, y, SND_MAGIC_WALL_FILLING);
6817 else if (Tile[x][y + 1] == EL_BD_MAGIC_WALL_ACTIVE)
6818 PlayLevelSound(x, y, SND_BD_MAGIC_WALL_FILLING);
6819 else if (Tile[x][y + 1] == EL_DC_MAGIC_WALL_ACTIVE)
6820 PlayLevelSound(x, y, SND_DC_MAGIC_WALL_FILLING);
6825 // play sound of object that hits the ground
6826 if (last_line || object_hit)
6827 PlayLevelSoundElementAction(x, y, element, ACTION_IMPACT);
6830 static void TurnRoundExt(int x, int y)
6842 { 0, 0 }, { 0, 0 }, { 0, 0 },
6847 int left, right, back;
6851 { MV_DOWN, MV_UP, MV_RIGHT },
6852 { MV_UP, MV_DOWN, MV_LEFT },
6854 { MV_LEFT, MV_RIGHT, MV_DOWN },
6858 { MV_RIGHT, MV_LEFT, MV_UP }
6861 int element = Tile[x][y];
6862 int move_pattern = element_info[element].move_pattern;
6864 int old_move_dir = MovDir[x][y];
6865 int left_dir = turn[old_move_dir].left;
6866 int right_dir = turn[old_move_dir].right;
6867 int back_dir = turn[old_move_dir].back;
6869 int left_dx = move_xy[left_dir].dx, left_dy = move_xy[left_dir].dy;
6870 int right_dx = move_xy[right_dir].dx, right_dy = move_xy[right_dir].dy;
6871 int move_dx = move_xy[old_move_dir].dx, move_dy = move_xy[old_move_dir].dy;
6872 int back_dx = move_xy[back_dir].dx, back_dy = move_xy[back_dir].dy;
6874 int left_x = x + left_dx, left_y = y + left_dy;
6875 int right_x = x + right_dx, right_y = y + right_dy;
6876 int move_x = x + move_dx, move_y = y + move_dy;
6880 if (element == EL_BUG || element == EL_BD_BUTTERFLY)
6882 TestIfBadThingTouchesOtherBadThing(x, y);
6884 if (ENEMY_CAN_ENTER_FIELD(element, right_x, right_y))
6885 MovDir[x][y] = right_dir;
6886 else if (!ENEMY_CAN_ENTER_FIELD(element, move_x, move_y))
6887 MovDir[x][y] = left_dir;
6889 if (element == EL_BUG && MovDir[x][y] != old_move_dir)
6891 else if (element == EL_BD_BUTTERFLY) // && MovDir[x][y] == left_dir)
6894 else if (element == EL_SPACESHIP || element == EL_BD_FIREFLY)
6896 TestIfBadThingTouchesOtherBadThing(x, y);
6898 if (ENEMY_CAN_ENTER_FIELD(element, left_x, left_y))
6899 MovDir[x][y] = left_dir;
6900 else if (!ENEMY_CAN_ENTER_FIELD(element, move_x, move_y))
6901 MovDir[x][y] = right_dir;
6903 if (element == EL_SPACESHIP && MovDir[x][y] != old_move_dir)
6905 else if (element == EL_BD_FIREFLY) // && MovDir[x][y] == right_dir)
6908 else if (element == EL_SP_SNIKSNAK || element == EL_SP_ELECTRON)
6910 TestIfBadThingTouchesOtherBadThing(x, y);
6912 if (ELEMENT_CAN_ENTER_FIELD_BASE_4(element, left_x, left_y, 0))
6913 MovDir[x][y] = left_dir;
6914 else if (!ELEMENT_CAN_ENTER_FIELD_BASE_4(element, move_x, move_y, 0))
6915 MovDir[x][y] = right_dir;
6917 if (MovDir[x][y] != old_move_dir)
6920 else if (element == EL_YAMYAM)
6922 boolean can_turn_left = YAMYAM_CAN_ENTER_FIELD(element, left_x, left_y);
6923 boolean can_turn_right = YAMYAM_CAN_ENTER_FIELD(element, right_x, right_y);
6925 if (can_turn_left && can_turn_right)
6926 MovDir[x][y] = (RND(3) ? (RND(2) ? left_dir : right_dir) : back_dir);
6927 else if (can_turn_left)
6928 MovDir[x][y] = (RND(2) ? left_dir : back_dir);
6929 else if (can_turn_right)
6930 MovDir[x][y] = (RND(2) ? right_dir : back_dir);
6932 MovDir[x][y] = back_dir;
6934 MovDelay[x][y] = 16 + 16 * RND(3);
6936 else if (element == EL_DARK_YAMYAM)
6938 boolean can_turn_left = DARK_YAMYAM_CAN_ENTER_FIELD(element,
6940 boolean can_turn_right = DARK_YAMYAM_CAN_ENTER_FIELD(element,
6943 if (can_turn_left && can_turn_right)
6944 MovDir[x][y] = (RND(3) ? (RND(2) ? left_dir : right_dir) : back_dir);
6945 else if (can_turn_left)
6946 MovDir[x][y] = (RND(2) ? left_dir : back_dir);
6947 else if (can_turn_right)
6948 MovDir[x][y] = (RND(2) ? right_dir : back_dir);
6950 MovDir[x][y] = back_dir;
6952 MovDelay[x][y] = 16 + 16 * RND(3);
6954 else if (element == EL_PACMAN)
6956 boolean can_turn_left = PACMAN_CAN_ENTER_FIELD(element, left_x, left_y);
6957 boolean can_turn_right = PACMAN_CAN_ENTER_FIELD(element, right_x, right_y);
6959 if (can_turn_left && can_turn_right)
6960 MovDir[x][y] = (RND(3) ? (RND(2) ? left_dir : right_dir) : back_dir);
6961 else if (can_turn_left)
6962 MovDir[x][y] = (RND(2) ? left_dir : back_dir);
6963 else if (can_turn_right)
6964 MovDir[x][y] = (RND(2) ? right_dir : back_dir);
6966 MovDir[x][y] = back_dir;
6968 MovDelay[x][y] = 6 + RND(40);
6970 else if (element == EL_PIG)
6972 boolean can_turn_left = PIG_CAN_ENTER_FIELD(element, left_x, left_y);
6973 boolean can_turn_right = PIG_CAN_ENTER_FIELD(element, right_x, right_y);
6974 boolean can_move_on = PIG_CAN_ENTER_FIELD(element, move_x, move_y);
6975 boolean should_turn_left, should_turn_right, should_move_on;
6977 int rnd = RND(rnd_value);
6979 should_turn_left = (can_turn_left &&
6981 IN_LEV_FIELD_AND_NOT_FREE(x + back_dx + left_dx,
6982 y + back_dy + left_dy)));
6983 should_turn_right = (can_turn_right &&
6985 IN_LEV_FIELD_AND_NOT_FREE(x + back_dx + right_dx,
6986 y + back_dy + right_dy)));
6987 should_move_on = (can_move_on &&
6990 IN_LEV_FIELD_AND_NOT_FREE(x + move_dx + left_dx,
6991 y + move_dy + left_dy) ||
6992 IN_LEV_FIELD_AND_NOT_FREE(x + move_dx + right_dx,
6993 y + move_dy + right_dy)));
6995 if (should_turn_left || should_turn_right || should_move_on)
6997 if (should_turn_left && should_turn_right && should_move_on)
6998 MovDir[x][y] = (rnd < rnd_value / 3 ? left_dir :
6999 rnd < 2 * rnd_value / 3 ? right_dir :
7001 else if (should_turn_left && should_turn_right)
7002 MovDir[x][y] = (rnd < rnd_value / 2 ? left_dir : right_dir);
7003 else if (should_turn_left && should_move_on)
7004 MovDir[x][y] = (rnd < rnd_value / 2 ? left_dir : old_move_dir);
7005 else if (should_turn_right && should_move_on)
7006 MovDir[x][y] = (rnd < rnd_value / 2 ? right_dir : old_move_dir);
7007 else if (should_turn_left)
7008 MovDir[x][y] = left_dir;
7009 else if (should_turn_right)
7010 MovDir[x][y] = right_dir;
7011 else if (should_move_on)
7012 MovDir[x][y] = old_move_dir;
7014 else if (can_move_on && rnd > rnd_value / 8)
7015 MovDir[x][y] = old_move_dir;
7016 else if (can_turn_left && can_turn_right)
7017 MovDir[x][y] = (rnd < rnd_value / 2 ? left_dir : right_dir);
7018 else if (can_turn_left && rnd > rnd_value / 8)
7019 MovDir[x][y] = left_dir;
7020 else if (can_turn_right && rnd > rnd_value/8)
7021 MovDir[x][y] = right_dir;
7023 MovDir[x][y] = back_dir;
7025 xx = x + move_xy[MovDir[x][y]].dx;
7026 yy = y + move_xy[MovDir[x][y]].dy;
7028 if (!IN_LEV_FIELD(xx, yy) ||
7029 (!IS_FREE(xx, yy) && !IS_FOOD_PIG(Tile[xx][yy])))
7030 MovDir[x][y] = old_move_dir;
7034 else if (element == EL_DRAGON)
7036 boolean can_turn_left = DRAGON_CAN_ENTER_FIELD(element, left_x, left_y);
7037 boolean can_turn_right = DRAGON_CAN_ENTER_FIELD(element, right_x, right_y);
7038 boolean can_move_on = DRAGON_CAN_ENTER_FIELD(element, move_x, move_y);
7040 int rnd = RND(rnd_value);
7042 if (can_move_on && rnd > rnd_value / 8)
7043 MovDir[x][y] = old_move_dir;
7044 else if (can_turn_left && can_turn_right)
7045 MovDir[x][y] = (rnd < rnd_value / 2 ? left_dir : right_dir);
7046 else if (can_turn_left && rnd > rnd_value / 8)
7047 MovDir[x][y] = left_dir;
7048 else if (can_turn_right && rnd > rnd_value / 8)
7049 MovDir[x][y] = right_dir;
7051 MovDir[x][y] = back_dir;
7053 xx = x + move_xy[MovDir[x][y]].dx;
7054 yy = y + move_xy[MovDir[x][y]].dy;
7056 if (!IN_LEV_FIELD_AND_IS_FREE(xx, yy))
7057 MovDir[x][y] = old_move_dir;
7061 else if (element == EL_MOLE)
7063 boolean can_move_on =
7064 (MOLE_CAN_ENTER_FIELD(element, move_x, move_y,
7065 IS_AMOEBOID(Tile[move_x][move_y]) ||
7066 Tile[move_x][move_y] == EL_AMOEBA_SHRINKING));
7069 boolean can_turn_left =
7070 (MOLE_CAN_ENTER_FIELD(element, left_x, left_y,
7071 IS_AMOEBOID(Tile[left_x][left_y])));
7073 boolean can_turn_right =
7074 (MOLE_CAN_ENTER_FIELD(element, right_x, right_y,
7075 IS_AMOEBOID(Tile[right_x][right_y])));
7077 if (can_turn_left && can_turn_right)
7078 MovDir[x][y] = (RND(2) ? left_dir : right_dir);
7079 else if (can_turn_left)
7080 MovDir[x][y] = left_dir;
7082 MovDir[x][y] = right_dir;
7085 if (MovDir[x][y] != old_move_dir)
7088 else if (element == EL_BALLOON)
7090 MovDir[x][y] = game.wind_direction;
7093 else if (element == EL_SPRING)
7095 if (MovDir[x][y] & MV_HORIZONTAL)
7097 if (SPRING_CAN_BUMP_FROM_FIELD(move_x, move_y) &&
7098 !SPRING_CAN_ENTER_FIELD(element, x, y + 1))
7100 Tile[move_x][move_y] = EL_EMC_SPRING_BUMPER_ACTIVE;
7101 ResetGfxAnimation(move_x, move_y);
7102 TEST_DrawLevelField(move_x, move_y);
7104 MovDir[x][y] = back_dir;
7106 else if (!SPRING_CAN_ENTER_FIELD(element, move_x, move_y) ||
7107 SPRING_CAN_ENTER_FIELD(element, x, y + 1))
7108 MovDir[x][y] = MV_NONE;
7113 else if (element == EL_ROBOT ||
7114 element == EL_SATELLITE ||
7115 element == EL_PENGUIN ||
7116 element == EL_EMC_ANDROID)
7118 int attr_x = -1, attr_y = -1;
7120 if (game.all_players_gone)
7122 attr_x = game.exit_x;
7123 attr_y = game.exit_y;
7129 for (i = 0; i < MAX_PLAYERS; i++)
7131 struct PlayerInfo *player = &stored_player[i];
7132 int jx = player->jx, jy = player->jy;
7134 if (!player->active)
7138 ABS(jx - x) + ABS(jy - y) < ABS(attr_x - x) + ABS(attr_y - y))
7146 if (element == EL_ROBOT &&
7147 game.robot_wheel_x >= 0 &&
7148 game.robot_wheel_y >= 0 &&
7149 (Tile[game.robot_wheel_x][game.robot_wheel_y] == EL_ROBOT_WHEEL_ACTIVE ||
7150 game.engine_version < VERSION_IDENT(3,1,0,0)))
7152 attr_x = game.robot_wheel_x;
7153 attr_y = game.robot_wheel_y;
7156 if (element == EL_PENGUIN)
7159 static int xy[4][2] =
7167 for (i = 0; i < NUM_DIRECTIONS; i++)
7169 int ex = x + xy[i][0];
7170 int ey = y + xy[i][1];
7172 if (IN_LEV_FIELD(ex, ey) && (Tile[ex][ey] == EL_EXIT_OPEN ||
7173 Tile[ex][ey] == EL_EM_EXIT_OPEN ||
7174 Tile[ex][ey] == EL_STEEL_EXIT_OPEN ||
7175 Tile[ex][ey] == EL_EM_STEEL_EXIT_OPEN))
7184 MovDir[x][y] = MV_NONE;
7186 MovDir[x][y] |= (game.all_players_gone ? MV_RIGHT : MV_LEFT);
7187 else if (attr_x > x)
7188 MovDir[x][y] |= (game.all_players_gone ? MV_LEFT : MV_RIGHT);
7190 MovDir[x][y] |= (game.all_players_gone ? MV_DOWN : MV_UP);
7191 else if (attr_y > y)
7192 MovDir[x][y] |= (game.all_players_gone ? MV_UP : MV_DOWN);
7194 if (element == EL_ROBOT)
7198 if (MovDir[x][y] & MV_HORIZONTAL && MovDir[x][y] & MV_VERTICAL)
7199 MovDir[x][y] &= (RND(2) ? MV_HORIZONTAL : MV_VERTICAL);
7200 Moving2Blocked(x, y, &newx, &newy);
7202 if (IN_LEV_FIELD(newx, newy) && IS_FREE_OR_PLAYER(newx, newy))
7203 MovDelay[x][y] = 8 + 8 * !RND(3);
7205 MovDelay[x][y] = 16;
7207 else if (element == EL_PENGUIN)
7213 if (MovDir[x][y] & MV_HORIZONTAL && MovDir[x][y] & MV_VERTICAL)
7215 boolean first_horiz = RND(2);
7216 int new_move_dir = MovDir[x][y];
7219 new_move_dir & (first_horiz ? MV_HORIZONTAL : MV_VERTICAL);
7220 Moving2Blocked(x, y, &newx, &newy);
7222 if (PENGUIN_CAN_ENTER_FIELD(element, newx, newy))
7226 new_move_dir & (!first_horiz ? MV_HORIZONTAL : MV_VERTICAL);
7227 Moving2Blocked(x, y, &newx, &newy);
7229 if (PENGUIN_CAN_ENTER_FIELD(element, newx, newy))
7232 MovDir[x][y] = old_move_dir;
7236 else if (element == EL_SATELLITE)
7242 if (MovDir[x][y] & MV_HORIZONTAL && MovDir[x][y] & MV_VERTICAL)
7244 boolean first_horiz = RND(2);
7245 int new_move_dir = MovDir[x][y];
7248 new_move_dir & (first_horiz ? MV_HORIZONTAL : MV_VERTICAL);
7249 Moving2Blocked(x, y, &newx, &newy);
7251 if (SATELLITE_CAN_ENTER_FIELD(newx, newy))
7255 new_move_dir & (!first_horiz ? MV_HORIZONTAL : MV_VERTICAL);
7256 Moving2Blocked(x, y, &newx, &newy);
7258 if (SATELLITE_CAN_ENTER_FIELD(newx, newy))
7261 MovDir[x][y] = old_move_dir;
7265 else if (element == EL_EMC_ANDROID)
7267 static int check_pos[16] =
7269 -1, // 0 => (invalid)
7272 -1, // 3 => (invalid)
7274 0, // 5 => MV_LEFT | MV_UP
7275 2, // 6 => MV_RIGHT | MV_UP
7276 -1, // 7 => (invalid)
7278 6, // 9 => MV_LEFT | MV_DOWN
7279 4, // 10 => MV_RIGHT | MV_DOWN
7280 -1, // 11 => (invalid)
7281 -1, // 12 => (invalid)
7282 -1, // 13 => (invalid)
7283 -1, // 14 => (invalid)
7284 -1, // 15 => (invalid)
7292 { -1, -1, MV_LEFT | MV_UP },
7294 { +1, -1, MV_RIGHT | MV_UP },
7295 { +1, 0, MV_RIGHT },
7296 { +1, +1, MV_RIGHT | MV_DOWN },
7298 { -1, +1, MV_LEFT | MV_DOWN },
7301 int start_pos, check_order;
7302 boolean can_clone = FALSE;
7305 // check if there is any free field around current position
7306 for (i = 0; i < 8; i++)
7308 int newx = x + check_xy[i].dx;
7309 int newy = y + check_xy[i].dy;
7311 if (IN_LEV_FIELD_AND_IS_FREE(newx, newy))
7319 if (can_clone) // randomly find an element to clone
7323 start_pos = check_pos[RND(8)];
7324 check_order = (RND(2) ? -1 : +1);
7326 for (i = 0; i < 8; i++)
7328 int pos_raw = start_pos + i * check_order;
7329 int pos = (pos_raw + 8) % 8;
7330 int newx = x + check_xy[pos].dx;
7331 int newy = y + check_xy[pos].dy;
7333 if (ANDROID_CAN_CLONE_FIELD(newx, newy))
7335 element_info[element].move_leave_type = LEAVE_TYPE_LIMITED;
7336 element_info[element].move_leave_element = EL_TRIGGER_ELEMENT;
7338 Store[x][y] = Tile[newx][newy];
7347 if (can_clone) // randomly find a direction to move
7351 start_pos = check_pos[RND(8)];
7352 check_order = (RND(2) ? -1 : +1);
7354 for (i = 0; i < 8; i++)
7356 int pos_raw = start_pos + i * check_order;
7357 int pos = (pos_raw + 8) % 8;
7358 int newx = x + check_xy[pos].dx;
7359 int newy = y + check_xy[pos].dy;
7360 int new_move_dir = check_xy[pos].dir;
7362 if (IN_LEV_FIELD_AND_IS_FREE(newx, newy))
7364 MovDir[x][y] = new_move_dir;
7365 MovDelay[x][y] = level.android_clone_time * 8 + 1;
7374 if (can_clone) // cloning and moving successful
7377 // cannot clone -- try to move towards player
7379 start_pos = check_pos[MovDir[x][y] & 0x0f];
7380 check_order = (RND(2) ? -1 : +1);
7382 for (i = 0; i < 3; i++)
7384 // first check start_pos, then previous/next or (next/previous) pos
7385 int pos_raw = start_pos + (i < 2 ? i : -1) * check_order;
7386 int pos = (pos_raw + 8) % 8;
7387 int newx = x + check_xy[pos].dx;
7388 int newy = y + check_xy[pos].dy;
7389 int new_move_dir = check_xy[pos].dir;
7391 if (IS_PLAYER(newx, newy))
7394 if (ANDROID_CAN_ENTER_FIELD(element, newx, newy))
7396 MovDir[x][y] = new_move_dir;
7397 MovDelay[x][y] = level.android_move_time * 8 + 1;
7404 else if (move_pattern == MV_TURNING_LEFT ||
7405 move_pattern == MV_TURNING_RIGHT ||
7406 move_pattern == MV_TURNING_LEFT_RIGHT ||
7407 move_pattern == MV_TURNING_RIGHT_LEFT ||
7408 move_pattern == MV_TURNING_RANDOM ||
7409 move_pattern == MV_ALL_DIRECTIONS)
7411 boolean can_turn_left =
7412 CUSTOM_ELEMENT_CAN_ENTER_FIELD(element, left_x, left_y);
7413 boolean can_turn_right =
7414 CUSTOM_ELEMENT_CAN_ENTER_FIELD(element, right_x,right_y);
7416 if (element_info[element].move_stepsize == 0) // "not moving"
7419 if (move_pattern == MV_TURNING_LEFT)
7420 MovDir[x][y] = left_dir;
7421 else if (move_pattern == MV_TURNING_RIGHT)
7422 MovDir[x][y] = right_dir;
7423 else if (move_pattern == MV_TURNING_LEFT_RIGHT)
7424 MovDir[x][y] = (can_turn_left || !can_turn_right ? left_dir : right_dir);
7425 else if (move_pattern == MV_TURNING_RIGHT_LEFT)
7426 MovDir[x][y] = (can_turn_right || !can_turn_left ? right_dir : left_dir);
7427 else if (move_pattern == MV_TURNING_RANDOM)
7428 MovDir[x][y] = (can_turn_left && !can_turn_right ? left_dir :
7429 can_turn_right && !can_turn_left ? right_dir :
7430 RND(2) ? left_dir : right_dir);
7431 else if (can_turn_left && can_turn_right)
7432 MovDir[x][y] = (RND(3) ? (RND(2) ? left_dir : right_dir) : back_dir);
7433 else if (can_turn_left)
7434 MovDir[x][y] = (RND(2) ? left_dir : back_dir);
7435 else if (can_turn_right)
7436 MovDir[x][y] = (RND(2) ? right_dir : back_dir);
7438 MovDir[x][y] = back_dir;
7440 MovDelay[x][y] = GET_NEW_MOVE_DELAY(element);
7442 else if (move_pattern == MV_HORIZONTAL ||
7443 move_pattern == MV_VERTICAL)
7445 if (move_pattern & old_move_dir)
7446 MovDir[x][y] = back_dir;
7447 else if (move_pattern == MV_HORIZONTAL)
7448 MovDir[x][y] = (RND(2) ? MV_LEFT : MV_RIGHT);
7449 else if (move_pattern == MV_VERTICAL)
7450 MovDir[x][y] = (RND(2) ? MV_UP : MV_DOWN);
7452 MovDelay[x][y] = GET_NEW_MOVE_DELAY(element);
7454 else if (move_pattern & MV_ANY_DIRECTION)
7456 MovDir[x][y] = move_pattern;
7457 MovDelay[x][y] = GET_NEW_MOVE_DELAY(element);
7459 else if (move_pattern & MV_WIND_DIRECTION)
7461 MovDir[x][y] = game.wind_direction;
7462 MovDelay[x][y] = GET_NEW_MOVE_DELAY(element);
7464 else if (move_pattern == MV_ALONG_LEFT_SIDE)
7466 if (CUSTOM_ELEMENT_CAN_ENTER_FIELD(element, left_x, left_y))
7467 MovDir[x][y] = left_dir;
7468 else if (!CUSTOM_ELEMENT_CAN_ENTER_FIELD(element, move_x, move_y))
7469 MovDir[x][y] = right_dir;
7471 if (MovDir[x][y] != old_move_dir)
7472 MovDelay[x][y] = GET_NEW_MOVE_DELAY(element);
7474 else if (move_pattern == MV_ALONG_RIGHT_SIDE)
7476 if (CUSTOM_ELEMENT_CAN_ENTER_FIELD(element, right_x, right_y))
7477 MovDir[x][y] = right_dir;
7478 else if (!CUSTOM_ELEMENT_CAN_ENTER_FIELD(element, move_x, move_y))
7479 MovDir[x][y] = left_dir;
7481 if (MovDir[x][y] != old_move_dir)
7482 MovDelay[x][y] = GET_NEW_MOVE_DELAY(element);
7484 else if (move_pattern == MV_TOWARDS_PLAYER ||
7485 move_pattern == MV_AWAY_FROM_PLAYER)
7487 int attr_x = -1, attr_y = -1;
7489 boolean move_away = (move_pattern == MV_AWAY_FROM_PLAYER);
7491 if (game.all_players_gone)
7493 attr_x = game.exit_x;
7494 attr_y = game.exit_y;
7500 for (i = 0; i < MAX_PLAYERS; i++)
7502 struct PlayerInfo *player = &stored_player[i];
7503 int jx = player->jx, jy = player->jy;
7505 if (!player->active)
7509 ABS(jx - x) + ABS(jy - y) < ABS(attr_x - x) + ABS(attr_y - y))
7517 MovDir[x][y] = MV_NONE;
7519 MovDir[x][y] |= (move_away ? MV_RIGHT : MV_LEFT);
7520 else if (attr_x > x)
7521 MovDir[x][y] |= (move_away ? MV_LEFT : MV_RIGHT);
7523 MovDir[x][y] |= (move_away ? MV_DOWN : MV_UP);
7524 else if (attr_y > y)
7525 MovDir[x][y] |= (move_away ? MV_UP : MV_DOWN);
7527 MovDelay[x][y] = GET_NEW_MOVE_DELAY(element);
7529 if (MovDir[x][y] & MV_HORIZONTAL && MovDir[x][y] & MV_VERTICAL)
7531 boolean first_horiz = RND(2);
7532 int new_move_dir = MovDir[x][y];
7534 if (element_info[element].move_stepsize == 0) // "not moving"
7536 first_horiz = (ABS(attr_x - x) >= ABS(attr_y - y));
7537 MovDir[x][y] &= (first_horiz ? MV_HORIZONTAL : MV_VERTICAL);
7543 new_move_dir & (first_horiz ? MV_HORIZONTAL : MV_VERTICAL);
7544 Moving2Blocked(x, y, &newx, &newy);
7546 if (CUSTOM_ELEMENT_CAN_ENTER_FIELD(element, newx, newy))
7550 new_move_dir & (!first_horiz ? MV_HORIZONTAL : MV_VERTICAL);
7551 Moving2Blocked(x, y, &newx, &newy);
7553 if (CUSTOM_ELEMENT_CAN_ENTER_FIELD(element, newx, newy))
7556 MovDir[x][y] = old_move_dir;
7559 else if (move_pattern == MV_WHEN_PUSHED ||
7560 move_pattern == MV_WHEN_DROPPED)
7562 if (!CUSTOM_ELEMENT_CAN_ENTER_FIELD(element, move_x, move_y))
7563 MovDir[x][y] = MV_NONE;
7567 else if (move_pattern & MV_MAZE_RUNNER_STYLE)
7569 static int test_xy[7][2] =
7579 static int test_dir[7] =
7589 boolean hunter_mode = (move_pattern == MV_MAZE_HUNTER);
7590 int move_preference = -1000000; // start with very low preference
7591 int new_move_dir = MV_NONE;
7592 int start_test = RND(4);
7595 for (i = 0; i < NUM_DIRECTIONS; i++)
7597 int move_dir = test_dir[start_test + i];
7598 int move_dir_preference;
7600 xx = x + test_xy[start_test + i][0];
7601 yy = y + test_xy[start_test + i][1];
7603 if (hunter_mode && IN_LEV_FIELD(xx, yy) &&
7604 (IS_PLAYER(xx, yy) || Tile[xx][yy] == EL_PLAYER_IS_LEAVING))
7606 new_move_dir = move_dir;
7611 if (!CUSTOM_ELEMENT_CAN_ENTER_FIELD(element, xx, yy))
7614 move_dir_preference = -1 * RunnerVisit[xx][yy];
7615 if (hunter_mode && PlayerVisit[xx][yy] > 0)
7616 move_dir_preference = PlayerVisit[xx][yy];
7618 if (move_dir_preference > move_preference)
7620 // prefer field that has not been visited for the longest time
7621 move_preference = move_dir_preference;
7622 new_move_dir = move_dir;
7624 else if (move_dir_preference == move_preference &&
7625 move_dir == old_move_dir)
7627 // prefer last direction when all directions are preferred equally
7628 move_preference = move_dir_preference;
7629 new_move_dir = move_dir;
7633 MovDir[x][y] = new_move_dir;
7634 if (old_move_dir != new_move_dir)
7635 MovDelay[x][y] = GET_NEW_MOVE_DELAY(element);
7639 static void TurnRound(int x, int y)
7641 int direction = MovDir[x][y];
7645 GfxDir[x][y] = MovDir[x][y];
7647 if (direction != MovDir[x][y])
7651 GfxAction[x][y] = ACTION_TURNING_FROM_LEFT + MV_DIR_TO_BIT(direction);
7653 ResetGfxFrame(x, y);
7656 static boolean JustBeingPushed(int x, int y)
7660 for (i = 0; i < MAX_PLAYERS; i++)
7662 struct PlayerInfo *player = &stored_player[i];
7664 if (player->active && player->is_pushing && player->MovPos)
7666 int next_jx = player->jx + (player->jx - player->last_jx);
7667 int next_jy = player->jy + (player->jy - player->last_jy);
7669 if (x == next_jx && y == next_jy)
7677 static void StartMoving(int x, int y)
7679 boolean started_moving = FALSE; // some elements can fall _and_ move
7680 int element = Tile[x][y];
7685 if (MovDelay[x][y] == 0)
7686 GfxAction[x][y] = ACTION_DEFAULT;
7688 if (CAN_FALL(element) && y < lev_fieldy - 1)
7690 if ((x > 0 && IS_PLAYER(x - 1, y)) ||
7691 (x < lev_fieldx - 1 && IS_PLAYER(x + 1, y)))
7692 if (JustBeingPushed(x, y))
7695 if (element == EL_QUICKSAND_FULL)
7697 if (IS_FREE(x, y + 1))
7699 InitMovingField(x, y, MV_DOWN);
7700 started_moving = TRUE;
7702 Tile[x][y] = EL_QUICKSAND_EMPTYING;
7703 #if USE_QUICKSAND_BD_ROCK_BUGFIX
7704 if (Store[x][y] != EL_ROCK && Store[x][y] != EL_BD_ROCK)
7705 Store[x][y] = EL_ROCK;
7707 Store[x][y] = EL_ROCK;
7710 PlayLevelSoundAction(x, y, ACTION_EMPTYING);
7712 else if (Tile[x][y + 1] == EL_QUICKSAND_EMPTY)
7714 if (!MovDelay[x][y])
7716 MovDelay[x][y] = TILEY + 1;
7718 ResetGfxAnimation(x, y);
7719 ResetGfxAnimation(x, y + 1);
7724 DrawLevelElement(x, y, EL_QUICKSAND_EMPTYING);
7725 DrawLevelElement(x, y + 1, EL_QUICKSAND_FILLING);
7732 Tile[x][y] = EL_QUICKSAND_EMPTY;
7733 Tile[x][y + 1] = EL_QUICKSAND_FULL;
7734 Store[x][y + 1] = Store[x][y];
7737 PlayLevelSoundAction(x, y, ACTION_FILLING);
7739 else if (Tile[x][y + 1] == EL_QUICKSAND_FAST_EMPTY)
7741 if (!MovDelay[x][y])
7743 MovDelay[x][y] = TILEY + 1;
7745 ResetGfxAnimation(x, y);
7746 ResetGfxAnimation(x, y + 1);
7751 DrawLevelElement(x, y, EL_QUICKSAND_EMPTYING);
7752 DrawLevelElement(x, y + 1, EL_QUICKSAND_FAST_FILLING);
7759 Tile[x][y] = EL_QUICKSAND_EMPTY;
7760 Tile[x][y + 1] = EL_QUICKSAND_FAST_FULL;
7761 Store[x][y + 1] = Store[x][y];
7764 PlayLevelSoundAction(x, y, ACTION_FILLING);
7767 else if (element == EL_QUICKSAND_FAST_FULL)
7769 if (IS_FREE(x, y + 1))
7771 InitMovingField(x, y, MV_DOWN);
7772 started_moving = TRUE;
7774 Tile[x][y] = EL_QUICKSAND_FAST_EMPTYING;
7775 #if USE_QUICKSAND_BD_ROCK_BUGFIX
7776 if (Store[x][y] != EL_ROCK && Store[x][y] != EL_BD_ROCK)
7777 Store[x][y] = EL_ROCK;
7779 Store[x][y] = EL_ROCK;
7782 PlayLevelSoundAction(x, y, ACTION_EMPTYING);
7784 else if (Tile[x][y + 1] == EL_QUICKSAND_FAST_EMPTY)
7786 if (!MovDelay[x][y])
7788 MovDelay[x][y] = TILEY + 1;
7790 ResetGfxAnimation(x, y);
7791 ResetGfxAnimation(x, y + 1);
7796 DrawLevelElement(x, y, EL_QUICKSAND_FAST_EMPTYING);
7797 DrawLevelElement(x, y + 1, EL_QUICKSAND_FAST_FILLING);
7804 Tile[x][y] = EL_QUICKSAND_FAST_EMPTY;
7805 Tile[x][y + 1] = EL_QUICKSAND_FAST_FULL;
7806 Store[x][y + 1] = Store[x][y];
7809 PlayLevelSoundAction(x, y, ACTION_FILLING);
7811 else if (Tile[x][y + 1] == EL_QUICKSAND_EMPTY)
7813 if (!MovDelay[x][y])
7815 MovDelay[x][y] = TILEY + 1;
7817 ResetGfxAnimation(x, y);
7818 ResetGfxAnimation(x, y + 1);
7823 DrawLevelElement(x, y, EL_QUICKSAND_FAST_EMPTYING);
7824 DrawLevelElement(x, y + 1, EL_QUICKSAND_FILLING);
7831 Tile[x][y] = EL_QUICKSAND_FAST_EMPTY;
7832 Tile[x][y + 1] = EL_QUICKSAND_FULL;
7833 Store[x][y + 1] = Store[x][y];
7836 PlayLevelSoundAction(x, y, ACTION_FILLING);
7839 else if ((element == EL_ROCK || element == EL_BD_ROCK) &&
7840 Tile[x][y + 1] == EL_QUICKSAND_EMPTY)
7842 InitMovingField(x, y, MV_DOWN);
7843 started_moving = TRUE;
7845 Tile[x][y] = EL_QUICKSAND_FILLING;
7846 Store[x][y] = element;
7848 PlayLevelSoundAction(x, y, ACTION_FILLING);
7850 else if ((element == EL_ROCK || element == EL_BD_ROCK) &&
7851 Tile[x][y + 1] == EL_QUICKSAND_FAST_EMPTY)
7853 InitMovingField(x, y, MV_DOWN);
7854 started_moving = TRUE;
7856 Tile[x][y] = EL_QUICKSAND_FAST_FILLING;
7857 Store[x][y] = element;
7859 PlayLevelSoundAction(x, y, ACTION_FILLING);
7861 else if (element == EL_MAGIC_WALL_FULL)
7863 if (IS_FREE(x, y + 1))
7865 InitMovingField(x, y, MV_DOWN);
7866 started_moving = TRUE;
7868 Tile[x][y] = EL_MAGIC_WALL_EMPTYING;
7869 Store[x][y] = EL_CHANGED(Store[x][y]);
7871 else if (Tile[x][y + 1] == EL_MAGIC_WALL_ACTIVE)
7873 if (!MovDelay[x][y])
7874 MovDelay[x][y] = TILEY / 4 + 1;
7883 Tile[x][y] = EL_MAGIC_WALL_ACTIVE;
7884 Tile[x][y + 1] = EL_MAGIC_WALL_FULL;
7885 Store[x][y + 1] = EL_CHANGED(Store[x][y]);
7889 else if (element == EL_BD_MAGIC_WALL_FULL)
7891 if (IS_FREE(x, y + 1))
7893 InitMovingField(x, y, MV_DOWN);
7894 started_moving = TRUE;
7896 Tile[x][y] = EL_BD_MAGIC_WALL_EMPTYING;
7897 Store[x][y] = EL_CHANGED_BD(Store[x][y]);
7899 else if (Tile[x][y + 1] == EL_BD_MAGIC_WALL_ACTIVE)
7901 if (!MovDelay[x][y])
7902 MovDelay[x][y] = TILEY / 4 + 1;
7911 Tile[x][y] = EL_BD_MAGIC_WALL_ACTIVE;
7912 Tile[x][y + 1] = EL_BD_MAGIC_WALL_FULL;
7913 Store[x][y + 1] = EL_CHANGED_BD(Store[x][y]);
7917 else if (element == EL_DC_MAGIC_WALL_FULL)
7919 if (IS_FREE(x, y + 1))
7921 InitMovingField(x, y, MV_DOWN);
7922 started_moving = TRUE;
7924 Tile[x][y] = EL_DC_MAGIC_WALL_EMPTYING;
7925 Store[x][y] = EL_CHANGED_DC(Store[x][y]);
7927 else if (Tile[x][y + 1] == EL_DC_MAGIC_WALL_ACTIVE)
7929 if (!MovDelay[x][y])
7930 MovDelay[x][y] = TILEY / 4 + 1;
7939 Tile[x][y] = EL_DC_MAGIC_WALL_ACTIVE;
7940 Tile[x][y + 1] = EL_DC_MAGIC_WALL_FULL;
7941 Store[x][y + 1] = EL_CHANGED_DC(Store[x][y]);
7945 else if ((CAN_PASS_MAGIC_WALL(element) &&
7946 (Tile[x][y + 1] == EL_MAGIC_WALL_ACTIVE ||
7947 Tile[x][y + 1] == EL_BD_MAGIC_WALL_ACTIVE)) ||
7948 (CAN_PASS_DC_MAGIC_WALL(element) &&
7949 (Tile[x][y + 1] == EL_DC_MAGIC_WALL_ACTIVE)))
7952 InitMovingField(x, y, MV_DOWN);
7953 started_moving = TRUE;
7956 (Tile[x][y + 1] == EL_MAGIC_WALL_ACTIVE ? EL_MAGIC_WALL_FILLING :
7957 Tile[x][y + 1] == EL_BD_MAGIC_WALL_ACTIVE ? EL_BD_MAGIC_WALL_FILLING :
7958 EL_DC_MAGIC_WALL_FILLING);
7959 Store[x][y] = element;
7961 else if (CAN_FALL(element) && Tile[x][y + 1] == EL_ACID)
7963 SplashAcid(x, y + 1);
7965 InitMovingField(x, y, MV_DOWN);
7966 started_moving = TRUE;
7968 Store[x][y] = EL_ACID;
7971 (game.engine_version >= VERSION_IDENT(3,1,0,0) &&
7972 CheckImpact[x][y] && !IS_FREE(x, y + 1)) ||
7973 (game.engine_version >= VERSION_IDENT(3,0,7,0) &&
7974 CAN_FALL(element) && WasJustFalling[x][y] &&
7975 (Tile[x][y + 1] == EL_BLOCKED || IS_PLAYER(x, y + 1))) ||
7977 (game.engine_version < VERSION_IDENT(2,2,0,7) &&
7978 CAN_FALL(element) && WasJustMoving[x][y] && !Pushed[x][y + 1] &&
7979 (Tile[x][y + 1] == EL_BLOCKED)))
7981 /* this is needed for a special case not covered by calling "Impact()"
7982 from "ContinueMoving()": if an element moves to a tile directly below
7983 another element which was just falling on that tile (which was empty
7984 in the previous frame), the falling element above would just stop
7985 instead of smashing the element below (in previous version, the above
7986 element was just checked for "moving" instead of "falling", resulting
7987 in incorrect smashes caused by horizontal movement of the above
7988 element; also, the case of the player being the element to smash was
7989 simply not covered here... :-/ ) */
7991 CheckCollision[x][y] = 0;
7992 CheckImpact[x][y] = 0;
7996 else if (IS_FREE(x, y + 1) && element == EL_SPRING && level.use_spring_bug)
7998 if (MovDir[x][y] == MV_NONE)
8000 InitMovingField(x, y, MV_DOWN);
8001 started_moving = TRUE;
8004 else if (IS_FREE(x, y + 1) || Tile[x][y + 1] == EL_DIAMOND_BREAKING)
8006 if (WasJustFalling[x][y]) // prevent animation from being restarted
8007 MovDir[x][y] = MV_DOWN;
8009 InitMovingField(x, y, MV_DOWN);
8010 started_moving = TRUE;
8012 else if (element == EL_AMOEBA_DROP)
8014 Tile[x][y] = EL_AMOEBA_GROWING;
8015 Store[x][y] = EL_AMOEBA_WET;
8017 else if (((IS_SLIPPERY(Tile[x][y + 1]) && !IS_PLAYER(x, y + 1)) ||
8018 (IS_EM_SLIPPERY_WALL(Tile[x][y + 1]) && IS_GEM(element))) &&
8019 !IS_FALLING(x, y + 1) && !WasJustMoving[x][y + 1] &&
8020 element != EL_DX_SUPABOMB && element != EL_SP_DISK_ORANGE)
8022 boolean can_fall_left = (x > 0 && IS_FREE(x - 1, y) &&
8023 (IS_FREE(x - 1, y + 1) ||
8024 Tile[x - 1][y + 1] == EL_ACID));
8025 boolean can_fall_right = (x < lev_fieldx - 1 && IS_FREE(x + 1, y) &&
8026 (IS_FREE(x + 1, y + 1) ||
8027 Tile[x + 1][y + 1] == EL_ACID));
8028 boolean can_fall_any = (can_fall_left || can_fall_right);
8029 boolean can_fall_both = (can_fall_left && can_fall_right);
8030 int slippery_type = element_info[Tile[x][y + 1]].slippery_type;
8032 if (can_fall_any && slippery_type != SLIPPERY_ANY_RANDOM)
8034 if (slippery_type == SLIPPERY_ANY_LEFT_RIGHT && can_fall_both)
8035 can_fall_right = FALSE;
8036 else if (slippery_type == SLIPPERY_ANY_RIGHT_LEFT && can_fall_both)
8037 can_fall_left = FALSE;
8038 else if (slippery_type == SLIPPERY_ONLY_LEFT)
8039 can_fall_right = FALSE;
8040 else if (slippery_type == SLIPPERY_ONLY_RIGHT)
8041 can_fall_left = FALSE;
8043 can_fall_any = (can_fall_left || can_fall_right);
8044 can_fall_both = FALSE;
8049 if (element == EL_BD_ROCK || element == EL_BD_DIAMOND)
8050 can_fall_right = FALSE; // slip down on left side
8052 can_fall_left = !(can_fall_right = RND(2));
8054 can_fall_both = FALSE;
8059 // if not determined otherwise, prefer left side for slipping down
8060 InitMovingField(x, y, can_fall_left ? MV_LEFT : MV_RIGHT);
8061 started_moving = TRUE;
8064 else if (IS_BELT_ACTIVE(Tile[x][y + 1]))
8066 boolean left_is_free = (x > 0 && IS_FREE(x - 1, y));
8067 boolean right_is_free = (x < lev_fieldx - 1 && IS_FREE(x + 1, y));
8068 int belt_nr = getBeltNrFromBeltActiveElement(Tile[x][y + 1]);
8069 int belt_dir = game.belt_dir[belt_nr];
8071 if ((belt_dir == MV_LEFT && left_is_free) ||
8072 (belt_dir == MV_RIGHT && right_is_free))
8074 int nextx = (belt_dir == MV_LEFT ? x - 1 : x + 1);
8076 InitMovingField(x, y, belt_dir);
8077 started_moving = TRUE;
8079 Pushed[x][y] = TRUE;
8080 Pushed[nextx][y] = TRUE;
8082 GfxAction[x][y] = ACTION_DEFAULT;
8086 MovDir[x][y] = 0; // if element was moving, stop it
8091 // not "else if" because of elements that can fall and move (EL_SPRING)
8092 if (CAN_MOVE(element) && !started_moving)
8094 int move_pattern = element_info[element].move_pattern;
8097 Moving2Blocked(x, y, &newx, &newy);
8099 if (IS_PUSHABLE(element) && JustBeingPushed(x, y))
8102 if (game.engine_version >= VERSION_IDENT(3,1,0,0) &&
8103 CheckCollision[x][y] && !IN_LEV_FIELD_AND_IS_FREE(newx, newy))
8105 WasJustMoving[x][y] = 0;
8106 CheckCollision[x][y] = 0;
8108 TestIfElementHitsCustomElement(x, y, MovDir[x][y]);
8110 if (Tile[x][y] != element) // element has changed
8114 if (!MovDelay[x][y]) // start new movement phase
8116 // all objects that can change their move direction after each step
8117 // (YAMYAM, DARK_YAMYAM and PACMAN go straight until they hit a wall
8119 if (element != EL_YAMYAM &&
8120 element != EL_DARK_YAMYAM &&
8121 element != EL_PACMAN &&
8122 !(move_pattern & MV_ANY_DIRECTION) &&
8123 move_pattern != MV_TURNING_LEFT &&
8124 move_pattern != MV_TURNING_RIGHT &&
8125 move_pattern != MV_TURNING_LEFT_RIGHT &&
8126 move_pattern != MV_TURNING_RIGHT_LEFT &&
8127 move_pattern != MV_TURNING_RANDOM)
8131 if (MovDelay[x][y] && (element == EL_BUG ||
8132 element == EL_SPACESHIP ||
8133 element == EL_SP_SNIKSNAK ||
8134 element == EL_SP_ELECTRON ||
8135 element == EL_MOLE))
8136 TEST_DrawLevelField(x, y);
8140 if (MovDelay[x][y]) // wait some time before next movement
8144 if (element == EL_ROBOT ||
8145 element == EL_YAMYAM ||
8146 element == EL_DARK_YAMYAM)
8148 DrawLevelElementAnimationIfNeeded(x, y, element);
8149 PlayLevelSoundAction(x, y, ACTION_WAITING);
8151 else if (element == EL_SP_ELECTRON)
8152 DrawLevelElementAnimationIfNeeded(x, y, element);
8153 else if (element == EL_DRAGON)
8156 int dir = MovDir[x][y];
8157 int dx = (dir == MV_LEFT ? -1 : dir == MV_RIGHT ? +1 : 0);
8158 int dy = (dir == MV_UP ? -1 : dir == MV_DOWN ? +1 : 0);
8159 int graphic = (dir == MV_LEFT ? IMG_FLAMES_1_LEFT :
8160 dir == MV_RIGHT ? IMG_FLAMES_1_RIGHT :
8161 dir == MV_UP ? IMG_FLAMES_1_UP :
8162 dir == MV_DOWN ? IMG_FLAMES_1_DOWN : IMG_EMPTY);
8163 int frame = getGraphicAnimationFrame(graphic, GfxFrame[x][y]);
8165 GfxAction[x][y] = ACTION_ATTACKING;
8167 if (IS_PLAYER(x, y))
8168 DrawPlayerField(x, y);
8170 TEST_DrawLevelField(x, y);
8172 PlayLevelSoundActionIfLoop(x, y, ACTION_ATTACKING);
8174 for (i = 1; i <= 3; i++)
8176 int xx = x + i * dx;
8177 int yy = y + i * dy;
8178 int sx = SCREENX(xx);
8179 int sy = SCREENY(yy);
8180 int flame_graphic = graphic + (i - 1);
8182 if (!IN_LEV_FIELD(xx, yy) || IS_DRAGONFIRE_PROOF(Tile[xx][yy]))
8187 int flamed = MovingOrBlocked2Element(xx, yy);
8189 if (IS_CLASSIC_ENEMY(flamed) || CAN_EXPLODE_BY_DRAGONFIRE(flamed))
8192 RemoveMovingField(xx, yy);
8194 ChangeDelay[xx][yy] = 0;
8196 Tile[xx][yy] = EL_FLAMES;
8198 if (IN_SCR_FIELD(sx, sy))
8200 TEST_DrawLevelFieldCrumbled(xx, yy);
8201 DrawGraphic(sx, sy, flame_graphic, frame);
8206 if (Tile[xx][yy] == EL_FLAMES)
8207 Tile[xx][yy] = EL_EMPTY;
8208 TEST_DrawLevelField(xx, yy);
8213 if (MovDelay[x][y]) // element still has to wait some time
8215 PlayLevelSoundAction(x, y, ACTION_WAITING);
8221 // now make next step
8223 Moving2Blocked(x, y, &newx, &newy); // get next screen position
8225 if (DONT_COLLIDE_WITH(element) &&
8226 IN_LEV_FIELD(newx, newy) && IS_PLAYER(newx, newy) &&
8227 !PLAYER_ENEMY_PROTECTED(newx, newy))
8229 TestIfBadThingRunsIntoPlayer(x, y, MovDir[x][y]);
8234 else if (CAN_MOVE_INTO_ACID(element) &&
8235 IN_LEV_FIELD(newx, newy) && Tile[newx][newy] == EL_ACID &&
8236 !IS_MV_DIAGONAL(MovDir[x][y]) &&
8237 (MovDir[x][y] == MV_DOWN ||
8238 game.engine_version >= VERSION_IDENT(3,1,0,0)))
8240 SplashAcid(newx, newy);
8241 Store[x][y] = EL_ACID;
8243 else if (element == EL_PENGUIN && IN_LEV_FIELD(newx, newy))
8245 if (Tile[newx][newy] == EL_EXIT_OPEN ||
8246 Tile[newx][newy] == EL_EM_EXIT_OPEN ||
8247 Tile[newx][newy] == EL_STEEL_EXIT_OPEN ||
8248 Tile[newx][newy] == EL_EM_STEEL_EXIT_OPEN)
8251 TEST_DrawLevelField(x, y);
8253 PlayLevelSound(newx, newy, SND_PENGUIN_PASSING);
8254 if (IN_SCR_FIELD(SCREENX(newx), SCREENY(newy)))
8255 DrawGraphicThruMask(SCREENX(newx),SCREENY(newy), el2img(element), 0);
8257 game.friends_still_needed--;
8258 if (!game.friends_still_needed &&
8260 game.all_players_gone)
8265 else if (IS_FOOD_PENGUIN(Tile[newx][newy]))
8267 if (DigField(local_player, x, y, newx, newy, 0,0, DF_DIG) == MP_MOVING)
8268 TEST_DrawLevelField(newx, newy);
8270 GfxDir[x][y] = MovDir[x][y] = MV_NONE;
8272 else if (!IS_FREE(newx, newy))
8274 GfxAction[x][y] = ACTION_WAITING;
8276 if (IS_PLAYER(x, y))
8277 DrawPlayerField(x, y);
8279 TEST_DrawLevelField(x, y);
8284 else if (element == EL_PIG && IN_LEV_FIELD(newx, newy))
8286 if (IS_FOOD_PIG(Tile[newx][newy]))
8288 if (IS_MOVING(newx, newy))
8289 RemoveMovingField(newx, newy);
8292 Tile[newx][newy] = EL_EMPTY;
8293 TEST_DrawLevelField(newx, newy);
8296 PlayLevelSound(x, y, SND_PIG_DIGGING);
8298 else if (!IS_FREE(newx, newy))
8300 if (IS_PLAYER(x, y))
8301 DrawPlayerField(x, y);
8303 TEST_DrawLevelField(x, y);
8308 else if (element == EL_EMC_ANDROID && IN_LEV_FIELD(newx, newy))
8310 if (Store[x][y] != EL_EMPTY)
8312 boolean can_clone = FALSE;
8315 // check if element to clone is still there
8316 for (yy = y - 1; yy <= y + 1; yy++) for (xx = x - 1; xx <= x + 1; xx++)
8318 if (IN_LEV_FIELD(xx, yy) && Tile[xx][yy] == Store[x][y])
8326 // cannot clone or target field not free anymore -- do not clone
8327 if (!can_clone || !ANDROID_CAN_ENTER_FIELD(element, newx, newy))
8328 Store[x][y] = EL_EMPTY;
8331 if (ANDROID_CAN_ENTER_FIELD(element, newx, newy))
8333 if (IS_MV_DIAGONAL(MovDir[x][y]))
8335 int diagonal_move_dir = MovDir[x][y];
8336 int stored = Store[x][y];
8337 int change_delay = 8;
8340 // android is moving diagonally
8342 CreateField(x, y, EL_DIAGONAL_SHRINKING);
8344 Store[x][y] = (stored == EL_ACID ? EL_EMPTY : stored);
8345 GfxElement[x][y] = EL_EMC_ANDROID;
8346 GfxAction[x][y] = ACTION_SHRINKING;
8347 GfxDir[x][y] = diagonal_move_dir;
8348 ChangeDelay[x][y] = change_delay;
8350 graphic = el_act_dir2img(GfxElement[x][y], GfxAction[x][y],
8353 DrawLevelGraphicAnimation(x, y, graphic);
8354 PlayLevelSoundAction(x, y, ACTION_SHRINKING);
8356 if (Tile[newx][newy] == EL_ACID)
8358 SplashAcid(newx, newy);
8363 CreateField(newx, newy, EL_DIAGONAL_GROWING);
8365 Store[newx][newy] = EL_EMC_ANDROID;
8366 GfxElement[newx][newy] = EL_EMC_ANDROID;
8367 GfxAction[newx][newy] = ACTION_GROWING;
8368 GfxDir[newx][newy] = diagonal_move_dir;
8369 ChangeDelay[newx][newy] = change_delay;
8371 graphic = el_act_dir2img(GfxElement[newx][newy],
8372 GfxAction[newx][newy], GfxDir[newx][newy]);
8374 DrawLevelGraphicAnimation(newx, newy, graphic);
8375 PlayLevelSoundAction(newx, newy, ACTION_GROWING);
8381 Tile[newx][newy] = EL_EMPTY;
8382 TEST_DrawLevelField(newx, newy);
8384 PlayLevelSoundAction(x, y, ACTION_DIGGING);
8387 else if (!IS_FREE(newx, newy))
8392 else if (IS_CUSTOM_ELEMENT(element) &&
8393 CUSTOM_ELEMENT_CAN_ENTER_FIELD(element, newx, newy))
8395 if (!DigFieldByCE(newx, newy, element))
8398 if (move_pattern & MV_MAZE_RUNNER_STYLE)
8400 RunnerVisit[x][y] = FrameCounter;
8401 PlayerVisit[x][y] /= 8; // expire player visit path
8404 else if (element == EL_DRAGON && IN_LEV_FIELD(newx, newy))
8406 if (!IS_FREE(newx, newy))
8408 if (IS_PLAYER(x, y))
8409 DrawPlayerField(x, y);
8411 TEST_DrawLevelField(x, y);
8417 boolean wanna_flame = !RND(10);
8418 int dx = newx - x, dy = newy - y;
8419 int newx1 = newx + 1 * dx, newy1 = newy + 1 * dy;
8420 int newx2 = newx + 2 * dx, newy2 = newy + 2 * dy;
8421 int element1 = (IN_LEV_FIELD(newx1, newy1) ?
8422 MovingOrBlocked2Element(newx1, newy1) : EL_STEELWALL);
8423 int element2 = (IN_LEV_FIELD(newx2, newy2) ?
8424 MovingOrBlocked2Element(newx2, newy2) : EL_STEELWALL);
8427 IS_CLASSIC_ENEMY(element1) ||
8428 IS_CLASSIC_ENEMY(element2)) &&
8429 element1 != EL_DRAGON && element2 != EL_DRAGON &&
8430 element1 != EL_FLAMES && element2 != EL_FLAMES)
8432 ResetGfxAnimation(x, y);
8433 GfxAction[x][y] = ACTION_ATTACKING;
8435 if (IS_PLAYER(x, y))
8436 DrawPlayerField(x, y);
8438 TEST_DrawLevelField(x, y);
8440 PlayLevelSound(x, y, SND_DRAGON_ATTACKING);
8442 MovDelay[x][y] = 50;
8444 Tile[newx][newy] = EL_FLAMES;
8445 if (IN_LEV_FIELD(newx1, newy1) && Tile[newx1][newy1] == EL_EMPTY)
8446 Tile[newx1][newy1] = EL_FLAMES;
8447 if (IN_LEV_FIELD(newx2, newy2) && Tile[newx2][newy2] == EL_EMPTY)
8448 Tile[newx2][newy2] = EL_FLAMES;
8454 else if (element == EL_YAMYAM && IN_LEV_FIELD(newx, newy) &&
8455 Tile[newx][newy] == EL_DIAMOND)
8457 if (IS_MOVING(newx, newy))
8458 RemoveMovingField(newx, newy);
8461 Tile[newx][newy] = EL_EMPTY;
8462 TEST_DrawLevelField(newx, newy);
8465 PlayLevelSound(x, y, SND_YAMYAM_DIGGING);
8467 else if (element == EL_DARK_YAMYAM && IN_LEV_FIELD(newx, newy) &&
8468 IS_FOOD_DARK_YAMYAM(Tile[newx][newy]))
8470 if (AmoebaNr[newx][newy])
8472 AmoebaCnt2[AmoebaNr[newx][newy]]--;
8473 if (Tile[newx][newy] == EL_AMOEBA_FULL ||
8474 Tile[newx][newy] == EL_BD_AMOEBA)
8475 AmoebaCnt[AmoebaNr[newx][newy]]--;
8478 if (IS_MOVING(newx, newy))
8480 RemoveMovingField(newx, newy);
8484 Tile[newx][newy] = EL_EMPTY;
8485 TEST_DrawLevelField(newx, newy);
8488 PlayLevelSound(x, y, SND_DARK_YAMYAM_DIGGING);
8490 else if ((element == EL_PACMAN || element == EL_MOLE)
8491 && IN_LEV_FIELD(newx, newy) && IS_AMOEBOID(Tile[newx][newy]))
8493 if (AmoebaNr[newx][newy])
8495 AmoebaCnt2[AmoebaNr[newx][newy]]--;
8496 if (Tile[newx][newy] == EL_AMOEBA_FULL ||
8497 Tile[newx][newy] == EL_BD_AMOEBA)
8498 AmoebaCnt[AmoebaNr[newx][newy]]--;
8501 if (element == EL_MOLE)
8503 Tile[newx][newy] = EL_AMOEBA_SHRINKING;
8504 PlayLevelSound(x, y, SND_MOLE_DIGGING);
8506 ResetGfxAnimation(x, y);
8507 GfxAction[x][y] = ACTION_DIGGING;
8508 TEST_DrawLevelField(x, y);
8510 MovDelay[newx][newy] = 0; // start amoeba shrinking delay
8512 return; // wait for shrinking amoeba
8514 else // element == EL_PACMAN
8516 Tile[newx][newy] = EL_EMPTY;
8517 TEST_DrawLevelField(newx, newy);
8518 PlayLevelSound(x, y, SND_PACMAN_DIGGING);
8521 else if (element == EL_MOLE && IN_LEV_FIELD(newx, newy) &&
8522 (Tile[newx][newy] == EL_AMOEBA_SHRINKING ||
8523 (Tile[newx][newy] == EL_EMPTY && Stop[newx][newy])))
8525 // wait for shrinking amoeba to completely disappear
8528 else if (!IN_LEV_FIELD(newx, newy) || !IS_FREE(newx, newy))
8530 // object was running against a wall
8534 if (GFX_ELEMENT(element) != EL_SAND) // !!! FIX THIS (crumble) !!!
8535 DrawLevelElementAnimation(x, y, element);
8537 if (DONT_TOUCH(element))
8538 TestIfBadThingTouchesPlayer(x, y);
8543 InitMovingField(x, y, MovDir[x][y]);
8545 PlayLevelSoundAction(x, y, ACTION_MOVING);
8549 ContinueMoving(x, y);
8552 void ContinueMoving(int x, int y)
8554 int element = Tile[x][y];
8555 struct ElementInfo *ei = &element_info[element];
8556 int direction = MovDir[x][y];
8557 int dx = (direction == MV_LEFT ? -1 : direction == MV_RIGHT ? +1 : 0);
8558 int dy = (direction == MV_UP ? -1 : direction == MV_DOWN ? +1 : 0);
8559 int newx = x + dx, newy = y + dy;
8560 int stored = Store[x][y];
8561 int stored_new = Store[newx][newy];
8562 boolean pushed_by_player = (Pushed[x][y] && IS_PLAYER(x, y));
8563 boolean pushed_by_conveyor = (Pushed[x][y] && !IS_PLAYER(x, y));
8564 boolean last_line = (newy == lev_fieldy - 1);
8565 boolean use_step_delay = (GET_MAX_STEP_DELAY(element) != 0);
8567 if (pushed_by_player) // special case: moving object pushed by player
8569 MovPos[x][y] = SIGN(MovPos[x][y]) * (TILEX - ABS(PLAYERINFO(x,y)->MovPos));
8571 else if (use_step_delay) // special case: moving object has step delay
8573 if (!MovDelay[x][y])
8574 MovPos[x][y] += getElementMoveStepsize(x, y);
8579 MovDelay[x][y] = GET_NEW_STEP_DELAY(element);
8583 TEST_DrawLevelField(x, y);
8585 return; // element is still waiting
8588 else // normal case: generically moving object
8590 MovPos[x][y] += getElementMoveStepsize(x, y);
8593 if (ABS(MovPos[x][y]) < TILEX)
8595 TEST_DrawLevelField(x, y);
8597 return; // element is still moving
8600 // element reached destination field
8602 Tile[x][y] = EL_EMPTY;
8603 Tile[newx][newy] = element;
8604 MovPos[x][y] = 0; // force "not moving" for "crumbled sand"
8606 if (Store[x][y] == EL_ACID) // element is moving into acid pool
8608 element = Tile[newx][newy] = EL_ACID;
8610 else if (element == EL_MOLE)
8612 Tile[x][y] = EL_SAND;
8614 TEST_DrawLevelFieldCrumbledNeighbours(x, y);
8616 else if (element == EL_QUICKSAND_FILLING)
8618 element = Tile[newx][newy] = get_next_element(element);
8619 Store[newx][newy] = Store[x][y];
8621 else if (element == EL_QUICKSAND_EMPTYING)
8623 Tile[x][y] = get_next_element(element);
8624 element = Tile[newx][newy] = Store[x][y];
8626 else if (element == EL_QUICKSAND_FAST_FILLING)
8628 element = Tile[newx][newy] = get_next_element(element);
8629 Store[newx][newy] = Store[x][y];
8631 else if (element == EL_QUICKSAND_FAST_EMPTYING)
8633 Tile[x][y] = get_next_element(element);
8634 element = Tile[newx][newy] = Store[x][y];
8636 else if (element == EL_MAGIC_WALL_FILLING)
8638 element = Tile[newx][newy] = get_next_element(element);
8639 if (!game.magic_wall_active)
8640 element = Tile[newx][newy] = EL_MAGIC_WALL_DEAD;
8641 Store[newx][newy] = Store[x][y];
8643 else if (element == EL_MAGIC_WALL_EMPTYING)
8645 Tile[x][y] = get_next_element(element);
8646 if (!game.magic_wall_active)
8647 Tile[x][y] = EL_MAGIC_WALL_DEAD;
8648 element = Tile[newx][newy] = Store[x][y];
8650 InitField(newx, newy, FALSE);
8652 else if (element == EL_BD_MAGIC_WALL_FILLING)
8654 element = Tile[newx][newy] = get_next_element(element);
8655 if (!game.magic_wall_active)
8656 element = Tile[newx][newy] = EL_BD_MAGIC_WALL_DEAD;
8657 Store[newx][newy] = Store[x][y];
8659 else if (element == EL_BD_MAGIC_WALL_EMPTYING)
8661 Tile[x][y] = get_next_element(element);
8662 if (!game.magic_wall_active)
8663 Tile[x][y] = EL_BD_MAGIC_WALL_DEAD;
8664 element = Tile[newx][newy] = Store[x][y];
8666 InitField(newx, newy, FALSE);
8668 else if (element == EL_DC_MAGIC_WALL_FILLING)
8670 element = Tile[newx][newy] = get_next_element(element);
8671 if (!game.magic_wall_active)
8672 element = Tile[newx][newy] = EL_DC_MAGIC_WALL_DEAD;
8673 Store[newx][newy] = Store[x][y];
8675 else if (element == EL_DC_MAGIC_WALL_EMPTYING)
8677 Tile[x][y] = get_next_element(element);
8678 if (!game.magic_wall_active)
8679 Tile[x][y] = EL_DC_MAGIC_WALL_DEAD;
8680 element = Tile[newx][newy] = Store[x][y];
8682 InitField(newx, newy, FALSE);
8684 else if (element == EL_AMOEBA_DROPPING)
8686 Tile[x][y] = get_next_element(element);
8687 element = Tile[newx][newy] = Store[x][y];
8689 else if (element == EL_SOKOBAN_OBJECT)
8692 Tile[x][y] = Back[x][y];
8694 if (Back[newx][newy])
8695 Tile[newx][newy] = EL_SOKOBAN_FIELD_FULL;
8697 Back[x][y] = Back[newx][newy] = 0;
8700 Store[x][y] = EL_EMPTY;
8705 MovDelay[newx][newy] = 0;
8707 if (CAN_CHANGE_OR_HAS_ACTION(element))
8709 // copy element change control values to new field
8710 ChangeDelay[newx][newy] = ChangeDelay[x][y];
8711 ChangePage[newx][newy] = ChangePage[x][y];
8712 ChangeCount[newx][newy] = ChangeCount[x][y];
8713 ChangeEvent[newx][newy] = ChangeEvent[x][y];
8716 CustomValue[newx][newy] = CustomValue[x][y];
8718 ChangeDelay[x][y] = 0;
8719 ChangePage[x][y] = -1;
8720 ChangeCount[x][y] = 0;
8721 ChangeEvent[x][y] = -1;
8723 CustomValue[x][y] = 0;
8725 // copy animation control values to new field
8726 GfxFrame[newx][newy] = GfxFrame[x][y];
8727 GfxRandom[newx][newy] = GfxRandom[x][y]; // keep same random value
8728 GfxAction[newx][newy] = GfxAction[x][y]; // keep action one frame
8729 GfxDir[newx][newy] = GfxDir[x][y]; // keep element direction
8731 Pushed[x][y] = Pushed[newx][newy] = FALSE;
8733 // some elements can leave other elements behind after moving
8734 if (ei->move_leave_element != EL_EMPTY &&
8735 (ei->move_leave_type == LEAVE_TYPE_UNLIMITED || stored != EL_EMPTY) &&
8736 (!IS_PLAYER(x, y) || IS_WALKABLE(ei->move_leave_element)))
8738 int move_leave_element = ei->move_leave_element;
8740 // this makes it possible to leave the removed element again
8741 if (ei->move_leave_element == EL_TRIGGER_ELEMENT)
8742 move_leave_element = (stored == EL_ACID ? EL_EMPTY : stored);
8744 Tile[x][y] = move_leave_element;
8746 if (element_info[Tile[x][y]].move_direction_initial == MV_START_PREVIOUS)
8747 MovDir[x][y] = direction;
8749 InitField(x, y, FALSE);
8751 if (GFX_CRUMBLED(Tile[x][y]))
8752 TEST_DrawLevelFieldCrumbledNeighbours(x, y);
8754 if (ELEM_IS_PLAYER(move_leave_element))
8755 RelocatePlayer(x, y, move_leave_element);
8758 // do this after checking for left-behind element
8759 ResetGfxAnimation(x, y); // reset animation values for old field
8761 if (!CAN_MOVE(element) ||
8762 (CAN_FALL(element) && direction == MV_DOWN &&
8763 (element == EL_SPRING ||
8764 element_info[element].move_pattern == MV_WHEN_PUSHED ||
8765 element_info[element].move_pattern == MV_WHEN_DROPPED)))
8766 GfxDir[x][y] = MovDir[newx][newy] = 0;
8768 TEST_DrawLevelField(x, y);
8769 TEST_DrawLevelField(newx, newy);
8771 Stop[newx][newy] = TRUE; // ignore this element until the next frame
8773 // prevent pushed element from moving on in pushed direction
8774 if (pushed_by_player && CAN_MOVE(element) &&
8775 element_info[element].move_pattern & MV_ANY_DIRECTION &&
8776 !(element_info[element].move_pattern & direction))
8777 TurnRound(newx, newy);
8779 // prevent elements on conveyor belt from moving on in last direction
8780 if (pushed_by_conveyor && CAN_FALL(element) &&
8781 direction & MV_HORIZONTAL)
8782 MovDir[newx][newy] = 0;
8784 if (!pushed_by_player)
8786 int nextx = newx + dx, nexty = newy + dy;
8787 boolean check_collision_again = IN_LEV_FIELD_AND_IS_FREE(nextx, nexty);
8789 WasJustMoving[newx][newy] = CHECK_DELAY_MOVING;
8791 if (CAN_FALL(element) && direction == MV_DOWN)
8792 WasJustFalling[newx][newy] = CHECK_DELAY_FALLING;
8794 if ((!CAN_FALL(element) || direction == MV_DOWN) && check_collision_again)
8795 CheckCollision[newx][newy] = CHECK_DELAY_COLLISION;
8797 if (CAN_FALL(element) && direction == MV_DOWN && check_collision_again)
8798 CheckImpact[newx][newy] = CHECK_DELAY_IMPACT;
8801 if (DONT_TOUCH(element)) // object may be nasty to player or others
8803 TestIfBadThingTouchesPlayer(newx, newy);
8804 TestIfBadThingTouchesFriend(newx, newy);
8806 if (!IS_CUSTOM_ELEMENT(element))
8807 TestIfBadThingTouchesOtherBadThing(newx, newy);
8809 else if (element == EL_PENGUIN)
8810 TestIfFriendTouchesBadThing(newx, newy);
8812 if (DONT_GET_HIT_BY(element))
8814 TestIfGoodThingGetsHitByBadThing(newx, newy, direction);
8817 // give the player one last chance (one more frame) to move away
8818 if (CAN_FALL(element) && direction == MV_DOWN &&
8819 (last_line || (!IS_FREE(x, newy + 1) &&
8820 (!IS_PLAYER(x, newy + 1) ||
8821 game.engine_version < VERSION_IDENT(3,1,1,0)))))
8824 if (pushed_by_player && !game.use_change_when_pushing_bug)
8826 int push_side = MV_DIR_OPPOSITE(direction);
8827 struct PlayerInfo *player = PLAYERINFO(x, y);
8829 CheckElementChangeByPlayer(newx, newy, element, CE_PUSHED_BY_PLAYER,
8830 player->index_bit, push_side);
8831 CheckTriggeredElementChangeByPlayer(newx,newy, element, CE_PLAYER_PUSHES_X,
8832 player->index_bit, push_side);
8835 if (element == EL_EMC_ANDROID && pushed_by_player) // make another move
8836 MovDelay[newx][newy] = 1;
8838 CheckTriggeredElementChangeBySide(x, y, element, CE_MOVE_OF_X, direction);
8840 TestIfElementTouchesCustomElement(x, y); // empty or new element
8841 TestIfElementHitsCustomElement(newx, newy, direction);
8842 TestIfPlayerTouchesCustomElement(newx, newy);
8843 TestIfElementTouchesCustomElement(newx, newy);
8845 if (IS_CUSTOM_ELEMENT(element) && ei->move_enter_element != EL_EMPTY &&
8846 IS_EQUAL_OR_IN_GROUP(stored_new, ei->move_enter_element))
8847 CheckElementChangeBySide(newx, newy, element, stored_new, CE_DIGGING_X,
8848 MV_DIR_OPPOSITE(direction));
8851 int AmoebaNeighbourNr(int ax, int ay)
8854 int element = Tile[ax][ay];
8856 static int xy[4][2] =
8864 for (i = 0; i < NUM_DIRECTIONS; i++)
8866 int x = ax + xy[i][0];
8867 int y = ay + xy[i][1];
8869 if (!IN_LEV_FIELD(x, y))
8872 if (Tile[x][y] == element && AmoebaNr[x][y] > 0)
8873 group_nr = AmoebaNr[x][y];
8879 static void AmoebaMerge(int ax, int ay)
8881 int i, x, y, xx, yy;
8882 int new_group_nr = AmoebaNr[ax][ay];
8883 static int xy[4][2] =
8891 if (new_group_nr == 0)
8894 for (i = 0; i < NUM_DIRECTIONS; i++)
8899 if (!IN_LEV_FIELD(x, y))
8902 if ((Tile[x][y] == EL_AMOEBA_FULL ||
8903 Tile[x][y] == EL_BD_AMOEBA ||
8904 Tile[x][y] == EL_AMOEBA_DEAD) &&
8905 AmoebaNr[x][y] != new_group_nr)
8907 int old_group_nr = AmoebaNr[x][y];
8909 if (old_group_nr == 0)
8912 AmoebaCnt[new_group_nr] += AmoebaCnt[old_group_nr];
8913 AmoebaCnt[old_group_nr] = 0;
8914 AmoebaCnt2[new_group_nr] += AmoebaCnt2[old_group_nr];
8915 AmoebaCnt2[old_group_nr] = 0;
8917 SCAN_PLAYFIELD(xx, yy)
8919 if (AmoebaNr[xx][yy] == old_group_nr)
8920 AmoebaNr[xx][yy] = new_group_nr;
8926 void AmoebaToDiamond(int ax, int ay)
8930 if (Tile[ax][ay] == EL_AMOEBA_DEAD)
8932 int group_nr = AmoebaNr[ax][ay];
8937 Debug("game:playing:AmoebaToDiamond", "ax = %d, ay = %d", ax, ay);
8938 Debug("game:playing:AmoebaToDiamond", "This should never happen!");
8944 SCAN_PLAYFIELD(x, y)
8946 if (Tile[x][y] == EL_AMOEBA_DEAD && AmoebaNr[x][y] == group_nr)
8949 Tile[x][y] = EL_AMOEBA_TO_DIAMOND;
8953 PlayLevelSound(ax, ay, (IS_GEM(level.amoeba_content) ?
8954 SND_AMOEBA_TURNING_TO_GEM :
8955 SND_AMOEBA_TURNING_TO_ROCK));
8960 static int xy[4][2] =
8968 for (i = 0; i < NUM_DIRECTIONS; i++)
8973 if (!IN_LEV_FIELD(x, y))
8976 if (Tile[x][y] == EL_AMOEBA_TO_DIAMOND)
8978 PlayLevelSound(x, y, (IS_GEM(level.amoeba_content) ?
8979 SND_AMOEBA_TURNING_TO_GEM :
8980 SND_AMOEBA_TURNING_TO_ROCK));
8987 static void AmoebaToDiamondBD(int ax, int ay, int new_element)
8990 int group_nr = AmoebaNr[ax][ay];
8991 boolean done = FALSE;
8996 Debug("game:playing:AmoebaToDiamondBD", "ax = %d, ay = %d", ax, ay);
8997 Debug("game:playing:AmoebaToDiamondBD", "This should never happen!");
9003 SCAN_PLAYFIELD(x, y)
9005 if (AmoebaNr[x][y] == group_nr &&
9006 (Tile[x][y] == EL_AMOEBA_DEAD ||
9007 Tile[x][y] == EL_BD_AMOEBA ||
9008 Tile[x][y] == EL_AMOEBA_GROWING))
9011 Tile[x][y] = new_element;
9012 InitField(x, y, FALSE);
9013 TEST_DrawLevelField(x, y);
9019 PlayLevelSound(ax, ay, (new_element == EL_BD_ROCK ?
9020 SND_BD_AMOEBA_TURNING_TO_ROCK :
9021 SND_BD_AMOEBA_TURNING_TO_GEM));
9024 static void AmoebaGrowing(int x, int y)
9026 static unsigned int sound_delay = 0;
9027 static unsigned int sound_delay_value = 0;
9029 if (!MovDelay[x][y]) // start new growing cycle
9033 if (DelayReached(&sound_delay, sound_delay_value))
9035 PlayLevelSoundElementAction(x, y, Store[x][y], ACTION_GROWING);
9036 sound_delay_value = 30;
9040 if (MovDelay[x][y]) // wait some time before growing bigger
9043 if (MovDelay[x][y]/2 && IN_SCR_FIELD(SCREENX(x), SCREENY(y)))
9045 int frame = getGraphicAnimationFrame(IMG_AMOEBA_GROWING,
9046 6 - MovDelay[x][y]);
9048 DrawGraphic(SCREENX(x), SCREENY(y), IMG_AMOEBA_GROWING, frame);
9051 if (!MovDelay[x][y])
9053 Tile[x][y] = Store[x][y];
9055 TEST_DrawLevelField(x, y);
9060 static void AmoebaShrinking(int x, int y)
9062 static unsigned int sound_delay = 0;
9063 static unsigned int sound_delay_value = 0;
9065 if (!MovDelay[x][y]) // start new shrinking cycle
9069 if (DelayReached(&sound_delay, sound_delay_value))
9070 sound_delay_value = 30;
9073 if (MovDelay[x][y]) // wait some time before shrinking
9076 if (MovDelay[x][y]/2 && IN_SCR_FIELD(SCREENX(x), SCREENY(y)))
9078 int frame = getGraphicAnimationFrame(IMG_AMOEBA_SHRINKING,
9079 6 - MovDelay[x][y]);
9081 DrawGraphic(SCREENX(x), SCREENY(y), IMG_AMOEBA_SHRINKING, frame);
9084 if (!MovDelay[x][y])
9086 Tile[x][y] = EL_EMPTY;
9087 TEST_DrawLevelField(x, y);
9089 // don't let mole enter this field in this cycle;
9090 // (give priority to objects falling to this field from above)
9096 static void AmoebaReproduce(int ax, int ay)
9099 int element = Tile[ax][ay];
9100 int graphic = el2img(element);
9101 int newax = ax, neway = ay;
9102 boolean can_drop = (element == EL_AMOEBA_WET || element == EL_EMC_DRIPPER);
9103 static int xy[4][2] =
9111 if (!level.amoeba_speed && element != EL_EMC_DRIPPER)
9113 Tile[ax][ay] = EL_AMOEBA_DEAD;
9114 TEST_DrawLevelField(ax, ay);
9118 if (IS_ANIMATED(graphic))
9119 DrawLevelGraphicAnimationIfNeeded(ax, ay, graphic);
9121 if (!MovDelay[ax][ay]) // start making new amoeba field
9122 MovDelay[ax][ay] = RND(FRAMES_PER_SECOND * 25 / (1 + level.amoeba_speed));
9124 if (MovDelay[ax][ay]) // wait some time before making new amoeba
9127 if (MovDelay[ax][ay])
9131 if (can_drop) // EL_AMOEBA_WET or EL_EMC_DRIPPER
9134 int x = ax + xy[start][0];
9135 int y = ay + xy[start][1];
9137 if (!IN_LEV_FIELD(x, y))
9140 if (IS_FREE(x, y) ||
9141 CAN_GROW_INTO(Tile[x][y]) ||
9142 Tile[x][y] == EL_QUICKSAND_EMPTY ||
9143 Tile[x][y] == EL_QUICKSAND_FAST_EMPTY)
9149 if (newax == ax && neway == ay)
9152 else // normal or "filled" (BD style) amoeba
9155 boolean waiting_for_player = FALSE;
9157 for (i = 0; i < NUM_DIRECTIONS; i++)
9159 int j = (start + i) % 4;
9160 int x = ax + xy[j][0];
9161 int y = ay + xy[j][1];
9163 if (!IN_LEV_FIELD(x, y))
9166 if (IS_FREE(x, y) ||
9167 CAN_GROW_INTO(Tile[x][y]) ||
9168 Tile[x][y] == EL_QUICKSAND_EMPTY ||
9169 Tile[x][y] == EL_QUICKSAND_FAST_EMPTY)
9175 else if (IS_PLAYER(x, y))
9176 waiting_for_player = TRUE;
9179 if (newax == ax && neway == ay) // amoeba cannot grow
9181 if (i == 4 && (!waiting_for_player || element == EL_BD_AMOEBA))
9183 Tile[ax][ay] = EL_AMOEBA_DEAD;
9184 TEST_DrawLevelField(ax, ay);
9185 AmoebaCnt[AmoebaNr[ax][ay]]--;
9187 if (AmoebaCnt[AmoebaNr[ax][ay]] <= 0) // amoeba is completely dead
9189 if (element == EL_AMOEBA_FULL)
9190 AmoebaToDiamond(ax, ay);
9191 else if (element == EL_BD_AMOEBA)
9192 AmoebaToDiamondBD(ax, ay, level.amoeba_content);
9197 else if (element == EL_AMOEBA_FULL || element == EL_BD_AMOEBA)
9199 // amoeba gets larger by growing in some direction
9201 int new_group_nr = AmoebaNr[ax][ay];
9204 if (new_group_nr == 0)
9206 Debug("game:playing:AmoebaReproduce", "newax = %d, neway = %d",
9208 Debug("game:playing:AmoebaReproduce", "This should never happen!");
9214 AmoebaNr[newax][neway] = new_group_nr;
9215 AmoebaCnt[new_group_nr]++;
9216 AmoebaCnt2[new_group_nr]++;
9218 // if amoeba touches other amoeba(s) after growing, unify them
9219 AmoebaMerge(newax, neway);
9221 if (element == EL_BD_AMOEBA && AmoebaCnt2[new_group_nr] >= 200)
9223 AmoebaToDiamondBD(newax, neway, EL_BD_ROCK);
9229 if (!can_drop || neway < ay || !IS_FREE(newax, neway) ||
9230 (neway == lev_fieldy - 1 && newax != ax))
9232 Tile[newax][neway] = EL_AMOEBA_GROWING; // creation of new amoeba
9233 Store[newax][neway] = element;
9235 else if (neway == ay || element == EL_EMC_DRIPPER)
9237 Tile[newax][neway] = EL_AMOEBA_DROP; // drop left/right of amoeba
9239 PlayLevelSoundAction(newax, neway, ACTION_GROWING);
9243 InitMovingField(ax, ay, MV_DOWN); // drop dripping from amoeba
9244 Tile[ax][ay] = EL_AMOEBA_DROPPING;
9245 Store[ax][ay] = EL_AMOEBA_DROP;
9246 ContinueMoving(ax, ay);
9250 TEST_DrawLevelField(newax, neway);
9253 static void Life(int ax, int ay)
9257 int element = Tile[ax][ay];
9258 int graphic = el2img(element);
9259 int *life_parameter = (element == EL_GAME_OF_LIFE ? level.game_of_life :
9261 boolean changed = FALSE;
9263 if (IS_ANIMATED(graphic))
9264 DrawLevelGraphicAnimationIfNeeded(ax, ay, graphic);
9269 if (!MovDelay[ax][ay]) // start new "game of life" cycle
9270 MovDelay[ax][ay] = life_time;
9272 if (MovDelay[ax][ay]) // wait some time before next cycle
9275 if (MovDelay[ax][ay])
9279 for (y1 = -1; y1 < 2; y1++) for (x1 = -1; x1 < 2; x1++)
9281 int xx = ax+x1, yy = ay+y1;
9282 int old_element = Tile[xx][yy];
9283 int num_neighbours = 0;
9285 if (!IN_LEV_FIELD(xx, yy))
9288 for (y2 = -1; y2 < 2; y2++) for (x2 = -1; x2 < 2; x2++)
9290 int x = xx+x2, y = yy+y2;
9292 if (!IN_LEV_FIELD(x, y) || (x == xx && y == yy))
9295 boolean is_player_cell = (element == EL_GAME_OF_LIFE && IS_PLAYER(x, y));
9296 boolean is_neighbour = FALSE;
9298 if (level.use_life_bugs)
9300 (((Tile[x][y] == element || is_player_cell) && !Stop[x][y]) ||
9301 (IS_FREE(x, y) && Stop[x][y]));
9304 (Last[x][y] == element || is_player_cell);
9310 boolean is_free = FALSE;
9312 if (level.use_life_bugs)
9313 is_free = (IS_FREE(xx, yy));
9315 is_free = (IS_FREE(xx, yy) && Last[xx][yy] == EL_EMPTY);
9317 if (xx == ax && yy == ay) // field in the middle
9319 if (num_neighbours < life_parameter[0] ||
9320 num_neighbours > life_parameter[1])
9322 Tile[xx][yy] = EL_EMPTY;
9323 if (Tile[xx][yy] != old_element)
9324 TEST_DrawLevelField(xx, yy);
9325 Stop[xx][yy] = TRUE;
9329 else if (is_free || CAN_GROW_INTO(Tile[xx][yy]))
9330 { // free border field
9331 if (num_neighbours >= life_parameter[2] &&
9332 num_neighbours <= life_parameter[3])
9334 Tile[xx][yy] = element;
9335 MovDelay[xx][yy] = (element == EL_GAME_OF_LIFE ? 0 : life_time-1);
9336 if (Tile[xx][yy] != old_element)
9337 TEST_DrawLevelField(xx, yy);
9338 Stop[xx][yy] = TRUE;
9345 PlayLevelSound(ax, ay, element == EL_BIOMAZE ? SND_BIOMAZE_GROWING :
9346 SND_GAME_OF_LIFE_GROWING);
9349 static void InitRobotWheel(int x, int y)
9351 ChangeDelay[x][y] = level.time_wheel * FRAMES_PER_SECOND;
9354 static void RunRobotWheel(int x, int y)
9356 PlayLevelSound(x, y, SND_ROBOT_WHEEL_ACTIVE);
9359 static void StopRobotWheel(int x, int y)
9361 if (game.robot_wheel_x == x &&
9362 game.robot_wheel_y == y)
9364 game.robot_wheel_x = -1;
9365 game.robot_wheel_y = -1;
9366 game.robot_wheel_active = FALSE;
9370 static void InitTimegateWheel(int x, int y)
9372 ChangeDelay[x][y] = level.time_timegate * FRAMES_PER_SECOND;
9375 static void RunTimegateWheel(int x, int y)
9377 PlayLevelSound(x, y, SND_CLASS_TIMEGATE_SWITCH_ACTIVE);
9380 static void InitMagicBallDelay(int x, int y)
9382 ChangeDelay[x][y] = (level.ball_time + 1) * 8 + 1;
9385 static void ActivateMagicBall(int bx, int by)
9389 if (level.ball_random)
9391 int pos_border = RND(8); // select one of the eight border elements
9392 int pos_content = (pos_border > 3 ? pos_border + 1 : pos_border);
9393 int xx = pos_content % 3;
9394 int yy = pos_content / 3;
9399 if (IN_LEV_FIELD(x, y) && Tile[x][y] == EL_EMPTY)
9400 CreateField(x, y, level.ball_content[game.ball_content_nr].e[xx][yy]);
9404 for (y = by - 1; y <= by + 1; y++) for (x = bx - 1; x <= bx + 1; x++)
9406 int xx = x - bx + 1;
9407 int yy = y - by + 1;
9409 if (IN_LEV_FIELD(x, y) && Tile[x][y] == EL_EMPTY)
9410 CreateField(x, y, level.ball_content[game.ball_content_nr].e[xx][yy]);
9414 game.ball_content_nr = (game.ball_content_nr + 1) % level.num_ball_contents;
9417 static void CheckExit(int x, int y)
9419 if (game.gems_still_needed > 0 ||
9420 game.sokoban_fields_still_needed > 0 ||
9421 game.sokoban_objects_still_needed > 0 ||
9422 game.lights_still_needed > 0)
9424 int element = Tile[x][y];
9425 int graphic = el2img(element);
9427 if (IS_ANIMATED(graphic))
9428 DrawLevelGraphicAnimationIfNeeded(x, y, graphic);
9433 // do not re-open exit door closed after last player
9434 if (game.all_players_gone)
9437 Tile[x][y] = EL_EXIT_OPENING;
9439 PlayLevelSoundNearest(x, y, SND_CLASS_EXIT_OPENING);
9442 static void CheckExitEM(int x, int y)
9444 if (game.gems_still_needed > 0 ||
9445 game.sokoban_fields_still_needed > 0 ||
9446 game.sokoban_objects_still_needed > 0 ||
9447 game.lights_still_needed > 0)
9449 int element = Tile[x][y];
9450 int graphic = el2img(element);
9452 if (IS_ANIMATED(graphic))
9453 DrawLevelGraphicAnimationIfNeeded(x, y, graphic);
9458 // do not re-open exit door closed after last player
9459 if (game.all_players_gone)
9462 Tile[x][y] = EL_EM_EXIT_OPENING;
9464 PlayLevelSoundNearest(x, y, SND_CLASS_EM_EXIT_OPENING);
9467 static void CheckExitSteel(int x, int y)
9469 if (game.gems_still_needed > 0 ||
9470 game.sokoban_fields_still_needed > 0 ||
9471 game.sokoban_objects_still_needed > 0 ||
9472 game.lights_still_needed > 0)
9474 int element = Tile[x][y];
9475 int graphic = el2img(element);
9477 if (IS_ANIMATED(graphic))
9478 DrawLevelGraphicAnimationIfNeeded(x, y, graphic);
9483 // do not re-open exit door closed after last player
9484 if (game.all_players_gone)
9487 Tile[x][y] = EL_STEEL_EXIT_OPENING;
9489 PlayLevelSoundNearest(x, y, SND_CLASS_STEEL_EXIT_OPENING);
9492 static void CheckExitSteelEM(int x, int y)
9494 if (game.gems_still_needed > 0 ||
9495 game.sokoban_fields_still_needed > 0 ||
9496 game.sokoban_objects_still_needed > 0 ||
9497 game.lights_still_needed > 0)
9499 int element = Tile[x][y];
9500 int graphic = el2img(element);
9502 if (IS_ANIMATED(graphic))
9503 DrawLevelGraphicAnimationIfNeeded(x, y, graphic);
9508 // do not re-open exit door closed after last player
9509 if (game.all_players_gone)
9512 Tile[x][y] = EL_EM_STEEL_EXIT_OPENING;
9514 PlayLevelSoundNearest(x, y, SND_CLASS_EM_STEEL_EXIT_OPENING);
9517 static void CheckExitSP(int x, int y)
9519 if (game.gems_still_needed > 0)
9521 int element = Tile[x][y];
9522 int graphic = el2img(element);
9524 if (IS_ANIMATED(graphic))
9525 DrawLevelGraphicAnimationIfNeeded(x, y, graphic);
9530 // do not re-open exit door closed after last player
9531 if (game.all_players_gone)
9534 Tile[x][y] = EL_SP_EXIT_OPENING;
9536 PlayLevelSoundNearest(x, y, SND_CLASS_SP_EXIT_OPENING);
9539 static void CloseAllOpenTimegates(void)
9543 SCAN_PLAYFIELD(x, y)
9545 int element = Tile[x][y];
9547 if (element == EL_TIMEGATE_OPEN || element == EL_TIMEGATE_OPENING)
9549 Tile[x][y] = EL_TIMEGATE_CLOSING;
9551 PlayLevelSoundAction(x, y, ACTION_CLOSING);
9556 static void DrawTwinkleOnField(int x, int y)
9558 if (!IN_SCR_FIELD(SCREENX(x), SCREENY(y)) || IS_MOVING(x, y))
9561 if (Tile[x][y] == EL_BD_DIAMOND)
9564 if (MovDelay[x][y] == 0) // next animation frame
9565 MovDelay[x][y] = 11 * !GetSimpleRandom(500);
9567 if (MovDelay[x][y] != 0) // wait some time before next frame
9571 DrawLevelElementAnimation(x, y, Tile[x][y]);
9573 if (MovDelay[x][y] != 0)
9575 int frame = getGraphicAnimationFrame(IMG_TWINKLE_WHITE,
9576 10 - MovDelay[x][y]);
9578 DrawGraphicThruMask(SCREENX(x), SCREENY(y), IMG_TWINKLE_WHITE, frame);
9583 static void MauerWaechst(int x, int y)
9587 if (!MovDelay[x][y]) // next animation frame
9588 MovDelay[x][y] = 3 * delay;
9590 if (MovDelay[x][y]) // wait some time before next frame
9594 if (IN_SCR_FIELD(SCREENX(x), SCREENY(y)))
9596 int graphic = el_dir2img(Tile[x][y], GfxDir[x][y]);
9597 int frame = getGraphicAnimationFrame(graphic, 17 - MovDelay[x][y]);
9599 DrawGraphic(SCREENX(x), SCREENY(y), graphic, frame);
9602 if (!MovDelay[x][y])
9604 if (MovDir[x][y] == MV_LEFT)
9606 if (IN_LEV_FIELD(x - 1, y) && IS_WALL(Tile[x - 1][y]))
9607 TEST_DrawLevelField(x - 1, y);
9609 else if (MovDir[x][y] == MV_RIGHT)
9611 if (IN_LEV_FIELD(x + 1, y) && IS_WALL(Tile[x + 1][y]))
9612 TEST_DrawLevelField(x + 1, y);
9614 else if (MovDir[x][y] == MV_UP)
9616 if (IN_LEV_FIELD(x, y - 1) && IS_WALL(Tile[x][y - 1]))
9617 TEST_DrawLevelField(x, y - 1);
9621 if (IN_LEV_FIELD(x, y + 1) && IS_WALL(Tile[x][y + 1]))
9622 TEST_DrawLevelField(x, y + 1);
9625 Tile[x][y] = Store[x][y];
9627 GfxDir[x][y] = MovDir[x][y] = MV_NONE;
9628 TEST_DrawLevelField(x, y);
9633 static void MauerAbleger(int ax, int ay)
9635 int element = Tile[ax][ay];
9636 int graphic = el2img(element);
9637 boolean oben_frei = FALSE, unten_frei = FALSE;
9638 boolean links_frei = FALSE, rechts_frei = FALSE;
9639 boolean oben_massiv = FALSE, unten_massiv = FALSE;
9640 boolean links_massiv = FALSE, rechts_massiv = FALSE;
9641 boolean new_wall = FALSE;
9643 if (IS_ANIMATED(graphic))
9644 DrawLevelGraphicAnimationIfNeeded(ax, ay, graphic);
9646 if (!MovDelay[ax][ay]) // start building new wall
9647 MovDelay[ax][ay] = 6;
9649 if (MovDelay[ax][ay]) // wait some time before building new wall
9652 if (MovDelay[ax][ay])
9656 if (IN_LEV_FIELD(ax, ay-1) && IS_FREE(ax, ay-1))
9658 if (IN_LEV_FIELD(ax, ay+1) && IS_FREE(ax, ay+1))
9660 if (IN_LEV_FIELD(ax-1, ay) && IS_FREE(ax-1, ay))
9662 if (IN_LEV_FIELD(ax+1, ay) && IS_FREE(ax+1, ay))
9665 if (element == EL_EXPANDABLE_WALL_VERTICAL ||
9666 element == EL_EXPANDABLE_WALL_ANY)
9670 Tile[ax][ay-1] = EL_EXPANDABLE_WALL_GROWING;
9671 Store[ax][ay-1] = element;
9672 GfxDir[ax][ay-1] = MovDir[ax][ay-1] = MV_UP;
9673 if (IN_SCR_FIELD(SCREENX(ax), SCREENY(ay-1)))
9674 DrawGraphic(SCREENX(ax), SCREENY(ay - 1),
9675 IMG_EXPANDABLE_WALL_GROWING_UP, 0);
9680 Tile[ax][ay+1] = EL_EXPANDABLE_WALL_GROWING;
9681 Store[ax][ay+1] = element;
9682 GfxDir[ax][ay+1] = MovDir[ax][ay+1] = MV_DOWN;
9683 if (IN_SCR_FIELD(SCREENX(ax), SCREENY(ay+1)))
9684 DrawGraphic(SCREENX(ax), SCREENY(ay + 1),
9685 IMG_EXPANDABLE_WALL_GROWING_DOWN, 0);
9690 if (element == EL_EXPANDABLE_WALL_HORIZONTAL ||
9691 element == EL_EXPANDABLE_WALL_ANY ||
9692 element == EL_EXPANDABLE_WALL ||
9693 element == EL_BD_EXPANDABLE_WALL)
9697 Tile[ax-1][ay] = EL_EXPANDABLE_WALL_GROWING;
9698 Store[ax-1][ay] = element;
9699 GfxDir[ax-1][ay] = MovDir[ax-1][ay] = MV_LEFT;
9700 if (IN_SCR_FIELD(SCREENX(ax-1), SCREENY(ay)))
9701 DrawGraphic(SCREENX(ax - 1), SCREENY(ay),
9702 IMG_EXPANDABLE_WALL_GROWING_LEFT, 0);
9708 Tile[ax+1][ay] = EL_EXPANDABLE_WALL_GROWING;
9709 Store[ax+1][ay] = element;
9710 GfxDir[ax+1][ay] = MovDir[ax+1][ay] = MV_RIGHT;
9711 if (IN_SCR_FIELD(SCREENX(ax+1), SCREENY(ay)))
9712 DrawGraphic(SCREENX(ax + 1), SCREENY(ay),
9713 IMG_EXPANDABLE_WALL_GROWING_RIGHT, 0);
9718 if (element == EL_EXPANDABLE_WALL && (links_frei || rechts_frei))
9719 TEST_DrawLevelField(ax, ay);
9721 if (!IN_LEV_FIELD(ax, ay-1) || IS_WALL(Tile[ax][ay-1]))
9723 if (!IN_LEV_FIELD(ax, ay+1) || IS_WALL(Tile[ax][ay+1]))
9724 unten_massiv = TRUE;
9725 if (!IN_LEV_FIELD(ax-1, ay) || IS_WALL(Tile[ax-1][ay]))
9726 links_massiv = TRUE;
9727 if (!IN_LEV_FIELD(ax+1, ay) || IS_WALL(Tile[ax+1][ay]))
9728 rechts_massiv = TRUE;
9730 if (((oben_massiv && unten_massiv) ||
9731 element == EL_EXPANDABLE_WALL_HORIZONTAL ||
9732 element == EL_EXPANDABLE_WALL) &&
9733 ((links_massiv && rechts_massiv) ||
9734 element == EL_EXPANDABLE_WALL_VERTICAL))
9735 Tile[ax][ay] = EL_WALL;
9738 PlayLevelSoundAction(ax, ay, ACTION_GROWING);
9741 static void MauerAblegerStahl(int ax, int ay)
9743 int element = Tile[ax][ay];
9744 int graphic = el2img(element);
9745 boolean oben_frei = FALSE, unten_frei = FALSE;
9746 boolean links_frei = FALSE, rechts_frei = FALSE;
9747 boolean oben_massiv = FALSE, unten_massiv = FALSE;
9748 boolean links_massiv = FALSE, rechts_massiv = FALSE;
9749 boolean new_wall = FALSE;
9751 if (IS_ANIMATED(graphic))
9752 DrawLevelGraphicAnimationIfNeeded(ax, ay, graphic);
9754 if (!MovDelay[ax][ay]) // start building new wall
9755 MovDelay[ax][ay] = 6;
9757 if (MovDelay[ax][ay]) // wait some time before building new wall
9760 if (MovDelay[ax][ay])
9764 if (IN_LEV_FIELD(ax, ay-1) && IS_FREE(ax, ay-1))
9766 if (IN_LEV_FIELD(ax, ay+1) && IS_FREE(ax, ay+1))
9768 if (IN_LEV_FIELD(ax-1, ay) && IS_FREE(ax-1, ay))
9770 if (IN_LEV_FIELD(ax+1, ay) && IS_FREE(ax+1, ay))
9773 if (element == EL_EXPANDABLE_STEELWALL_VERTICAL ||
9774 element == EL_EXPANDABLE_STEELWALL_ANY)
9778 Tile[ax][ay-1] = EL_EXPANDABLE_STEELWALL_GROWING;
9779 Store[ax][ay-1] = element;
9780 GfxDir[ax][ay-1] = MovDir[ax][ay-1] = MV_UP;
9781 if (IN_SCR_FIELD(SCREENX(ax), SCREENY(ay-1)))
9782 DrawGraphic(SCREENX(ax), SCREENY(ay - 1),
9783 IMG_EXPANDABLE_STEELWALL_GROWING_UP, 0);
9788 Tile[ax][ay+1] = EL_EXPANDABLE_STEELWALL_GROWING;
9789 Store[ax][ay+1] = element;
9790 GfxDir[ax][ay+1] = MovDir[ax][ay+1] = MV_DOWN;
9791 if (IN_SCR_FIELD(SCREENX(ax), SCREENY(ay+1)))
9792 DrawGraphic(SCREENX(ax), SCREENY(ay + 1),
9793 IMG_EXPANDABLE_STEELWALL_GROWING_DOWN, 0);
9798 if (element == EL_EXPANDABLE_STEELWALL_HORIZONTAL ||
9799 element == EL_EXPANDABLE_STEELWALL_ANY)
9803 Tile[ax-1][ay] = EL_EXPANDABLE_STEELWALL_GROWING;
9804 Store[ax-1][ay] = element;
9805 GfxDir[ax-1][ay] = MovDir[ax-1][ay] = MV_LEFT;
9806 if (IN_SCR_FIELD(SCREENX(ax-1), SCREENY(ay)))
9807 DrawGraphic(SCREENX(ax - 1), SCREENY(ay),
9808 IMG_EXPANDABLE_STEELWALL_GROWING_LEFT, 0);
9814 Tile[ax+1][ay] = EL_EXPANDABLE_STEELWALL_GROWING;
9815 Store[ax+1][ay] = element;
9816 GfxDir[ax+1][ay] = MovDir[ax+1][ay] = MV_RIGHT;
9817 if (IN_SCR_FIELD(SCREENX(ax+1), SCREENY(ay)))
9818 DrawGraphic(SCREENX(ax + 1), SCREENY(ay),
9819 IMG_EXPANDABLE_STEELWALL_GROWING_RIGHT, 0);
9824 if (!IN_LEV_FIELD(ax, ay-1) || IS_WALL(Tile[ax][ay-1]))
9826 if (!IN_LEV_FIELD(ax, ay+1) || IS_WALL(Tile[ax][ay+1]))
9827 unten_massiv = TRUE;
9828 if (!IN_LEV_FIELD(ax-1, ay) || IS_WALL(Tile[ax-1][ay]))
9829 links_massiv = TRUE;
9830 if (!IN_LEV_FIELD(ax+1, ay) || IS_WALL(Tile[ax+1][ay]))
9831 rechts_massiv = TRUE;
9833 if (((oben_massiv && unten_massiv) ||
9834 element == EL_EXPANDABLE_STEELWALL_HORIZONTAL) &&
9835 ((links_massiv && rechts_massiv) ||
9836 element == EL_EXPANDABLE_STEELWALL_VERTICAL))
9837 Tile[ax][ay] = EL_STEELWALL;
9840 PlayLevelSoundAction(ax, ay, ACTION_GROWING);
9843 static void CheckForDragon(int x, int y)
9846 boolean dragon_found = FALSE;
9847 static int xy[4][2] =
9855 for (i = 0; i < NUM_DIRECTIONS; i++)
9857 for (j = 0; j < 4; j++)
9859 int xx = x + j * xy[i][0], yy = y + j * xy[i][1];
9861 if (IN_LEV_FIELD(xx, yy) &&
9862 (Tile[xx][yy] == EL_FLAMES || Tile[xx][yy] == EL_DRAGON))
9864 if (Tile[xx][yy] == EL_DRAGON)
9865 dragon_found = TRUE;
9874 for (i = 0; i < NUM_DIRECTIONS; i++)
9876 for (j = 0; j < 3; j++)
9878 int xx = x + j * xy[i][0], yy = y + j * xy[i][1];
9880 if (IN_LEV_FIELD(xx, yy) && Tile[xx][yy] == EL_FLAMES)
9882 Tile[xx][yy] = EL_EMPTY;
9883 TEST_DrawLevelField(xx, yy);
9892 static void InitBuggyBase(int x, int y)
9894 int element = Tile[x][y];
9895 int activating_delay = FRAMES_PER_SECOND / 4;
9898 (element == EL_SP_BUGGY_BASE ?
9899 2 * FRAMES_PER_SECOND + RND(5 * FRAMES_PER_SECOND) - activating_delay :
9900 element == EL_SP_BUGGY_BASE_ACTIVATING ?
9902 element == EL_SP_BUGGY_BASE_ACTIVE ?
9903 1 * FRAMES_PER_SECOND + RND(1 * FRAMES_PER_SECOND) : 1);
9906 static void WarnBuggyBase(int x, int y)
9909 static int xy[4][2] =
9917 for (i = 0; i < NUM_DIRECTIONS; i++)
9919 int xx = x + xy[i][0];
9920 int yy = y + xy[i][1];
9922 if (IN_LEV_FIELD(xx, yy) && IS_PLAYER(xx, yy))
9924 PlayLevelSound(x, y, SND_SP_BUGGY_BASE_ACTIVE);
9931 static void InitTrap(int x, int y)
9933 ChangeDelay[x][y] = 2 * FRAMES_PER_SECOND + RND(5 * FRAMES_PER_SECOND);
9936 static void ActivateTrap(int x, int y)
9938 PlayLevelSound(x, y, SND_TRAP_ACTIVATING);
9941 static void ChangeActiveTrap(int x, int y)
9943 int graphic = IMG_TRAP_ACTIVE;
9945 // if new animation frame was drawn, correct crumbled sand border
9946 if (IS_NEW_FRAME(GfxFrame[x][y], graphic))
9947 TEST_DrawLevelFieldCrumbled(x, y);
9950 static int getSpecialActionElement(int element, int number, int base_element)
9952 return (element != EL_EMPTY ? element :
9953 number != -1 ? base_element + number - 1 :
9957 static int getModifiedActionNumber(int value_old, int operator, int operand,
9958 int value_min, int value_max)
9960 int value_new = (operator == CA_MODE_SET ? operand :
9961 operator == CA_MODE_ADD ? value_old + operand :
9962 operator == CA_MODE_SUBTRACT ? value_old - operand :
9963 operator == CA_MODE_MULTIPLY ? value_old * operand :
9964 operator == CA_MODE_DIVIDE ? value_old / MAX(1, operand) :
9965 operator == CA_MODE_MODULO ? value_old % MAX(1, operand) :
9968 return (value_new < value_min ? value_min :
9969 value_new > value_max ? value_max :
9973 static void ExecuteCustomElementAction(int x, int y, int element, int page)
9975 struct ElementInfo *ei = &element_info[element];
9976 struct ElementChangeInfo *change = &ei->change_page[page];
9977 int target_element = change->target_element;
9978 int action_type = change->action_type;
9979 int action_mode = change->action_mode;
9980 int action_arg = change->action_arg;
9981 int action_element = change->action_element;
9984 if (!change->has_action)
9987 // ---------- determine action paramater values -----------------------------
9989 int level_time_value =
9990 (level.time > 0 ? TimeLeft :
9993 int action_arg_element_raw =
9994 (action_arg == CA_ARG_PLAYER_TRIGGER ? change->actual_trigger_player :
9995 action_arg == CA_ARG_ELEMENT_TRIGGER ? change->actual_trigger_element :
9996 action_arg == CA_ARG_ELEMENT_TARGET ? change->target_element :
9997 action_arg == CA_ARG_ELEMENT_ACTION ? change->action_element :
9998 action_arg == CA_ARG_INVENTORY_RM_TRIGGER ? change->actual_trigger_element:
9999 action_arg == CA_ARG_INVENTORY_RM_TARGET ? change->target_element :
10000 action_arg == CA_ARG_INVENTORY_RM_ACTION ? change->action_element :
10002 int action_arg_element = GetElementFromGroupElement(action_arg_element_raw);
10004 int action_arg_direction =
10005 (action_arg >= CA_ARG_DIRECTION_LEFT &&
10006 action_arg <= CA_ARG_DIRECTION_DOWN ? action_arg - CA_ARG_DIRECTION :
10007 action_arg == CA_ARG_DIRECTION_TRIGGER ?
10008 change->actual_trigger_side :
10009 action_arg == CA_ARG_DIRECTION_TRIGGER_BACK ?
10010 MV_DIR_OPPOSITE(change->actual_trigger_side) :
10013 int action_arg_number_min =
10014 (action_type == CA_SET_PLAYER_SPEED ? STEPSIZE_NOT_MOVING :
10017 int action_arg_number_max =
10018 (action_type == CA_SET_PLAYER_SPEED ? STEPSIZE_EVEN_FASTER :
10019 action_type == CA_SET_LEVEL_GEMS ? 999 :
10020 action_type == CA_SET_LEVEL_TIME ? 9999 :
10021 action_type == CA_SET_LEVEL_SCORE ? 99999 :
10022 action_type == CA_SET_CE_VALUE ? 9999 :
10023 action_type == CA_SET_CE_SCORE ? 9999 :
10026 int action_arg_number_reset =
10027 (action_type == CA_SET_PLAYER_SPEED ? level.initial_player_stepsize[0] :
10028 action_type == CA_SET_LEVEL_GEMS ? level.gems_needed :
10029 action_type == CA_SET_LEVEL_TIME ? level.time :
10030 action_type == CA_SET_LEVEL_SCORE ? 0 :
10031 action_type == CA_SET_CE_VALUE ? GET_NEW_CE_VALUE(element) :
10032 action_type == CA_SET_CE_SCORE ? 0 :
10035 int action_arg_number =
10036 (action_arg <= CA_ARG_MAX ? action_arg :
10037 action_arg >= CA_ARG_SPEED_NOT_MOVING &&
10038 action_arg <= CA_ARG_SPEED_EVEN_FASTER ? (action_arg - CA_ARG_SPEED) :
10039 action_arg == CA_ARG_SPEED_RESET ? action_arg_number_reset :
10040 action_arg == CA_ARG_NUMBER_MIN ? action_arg_number_min :
10041 action_arg == CA_ARG_NUMBER_MAX ? action_arg_number_max :
10042 action_arg == CA_ARG_NUMBER_RESET ? action_arg_number_reset :
10043 action_arg == CA_ARG_NUMBER_CE_VALUE ? CustomValue[x][y] :
10044 action_arg == CA_ARG_NUMBER_CE_SCORE ? ei->collect_score :
10045 action_arg == CA_ARG_NUMBER_CE_DELAY ? GET_CE_DELAY_VALUE(change) :
10046 action_arg == CA_ARG_NUMBER_LEVEL_TIME ? level_time_value :
10047 action_arg == CA_ARG_NUMBER_LEVEL_GEMS ? game.gems_still_needed :
10048 action_arg == CA_ARG_NUMBER_LEVEL_SCORE ? game.score :
10049 action_arg == CA_ARG_ELEMENT_CV_TARGET ? GET_NEW_CE_VALUE(target_element):
10050 action_arg == CA_ARG_ELEMENT_CV_TRIGGER ? change->actual_trigger_ce_value:
10051 action_arg == CA_ARG_ELEMENT_CV_ACTION ? GET_NEW_CE_VALUE(action_element):
10052 action_arg == CA_ARG_ELEMENT_CS_TARGET ? GET_CE_SCORE(target_element) :
10053 action_arg == CA_ARG_ELEMENT_CS_TRIGGER ? change->actual_trigger_ce_score:
10054 action_arg == CA_ARG_ELEMENT_CS_ACTION ? GET_CE_SCORE(action_element) :
10055 action_arg == CA_ARG_ELEMENT_NR_TARGET ? change->target_element :
10056 action_arg == CA_ARG_ELEMENT_NR_TRIGGER ? change->actual_trigger_element :
10057 action_arg == CA_ARG_ELEMENT_NR_ACTION ? change->action_element :
10060 int action_arg_number_old =
10061 (action_type == CA_SET_LEVEL_GEMS ? game.gems_still_needed :
10062 action_type == CA_SET_LEVEL_TIME ? TimeLeft :
10063 action_type == CA_SET_LEVEL_SCORE ? game.score :
10064 action_type == CA_SET_CE_VALUE ? CustomValue[x][y] :
10065 action_type == CA_SET_CE_SCORE ? ei->collect_score :
10068 int action_arg_number_new =
10069 getModifiedActionNumber(action_arg_number_old,
10070 action_mode, action_arg_number,
10071 action_arg_number_min, action_arg_number_max);
10073 int trigger_player_bits =
10074 (change->actual_trigger_player_bits != CH_PLAYER_NONE ?
10075 change->actual_trigger_player_bits : change->trigger_player);
10077 int action_arg_player_bits =
10078 (action_arg >= CA_ARG_PLAYER_1 &&
10079 action_arg <= CA_ARG_PLAYER_4 ? action_arg - CA_ARG_PLAYER :
10080 action_arg == CA_ARG_PLAYER_TRIGGER ? trigger_player_bits :
10081 action_arg == CA_ARG_PLAYER_ACTION ? 1 << GET_PLAYER_NR(action_element) :
10084 // ---------- execute action -----------------------------------------------
10086 switch (action_type)
10093 // ---------- level actions ----------------------------------------------
10095 case CA_RESTART_LEVEL:
10097 game.restart_level = TRUE;
10102 case CA_SHOW_ENVELOPE:
10104 int element = getSpecialActionElement(action_arg_element,
10105 action_arg_number, EL_ENVELOPE_1);
10107 if (IS_ENVELOPE(element))
10108 local_player->show_envelope = element;
10113 case CA_SET_LEVEL_TIME:
10115 if (level.time > 0) // only modify limited time value
10117 TimeLeft = action_arg_number_new;
10119 game_panel_controls[GAME_PANEL_TIME].value = TimeLeft;
10121 DisplayGameControlValues();
10123 if (!TimeLeft && setup.time_limit)
10124 for (i = 0; i < MAX_PLAYERS; i++)
10125 KillPlayer(&stored_player[i]);
10131 case CA_SET_LEVEL_SCORE:
10133 game.score = action_arg_number_new;
10135 game_panel_controls[GAME_PANEL_SCORE].value = game.score;
10137 DisplayGameControlValues();
10142 case CA_SET_LEVEL_GEMS:
10144 game.gems_still_needed = action_arg_number_new;
10146 game.snapshot.collected_item = TRUE;
10148 game_panel_controls[GAME_PANEL_GEMS].value = game.gems_still_needed;
10150 DisplayGameControlValues();
10155 case CA_SET_LEVEL_WIND:
10157 game.wind_direction = action_arg_direction;
10162 case CA_SET_LEVEL_RANDOM_SEED:
10164 // ensure that setting a new random seed while playing is predictable
10165 InitRND(action_arg_number_new ? action_arg_number_new : RND(1000000) + 1);
10170 // ---------- player actions ---------------------------------------------
10172 case CA_MOVE_PLAYER:
10173 case CA_MOVE_PLAYER_NEW:
10175 // automatically move to the next field in specified direction
10176 for (i = 0; i < MAX_PLAYERS; i++)
10177 if (trigger_player_bits & (1 << i))
10178 if (action_type == CA_MOVE_PLAYER ||
10179 stored_player[i].MovPos == 0)
10180 stored_player[i].programmed_action = action_arg_direction;
10185 case CA_EXIT_PLAYER:
10187 for (i = 0; i < MAX_PLAYERS; i++)
10188 if (action_arg_player_bits & (1 << i))
10189 ExitPlayer(&stored_player[i]);
10191 if (game.players_still_needed == 0)
10197 case CA_KILL_PLAYER:
10199 for (i = 0; i < MAX_PLAYERS; i++)
10200 if (action_arg_player_bits & (1 << i))
10201 KillPlayer(&stored_player[i]);
10206 case CA_SET_PLAYER_KEYS:
10208 int key_state = (action_mode == CA_MODE_ADD ? TRUE : FALSE);
10209 int element = getSpecialActionElement(action_arg_element,
10210 action_arg_number, EL_KEY_1);
10212 if (IS_KEY(element))
10214 for (i = 0; i < MAX_PLAYERS; i++)
10216 if (trigger_player_bits & (1 << i))
10218 stored_player[i].key[KEY_NR(element)] = key_state;
10220 DrawGameDoorValues();
10228 case CA_SET_PLAYER_SPEED:
10230 for (i = 0; i < MAX_PLAYERS; i++)
10232 if (trigger_player_bits & (1 << i))
10234 int move_stepsize = TILEX / stored_player[i].move_delay_value;
10236 if (action_arg == CA_ARG_SPEED_FASTER &&
10237 stored_player[i].cannot_move)
10239 action_arg_number = STEPSIZE_VERY_SLOW;
10241 else if (action_arg == CA_ARG_SPEED_SLOWER ||
10242 action_arg == CA_ARG_SPEED_FASTER)
10244 action_arg_number = 2;
10245 action_mode = (action_arg == CA_ARG_SPEED_SLOWER ? CA_MODE_DIVIDE :
10248 else if (action_arg == CA_ARG_NUMBER_RESET)
10250 action_arg_number = level.initial_player_stepsize[i];
10254 getModifiedActionNumber(move_stepsize,
10257 action_arg_number_min,
10258 action_arg_number_max);
10260 SetPlayerMoveSpeed(&stored_player[i], move_stepsize, FALSE);
10267 case CA_SET_PLAYER_SHIELD:
10269 for (i = 0; i < MAX_PLAYERS; i++)
10271 if (trigger_player_bits & (1 << i))
10273 if (action_arg == CA_ARG_SHIELD_OFF)
10275 stored_player[i].shield_normal_time_left = 0;
10276 stored_player[i].shield_deadly_time_left = 0;
10278 else if (action_arg == CA_ARG_SHIELD_NORMAL)
10280 stored_player[i].shield_normal_time_left = 999999;
10282 else if (action_arg == CA_ARG_SHIELD_DEADLY)
10284 stored_player[i].shield_normal_time_left = 999999;
10285 stored_player[i].shield_deadly_time_left = 999999;
10293 case CA_SET_PLAYER_GRAVITY:
10295 for (i = 0; i < MAX_PLAYERS; i++)
10297 if (trigger_player_bits & (1 << i))
10299 stored_player[i].gravity =
10300 (action_arg == CA_ARG_GRAVITY_OFF ? FALSE :
10301 action_arg == CA_ARG_GRAVITY_ON ? TRUE :
10302 action_arg == CA_ARG_GRAVITY_TOGGLE ? !stored_player[i].gravity :
10303 stored_player[i].gravity);
10310 case CA_SET_PLAYER_ARTWORK:
10312 for (i = 0; i < MAX_PLAYERS; i++)
10314 if (trigger_player_bits & (1 << i))
10316 int artwork_element = action_arg_element;
10318 if (action_arg == CA_ARG_ELEMENT_RESET)
10320 (level.use_artwork_element[i] ? level.artwork_element[i] :
10321 stored_player[i].element_nr);
10323 if (stored_player[i].artwork_element != artwork_element)
10324 stored_player[i].Frame = 0;
10326 stored_player[i].artwork_element = artwork_element;
10328 SetPlayerWaiting(&stored_player[i], FALSE);
10330 // set number of special actions for bored and sleeping animation
10331 stored_player[i].num_special_action_bored =
10332 get_num_special_action(artwork_element,
10333 ACTION_BORING_1, ACTION_BORING_LAST);
10334 stored_player[i].num_special_action_sleeping =
10335 get_num_special_action(artwork_element,
10336 ACTION_SLEEPING_1, ACTION_SLEEPING_LAST);
10343 case CA_SET_PLAYER_INVENTORY:
10345 for (i = 0; i < MAX_PLAYERS; i++)
10347 struct PlayerInfo *player = &stored_player[i];
10350 if (trigger_player_bits & (1 << i))
10352 int inventory_element = action_arg_element;
10354 if (action_arg == CA_ARG_ELEMENT_TARGET ||
10355 action_arg == CA_ARG_ELEMENT_TRIGGER ||
10356 action_arg == CA_ARG_ELEMENT_ACTION)
10358 int element = inventory_element;
10359 int collect_count = element_info[element].collect_count_initial;
10361 if (!IS_CUSTOM_ELEMENT(element))
10364 if (collect_count == 0)
10365 player->inventory_infinite_element = element;
10367 for (k = 0; k < collect_count; k++)
10368 if (player->inventory_size < MAX_INVENTORY_SIZE)
10369 player->inventory_element[player->inventory_size++] =
10372 else if (action_arg == CA_ARG_INVENTORY_RM_TARGET ||
10373 action_arg == CA_ARG_INVENTORY_RM_TRIGGER ||
10374 action_arg == CA_ARG_INVENTORY_RM_ACTION)
10376 if (player->inventory_infinite_element != EL_UNDEFINED &&
10377 IS_EQUAL_OR_IN_GROUP(player->inventory_infinite_element,
10378 action_arg_element_raw))
10379 player->inventory_infinite_element = EL_UNDEFINED;
10381 for (k = 0, j = 0; j < player->inventory_size; j++)
10383 if (!IS_EQUAL_OR_IN_GROUP(player->inventory_element[j],
10384 action_arg_element_raw))
10385 player->inventory_element[k++] = player->inventory_element[j];
10388 player->inventory_size = k;
10390 else if (action_arg == CA_ARG_INVENTORY_RM_FIRST)
10392 if (player->inventory_size > 0)
10394 for (j = 0; j < player->inventory_size - 1; j++)
10395 player->inventory_element[j] = player->inventory_element[j + 1];
10397 player->inventory_size--;
10400 else if (action_arg == CA_ARG_INVENTORY_RM_LAST)
10402 if (player->inventory_size > 0)
10403 player->inventory_size--;
10405 else if (action_arg == CA_ARG_INVENTORY_RM_ALL)
10407 player->inventory_infinite_element = EL_UNDEFINED;
10408 player->inventory_size = 0;
10410 else if (action_arg == CA_ARG_INVENTORY_RESET)
10412 player->inventory_infinite_element = EL_UNDEFINED;
10413 player->inventory_size = 0;
10415 if (level.use_initial_inventory[i])
10417 for (j = 0; j < level.initial_inventory_size[i]; j++)
10419 int element = level.initial_inventory_content[i][j];
10420 int collect_count = element_info[element].collect_count_initial;
10422 if (!IS_CUSTOM_ELEMENT(element))
10425 if (collect_count == 0)
10426 player->inventory_infinite_element = element;
10428 for (k = 0; k < collect_count; k++)
10429 if (player->inventory_size < MAX_INVENTORY_SIZE)
10430 player->inventory_element[player->inventory_size++] =
10441 // ---------- CE actions -------------------------------------------------
10443 case CA_SET_CE_VALUE:
10445 int last_ce_value = CustomValue[x][y];
10447 CustomValue[x][y] = action_arg_number_new;
10449 if (CustomValue[x][y] != last_ce_value)
10451 CheckElementChange(x, y, element, EL_UNDEFINED, CE_VALUE_CHANGES);
10452 CheckTriggeredElementChange(x, y, element, CE_VALUE_CHANGES_OF_X);
10454 if (CustomValue[x][y] == 0)
10456 // reset change counter (else CE_VALUE_GETS_ZERO would not work)
10457 ChangeCount[x][y] = 0; // allow at least one more change
10459 CheckElementChange(x, y, element, EL_UNDEFINED, CE_VALUE_GETS_ZERO);
10460 CheckTriggeredElementChange(x, y, element, CE_VALUE_GETS_ZERO_OF_X);
10467 case CA_SET_CE_SCORE:
10469 int last_ce_score = ei->collect_score;
10471 ei->collect_score = action_arg_number_new;
10473 if (ei->collect_score != last_ce_score)
10475 CheckElementChange(x, y, element, EL_UNDEFINED, CE_SCORE_CHANGES);
10476 CheckTriggeredElementChange(x, y, element, CE_SCORE_CHANGES_OF_X);
10478 if (ei->collect_score == 0)
10482 // reset change counter (else CE_SCORE_GETS_ZERO would not work)
10483 ChangeCount[x][y] = 0; // allow at least one more change
10485 CheckElementChange(x, y, element, EL_UNDEFINED, CE_SCORE_GETS_ZERO);
10486 CheckTriggeredElementChange(x, y, element, CE_SCORE_GETS_ZERO_OF_X);
10489 This is a very special case that seems to be a mixture between
10490 CheckElementChange() and CheckTriggeredElementChange(): while
10491 the first one only affects single elements that are triggered
10492 directly, the second one affects multiple elements in the playfield
10493 that are triggered indirectly by another element. This is a third
10494 case: Changing the CE score always affects multiple identical CEs,
10495 so every affected CE must be checked, not only the single CE for
10496 which the CE score was changed in the first place (as every instance
10497 of that CE shares the same CE score, and therefore also can change)!
10499 SCAN_PLAYFIELD(xx, yy)
10501 if (Tile[xx][yy] == element)
10502 CheckElementChange(xx, yy, element, EL_UNDEFINED,
10503 CE_SCORE_GETS_ZERO);
10511 case CA_SET_CE_ARTWORK:
10513 int artwork_element = action_arg_element;
10514 boolean reset_frame = FALSE;
10517 if (action_arg == CA_ARG_ELEMENT_RESET)
10518 artwork_element = (ei->use_gfx_element ? ei->gfx_element_initial :
10521 if (ei->gfx_element != artwork_element)
10522 reset_frame = TRUE;
10524 ei->gfx_element = artwork_element;
10526 SCAN_PLAYFIELD(xx, yy)
10528 if (Tile[xx][yy] == element)
10532 ResetGfxAnimation(xx, yy);
10533 ResetRandomAnimationValue(xx, yy);
10536 TEST_DrawLevelField(xx, yy);
10543 // ---------- engine actions ---------------------------------------------
10545 case CA_SET_ENGINE_SCAN_MODE:
10547 InitPlayfieldScanMode(action_arg);
10557 static void CreateFieldExt(int x, int y, int element, boolean is_change)
10559 int old_element = Tile[x][y];
10560 int new_element = GetElementFromGroupElement(element);
10561 int previous_move_direction = MovDir[x][y];
10562 int last_ce_value = CustomValue[x][y];
10563 boolean player_explosion_protected = PLAYER_EXPLOSION_PROTECTED(x, y);
10564 boolean new_element_is_player = ELEM_IS_PLAYER(new_element);
10565 boolean add_player_onto_element = (new_element_is_player &&
10566 new_element != EL_SOKOBAN_FIELD_PLAYER &&
10567 IS_WALKABLE(old_element));
10569 if (!add_player_onto_element)
10571 if (IS_MOVING(x, y) || IS_BLOCKED(x, y))
10572 RemoveMovingField(x, y);
10576 Tile[x][y] = new_element;
10578 if (element_info[new_element].move_direction_initial == MV_START_PREVIOUS)
10579 MovDir[x][y] = previous_move_direction;
10581 if (element_info[new_element].use_last_ce_value)
10582 CustomValue[x][y] = last_ce_value;
10584 InitField_WithBug1(x, y, FALSE);
10586 new_element = Tile[x][y]; // element may have changed
10588 ResetGfxAnimation(x, y);
10589 ResetRandomAnimationValue(x, y);
10591 TEST_DrawLevelField(x, y);
10593 if (GFX_CRUMBLED(new_element))
10594 TEST_DrawLevelFieldCrumbledNeighbours(x, y);
10597 // check if element under the player changes from accessible to unaccessible
10598 // (needed for special case of dropping element which then changes)
10599 // (must be checked after creating new element for walkable group elements)
10600 if (IS_PLAYER(x, y) && !player_explosion_protected &&
10601 IS_ACCESSIBLE(old_element) && !IS_ACCESSIBLE(new_element))
10608 // "ChangeCount" not set yet to allow "entered by player" change one time
10609 if (new_element_is_player)
10610 RelocatePlayer(x, y, new_element);
10613 ChangeCount[x][y]++; // count number of changes in the same frame
10615 TestIfBadThingTouchesPlayer(x, y);
10616 TestIfPlayerTouchesCustomElement(x, y);
10617 TestIfElementTouchesCustomElement(x, y);
10620 static void CreateField(int x, int y, int element)
10622 CreateFieldExt(x, y, element, FALSE);
10625 static void CreateElementFromChange(int x, int y, int element)
10627 element = GET_VALID_RUNTIME_ELEMENT(element);
10629 if (game.engine_version >= VERSION_IDENT(3,2,0,7))
10631 int old_element = Tile[x][y];
10633 // prevent changed element from moving in same engine frame
10634 // unless both old and new element can either fall or move
10635 if ((!CAN_FALL(old_element) || !CAN_FALL(element)) &&
10636 (!CAN_MOVE(old_element) || !CAN_MOVE(element)))
10640 CreateFieldExt(x, y, element, TRUE);
10643 static boolean ChangeElement(int x, int y, int element, int page)
10645 struct ElementInfo *ei = &element_info[element];
10646 struct ElementChangeInfo *change = &ei->change_page[page];
10647 int ce_value = CustomValue[x][y];
10648 int ce_score = ei->collect_score;
10649 int target_element;
10650 int old_element = Tile[x][y];
10652 // always use default change event to prevent running into a loop
10653 if (ChangeEvent[x][y] == -1)
10654 ChangeEvent[x][y] = CE_DELAY;
10656 if (ChangeEvent[x][y] == CE_DELAY)
10658 // reset actual trigger element, trigger player and action element
10659 change->actual_trigger_element = EL_EMPTY;
10660 change->actual_trigger_player = EL_EMPTY;
10661 change->actual_trigger_player_bits = CH_PLAYER_NONE;
10662 change->actual_trigger_side = CH_SIDE_NONE;
10663 change->actual_trigger_ce_value = 0;
10664 change->actual_trigger_ce_score = 0;
10667 // do not change elements more than a specified maximum number of changes
10668 if (ChangeCount[x][y] >= game.max_num_changes_per_frame)
10671 ChangeCount[x][y]++; // count number of changes in the same frame
10673 if (change->explode)
10680 if (change->use_target_content)
10682 boolean complete_replace = TRUE;
10683 boolean can_replace[3][3];
10686 for (yy = 0; yy < 3; yy++) for (xx = 0; xx < 3 ; xx++)
10689 boolean is_walkable;
10690 boolean is_diggable;
10691 boolean is_collectible;
10692 boolean is_removable;
10693 boolean is_destructible;
10694 int ex = x + xx - 1;
10695 int ey = y + yy - 1;
10696 int content_element = change->target_content.e[xx][yy];
10699 can_replace[xx][yy] = TRUE;
10701 if (ex == x && ey == y) // do not check changing element itself
10704 if (content_element == EL_EMPTY_SPACE)
10706 can_replace[xx][yy] = FALSE; // do not replace border with space
10711 if (!IN_LEV_FIELD(ex, ey))
10713 can_replace[xx][yy] = FALSE;
10714 complete_replace = FALSE;
10721 if (IS_MOVING(ex, ey) || IS_BLOCKED(ex, ey))
10722 e = MovingOrBlocked2Element(ex, ey);
10724 is_empty = (IS_FREE(ex, ey) ||
10725 (IS_FREE_OR_PLAYER(ex, ey) && IS_WALKABLE(content_element)));
10727 is_walkable = (is_empty || IS_WALKABLE(e));
10728 is_diggable = (is_empty || IS_DIGGABLE(e));
10729 is_collectible = (is_empty || IS_COLLECTIBLE(e));
10730 is_destructible = (is_empty || !IS_INDESTRUCTIBLE(e));
10731 is_removable = (is_diggable || is_collectible);
10733 can_replace[xx][yy] =
10734 (((change->replace_when == CP_WHEN_EMPTY && is_empty) ||
10735 (change->replace_when == CP_WHEN_WALKABLE && is_walkable) ||
10736 (change->replace_when == CP_WHEN_DIGGABLE && is_diggable) ||
10737 (change->replace_when == CP_WHEN_COLLECTIBLE && is_collectible) ||
10738 (change->replace_when == CP_WHEN_REMOVABLE && is_removable) ||
10739 (change->replace_when == CP_WHEN_DESTRUCTIBLE && is_destructible)) &&
10740 !(IS_PLAYER(ex, ey) && ELEM_IS_PLAYER(content_element)));
10742 if (!can_replace[xx][yy])
10743 complete_replace = FALSE;
10746 if (!change->only_if_complete || complete_replace)
10748 boolean something_has_changed = FALSE;
10750 if (change->only_if_complete && change->use_random_replace &&
10751 RND(100) < change->random_percentage)
10754 for (yy = 0; yy < 3; yy++) for (xx = 0; xx < 3 ; xx++)
10756 int ex = x + xx - 1;
10757 int ey = y + yy - 1;
10758 int content_element;
10760 if (can_replace[xx][yy] && (!change->use_random_replace ||
10761 RND(100) < change->random_percentage))
10763 if (IS_MOVING(ex, ey) || IS_BLOCKED(ex, ey))
10764 RemoveMovingField(ex, ey);
10766 ChangeEvent[ex][ey] = ChangeEvent[x][y];
10768 content_element = change->target_content.e[xx][yy];
10769 target_element = GET_TARGET_ELEMENT(element, content_element, change,
10770 ce_value, ce_score);
10772 CreateElementFromChange(ex, ey, target_element);
10774 something_has_changed = TRUE;
10776 // for symmetry reasons, freeze newly created border elements
10777 if (ex != x || ey != y)
10778 Stop[ex][ey] = TRUE; // no more moving in this frame
10782 if (something_has_changed)
10784 PlayLevelSoundElementAction(x, y, element, ACTION_CHANGING);
10785 PlayLevelSoundElementAction(x, y, element, ACTION_PAGE_1 + page);
10791 target_element = GET_TARGET_ELEMENT(element, change->target_element, change,
10792 ce_value, ce_score);
10794 if (element == EL_DIAGONAL_GROWING ||
10795 element == EL_DIAGONAL_SHRINKING)
10797 target_element = Store[x][y];
10799 Store[x][y] = EL_EMPTY;
10802 CreateElementFromChange(x, y, target_element);
10804 PlayLevelSoundElementAction(x, y, element, ACTION_CHANGING);
10805 PlayLevelSoundElementAction(x, y, element, ACTION_PAGE_1 + page);
10808 // this uses direct change before indirect change
10809 CheckTriggeredElementChangeByPage(x, y, old_element, CE_CHANGE_OF_X, page);
10814 static void HandleElementChange(int x, int y, int page)
10816 int element = MovingOrBlocked2Element(x, y);
10817 struct ElementInfo *ei = &element_info[element];
10818 struct ElementChangeInfo *change = &ei->change_page[page];
10819 boolean handle_action_before_change = FALSE;
10822 if (!CAN_CHANGE_OR_HAS_ACTION(element) &&
10823 !CAN_CHANGE_OR_HAS_ACTION(Back[x][y]))
10825 Debug("game:playing:HandleElementChange", "%d,%d: element = %d ('%s')",
10826 x, y, element, element_info[element].token_name);
10827 Debug("game:playing:HandleElementChange", "This should never happen!");
10831 // this can happen with classic bombs on walkable, changing elements
10832 if (!CAN_CHANGE_OR_HAS_ACTION(element))
10837 if (ChangeDelay[x][y] == 0) // initialize element change
10839 ChangeDelay[x][y] = GET_CHANGE_DELAY(change) + 1;
10841 if (change->can_change)
10843 // !!! not clear why graphic animation should be reset at all here !!!
10844 // !!! UPDATE: but is needed for correct Snake Bite tail animation !!!
10845 // !!! SOLUTION: do not reset if graphics engine set to 4 or above !!!
10848 GRAPHICAL BUG ADDRESSED BY CHECKING GRAPHICS ENGINE VERSION:
10850 When using an animation frame delay of 1 (this only happens with
10851 "sp_zonk.moving.left/right" in the classic graphics), the default
10852 (non-moving) animation shows wrong animation frames (while the
10853 moving animation, like "sp_zonk.moving.left/right", is correct,
10854 so this graphical bug never shows up with the classic graphics).
10855 For an animation with 4 frames, this causes wrong frames 0,0,1,2
10856 be drawn instead of the correct frames 0,1,2,3. This is caused by
10857 "GfxFrame[][]" being reset *twice* (in two successive frames) after
10858 an element change: First when the change delay ("ChangeDelay[][]")
10859 counter has reached zero after decrementing, then a second time in
10860 the next frame (after "GfxFrame[][]" was already incremented) when
10861 "ChangeDelay[][]" is reset to the initial delay value again.
10863 This causes frame 0 to be drawn twice, while the last frame won't
10864 be drawn anymore, resulting in the wrong frame sequence 0,0,1,2.
10866 As some animations may already be cleverly designed around this bug
10867 (at least the "Snake Bite" snake tail animation does this), it cannot
10868 simply be fixed here without breaking such existing animations.
10869 Unfortunately, it cannot easily be detected if a graphics set was
10870 designed "before" or "after" the bug was fixed. As a workaround,
10871 a new graphics set option "game.graphics_engine_version" was added
10872 to be able to specify the game's major release version for which the
10873 graphics set was designed, which can then be used to decide if the
10874 bugfix should be used (version 4 and above) or not (version 3 or
10875 below, or if no version was specified at all, as with old sets).
10877 (The wrong/fixed animation frames can be tested with the test level set
10878 "test_gfxframe" and level "000", which contains a specially prepared
10879 custom element at level position (x/y) == (11/9) which uses the zonk
10880 animation mentioned above. Using "game.graphics_engine_version: 4"
10881 fixes the wrong animation frames, showing the correct frames 0,1,2,3.
10882 This can also be seen from the debug output for this test element.)
10885 // when a custom element is about to change (for example by change delay),
10886 // do not reset graphic animation when the custom element is moving
10887 if (game.graphics_engine_version < 4 &&
10890 ResetGfxAnimation(x, y);
10891 ResetRandomAnimationValue(x, y);
10894 if (change->pre_change_function)
10895 change->pre_change_function(x, y);
10899 ChangeDelay[x][y]--;
10901 if (ChangeDelay[x][y] != 0) // continue element change
10903 if (change->can_change)
10905 int graphic = el_act_dir2img(element, GfxAction[x][y], GfxDir[x][y]);
10907 if (IS_ANIMATED(graphic))
10908 DrawLevelGraphicAnimationIfNeeded(x, y, graphic);
10910 if (change->change_function)
10911 change->change_function(x, y);
10914 else // finish element change
10916 if (ChangePage[x][y] != -1) // remember page from delayed change
10918 page = ChangePage[x][y];
10919 ChangePage[x][y] = -1;
10921 change = &ei->change_page[page];
10924 if (IS_MOVING(x, y)) // never change a running system ;-)
10926 ChangeDelay[x][y] = 1; // try change after next move step
10927 ChangePage[x][y] = page; // remember page to use for change
10932 // special case: set new level random seed before changing element
10933 if (change->has_action && change->action_type == CA_SET_LEVEL_RANDOM_SEED)
10934 handle_action_before_change = TRUE;
10936 if (change->has_action && handle_action_before_change)
10937 ExecuteCustomElementAction(x, y, element, page);
10939 if (change->can_change)
10941 if (ChangeElement(x, y, element, page))
10943 if (change->post_change_function)
10944 change->post_change_function(x, y);
10948 if (change->has_action && !handle_action_before_change)
10949 ExecuteCustomElementAction(x, y, element, page);
10953 static boolean CheckTriggeredElementChangeExt(int trigger_x, int trigger_y,
10954 int trigger_element,
10956 int trigger_player,
10960 boolean change_done_any = FALSE;
10961 int trigger_page_bits = (trigger_page < 0 ? CH_PAGE_ANY : 1 << trigger_page);
10964 if (!(trigger_events[trigger_element][trigger_event]))
10967 RECURSION_LOOP_DETECTION_START(trigger_element, FALSE);
10969 for (i = 0; i < NUM_CUSTOM_ELEMENTS; i++)
10971 int element = EL_CUSTOM_START + i;
10972 boolean change_done = FALSE;
10975 if (!CAN_CHANGE_OR_HAS_ACTION(element) ||
10976 !HAS_ANY_CHANGE_EVENT(element, trigger_event))
10979 for (p = 0; p < element_info[element].num_change_pages; p++)
10981 struct ElementChangeInfo *change = &element_info[element].change_page[p];
10983 if (change->can_change_or_has_action &&
10984 change->has_event[trigger_event] &&
10985 change->trigger_side & trigger_side &&
10986 change->trigger_player & trigger_player &&
10987 change->trigger_page & trigger_page_bits &&
10988 IS_EQUAL_OR_IN_GROUP(trigger_element, change->trigger_element))
10990 change->actual_trigger_element = trigger_element;
10991 change->actual_trigger_player = GET_PLAYER_FROM_BITS(trigger_player);
10992 change->actual_trigger_player_bits = trigger_player;
10993 change->actual_trigger_side = trigger_side;
10994 change->actual_trigger_ce_value = CustomValue[trigger_x][trigger_y];
10995 change->actual_trigger_ce_score = GET_CE_SCORE(trigger_element);
10997 if ((change->can_change && !change_done) || change->has_action)
11001 SCAN_PLAYFIELD(x, y)
11003 if (Tile[x][y] == element)
11005 if (change->can_change && !change_done)
11007 // if element already changed in this frame, not only prevent
11008 // another element change (checked in ChangeElement()), but
11009 // also prevent additional element actions for this element
11011 if (ChangeCount[x][y] >= game.max_num_changes_per_frame &&
11012 !level.use_action_after_change_bug)
11015 ChangeDelay[x][y] = 1;
11016 ChangeEvent[x][y] = trigger_event;
11018 HandleElementChange(x, y, p);
11020 else if (change->has_action)
11022 // if element already changed in this frame, not only prevent
11023 // another element change (checked in ChangeElement()), but
11024 // also prevent additional element actions for this element
11026 if (ChangeCount[x][y] >= game.max_num_changes_per_frame &&
11027 !level.use_action_after_change_bug)
11030 ExecuteCustomElementAction(x, y, element, p);
11031 PlayLevelSoundElementAction(x, y, element, ACTION_PAGE_1 + p);
11036 if (change->can_change)
11038 change_done = TRUE;
11039 change_done_any = TRUE;
11046 RECURSION_LOOP_DETECTION_END();
11048 return change_done_any;
11051 static boolean CheckElementChangeExt(int x, int y,
11053 int trigger_element,
11055 int trigger_player,
11058 boolean change_done = FALSE;
11061 if (!CAN_CHANGE_OR_HAS_ACTION(element) ||
11062 !HAS_ANY_CHANGE_EVENT(element, trigger_event))
11065 if (Tile[x][y] == EL_BLOCKED)
11067 Blocked2Moving(x, y, &x, &y);
11068 element = Tile[x][y];
11071 // check if element has already changed or is about to change after moving
11072 if ((game.engine_version < VERSION_IDENT(3,2,0,7) &&
11073 Tile[x][y] != element) ||
11075 (game.engine_version >= VERSION_IDENT(3,2,0,7) &&
11076 (ChangeCount[x][y] >= game.max_num_changes_per_frame ||
11077 ChangePage[x][y] != -1)))
11080 RECURSION_LOOP_DETECTION_START(trigger_element, FALSE);
11082 for (p = 0; p < element_info[element].num_change_pages; p++)
11084 struct ElementChangeInfo *change = &element_info[element].change_page[p];
11086 /* check trigger element for all events where the element that is checked
11087 for changing interacts with a directly adjacent element -- this is
11088 different to element changes that affect other elements to change on the
11089 whole playfield (which is handeld by CheckTriggeredElementChangeExt()) */
11090 boolean check_trigger_element =
11091 (trigger_event == CE_TOUCHING_X ||
11092 trigger_event == CE_HITTING_X ||
11093 trigger_event == CE_HIT_BY_X ||
11094 trigger_event == CE_DIGGING_X); // this one was forgotten until 3.2.3
11096 if (change->can_change_or_has_action &&
11097 change->has_event[trigger_event] &&
11098 change->trigger_side & trigger_side &&
11099 change->trigger_player & trigger_player &&
11100 (!check_trigger_element ||
11101 IS_EQUAL_OR_IN_GROUP(trigger_element, change->trigger_element)))
11103 change->actual_trigger_element = trigger_element;
11104 change->actual_trigger_player = GET_PLAYER_FROM_BITS(trigger_player);
11105 change->actual_trigger_player_bits = trigger_player;
11106 change->actual_trigger_side = trigger_side;
11107 change->actual_trigger_ce_value = CustomValue[x][y];
11108 change->actual_trigger_ce_score = GET_CE_SCORE(trigger_element);
11110 // special case: trigger element not at (x,y) position for some events
11111 if (check_trigger_element)
11123 { 0, 0 }, { 0, 0 }, { 0, 0 },
11127 int xx = x + move_xy[MV_DIR_OPPOSITE(trigger_side)].dx;
11128 int yy = y + move_xy[MV_DIR_OPPOSITE(trigger_side)].dy;
11130 change->actual_trigger_ce_value = CustomValue[xx][yy];
11131 change->actual_trigger_ce_score = GET_CE_SCORE(trigger_element);
11134 if (change->can_change && !change_done)
11136 ChangeDelay[x][y] = 1;
11137 ChangeEvent[x][y] = trigger_event;
11139 HandleElementChange(x, y, p);
11141 change_done = TRUE;
11143 else if (change->has_action)
11145 ExecuteCustomElementAction(x, y, element, p);
11146 PlayLevelSoundElementAction(x, y, element, ACTION_PAGE_1 + p);
11151 RECURSION_LOOP_DETECTION_END();
11153 return change_done;
11156 static void PlayPlayerSound(struct PlayerInfo *player)
11158 int jx = player->jx, jy = player->jy;
11159 int sound_element = player->artwork_element;
11160 int last_action = player->last_action_waiting;
11161 int action = player->action_waiting;
11163 if (player->is_waiting)
11165 if (action != last_action)
11166 PlayLevelSoundElementAction(jx, jy, sound_element, action);
11168 PlayLevelSoundElementActionIfLoop(jx, jy, sound_element, action);
11172 if (action != last_action)
11173 StopSound(element_info[sound_element].sound[last_action]);
11175 if (last_action == ACTION_SLEEPING)
11176 PlayLevelSoundElementAction(jx, jy, sound_element, ACTION_AWAKENING);
11180 static void PlayAllPlayersSound(void)
11184 for (i = 0; i < MAX_PLAYERS; i++)
11185 if (stored_player[i].active)
11186 PlayPlayerSound(&stored_player[i]);
11189 static void SetPlayerWaiting(struct PlayerInfo *player, boolean is_waiting)
11191 boolean last_waiting = player->is_waiting;
11192 int move_dir = player->MovDir;
11194 player->dir_waiting = move_dir;
11195 player->last_action_waiting = player->action_waiting;
11199 if (!last_waiting) // not waiting -> waiting
11201 player->is_waiting = TRUE;
11203 player->frame_counter_bored =
11205 game.player_boring_delay_fixed +
11206 GetSimpleRandom(game.player_boring_delay_random);
11207 player->frame_counter_sleeping =
11209 game.player_sleeping_delay_fixed +
11210 GetSimpleRandom(game.player_sleeping_delay_random);
11212 InitPlayerGfxAnimation(player, ACTION_WAITING, move_dir);
11215 if (game.player_sleeping_delay_fixed +
11216 game.player_sleeping_delay_random > 0 &&
11217 player->anim_delay_counter == 0 &&
11218 player->post_delay_counter == 0 &&
11219 FrameCounter >= player->frame_counter_sleeping)
11220 player->is_sleeping = TRUE;
11221 else if (game.player_boring_delay_fixed +
11222 game.player_boring_delay_random > 0 &&
11223 FrameCounter >= player->frame_counter_bored)
11224 player->is_bored = TRUE;
11226 player->action_waiting = (player->is_sleeping ? ACTION_SLEEPING :
11227 player->is_bored ? ACTION_BORING :
11230 if (player->is_sleeping && player->use_murphy)
11232 // special case for sleeping Murphy when leaning against non-free tile
11234 if (!IN_LEV_FIELD(player->jx - 1, player->jy) ||
11235 (Tile[player->jx - 1][player->jy] != EL_EMPTY &&
11236 !IS_MOVING(player->jx - 1, player->jy)))
11237 move_dir = MV_LEFT;
11238 else if (!IN_LEV_FIELD(player->jx + 1, player->jy) ||
11239 (Tile[player->jx + 1][player->jy] != EL_EMPTY &&
11240 !IS_MOVING(player->jx + 1, player->jy)))
11241 move_dir = MV_RIGHT;
11243 player->is_sleeping = FALSE;
11245 player->dir_waiting = move_dir;
11248 if (player->is_sleeping)
11250 if (player->num_special_action_sleeping > 0)
11252 if (player->anim_delay_counter == 0 && player->post_delay_counter == 0)
11254 int last_special_action = player->special_action_sleeping;
11255 int num_special_action = player->num_special_action_sleeping;
11256 int special_action =
11257 (last_special_action == ACTION_DEFAULT ? ACTION_SLEEPING_1 :
11258 last_special_action == ACTION_SLEEPING ? ACTION_SLEEPING :
11259 last_special_action < ACTION_SLEEPING_1 + num_special_action - 1 ?
11260 last_special_action + 1 : ACTION_SLEEPING);
11261 int special_graphic =
11262 el_act_dir2img(player->artwork_element, special_action, move_dir);
11264 player->anim_delay_counter =
11265 graphic_info[special_graphic].anim_delay_fixed +
11266 GetSimpleRandom(graphic_info[special_graphic].anim_delay_random);
11267 player->post_delay_counter =
11268 graphic_info[special_graphic].post_delay_fixed +
11269 GetSimpleRandom(graphic_info[special_graphic].post_delay_random);
11271 player->special_action_sleeping = special_action;
11274 if (player->anim_delay_counter > 0)
11276 player->action_waiting = player->special_action_sleeping;
11277 player->anim_delay_counter--;
11279 else if (player->post_delay_counter > 0)
11281 player->post_delay_counter--;
11285 else if (player->is_bored)
11287 if (player->num_special_action_bored > 0)
11289 if (player->anim_delay_counter == 0 && player->post_delay_counter == 0)
11291 int special_action =
11292 ACTION_BORING_1 + GetSimpleRandom(player->num_special_action_bored);
11293 int special_graphic =
11294 el_act_dir2img(player->artwork_element, special_action, move_dir);
11296 player->anim_delay_counter =
11297 graphic_info[special_graphic].anim_delay_fixed +
11298 GetSimpleRandom(graphic_info[special_graphic].anim_delay_random);
11299 player->post_delay_counter =
11300 graphic_info[special_graphic].post_delay_fixed +
11301 GetSimpleRandom(graphic_info[special_graphic].post_delay_random);
11303 player->special_action_bored = special_action;
11306 if (player->anim_delay_counter > 0)
11308 player->action_waiting = player->special_action_bored;
11309 player->anim_delay_counter--;
11311 else if (player->post_delay_counter > 0)
11313 player->post_delay_counter--;
11318 else if (last_waiting) // waiting -> not waiting
11320 player->is_waiting = FALSE;
11321 player->is_bored = FALSE;
11322 player->is_sleeping = FALSE;
11324 player->frame_counter_bored = -1;
11325 player->frame_counter_sleeping = -1;
11327 player->anim_delay_counter = 0;
11328 player->post_delay_counter = 0;
11330 player->dir_waiting = player->MovDir;
11331 player->action_waiting = ACTION_DEFAULT;
11333 player->special_action_bored = ACTION_DEFAULT;
11334 player->special_action_sleeping = ACTION_DEFAULT;
11338 static void CheckSaveEngineSnapshot(struct PlayerInfo *player)
11340 if ((!player->is_moving && player->was_moving) ||
11341 (player->MovPos == 0 && player->was_moving) ||
11342 (player->is_snapping && !player->was_snapping) ||
11343 (player->is_dropping && !player->was_dropping))
11345 if (!CheckSaveEngineSnapshotToList())
11348 player->was_moving = FALSE;
11349 player->was_snapping = TRUE;
11350 player->was_dropping = TRUE;
11354 if (player->is_moving)
11355 player->was_moving = TRUE;
11357 if (!player->is_snapping)
11358 player->was_snapping = FALSE;
11360 if (!player->is_dropping)
11361 player->was_dropping = FALSE;
11364 static struct MouseActionInfo mouse_action_last = { 0 };
11365 struct MouseActionInfo mouse_action = player->effective_mouse_action;
11366 boolean new_released = (!mouse_action.button && mouse_action_last.button);
11369 CheckSaveEngineSnapshotToList();
11371 mouse_action_last = mouse_action;
11374 static void CheckSingleStepMode(struct PlayerInfo *player)
11376 if (tape.single_step && tape.recording && !tape.pausing)
11378 // as it is called "single step mode", just return to pause mode when the
11379 // player stopped moving after one tile (or never starts moving at all)
11380 // (reverse logic needed here in case single step mode used in team mode)
11381 if (player->is_moving ||
11382 player->is_pushing ||
11383 player->is_dropping_pressed ||
11384 player->effective_mouse_action.button)
11385 game.enter_single_step_mode = FALSE;
11388 CheckSaveEngineSnapshot(player);
11391 static byte PlayerActions(struct PlayerInfo *player, byte player_action)
11393 int left = player_action & JOY_LEFT;
11394 int right = player_action & JOY_RIGHT;
11395 int up = player_action & JOY_UP;
11396 int down = player_action & JOY_DOWN;
11397 int button1 = player_action & JOY_BUTTON_1;
11398 int button2 = player_action & JOY_BUTTON_2;
11399 int dx = (left ? -1 : right ? 1 : 0);
11400 int dy = (up ? -1 : down ? 1 : 0);
11402 if (!player->active || tape.pausing)
11408 SnapField(player, dx, dy);
11412 DropElement(player);
11414 MovePlayer(player, dx, dy);
11417 CheckSingleStepMode(player);
11419 SetPlayerWaiting(player, FALSE);
11421 return player_action;
11425 // no actions for this player (no input at player's configured device)
11427 DigField(player, 0, 0, 0, 0, 0, 0, DF_NO_PUSH);
11428 SnapField(player, 0, 0);
11429 CheckGravityMovementWhenNotMoving(player);
11431 if (player->MovPos == 0)
11432 SetPlayerWaiting(player, TRUE);
11434 if (player->MovPos == 0) // needed for tape.playing
11435 player->is_moving = FALSE;
11437 player->is_dropping = FALSE;
11438 player->is_dropping_pressed = FALSE;
11439 player->drop_pressed_delay = 0;
11441 CheckSingleStepMode(player);
11447 static void SetMouseActionFromTapeAction(struct MouseActionInfo *mouse_action,
11450 if (!tape.use_mouse_actions)
11453 mouse_action->lx = tape_action[TAPE_ACTION_LX];
11454 mouse_action->ly = tape_action[TAPE_ACTION_LY];
11455 mouse_action->button = tape_action[TAPE_ACTION_BUTTON];
11458 static void SetTapeActionFromMouseAction(byte *tape_action,
11459 struct MouseActionInfo *mouse_action)
11461 if (!tape.use_mouse_actions)
11464 tape_action[TAPE_ACTION_LX] = mouse_action->lx;
11465 tape_action[TAPE_ACTION_LY] = mouse_action->ly;
11466 tape_action[TAPE_ACTION_BUTTON] = mouse_action->button;
11469 static void CheckLevelSolved(void)
11471 if (level.game_engine_type == GAME_ENGINE_TYPE_EM)
11473 if (game_em.level_solved &&
11474 !game_em.game_over) // game won
11478 game_em.game_over = TRUE;
11480 game.all_players_gone = TRUE;
11483 if (game_em.game_over) // game lost
11484 game.all_players_gone = TRUE;
11486 else if (level.game_engine_type == GAME_ENGINE_TYPE_SP)
11488 if (game_sp.level_solved &&
11489 !game_sp.game_over) // game won
11493 game_sp.game_over = TRUE;
11495 game.all_players_gone = TRUE;
11498 if (game_sp.game_over) // game lost
11499 game.all_players_gone = TRUE;
11501 else if (level.game_engine_type == GAME_ENGINE_TYPE_MM)
11503 if (game_mm.level_solved &&
11504 !game_mm.game_over) // game won
11508 game_mm.game_over = TRUE;
11510 game.all_players_gone = TRUE;
11513 if (game_mm.game_over) // game lost
11514 game.all_players_gone = TRUE;
11518 static void CheckLevelTime(void)
11522 if (TimeFrames >= FRAMES_PER_SECOND)
11527 for (i = 0; i < MAX_PLAYERS; i++)
11529 struct PlayerInfo *player = &stored_player[i];
11531 if (SHIELD_ON(player))
11533 player->shield_normal_time_left--;
11535 if (player->shield_deadly_time_left > 0)
11536 player->shield_deadly_time_left--;
11540 if (!game.LevelSolved && !level.use_step_counter)
11548 if (TimeLeft <= 10 && setup.time_limit)
11549 PlaySound(SND_GAME_RUNNING_OUT_OF_TIME);
11551 /* this does not make sense: game_panel_controls[GAME_PANEL_TIME].value
11552 is reset from other values in UpdateGameDoorValues() -- FIX THIS */
11554 game_panel_controls[GAME_PANEL_TIME].value = TimeLeft;
11556 if (!TimeLeft && setup.time_limit)
11558 if (level.game_engine_type == GAME_ENGINE_TYPE_EM)
11559 game_em.lev->killed_out_of_time = TRUE;
11561 for (i = 0; i < MAX_PLAYERS; i++)
11562 KillPlayer(&stored_player[i]);
11565 else if (game.no_time_limit && !game.all_players_gone)
11567 game_panel_controls[GAME_PANEL_TIME].value = TimePlayed;
11570 game_em.lev->time = (game.no_time_limit ? TimePlayed : TimeLeft);
11573 if (tape.recording || tape.playing)
11574 DrawVideoDisplay(VIDEO_STATE_TIME_ON, TapeTime);
11577 if (tape.recording || tape.playing)
11578 DrawVideoDisplay(VIDEO_STATE_FRAME_ON, FrameCounter);
11580 UpdateAndDisplayGameControlValues();
11583 void AdvanceFrameAndPlayerCounters(int player_nr)
11587 // advance frame counters (global frame counter and time frame counter)
11591 // advance player counters (counters for move delay, move animation etc.)
11592 for (i = 0; i < MAX_PLAYERS; i++)
11594 boolean advance_player_counters = (player_nr == -1 || player_nr == i);
11595 int move_delay_value = stored_player[i].move_delay_value;
11596 int move_frames = MOVE_DELAY_NORMAL_SPEED / move_delay_value;
11598 if (!advance_player_counters) // not all players may be affected
11601 if (move_frames == 0) // less than one move per game frame
11603 int stepsize = TILEX / move_delay_value;
11604 int delay = move_delay_value / MOVE_DELAY_NORMAL_SPEED;
11605 int count = (stored_player[i].is_moving ?
11606 ABS(stored_player[i].MovPos) / stepsize : FrameCounter);
11608 if (count % delay == 0)
11612 stored_player[i].Frame += move_frames;
11614 if (stored_player[i].MovPos != 0)
11615 stored_player[i].StepFrame += move_frames;
11617 if (stored_player[i].move_delay > 0)
11618 stored_player[i].move_delay--;
11620 // due to bugs in previous versions, counter must count up, not down
11621 if (stored_player[i].push_delay != -1)
11622 stored_player[i].push_delay++;
11624 if (stored_player[i].drop_delay > 0)
11625 stored_player[i].drop_delay--;
11627 if (stored_player[i].is_dropping_pressed)
11628 stored_player[i].drop_pressed_delay++;
11632 void StartGameActions(boolean init_network_game, boolean record_tape,
11635 unsigned int new_random_seed = InitRND(random_seed);
11638 TapeStartRecording(new_random_seed);
11640 if (init_network_game)
11642 SendToServer_LevelFile();
11643 SendToServer_StartPlaying();
11651 static void GameActionsExt(void)
11654 static unsigned int game_frame_delay = 0;
11656 unsigned int game_frame_delay_value;
11657 byte *recorded_player_action;
11658 byte summarized_player_action = 0;
11659 byte tape_action[MAX_TAPE_ACTIONS] = { 0 };
11662 // detect endless loops, caused by custom element programming
11663 if (recursion_loop_detected && recursion_loop_depth == 0)
11665 char *message = getStringCat3("Internal Error! Element ",
11666 EL_NAME(recursion_loop_element),
11667 " caused endless loop! Quit the game?");
11669 Warn("element '%s' caused endless loop in game engine",
11670 EL_NAME(recursion_loop_element));
11672 RequestQuitGameExt(FALSE, level_editor_test_game, message);
11674 recursion_loop_detected = FALSE; // if game should be continued
11681 if (game.restart_level)
11682 StartGameActions(network.enabled, setup.autorecord, level.random_seed);
11684 CheckLevelSolved();
11686 if (game.LevelSolved && !game.LevelSolved_GameEnd)
11689 if (game.all_players_gone && !TAPE_IS_STOPPED(tape))
11692 if (game_status != GAME_MODE_PLAYING) // status might have changed
11695 game_frame_delay_value =
11696 (tape.playing && tape.fast_forward ? FfwdFrameDelay : GameFrameDelay);
11698 if (tape.playing && tape.warp_forward && !tape.pausing)
11699 game_frame_delay_value = 0;
11701 SetVideoFrameDelay(game_frame_delay_value);
11703 // (de)activate virtual buttons depending on current game status
11704 if (strEqual(setup.touch.control_type, TOUCH_CONTROL_VIRTUAL_BUTTONS))
11706 if (game.all_players_gone) // if no players there to be controlled anymore
11707 SetOverlayActive(FALSE);
11708 else if (!tape.playing) // if game continues after tape stopped playing
11709 SetOverlayActive(TRUE);
11714 // ---------- main game synchronization point ----------
11716 int skip = WaitUntilDelayReached(&game_frame_delay, game_frame_delay_value);
11718 Debug("game:playing:skip", "skip == %d", skip);
11721 // ---------- main game synchronization point ----------
11723 WaitUntilDelayReached(&game_frame_delay, game_frame_delay_value);
11727 if (network_playing && !network_player_action_received)
11729 // try to get network player actions in time
11731 // last chance to get network player actions without main loop delay
11732 HandleNetworking();
11734 // game was quit by network peer
11735 if (game_status != GAME_MODE_PLAYING)
11738 // check if network player actions still missing and game still running
11739 if (!network_player_action_received && !checkGameEnded())
11740 return; // failed to get network player actions in time
11742 // do not yet reset "network_player_action_received" (for tape.pausing)
11748 // at this point we know that we really continue executing the game
11750 network_player_action_received = FALSE;
11752 // when playing tape, read previously recorded player input from tape data
11753 recorded_player_action = (tape.playing ? TapePlayAction() : NULL);
11755 local_player->effective_mouse_action = local_player->mouse_action;
11757 if (recorded_player_action != NULL)
11758 SetMouseActionFromTapeAction(&local_player->effective_mouse_action,
11759 recorded_player_action);
11761 // TapePlayAction() may return NULL when toggling to "pause before death"
11765 if (tape.set_centered_player)
11767 game.centered_player_nr_next = tape.centered_player_nr_next;
11768 game.set_centered_player = TRUE;
11771 for (i = 0; i < MAX_PLAYERS; i++)
11773 summarized_player_action |= stored_player[i].action;
11775 if (!network_playing && (game.team_mode || tape.playing))
11776 stored_player[i].effective_action = stored_player[i].action;
11779 if (network_playing && !checkGameEnded())
11780 SendToServer_MovePlayer(summarized_player_action);
11782 // summarize all actions at local players mapped input device position
11783 // (this allows using different input devices in single player mode)
11784 if (!network.enabled && !game.team_mode)
11785 stored_player[map_player_action[local_player->index_nr]].effective_action =
11786 summarized_player_action;
11788 // summarize all actions at centered player in local team mode
11789 if (tape.recording &&
11790 setup.team_mode && !network.enabled &&
11791 setup.input_on_focus &&
11792 game.centered_player_nr != -1)
11794 for (i = 0; i < MAX_PLAYERS; i++)
11795 stored_player[map_player_action[i]].effective_action =
11796 (i == game.centered_player_nr ? summarized_player_action : 0);
11799 if (recorded_player_action != NULL)
11800 for (i = 0; i < MAX_PLAYERS; i++)
11801 stored_player[i].effective_action = recorded_player_action[i];
11803 for (i = 0; i < MAX_PLAYERS; i++)
11805 tape_action[i] = stored_player[i].effective_action;
11807 /* (this may happen in the RND game engine if a player was not present on
11808 the playfield on level start, but appeared later from a custom element */
11809 if (setup.team_mode &&
11812 !tape.player_participates[i])
11813 tape.player_participates[i] = TRUE;
11816 SetTapeActionFromMouseAction(tape_action,
11817 &local_player->effective_mouse_action);
11819 // only record actions from input devices, but not programmed actions
11820 if (tape.recording)
11821 TapeRecordAction(tape_action);
11823 // remember if game was played (especially after tape stopped playing)
11824 if (!tape.playing && summarized_player_action)
11825 game.GamePlayed = TRUE;
11827 #if USE_NEW_PLAYER_ASSIGNMENTS
11828 // !!! also map player actions in single player mode !!!
11829 // if (game.team_mode)
11832 byte mapped_action[MAX_PLAYERS];
11834 #if DEBUG_PLAYER_ACTIONS
11835 for (i = 0; i < MAX_PLAYERS; i++)
11836 DebugContinued("", "%d, ", stored_player[i].effective_action);
11839 for (i = 0; i < MAX_PLAYERS; i++)
11840 mapped_action[i] = stored_player[map_player_action[i]].effective_action;
11842 for (i = 0; i < MAX_PLAYERS; i++)
11843 stored_player[i].effective_action = mapped_action[i];
11845 #if DEBUG_PLAYER_ACTIONS
11846 DebugContinued("", "=> ");
11847 for (i = 0; i < MAX_PLAYERS; i++)
11848 DebugContinued("", "%d, ", stored_player[i].effective_action);
11849 DebugContinued("game:playing:player", "\n");
11852 #if DEBUG_PLAYER_ACTIONS
11855 for (i = 0; i < MAX_PLAYERS; i++)
11856 DebugContinued("", "%d, ", stored_player[i].effective_action);
11857 DebugContinued("game:playing:player", "\n");
11862 for (i = 0; i < MAX_PLAYERS; i++)
11864 // allow engine snapshot in case of changed movement attempt
11865 if ((game.snapshot.last_action[i] & KEY_MOTION) !=
11866 (stored_player[i].effective_action & KEY_MOTION))
11867 game.snapshot.changed_action = TRUE;
11869 // allow engine snapshot in case of snapping/dropping attempt
11870 if ((game.snapshot.last_action[i] & KEY_BUTTON) == 0 &&
11871 (stored_player[i].effective_action & KEY_BUTTON) != 0)
11872 game.snapshot.changed_action = TRUE;
11874 game.snapshot.last_action[i] = stored_player[i].effective_action;
11877 if (level.game_engine_type == GAME_ENGINE_TYPE_EM)
11879 GameActions_EM_Main();
11881 else if (level.game_engine_type == GAME_ENGINE_TYPE_SP)
11883 GameActions_SP_Main();
11885 else if (level.game_engine_type == GAME_ENGINE_TYPE_MM)
11887 GameActions_MM_Main();
11891 GameActions_RND_Main();
11894 BlitScreenToBitmap(backbuffer);
11896 CheckLevelSolved();
11899 AdvanceFrameAndPlayerCounters(-1); // advance counters for all players
11901 if (global.show_frames_per_second)
11903 static unsigned int fps_counter = 0;
11904 static int fps_frames = 0;
11905 unsigned int fps_delay_ms = Counter() - fps_counter;
11909 if (fps_delay_ms >= 500) // calculate FPS every 0.5 seconds
11911 global.frames_per_second = 1000 * (float)fps_frames / fps_delay_ms;
11914 fps_counter = Counter();
11916 // always draw FPS to screen after FPS value was updated
11917 redraw_mask |= REDRAW_FPS;
11920 // only draw FPS if no screen areas are deactivated (invisible warp mode)
11921 if (GetDrawDeactivationMask() == REDRAW_NONE)
11922 redraw_mask |= REDRAW_FPS;
11926 static void GameActions_CheckSaveEngineSnapshot(void)
11928 if (!game.snapshot.save_snapshot)
11931 // clear flag for saving snapshot _before_ saving snapshot
11932 game.snapshot.save_snapshot = FALSE;
11934 SaveEngineSnapshotToList();
11937 void GameActions(void)
11941 GameActions_CheckSaveEngineSnapshot();
11944 void GameActions_EM_Main(void)
11946 byte effective_action[MAX_PLAYERS];
11947 boolean warp_mode = (tape.playing && tape.warp_forward && !tape.pausing);
11950 for (i = 0; i < MAX_PLAYERS; i++)
11951 effective_action[i] = stored_player[i].effective_action;
11953 GameActions_EM(effective_action, warp_mode);
11956 void GameActions_SP_Main(void)
11958 byte effective_action[MAX_PLAYERS];
11959 boolean warp_mode = (tape.playing && tape.warp_forward && !tape.pausing);
11962 for (i = 0; i < MAX_PLAYERS; i++)
11963 effective_action[i] = stored_player[i].effective_action;
11965 GameActions_SP(effective_action, warp_mode);
11967 for (i = 0; i < MAX_PLAYERS; i++)
11969 if (stored_player[i].force_dropping)
11970 stored_player[i].action |= KEY_BUTTON_DROP;
11972 stored_player[i].force_dropping = FALSE;
11976 void GameActions_MM_Main(void)
11978 boolean warp_mode = (tape.playing && tape.warp_forward && !tape.pausing);
11980 GameActions_MM(local_player->effective_mouse_action, warp_mode);
11983 void GameActions_RND_Main(void)
11988 void GameActions_RND(void)
11990 static struct MouseActionInfo mouse_action_last = { 0 };
11991 struct MouseActionInfo mouse_action = local_player->effective_mouse_action;
11992 int magic_wall_x = 0, magic_wall_y = 0;
11993 int i, x, y, element, graphic, last_gfx_frame;
11995 InitPlayfieldScanModeVars();
11997 if (game.engine_version >= VERSION_IDENT(3,2,0,7))
11999 SCAN_PLAYFIELD(x, y)
12001 ChangeCount[x][y] = 0;
12002 ChangeEvent[x][y] = -1;
12006 if (game.set_centered_player)
12008 boolean all_players_fit_to_screen = checkIfAllPlayersFitToScreen_RND();
12010 // switching to "all players" only possible if all players fit to screen
12011 if (game.centered_player_nr_next == -1 && !all_players_fit_to_screen)
12013 game.centered_player_nr_next = game.centered_player_nr;
12014 game.set_centered_player = FALSE;
12017 // do not switch focus to non-existing (or non-active) player
12018 if (game.centered_player_nr_next >= 0 &&
12019 !stored_player[game.centered_player_nr_next].active)
12021 game.centered_player_nr_next = game.centered_player_nr;
12022 game.set_centered_player = FALSE;
12026 if (game.set_centered_player &&
12027 ScreenMovPos == 0) // screen currently aligned at tile position
12031 if (game.centered_player_nr_next == -1)
12033 setScreenCenteredToAllPlayers(&sx, &sy);
12037 sx = stored_player[game.centered_player_nr_next].jx;
12038 sy = stored_player[game.centered_player_nr_next].jy;
12041 game.centered_player_nr = game.centered_player_nr_next;
12042 game.set_centered_player = FALSE;
12044 DrawRelocateScreen(0, 0, sx, sy, MV_NONE, TRUE, setup.quick_switch);
12045 DrawGameDoorValues();
12048 // check single step mode (set flag and clear again if any player is active)
12049 game.enter_single_step_mode =
12050 (tape.single_step && tape.recording && !tape.pausing);
12052 for (i = 0; i < MAX_PLAYERS; i++)
12054 int actual_player_action = stored_player[i].effective_action;
12057 /* !!! THIS BREAKS THE FOLLOWING TAPES: !!!
12058 - rnd_equinox_tetrachloride 048
12059 - rnd_equinox_tetrachloride_ii 096
12060 - rnd_emanuel_schmieg 002
12061 - doctor_sloan_ww 001, 020
12063 if (stored_player[i].MovPos == 0)
12064 CheckGravityMovement(&stored_player[i]);
12067 // overwrite programmed action with tape action
12068 if (stored_player[i].programmed_action)
12069 actual_player_action = stored_player[i].programmed_action;
12071 PlayerActions(&stored_player[i], actual_player_action);
12073 ScrollPlayer(&stored_player[i], SCROLL_GO_ON);
12076 // single step pause mode may already have been toggled by "ScrollPlayer()"
12077 if (game.enter_single_step_mode && !tape.pausing)
12078 TapeTogglePause(TAPE_TOGGLE_AUTOMATIC);
12080 ScrollScreen(NULL, SCROLL_GO_ON);
12082 /* for backwards compatibility, the following code emulates a fixed bug that
12083 occured when pushing elements (causing elements that just made their last
12084 pushing step to already (if possible) make their first falling step in the
12085 same game frame, which is bad); this code is also needed to use the famous
12086 "spring push bug" which is used in older levels and might be wanted to be
12087 used also in newer levels, but in this case the buggy pushing code is only
12088 affecting the "spring" element and no other elements */
12090 if (game.engine_version < VERSION_IDENT(2,2,0,7) || level.use_spring_bug)
12092 for (i = 0; i < MAX_PLAYERS; i++)
12094 struct PlayerInfo *player = &stored_player[i];
12095 int x = player->jx;
12096 int y = player->jy;
12098 if (player->active && player->is_pushing && player->is_moving &&
12100 (game.engine_version < VERSION_IDENT(2,2,0,7) ||
12101 Tile[x][y] == EL_SPRING))
12103 ContinueMoving(x, y);
12105 // continue moving after pushing (this is actually a bug)
12106 if (!IS_MOVING(x, y))
12107 Stop[x][y] = FALSE;
12112 SCAN_PLAYFIELD(x, y)
12114 Last[x][y] = Tile[x][y];
12116 ChangeCount[x][y] = 0;
12117 ChangeEvent[x][y] = -1;
12119 // this must be handled before main playfield loop
12120 if (Tile[x][y] == EL_PLAYER_IS_LEAVING)
12123 if (MovDelay[x][y] <= 0)
12127 if (Tile[x][y] == EL_ELEMENT_SNAPPING)
12130 if (MovDelay[x][y] <= 0)
12132 int element = Store[x][y];
12133 int move_direction = MovDir[x][y];
12134 int player_index_bit = Store2[x][y];
12140 TEST_DrawLevelField(x, y);
12142 TestFieldAfterSnapping(x, y, element, move_direction, player_index_bit);
12147 if (ChangePage[x][y] != -1 && ChangeDelay[x][y] != 1)
12149 Debug("game:playing:GameActions_RND", "x = %d, y = %d: ChangePage != -1",
12151 Debug("game:playing:GameActions_RND", "This should never happen!");
12153 ChangePage[x][y] = -1;
12157 Stop[x][y] = FALSE;
12158 if (WasJustMoving[x][y] > 0)
12159 WasJustMoving[x][y]--;
12160 if (WasJustFalling[x][y] > 0)
12161 WasJustFalling[x][y]--;
12162 if (CheckCollision[x][y] > 0)
12163 CheckCollision[x][y]--;
12164 if (CheckImpact[x][y] > 0)
12165 CheckImpact[x][y]--;
12169 /* reset finished pushing action (not done in ContinueMoving() to allow
12170 continuous pushing animation for elements with zero push delay) */
12171 if (GfxAction[x][y] == ACTION_PUSHING && !IS_MOVING(x, y))
12173 ResetGfxAnimation(x, y);
12174 TEST_DrawLevelField(x, y);
12178 if (IS_BLOCKED(x, y))
12182 Blocked2Moving(x, y, &oldx, &oldy);
12183 if (!IS_MOVING(oldx, oldy))
12185 Debug("game:playing:GameActions_RND", "(BLOCKED => MOVING) context corrupted!");
12186 Debug("game:playing:GameActions_RND", "BLOCKED: x = %d, y = %d", x, y);
12187 Debug("game:playing:GameActions_RND", "!MOVING: oldx = %d, oldy = %d", oldx, oldy);
12188 Debug("game:playing:GameActions_RND", "This should never happen!");
12194 if (mouse_action.button)
12196 int new_button = (mouse_action.button && mouse_action_last.button == 0);
12197 int ch_button = CH_SIDE_FROM_BUTTON(mouse_action.button);
12199 x = mouse_action.lx;
12200 y = mouse_action.ly;
12201 element = Tile[x][y];
12205 CheckElementChangeByMouse(x, y, element, CE_CLICKED_BY_MOUSE, ch_button);
12206 CheckTriggeredElementChangeByMouse(x, y, element, CE_MOUSE_CLICKED_ON_X,
12210 CheckElementChangeByMouse(x, y, element, CE_PRESSED_BY_MOUSE, ch_button);
12211 CheckTriggeredElementChangeByMouse(x, y, element, CE_MOUSE_PRESSED_ON_X,
12215 SCAN_PLAYFIELD(x, y)
12217 element = Tile[x][y];
12218 graphic = el_act_dir2img(element, GfxAction[x][y], GfxDir[x][y]);
12219 last_gfx_frame = GfxFrame[x][y];
12221 ResetGfxFrame(x, y);
12223 if (GfxFrame[x][y] != last_gfx_frame && !Stop[x][y])
12224 DrawLevelGraphicAnimation(x, y, graphic);
12226 if (ANIM_MODE(graphic) == ANIM_RANDOM &&
12227 IS_NEXT_FRAME(GfxFrame[x][y], graphic))
12228 ResetRandomAnimationValue(x, y);
12230 SetRandomAnimationValue(x, y);
12232 PlayLevelSoundActionIfLoop(x, y, GfxAction[x][y]);
12234 if (IS_INACTIVE(element))
12236 if (IS_ANIMATED(graphic))
12237 DrawLevelGraphicAnimationIfNeeded(x, y, graphic);
12242 // this may take place after moving, so 'element' may have changed
12243 if (IS_CHANGING(x, y) &&
12244 (game.engine_version < VERSION_IDENT(3,0,7,1) || !Stop[x][y]))
12246 int page = element_info[element].event_page_nr[CE_DELAY];
12248 HandleElementChange(x, y, page);
12250 element = Tile[x][y];
12251 graphic = el_act_dir2img(element, GfxAction[x][y], GfxDir[x][y]);
12254 if (!IS_MOVING(x, y) && (CAN_FALL(element) || CAN_MOVE(element)))
12258 element = Tile[x][y];
12259 graphic = el_act_dir2img(element, GfxAction[x][y], GfxDir[x][y]);
12261 if (IS_ANIMATED(graphic) &&
12262 !IS_MOVING(x, y) &&
12264 DrawLevelGraphicAnimationIfNeeded(x, y, graphic);
12266 if (IS_GEM(element) || element == EL_SP_INFOTRON)
12267 TEST_DrawTwinkleOnField(x, y);
12269 else if (element == EL_ACID)
12272 DrawLevelGraphicAnimationIfNeeded(x, y, graphic);
12274 else if ((element == EL_EXIT_OPEN ||
12275 element == EL_EM_EXIT_OPEN ||
12276 element == EL_SP_EXIT_OPEN ||
12277 element == EL_STEEL_EXIT_OPEN ||
12278 element == EL_EM_STEEL_EXIT_OPEN ||
12279 element == EL_SP_TERMINAL ||
12280 element == EL_SP_TERMINAL_ACTIVE ||
12281 element == EL_EXTRA_TIME ||
12282 element == EL_SHIELD_NORMAL ||
12283 element == EL_SHIELD_DEADLY) &&
12284 IS_ANIMATED(graphic))
12285 DrawLevelGraphicAnimationIfNeeded(x, y, graphic);
12286 else if (IS_MOVING(x, y))
12287 ContinueMoving(x, y);
12288 else if (IS_ACTIVE_BOMB(element))
12289 CheckDynamite(x, y);
12290 else if (element == EL_AMOEBA_GROWING)
12291 AmoebaGrowing(x, y);
12292 else if (element == EL_AMOEBA_SHRINKING)
12293 AmoebaShrinking(x, y);
12295 #if !USE_NEW_AMOEBA_CODE
12296 else if (IS_AMOEBALIVE(element))
12297 AmoebaReproduce(x, y);
12300 else if (element == EL_GAME_OF_LIFE || element == EL_BIOMAZE)
12302 else if (element == EL_EXIT_CLOSED)
12304 else if (element == EL_EM_EXIT_CLOSED)
12306 else if (element == EL_STEEL_EXIT_CLOSED)
12307 CheckExitSteel(x, y);
12308 else if (element == EL_EM_STEEL_EXIT_CLOSED)
12309 CheckExitSteelEM(x, y);
12310 else if (element == EL_SP_EXIT_CLOSED)
12312 else if (element == EL_EXPANDABLE_WALL_GROWING ||
12313 element == EL_EXPANDABLE_STEELWALL_GROWING)
12314 MauerWaechst(x, y);
12315 else if (element == EL_EXPANDABLE_WALL ||
12316 element == EL_EXPANDABLE_WALL_HORIZONTAL ||
12317 element == EL_EXPANDABLE_WALL_VERTICAL ||
12318 element == EL_EXPANDABLE_WALL_ANY ||
12319 element == EL_BD_EXPANDABLE_WALL)
12320 MauerAbleger(x, y);
12321 else if (element == EL_EXPANDABLE_STEELWALL_HORIZONTAL ||
12322 element == EL_EXPANDABLE_STEELWALL_VERTICAL ||
12323 element == EL_EXPANDABLE_STEELWALL_ANY)
12324 MauerAblegerStahl(x, y);
12325 else if (element == EL_FLAMES)
12326 CheckForDragon(x, y);
12327 else if (element == EL_EXPLOSION)
12328 ; // drawing of correct explosion animation is handled separately
12329 else if (element == EL_ELEMENT_SNAPPING ||
12330 element == EL_DIAGONAL_SHRINKING ||
12331 element == EL_DIAGONAL_GROWING)
12333 graphic = el_act_dir2img(GfxElement[x][y], GfxAction[x][y],GfxDir[x][y]);
12335 DrawLevelGraphicAnimationIfNeeded(x, y, graphic);
12337 else if (IS_ANIMATED(graphic) && !IS_CHANGING(x, y))
12338 DrawLevelGraphicAnimationIfNeeded(x, y, graphic);
12340 if (IS_BELT_ACTIVE(element))
12341 PlayLevelSoundAction(x, y, ACTION_ACTIVE);
12343 if (game.magic_wall_active)
12345 int jx = local_player->jx, jy = local_player->jy;
12347 // play the element sound at the position nearest to the player
12348 if ((element == EL_MAGIC_WALL_FULL ||
12349 element == EL_MAGIC_WALL_ACTIVE ||
12350 element == EL_MAGIC_WALL_EMPTYING ||
12351 element == EL_BD_MAGIC_WALL_FULL ||
12352 element == EL_BD_MAGIC_WALL_ACTIVE ||
12353 element == EL_BD_MAGIC_WALL_EMPTYING ||
12354 element == EL_DC_MAGIC_WALL_FULL ||
12355 element == EL_DC_MAGIC_WALL_ACTIVE ||
12356 element == EL_DC_MAGIC_WALL_EMPTYING) &&
12357 ABS(x - jx) + ABS(y - jy) <
12358 ABS(magic_wall_x - jx) + ABS(magic_wall_y - jy))
12366 #if USE_NEW_AMOEBA_CODE
12367 // new experimental amoeba growth stuff
12368 if (!(FrameCounter % 8))
12370 static unsigned int random = 1684108901;
12372 for (i = 0; i < level.amoeba_speed * 28 / 8; i++)
12374 x = RND(lev_fieldx);
12375 y = RND(lev_fieldy);
12376 element = Tile[x][y];
12378 if (!IS_PLAYER(x,y) &&
12379 (element == EL_EMPTY ||
12380 CAN_GROW_INTO(element) ||
12381 element == EL_QUICKSAND_EMPTY ||
12382 element == EL_QUICKSAND_FAST_EMPTY ||
12383 element == EL_ACID_SPLASH_LEFT ||
12384 element == EL_ACID_SPLASH_RIGHT))
12386 if ((IN_LEV_FIELD(x, y-1) && Tile[x][y-1] == EL_AMOEBA_WET) ||
12387 (IN_LEV_FIELD(x-1, y) && Tile[x-1][y] == EL_AMOEBA_WET) ||
12388 (IN_LEV_FIELD(x+1, y) && Tile[x+1][y] == EL_AMOEBA_WET) ||
12389 (IN_LEV_FIELD(x, y+1) && Tile[x][y+1] == EL_AMOEBA_WET))
12390 Tile[x][y] = EL_AMOEBA_DROP;
12393 random = random * 129 + 1;
12398 game.explosions_delayed = FALSE;
12400 SCAN_PLAYFIELD(x, y)
12402 element = Tile[x][y];
12404 if (ExplodeField[x][y])
12405 Explode(x, y, EX_PHASE_START, ExplodeField[x][y]);
12406 else if (element == EL_EXPLOSION)
12407 Explode(x, y, ExplodePhase[x][y], EX_TYPE_NORMAL);
12409 ExplodeField[x][y] = EX_TYPE_NONE;
12412 game.explosions_delayed = TRUE;
12414 if (game.magic_wall_active)
12416 if (!(game.magic_wall_time_left % 4))
12418 int element = Tile[magic_wall_x][magic_wall_y];
12420 if (element == EL_BD_MAGIC_WALL_FULL ||
12421 element == EL_BD_MAGIC_WALL_ACTIVE ||
12422 element == EL_BD_MAGIC_WALL_EMPTYING)
12423 PlayLevelSound(magic_wall_x, magic_wall_y, SND_BD_MAGIC_WALL_ACTIVE);
12424 else if (element == EL_DC_MAGIC_WALL_FULL ||
12425 element == EL_DC_MAGIC_WALL_ACTIVE ||
12426 element == EL_DC_MAGIC_WALL_EMPTYING)
12427 PlayLevelSound(magic_wall_x, magic_wall_y, SND_DC_MAGIC_WALL_ACTIVE);
12429 PlayLevelSound(magic_wall_x, magic_wall_y, SND_MAGIC_WALL_ACTIVE);
12432 if (game.magic_wall_time_left > 0)
12434 game.magic_wall_time_left--;
12436 if (!game.magic_wall_time_left)
12438 SCAN_PLAYFIELD(x, y)
12440 element = Tile[x][y];
12442 if (element == EL_MAGIC_WALL_ACTIVE ||
12443 element == EL_MAGIC_WALL_FULL)
12445 Tile[x][y] = EL_MAGIC_WALL_DEAD;
12446 TEST_DrawLevelField(x, y);
12448 else if (element == EL_BD_MAGIC_WALL_ACTIVE ||
12449 element == EL_BD_MAGIC_WALL_FULL)
12451 Tile[x][y] = EL_BD_MAGIC_WALL_DEAD;
12452 TEST_DrawLevelField(x, y);
12454 else if (element == EL_DC_MAGIC_WALL_ACTIVE ||
12455 element == EL_DC_MAGIC_WALL_FULL)
12457 Tile[x][y] = EL_DC_MAGIC_WALL_DEAD;
12458 TEST_DrawLevelField(x, y);
12462 game.magic_wall_active = FALSE;
12467 if (game.light_time_left > 0)
12469 game.light_time_left--;
12471 if (game.light_time_left == 0)
12472 RedrawAllLightSwitchesAndInvisibleElements();
12475 if (game.timegate_time_left > 0)
12477 game.timegate_time_left--;
12479 if (game.timegate_time_left == 0)
12480 CloseAllOpenTimegates();
12483 if (game.lenses_time_left > 0)
12485 game.lenses_time_left--;
12487 if (game.lenses_time_left == 0)
12488 RedrawAllInvisibleElementsForLenses();
12491 if (game.magnify_time_left > 0)
12493 game.magnify_time_left--;
12495 if (game.magnify_time_left == 0)
12496 RedrawAllInvisibleElementsForMagnifier();
12499 for (i = 0; i < MAX_PLAYERS; i++)
12501 struct PlayerInfo *player = &stored_player[i];
12503 if (SHIELD_ON(player))
12505 if (player->shield_deadly_time_left)
12506 PlayLevelSound(player->jx, player->jy, SND_SHIELD_DEADLY_ACTIVE);
12507 else if (player->shield_normal_time_left)
12508 PlayLevelSound(player->jx, player->jy, SND_SHIELD_NORMAL_ACTIVE);
12512 #if USE_DELAYED_GFX_REDRAW
12513 SCAN_PLAYFIELD(x, y)
12515 if (GfxRedraw[x][y] != GFX_REDRAW_NONE)
12517 /* !!! PROBLEM: THIS REDRAWS THE PLAYFIELD _AFTER_ THE SCAN, BUT TILES
12518 !!! MAY HAVE CHANGED AFTER BEING DRAWN DURING PLAYFIELD SCAN !!! */
12520 if (GfxRedraw[x][y] & GFX_REDRAW_TILE)
12521 DrawLevelField(x, y);
12523 if (GfxRedraw[x][y] & GFX_REDRAW_TILE_CRUMBLED)
12524 DrawLevelFieldCrumbled(x, y);
12526 if (GfxRedraw[x][y] & GFX_REDRAW_TILE_CRUMBLED_NEIGHBOURS)
12527 DrawLevelFieldCrumbledNeighbours(x, y);
12529 if (GfxRedraw[x][y] & GFX_REDRAW_TILE_TWINKLED)
12530 DrawTwinkleOnField(x, y);
12533 GfxRedraw[x][y] = GFX_REDRAW_NONE;
12538 PlayAllPlayersSound();
12540 for (i = 0; i < MAX_PLAYERS; i++)
12542 struct PlayerInfo *player = &stored_player[i];
12544 if (player->show_envelope != 0 && (!player->active ||
12545 player->MovPos == 0))
12547 ShowEnvelope(player->show_envelope - EL_ENVELOPE_1);
12549 player->show_envelope = 0;
12553 // use random number generator in every frame to make it less predictable
12554 if (game.engine_version >= VERSION_IDENT(3,1,1,0))
12557 mouse_action_last = mouse_action;
12560 static boolean AllPlayersInSight(struct PlayerInfo *player, int x, int y)
12562 int min_x = x, min_y = y, max_x = x, max_y = y;
12563 int scr_fieldx = getScreenFieldSizeX();
12564 int scr_fieldy = getScreenFieldSizeY();
12567 for (i = 0; i < MAX_PLAYERS; i++)
12569 int jx = stored_player[i].jx, jy = stored_player[i].jy;
12571 if (!stored_player[i].active || &stored_player[i] == player)
12574 min_x = MIN(min_x, jx);
12575 min_y = MIN(min_y, jy);
12576 max_x = MAX(max_x, jx);
12577 max_y = MAX(max_y, jy);
12580 return (max_x - min_x < scr_fieldx && max_y - min_y < scr_fieldy);
12583 static boolean AllPlayersInVisibleScreen(void)
12587 for (i = 0; i < MAX_PLAYERS; i++)
12589 int jx = stored_player[i].jx, jy = stored_player[i].jy;
12591 if (!stored_player[i].active)
12594 if (!IN_VIS_FIELD(SCREENX(jx), SCREENY(jy)))
12601 void ScrollLevel(int dx, int dy)
12603 int scroll_offset = 2 * TILEX_VAR;
12606 BlitBitmap(drawto_field, drawto_field,
12607 FX + TILEX_VAR * (dx == -1) - scroll_offset,
12608 FY + TILEY_VAR * (dy == -1) - scroll_offset,
12609 SXSIZE - TILEX_VAR * (dx != 0) + 2 * scroll_offset,
12610 SYSIZE - TILEY_VAR * (dy != 0) + 2 * scroll_offset,
12611 FX + TILEX_VAR * (dx == 1) - scroll_offset,
12612 FY + TILEY_VAR * (dy == 1) - scroll_offset);
12616 x = (dx == 1 ? BX1 : BX2);
12617 for (y = BY1; y <= BY2; y++)
12618 DrawScreenField(x, y);
12623 y = (dy == 1 ? BY1 : BY2);
12624 for (x = BX1; x <= BX2; x++)
12625 DrawScreenField(x, y);
12628 redraw_mask |= REDRAW_FIELD;
12631 static boolean canFallDown(struct PlayerInfo *player)
12633 int jx = player->jx, jy = player->jy;
12635 return (IN_LEV_FIELD(jx, jy + 1) &&
12636 (IS_FREE(jx, jy + 1) ||
12637 (Tile[jx][jy + 1] == EL_ACID && player->can_fall_into_acid)) &&
12638 IS_WALKABLE_FROM(Tile[jx][jy], MV_DOWN) &&
12639 !IS_WALKABLE_INSIDE(Tile[jx][jy]));
12642 static boolean canPassField(int x, int y, int move_dir)
12644 int opposite_dir = MV_DIR_OPPOSITE(move_dir);
12645 int dx = (move_dir & MV_LEFT ? -1 : move_dir & MV_RIGHT ? +1 : 0);
12646 int dy = (move_dir & MV_UP ? -1 : move_dir & MV_DOWN ? +1 : 0);
12647 int nextx = x + dx;
12648 int nexty = y + dy;
12649 int element = Tile[x][y];
12651 return (IS_PASSABLE_FROM(element, opposite_dir) &&
12652 !CAN_MOVE(element) &&
12653 IN_LEV_FIELD(nextx, nexty) && !IS_PLAYER(nextx, nexty) &&
12654 IS_WALKABLE_FROM(Tile[nextx][nexty], move_dir) &&
12655 (level.can_pass_to_walkable || IS_FREE(nextx, nexty)));
12658 static boolean canMoveToValidFieldWithGravity(int x, int y, int move_dir)
12660 int opposite_dir = MV_DIR_OPPOSITE(move_dir);
12661 int dx = (move_dir & MV_LEFT ? -1 : move_dir & MV_RIGHT ? +1 : 0);
12662 int dy = (move_dir & MV_UP ? -1 : move_dir & MV_DOWN ? +1 : 0);
12666 return (IN_LEV_FIELD(newx, newy) && !IS_FREE_OR_PLAYER(newx, newy) &&
12667 IS_GRAVITY_REACHABLE(Tile[newx][newy]) &&
12668 (IS_DIGGABLE(Tile[newx][newy]) ||
12669 IS_WALKABLE_FROM(Tile[newx][newy], opposite_dir) ||
12670 canPassField(newx, newy, move_dir)));
12673 static void CheckGravityMovement(struct PlayerInfo *player)
12675 if (player->gravity && !player->programmed_action)
12677 int move_dir_horizontal = player->effective_action & MV_HORIZONTAL;
12678 int move_dir_vertical = player->effective_action & MV_VERTICAL;
12679 boolean player_is_snapping = (player->effective_action & JOY_BUTTON_1);
12680 int jx = player->jx, jy = player->jy;
12681 boolean player_is_moving_to_valid_field =
12682 (!player_is_snapping &&
12683 (canMoveToValidFieldWithGravity(jx, jy, move_dir_horizontal) ||
12684 canMoveToValidFieldWithGravity(jx, jy, move_dir_vertical)));
12685 boolean player_can_fall_down = canFallDown(player);
12687 if (player_can_fall_down &&
12688 !player_is_moving_to_valid_field)
12689 player->programmed_action = MV_DOWN;
12693 static void CheckGravityMovementWhenNotMoving(struct PlayerInfo *player)
12695 return CheckGravityMovement(player);
12697 if (player->gravity && !player->programmed_action)
12699 int jx = player->jx, jy = player->jy;
12700 boolean field_under_player_is_free =
12701 (IN_LEV_FIELD(jx, jy + 1) && IS_FREE(jx, jy + 1));
12702 boolean player_is_standing_on_valid_field =
12703 (IS_WALKABLE_INSIDE(Tile[jx][jy]) ||
12704 (IS_WALKABLE(Tile[jx][jy]) &&
12705 !(element_info[Tile[jx][jy]].access_direction & MV_DOWN)));
12707 if (field_under_player_is_free && !player_is_standing_on_valid_field)
12708 player->programmed_action = MV_DOWN;
12713 MovePlayerOneStep()
12714 -----------------------------------------------------------------------------
12715 dx, dy: direction (non-diagonal) to try to move the player to
12716 real_dx, real_dy: direction as read from input device (can be diagonal)
12719 boolean MovePlayerOneStep(struct PlayerInfo *player,
12720 int dx, int dy, int real_dx, int real_dy)
12722 int jx = player->jx, jy = player->jy;
12723 int new_jx = jx + dx, new_jy = jy + dy;
12725 boolean player_can_move = !player->cannot_move;
12727 if (!player->active || (!dx && !dy))
12728 return MP_NO_ACTION;
12730 player->MovDir = (dx < 0 ? MV_LEFT :
12731 dx > 0 ? MV_RIGHT :
12733 dy > 0 ? MV_DOWN : MV_NONE);
12735 if (!IN_LEV_FIELD(new_jx, new_jy))
12736 return MP_NO_ACTION;
12738 if (!player_can_move)
12740 if (player->MovPos == 0)
12742 player->is_moving = FALSE;
12743 player->is_digging = FALSE;
12744 player->is_collecting = FALSE;
12745 player->is_snapping = FALSE;
12746 player->is_pushing = FALSE;
12750 if (!network.enabled && game.centered_player_nr == -1 &&
12751 !AllPlayersInSight(player, new_jx, new_jy))
12752 return MP_NO_ACTION;
12754 can_move = DigField(player, jx, jy, new_jx, new_jy, real_dx,real_dy, DF_DIG);
12755 if (can_move != MP_MOVING)
12758 // check if DigField() has caused relocation of the player
12759 if (player->jx != jx || player->jy != jy)
12760 return MP_NO_ACTION; // <-- !!! CHECK THIS [-> MP_ACTION ?] !!!
12762 StorePlayer[jx][jy] = 0;
12763 player->last_jx = jx;
12764 player->last_jy = jy;
12765 player->jx = new_jx;
12766 player->jy = new_jy;
12767 StorePlayer[new_jx][new_jy] = player->element_nr;
12769 if (player->move_delay_value_next != -1)
12771 player->move_delay_value = player->move_delay_value_next;
12772 player->move_delay_value_next = -1;
12776 (dx > 0 || dy > 0 ? -1 : 1) * (TILEX - TILEX / player->move_delay_value);
12778 player->step_counter++;
12780 PlayerVisit[jx][jy] = FrameCounter;
12782 player->is_moving = TRUE;
12785 // should better be called in MovePlayer(), but this breaks some tapes
12786 ScrollPlayer(player, SCROLL_INIT);
12792 boolean MovePlayer(struct PlayerInfo *player, int dx, int dy)
12794 int jx = player->jx, jy = player->jy;
12795 int old_jx = jx, old_jy = jy;
12796 int moved = MP_NO_ACTION;
12798 if (!player->active)
12803 if (player->MovPos == 0)
12805 player->is_moving = FALSE;
12806 player->is_digging = FALSE;
12807 player->is_collecting = FALSE;
12808 player->is_snapping = FALSE;
12809 player->is_pushing = FALSE;
12815 if (player->move_delay > 0)
12818 player->move_delay = -1; // set to "uninitialized" value
12820 // store if player is automatically moved to next field
12821 player->is_auto_moving = (player->programmed_action != MV_NONE);
12823 // remove the last programmed player action
12824 player->programmed_action = 0;
12826 if (player->MovPos)
12828 // should only happen if pre-1.2 tape recordings are played
12829 // this is only for backward compatibility
12831 int original_move_delay_value = player->move_delay_value;
12834 Debug("game:playing:MovePlayer",
12835 "THIS SHOULD ONLY HAPPEN WITH PRE-1.2 LEVEL TAPES. [%d]",
12839 // scroll remaining steps with finest movement resolution
12840 player->move_delay_value = MOVE_DELAY_NORMAL_SPEED;
12842 while (player->MovPos)
12844 ScrollPlayer(player, SCROLL_GO_ON);
12845 ScrollScreen(NULL, SCROLL_GO_ON);
12847 AdvanceFrameAndPlayerCounters(player->index_nr);
12850 BackToFront_WithFrameDelay(0);
12853 player->move_delay_value = original_move_delay_value;
12856 player->is_active = FALSE;
12858 if (player->last_move_dir & MV_HORIZONTAL)
12860 if (!(moved |= MovePlayerOneStep(player, 0, dy, dx, dy)))
12861 moved |= MovePlayerOneStep(player, dx, 0, dx, dy);
12865 if (!(moved |= MovePlayerOneStep(player, dx, 0, dx, dy)))
12866 moved |= MovePlayerOneStep(player, 0, dy, dx, dy);
12869 if (!moved && !player->is_active)
12871 player->is_moving = FALSE;
12872 player->is_digging = FALSE;
12873 player->is_collecting = FALSE;
12874 player->is_snapping = FALSE;
12875 player->is_pushing = FALSE;
12881 if (moved & MP_MOVING && !ScreenMovPos &&
12882 (player->index_nr == game.centered_player_nr ||
12883 game.centered_player_nr == -1))
12885 int old_scroll_x = scroll_x, old_scroll_y = scroll_y;
12887 if (!IN_VIS_FIELD(SCREENX(jx), SCREENY(jy)))
12889 // actual player has left the screen -- scroll in that direction
12890 if (jx != old_jx) // player has moved horizontally
12891 scroll_x += (jx - old_jx);
12892 else // player has moved vertically
12893 scroll_y += (jy - old_jy);
12897 int offset_raw = game.scroll_delay_value;
12899 if (jx != old_jx) // player has moved horizontally
12901 int offset = MIN(offset_raw, (SCR_FIELDX - 2) / 2);
12902 int offset_x = offset * (player->MovDir == MV_LEFT ? +1 : -1);
12903 int new_scroll_x = jx - MIDPOSX + offset_x;
12905 if ((player->MovDir == MV_LEFT && scroll_x > new_scroll_x) ||
12906 (player->MovDir == MV_RIGHT && scroll_x < new_scroll_x))
12907 scroll_x = new_scroll_x;
12909 // don't scroll over playfield boundaries
12910 scroll_x = MIN(MAX(SBX_Left, scroll_x), SBX_Right);
12912 // don't scroll more than one field at a time
12913 scroll_x = old_scroll_x + SIGN(scroll_x - old_scroll_x);
12915 // don't scroll against the player's moving direction
12916 if ((player->MovDir == MV_LEFT && scroll_x > old_scroll_x) ||
12917 (player->MovDir == MV_RIGHT && scroll_x < old_scroll_x))
12918 scroll_x = old_scroll_x;
12920 else // player has moved vertically
12922 int offset = MIN(offset_raw, (SCR_FIELDY - 2) / 2);
12923 int offset_y = offset * (player->MovDir == MV_UP ? +1 : -1);
12924 int new_scroll_y = jy - MIDPOSY + offset_y;
12926 if ((player->MovDir == MV_UP && scroll_y > new_scroll_y) ||
12927 (player->MovDir == MV_DOWN && scroll_y < new_scroll_y))
12928 scroll_y = new_scroll_y;
12930 // don't scroll over playfield boundaries
12931 scroll_y = MIN(MAX(SBY_Upper, scroll_y), SBY_Lower);
12933 // don't scroll more than one field at a time
12934 scroll_y = old_scroll_y + SIGN(scroll_y - old_scroll_y);
12936 // don't scroll against the player's moving direction
12937 if ((player->MovDir == MV_UP && scroll_y > old_scroll_y) ||
12938 (player->MovDir == MV_DOWN && scroll_y < old_scroll_y))
12939 scroll_y = old_scroll_y;
12943 if (scroll_x != old_scroll_x || scroll_y != old_scroll_y)
12945 if (!network.enabled && game.centered_player_nr == -1 &&
12946 !AllPlayersInVisibleScreen())
12948 scroll_x = old_scroll_x;
12949 scroll_y = old_scroll_y;
12953 ScrollScreen(player, SCROLL_INIT);
12954 ScrollLevel(old_scroll_x - scroll_x, old_scroll_y - scroll_y);
12959 player->StepFrame = 0;
12961 if (moved & MP_MOVING)
12963 if (old_jx != jx && old_jy == jy)
12964 player->MovDir = (old_jx < jx ? MV_RIGHT : MV_LEFT);
12965 else if (old_jx == jx && old_jy != jy)
12966 player->MovDir = (old_jy < jy ? MV_DOWN : MV_UP);
12968 TEST_DrawLevelField(jx, jy); // for "crumbled sand"
12970 player->last_move_dir = player->MovDir;
12971 player->is_moving = TRUE;
12972 player->is_snapping = FALSE;
12973 player->is_switching = FALSE;
12974 player->is_dropping = FALSE;
12975 player->is_dropping_pressed = FALSE;
12976 player->drop_pressed_delay = 0;
12979 // should better be called here than above, but this breaks some tapes
12980 ScrollPlayer(player, SCROLL_INIT);
12985 CheckGravityMovementWhenNotMoving(player);
12987 player->is_moving = FALSE;
12989 /* at this point, the player is allowed to move, but cannot move right now
12990 (e.g. because of something blocking the way) -- ensure that the player
12991 is also allowed to move in the next frame (in old versions before 3.1.1,
12992 the player was forced to wait again for eight frames before next try) */
12994 if (game.engine_version >= VERSION_IDENT(3,1,1,0))
12995 player->move_delay = 0; // allow direct movement in the next frame
12998 if (player->move_delay == -1) // not yet initialized by DigField()
12999 player->move_delay = player->move_delay_value;
13001 if (game.engine_version < VERSION_IDENT(3,0,7,0))
13003 TestIfPlayerTouchesBadThing(jx, jy);
13004 TestIfPlayerTouchesCustomElement(jx, jy);
13007 if (!player->active)
13008 RemovePlayer(player);
13013 void ScrollPlayer(struct PlayerInfo *player, int mode)
13015 int jx = player->jx, jy = player->jy;
13016 int last_jx = player->last_jx, last_jy = player->last_jy;
13017 int move_stepsize = TILEX / player->move_delay_value;
13019 if (!player->active)
13022 if (player->MovPos == 0 && mode == SCROLL_GO_ON) // player not moving
13025 if (mode == SCROLL_INIT)
13027 player->actual_frame_counter = FrameCounter;
13028 player->GfxPos = move_stepsize * (player->MovPos / move_stepsize);
13030 if ((player->block_last_field || player->block_delay_adjustment > 0) &&
13031 Tile[last_jx][last_jy] == EL_EMPTY)
13033 int last_field_block_delay = 0; // start with no blocking at all
13034 int block_delay_adjustment = player->block_delay_adjustment;
13036 // if player blocks last field, add delay for exactly one move
13037 if (player->block_last_field)
13039 last_field_block_delay += player->move_delay_value;
13041 // when blocking enabled, prevent moving up despite gravity
13042 if (player->gravity && player->MovDir == MV_UP)
13043 block_delay_adjustment = -1;
13046 // add block delay adjustment (also possible when not blocking)
13047 last_field_block_delay += block_delay_adjustment;
13049 Tile[last_jx][last_jy] = EL_PLAYER_IS_LEAVING;
13050 MovDelay[last_jx][last_jy] = last_field_block_delay + 1;
13053 if (player->MovPos != 0) // player has not yet reached destination
13056 else if (!FrameReached(&player->actual_frame_counter, 1))
13059 if (player->MovPos != 0)
13061 player->MovPos += (player->MovPos > 0 ? -1 : 1) * move_stepsize;
13062 player->GfxPos = move_stepsize * (player->MovPos / move_stepsize);
13064 // before DrawPlayer() to draw correct player graphic for this case
13065 if (player->MovPos == 0)
13066 CheckGravityMovement(player);
13069 if (player->MovPos == 0) // player reached destination field
13071 if (player->move_delay_reset_counter > 0)
13073 player->move_delay_reset_counter--;
13075 if (player->move_delay_reset_counter == 0)
13077 // continue with normal speed after quickly moving through gate
13078 HALVE_PLAYER_SPEED(player);
13080 // be able to make the next move without delay
13081 player->move_delay = 0;
13085 player->last_jx = jx;
13086 player->last_jy = jy;
13088 if (Tile[jx][jy] == EL_EXIT_OPEN ||
13089 Tile[jx][jy] == EL_EM_EXIT_OPEN ||
13090 Tile[jx][jy] == EL_EM_EXIT_OPENING ||
13091 Tile[jx][jy] == EL_STEEL_EXIT_OPEN ||
13092 Tile[jx][jy] == EL_EM_STEEL_EXIT_OPEN ||
13093 Tile[jx][jy] == EL_EM_STEEL_EXIT_OPENING ||
13094 Tile[jx][jy] == EL_SP_EXIT_OPEN ||
13095 Tile[jx][jy] == EL_SP_EXIT_OPENING) // <-- special case
13097 ExitPlayer(player);
13099 if (game.players_still_needed == 0 &&
13100 (game.friends_still_needed == 0 ||
13101 IS_SP_ELEMENT(Tile[jx][jy])))
13105 // this breaks one level: "machine", level 000
13107 int move_direction = player->MovDir;
13108 int enter_side = MV_DIR_OPPOSITE(move_direction);
13109 int leave_side = move_direction;
13110 int old_jx = last_jx;
13111 int old_jy = last_jy;
13112 int old_element = Tile[old_jx][old_jy];
13113 int new_element = Tile[jx][jy];
13115 if (IS_CUSTOM_ELEMENT(old_element))
13116 CheckElementChangeByPlayer(old_jx, old_jy, old_element,
13118 player->index_bit, leave_side);
13120 CheckTriggeredElementChangeByPlayer(old_jx, old_jy, old_element,
13121 CE_PLAYER_LEAVES_X,
13122 player->index_bit, leave_side);
13124 if (IS_CUSTOM_ELEMENT(new_element))
13125 CheckElementChangeByPlayer(jx, jy, new_element, CE_ENTERED_BY_PLAYER,
13126 player->index_bit, enter_side);
13128 CheckTriggeredElementChangeByPlayer(jx, jy, new_element,
13129 CE_PLAYER_ENTERS_X,
13130 player->index_bit, enter_side);
13132 CheckTriggeredElementChangeBySide(jx, jy, player->initial_element,
13133 CE_MOVE_OF_X, move_direction);
13136 if (game.engine_version >= VERSION_IDENT(3,0,7,0))
13138 TestIfPlayerTouchesBadThing(jx, jy);
13139 TestIfPlayerTouchesCustomElement(jx, jy);
13141 /* needed because pushed element has not yet reached its destination,
13142 so it would trigger a change event at its previous field location */
13143 if (!player->is_pushing)
13144 TestIfElementTouchesCustomElement(jx, jy); // for empty space
13146 if (level.finish_dig_collect &&
13147 (player->is_digging || player->is_collecting))
13149 int last_element = player->last_removed_element;
13150 int move_direction = player->MovDir;
13151 int enter_side = MV_DIR_OPPOSITE(move_direction);
13152 int change_event = (player->is_digging ? CE_PLAYER_DIGS_X :
13153 CE_PLAYER_COLLECTS_X);
13155 CheckTriggeredElementChangeByPlayer(jx, jy, last_element, change_event,
13156 player->index_bit, enter_side);
13158 player->last_removed_element = EL_UNDEFINED;
13161 if (!player->active)
13162 RemovePlayer(player);
13165 if (level.use_step_counter)
13175 if (TimeLeft <= 10 && setup.time_limit && !game.LevelSolved)
13176 PlaySound(SND_GAME_RUNNING_OUT_OF_TIME);
13178 game_panel_controls[GAME_PANEL_TIME].value = TimeLeft;
13180 DisplayGameControlValues();
13182 if (!TimeLeft && setup.time_limit && !game.LevelSolved)
13183 for (i = 0; i < MAX_PLAYERS; i++)
13184 KillPlayer(&stored_player[i]);
13186 else if (game.no_time_limit && !game.all_players_gone)
13188 game_panel_controls[GAME_PANEL_TIME].value = TimePlayed;
13190 DisplayGameControlValues();
13194 if (tape.single_step && tape.recording && !tape.pausing &&
13195 !player->programmed_action)
13196 TapeTogglePause(TAPE_TOGGLE_AUTOMATIC);
13198 if (!player->programmed_action)
13199 CheckSaveEngineSnapshot(player);
13203 void ScrollScreen(struct PlayerInfo *player, int mode)
13205 static unsigned int screen_frame_counter = 0;
13207 if (mode == SCROLL_INIT)
13209 // set scrolling step size according to actual player's moving speed
13210 ScrollStepSize = TILEX / player->move_delay_value;
13212 screen_frame_counter = FrameCounter;
13213 ScreenMovDir = player->MovDir;
13214 ScreenMovPos = player->MovPos;
13215 ScreenGfxPos = ScrollStepSize * (ScreenMovPos / ScrollStepSize);
13218 else if (!FrameReached(&screen_frame_counter, 1))
13223 ScreenMovPos += (ScreenMovPos > 0 ? -1 : 1) * ScrollStepSize;
13224 ScreenGfxPos = ScrollStepSize * (ScreenMovPos / ScrollStepSize);
13225 redraw_mask |= REDRAW_FIELD;
13228 ScreenMovDir = MV_NONE;
13231 void TestIfPlayerTouchesCustomElement(int x, int y)
13233 static int xy[4][2] =
13240 static int trigger_sides[4][2] =
13242 // center side border side
13243 { CH_SIDE_TOP, CH_SIDE_BOTTOM }, // check top
13244 { CH_SIDE_LEFT, CH_SIDE_RIGHT }, // check left
13245 { CH_SIDE_RIGHT, CH_SIDE_LEFT }, // check right
13246 { CH_SIDE_BOTTOM, CH_SIDE_TOP } // check bottom
13248 static int touch_dir[4] =
13250 MV_LEFT | MV_RIGHT,
13255 int center_element = Tile[x][y]; // should always be non-moving!
13258 for (i = 0; i < NUM_DIRECTIONS; i++)
13260 int xx = x + xy[i][0];
13261 int yy = y + xy[i][1];
13262 int center_side = trigger_sides[i][0];
13263 int border_side = trigger_sides[i][1];
13264 int border_element;
13266 if (!IN_LEV_FIELD(xx, yy))
13269 if (IS_PLAYER(x, y)) // player found at center element
13271 struct PlayerInfo *player = PLAYERINFO(x, y);
13273 if (game.engine_version < VERSION_IDENT(3,0,7,0))
13274 border_element = Tile[xx][yy]; // may be moving!
13275 else if (!IS_MOVING(xx, yy) && !IS_BLOCKED(xx, yy))
13276 border_element = Tile[xx][yy];
13277 else if (MovDir[xx][yy] & touch_dir[i]) // elements are touching
13278 border_element = MovingOrBlocked2Element(xx, yy);
13280 continue; // center and border element do not touch
13282 CheckElementChangeByPlayer(xx, yy, border_element, CE_TOUCHED_BY_PLAYER,
13283 player->index_bit, border_side);
13284 CheckTriggeredElementChangeByPlayer(xx, yy, border_element,
13285 CE_PLAYER_TOUCHES_X,
13286 player->index_bit, border_side);
13289 /* use player element that is initially defined in the level playfield,
13290 not the player element that corresponds to the runtime player number
13291 (example: a level that contains EL_PLAYER_3 as the only player would
13292 incorrectly give EL_PLAYER_1 for "player->element_nr") */
13293 int player_element = PLAYERINFO(x, y)->initial_element;
13295 CheckElementChangeBySide(xx, yy, border_element, player_element,
13296 CE_TOUCHING_X, border_side);
13299 else if (IS_PLAYER(xx, yy)) // player found at border element
13301 struct PlayerInfo *player = PLAYERINFO(xx, yy);
13303 if (game.engine_version >= VERSION_IDENT(3,0,7,0))
13305 if (player->MovPos != 0 && !(player->MovDir & touch_dir[i]))
13306 continue; // center and border element do not touch
13309 CheckElementChangeByPlayer(x, y, center_element, CE_TOUCHED_BY_PLAYER,
13310 player->index_bit, center_side);
13311 CheckTriggeredElementChangeByPlayer(x, y, center_element,
13312 CE_PLAYER_TOUCHES_X,
13313 player->index_bit, center_side);
13316 /* use player element that is initially defined in the level playfield,
13317 not the player element that corresponds to the runtime player number
13318 (example: a level that contains EL_PLAYER_3 as the only player would
13319 incorrectly give EL_PLAYER_1 for "player->element_nr") */
13320 int player_element = PLAYERINFO(xx, yy)->initial_element;
13322 CheckElementChangeBySide(x, y, center_element, player_element,
13323 CE_TOUCHING_X, center_side);
13331 void TestIfElementTouchesCustomElement(int x, int y)
13333 static int xy[4][2] =
13340 static int trigger_sides[4][2] =
13342 // center side border side
13343 { CH_SIDE_TOP, CH_SIDE_BOTTOM }, // check top
13344 { CH_SIDE_LEFT, CH_SIDE_RIGHT }, // check left
13345 { CH_SIDE_RIGHT, CH_SIDE_LEFT }, // check right
13346 { CH_SIDE_BOTTOM, CH_SIDE_TOP } // check bottom
13348 static int touch_dir[4] =
13350 MV_LEFT | MV_RIGHT,
13355 boolean change_center_element = FALSE;
13356 int center_element = Tile[x][y]; // should always be non-moving!
13357 int border_element_old[NUM_DIRECTIONS];
13360 for (i = 0; i < NUM_DIRECTIONS; i++)
13362 int xx = x + xy[i][0];
13363 int yy = y + xy[i][1];
13364 int border_element;
13366 border_element_old[i] = -1;
13368 if (!IN_LEV_FIELD(xx, yy))
13371 if (game.engine_version < VERSION_IDENT(3,0,7,0))
13372 border_element = Tile[xx][yy]; // may be moving!
13373 else if (!IS_MOVING(xx, yy) && !IS_BLOCKED(xx, yy))
13374 border_element = Tile[xx][yy];
13375 else if (MovDir[xx][yy] & touch_dir[i]) // elements are touching
13376 border_element = MovingOrBlocked2Element(xx, yy);
13378 continue; // center and border element do not touch
13380 border_element_old[i] = border_element;
13383 for (i = 0; i < NUM_DIRECTIONS; i++)
13385 int xx = x + xy[i][0];
13386 int yy = y + xy[i][1];
13387 int center_side = trigger_sides[i][0];
13388 int border_element = border_element_old[i];
13390 if (border_element == -1)
13393 // check for change of border element
13394 CheckElementChangeBySide(xx, yy, border_element, center_element,
13395 CE_TOUCHING_X, center_side);
13397 // (center element cannot be player, so we dont have to check this here)
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_side = trigger_sides[i][1];
13405 int border_element = border_element_old[i];
13407 if (border_element == -1)
13410 // check for change of center element (but change it only once)
13411 if (!change_center_element)
13412 change_center_element =
13413 CheckElementChangeBySide(x, y, center_element, border_element,
13414 CE_TOUCHING_X, border_side);
13416 if (IS_PLAYER(xx, yy))
13418 /* use player element that is initially defined in the level playfield,
13419 not the player element that corresponds to the runtime player number
13420 (example: a level that contains EL_PLAYER_3 as the only player would
13421 incorrectly give EL_PLAYER_1 for "player->element_nr") */
13422 int player_element = PLAYERINFO(xx, yy)->initial_element;
13424 CheckElementChangeBySide(x, y, center_element, player_element,
13425 CE_TOUCHING_X, border_side);
13430 void TestIfElementHitsCustomElement(int x, int y, int direction)
13432 int dx = (direction == MV_LEFT ? -1 : direction == MV_RIGHT ? +1 : 0);
13433 int dy = (direction == MV_UP ? -1 : direction == MV_DOWN ? +1 : 0);
13434 int hitx = x + dx, hity = y + dy;
13435 int hitting_element = Tile[x][y];
13436 int touched_element;
13438 if (IN_LEV_FIELD(hitx, hity) && IS_FREE(hitx, hity))
13441 touched_element = (IN_LEV_FIELD(hitx, hity) ?
13442 MovingOrBlocked2Element(hitx, hity) : EL_STEELWALL);
13444 if (IN_LEV_FIELD(hitx, hity))
13446 int opposite_direction = MV_DIR_OPPOSITE(direction);
13447 int hitting_side = direction;
13448 int touched_side = opposite_direction;
13449 boolean object_hit = (!IS_MOVING(hitx, hity) ||
13450 MovDir[hitx][hity] != direction ||
13451 ABS(MovPos[hitx][hity]) <= TILEY / 2);
13457 CheckElementChangeBySide(x, y, hitting_element, touched_element,
13458 CE_HITTING_X, touched_side);
13460 CheckElementChangeBySide(hitx, hity, touched_element, hitting_element,
13461 CE_HIT_BY_X, hitting_side);
13463 CheckElementChangeBySide(hitx, hity, touched_element, hitting_element,
13464 CE_HIT_BY_SOMETHING, opposite_direction);
13466 if (IS_PLAYER(hitx, hity))
13468 /* use player element that is initially defined in the level playfield,
13469 not the player element that corresponds to the runtime player number
13470 (example: a level that contains EL_PLAYER_3 as the only player would
13471 incorrectly give EL_PLAYER_1 for "player->element_nr") */
13472 int player_element = PLAYERINFO(hitx, hity)->initial_element;
13474 CheckElementChangeBySide(x, y, hitting_element, player_element,
13475 CE_HITTING_X, touched_side);
13480 // "hitting something" is also true when hitting the playfield border
13481 CheckElementChangeBySide(x, y, hitting_element, touched_element,
13482 CE_HITTING_SOMETHING, direction);
13485 void TestIfGoodThingHitsBadThing(int good_x, int good_y, int good_move_dir)
13487 int i, kill_x = -1, kill_y = -1;
13489 int bad_element = -1;
13490 static int test_xy[4][2] =
13497 static int test_dir[4] =
13505 for (i = 0; i < NUM_DIRECTIONS; i++)
13507 int test_x, test_y, test_move_dir, test_element;
13509 test_x = good_x + test_xy[i][0];
13510 test_y = good_y + test_xy[i][1];
13512 if (!IN_LEV_FIELD(test_x, test_y))
13516 (IS_MOVING(test_x, test_y) ? MovDir[test_x][test_y] : MV_NONE);
13518 test_element = MovingOrBlocked2ElementIfNotLeaving(test_x, test_y);
13520 /* 1st case: good thing is moving towards DONT_RUN_INTO style bad thing;
13521 2nd case: DONT_TOUCH style bad thing does not move away from good thing
13523 if ((DONT_RUN_INTO(test_element) && good_move_dir == test_dir[i]) ||
13524 (DONT_TOUCH(test_element) && test_move_dir != test_dir[i]))
13528 bad_element = test_element;
13534 if (kill_x != -1 || kill_y != -1)
13536 if (IS_PLAYER(good_x, good_y))
13538 struct PlayerInfo *player = PLAYERINFO(good_x, good_y);
13540 if (player->shield_deadly_time_left > 0 &&
13541 !IS_INDESTRUCTIBLE(bad_element))
13542 Bang(kill_x, kill_y);
13543 else if (!PLAYER_ENEMY_PROTECTED(good_x, good_y))
13544 KillPlayer(player);
13547 Bang(good_x, good_y);
13551 void TestIfBadThingHitsGoodThing(int bad_x, int bad_y, int bad_move_dir)
13553 int i, kill_x = -1, kill_y = -1;
13554 int bad_element = Tile[bad_x][bad_y];
13555 static int test_xy[4][2] =
13562 static int touch_dir[4] =
13564 MV_LEFT | MV_RIGHT,
13569 static int test_dir[4] =
13577 if (bad_element == EL_EXPLOSION) // skip just exploding bad things
13580 for (i = 0; i < NUM_DIRECTIONS; i++)
13582 int test_x, test_y, test_move_dir, test_element;
13584 test_x = bad_x + test_xy[i][0];
13585 test_y = bad_y + test_xy[i][1];
13587 if (!IN_LEV_FIELD(test_x, test_y))
13591 (IS_MOVING(test_x, test_y) ? MovDir[test_x][test_y] : MV_NONE);
13593 test_element = Tile[test_x][test_y];
13595 /* 1st case: good thing is moving towards DONT_RUN_INTO style bad thing;
13596 2nd case: DONT_TOUCH style bad thing does not move away from good thing
13598 if ((DONT_RUN_INTO(bad_element) && bad_move_dir == test_dir[i]) ||
13599 (DONT_TOUCH(bad_element) && test_move_dir != test_dir[i]))
13601 // good thing is player or penguin that does not move away
13602 if (IS_PLAYER(test_x, test_y))
13604 struct PlayerInfo *player = PLAYERINFO(test_x, test_y);
13606 if (bad_element == EL_ROBOT && player->is_moving)
13607 continue; // robot does not kill player if he is moving
13609 if (game.engine_version >= VERSION_IDENT(3,0,7,0))
13611 if (player->MovPos != 0 && !(player->MovDir & touch_dir[i]))
13612 continue; // center and border element do not touch
13620 else if (test_element == EL_PENGUIN)
13630 if (kill_x != -1 || kill_y != -1)
13632 if (IS_PLAYER(kill_x, kill_y))
13634 struct PlayerInfo *player = PLAYERINFO(kill_x, kill_y);
13636 if (player->shield_deadly_time_left > 0 &&
13637 !IS_INDESTRUCTIBLE(bad_element))
13638 Bang(bad_x, bad_y);
13639 else if (!PLAYER_ENEMY_PROTECTED(kill_x, kill_y))
13640 KillPlayer(player);
13643 Bang(kill_x, kill_y);
13647 void TestIfGoodThingGetsHitByBadThing(int bad_x, int bad_y, int bad_move_dir)
13649 int bad_element = Tile[bad_x][bad_y];
13650 int dx = (bad_move_dir == MV_LEFT ? -1 : bad_move_dir == MV_RIGHT ? +1 : 0);
13651 int dy = (bad_move_dir == MV_UP ? -1 : bad_move_dir == MV_DOWN ? +1 : 0);
13652 int test_x = bad_x + dx, test_y = bad_y + dy;
13653 int test_move_dir, test_element;
13654 int kill_x = -1, kill_y = -1;
13656 if (!IN_LEV_FIELD(test_x, test_y))
13660 (IS_MOVING(test_x, test_y) ? MovDir[test_x][test_y] : MV_NONE);
13662 test_element = Tile[test_x][test_y];
13664 if (test_move_dir != bad_move_dir)
13666 // good thing can be player or penguin that does not move away
13667 if (IS_PLAYER(test_x, test_y))
13669 struct PlayerInfo *player = PLAYERINFO(test_x, test_y);
13671 /* (note: in comparison to DONT_RUN_TO and DONT_TOUCH, also handle the
13672 player as being hit when he is moving towards the bad thing, because
13673 the "get hit by" condition would be lost after the player stops) */
13674 if (player->MovPos != 0 && player->MovDir == bad_move_dir)
13675 return; // player moves away from bad thing
13680 else if (test_element == EL_PENGUIN)
13687 if (kill_x != -1 || kill_y != -1)
13689 if (IS_PLAYER(kill_x, kill_y))
13691 struct PlayerInfo *player = PLAYERINFO(kill_x, kill_y);
13693 if (player->shield_deadly_time_left > 0 &&
13694 !IS_INDESTRUCTIBLE(bad_element))
13695 Bang(bad_x, bad_y);
13696 else if (!PLAYER_ENEMY_PROTECTED(kill_x, kill_y))
13697 KillPlayer(player);
13700 Bang(kill_x, kill_y);
13704 void TestIfPlayerTouchesBadThing(int x, int y)
13706 TestIfGoodThingHitsBadThing(x, y, MV_NONE);
13709 void TestIfPlayerRunsIntoBadThing(int x, int y, int move_dir)
13711 TestIfGoodThingHitsBadThing(x, y, move_dir);
13714 void TestIfBadThingTouchesPlayer(int x, int y)
13716 TestIfBadThingHitsGoodThing(x, y, MV_NONE);
13719 void TestIfBadThingRunsIntoPlayer(int x, int y, int move_dir)
13721 TestIfBadThingHitsGoodThing(x, y, move_dir);
13724 void TestIfFriendTouchesBadThing(int x, int y)
13726 TestIfGoodThingHitsBadThing(x, y, MV_NONE);
13729 void TestIfBadThingTouchesFriend(int x, int y)
13731 TestIfBadThingHitsGoodThing(x, y, MV_NONE);
13734 void TestIfBadThingTouchesOtherBadThing(int bad_x, int bad_y)
13736 int i, kill_x = bad_x, kill_y = bad_y;
13737 static int xy[4][2] =
13745 for (i = 0; i < NUM_DIRECTIONS; i++)
13749 x = bad_x + xy[i][0];
13750 y = bad_y + xy[i][1];
13751 if (!IN_LEV_FIELD(x, y))
13754 element = Tile[x][y];
13755 if (IS_AMOEBOID(element) || element == EL_GAME_OF_LIFE ||
13756 element == EL_AMOEBA_GROWING || element == EL_AMOEBA_DROP)
13764 if (kill_x != bad_x || kill_y != bad_y)
13765 Bang(bad_x, bad_y);
13768 void KillPlayer(struct PlayerInfo *player)
13770 int jx = player->jx, jy = player->jy;
13772 if (!player->active)
13776 Debug("game:playing:KillPlayer",
13777 "0: killed == %d, active == %d, reanimated == %d",
13778 player->killed, player->active, player->reanimated);
13781 /* the following code was introduced to prevent an infinite loop when calling
13783 -> CheckTriggeredElementChangeExt()
13784 -> ExecuteCustomElementAction()
13786 -> (infinitely repeating the above sequence of function calls)
13787 which occurs when killing the player while having a CE with the setting
13788 "kill player X when explosion of <player X>"; the solution using a new
13789 field "player->killed" was chosen for backwards compatibility, although
13790 clever use of the fields "player->active" etc. would probably also work */
13792 if (player->killed)
13796 player->killed = TRUE;
13798 // remove accessible field at the player's position
13799 Tile[jx][jy] = EL_EMPTY;
13801 // deactivate shield (else Bang()/Explode() would not work right)
13802 player->shield_normal_time_left = 0;
13803 player->shield_deadly_time_left = 0;
13806 Debug("game:playing:KillPlayer",
13807 "1: killed == %d, active == %d, reanimated == %d",
13808 player->killed, player->active, player->reanimated);
13814 Debug("game:playing:KillPlayer",
13815 "2: killed == %d, active == %d, reanimated == %d",
13816 player->killed, player->active, player->reanimated);
13819 if (player->reanimated) // killed player may have been reanimated
13820 player->killed = player->reanimated = FALSE;
13822 BuryPlayer(player);
13825 static void KillPlayerUnlessEnemyProtected(int x, int y)
13827 if (!PLAYER_ENEMY_PROTECTED(x, y))
13828 KillPlayer(PLAYERINFO(x, y));
13831 static void KillPlayerUnlessExplosionProtected(int x, int y)
13833 if (!PLAYER_EXPLOSION_PROTECTED(x, y))
13834 KillPlayer(PLAYERINFO(x, y));
13837 void BuryPlayer(struct PlayerInfo *player)
13839 int jx = player->jx, jy = player->jy;
13841 if (!player->active)
13844 PlayLevelSoundElementAction(jx, jy, player->artwork_element, ACTION_DYING);
13845 PlayLevelSound(jx, jy, SND_GAME_LOSING);
13847 RemovePlayer(player);
13849 player->buried = TRUE;
13851 if (game.all_players_gone)
13852 game.GameOver = TRUE;
13855 void RemovePlayer(struct PlayerInfo *player)
13857 int jx = player->jx, jy = player->jy;
13858 int i, found = FALSE;
13860 player->present = FALSE;
13861 player->active = FALSE;
13863 // required for some CE actions (even if the player is not active anymore)
13864 player->MovPos = 0;
13866 if (!ExplodeField[jx][jy])
13867 StorePlayer[jx][jy] = 0;
13869 if (player->is_moving)
13870 TEST_DrawLevelField(player->last_jx, player->last_jy);
13872 for (i = 0; i < MAX_PLAYERS; i++)
13873 if (stored_player[i].active)
13878 game.all_players_gone = TRUE;
13879 game.GameOver = TRUE;
13882 game.exit_x = game.robot_wheel_x = jx;
13883 game.exit_y = game.robot_wheel_y = jy;
13886 void ExitPlayer(struct PlayerInfo *player)
13888 DrawPlayer(player); // needed here only to cleanup last field
13889 RemovePlayer(player);
13891 if (game.players_still_needed > 0)
13892 game.players_still_needed--;
13895 static void SetFieldForSnapping(int x, int y, int element, int direction,
13896 int player_index_bit)
13898 struct ElementInfo *ei = &element_info[element];
13899 int direction_bit = MV_DIR_TO_BIT(direction);
13900 int graphic_snapping = ei->direction_graphic[ACTION_SNAPPING][direction_bit];
13901 int action = (graphic_snapping != IMG_EMPTY_SPACE ? ACTION_SNAPPING :
13902 IS_DIGGABLE(element) ? ACTION_DIGGING : ACTION_COLLECTING);
13904 Tile[x][y] = EL_ELEMENT_SNAPPING;
13905 MovDelay[x][y] = MOVE_DELAY_NORMAL_SPEED + 1 - 1;
13906 MovDir[x][y] = direction;
13907 Store[x][y] = element;
13908 Store2[x][y] = player_index_bit;
13910 ResetGfxAnimation(x, y);
13912 GfxElement[x][y] = element;
13913 GfxAction[x][y] = action;
13914 GfxDir[x][y] = direction;
13915 GfxFrame[x][y] = -1;
13918 static void TestFieldAfterSnapping(int x, int y, int element, int direction,
13919 int player_index_bit)
13921 TestIfElementTouchesCustomElement(x, y); // for empty space
13923 if (level.finish_dig_collect)
13925 int dig_side = MV_DIR_OPPOSITE(direction);
13927 CheckTriggeredElementChangeByPlayer(x, y, element, CE_PLAYER_SNAPS_X,
13928 player_index_bit, dig_side);
13933 =============================================================================
13934 checkDiagonalPushing()
13935 -----------------------------------------------------------------------------
13936 check if diagonal input device direction results in pushing of object
13937 (by checking if the alternative direction is walkable, diggable, ...)
13938 =============================================================================
13941 static boolean checkDiagonalPushing(struct PlayerInfo *player,
13942 int x, int y, int real_dx, int real_dy)
13944 int jx, jy, dx, dy, xx, yy;
13946 if (real_dx == 0 || real_dy == 0) // no diagonal direction => push
13949 // diagonal direction: check alternative direction
13954 xx = jx + (dx == 0 ? real_dx : 0);
13955 yy = jy + (dy == 0 ? real_dy : 0);
13957 return (!IN_LEV_FIELD(xx, yy) || IS_SOLID_FOR_PUSHING(Tile[xx][yy]));
13961 =============================================================================
13963 -----------------------------------------------------------------------------
13964 x, y: field next to player (non-diagonal) to try to dig to
13965 real_dx, real_dy: direction as read from input device (can be diagonal)
13966 =============================================================================
13969 static int DigField(struct PlayerInfo *player,
13970 int oldx, int oldy, int x, int y,
13971 int real_dx, int real_dy, int mode)
13973 boolean is_player = (IS_PLAYER(oldx, oldy) || mode != DF_DIG);
13974 boolean player_was_pushing = player->is_pushing;
13975 boolean player_can_move = (!player->cannot_move && mode != DF_SNAP);
13976 boolean player_can_move_or_snap = (!player->cannot_move || mode == DF_SNAP);
13977 int jx = oldx, jy = oldy;
13978 int dx = x - jx, dy = y - jy;
13979 int nextx = x + dx, nexty = y + dy;
13980 int move_direction = (dx == -1 ? MV_LEFT :
13981 dx == +1 ? MV_RIGHT :
13983 dy == +1 ? MV_DOWN : MV_NONE);
13984 int opposite_direction = MV_DIR_OPPOSITE(move_direction);
13985 int dig_side = MV_DIR_OPPOSITE(move_direction);
13986 int old_element = Tile[jx][jy];
13987 int element = MovingOrBlocked2ElementIfNotLeaving(x, y);
13990 if (is_player) // function can also be called by EL_PENGUIN
13992 if (player->MovPos == 0)
13994 player->is_digging = FALSE;
13995 player->is_collecting = FALSE;
13998 if (player->MovPos == 0) // last pushing move finished
13999 player->is_pushing = FALSE;
14001 if (mode == DF_NO_PUSH) // player just stopped pushing
14003 player->is_switching = FALSE;
14004 player->push_delay = -1;
14006 return MP_NO_ACTION;
14010 if (IS_TUBE(Back[jx][jy]) && game.engine_version >= VERSION_IDENT(2,2,0,0))
14011 old_element = Back[jx][jy];
14013 // in case of element dropped at player position, check background
14014 else if (Back[jx][jy] != EL_EMPTY &&
14015 game.engine_version >= VERSION_IDENT(2,2,0,0))
14016 old_element = Back[jx][jy];
14018 if (IS_WALKABLE(old_element) && !ACCESS_FROM(old_element, move_direction))
14019 return MP_NO_ACTION; // field has no opening in this direction
14021 if (IS_PASSABLE(old_element) && !ACCESS_FROM(old_element,opposite_direction))
14022 return MP_NO_ACTION; // field has no opening in this direction
14024 if (player_can_move && element == EL_ACID && move_direction == MV_DOWN)
14028 Tile[jx][jy] = player->artwork_element;
14029 InitMovingField(jx, jy, MV_DOWN);
14030 Store[jx][jy] = EL_ACID;
14031 ContinueMoving(jx, jy);
14032 BuryPlayer(player);
14034 return MP_DONT_RUN_INTO;
14037 if (player_can_move && DONT_RUN_INTO(element))
14039 TestIfPlayerRunsIntoBadThing(jx, jy, player->MovDir);
14041 return MP_DONT_RUN_INTO;
14044 if (IS_MOVING(x, y) || IS_PLAYER(x, y))
14045 return MP_NO_ACTION;
14047 collect_count = element_info[element].collect_count_initial;
14049 if (!is_player && !IS_COLLECTIBLE(element)) // penguin cannot collect it
14050 return MP_NO_ACTION;
14052 if (game.engine_version < VERSION_IDENT(2,2,0,0))
14053 player_can_move = player_can_move_or_snap;
14055 if (mode == DF_SNAP && !IS_SNAPPABLE(element) &&
14056 game.engine_version >= VERSION_IDENT(2,2,0,0))
14058 CheckElementChangeByPlayer(x, y, element, CE_SNAPPED_BY_PLAYER,
14059 player->index_bit, dig_side);
14060 CheckTriggeredElementChangeByPlayer(x, y, element, CE_PLAYER_SNAPS_X,
14061 player->index_bit, dig_side);
14063 if (element == EL_DC_LANDMINE)
14066 if (Tile[x][y] != element) // field changed by snapping
14069 return MP_NO_ACTION;
14072 if (player->gravity && is_player && !player->is_auto_moving &&
14073 canFallDown(player) && move_direction != MV_DOWN &&
14074 !canMoveToValidFieldWithGravity(jx, jy, move_direction))
14075 return MP_NO_ACTION; // player cannot walk here due to gravity
14077 if (player_can_move &&
14078 IS_WALKABLE(element) && ACCESS_FROM(element, opposite_direction))
14080 int sound_element = SND_ELEMENT(element);
14081 int sound_action = ACTION_WALKING;
14083 if (IS_RND_GATE(element))
14085 if (!player->key[RND_GATE_NR(element)])
14086 return MP_NO_ACTION;
14088 else if (IS_RND_GATE_GRAY(element))
14090 if (!player->key[RND_GATE_GRAY_NR(element)])
14091 return MP_NO_ACTION;
14093 else if (IS_RND_GATE_GRAY_ACTIVE(element))
14095 if (!player->key[RND_GATE_GRAY_ACTIVE_NR(element)])
14096 return MP_NO_ACTION;
14098 else if (element == EL_EXIT_OPEN ||
14099 element == EL_EM_EXIT_OPEN ||
14100 element == EL_EM_EXIT_OPENING ||
14101 element == EL_STEEL_EXIT_OPEN ||
14102 element == EL_EM_STEEL_EXIT_OPEN ||
14103 element == EL_EM_STEEL_EXIT_OPENING ||
14104 element == EL_SP_EXIT_OPEN ||
14105 element == EL_SP_EXIT_OPENING)
14107 sound_action = ACTION_PASSING; // player is passing exit
14109 else if (element == EL_EMPTY)
14111 sound_action = ACTION_MOVING; // nothing to walk on
14114 // play sound from background or player, whatever is available
14115 if (element_info[sound_element].sound[sound_action] != SND_UNDEFINED)
14116 PlayLevelSoundElementAction(x, y, sound_element, sound_action);
14118 PlayLevelSoundElementAction(x, y, player->artwork_element, sound_action);
14120 else if (player_can_move &&
14121 IS_PASSABLE(element) && canPassField(x, y, move_direction))
14123 if (!ACCESS_FROM(element, opposite_direction))
14124 return MP_NO_ACTION; // field not accessible from this direction
14126 if (CAN_MOVE(element)) // only fixed elements can be passed!
14127 return MP_NO_ACTION;
14129 if (IS_EM_GATE(element))
14131 if (!player->key[EM_GATE_NR(element)])
14132 return MP_NO_ACTION;
14134 else if (IS_EM_GATE_GRAY(element))
14136 if (!player->key[EM_GATE_GRAY_NR(element)])
14137 return MP_NO_ACTION;
14139 else if (IS_EM_GATE_GRAY_ACTIVE(element))
14141 if (!player->key[EM_GATE_GRAY_ACTIVE_NR(element)])
14142 return MP_NO_ACTION;
14144 else if (IS_EMC_GATE(element))
14146 if (!player->key[EMC_GATE_NR(element)])
14147 return MP_NO_ACTION;
14149 else if (IS_EMC_GATE_GRAY(element))
14151 if (!player->key[EMC_GATE_GRAY_NR(element)])
14152 return MP_NO_ACTION;
14154 else if (IS_EMC_GATE_GRAY_ACTIVE(element))
14156 if (!player->key[EMC_GATE_GRAY_ACTIVE_NR(element)])
14157 return MP_NO_ACTION;
14159 else if (element == EL_DC_GATE_WHITE ||
14160 element == EL_DC_GATE_WHITE_GRAY ||
14161 element == EL_DC_GATE_WHITE_GRAY_ACTIVE)
14163 if (player->num_white_keys == 0)
14164 return MP_NO_ACTION;
14166 player->num_white_keys--;
14168 else if (IS_SP_PORT(element))
14170 if (element == EL_SP_GRAVITY_PORT_LEFT ||
14171 element == EL_SP_GRAVITY_PORT_RIGHT ||
14172 element == EL_SP_GRAVITY_PORT_UP ||
14173 element == EL_SP_GRAVITY_PORT_DOWN)
14174 player->gravity = !player->gravity;
14175 else if (element == EL_SP_GRAVITY_ON_PORT_LEFT ||
14176 element == EL_SP_GRAVITY_ON_PORT_RIGHT ||
14177 element == EL_SP_GRAVITY_ON_PORT_UP ||
14178 element == EL_SP_GRAVITY_ON_PORT_DOWN)
14179 player->gravity = TRUE;
14180 else if (element == EL_SP_GRAVITY_OFF_PORT_LEFT ||
14181 element == EL_SP_GRAVITY_OFF_PORT_RIGHT ||
14182 element == EL_SP_GRAVITY_OFF_PORT_UP ||
14183 element == EL_SP_GRAVITY_OFF_PORT_DOWN)
14184 player->gravity = FALSE;
14187 // automatically move to the next field with double speed
14188 player->programmed_action = move_direction;
14190 if (player->move_delay_reset_counter == 0)
14192 player->move_delay_reset_counter = 2; // two double speed steps
14194 DOUBLE_PLAYER_SPEED(player);
14197 PlayLevelSoundAction(x, y, ACTION_PASSING);
14199 else if (player_can_move_or_snap && IS_DIGGABLE(element))
14203 if (mode != DF_SNAP)
14205 GfxElement[x][y] = GFX_ELEMENT(element);
14206 player->is_digging = TRUE;
14209 PlayLevelSoundElementAction(x, y, element, ACTION_DIGGING);
14211 // use old behaviour for old levels (digging)
14212 if (!level.finish_dig_collect)
14214 CheckTriggeredElementChangeByPlayer(x, y, element, CE_PLAYER_DIGS_X,
14215 player->index_bit, dig_side);
14217 // if digging triggered player relocation, finish digging tile
14218 if (mode == DF_DIG && (player->jx != jx || player->jy != jy))
14219 SetFieldForSnapping(x, y, element, move_direction, player->index_bit);
14222 if (mode == DF_SNAP)
14224 if (level.block_snap_field)
14225 SetFieldForSnapping(x, y, element, move_direction, player->index_bit);
14227 TestFieldAfterSnapping(x, y, element, move_direction, player->index_bit);
14229 // use old behaviour for old levels (snapping)
14230 if (!level.finish_dig_collect)
14231 CheckTriggeredElementChangeByPlayer(x, y, element, CE_PLAYER_SNAPS_X,
14232 player->index_bit, dig_side);
14235 else if (player_can_move_or_snap && IS_COLLECTIBLE(element))
14239 if (is_player && mode != DF_SNAP)
14241 GfxElement[x][y] = element;
14242 player->is_collecting = TRUE;
14245 if (element == EL_SPEED_PILL)
14247 player->move_delay_value = MOVE_DELAY_HIGH_SPEED;
14249 else if (element == EL_EXTRA_TIME && level.time > 0)
14251 TimeLeft += level.extra_time;
14253 game_panel_controls[GAME_PANEL_TIME].value = TimeLeft;
14255 DisplayGameControlValues();
14257 else if (element == EL_SHIELD_NORMAL || element == EL_SHIELD_DEADLY)
14259 player->shield_normal_time_left += level.shield_normal_time;
14260 if (element == EL_SHIELD_DEADLY)
14261 player->shield_deadly_time_left += level.shield_deadly_time;
14263 else if (element == EL_DYNAMITE ||
14264 element == EL_EM_DYNAMITE ||
14265 element == EL_SP_DISK_RED)
14267 if (player->inventory_size < MAX_INVENTORY_SIZE)
14268 player->inventory_element[player->inventory_size++] = element;
14270 DrawGameDoorValues();
14272 else if (element == EL_DYNABOMB_INCREASE_NUMBER)
14274 player->dynabomb_count++;
14275 player->dynabombs_left++;
14277 else if (element == EL_DYNABOMB_INCREASE_SIZE)
14279 player->dynabomb_size++;
14281 else if (element == EL_DYNABOMB_INCREASE_POWER)
14283 player->dynabomb_xl = TRUE;
14285 else if (IS_KEY(element))
14287 player->key[KEY_NR(element)] = TRUE;
14289 DrawGameDoorValues();
14291 else if (element == EL_DC_KEY_WHITE)
14293 player->num_white_keys++;
14295 // display white keys?
14296 // DrawGameDoorValues();
14298 else if (IS_ENVELOPE(element))
14300 player->show_envelope = element;
14302 else if (element == EL_EMC_LENSES)
14304 game.lenses_time_left = level.lenses_time * FRAMES_PER_SECOND;
14306 RedrawAllInvisibleElementsForLenses();
14308 else if (element == EL_EMC_MAGNIFIER)
14310 game.magnify_time_left = level.magnify_time * FRAMES_PER_SECOND;
14312 RedrawAllInvisibleElementsForMagnifier();
14314 else if (IS_DROPPABLE(element) ||
14315 IS_THROWABLE(element)) // can be collected and dropped
14319 if (collect_count == 0)
14320 player->inventory_infinite_element = element;
14322 for (i = 0; i < collect_count; i++)
14323 if (player->inventory_size < MAX_INVENTORY_SIZE)
14324 player->inventory_element[player->inventory_size++] = element;
14326 DrawGameDoorValues();
14328 else if (collect_count > 0)
14330 game.gems_still_needed -= collect_count;
14331 if (game.gems_still_needed < 0)
14332 game.gems_still_needed = 0;
14334 game.snapshot.collected_item = TRUE;
14336 game_panel_controls[GAME_PANEL_GEMS].value = game.gems_still_needed;
14338 DisplayGameControlValues();
14341 RaiseScoreElement(element);
14342 PlayLevelSoundElementAction(x, y, element, ACTION_COLLECTING);
14344 // use old behaviour for old levels (collecting)
14345 if (!level.finish_dig_collect && is_player)
14347 CheckTriggeredElementChangeByPlayer(x, y, element, CE_PLAYER_COLLECTS_X,
14348 player->index_bit, dig_side);
14350 // if collecting triggered player relocation, finish collecting tile
14351 if (mode == DF_DIG && (player->jx != jx || player->jy != jy))
14352 SetFieldForSnapping(x, y, element, move_direction, player->index_bit);
14355 if (mode == DF_SNAP)
14357 if (level.block_snap_field)
14358 SetFieldForSnapping(x, y, element, move_direction, player->index_bit);
14360 TestFieldAfterSnapping(x, y, element, move_direction, player->index_bit);
14362 // use old behaviour for old levels (snapping)
14363 if (!level.finish_dig_collect)
14364 CheckTriggeredElementChangeByPlayer(x, y, element, CE_PLAYER_SNAPS_X,
14365 player->index_bit, dig_side);
14368 else if (player_can_move_or_snap && IS_PUSHABLE(element))
14370 if (mode == DF_SNAP && element != EL_BD_ROCK)
14371 return MP_NO_ACTION;
14373 if (CAN_FALL(element) && dy)
14374 return MP_NO_ACTION;
14376 if (CAN_FALL(element) && IN_LEV_FIELD(x, y + 1) && IS_FREE(x, y + 1) &&
14377 !(element == EL_SPRING && level.use_spring_bug))
14378 return MP_NO_ACTION;
14380 if (CAN_MOVE(element) && GET_MAX_MOVE_DELAY(element) == 0 &&
14381 ((move_direction & MV_VERTICAL &&
14382 ((element_info[element].move_pattern & MV_LEFT &&
14383 IN_LEV_FIELD(x - 1, y) && IS_FREE(x - 1, y)) ||
14384 (element_info[element].move_pattern & MV_RIGHT &&
14385 IN_LEV_FIELD(x + 1, y) && IS_FREE(x + 1, y)))) ||
14386 (move_direction & MV_HORIZONTAL &&
14387 ((element_info[element].move_pattern & MV_UP &&
14388 IN_LEV_FIELD(x, y - 1) && IS_FREE(x, y - 1)) ||
14389 (element_info[element].move_pattern & MV_DOWN &&
14390 IN_LEV_FIELD(x, y + 1) && IS_FREE(x, y + 1))))))
14391 return MP_NO_ACTION;
14393 // do not push elements already moving away faster than player
14394 if (CAN_MOVE(element) && MovDir[x][y] == move_direction &&
14395 ABS(getElementMoveStepsize(x, y)) > MOVE_STEPSIZE_NORMAL)
14396 return MP_NO_ACTION;
14398 if (game.engine_version >= VERSION_IDENT(3,1,0,0))
14400 if (player->push_delay_value == -1 || !player_was_pushing)
14401 player->push_delay_value = GET_NEW_PUSH_DELAY(element);
14403 else if (game.engine_version >= VERSION_IDENT(3,0,7,1))
14405 if (player->push_delay_value == -1)
14406 player->push_delay_value = GET_NEW_PUSH_DELAY(element);
14408 else if (game.engine_version >= VERSION_IDENT(2,2,0,7))
14410 if (!player->is_pushing)
14411 player->push_delay_value = GET_NEW_PUSH_DELAY(element);
14414 player->is_pushing = TRUE;
14415 player->is_active = TRUE;
14417 if (!(IN_LEV_FIELD(nextx, nexty) &&
14418 (IS_FREE(nextx, nexty) ||
14419 (IS_SB_ELEMENT(element) &&
14420 Tile[nextx][nexty] == EL_SOKOBAN_FIELD_EMPTY) ||
14421 (IS_CUSTOM_ELEMENT(element) &&
14422 CUSTOM_ELEMENT_CAN_ENTER_FIELD(element, nextx, nexty)))))
14423 return MP_NO_ACTION;
14425 if (!checkDiagonalPushing(player, x, y, real_dx, real_dy))
14426 return MP_NO_ACTION;
14428 if (player->push_delay == -1) // new pushing; restart delay
14429 player->push_delay = 0;
14431 if (player->push_delay < player->push_delay_value &&
14432 !(tape.playing && tape.file_version < FILE_VERSION_2_0) &&
14433 element != EL_SPRING && element != EL_BALLOON)
14435 // make sure that there is no move delay before next try to push
14436 if (game.engine_version >= VERSION_IDENT(3,0,7,1))
14437 player->move_delay = 0;
14439 return MP_NO_ACTION;
14442 if (IS_CUSTOM_ELEMENT(element) &&
14443 CUSTOM_ELEMENT_CAN_ENTER_FIELD(element, nextx, nexty))
14445 if (!DigFieldByCE(nextx, nexty, element))
14446 return MP_NO_ACTION;
14449 if (IS_SB_ELEMENT(element))
14451 boolean sokoban_task_solved = FALSE;
14453 if (element == EL_SOKOBAN_FIELD_FULL)
14455 Back[x][y] = EL_SOKOBAN_FIELD_EMPTY;
14457 IncrementSokobanFieldsNeeded();
14458 IncrementSokobanObjectsNeeded();
14461 if (Tile[nextx][nexty] == EL_SOKOBAN_FIELD_EMPTY)
14463 Back[nextx][nexty] = EL_SOKOBAN_FIELD_EMPTY;
14465 DecrementSokobanFieldsNeeded();
14466 DecrementSokobanObjectsNeeded();
14468 // sokoban object was pushed from empty field to sokoban field
14469 if (Back[x][y] == EL_EMPTY)
14470 sokoban_task_solved = TRUE;
14473 Tile[x][y] = EL_SOKOBAN_OBJECT;
14475 if (Back[x][y] == Back[nextx][nexty])
14476 PlayLevelSoundAction(x, y, ACTION_PUSHING);
14477 else if (Back[x][y] != 0)
14478 PlayLevelSoundElementAction(x, y, EL_SOKOBAN_FIELD_FULL,
14481 PlayLevelSoundElementAction(nextx, nexty, EL_SOKOBAN_FIELD_EMPTY,
14484 if (sokoban_task_solved &&
14485 game.sokoban_fields_still_needed == 0 &&
14486 game.sokoban_objects_still_needed == 0 &&
14487 (game.emulation == EMU_SOKOBAN || level.auto_exit_sokoban))
14489 game.players_still_needed = 0;
14493 PlayLevelSound(x, y, SND_GAME_SOKOBAN_SOLVING);
14497 PlayLevelSoundElementAction(x, y, element, ACTION_PUSHING);
14499 InitMovingField(x, y, move_direction);
14500 GfxAction[x][y] = ACTION_PUSHING;
14502 if (mode == DF_SNAP)
14503 ContinueMoving(x, y);
14505 MovPos[x][y] = (dx != 0 ? dx : dy);
14507 Pushed[x][y] = TRUE;
14508 Pushed[nextx][nexty] = TRUE;
14510 if (game.engine_version < VERSION_IDENT(2,2,0,7))
14511 player->push_delay_value = GET_NEW_PUSH_DELAY(element);
14513 player->push_delay_value = -1; // get new value later
14515 // check for element change _after_ element has been pushed
14516 if (game.use_change_when_pushing_bug)
14518 CheckElementChangeByPlayer(x, y, element, CE_PUSHED_BY_PLAYER,
14519 player->index_bit, dig_side);
14520 CheckTriggeredElementChangeByPlayer(x, y, element, CE_PLAYER_PUSHES_X,
14521 player->index_bit, dig_side);
14524 else if (IS_SWITCHABLE(element))
14526 if (PLAYER_SWITCHING(player, x, y))
14528 CheckTriggeredElementChangeByPlayer(x, y, element, CE_PLAYER_PRESSES_X,
14529 player->index_bit, dig_side);
14534 player->is_switching = TRUE;
14535 player->switch_x = x;
14536 player->switch_y = y;
14538 PlayLevelSoundElementAction(x, y, element, ACTION_ACTIVATING);
14540 if (element == EL_ROBOT_WHEEL)
14542 Tile[x][y] = EL_ROBOT_WHEEL_ACTIVE;
14544 game.robot_wheel_x = x;
14545 game.robot_wheel_y = y;
14546 game.robot_wheel_active = TRUE;
14548 TEST_DrawLevelField(x, y);
14550 else if (element == EL_SP_TERMINAL)
14554 SCAN_PLAYFIELD(xx, yy)
14556 if (Tile[xx][yy] == EL_SP_DISK_YELLOW)
14560 else if (Tile[xx][yy] == EL_SP_TERMINAL)
14562 Tile[xx][yy] = EL_SP_TERMINAL_ACTIVE;
14564 ResetGfxAnimation(xx, yy);
14565 TEST_DrawLevelField(xx, yy);
14569 else if (IS_BELT_SWITCH(element))
14571 ToggleBeltSwitch(x, y);
14573 else if (element == EL_SWITCHGATE_SWITCH_UP ||
14574 element == EL_SWITCHGATE_SWITCH_DOWN ||
14575 element == EL_DC_SWITCHGATE_SWITCH_UP ||
14576 element == EL_DC_SWITCHGATE_SWITCH_DOWN)
14578 ToggleSwitchgateSwitch(x, y);
14580 else if (element == EL_LIGHT_SWITCH ||
14581 element == EL_LIGHT_SWITCH_ACTIVE)
14583 ToggleLightSwitch(x, y);
14585 else if (element == EL_TIMEGATE_SWITCH ||
14586 element == EL_DC_TIMEGATE_SWITCH)
14588 ActivateTimegateSwitch(x, y);
14590 else if (element == EL_BALLOON_SWITCH_LEFT ||
14591 element == EL_BALLOON_SWITCH_RIGHT ||
14592 element == EL_BALLOON_SWITCH_UP ||
14593 element == EL_BALLOON_SWITCH_DOWN ||
14594 element == EL_BALLOON_SWITCH_NONE ||
14595 element == EL_BALLOON_SWITCH_ANY)
14597 game.wind_direction = (element == EL_BALLOON_SWITCH_LEFT ? MV_LEFT :
14598 element == EL_BALLOON_SWITCH_RIGHT ? MV_RIGHT :
14599 element == EL_BALLOON_SWITCH_UP ? MV_UP :
14600 element == EL_BALLOON_SWITCH_DOWN ? MV_DOWN :
14601 element == EL_BALLOON_SWITCH_NONE ? MV_NONE :
14604 else if (element == EL_LAMP)
14606 Tile[x][y] = EL_LAMP_ACTIVE;
14607 game.lights_still_needed--;
14609 ResetGfxAnimation(x, y);
14610 TEST_DrawLevelField(x, y);
14612 else if (element == EL_TIME_ORB_FULL)
14614 Tile[x][y] = EL_TIME_ORB_EMPTY;
14616 if (level.time > 0 || level.use_time_orb_bug)
14618 TimeLeft += level.time_orb_time;
14619 game.no_time_limit = FALSE;
14621 game_panel_controls[GAME_PANEL_TIME].value = TimeLeft;
14623 DisplayGameControlValues();
14626 ResetGfxAnimation(x, y);
14627 TEST_DrawLevelField(x, y);
14629 else if (element == EL_EMC_MAGIC_BALL_SWITCH ||
14630 element == EL_EMC_MAGIC_BALL_SWITCH_ACTIVE)
14634 game.ball_active = !game.ball_active;
14636 SCAN_PLAYFIELD(xx, yy)
14638 int e = Tile[xx][yy];
14640 if (game.ball_active)
14642 if (e == EL_EMC_MAGIC_BALL)
14643 CreateField(xx, yy, EL_EMC_MAGIC_BALL_ACTIVE);
14644 else if (e == EL_EMC_MAGIC_BALL_SWITCH)
14645 CreateField(xx, yy, EL_EMC_MAGIC_BALL_SWITCH_ACTIVE);
14649 if (e == EL_EMC_MAGIC_BALL_ACTIVE)
14650 CreateField(xx, yy, EL_EMC_MAGIC_BALL);
14651 else if (e == EL_EMC_MAGIC_BALL_SWITCH_ACTIVE)
14652 CreateField(xx, yy, EL_EMC_MAGIC_BALL_SWITCH);
14657 CheckTriggeredElementChangeByPlayer(x, y, element, CE_SWITCH_OF_X,
14658 player->index_bit, dig_side);
14660 CheckTriggeredElementChangeByPlayer(x, y, element, CE_PLAYER_SWITCHES_X,
14661 player->index_bit, dig_side);
14663 CheckTriggeredElementChangeByPlayer(x, y, element, CE_PLAYER_PRESSES_X,
14664 player->index_bit, dig_side);
14670 if (!PLAYER_SWITCHING(player, x, y))
14672 player->is_switching = TRUE;
14673 player->switch_x = x;
14674 player->switch_y = y;
14676 CheckElementChangeByPlayer(x, y, element, CE_SWITCHED,
14677 player->index_bit, dig_side);
14678 CheckTriggeredElementChangeByPlayer(x, y, element, CE_SWITCH_OF_X,
14679 player->index_bit, dig_side);
14681 CheckElementChangeByPlayer(x, y, element, CE_SWITCHED_BY_PLAYER,
14682 player->index_bit, dig_side);
14683 CheckTriggeredElementChangeByPlayer(x, y, element, CE_PLAYER_SWITCHES_X,
14684 player->index_bit, dig_side);
14687 CheckElementChangeByPlayer(x, y, element, CE_PRESSED_BY_PLAYER,
14688 player->index_bit, dig_side);
14689 CheckTriggeredElementChangeByPlayer(x, y, element, CE_PLAYER_PRESSES_X,
14690 player->index_bit, dig_side);
14692 return MP_NO_ACTION;
14695 player->push_delay = -1;
14697 if (is_player) // function can also be called by EL_PENGUIN
14699 if (Tile[x][y] != element) // really digged/collected something
14701 player->is_collecting = !player->is_digging;
14702 player->is_active = TRUE;
14704 player->last_removed_element = element;
14711 static boolean DigFieldByCE(int x, int y, int digging_element)
14713 int element = Tile[x][y];
14715 if (!IS_FREE(x, y))
14717 int action = (IS_DIGGABLE(element) ? ACTION_DIGGING :
14718 IS_COLLECTIBLE(element) ? ACTION_COLLECTING :
14721 // no element can dig solid indestructible elements
14722 if (IS_INDESTRUCTIBLE(element) &&
14723 !IS_DIGGABLE(element) &&
14724 !IS_COLLECTIBLE(element))
14727 if (AmoebaNr[x][y] &&
14728 (element == EL_AMOEBA_FULL ||
14729 element == EL_BD_AMOEBA ||
14730 element == EL_AMOEBA_GROWING))
14732 AmoebaCnt[AmoebaNr[x][y]]--;
14733 AmoebaCnt2[AmoebaNr[x][y]]--;
14736 if (IS_MOVING(x, y))
14737 RemoveMovingField(x, y);
14741 TEST_DrawLevelField(x, y);
14744 // if digged element was about to explode, prevent the explosion
14745 ExplodeField[x][y] = EX_TYPE_NONE;
14747 PlayLevelSoundAction(x, y, action);
14750 Store[x][y] = EL_EMPTY;
14752 // this makes it possible to leave the removed element again
14753 if (IS_EQUAL_OR_IN_GROUP(element, MOVE_ENTER_EL(digging_element)))
14754 Store[x][y] = element;
14759 static boolean SnapField(struct PlayerInfo *player, int dx, int dy)
14761 int jx = player->jx, jy = player->jy;
14762 int x = jx + dx, y = jy + dy;
14763 int snap_direction = (dx == -1 ? MV_LEFT :
14764 dx == +1 ? MV_RIGHT :
14766 dy == +1 ? MV_DOWN : MV_NONE);
14767 boolean can_continue_snapping = (level.continuous_snapping &&
14768 WasJustFalling[x][y] < CHECK_DELAY_FALLING);
14770 if (player->MovPos != 0 && game.engine_version >= VERSION_IDENT(2,2,0,0))
14773 if (!player->active || !IN_LEV_FIELD(x, y))
14781 if (player->MovPos == 0)
14782 player->is_pushing = FALSE;
14784 player->is_snapping = FALSE;
14786 if (player->MovPos == 0)
14788 player->is_moving = FALSE;
14789 player->is_digging = FALSE;
14790 player->is_collecting = FALSE;
14796 // prevent snapping with already pressed snap key when not allowed
14797 if (player->is_snapping && !can_continue_snapping)
14800 player->MovDir = snap_direction;
14802 if (player->MovPos == 0)
14804 player->is_moving = FALSE;
14805 player->is_digging = FALSE;
14806 player->is_collecting = FALSE;
14809 player->is_dropping = FALSE;
14810 player->is_dropping_pressed = FALSE;
14811 player->drop_pressed_delay = 0;
14813 if (DigField(player, jx, jy, x, y, 0, 0, DF_SNAP) == MP_NO_ACTION)
14816 player->is_snapping = TRUE;
14817 player->is_active = TRUE;
14819 if (player->MovPos == 0)
14821 player->is_moving = FALSE;
14822 player->is_digging = FALSE;
14823 player->is_collecting = FALSE;
14826 if (player->MovPos != 0) // prevent graphic bugs in versions < 2.2.0
14827 TEST_DrawLevelField(player->last_jx, player->last_jy);
14829 TEST_DrawLevelField(x, y);
14834 static boolean DropElement(struct PlayerInfo *player)
14836 int old_element, new_element;
14837 int dropx = player->jx, dropy = player->jy;
14838 int drop_direction = player->MovDir;
14839 int drop_side = drop_direction;
14840 int drop_element = get_next_dropped_element(player);
14842 /* do not drop an element on top of another element; when holding drop key
14843 pressed without moving, dropped element must move away before the next
14844 element can be dropped (this is especially important if the next element
14845 is dynamite, which can be placed on background for historical reasons) */
14846 if (PLAYER_DROPPING(player, dropx, dropy) && Tile[dropx][dropy] != EL_EMPTY)
14849 if (IS_THROWABLE(drop_element))
14851 dropx += GET_DX_FROM_DIR(drop_direction);
14852 dropy += GET_DY_FROM_DIR(drop_direction);
14854 if (!IN_LEV_FIELD(dropx, dropy))
14858 old_element = Tile[dropx][dropy]; // old element at dropping position
14859 new_element = drop_element; // default: no change when dropping
14861 // check if player is active, not moving and ready to drop
14862 if (!player->active || player->MovPos || player->drop_delay > 0)
14865 // check if player has anything that can be dropped
14866 if (new_element == EL_UNDEFINED)
14869 // only set if player has anything that can be dropped
14870 player->is_dropping_pressed = TRUE;
14872 // check if drop key was pressed long enough for EM style dynamite
14873 if (new_element == EL_EM_DYNAMITE && player->drop_pressed_delay < 40)
14876 // check if anything can be dropped at the current position
14877 if (IS_ACTIVE_BOMB(old_element) || old_element == EL_EXPLOSION)
14880 // collected custom elements can only be dropped on empty fields
14881 if (IS_CUSTOM_ELEMENT(new_element) && old_element != EL_EMPTY)
14884 if (old_element != EL_EMPTY)
14885 Back[dropx][dropy] = old_element; // store old element on this field
14887 ResetGfxAnimation(dropx, dropy);
14888 ResetRandomAnimationValue(dropx, dropy);
14890 if (player->inventory_size > 0 ||
14891 player->inventory_infinite_element != EL_UNDEFINED)
14893 if (player->inventory_size > 0)
14895 player->inventory_size--;
14897 DrawGameDoorValues();
14899 if (new_element == EL_DYNAMITE)
14900 new_element = EL_DYNAMITE_ACTIVE;
14901 else if (new_element == EL_EM_DYNAMITE)
14902 new_element = EL_EM_DYNAMITE_ACTIVE;
14903 else if (new_element == EL_SP_DISK_RED)
14904 new_element = EL_SP_DISK_RED_ACTIVE;
14907 Tile[dropx][dropy] = new_element;
14909 if (IN_SCR_FIELD(SCREENX(dropx), SCREENY(dropy)))
14910 DrawGraphicThruMask(SCREENX(dropx), SCREENY(dropy),
14911 el2img(Tile[dropx][dropy]), 0);
14913 PlayLevelSoundAction(dropx, dropy, ACTION_DROPPING);
14915 // needed if previous element just changed to "empty" in the last frame
14916 ChangeCount[dropx][dropy] = 0; // allow at least one more change
14918 CheckElementChangeByPlayer(dropx, dropy, new_element, CE_DROPPED_BY_PLAYER,
14919 player->index_bit, drop_side);
14920 CheckTriggeredElementChangeByPlayer(dropx, dropy, new_element,
14922 player->index_bit, drop_side);
14924 TestIfElementTouchesCustomElement(dropx, dropy);
14926 else // player is dropping a dyna bomb
14928 player->dynabombs_left--;
14930 Tile[dropx][dropy] = new_element;
14932 if (IN_SCR_FIELD(SCREENX(dropx), SCREENY(dropy)))
14933 DrawGraphicThruMask(SCREENX(dropx), SCREENY(dropy),
14934 el2img(Tile[dropx][dropy]), 0);
14936 PlayLevelSoundAction(dropx, dropy, ACTION_DROPPING);
14939 if (Tile[dropx][dropy] == new_element) // uninitialized unless CE change
14940 InitField_WithBug1(dropx, dropy, FALSE);
14942 new_element = Tile[dropx][dropy]; // element might have changed
14944 if (IS_CUSTOM_ELEMENT(new_element) && CAN_MOVE(new_element) &&
14945 element_info[new_element].move_pattern == MV_WHEN_DROPPED)
14947 if (element_info[new_element].move_direction_initial == MV_START_AUTOMATIC)
14948 MovDir[dropx][dropy] = drop_direction;
14950 ChangeCount[dropx][dropy] = 0; // allow at least one more change
14952 // do not cause impact style collision by dropping elements that can fall
14953 CheckCollision[dropx][dropy] = CHECK_DELAY_COLLISION;
14956 player->drop_delay = GET_NEW_DROP_DELAY(drop_element);
14957 player->is_dropping = TRUE;
14959 player->drop_pressed_delay = 0;
14960 player->is_dropping_pressed = FALSE;
14962 player->drop_x = dropx;
14963 player->drop_y = dropy;
14968 // ----------------------------------------------------------------------------
14969 // game sound playing functions
14970 // ----------------------------------------------------------------------------
14972 static int *loop_sound_frame = NULL;
14973 static int *loop_sound_volume = NULL;
14975 void InitPlayLevelSound(void)
14977 int num_sounds = getSoundListSize();
14979 checked_free(loop_sound_frame);
14980 checked_free(loop_sound_volume);
14982 loop_sound_frame = checked_calloc(num_sounds * sizeof(int));
14983 loop_sound_volume = checked_calloc(num_sounds * sizeof(int));
14986 static void PlayLevelSound(int x, int y, int nr)
14988 int sx = SCREENX(x), sy = SCREENY(y);
14989 int volume, stereo_position;
14990 int max_distance = 8;
14991 int type = (IS_LOOP_SOUND(nr) ? SND_CTRL_PLAY_LOOP : SND_CTRL_PLAY_SOUND);
14993 if ((!setup.sound_simple && !IS_LOOP_SOUND(nr)) ||
14994 (!setup.sound_loops && IS_LOOP_SOUND(nr)))
14997 if (!IN_LEV_FIELD(x, y) ||
14998 sx < -max_distance || sx >= SCR_FIELDX + max_distance ||
14999 sy < -max_distance || sy >= SCR_FIELDY + max_distance)
15002 volume = SOUND_MAX_VOLUME;
15004 if (!IN_SCR_FIELD(sx, sy))
15006 int dx = ABS(sx - SCR_FIELDX / 2) - SCR_FIELDX / 2;
15007 int dy = ABS(sy - SCR_FIELDY / 2) - SCR_FIELDY / 2;
15009 volume -= volume * (dx > dy ? dx : dy) / max_distance;
15012 stereo_position = (SOUND_MAX_LEFT +
15013 (sx + max_distance) * SOUND_MAX_LEFT2RIGHT /
15014 (SCR_FIELDX + 2 * max_distance));
15016 if (IS_LOOP_SOUND(nr))
15018 /* This assures that quieter loop sounds do not overwrite louder ones,
15019 while restarting sound volume comparison with each new game frame. */
15021 if (loop_sound_volume[nr] > volume && loop_sound_frame[nr] == FrameCounter)
15024 loop_sound_volume[nr] = volume;
15025 loop_sound_frame[nr] = FrameCounter;
15028 PlaySoundExt(nr, volume, stereo_position, type);
15031 static void PlayLevelSoundNearest(int x, int y, int sound_action)
15033 PlayLevelSound(x < LEVELX(BX1) ? LEVELX(BX1) :
15034 x > LEVELX(BX2) ? LEVELX(BX2) : x,
15035 y < LEVELY(BY1) ? LEVELY(BY1) :
15036 y > LEVELY(BY2) ? LEVELY(BY2) : y,
15040 static void PlayLevelSoundAction(int x, int y, int action)
15042 PlayLevelSoundElementAction(x, y, Tile[x][y], action);
15045 static void PlayLevelSoundElementAction(int x, int y, int element, int action)
15047 int sound_effect = element_info[SND_ELEMENT(element)].sound[action];
15049 if (sound_effect != SND_UNDEFINED)
15050 PlayLevelSound(x, y, sound_effect);
15053 static void PlayLevelSoundElementActionIfLoop(int x, int y, int element,
15056 int sound_effect = element_info[SND_ELEMENT(element)].sound[action];
15058 if (sound_effect != SND_UNDEFINED && IS_LOOP_SOUND(sound_effect))
15059 PlayLevelSound(x, y, sound_effect);
15062 static void PlayLevelSoundActionIfLoop(int x, int y, int action)
15064 int sound_effect = element_info[SND_ELEMENT(Tile[x][y])].sound[action];
15066 if (sound_effect != SND_UNDEFINED && IS_LOOP_SOUND(sound_effect))
15067 PlayLevelSound(x, y, sound_effect);
15070 static void StopLevelSoundActionIfLoop(int x, int y, int action)
15072 int sound_effect = element_info[SND_ELEMENT(Tile[x][y])].sound[action];
15074 if (sound_effect != SND_UNDEFINED && IS_LOOP_SOUND(sound_effect))
15075 StopSound(sound_effect);
15078 static int getLevelMusicNr(void)
15080 if (levelset.music[level_nr] != MUS_UNDEFINED)
15081 return levelset.music[level_nr]; // from config file
15083 return MAP_NOCONF_MUSIC(level_nr); // from music dir
15086 static void FadeLevelSounds(void)
15091 static void FadeLevelMusic(void)
15093 int music_nr = getLevelMusicNr();
15094 char *curr_music = getCurrentlyPlayingMusicFilename();
15095 char *next_music = getMusicInfoEntryFilename(music_nr);
15097 if (!strEqual(curr_music, next_music))
15101 void FadeLevelSoundsAndMusic(void)
15107 static void PlayLevelMusic(void)
15109 int music_nr = getLevelMusicNr();
15110 char *curr_music = getCurrentlyPlayingMusicFilename();
15111 char *next_music = getMusicInfoEntryFilename(music_nr);
15113 if (!strEqual(curr_music, next_music))
15114 PlayMusicLoop(music_nr);
15117 void PlayLevelSound_EM(int xx, int yy, int element_em, int sample)
15119 int element = (element_em > -1 ? map_element_EM_to_RND_game(element_em) : 0);
15121 int x = xx - offset;
15122 int y = yy - offset;
15127 PlayLevelSoundElementAction(x, y, element, ACTION_WALKING);
15131 PlayLevelSoundElementAction(x, y, element, ACTION_PUSHING);
15135 PlayLevelSoundElementAction(x, y, element, ACTION_IMPACT);
15139 PlayLevelSoundElementAction(x, y, element, ACTION_IMPACT);
15143 PlayLevelSoundElementAction(x, y, element, ACTION_BREAKING);
15147 PlayLevelSoundElementAction(x, y, element, ACTION_MOVING);
15151 PlayLevelSoundElementAction(x, y, element, ACTION_MOVING);
15154 case SOUND_android_clone:
15155 PlayLevelSoundElementAction(x, y, element, ACTION_DROPPING);
15158 case SOUND_android_move:
15159 PlayLevelSoundElementAction(x, y, element, ACTION_MOVING);
15163 PlayLevelSoundElementAction(x, y, element, ACTION_IMPACT);
15167 PlayLevelSoundElementAction(x, y, element, ACTION_EATING);
15171 PlayLevelSoundElementAction(x, y, element, ACTION_WAITING);
15174 case SOUND_eater_eat:
15175 PlayLevelSoundElementAction(x, y, element, ACTION_DIGGING);
15179 PlayLevelSoundElementAction(x, y, element, ACTION_MOVING);
15182 case SOUND_collect:
15183 PlayLevelSoundElementAction(x, y, element, ACTION_COLLECTING);
15186 case SOUND_diamond:
15187 PlayLevelSoundElementAction(x, y, element, ACTION_IMPACT);
15191 // !!! CHECK THIS !!!
15193 PlayLevelSoundElementAction(x, y, element, ACTION_BREAKING);
15195 PlayLevelSoundElementAction(x, y, element, ACTION_SMASHED_BY_ROCK);
15199 case SOUND_wonderfall:
15200 PlayLevelSoundElementAction(x, y, element, ACTION_FILLING);
15204 PlayLevelSoundElementAction(x, y, element, ACTION_IMPACT);
15208 PlayLevelSoundElementAction(x, y, element, ACTION_PUSHING);
15212 PlayLevelSoundElementAction(x, y, element, ACTION_DIGGING);
15216 PlayLevelSoundElementAction(x, y, element, ACTION_SPLASHING);
15220 PlayLevelSoundElementAction(x, y, element, ACTION_DROPPING);
15224 PlayLevelSoundElementAction(x, y, element, ACTION_GROWING);
15228 PlayLevelSoundElementAction(x, y, element, ACTION_ACTIVE);
15232 PlayLevelSoundElementAction(x, y, element, ACTION_PASSING);
15235 case SOUND_exit_open:
15236 PlayLevelSoundElementAction(x, y, element, ACTION_OPENING);
15239 case SOUND_exit_leave:
15240 PlayLevelSoundElementAction(x, y, element, ACTION_PASSING);
15243 case SOUND_dynamite:
15244 PlayLevelSoundElementAction(x, y, element, ACTION_DROPPING);
15248 PlayLevelSoundElementAction(x, y, element, ACTION_ACTIVE);
15252 PlayLevelSoundElementAction(x, y, element, ACTION_ACTIVATING);
15256 PlayLevelSoundElementAction(x, y, element, ACTION_ACTIVE);
15260 PlayLevelSoundElementAction(x, y, element, ACTION_EXPLODING);
15264 PlayLevelSoundElementAction(x, y, element, ACTION_DYING);
15268 PlaySound(SND_GAME_RUNNING_OUT_OF_TIME);
15272 PlayLevelSoundElementAction(x, y, element, ACTION_DEFAULT);
15277 void PlayLevelSound_SP(int xx, int yy, int element_sp, int action_sp)
15279 int element = map_element_SP_to_RND(element_sp);
15280 int action = map_action_SP_to_RND(action_sp);
15281 int offset = (setup.sp_show_border_elements ? 0 : 1);
15282 int x = xx - offset;
15283 int y = yy - offset;
15285 PlayLevelSoundElementAction(x, y, element, action);
15288 void PlayLevelSound_MM(int xx, int yy, int element_mm, int action_mm)
15290 int element = map_element_MM_to_RND(element_mm);
15291 int action = map_action_MM_to_RND(action_mm);
15293 int x = xx - offset;
15294 int y = yy - offset;
15296 if (!IS_MM_ELEMENT(element))
15297 element = EL_MM_DEFAULT;
15299 PlayLevelSoundElementAction(x, y, element, action);
15302 void PlaySound_MM(int sound_mm)
15304 int sound = map_sound_MM_to_RND(sound_mm);
15306 if (sound == SND_UNDEFINED)
15312 void PlaySoundLoop_MM(int sound_mm)
15314 int sound = map_sound_MM_to_RND(sound_mm);
15316 if (sound == SND_UNDEFINED)
15319 PlaySoundLoop(sound);
15322 void StopSound_MM(int sound_mm)
15324 int sound = map_sound_MM_to_RND(sound_mm);
15326 if (sound == SND_UNDEFINED)
15332 void RaiseScore(int value)
15334 game.score += value;
15336 game_panel_controls[GAME_PANEL_SCORE].value = game.score;
15338 DisplayGameControlValues();
15341 void RaiseScoreElement(int element)
15346 case EL_BD_DIAMOND:
15347 case EL_EMERALD_YELLOW:
15348 case EL_EMERALD_RED:
15349 case EL_EMERALD_PURPLE:
15350 case EL_SP_INFOTRON:
15351 RaiseScore(level.score[SC_EMERALD]);
15354 RaiseScore(level.score[SC_DIAMOND]);
15357 RaiseScore(level.score[SC_CRYSTAL]);
15360 RaiseScore(level.score[SC_PEARL]);
15363 case EL_BD_BUTTERFLY:
15364 case EL_SP_ELECTRON:
15365 RaiseScore(level.score[SC_BUG]);
15368 case EL_BD_FIREFLY:
15369 case EL_SP_SNIKSNAK:
15370 RaiseScore(level.score[SC_SPACESHIP]);
15373 case EL_DARK_YAMYAM:
15374 RaiseScore(level.score[SC_YAMYAM]);
15377 RaiseScore(level.score[SC_ROBOT]);
15380 RaiseScore(level.score[SC_PACMAN]);
15383 RaiseScore(level.score[SC_NUT]);
15386 case EL_EM_DYNAMITE:
15387 case EL_SP_DISK_RED:
15388 case EL_DYNABOMB_INCREASE_NUMBER:
15389 case EL_DYNABOMB_INCREASE_SIZE:
15390 case EL_DYNABOMB_INCREASE_POWER:
15391 RaiseScore(level.score[SC_DYNAMITE]);
15393 case EL_SHIELD_NORMAL:
15394 case EL_SHIELD_DEADLY:
15395 RaiseScore(level.score[SC_SHIELD]);
15397 case EL_EXTRA_TIME:
15398 RaiseScore(level.extra_time_score);
15412 case EL_DC_KEY_WHITE:
15413 RaiseScore(level.score[SC_KEY]);
15416 RaiseScore(element_info[element].collect_score);
15421 void RequestQuitGameExt(boolean skip_request, boolean quick_quit, char *message)
15423 if (skip_request || Request(message, REQ_ASK | REQ_STAY_CLOSED))
15427 // prevent short reactivation of overlay buttons while closing door
15428 SetOverlayActive(FALSE);
15430 // door may still be open due to skipped or envelope style request
15431 CloseDoor(DOOR_CLOSE_1);
15434 if (network.enabled)
15435 SendToServer_StopPlaying(NETWORK_STOP_BY_PLAYER);
15439 FadeSkipNextFadeIn();
15441 SetGameStatus(GAME_MODE_MAIN);
15446 else // continue playing the game
15448 if (tape.playing && tape.deactivate_display)
15449 TapeDeactivateDisplayOff(TRUE);
15451 OpenDoor(DOOR_OPEN_1 | DOOR_COPY_BACK);
15453 if (tape.playing && tape.deactivate_display)
15454 TapeDeactivateDisplayOn();
15458 void RequestQuitGame(boolean escape_key_pressed)
15460 boolean ask_on_escape = (setup.ask_on_escape && setup.ask_on_quit_game);
15461 boolean quick_quit = ((escape_key_pressed && !ask_on_escape) ||
15462 level_editor_test_game);
15463 boolean skip_request = (game.all_players_gone || !setup.ask_on_quit_game ||
15466 RequestQuitGameExt(skip_request, quick_quit,
15467 "Do you really want to quit the game?");
15470 void RequestRestartGame(char *message)
15472 game.restart_game_message = NULL;
15474 boolean has_started_game = hasStartedNetworkGame();
15475 int request_mode = (has_started_game ? REQ_ASK : REQ_CONFIRM);
15477 if (Request(message, request_mode | REQ_STAY_CLOSED) && has_started_game)
15479 StartGameActions(network.enabled, setup.autorecord, level.random_seed);
15483 // needed in case of envelope request to close game panel
15484 CloseDoor(DOOR_CLOSE_1);
15486 SetGameStatus(GAME_MODE_MAIN);
15492 void CheckGameOver(void)
15494 static boolean last_game_over = FALSE;
15495 static int game_over_delay = 0;
15496 int game_over_delay_value = 50;
15497 boolean game_over = checkGameFailed();
15499 // do not handle game over if request dialog is already active
15500 if (game.request_active)
15503 // do not ask to play again if game was never actually played
15504 if (!game.GamePlayed)
15509 last_game_over = FALSE;
15510 game_over_delay = game_over_delay_value;
15515 if (game_over_delay > 0)
15522 if (last_game_over != game_over)
15523 game.restart_game_message = (hasStartedNetworkGame() ?
15524 "Game over! Play it again?" :
15527 last_game_over = game_over;
15530 boolean checkGameSolved(void)
15532 // set for all game engines if level was solved
15533 return game.LevelSolved_GameEnd;
15536 boolean checkGameFailed(void)
15538 if (level.game_engine_type == GAME_ENGINE_TYPE_EM)
15539 return (game_em.game_over && !game_em.level_solved);
15540 else if (level.game_engine_type == GAME_ENGINE_TYPE_SP)
15541 return (game_sp.game_over && !game_sp.level_solved);
15542 else if (level.game_engine_type == GAME_ENGINE_TYPE_MM)
15543 return (game_mm.game_over && !game_mm.level_solved);
15544 else // GAME_ENGINE_TYPE_RND
15545 return (game.GameOver && !game.LevelSolved);
15548 boolean checkGameEnded(void)
15550 return (checkGameSolved() || checkGameFailed());
15554 // ----------------------------------------------------------------------------
15555 // random generator functions
15556 // ----------------------------------------------------------------------------
15558 unsigned int InitEngineRandom_RND(int seed)
15560 game.num_random_calls = 0;
15562 return InitEngineRandom(seed);
15565 unsigned int RND(int max)
15569 game.num_random_calls++;
15571 return GetEngineRandom(max);
15578 // ----------------------------------------------------------------------------
15579 // game engine snapshot handling functions
15580 // ----------------------------------------------------------------------------
15582 struct EngineSnapshotInfo
15584 // runtime values for custom element collect score
15585 int collect_score[NUM_CUSTOM_ELEMENTS];
15587 // runtime values for group element choice position
15588 int choice_pos[NUM_GROUP_ELEMENTS];
15590 // runtime values for belt position animations
15591 int belt_graphic[4][NUM_BELT_PARTS];
15592 int belt_anim_mode[4][NUM_BELT_PARTS];
15595 static struct EngineSnapshotInfo engine_snapshot_rnd;
15596 static char *snapshot_level_identifier = NULL;
15597 static int snapshot_level_nr = -1;
15599 static void SaveEngineSnapshotValues_RND(void)
15601 static int belt_base_active_element[4] =
15603 EL_CONVEYOR_BELT_1_LEFT_ACTIVE,
15604 EL_CONVEYOR_BELT_2_LEFT_ACTIVE,
15605 EL_CONVEYOR_BELT_3_LEFT_ACTIVE,
15606 EL_CONVEYOR_BELT_4_LEFT_ACTIVE
15610 for (i = 0; i < NUM_CUSTOM_ELEMENTS; i++)
15612 int element = EL_CUSTOM_START + i;
15614 engine_snapshot_rnd.collect_score[i] = element_info[element].collect_score;
15617 for (i = 0; i < NUM_GROUP_ELEMENTS; i++)
15619 int element = EL_GROUP_START + i;
15621 engine_snapshot_rnd.choice_pos[i] = element_info[element].group->choice_pos;
15624 for (i = 0; i < 4; i++)
15626 for (j = 0; j < NUM_BELT_PARTS; j++)
15628 int element = belt_base_active_element[i] + j;
15629 int graphic = el2img(element);
15630 int anim_mode = graphic_info[graphic].anim_mode;
15632 engine_snapshot_rnd.belt_graphic[i][j] = graphic;
15633 engine_snapshot_rnd.belt_anim_mode[i][j] = anim_mode;
15638 static void LoadEngineSnapshotValues_RND(void)
15640 unsigned int num_random_calls = game.num_random_calls;
15643 for (i = 0; i < NUM_CUSTOM_ELEMENTS; i++)
15645 int element = EL_CUSTOM_START + i;
15647 element_info[element].collect_score = engine_snapshot_rnd.collect_score[i];
15650 for (i = 0; i < NUM_GROUP_ELEMENTS; i++)
15652 int element = EL_GROUP_START + i;
15654 element_info[element].group->choice_pos = engine_snapshot_rnd.choice_pos[i];
15657 for (i = 0; i < 4; i++)
15659 for (j = 0; j < NUM_BELT_PARTS; j++)
15661 int graphic = engine_snapshot_rnd.belt_graphic[i][j];
15662 int anim_mode = engine_snapshot_rnd.belt_anim_mode[i][j];
15664 graphic_info[graphic].anim_mode = anim_mode;
15668 if (level.game_engine_type == GAME_ENGINE_TYPE_RND)
15670 InitRND(tape.random_seed);
15671 for (i = 0; i < num_random_calls; i++)
15675 if (game.num_random_calls != num_random_calls)
15677 Error("number of random calls out of sync");
15678 Error("number of random calls should be %d", num_random_calls);
15679 Error("number of random calls is %d", game.num_random_calls);
15681 Fail("this should not happen -- please debug");
15685 void FreeEngineSnapshotSingle(void)
15687 FreeSnapshotSingle();
15689 setString(&snapshot_level_identifier, NULL);
15690 snapshot_level_nr = -1;
15693 void FreeEngineSnapshotList(void)
15695 FreeSnapshotList();
15698 static ListNode *SaveEngineSnapshotBuffers(void)
15700 ListNode *buffers = NULL;
15702 // copy some special values to a structure better suited for the snapshot
15704 if (level.game_engine_type == GAME_ENGINE_TYPE_RND)
15705 SaveEngineSnapshotValues_RND();
15706 if (level.game_engine_type == GAME_ENGINE_TYPE_EM)
15707 SaveEngineSnapshotValues_EM();
15708 if (level.game_engine_type == GAME_ENGINE_TYPE_SP)
15709 SaveEngineSnapshotValues_SP(&buffers);
15710 if (level.game_engine_type == GAME_ENGINE_TYPE_MM)
15711 SaveEngineSnapshotValues_MM(&buffers);
15713 // save values stored in special snapshot structure
15715 if (level.game_engine_type == GAME_ENGINE_TYPE_RND)
15716 SaveSnapshotBuffer(&buffers, ARGS_ADDRESS_AND_SIZEOF(engine_snapshot_rnd));
15717 if (level.game_engine_type == GAME_ENGINE_TYPE_EM)
15718 SaveSnapshotBuffer(&buffers, ARGS_ADDRESS_AND_SIZEOF(engine_snapshot_em));
15719 if (level.game_engine_type == GAME_ENGINE_TYPE_SP)
15720 SaveSnapshotBuffer(&buffers, ARGS_ADDRESS_AND_SIZEOF(engine_snapshot_sp));
15721 if (level.game_engine_type == GAME_ENGINE_TYPE_MM)
15722 SaveSnapshotBuffer(&buffers, ARGS_ADDRESS_AND_SIZEOF(engine_snapshot_mm));
15724 // save further RND engine values
15726 SaveSnapshotBuffer(&buffers, ARGS_ADDRESS_AND_SIZEOF(stored_player));
15727 SaveSnapshotBuffer(&buffers, ARGS_ADDRESS_AND_SIZEOF(game));
15728 SaveSnapshotBuffer(&buffers, ARGS_ADDRESS_AND_SIZEOF(tape));
15730 SaveSnapshotBuffer(&buffers, ARGS_ADDRESS_AND_SIZEOF(FrameCounter));
15731 SaveSnapshotBuffer(&buffers, ARGS_ADDRESS_AND_SIZEOF(TimeFrames));
15732 SaveSnapshotBuffer(&buffers, ARGS_ADDRESS_AND_SIZEOF(TimePlayed));
15733 SaveSnapshotBuffer(&buffers, ARGS_ADDRESS_AND_SIZEOF(TimeLeft));
15734 SaveSnapshotBuffer(&buffers, ARGS_ADDRESS_AND_SIZEOF(TapeTime));
15736 SaveSnapshotBuffer(&buffers, ARGS_ADDRESS_AND_SIZEOF(ScreenMovDir));
15737 SaveSnapshotBuffer(&buffers, ARGS_ADDRESS_AND_SIZEOF(ScreenMovPos));
15738 SaveSnapshotBuffer(&buffers, ARGS_ADDRESS_AND_SIZEOF(ScreenGfxPos));
15740 SaveSnapshotBuffer(&buffers, ARGS_ADDRESS_AND_SIZEOF(ScrollStepSize));
15742 SaveSnapshotBuffer(&buffers, ARGS_ADDRESS_AND_SIZEOF(AmoebaCnt));
15743 SaveSnapshotBuffer(&buffers, ARGS_ADDRESS_AND_SIZEOF(AmoebaCnt2));
15745 SaveSnapshotBuffer(&buffers, ARGS_ADDRESS_AND_SIZEOF(Tile));
15746 SaveSnapshotBuffer(&buffers, ARGS_ADDRESS_AND_SIZEOF(MovPos));
15747 SaveSnapshotBuffer(&buffers, ARGS_ADDRESS_AND_SIZEOF(MovDir));
15748 SaveSnapshotBuffer(&buffers, ARGS_ADDRESS_AND_SIZEOF(MovDelay));
15749 SaveSnapshotBuffer(&buffers, ARGS_ADDRESS_AND_SIZEOF(ChangeDelay));
15750 SaveSnapshotBuffer(&buffers, ARGS_ADDRESS_AND_SIZEOF(ChangePage));
15751 SaveSnapshotBuffer(&buffers, ARGS_ADDRESS_AND_SIZEOF(CustomValue));
15752 SaveSnapshotBuffer(&buffers, ARGS_ADDRESS_AND_SIZEOF(Store));
15753 SaveSnapshotBuffer(&buffers, ARGS_ADDRESS_AND_SIZEOF(Store2));
15754 SaveSnapshotBuffer(&buffers, ARGS_ADDRESS_AND_SIZEOF(StorePlayer));
15755 SaveSnapshotBuffer(&buffers, ARGS_ADDRESS_AND_SIZEOF(Back));
15756 SaveSnapshotBuffer(&buffers, ARGS_ADDRESS_AND_SIZEOF(AmoebaNr));
15757 SaveSnapshotBuffer(&buffers, ARGS_ADDRESS_AND_SIZEOF(WasJustMoving));
15758 SaveSnapshotBuffer(&buffers, ARGS_ADDRESS_AND_SIZEOF(WasJustFalling));
15759 SaveSnapshotBuffer(&buffers, ARGS_ADDRESS_AND_SIZEOF(CheckCollision));
15760 SaveSnapshotBuffer(&buffers, ARGS_ADDRESS_AND_SIZEOF(CheckImpact));
15761 SaveSnapshotBuffer(&buffers, ARGS_ADDRESS_AND_SIZEOF(Stop));
15762 SaveSnapshotBuffer(&buffers, ARGS_ADDRESS_AND_SIZEOF(Pushed));
15764 SaveSnapshotBuffer(&buffers, ARGS_ADDRESS_AND_SIZEOF(ChangeCount));
15765 SaveSnapshotBuffer(&buffers, ARGS_ADDRESS_AND_SIZEOF(ChangeEvent));
15767 SaveSnapshotBuffer(&buffers, ARGS_ADDRESS_AND_SIZEOF(ExplodePhase));
15768 SaveSnapshotBuffer(&buffers, ARGS_ADDRESS_AND_SIZEOF(ExplodeDelay));
15769 SaveSnapshotBuffer(&buffers, ARGS_ADDRESS_AND_SIZEOF(ExplodeField));
15771 SaveSnapshotBuffer(&buffers, ARGS_ADDRESS_AND_SIZEOF(RunnerVisit));
15772 SaveSnapshotBuffer(&buffers, ARGS_ADDRESS_AND_SIZEOF(PlayerVisit));
15774 SaveSnapshotBuffer(&buffers, ARGS_ADDRESS_AND_SIZEOF(GfxFrame));
15775 SaveSnapshotBuffer(&buffers, ARGS_ADDRESS_AND_SIZEOF(GfxRandom));
15776 SaveSnapshotBuffer(&buffers, ARGS_ADDRESS_AND_SIZEOF(GfxElement));
15777 SaveSnapshotBuffer(&buffers, ARGS_ADDRESS_AND_SIZEOF(GfxAction));
15778 SaveSnapshotBuffer(&buffers, ARGS_ADDRESS_AND_SIZEOF(GfxDir));
15780 SaveSnapshotBuffer(&buffers, ARGS_ADDRESS_AND_SIZEOF(scroll_x));
15781 SaveSnapshotBuffer(&buffers, ARGS_ADDRESS_AND_SIZEOF(scroll_y));
15784 ListNode *node = engine_snapshot_list_rnd;
15787 while (node != NULL)
15789 num_bytes += ((struct EngineSnapshotNodeInfo *)node->content)->size;
15794 Debug("game:playing:SaveEngineSnapshotBuffers",
15795 "size of engine snapshot: %d bytes", num_bytes);
15801 void SaveEngineSnapshotSingle(void)
15803 ListNode *buffers = SaveEngineSnapshotBuffers();
15805 // finally save all snapshot buffers to single snapshot
15806 SaveSnapshotSingle(buffers);
15808 // save level identification information
15809 setString(&snapshot_level_identifier, leveldir_current->identifier);
15810 snapshot_level_nr = level_nr;
15813 boolean CheckSaveEngineSnapshotToList(void)
15815 boolean save_snapshot =
15816 ((game.snapshot.mode == SNAPSHOT_MODE_EVERY_STEP) ||
15817 (game.snapshot.mode == SNAPSHOT_MODE_EVERY_MOVE &&
15818 game.snapshot.changed_action) ||
15819 (game.snapshot.mode == SNAPSHOT_MODE_EVERY_COLLECT &&
15820 game.snapshot.collected_item));
15822 game.snapshot.changed_action = FALSE;
15823 game.snapshot.collected_item = FALSE;
15824 game.snapshot.save_snapshot = save_snapshot;
15826 return save_snapshot;
15829 void SaveEngineSnapshotToList(void)
15831 if (game.snapshot.mode == SNAPSHOT_MODE_OFF ||
15835 ListNode *buffers = SaveEngineSnapshotBuffers();
15837 // finally save all snapshot buffers to snapshot list
15838 SaveSnapshotToList(buffers);
15841 void SaveEngineSnapshotToListInitial(void)
15843 FreeEngineSnapshotList();
15845 SaveEngineSnapshotToList();
15848 static void LoadEngineSnapshotValues(void)
15850 // restore special values from snapshot structure
15852 if (level.game_engine_type == GAME_ENGINE_TYPE_RND)
15853 LoadEngineSnapshotValues_RND();
15854 if (level.game_engine_type == GAME_ENGINE_TYPE_EM)
15855 LoadEngineSnapshotValues_EM();
15856 if (level.game_engine_type == GAME_ENGINE_TYPE_SP)
15857 LoadEngineSnapshotValues_SP();
15858 if (level.game_engine_type == GAME_ENGINE_TYPE_MM)
15859 LoadEngineSnapshotValues_MM();
15862 void LoadEngineSnapshotSingle(void)
15864 LoadSnapshotSingle();
15866 LoadEngineSnapshotValues();
15869 static void LoadEngineSnapshot_Undo(int steps)
15871 LoadSnapshotFromList_Older(steps);
15873 LoadEngineSnapshotValues();
15876 static void LoadEngineSnapshot_Redo(int steps)
15878 LoadSnapshotFromList_Newer(steps);
15880 LoadEngineSnapshotValues();
15883 boolean CheckEngineSnapshotSingle(void)
15885 return (strEqual(snapshot_level_identifier, leveldir_current->identifier) &&
15886 snapshot_level_nr == level_nr);
15889 boolean CheckEngineSnapshotList(void)
15891 return CheckSnapshotList();
15895 // ---------- new game button stuff -------------------------------------------
15902 boolean *setup_value;
15903 boolean allowed_on_tape;
15904 boolean is_touch_button;
15906 } gamebutton_info[NUM_GAME_BUTTONS] =
15909 IMG_GFX_GAME_BUTTON_STOP, &game.button.stop,
15910 GAME_CTRL_ID_STOP, NULL,
15911 TRUE, FALSE, "stop game"
15914 IMG_GFX_GAME_BUTTON_PAUSE, &game.button.pause,
15915 GAME_CTRL_ID_PAUSE, NULL,
15916 TRUE, FALSE, "pause game"
15919 IMG_GFX_GAME_BUTTON_PLAY, &game.button.play,
15920 GAME_CTRL_ID_PLAY, NULL,
15921 TRUE, FALSE, "play game"
15924 IMG_GFX_GAME_BUTTON_UNDO, &game.button.undo,
15925 GAME_CTRL_ID_UNDO, NULL,
15926 TRUE, FALSE, "undo step"
15929 IMG_GFX_GAME_BUTTON_REDO, &game.button.redo,
15930 GAME_CTRL_ID_REDO, NULL,
15931 TRUE, FALSE, "redo step"
15934 IMG_GFX_GAME_BUTTON_SAVE, &game.button.save,
15935 GAME_CTRL_ID_SAVE, NULL,
15936 TRUE, FALSE, "save game"
15939 IMG_GFX_GAME_BUTTON_PAUSE2, &game.button.pause2,
15940 GAME_CTRL_ID_PAUSE2, NULL,
15941 TRUE, FALSE, "pause game"
15944 IMG_GFX_GAME_BUTTON_LOAD, &game.button.load,
15945 GAME_CTRL_ID_LOAD, NULL,
15946 TRUE, FALSE, "load game"
15949 IMG_GFX_GAME_BUTTON_PANEL_STOP, &game.button.panel_stop,
15950 GAME_CTRL_ID_PANEL_STOP, NULL,
15951 FALSE, FALSE, "stop game"
15954 IMG_GFX_GAME_BUTTON_PANEL_PAUSE, &game.button.panel_pause,
15955 GAME_CTRL_ID_PANEL_PAUSE, NULL,
15956 FALSE, FALSE, "pause game"
15959 IMG_GFX_GAME_BUTTON_PANEL_PLAY, &game.button.panel_play,
15960 GAME_CTRL_ID_PANEL_PLAY, NULL,
15961 FALSE, FALSE, "play game"
15964 IMG_GFX_GAME_BUTTON_TOUCH_STOP, &game.button.touch_stop,
15965 GAME_CTRL_ID_TOUCH_STOP, NULL,
15966 FALSE, TRUE, "stop game"
15969 IMG_GFX_GAME_BUTTON_TOUCH_PAUSE, &game.button.touch_pause,
15970 GAME_CTRL_ID_TOUCH_PAUSE, NULL,
15971 FALSE, TRUE, "pause game"
15974 IMG_GFX_GAME_BUTTON_SOUND_MUSIC, &game.button.sound_music,
15975 SOUND_CTRL_ID_MUSIC, &setup.sound_music,
15976 TRUE, FALSE, "background music on/off"
15979 IMG_GFX_GAME_BUTTON_SOUND_LOOPS, &game.button.sound_loops,
15980 SOUND_CTRL_ID_LOOPS, &setup.sound_loops,
15981 TRUE, FALSE, "sound loops on/off"
15984 IMG_GFX_GAME_BUTTON_SOUND_SIMPLE, &game.button.sound_simple,
15985 SOUND_CTRL_ID_SIMPLE, &setup.sound_simple,
15986 TRUE, FALSE, "normal sounds on/off"
15989 IMG_GFX_GAME_BUTTON_PANEL_SOUND_MUSIC, &game.button.panel_sound_music,
15990 SOUND_CTRL_ID_PANEL_MUSIC, &setup.sound_music,
15991 FALSE, FALSE, "background music on/off"
15994 IMG_GFX_GAME_BUTTON_PANEL_SOUND_LOOPS, &game.button.panel_sound_loops,
15995 SOUND_CTRL_ID_PANEL_LOOPS, &setup.sound_loops,
15996 FALSE, FALSE, "sound loops on/off"
15999 IMG_GFX_GAME_BUTTON_PANEL_SOUND_SIMPLE, &game.button.panel_sound_simple,
16000 SOUND_CTRL_ID_PANEL_SIMPLE, &setup.sound_simple,
16001 FALSE, FALSE, "normal sounds on/off"
16005 void CreateGameButtons(void)
16009 for (i = 0; i < NUM_GAME_BUTTONS; i++)
16011 int graphic = gamebutton_info[i].graphic;
16012 struct GraphicInfo *gfx = &graphic_info[graphic];
16013 struct XY *pos = gamebutton_info[i].pos;
16014 struct GadgetInfo *gi;
16017 unsigned int event_mask;
16018 boolean is_touch_button = gamebutton_info[i].is_touch_button;
16019 boolean allowed_on_tape = gamebutton_info[i].allowed_on_tape;
16020 boolean on_tape = (tape.show_game_buttons && allowed_on_tape);
16021 int base_x = (is_touch_button ? 0 : on_tape ? VX : DX);
16022 int base_y = (is_touch_button ? 0 : on_tape ? VY : DY);
16023 int gd_x = gfx->src_x;
16024 int gd_y = gfx->src_y;
16025 int gd_xp = gfx->src_x + gfx->pressed_xoffset;
16026 int gd_yp = gfx->src_y + gfx->pressed_yoffset;
16027 int gd_xa = gfx->src_x + gfx->active_xoffset;
16028 int gd_ya = gfx->src_y + gfx->active_yoffset;
16029 int gd_xap = gfx->src_x + gfx->active_xoffset + gfx->pressed_xoffset;
16030 int gd_yap = gfx->src_y + gfx->active_yoffset + gfx->pressed_yoffset;
16031 int x = (is_touch_button ? pos->x : GDI_ACTIVE_POS(pos->x));
16032 int y = (is_touch_button ? pos->y : GDI_ACTIVE_POS(pos->y));
16035 if (gfx->bitmap == NULL)
16037 game_gadget[id] = NULL;
16042 if (id == GAME_CTRL_ID_STOP ||
16043 id == GAME_CTRL_ID_PANEL_STOP ||
16044 id == GAME_CTRL_ID_TOUCH_STOP ||
16045 id == GAME_CTRL_ID_PLAY ||
16046 id == GAME_CTRL_ID_PANEL_PLAY ||
16047 id == GAME_CTRL_ID_SAVE ||
16048 id == GAME_CTRL_ID_LOAD)
16050 button_type = GD_TYPE_NORMAL_BUTTON;
16052 event_mask = GD_EVENT_RELEASED;
16054 else if (id == GAME_CTRL_ID_UNDO ||
16055 id == GAME_CTRL_ID_REDO)
16057 button_type = GD_TYPE_NORMAL_BUTTON;
16059 event_mask = GD_EVENT_PRESSED | GD_EVENT_REPEATED;
16063 button_type = GD_TYPE_CHECK_BUTTON;
16064 checked = (gamebutton_info[i].setup_value != NULL ?
16065 *gamebutton_info[i].setup_value : FALSE);
16066 event_mask = GD_EVENT_PRESSED;
16069 gi = CreateGadget(GDI_CUSTOM_ID, id,
16070 GDI_IMAGE_ID, graphic,
16071 GDI_INFO_TEXT, gamebutton_info[i].infotext,
16074 GDI_WIDTH, gfx->width,
16075 GDI_HEIGHT, gfx->height,
16076 GDI_TYPE, button_type,
16077 GDI_STATE, GD_BUTTON_UNPRESSED,
16078 GDI_CHECKED, checked,
16079 GDI_DESIGN_UNPRESSED, gfx->bitmap, gd_x, gd_y,
16080 GDI_DESIGN_PRESSED, gfx->bitmap, gd_xp, gd_yp,
16081 GDI_ALT_DESIGN_UNPRESSED, gfx->bitmap, gd_xa, gd_ya,
16082 GDI_ALT_DESIGN_PRESSED, gfx->bitmap, gd_xap, gd_yap,
16083 GDI_DIRECT_DRAW, FALSE,
16084 GDI_OVERLAY_TOUCH_BUTTON, is_touch_button,
16085 GDI_EVENT_MASK, event_mask,
16086 GDI_CALLBACK_ACTION, HandleGameButtons,
16090 Fail("cannot create gadget");
16092 game_gadget[id] = gi;
16096 void FreeGameButtons(void)
16100 for (i = 0; i < NUM_GAME_BUTTONS; i++)
16101 FreeGadget(game_gadget[i]);
16104 static void UnmapGameButtonsAtSamePosition(int id)
16108 for (i = 0; i < NUM_GAME_BUTTONS; i++)
16110 gamebutton_info[i].pos->x == gamebutton_info[id].pos->x &&
16111 gamebutton_info[i].pos->y == gamebutton_info[id].pos->y)
16112 UnmapGadget(game_gadget[i]);
16115 static void UnmapGameButtonsAtSamePosition_All(void)
16117 if (setup.show_snapshot_buttons)
16119 UnmapGameButtonsAtSamePosition(GAME_CTRL_ID_SAVE);
16120 UnmapGameButtonsAtSamePosition(GAME_CTRL_ID_PAUSE2);
16121 UnmapGameButtonsAtSamePosition(GAME_CTRL_ID_LOAD);
16125 UnmapGameButtonsAtSamePosition(GAME_CTRL_ID_STOP);
16126 UnmapGameButtonsAtSamePosition(GAME_CTRL_ID_PAUSE);
16127 UnmapGameButtonsAtSamePosition(GAME_CTRL_ID_PLAY);
16129 UnmapGameButtonsAtSamePosition(GAME_CTRL_ID_PANEL_STOP);
16130 UnmapGameButtonsAtSamePosition(GAME_CTRL_ID_PANEL_PAUSE);
16131 UnmapGameButtonsAtSamePosition(GAME_CTRL_ID_PANEL_PLAY);
16135 static void MapGameButtonsAtSamePosition(int id)
16139 for (i = 0; i < NUM_GAME_BUTTONS; i++)
16141 gamebutton_info[i].pos->x == gamebutton_info[id].pos->x &&
16142 gamebutton_info[i].pos->y == gamebutton_info[id].pos->y)
16143 MapGadget(game_gadget[i]);
16145 UnmapGameButtonsAtSamePosition_All();
16148 void MapUndoRedoButtons(void)
16150 UnmapGameButtonsAtSamePosition(GAME_CTRL_ID_UNDO);
16151 UnmapGameButtonsAtSamePosition(GAME_CTRL_ID_REDO);
16153 MapGadget(game_gadget[GAME_CTRL_ID_UNDO]);
16154 MapGadget(game_gadget[GAME_CTRL_ID_REDO]);
16157 void UnmapUndoRedoButtons(void)
16159 UnmapGadget(game_gadget[GAME_CTRL_ID_UNDO]);
16160 UnmapGadget(game_gadget[GAME_CTRL_ID_REDO]);
16162 MapGameButtonsAtSamePosition(GAME_CTRL_ID_UNDO);
16163 MapGameButtonsAtSamePosition(GAME_CTRL_ID_REDO);
16166 void ModifyPauseButtons(void)
16170 GAME_CTRL_ID_PAUSE,
16171 GAME_CTRL_ID_PAUSE2,
16172 GAME_CTRL_ID_PANEL_PAUSE,
16173 GAME_CTRL_ID_TOUCH_PAUSE,
16178 for (i = 0; ids[i] > -1; i++)
16179 ModifyGadget(game_gadget[ids[i]], GDI_CHECKED, tape.pausing, GDI_END);
16182 static void MapGameButtonsExt(boolean on_tape)
16186 for (i = 0; i < NUM_GAME_BUTTONS; i++)
16187 if ((!on_tape || gamebutton_info[i].allowed_on_tape) &&
16188 i != GAME_CTRL_ID_UNDO &&
16189 i != GAME_CTRL_ID_REDO)
16190 MapGadget(game_gadget[i]);
16192 UnmapGameButtonsAtSamePosition_All();
16194 RedrawGameButtons();
16197 static void UnmapGameButtonsExt(boolean on_tape)
16201 for (i = 0; i < NUM_GAME_BUTTONS; i++)
16202 if (!on_tape || gamebutton_info[i].allowed_on_tape)
16203 UnmapGadget(game_gadget[i]);
16206 static void RedrawGameButtonsExt(boolean on_tape)
16210 for (i = 0; i < NUM_GAME_BUTTONS; i++)
16211 if (!on_tape || gamebutton_info[i].allowed_on_tape)
16212 RedrawGadget(game_gadget[i]);
16215 static void SetGadgetState(struct GadgetInfo *gi, boolean state)
16220 gi->checked = state;
16223 static void RedrawSoundButtonGadget(int id)
16225 int id2 = (id == SOUND_CTRL_ID_MUSIC ? SOUND_CTRL_ID_PANEL_MUSIC :
16226 id == SOUND_CTRL_ID_LOOPS ? SOUND_CTRL_ID_PANEL_LOOPS :
16227 id == SOUND_CTRL_ID_SIMPLE ? SOUND_CTRL_ID_PANEL_SIMPLE :
16228 id == SOUND_CTRL_ID_PANEL_MUSIC ? SOUND_CTRL_ID_MUSIC :
16229 id == SOUND_CTRL_ID_PANEL_LOOPS ? SOUND_CTRL_ID_LOOPS :
16230 id == SOUND_CTRL_ID_PANEL_SIMPLE ? SOUND_CTRL_ID_SIMPLE :
16233 SetGadgetState(game_gadget[id2], *gamebutton_info[id2].setup_value);
16234 RedrawGadget(game_gadget[id2]);
16237 void MapGameButtons(void)
16239 MapGameButtonsExt(FALSE);
16242 void UnmapGameButtons(void)
16244 UnmapGameButtonsExt(FALSE);
16247 void RedrawGameButtons(void)
16249 RedrawGameButtonsExt(FALSE);
16252 void MapGameButtonsOnTape(void)
16254 MapGameButtonsExt(TRUE);
16257 void UnmapGameButtonsOnTape(void)
16259 UnmapGameButtonsExt(TRUE);
16262 void RedrawGameButtonsOnTape(void)
16264 RedrawGameButtonsExt(TRUE);
16267 static void GameUndoRedoExt(void)
16269 ClearPlayerAction();
16271 tape.pausing = TRUE;
16274 UpdateAndDisplayGameControlValues();
16276 DrawCompleteVideoDisplay();
16277 DrawVideoDisplay(VIDEO_STATE_TIME_ON, TapeTime);
16278 DrawVideoDisplay(VIDEO_STATE_FRAME_ON, FrameCounter);
16279 DrawVideoDisplay(VIDEO_STATE_1STEP(tape.single_step), 0);
16284 static void GameUndo(int steps)
16286 if (!CheckEngineSnapshotList())
16289 LoadEngineSnapshot_Undo(steps);
16294 static void GameRedo(int steps)
16296 if (!CheckEngineSnapshotList())
16299 LoadEngineSnapshot_Redo(steps);
16304 static void HandleGameButtonsExt(int id, int button)
16306 static boolean game_undo_executed = FALSE;
16307 int steps = BUTTON_STEPSIZE(button);
16308 boolean handle_game_buttons =
16309 (game_status == GAME_MODE_PLAYING ||
16310 (game_status == GAME_MODE_MAIN && tape.show_game_buttons));
16312 if (!handle_game_buttons)
16317 case GAME_CTRL_ID_STOP:
16318 case GAME_CTRL_ID_PANEL_STOP:
16319 case GAME_CTRL_ID_TOUCH_STOP:
16320 if (game_status == GAME_MODE_MAIN)
16326 RequestQuitGame(FALSE);
16330 case GAME_CTRL_ID_PAUSE:
16331 case GAME_CTRL_ID_PAUSE2:
16332 case GAME_CTRL_ID_PANEL_PAUSE:
16333 case GAME_CTRL_ID_TOUCH_PAUSE:
16334 if (network.enabled && game_status == GAME_MODE_PLAYING)
16337 SendToServer_ContinuePlaying();
16339 SendToServer_PausePlaying();
16342 TapeTogglePause(TAPE_TOGGLE_MANUAL);
16344 game_undo_executed = FALSE;
16348 case GAME_CTRL_ID_PLAY:
16349 case GAME_CTRL_ID_PANEL_PLAY:
16350 if (game_status == GAME_MODE_MAIN)
16352 StartGameActions(network.enabled, setup.autorecord, level.random_seed);
16354 else if (tape.pausing)
16356 if (network.enabled)
16357 SendToServer_ContinuePlaying();
16359 TapeTogglePause(TAPE_TOGGLE_MANUAL | TAPE_TOGGLE_PLAY_PAUSE);
16363 case GAME_CTRL_ID_UNDO:
16364 // Important: When using "save snapshot when collecting an item" mode,
16365 // load last (current) snapshot for first "undo" after pressing "pause"
16366 // (else the last-but-one snapshot would be loaded, because the snapshot
16367 // pointer already points to the last snapshot when pressing "pause",
16368 // which is fine for "every step/move" mode, but not for "every collect")
16369 if (game.snapshot.mode == SNAPSHOT_MODE_EVERY_COLLECT &&
16370 !game_undo_executed)
16373 game_undo_executed = TRUE;
16378 case GAME_CTRL_ID_REDO:
16382 case GAME_CTRL_ID_SAVE:
16386 case GAME_CTRL_ID_LOAD:
16390 case SOUND_CTRL_ID_MUSIC:
16391 case SOUND_CTRL_ID_PANEL_MUSIC:
16392 if (setup.sound_music)
16394 setup.sound_music = FALSE;
16398 else if (audio.music_available)
16400 setup.sound = setup.sound_music = TRUE;
16402 SetAudioMode(setup.sound);
16404 if (game_status == GAME_MODE_PLAYING)
16408 RedrawSoundButtonGadget(id);
16412 case SOUND_CTRL_ID_LOOPS:
16413 case SOUND_CTRL_ID_PANEL_LOOPS:
16414 if (setup.sound_loops)
16415 setup.sound_loops = FALSE;
16416 else if (audio.loops_available)
16418 setup.sound = setup.sound_loops = TRUE;
16420 SetAudioMode(setup.sound);
16423 RedrawSoundButtonGadget(id);
16427 case SOUND_CTRL_ID_SIMPLE:
16428 case SOUND_CTRL_ID_PANEL_SIMPLE:
16429 if (setup.sound_simple)
16430 setup.sound_simple = FALSE;
16431 else if (audio.sound_available)
16433 setup.sound = setup.sound_simple = TRUE;
16435 SetAudioMode(setup.sound);
16438 RedrawSoundButtonGadget(id);
16447 static void HandleGameButtons(struct GadgetInfo *gi)
16449 HandleGameButtonsExt(gi->custom_id, gi->event.button);
16452 void HandleSoundButtonKeys(Key key)
16454 if (key == setup.shortcut.sound_simple)
16455 ClickOnGadget(game_gadget[SOUND_CTRL_ID_SIMPLE], MB_LEFTBUTTON);
16456 else if (key == setup.shortcut.sound_loops)
16457 ClickOnGadget(game_gadget[SOUND_CTRL_ID_LOOPS], MB_LEFTBUTTON);
16458 else if (key == setup.shortcut.sound_music)
16459 ClickOnGadget(game_gadget[SOUND_CTRL_ID_MUSIC], MB_LEFTBUTTON);