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 if (setup.increment_levels &&
5008 level_nr < leveldir_current->last_level &&
5011 level_nr++; // advance to next level
5012 TapeErase(); // start with empty tape
5014 if (setup.auto_play_next_level)
5016 LoadLevel(level_nr);
5018 SaveLevelSetup_SeriesInfo();
5022 highlight_position = NewHighScore(last_level_nr);
5024 if (highlight_position >= 0 && setup.show_scores_after_game)
5026 SetGameStatus(GAME_MODE_SCORES);
5028 DrawHallOfFame(last_level_nr, highlight_position);
5030 else if (setup.auto_play_next_level && setup.increment_levels &&
5031 last_level_nr < leveldir_current->last_level &&
5034 StartGameActions(network.enabled, setup.autorecord, level.random_seed);
5038 SetGameStatus(GAME_MODE_MAIN);
5044 int NewHighScore(int level_nr)
5048 boolean one_score_entry_per_name = !program.many_scores_per_name;
5050 LoadScore(level_nr);
5052 if (strEqual(setup.player_name, EMPTY_PLAYER_NAME) ||
5053 game.score_final < scores.entry[MAX_SCORE_ENTRIES - 1].score)
5056 for (i = 0; i < MAX_SCORE_ENTRIES; i++)
5058 struct ScoreEntry *entry = &scores.entry[i];
5059 boolean score_is_better = (game.score_final > entry->score);
5060 boolean score_is_equal = (game.score_final == entry->score);
5061 boolean time_is_better = (game.score_time_final < entry->time);
5062 boolean time_is_equal = (game.score_time_final == entry->time);
5063 boolean better_by_score = (score_is_better ||
5064 (score_is_equal && time_is_better));
5065 boolean better_by_time = (time_is_better ||
5066 (time_is_equal && score_is_better));
5067 boolean is_better = (level.rate_time_over_score ? better_by_time :
5069 boolean entry_is_empty = (entry->score == 0 &&
5072 if (is_better || entry_is_empty)
5074 // player has made it to the hall of fame
5076 if (i < MAX_SCORE_ENTRIES - 1)
5078 int m = MAX_SCORE_ENTRIES - 1;
5080 if (one_score_entry_per_name)
5082 for (l = i; l < MAX_SCORE_ENTRIES; l++)
5083 if (strEqual(setup.player_name, scores.entry[l].name))
5086 if (m == i) // player's new highscore overwrites his old one
5090 for (l = m; l > i; l--)
5092 strcpy(scores.entry[l].name, scores.entry[l - 1].name);
5093 scores.entry[l].score = scores.entry[l - 1].score;
5094 scores.entry[l].time = scores.entry[l - 1].time;
5100 strcpy(entry->tape_basename, tape.score_tape_basename);
5101 strncpy(entry->name, setup.player_name, MAX_PLAYER_NAME_LEN);
5102 entry->name[MAX_PLAYER_NAME_LEN] = '\0';
5103 entry->score = game.score_final;
5104 entry->time = game.score_time_final;
5109 else if (one_score_entry_per_name &&
5110 !strncmp(setup.player_name, entry->name, MAX_PLAYER_NAME_LEN))
5111 break; // player already there with a higher score
5116 SaveScoreTape(level_nr);
5117 SaveScore(level_nr);
5123 static int getElementMoveStepsizeExt(int x, int y, int direction)
5125 int element = Tile[x][y];
5126 int dx = (direction == MV_LEFT ? -1 : direction == MV_RIGHT ? +1 : 0);
5127 int dy = (direction == MV_UP ? -1 : direction == MV_DOWN ? +1 : 0);
5128 int horiz_move = (dx != 0);
5129 int sign = (horiz_move ? dx : dy);
5130 int step = sign * element_info[element].move_stepsize;
5132 // special values for move stepsize for spring and things on conveyor belt
5135 if (CAN_FALL(element) &&
5136 y < lev_fieldy - 1 && IS_BELT_ACTIVE(Tile[x][y + 1]))
5137 step = sign * MOVE_STEPSIZE_NORMAL / 2;
5138 else if (element == EL_SPRING)
5139 step = sign * MOVE_STEPSIZE_NORMAL * 2;
5145 static int getElementMoveStepsize(int x, int y)
5147 return getElementMoveStepsizeExt(x, y, MovDir[x][y]);
5150 void InitPlayerGfxAnimation(struct PlayerInfo *player, int action, int dir)
5152 if (player->GfxAction != action || player->GfxDir != dir)
5154 player->GfxAction = action;
5155 player->GfxDir = dir;
5157 player->StepFrame = 0;
5161 static void ResetGfxFrame(int x, int y)
5163 // profiling showed that "autotest" spends 10~20% of its time in this function
5164 if (DrawingDeactivatedField())
5167 int element = Tile[x][y];
5168 int graphic = el_act_dir2img(element, GfxAction[x][y], GfxDir[x][y]);
5170 if (graphic_info[graphic].anim_global_sync)
5171 GfxFrame[x][y] = FrameCounter;
5172 else if (ANIM_MODE(graphic) == ANIM_CE_VALUE)
5173 GfxFrame[x][y] = CustomValue[x][y];
5174 else if (ANIM_MODE(graphic) == ANIM_CE_SCORE)
5175 GfxFrame[x][y] = element_info[element].collect_score;
5176 else if (ANIM_MODE(graphic) == ANIM_CE_DELAY)
5177 GfxFrame[x][y] = ChangeDelay[x][y];
5180 static void ResetGfxAnimation(int x, int y)
5182 GfxAction[x][y] = ACTION_DEFAULT;
5183 GfxDir[x][y] = MovDir[x][y];
5186 ResetGfxFrame(x, y);
5189 static void ResetRandomAnimationValue(int x, int y)
5191 GfxRandom[x][y] = INIT_GFX_RANDOM();
5194 static void InitMovingField(int x, int y, int direction)
5196 int element = Tile[x][y];
5197 int dx = (direction == MV_LEFT ? -1 : direction == MV_RIGHT ? +1 : 0);
5198 int dy = (direction == MV_UP ? -1 : direction == MV_DOWN ? +1 : 0);
5201 boolean is_moving_before, is_moving_after;
5203 // check if element was/is moving or being moved before/after mode change
5204 is_moving_before = (WasJustMoving[x][y] != 0);
5205 is_moving_after = (getElementMoveStepsizeExt(x, y, direction) != 0);
5207 // reset animation only for moving elements which change direction of moving
5208 // or which just started or stopped moving
5209 // (else CEs with property "can move" / "not moving" are reset each frame)
5210 if (is_moving_before != is_moving_after ||
5211 direction != MovDir[x][y])
5212 ResetGfxAnimation(x, y);
5214 MovDir[x][y] = direction;
5215 GfxDir[x][y] = direction;
5217 GfxAction[x][y] = (!is_moving_after ? ACTION_WAITING :
5218 direction == MV_DOWN && CAN_FALL(element) ?
5219 ACTION_FALLING : ACTION_MOVING);
5221 // this is needed for CEs with property "can move" / "not moving"
5223 if (is_moving_after)
5225 if (Tile[newx][newy] == EL_EMPTY)
5226 Tile[newx][newy] = EL_BLOCKED;
5228 MovDir[newx][newy] = MovDir[x][y];
5230 CustomValue[newx][newy] = CustomValue[x][y];
5232 GfxFrame[newx][newy] = GfxFrame[x][y];
5233 GfxRandom[newx][newy] = GfxRandom[x][y];
5234 GfxAction[newx][newy] = GfxAction[x][y];
5235 GfxDir[newx][newy] = GfxDir[x][y];
5239 void Moving2Blocked(int x, int y, int *goes_to_x, int *goes_to_y)
5241 int direction = MovDir[x][y];
5242 int newx = x + (direction & MV_LEFT ? -1 : direction & MV_RIGHT ? +1 : 0);
5243 int newy = y + (direction & MV_UP ? -1 : direction & MV_DOWN ? +1 : 0);
5249 void Blocked2Moving(int x, int y, int *comes_from_x, int *comes_from_y)
5251 int oldx = x, oldy = y;
5252 int direction = MovDir[x][y];
5254 if (direction == MV_LEFT)
5256 else if (direction == MV_RIGHT)
5258 else if (direction == MV_UP)
5260 else if (direction == MV_DOWN)
5263 *comes_from_x = oldx;
5264 *comes_from_y = oldy;
5267 static int MovingOrBlocked2Element(int x, int y)
5269 int element = Tile[x][y];
5271 if (element == EL_BLOCKED)
5275 Blocked2Moving(x, y, &oldx, &oldy);
5276 return Tile[oldx][oldy];
5282 static int MovingOrBlocked2ElementIfNotLeaving(int x, int y)
5284 // like MovingOrBlocked2Element(), but if element is moving
5285 // and (x,y) is the field the moving element is just leaving,
5286 // return EL_BLOCKED instead of the element value
5287 int element = Tile[x][y];
5289 if (IS_MOVING(x, y))
5291 if (element == EL_BLOCKED)
5295 Blocked2Moving(x, y, &oldx, &oldy);
5296 return Tile[oldx][oldy];
5305 static void RemoveField(int x, int y)
5307 Tile[x][y] = EL_EMPTY;
5313 CustomValue[x][y] = 0;
5316 ChangeDelay[x][y] = 0;
5317 ChangePage[x][y] = -1;
5318 Pushed[x][y] = FALSE;
5320 GfxElement[x][y] = EL_UNDEFINED;
5321 GfxAction[x][y] = ACTION_DEFAULT;
5322 GfxDir[x][y] = MV_NONE;
5325 static void RemoveMovingField(int x, int y)
5327 int oldx = x, oldy = y, newx = x, newy = y;
5328 int element = Tile[x][y];
5329 int next_element = EL_UNDEFINED;
5331 if (element != EL_BLOCKED && !IS_MOVING(x, y))
5334 if (IS_MOVING(x, y))
5336 Moving2Blocked(x, y, &newx, &newy);
5338 if (Tile[newx][newy] != EL_BLOCKED)
5340 // element is moving, but target field is not free (blocked), but
5341 // already occupied by something different (example: acid pool);
5342 // in this case, only remove the moving field, but not the target
5344 RemoveField(oldx, oldy);
5346 Store[oldx][oldy] = Store2[oldx][oldy] = 0;
5348 TEST_DrawLevelField(oldx, oldy);
5353 else if (element == EL_BLOCKED)
5355 Blocked2Moving(x, y, &oldx, &oldy);
5356 if (!IS_MOVING(oldx, oldy))
5360 if (element == EL_BLOCKED &&
5361 (Tile[oldx][oldy] == EL_QUICKSAND_EMPTYING ||
5362 Tile[oldx][oldy] == EL_QUICKSAND_FAST_EMPTYING ||
5363 Tile[oldx][oldy] == EL_MAGIC_WALL_EMPTYING ||
5364 Tile[oldx][oldy] == EL_BD_MAGIC_WALL_EMPTYING ||
5365 Tile[oldx][oldy] == EL_DC_MAGIC_WALL_EMPTYING ||
5366 Tile[oldx][oldy] == EL_AMOEBA_DROPPING))
5367 next_element = get_next_element(Tile[oldx][oldy]);
5369 RemoveField(oldx, oldy);
5370 RemoveField(newx, newy);
5372 Store[oldx][oldy] = Store2[oldx][oldy] = 0;
5374 if (next_element != EL_UNDEFINED)
5375 Tile[oldx][oldy] = next_element;
5377 TEST_DrawLevelField(oldx, oldy);
5378 TEST_DrawLevelField(newx, newy);
5381 void DrawDynamite(int x, int y)
5383 int sx = SCREENX(x), sy = SCREENY(y);
5384 int graphic = el2img(Tile[x][y]);
5387 if (!IN_SCR_FIELD(sx, sy) || IS_PLAYER(x, y))
5390 if (IS_WALKABLE_INSIDE(Back[x][y]))
5394 DrawLevelElement(x, y, Back[x][y]);
5395 else if (Store[x][y])
5396 DrawLevelElement(x, y, Store[x][y]);
5397 else if (game.use_masked_elements)
5398 DrawLevelElement(x, y, EL_EMPTY);
5400 frame = getGraphicAnimationFrame(graphic, GfxFrame[x][y]);
5402 if (Back[x][y] || Store[x][y] || game.use_masked_elements)
5403 DrawGraphicThruMask(sx, sy, graphic, frame);
5405 DrawGraphic(sx, sy, graphic, frame);
5408 static void CheckDynamite(int x, int y)
5410 if (MovDelay[x][y] != 0) // dynamite is still waiting to explode
5414 if (MovDelay[x][y] != 0)
5417 PlayLevelSoundActionIfLoop(x, y, ACTION_ACTIVE);
5423 StopLevelSoundActionIfLoop(x, y, ACTION_ACTIVE);
5428 static void setMinimalPlayerBoundaries(int *sx1, int *sy1, int *sx2, int *sy2)
5430 boolean num_checked_players = 0;
5433 for (i = 0; i < MAX_PLAYERS; i++)
5435 if (stored_player[i].active)
5437 int sx = stored_player[i].jx;
5438 int sy = stored_player[i].jy;
5440 if (num_checked_players == 0)
5447 *sx1 = MIN(*sx1, sx);
5448 *sy1 = MIN(*sy1, sy);
5449 *sx2 = MAX(*sx2, sx);
5450 *sy2 = MAX(*sy2, sy);
5453 num_checked_players++;
5458 static boolean checkIfAllPlayersFitToScreen_RND(void)
5460 int sx1 = 0, sy1 = 0, sx2 = 0, sy2 = 0;
5462 setMinimalPlayerBoundaries(&sx1, &sy1, &sx2, &sy2);
5464 return (sx2 - sx1 < SCR_FIELDX &&
5465 sy2 - sy1 < SCR_FIELDY);
5468 static void setScreenCenteredToAllPlayers(int *sx, int *sy)
5470 int sx1 = scroll_x, sy1 = scroll_y, sx2 = scroll_x, sy2 = scroll_y;
5472 setMinimalPlayerBoundaries(&sx1, &sy1, &sx2, &sy2);
5474 *sx = (sx1 + sx2) / 2;
5475 *sy = (sy1 + sy2) / 2;
5478 static void DrawRelocateScreen(int old_x, int old_y, int x, int y, int move_dir,
5479 boolean center_screen, boolean quick_relocation)
5481 unsigned int frame_delay_value_old = GetVideoFrameDelay();
5482 boolean ffwd_delay = (tape.playing && tape.fast_forward);
5483 boolean no_delay = (tape.warp_forward);
5484 int frame_delay_value = (ffwd_delay ? FfwdFrameDelay : GameFrameDelay);
5485 int wait_delay_value = (no_delay ? 0 : frame_delay_value);
5486 int new_scroll_x, new_scroll_y;
5488 if (level.lazy_relocation && IN_VIS_FIELD(SCREENX(x), SCREENY(y)))
5490 // case 1: quick relocation inside visible screen (without scrolling)
5497 if (!level.shifted_relocation || center_screen)
5499 // relocation _with_ centering of screen
5501 new_scroll_x = SCROLL_POSITION_X(x);
5502 new_scroll_y = SCROLL_POSITION_Y(y);
5506 // relocation _without_ centering of screen
5508 int center_scroll_x = SCROLL_POSITION_X(old_x);
5509 int center_scroll_y = SCROLL_POSITION_Y(old_y);
5510 int offset_x = x + (scroll_x - center_scroll_x);
5511 int offset_y = y + (scroll_y - center_scroll_y);
5513 // for new screen position, apply previous offset to center position
5514 new_scroll_x = SCROLL_POSITION_X(offset_x);
5515 new_scroll_y = SCROLL_POSITION_Y(offset_y);
5518 if (quick_relocation)
5520 // case 2: quick relocation (redraw without visible scrolling)
5522 scroll_x = new_scroll_x;
5523 scroll_y = new_scroll_y;
5530 // case 3: visible relocation (with scrolling to new position)
5532 ScrollScreen(NULL, SCROLL_GO_ON); // scroll last frame to full tile
5534 SetVideoFrameDelay(wait_delay_value);
5536 while (scroll_x != new_scroll_x || scroll_y != new_scroll_y)
5538 int dx = (new_scroll_x < scroll_x ? +1 : new_scroll_x > scroll_x ? -1 : 0);
5539 int dy = (new_scroll_y < scroll_y ? +1 : new_scroll_y > scroll_y ? -1 : 0);
5541 if (dx == 0 && dy == 0) // no scrolling needed at all
5547 // set values for horizontal/vertical screen scrolling (half tile size)
5548 int dir_x = (dx != 0 ? MV_HORIZONTAL : 0);
5549 int dir_y = (dy != 0 ? MV_VERTICAL : 0);
5550 int pos_x = dx * TILEX / 2;
5551 int pos_y = dy * TILEY / 2;
5552 int fx = getFieldbufferOffsetX_RND(dir_x, pos_x);
5553 int fy = getFieldbufferOffsetY_RND(dir_y, pos_y);
5555 ScrollLevel(dx, dy);
5558 // scroll in two steps of half tile size to make things smoother
5559 BlitScreenToBitmapExt_RND(window, fx, fy);
5561 // scroll second step to align at full tile size
5562 BlitScreenToBitmap(window);
5568 SetVideoFrameDelay(frame_delay_value_old);
5571 static void RelocatePlayer(int jx, int jy, int el_player_raw)
5573 int el_player = GET_PLAYER_ELEMENT(el_player_raw);
5574 int player_nr = GET_PLAYER_NR(el_player);
5575 struct PlayerInfo *player = &stored_player[player_nr];
5576 boolean ffwd_delay = (tape.playing && tape.fast_forward);
5577 boolean no_delay = (tape.warp_forward);
5578 int frame_delay_value = (ffwd_delay ? FfwdFrameDelay : GameFrameDelay);
5579 int wait_delay_value = (no_delay ? 0 : frame_delay_value);
5580 int old_jx = player->jx;
5581 int old_jy = player->jy;
5582 int old_element = Tile[old_jx][old_jy];
5583 int element = Tile[jx][jy];
5584 boolean player_relocated = (old_jx != jx || old_jy != jy);
5586 int move_dir_horiz = (jx < old_jx ? MV_LEFT : jx > old_jx ? MV_RIGHT : 0);
5587 int move_dir_vert = (jy < old_jy ? MV_UP : jy > old_jy ? MV_DOWN : 0);
5588 int enter_side_horiz = MV_DIR_OPPOSITE(move_dir_horiz);
5589 int enter_side_vert = MV_DIR_OPPOSITE(move_dir_vert);
5590 int leave_side_horiz = move_dir_horiz;
5591 int leave_side_vert = move_dir_vert;
5592 int enter_side = enter_side_horiz | enter_side_vert;
5593 int leave_side = leave_side_horiz | leave_side_vert;
5595 if (player->buried) // do not reanimate dead player
5598 if (!player_relocated) // no need to relocate the player
5601 if (IS_PLAYER(jx, jy)) // player already placed at new position
5603 RemoveField(jx, jy); // temporarily remove newly placed player
5604 DrawLevelField(jx, jy);
5607 if (player->present)
5609 while (player->MovPos)
5611 ScrollPlayer(player, SCROLL_GO_ON);
5612 ScrollScreen(NULL, SCROLL_GO_ON);
5614 AdvanceFrameAndPlayerCounters(player->index_nr);
5618 BackToFront_WithFrameDelay(wait_delay_value);
5621 DrawPlayer(player); // needed here only to cleanup last field
5622 DrawLevelField(player->jx, player->jy); // remove player graphic
5624 player->is_moving = FALSE;
5627 if (IS_CUSTOM_ELEMENT(old_element))
5628 CheckElementChangeByPlayer(old_jx, old_jy, old_element,
5630 player->index_bit, leave_side);
5632 CheckTriggeredElementChangeByPlayer(old_jx, old_jy, old_element,
5634 player->index_bit, leave_side);
5636 Tile[jx][jy] = el_player;
5637 InitPlayerField(jx, jy, el_player, TRUE);
5639 /* "InitPlayerField()" above sets Tile[jx][jy] to EL_EMPTY, but it may be
5640 possible that the relocation target field did not contain a player element,
5641 but a walkable element, to which the new player was relocated -- in this
5642 case, restore that (already initialized!) element on the player field */
5643 if (!ELEM_IS_PLAYER(element)) // player may be set on walkable element
5645 Tile[jx][jy] = element; // restore previously existing element
5648 // only visually relocate centered player
5649 DrawRelocateScreen(old_jx, old_jy, player->jx, player->jy, player->MovDir,
5650 FALSE, level.instant_relocation);
5652 TestIfPlayerTouchesBadThing(jx, jy);
5653 TestIfPlayerTouchesCustomElement(jx, jy);
5655 if (IS_CUSTOM_ELEMENT(element))
5656 CheckElementChangeByPlayer(jx, jy, element, CE_ENTERED_BY_PLAYER,
5657 player->index_bit, enter_side);
5659 CheckTriggeredElementChangeByPlayer(jx, jy, element, CE_PLAYER_ENTERS_X,
5660 player->index_bit, enter_side);
5662 if (player->is_switching)
5664 /* ensure that relocation while still switching an element does not cause
5665 a new element to be treated as also switched directly after relocation
5666 (this is important for teleporter switches that teleport the player to
5667 a place where another teleporter switch is in the same direction, which
5668 would then incorrectly be treated as immediately switched before the
5669 direction key that caused the switch was released) */
5671 player->switch_x += jx - old_jx;
5672 player->switch_y += jy - old_jy;
5676 static void Explode(int ex, int ey, int phase, int mode)
5682 // !!! eliminate this variable !!!
5683 int delay = (game.emulation == EMU_SUPAPLEX ? 3 : 2);
5685 if (game.explosions_delayed)
5687 ExplodeField[ex][ey] = mode;
5691 if (phase == EX_PHASE_START) // initialize 'Store[][]' field
5693 int center_element = Tile[ex][ey];
5694 int artwork_element, explosion_element; // set these values later
5696 // remove things displayed in background while burning dynamite
5697 if (Back[ex][ey] != EL_EMPTY && !IS_INDESTRUCTIBLE(Back[ex][ey]))
5700 if (IS_MOVING(ex, ey) || IS_BLOCKED(ex, ey))
5702 // put moving element to center field (and let it explode there)
5703 center_element = MovingOrBlocked2Element(ex, ey);
5704 RemoveMovingField(ex, ey);
5705 Tile[ex][ey] = center_element;
5708 // now "center_element" is finally determined -- set related values now
5709 artwork_element = center_element; // for custom player artwork
5710 explosion_element = center_element; // for custom player artwork
5712 if (IS_PLAYER(ex, ey))
5714 int player_nr = GET_PLAYER_NR(StorePlayer[ex][ey]);
5716 artwork_element = stored_player[player_nr].artwork_element;
5718 if (level.use_explosion_element[player_nr])
5720 explosion_element = level.explosion_element[player_nr];
5721 artwork_element = explosion_element;
5725 if (mode == EX_TYPE_NORMAL ||
5726 mode == EX_TYPE_CENTER ||
5727 mode == EX_TYPE_CROSS)
5728 PlayLevelSoundElementAction(ex, ey, artwork_element, ACTION_EXPLODING);
5730 last_phase = element_info[explosion_element].explosion_delay + 1;
5732 for (y = ey - 1; y <= ey + 1; y++) for (x = ex - 1; x <= ex + 1; x++)
5734 int xx = x - ex + 1;
5735 int yy = y - ey + 1;
5738 if (!IN_LEV_FIELD(x, y) ||
5739 (mode & EX_TYPE_SINGLE_TILE && (x != ex || y != ey)) ||
5740 (mode == EX_TYPE_CROSS && (x != ex && y != ey)))
5743 element = Tile[x][y];
5745 if (IS_MOVING(x, y) || IS_BLOCKED(x, y))
5747 element = MovingOrBlocked2Element(x, y);
5749 if (!IS_EXPLOSION_PROOF(element))
5750 RemoveMovingField(x, y);
5753 // indestructible elements can only explode in center (but not flames)
5754 if ((IS_EXPLOSION_PROOF(element) && (x != ex || y != ey ||
5755 mode == EX_TYPE_BORDER)) ||
5756 element == EL_FLAMES)
5759 /* no idea why this was changed from 3.0.8 to 3.1.0 -- this causes buggy
5760 behaviour, for example when touching a yamyam that explodes to rocks
5761 with active deadly shield, a rock is created under the player !!! */
5762 // (case 1 (surely buggy): >= 3.1.0, case 2 (maybe buggy): <= 3.0.8)
5764 if (IS_PLAYER(x, y) && SHIELD_ON(PLAYERINFO(x, y)) &&
5765 (game.engine_version < VERSION_IDENT(3,1,0,0) ||
5766 (x == ex && y == ey && mode != EX_TYPE_BORDER)))
5768 if (IS_PLAYER(x, y) && SHIELD_ON(PLAYERINFO(x, y)))
5771 if (IS_ACTIVE_BOMB(element))
5773 // re-activate things under the bomb like gate or penguin
5774 Tile[x][y] = (Back[x][y] ? Back[x][y] : EL_EMPTY);
5781 // save walkable background elements while explosion on same tile
5782 if (IS_WALKABLE(element) && IS_INDESTRUCTIBLE(element) &&
5783 (x != ex || y != ey || mode == EX_TYPE_BORDER))
5784 Back[x][y] = element;
5786 // ignite explodable elements reached by other explosion
5787 if (element == EL_EXPLOSION)
5788 element = Store2[x][y];
5790 if (AmoebaNr[x][y] &&
5791 (element == EL_AMOEBA_FULL ||
5792 element == EL_BD_AMOEBA ||
5793 element == EL_AMOEBA_GROWING))
5795 AmoebaCnt[AmoebaNr[x][y]]--;
5796 AmoebaCnt2[AmoebaNr[x][y]]--;
5801 if (IS_PLAYER(ex, ey) && !PLAYER_EXPLOSION_PROTECTED(ex, ey))
5803 int player_nr = StorePlayer[ex][ey] - EL_PLAYER_1;
5805 Store[x][y] = EL_PLAYER_IS_EXPLODING_1 + player_nr;
5807 if (PLAYERINFO(ex, ey)->use_murphy)
5808 Store[x][y] = EL_EMPTY;
5811 // !!! check this case -- currently needed for rnd_rado_negundo_v,
5812 // !!! levels 015 018 019 020 021 022 023 026 027 028 !!!
5813 else if (ELEM_IS_PLAYER(center_element))
5814 Store[x][y] = EL_EMPTY;
5815 else if (center_element == EL_YAMYAM)
5816 Store[x][y] = level.yamyam_content[game.yamyam_content_nr].e[xx][yy];
5817 else if (element_info[center_element].content.e[xx][yy] != EL_EMPTY)
5818 Store[x][y] = element_info[center_element].content.e[xx][yy];
5820 // needed because EL_BD_BUTTERFLY is not defined as "CAN_EXPLODE"
5821 // (killing EL_BD_BUTTERFLY with dynamite would result in BD diamond
5822 // otherwise) -- FIX THIS !!!
5823 else if (!CAN_EXPLODE(element) && element != EL_BD_BUTTERFLY)
5824 Store[x][y] = element_info[element].content.e[1][1];
5826 else if (!CAN_EXPLODE(element))
5827 Store[x][y] = element_info[element].content.e[1][1];
5830 Store[x][y] = EL_EMPTY;
5832 if (x != ex || y != ey || mode == EX_TYPE_BORDER ||
5833 center_element == EL_AMOEBA_TO_DIAMOND)
5834 Store2[x][y] = element;
5836 Tile[x][y] = EL_EXPLOSION;
5837 GfxElement[x][y] = artwork_element;
5839 ExplodePhase[x][y] = 1;
5840 ExplodeDelay[x][y] = last_phase;
5845 if (center_element == EL_YAMYAM)
5846 game.yamyam_content_nr =
5847 (game.yamyam_content_nr + 1) % level.num_yamyam_contents;
5859 GfxFrame[x][y] = 0; // restart explosion animation
5861 last_phase = ExplodeDelay[x][y];
5863 ExplodePhase[x][y] = (phase < last_phase ? phase + 1 : 0);
5865 // this can happen if the player leaves an explosion just in time
5866 if (GfxElement[x][y] == EL_UNDEFINED)
5867 GfxElement[x][y] = EL_EMPTY;
5869 border_element = Store2[x][y];
5870 if (IS_PLAYER(x, y) && !PLAYER_EXPLOSION_PROTECTED(x, y))
5871 border_element = StorePlayer[x][y];
5873 if (phase == element_info[border_element].ignition_delay ||
5874 phase == last_phase)
5876 boolean border_explosion = FALSE;
5878 if (IS_PLAYER(x, y) && PLAYERINFO(x, y)->present &&
5879 !PLAYER_EXPLOSION_PROTECTED(x, y))
5881 KillPlayerUnlessExplosionProtected(x, y);
5882 border_explosion = TRUE;
5884 else if (CAN_EXPLODE_BY_EXPLOSION(border_element))
5886 Tile[x][y] = Store2[x][y];
5889 border_explosion = TRUE;
5891 else if (border_element == EL_AMOEBA_TO_DIAMOND)
5893 AmoebaToDiamond(x, y);
5895 border_explosion = TRUE;
5898 // if an element just explodes due to another explosion (chain-reaction),
5899 // do not immediately end the new explosion when it was the last frame of
5900 // the explosion (as it would be done in the following "if"-statement!)
5901 if (border_explosion && phase == last_phase)
5905 if (phase == last_phase)
5909 element = Tile[x][y] = Store[x][y];
5910 Store[x][y] = Store2[x][y] = 0;
5911 GfxElement[x][y] = EL_UNDEFINED;
5913 // player can escape from explosions and might therefore be still alive
5914 if (element >= EL_PLAYER_IS_EXPLODING_1 &&
5915 element <= EL_PLAYER_IS_EXPLODING_4)
5917 int player_nr = element - EL_PLAYER_IS_EXPLODING_1;
5918 int explosion_element = EL_PLAYER_1 + player_nr;
5919 int xx = MIN(MAX(0, x - stored_player[player_nr].jx + 1), 2);
5920 int yy = MIN(MAX(0, y - stored_player[player_nr].jy + 1), 2);
5922 if (level.use_explosion_element[player_nr])
5923 explosion_element = level.explosion_element[player_nr];
5925 Tile[x][y] = (stored_player[player_nr].active ? EL_EMPTY :
5926 element_info[explosion_element].content.e[xx][yy]);
5929 // restore probably existing indestructible background element
5930 if (Back[x][y] && IS_INDESTRUCTIBLE(Back[x][y]))
5931 element = Tile[x][y] = Back[x][y];
5934 MovDir[x][y] = MovPos[x][y] = MovDelay[x][y] = 0;
5935 GfxDir[x][y] = MV_NONE;
5936 ChangeDelay[x][y] = 0;
5937 ChangePage[x][y] = -1;
5939 CustomValue[x][y] = 0;
5941 InitField_WithBug2(x, y, FALSE);
5943 TEST_DrawLevelField(x, y);
5945 TestIfElementTouchesCustomElement(x, y);
5947 if (GFX_CRUMBLED(element))
5948 TEST_DrawLevelFieldCrumbledNeighbours(x, y);
5950 if (IS_PLAYER(x, y) && !PLAYERINFO(x, y)->present)
5951 StorePlayer[x][y] = 0;
5953 if (ELEM_IS_PLAYER(element))
5954 RelocatePlayer(x, y, element);
5956 else if (IN_SCR_FIELD(SCREENX(x), SCREENY(y)))
5958 int graphic = el_act2img(GfxElement[x][y], ACTION_EXPLODING);
5959 int frame = getGraphicAnimationFrame(graphic, GfxFrame[x][y]);
5962 TEST_DrawLevelFieldCrumbled(x, y);
5964 if (IS_WALKABLE_OVER(Back[x][y]) && Back[x][y] != EL_EMPTY)
5966 DrawLevelElement(x, y, Back[x][y]);
5967 DrawGraphicThruMask(SCREENX(x), SCREENY(y), graphic, frame);
5969 else if (IS_WALKABLE_UNDER(Back[x][y]))
5971 DrawGraphic(SCREENX(x), SCREENY(y), graphic, frame);
5972 DrawLevelElementThruMask(x, y, Back[x][y]);
5974 else if (!IS_WALKABLE_INSIDE(Back[x][y]))
5975 DrawScreenGraphic(SCREENX(x), SCREENY(y), graphic, frame);
5979 static void DynaExplode(int ex, int ey)
5982 int dynabomb_element = Tile[ex][ey];
5983 int dynabomb_size = 1;
5984 boolean dynabomb_xl = FALSE;
5985 struct PlayerInfo *player;
5986 static int xy[4][2] =
5994 if (IS_ACTIVE_BOMB(dynabomb_element))
5996 player = &stored_player[dynabomb_element - EL_DYNABOMB_PLAYER_1_ACTIVE];
5997 dynabomb_size = player->dynabomb_size;
5998 dynabomb_xl = player->dynabomb_xl;
5999 player->dynabombs_left++;
6002 Explode(ex, ey, EX_PHASE_START, EX_TYPE_CENTER);
6004 for (i = 0; i < NUM_DIRECTIONS; i++)
6006 for (j = 1; j <= dynabomb_size; j++)
6008 int x = ex + j * xy[i][0];
6009 int y = ey + j * xy[i][1];
6012 if (!IN_LEV_FIELD(x, y) || IS_INDESTRUCTIBLE(Tile[x][y]))
6015 element = Tile[x][y];
6017 // do not restart explosions of fields with active bombs
6018 if (element == EL_EXPLOSION && IS_ACTIVE_BOMB(Store2[x][y]))
6021 Explode(x, y, EX_PHASE_START, EX_TYPE_BORDER);
6023 if (element != EL_EMPTY && element != EL_EXPLOSION &&
6024 !IS_DIGGABLE(element) && !dynabomb_xl)
6030 void Bang(int x, int y)
6032 int element = MovingOrBlocked2Element(x, y);
6033 int explosion_type = EX_TYPE_NORMAL;
6035 if (IS_PLAYER(x, y) && !PLAYER_EXPLOSION_PROTECTED(x, y))
6037 struct PlayerInfo *player = PLAYERINFO(x, y);
6039 element = Tile[x][y] = player->initial_element;
6041 if (level.use_explosion_element[player->index_nr])
6043 int explosion_element = level.explosion_element[player->index_nr];
6045 if (element_info[explosion_element].explosion_type == EXPLODES_CROSS)
6046 explosion_type = EX_TYPE_CROSS;
6047 else if (element_info[explosion_element].explosion_type == EXPLODES_1X1)
6048 explosion_type = EX_TYPE_CENTER;
6056 case EL_BD_BUTTERFLY:
6059 case EL_DARK_YAMYAM:
6063 RaiseScoreElement(element);
6066 case EL_DYNABOMB_PLAYER_1_ACTIVE:
6067 case EL_DYNABOMB_PLAYER_2_ACTIVE:
6068 case EL_DYNABOMB_PLAYER_3_ACTIVE:
6069 case EL_DYNABOMB_PLAYER_4_ACTIVE:
6070 case EL_DYNABOMB_INCREASE_NUMBER:
6071 case EL_DYNABOMB_INCREASE_SIZE:
6072 case EL_DYNABOMB_INCREASE_POWER:
6073 explosion_type = EX_TYPE_DYNA;
6076 case EL_DC_LANDMINE:
6077 explosion_type = EX_TYPE_CENTER;
6082 case EL_LAMP_ACTIVE:
6083 case EL_AMOEBA_TO_DIAMOND:
6084 if (!IS_PLAYER(x, y)) // penguin and player may be at same field
6085 explosion_type = EX_TYPE_CENTER;
6089 if (element_info[element].explosion_type == EXPLODES_CROSS)
6090 explosion_type = EX_TYPE_CROSS;
6091 else if (element_info[element].explosion_type == EXPLODES_1X1)
6092 explosion_type = EX_TYPE_CENTER;
6096 if (explosion_type == EX_TYPE_DYNA)
6099 Explode(x, y, EX_PHASE_START, explosion_type);
6101 CheckTriggeredElementChange(x, y, element, CE_EXPLOSION_OF_X);
6104 static void SplashAcid(int x, int y)
6106 if (IN_LEV_FIELD(x - 1, y - 1) && IS_FREE(x - 1, y - 1) &&
6107 (!IN_LEV_FIELD(x - 1, y - 2) ||
6108 !CAN_FALL(MovingOrBlocked2Element(x - 1, y - 2))))
6109 Tile[x - 1][y - 1] = EL_ACID_SPLASH_LEFT;
6111 if (IN_LEV_FIELD(x + 1, y - 1) && IS_FREE(x + 1, y - 1) &&
6112 (!IN_LEV_FIELD(x + 1, y - 2) ||
6113 !CAN_FALL(MovingOrBlocked2Element(x + 1, y - 2))))
6114 Tile[x + 1][y - 1] = EL_ACID_SPLASH_RIGHT;
6116 PlayLevelSound(x, y, SND_ACID_SPLASHING);
6119 static void InitBeltMovement(void)
6121 static int belt_base_element[4] =
6123 EL_CONVEYOR_BELT_1_LEFT,
6124 EL_CONVEYOR_BELT_2_LEFT,
6125 EL_CONVEYOR_BELT_3_LEFT,
6126 EL_CONVEYOR_BELT_4_LEFT
6128 static int belt_base_active_element[4] =
6130 EL_CONVEYOR_BELT_1_LEFT_ACTIVE,
6131 EL_CONVEYOR_BELT_2_LEFT_ACTIVE,
6132 EL_CONVEYOR_BELT_3_LEFT_ACTIVE,
6133 EL_CONVEYOR_BELT_4_LEFT_ACTIVE
6138 // set frame order for belt animation graphic according to belt direction
6139 for (i = 0; i < NUM_BELTS; i++)
6143 for (j = 0; j < NUM_BELT_PARTS; j++)
6145 int element = belt_base_active_element[belt_nr] + j;
6146 int graphic_1 = el2img(element);
6147 int graphic_2 = el2panelimg(element);
6149 if (game.belt_dir[i] == MV_LEFT)
6151 graphic_info[graphic_1].anim_mode &= ~ANIM_REVERSE;
6152 graphic_info[graphic_2].anim_mode &= ~ANIM_REVERSE;
6156 graphic_info[graphic_1].anim_mode |= ANIM_REVERSE;
6157 graphic_info[graphic_2].anim_mode |= ANIM_REVERSE;
6162 SCAN_PLAYFIELD(x, y)
6164 int element = Tile[x][y];
6166 for (i = 0; i < NUM_BELTS; i++)
6168 if (IS_BELT(element) && game.belt_dir[i] != MV_NONE)
6170 int e_belt_nr = getBeltNrFromBeltElement(element);
6173 if (e_belt_nr == belt_nr)
6175 int belt_part = Tile[x][y] - belt_base_element[belt_nr];
6177 Tile[x][y] = belt_base_active_element[belt_nr] + belt_part;
6184 static void ToggleBeltSwitch(int x, int y)
6186 static int belt_base_element[4] =
6188 EL_CONVEYOR_BELT_1_LEFT,
6189 EL_CONVEYOR_BELT_2_LEFT,
6190 EL_CONVEYOR_BELT_3_LEFT,
6191 EL_CONVEYOR_BELT_4_LEFT
6193 static int belt_base_active_element[4] =
6195 EL_CONVEYOR_BELT_1_LEFT_ACTIVE,
6196 EL_CONVEYOR_BELT_2_LEFT_ACTIVE,
6197 EL_CONVEYOR_BELT_3_LEFT_ACTIVE,
6198 EL_CONVEYOR_BELT_4_LEFT_ACTIVE
6200 static int belt_base_switch_element[4] =
6202 EL_CONVEYOR_BELT_1_SWITCH_LEFT,
6203 EL_CONVEYOR_BELT_2_SWITCH_LEFT,
6204 EL_CONVEYOR_BELT_3_SWITCH_LEFT,
6205 EL_CONVEYOR_BELT_4_SWITCH_LEFT
6207 static int belt_move_dir[4] =
6215 int element = Tile[x][y];
6216 int belt_nr = getBeltNrFromBeltSwitchElement(element);
6217 int belt_dir_nr = (game.belt_dir_nr[belt_nr] + 1) % 4;
6218 int belt_dir = belt_move_dir[belt_dir_nr];
6221 if (!IS_BELT_SWITCH(element))
6224 game.belt_dir_nr[belt_nr] = belt_dir_nr;
6225 game.belt_dir[belt_nr] = belt_dir;
6227 if (belt_dir_nr == 3)
6230 // set frame order for belt animation graphic according to belt direction
6231 for (i = 0; i < NUM_BELT_PARTS; i++)
6233 int element = belt_base_active_element[belt_nr] + i;
6234 int graphic_1 = el2img(element);
6235 int graphic_2 = el2panelimg(element);
6237 if (belt_dir == MV_LEFT)
6239 graphic_info[graphic_1].anim_mode &= ~ANIM_REVERSE;
6240 graphic_info[graphic_2].anim_mode &= ~ANIM_REVERSE;
6244 graphic_info[graphic_1].anim_mode |= ANIM_REVERSE;
6245 graphic_info[graphic_2].anim_mode |= ANIM_REVERSE;
6249 SCAN_PLAYFIELD(xx, yy)
6251 int element = Tile[xx][yy];
6253 if (IS_BELT_SWITCH(element))
6255 int e_belt_nr = getBeltNrFromBeltSwitchElement(element);
6257 if (e_belt_nr == belt_nr)
6259 Tile[xx][yy] = belt_base_switch_element[belt_nr] + belt_dir_nr;
6260 TEST_DrawLevelField(xx, yy);
6263 else if (IS_BELT(element) && belt_dir != MV_NONE)
6265 int e_belt_nr = getBeltNrFromBeltElement(element);
6267 if (e_belt_nr == belt_nr)
6269 int belt_part = Tile[xx][yy] - belt_base_element[belt_nr];
6271 Tile[xx][yy] = belt_base_active_element[belt_nr] + belt_part;
6272 TEST_DrawLevelField(xx, yy);
6275 else if (IS_BELT_ACTIVE(element) && belt_dir == MV_NONE)
6277 int e_belt_nr = getBeltNrFromBeltActiveElement(element);
6279 if (e_belt_nr == belt_nr)
6281 int belt_part = Tile[xx][yy] - belt_base_active_element[belt_nr];
6283 Tile[xx][yy] = belt_base_element[belt_nr] + belt_part;
6284 TEST_DrawLevelField(xx, yy);
6290 static void ToggleSwitchgateSwitch(int x, int y)
6294 game.switchgate_pos = !game.switchgate_pos;
6296 SCAN_PLAYFIELD(xx, yy)
6298 int element = Tile[xx][yy];
6300 if (element == EL_SWITCHGATE_SWITCH_UP)
6302 Tile[xx][yy] = EL_SWITCHGATE_SWITCH_DOWN;
6303 TEST_DrawLevelField(xx, yy);
6305 else if (element == EL_SWITCHGATE_SWITCH_DOWN)
6307 Tile[xx][yy] = EL_SWITCHGATE_SWITCH_UP;
6308 TEST_DrawLevelField(xx, yy);
6310 else if (element == EL_DC_SWITCHGATE_SWITCH_UP)
6312 Tile[xx][yy] = EL_DC_SWITCHGATE_SWITCH_DOWN;
6313 TEST_DrawLevelField(xx, yy);
6315 else if (element == EL_DC_SWITCHGATE_SWITCH_DOWN)
6317 Tile[xx][yy] = EL_DC_SWITCHGATE_SWITCH_UP;
6318 TEST_DrawLevelField(xx, yy);
6320 else if (element == EL_SWITCHGATE_OPEN ||
6321 element == EL_SWITCHGATE_OPENING)
6323 Tile[xx][yy] = EL_SWITCHGATE_CLOSING;
6325 PlayLevelSoundAction(xx, yy, ACTION_CLOSING);
6327 else if (element == EL_SWITCHGATE_CLOSED ||
6328 element == EL_SWITCHGATE_CLOSING)
6330 Tile[xx][yy] = EL_SWITCHGATE_OPENING;
6332 PlayLevelSoundAction(xx, yy, ACTION_OPENING);
6337 static int getInvisibleActiveFromInvisibleElement(int element)
6339 return (element == EL_INVISIBLE_STEELWALL ? EL_INVISIBLE_STEELWALL_ACTIVE :
6340 element == EL_INVISIBLE_WALL ? EL_INVISIBLE_WALL_ACTIVE :
6341 element == EL_INVISIBLE_SAND ? EL_INVISIBLE_SAND_ACTIVE :
6345 static int getInvisibleFromInvisibleActiveElement(int element)
6347 return (element == EL_INVISIBLE_STEELWALL_ACTIVE ? EL_INVISIBLE_STEELWALL :
6348 element == EL_INVISIBLE_WALL_ACTIVE ? EL_INVISIBLE_WALL :
6349 element == EL_INVISIBLE_SAND_ACTIVE ? EL_INVISIBLE_SAND :
6353 static void RedrawAllLightSwitchesAndInvisibleElements(void)
6357 SCAN_PLAYFIELD(x, y)
6359 int element = Tile[x][y];
6361 if (element == EL_LIGHT_SWITCH &&
6362 game.light_time_left > 0)
6364 Tile[x][y] = EL_LIGHT_SWITCH_ACTIVE;
6365 TEST_DrawLevelField(x, y);
6367 else if (element == EL_LIGHT_SWITCH_ACTIVE &&
6368 game.light_time_left == 0)
6370 Tile[x][y] = EL_LIGHT_SWITCH;
6371 TEST_DrawLevelField(x, y);
6373 else if (element == EL_EMC_DRIPPER &&
6374 game.light_time_left > 0)
6376 Tile[x][y] = EL_EMC_DRIPPER_ACTIVE;
6377 TEST_DrawLevelField(x, y);
6379 else if (element == EL_EMC_DRIPPER_ACTIVE &&
6380 game.light_time_left == 0)
6382 Tile[x][y] = EL_EMC_DRIPPER;
6383 TEST_DrawLevelField(x, y);
6385 else if (element == EL_INVISIBLE_STEELWALL ||
6386 element == EL_INVISIBLE_WALL ||
6387 element == EL_INVISIBLE_SAND)
6389 if (game.light_time_left > 0)
6390 Tile[x][y] = getInvisibleActiveFromInvisibleElement(element);
6392 TEST_DrawLevelField(x, y);
6394 // uncrumble neighbour fields, if needed
6395 if (element == EL_INVISIBLE_SAND)
6396 TEST_DrawLevelFieldCrumbledNeighbours(x, y);
6398 else if (element == EL_INVISIBLE_STEELWALL_ACTIVE ||
6399 element == EL_INVISIBLE_WALL_ACTIVE ||
6400 element == EL_INVISIBLE_SAND_ACTIVE)
6402 if (game.light_time_left == 0)
6403 Tile[x][y] = getInvisibleFromInvisibleActiveElement(element);
6405 TEST_DrawLevelField(x, y);
6407 // re-crumble neighbour fields, if needed
6408 if (element == EL_INVISIBLE_SAND)
6409 TEST_DrawLevelFieldCrumbledNeighbours(x, y);
6414 static void RedrawAllInvisibleElementsForLenses(void)
6418 SCAN_PLAYFIELD(x, y)
6420 int element = Tile[x][y];
6422 if (element == EL_EMC_DRIPPER &&
6423 game.lenses_time_left > 0)
6425 Tile[x][y] = EL_EMC_DRIPPER_ACTIVE;
6426 TEST_DrawLevelField(x, y);
6428 else if (element == EL_EMC_DRIPPER_ACTIVE &&
6429 game.lenses_time_left == 0)
6431 Tile[x][y] = EL_EMC_DRIPPER;
6432 TEST_DrawLevelField(x, y);
6434 else if (element == EL_INVISIBLE_STEELWALL ||
6435 element == EL_INVISIBLE_WALL ||
6436 element == EL_INVISIBLE_SAND)
6438 if (game.lenses_time_left > 0)
6439 Tile[x][y] = getInvisibleActiveFromInvisibleElement(element);
6441 TEST_DrawLevelField(x, y);
6443 // uncrumble neighbour fields, if needed
6444 if (element == EL_INVISIBLE_SAND)
6445 TEST_DrawLevelFieldCrumbledNeighbours(x, y);
6447 else if (element == EL_INVISIBLE_STEELWALL_ACTIVE ||
6448 element == EL_INVISIBLE_WALL_ACTIVE ||
6449 element == EL_INVISIBLE_SAND_ACTIVE)
6451 if (game.lenses_time_left == 0)
6452 Tile[x][y] = getInvisibleFromInvisibleActiveElement(element);
6454 TEST_DrawLevelField(x, y);
6456 // re-crumble neighbour fields, if needed
6457 if (element == EL_INVISIBLE_SAND)
6458 TEST_DrawLevelFieldCrumbledNeighbours(x, y);
6463 static void RedrawAllInvisibleElementsForMagnifier(void)
6467 SCAN_PLAYFIELD(x, y)
6469 int element = Tile[x][y];
6471 if (element == EL_EMC_FAKE_GRASS &&
6472 game.magnify_time_left > 0)
6474 Tile[x][y] = EL_EMC_FAKE_GRASS_ACTIVE;
6475 TEST_DrawLevelField(x, y);
6477 else if (element == EL_EMC_FAKE_GRASS_ACTIVE &&
6478 game.magnify_time_left == 0)
6480 Tile[x][y] = EL_EMC_FAKE_GRASS;
6481 TEST_DrawLevelField(x, y);
6483 else if (IS_GATE_GRAY(element) &&
6484 game.magnify_time_left > 0)
6486 Tile[x][y] = (IS_RND_GATE_GRAY(element) ?
6487 element - EL_GATE_1_GRAY + EL_GATE_1_GRAY_ACTIVE :
6488 IS_EM_GATE_GRAY(element) ?
6489 element - EL_EM_GATE_1_GRAY + EL_EM_GATE_1_GRAY_ACTIVE :
6490 IS_EMC_GATE_GRAY(element) ?
6491 element - EL_EMC_GATE_5_GRAY + EL_EMC_GATE_5_GRAY_ACTIVE :
6492 IS_DC_GATE_GRAY(element) ?
6493 EL_DC_GATE_WHITE_GRAY_ACTIVE :
6495 TEST_DrawLevelField(x, y);
6497 else if (IS_GATE_GRAY_ACTIVE(element) &&
6498 game.magnify_time_left == 0)
6500 Tile[x][y] = (IS_RND_GATE_GRAY_ACTIVE(element) ?
6501 element - EL_GATE_1_GRAY_ACTIVE + EL_GATE_1_GRAY :
6502 IS_EM_GATE_GRAY_ACTIVE(element) ?
6503 element - EL_EM_GATE_1_GRAY_ACTIVE + EL_EM_GATE_1_GRAY :
6504 IS_EMC_GATE_GRAY_ACTIVE(element) ?
6505 element - EL_EMC_GATE_5_GRAY_ACTIVE + EL_EMC_GATE_5_GRAY :
6506 IS_DC_GATE_GRAY_ACTIVE(element) ?
6507 EL_DC_GATE_WHITE_GRAY :
6509 TEST_DrawLevelField(x, y);
6514 static void ToggleLightSwitch(int x, int y)
6516 int element = Tile[x][y];
6518 game.light_time_left =
6519 (element == EL_LIGHT_SWITCH ?
6520 level.time_light * FRAMES_PER_SECOND : 0);
6522 RedrawAllLightSwitchesAndInvisibleElements();
6525 static void ActivateTimegateSwitch(int x, int y)
6529 game.timegate_time_left = level.time_timegate * FRAMES_PER_SECOND;
6531 SCAN_PLAYFIELD(xx, yy)
6533 int element = Tile[xx][yy];
6535 if (element == EL_TIMEGATE_CLOSED ||
6536 element == EL_TIMEGATE_CLOSING)
6538 Tile[xx][yy] = EL_TIMEGATE_OPENING;
6539 PlayLevelSound(xx, yy, SND_CLASS_TIMEGATE_OPENING);
6543 else if (element == EL_TIMEGATE_SWITCH_ACTIVE)
6545 Tile[xx][yy] = EL_TIMEGATE_SWITCH;
6546 TEST_DrawLevelField(xx, yy);
6552 Tile[x][y] = (Tile[x][y] == EL_TIMEGATE_SWITCH ? EL_TIMEGATE_SWITCH_ACTIVE :
6553 EL_DC_TIMEGATE_SWITCH_ACTIVE);
6556 static void Impact(int x, int y)
6558 boolean last_line = (y == lev_fieldy - 1);
6559 boolean object_hit = FALSE;
6560 boolean impact = (last_line || object_hit);
6561 int element = Tile[x][y];
6562 int smashed = EL_STEELWALL;
6564 if (!last_line) // check if element below was hit
6566 if (Tile[x][y + 1] == EL_PLAYER_IS_LEAVING)
6569 object_hit = (!IS_FREE(x, y + 1) && (!IS_MOVING(x, y + 1) ||
6570 MovDir[x][y + 1] != MV_DOWN ||
6571 MovPos[x][y + 1] <= TILEY / 2));
6573 // do not smash moving elements that left the smashed field in time
6574 if (game.engine_version >= VERSION_IDENT(2,2,0,7) && IS_MOVING(x, y + 1) &&
6575 ABS(MovPos[x][y + 1] + getElementMoveStepsize(x, y + 1)) >= TILEX)
6578 #if USE_QUICKSAND_IMPACT_BUGFIX
6579 if (Tile[x][y + 1] == EL_QUICKSAND_EMPTYING && object_hit == FALSE)
6581 RemoveMovingField(x, y + 1);
6582 Tile[x][y + 1] = EL_QUICKSAND_EMPTY;
6583 Tile[x][y + 2] = EL_ROCK;
6584 TEST_DrawLevelField(x, y + 2);
6589 if (Tile[x][y + 1] == EL_QUICKSAND_FAST_EMPTYING && object_hit == FALSE)
6591 RemoveMovingField(x, y + 1);
6592 Tile[x][y + 1] = EL_QUICKSAND_FAST_EMPTY;
6593 Tile[x][y + 2] = EL_ROCK;
6594 TEST_DrawLevelField(x, y + 2);
6601 smashed = MovingOrBlocked2Element(x, y + 1);
6603 impact = (last_line || object_hit);
6606 if (!last_line && smashed == EL_ACID) // element falls into acid
6608 SplashAcid(x, y + 1);
6612 // !!! not sufficient for all cases -- see EL_PEARL below !!!
6613 // only reset graphic animation if graphic really changes after impact
6615 el_act_dir2img(element, GfxAction[x][y], MV_DOWN) != el2img(element))
6617 ResetGfxAnimation(x, y);
6618 TEST_DrawLevelField(x, y);
6621 if (impact && CAN_EXPLODE_IMPACT(element))
6626 else if (impact && element == EL_PEARL &&
6627 smashed != EL_DC_MAGIC_WALL && smashed != EL_DC_MAGIC_WALL_ACTIVE)
6629 ResetGfxAnimation(x, y);
6631 Tile[x][y] = EL_PEARL_BREAKING;
6632 PlayLevelSound(x, y, SND_PEARL_BREAKING);
6635 else if (impact && CheckElementChange(x, y, element, smashed, CE_IMPACT))
6637 PlayLevelSoundElementAction(x, y, element, ACTION_IMPACT);
6642 if (impact && element == EL_AMOEBA_DROP)
6644 if (object_hit && IS_PLAYER(x, y + 1))
6645 KillPlayerUnlessEnemyProtected(x, y + 1);
6646 else if (object_hit && smashed == EL_PENGUIN)
6650 Tile[x][y] = EL_AMOEBA_GROWING;
6651 Store[x][y] = EL_AMOEBA_WET;
6653 ResetRandomAnimationValue(x, y);
6658 if (object_hit) // check which object was hit
6660 if ((CAN_PASS_MAGIC_WALL(element) &&
6661 (smashed == EL_MAGIC_WALL ||
6662 smashed == EL_BD_MAGIC_WALL)) ||
6663 (CAN_PASS_DC_MAGIC_WALL(element) &&
6664 smashed == EL_DC_MAGIC_WALL))
6667 int activated_magic_wall =
6668 (smashed == EL_MAGIC_WALL ? EL_MAGIC_WALL_ACTIVE :
6669 smashed == EL_BD_MAGIC_WALL ? EL_BD_MAGIC_WALL_ACTIVE :
6670 EL_DC_MAGIC_WALL_ACTIVE);
6672 // activate magic wall / mill
6673 SCAN_PLAYFIELD(xx, yy)
6675 if (Tile[xx][yy] == smashed)
6676 Tile[xx][yy] = activated_magic_wall;
6679 game.magic_wall_time_left = level.time_magic_wall * FRAMES_PER_SECOND;
6680 game.magic_wall_active = TRUE;
6682 PlayLevelSound(x, y, (smashed == EL_MAGIC_WALL ?
6683 SND_MAGIC_WALL_ACTIVATING :
6684 smashed == EL_BD_MAGIC_WALL ?
6685 SND_BD_MAGIC_WALL_ACTIVATING :
6686 SND_DC_MAGIC_WALL_ACTIVATING));
6689 if (IS_PLAYER(x, y + 1))
6691 if (CAN_SMASH_PLAYER(element))
6693 KillPlayerUnlessEnemyProtected(x, y + 1);
6697 else if (smashed == EL_PENGUIN)
6699 if (CAN_SMASH_PLAYER(element))
6705 else if (element == EL_BD_DIAMOND)
6707 if (IS_CLASSIC_ENEMY(smashed) && IS_BD_ELEMENT(smashed))
6713 else if (((element == EL_SP_INFOTRON ||
6714 element == EL_SP_ZONK) &&
6715 (smashed == EL_SP_SNIKSNAK ||
6716 smashed == EL_SP_ELECTRON ||
6717 smashed == EL_SP_DISK_ORANGE)) ||
6718 (element == EL_SP_INFOTRON &&
6719 smashed == EL_SP_DISK_YELLOW))
6724 else if (CAN_SMASH_EVERYTHING(element))
6726 if (IS_CLASSIC_ENEMY(smashed) ||
6727 CAN_EXPLODE_SMASHED(smashed))
6732 else if (!IS_MOVING(x, y + 1) && !IS_BLOCKED(x, y + 1))
6734 if (smashed == EL_LAMP ||
6735 smashed == EL_LAMP_ACTIVE)
6740 else if (smashed == EL_NUT)
6742 Tile[x][y + 1] = EL_NUT_BREAKING;
6743 PlayLevelSound(x, y, SND_NUT_BREAKING);
6744 RaiseScoreElement(EL_NUT);
6747 else if (smashed == EL_PEARL)
6749 ResetGfxAnimation(x, y);
6751 Tile[x][y + 1] = EL_PEARL_BREAKING;
6752 PlayLevelSound(x, y, SND_PEARL_BREAKING);
6755 else if (smashed == EL_DIAMOND)
6757 Tile[x][y + 1] = EL_DIAMOND_BREAKING;
6758 PlayLevelSound(x, y, SND_DIAMOND_BREAKING);
6761 else if (IS_BELT_SWITCH(smashed))
6763 ToggleBeltSwitch(x, y + 1);
6765 else if (smashed == EL_SWITCHGATE_SWITCH_UP ||
6766 smashed == EL_SWITCHGATE_SWITCH_DOWN ||
6767 smashed == EL_DC_SWITCHGATE_SWITCH_UP ||
6768 smashed == EL_DC_SWITCHGATE_SWITCH_DOWN)
6770 ToggleSwitchgateSwitch(x, y + 1);
6772 else if (smashed == EL_LIGHT_SWITCH ||
6773 smashed == EL_LIGHT_SWITCH_ACTIVE)
6775 ToggleLightSwitch(x, y + 1);
6779 CheckElementChange(x, y + 1, smashed, element, CE_SMASHED);
6781 CheckElementChangeBySide(x, y + 1, smashed, element,
6782 CE_SWITCHED, CH_SIDE_TOP);
6783 CheckTriggeredElementChangeBySide(x, y + 1, smashed, CE_SWITCH_OF_X,
6789 CheckElementChange(x, y + 1, smashed, element, CE_SMASHED);
6794 // play sound of magic wall / mill
6796 (Tile[x][y + 1] == EL_MAGIC_WALL_ACTIVE ||
6797 Tile[x][y + 1] == EL_BD_MAGIC_WALL_ACTIVE ||
6798 Tile[x][y + 1] == EL_DC_MAGIC_WALL_ACTIVE))
6800 if (Tile[x][y + 1] == EL_MAGIC_WALL_ACTIVE)
6801 PlayLevelSound(x, y, SND_MAGIC_WALL_FILLING);
6802 else if (Tile[x][y + 1] == EL_BD_MAGIC_WALL_ACTIVE)
6803 PlayLevelSound(x, y, SND_BD_MAGIC_WALL_FILLING);
6804 else if (Tile[x][y + 1] == EL_DC_MAGIC_WALL_ACTIVE)
6805 PlayLevelSound(x, y, SND_DC_MAGIC_WALL_FILLING);
6810 // play sound of object that hits the ground
6811 if (last_line || object_hit)
6812 PlayLevelSoundElementAction(x, y, element, ACTION_IMPACT);
6815 static void TurnRoundExt(int x, int y)
6827 { 0, 0 }, { 0, 0 }, { 0, 0 },
6832 int left, right, back;
6836 { MV_DOWN, MV_UP, MV_RIGHT },
6837 { MV_UP, MV_DOWN, MV_LEFT },
6839 { MV_LEFT, MV_RIGHT, MV_DOWN },
6843 { MV_RIGHT, MV_LEFT, MV_UP }
6846 int element = Tile[x][y];
6847 int move_pattern = element_info[element].move_pattern;
6849 int old_move_dir = MovDir[x][y];
6850 int left_dir = turn[old_move_dir].left;
6851 int right_dir = turn[old_move_dir].right;
6852 int back_dir = turn[old_move_dir].back;
6854 int left_dx = move_xy[left_dir].dx, left_dy = move_xy[left_dir].dy;
6855 int right_dx = move_xy[right_dir].dx, right_dy = move_xy[right_dir].dy;
6856 int move_dx = move_xy[old_move_dir].dx, move_dy = move_xy[old_move_dir].dy;
6857 int back_dx = move_xy[back_dir].dx, back_dy = move_xy[back_dir].dy;
6859 int left_x = x + left_dx, left_y = y + left_dy;
6860 int right_x = x + right_dx, right_y = y + right_dy;
6861 int move_x = x + move_dx, move_y = y + move_dy;
6865 if (element == EL_BUG || element == EL_BD_BUTTERFLY)
6867 TestIfBadThingTouchesOtherBadThing(x, y);
6869 if (ENEMY_CAN_ENTER_FIELD(element, right_x, right_y))
6870 MovDir[x][y] = right_dir;
6871 else if (!ENEMY_CAN_ENTER_FIELD(element, move_x, move_y))
6872 MovDir[x][y] = left_dir;
6874 if (element == EL_BUG && MovDir[x][y] != old_move_dir)
6876 else if (element == EL_BD_BUTTERFLY) // && MovDir[x][y] == left_dir)
6879 else if (element == EL_SPACESHIP || element == EL_BD_FIREFLY)
6881 TestIfBadThingTouchesOtherBadThing(x, y);
6883 if (ENEMY_CAN_ENTER_FIELD(element, left_x, left_y))
6884 MovDir[x][y] = left_dir;
6885 else if (!ENEMY_CAN_ENTER_FIELD(element, move_x, move_y))
6886 MovDir[x][y] = right_dir;
6888 if (element == EL_SPACESHIP && MovDir[x][y] != old_move_dir)
6890 else if (element == EL_BD_FIREFLY) // && MovDir[x][y] == right_dir)
6893 else if (element == EL_SP_SNIKSNAK || element == EL_SP_ELECTRON)
6895 TestIfBadThingTouchesOtherBadThing(x, y);
6897 if (ELEMENT_CAN_ENTER_FIELD_BASE_4(element, left_x, left_y, 0))
6898 MovDir[x][y] = left_dir;
6899 else if (!ELEMENT_CAN_ENTER_FIELD_BASE_4(element, move_x, move_y, 0))
6900 MovDir[x][y] = right_dir;
6902 if (MovDir[x][y] != old_move_dir)
6905 else if (element == EL_YAMYAM)
6907 boolean can_turn_left = YAMYAM_CAN_ENTER_FIELD(element, left_x, left_y);
6908 boolean can_turn_right = YAMYAM_CAN_ENTER_FIELD(element, right_x, right_y);
6910 if (can_turn_left && can_turn_right)
6911 MovDir[x][y] = (RND(3) ? (RND(2) ? left_dir : right_dir) : back_dir);
6912 else if (can_turn_left)
6913 MovDir[x][y] = (RND(2) ? left_dir : back_dir);
6914 else if (can_turn_right)
6915 MovDir[x][y] = (RND(2) ? right_dir : back_dir);
6917 MovDir[x][y] = back_dir;
6919 MovDelay[x][y] = 16 + 16 * RND(3);
6921 else if (element == EL_DARK_YAMYAM)
6923 boolean can_turn_left = DARK_YAMYAM_CAN_ENTER_FIELD(element,
6925 boolean can_turn_right = DARK_YAMYAM_CAN_ENTER_FIELD(element,
6928 if (can_turn_left && can_turn_right)
6929 MovDir[x][y] = (RND(3) ? (RND(2) ? left_dir : right_dir) : back_dir);
6930 else if (can_turn_left)
6931 MovDir[x][y] = (RND(2) ? left_dir : back_dir);
6932 else if (can_turn_right)
6933 MovDir[x][y] = (RND(2) ? right_dir : back_dir);
6935 MovDir[x][y] = back_dir;
6937 MovDelay[x][y] = 16 + 16 * RND(3);
6939 else if (element == EL_PACMAN)
6941 boolean can_turn_left = PACMAN_CAN_ENTER_FIELD(element, left_x, left_y);
6942 boolean can_turn_right = PACMAN_CAN_ENTER_FIELD(element, right_x, right_y);
6944 if (can_turn_left && can_turn_right)
6945 MovDir[x][y] = (RND(3) ? (RND(2) ? left_dir : right_dir) : back_dir);
6946 else if (can_turn_left)
6947 MovDir[x][y] = (RND(2) ? left_dir : back_dir);
6948 else if (can_turn_right)
6949 MovDir[x][y] = (RND(2) ? right_dir : back_dir);
6951 MovDir[x][y] = back_dir;
6953 MovDelay[x][y] = 6 + RND(40);
6955 else if (element == EL_PIG)
6957 boolean can_turn_left = PIG_CAN_ENTER_FIELD(element, left_x, left_y);
6958 boolean can_turn_right = PIG_CAN_ENTER_FIELD(element, right_x, right_y);
6959 boolean can_move_on = PIG_CAN_ENTER_FIELD(element, move_x, move_y);
6960 boolean should_turn_left, should_turn_right, should_move_on;
6962 int rnd = RND(rnd_value);
6964 should_turn_left = (can_turn_left &&
6966 IN_LEV_FIELD_AND_NOT_FREE(x + back_dx + left_dx,
6967 y + back_dy + left_dy)));
6968 should_turn_right = (can_turn_right &&
6970 IN_LEV_FIELD_AND_NOT_FREE(x + back_dx + right_dx,
6971 y + back_dy + right_dy)));
6972 should_move_on = (can_move_on &&
6975 IN_LEV_FIELD_AND_NOT_FREE(x + move_dx + left_dx,
6976 y + move_dy + left_dy) ||
6977 IN_LEV_FIELD_AND_NOT_FREE(x + move_dx + right_dx,
6978 y + move_dy + right_dy)));
6980 if (should_turn_left || should_turn_right || should_move_on)
6982 if (should_turn_left && should_turn_right && should_move_on)
6983 MovDir[x][y] = (rnd < rnd_value / 3 ? left_dir :
6984 rnd < 2 * rnd_value / 3 ? right_dir :
6986 else if (should_turn_left && should_turn_right)
6987 MovDir[x][y] = (rnd < rnd_value / 2 ? left_dir : right_dir);
6988 else if (should_turn_left && should_move_on)
6989 MovDir[x][y] = (rnd < rnd_value / 2 ? left_dir : old_move_dir);
6990 else if (should_turn_right && should_move_on)
6991 MovDir[x][y] = (rnd < rnd_value / 2 ? right_dir : old_move_dir);
6992 else if (should_turn_left)
6993 MovDir[x][y] = left_dir;
6994 else if (should_turn_right)
6995 MovDir[x][y] = right_dir;
6996 else if (should_move_on)
6997 MovDir[x][y] = old_move_dir;
6999 else if (can_move_on && rnd > rnd_value / 8)
7000 MovDir[x][y] = old_move_dir;
7001 else if (can_turn_left && can_turn_right)
7002 MovDir[x][y] = (rnd < rnd_value / 2 ? left_dir : right_dir);
7003 else if (can_turn_left && rnd > rnd_value / 8)
7004 MovDir[x][y] = left_dir;
7005 else if (can_turn_right && rnd > rnd_value/8)
7006 MovDir[x][y] = right_dir;
7008 MovDir[x][y] = back_dir;
7010 xx = x + move_xy[MovDir[x][y]].dx;
7011 yy = y + move_xy[MovDir[x][y]].dy;
7013 if (!IN_LEV_FIELD(xx, yy) ||
7014 (!IS_FREE(xx, yy) && !IS_FOOD_PIG(Tile[xx][yy])))
7015 MovDir[x][y] = old_move_dir;
7019 else if (element == EL_DRAGON)
7021 boolean can_turn_left = DRAGON_CAN_ENTER_FIELD(element, left_x, left_y);
7022 boolean can_turn_right = DRAGON_CAN_ENTER_FIELD(element, right_x, right_y);
7023 boolean can_move_on = DRAGON_CAN_ENTER_FIELD(element, move_x, move_y);
7025 int rnd = RND(rnd_value);
7027 if (can_move_on && rnd > rnd_value / 8)
7028 MovDir[x][y] = old_move_dir;
7029 else if (can_turn_left && can_turn_right)
7030 MovDir[x][y] = (rnd < rnd_value / 2 ? left_dir : right_dir);
7031 else if (can_turn_left && rnd > rnd_value / 8)
7032 MovDir[x][y] = left_dir;
7033 else if (can_turn_right && rnd > rnd_value / 8)
7034 MovDir[x][y] = right_dir;
7036 MovDir[x][y] = back_dir;
7038 xx = x + move_xy[MovDir[x][y]].dx;
7039 yy = y + move_xy[MovDir[x][y]].dy;
7041 if (!IN_LEV_FIELD_AND_IS_FREE(xx, yy))
7042 MovDir[x][y] = old_move_dir;
7046 else if (element == EL_MOLE)
7048 boolean can_move_on =
7049 (MOLE_CAN_ENTER_FIELD(element, move_x, move_y,
7050 IS_AMOEBOID(Tile[move_x][move_y]) ||
7051 Tile[move_x][move_y] == EL_AMOEBA_SHRINKING));
7054 boolean can_turn_left =
7055 (MOLE_CAN_ENTER_FIELD(element, left_x, left_y,
7056 IS_AMOEBOID(Tile[left_x][left_y])));
7058 boolean can_turn_right =
7059 (MOLE_CAN_ENTER_FIELD(element, right_x, right_y,
7060 IS_AMOEBOID(Tile[right_x][right_y])));
7062 if (can_turn_left && can_turn_right)
7063 MovDir[x][y] = (RND(2) ? left_dir : right_dir);
7064 else if (can_turn_left)
7065 MovDir[x][y] = left_dir;
7067 MovDir[x][y] = right_dir;
7070 if (MovDir[x][y] != old_move_dir)
7073 else if (element == EL_BALLOON)
7075 MovDir[x][y] = game.wind_direction;
7078 else if (element == EL_SPRING)
7080 if (MovDir[x][y] & MV_HORIZONTAL)
7082 if (SPRING_CAN_BUMP_FROM_FIELD(move_x, move_y) &&
7083 !SPRING_CAN_ENTER_FIELD(element, x, y + 1))
7085 Tile[move_x][move_y] = EL_EMC_SPRING_BUMPER_ACTIVE;
7086 ResetGfxAnimation(move_x, move_y);
7087 TEST_DrawLevelField(move_x, move_y);
7089 MovDir[x][y] = back_dir;
7091 else if (!SPRING_CAN_ENTER_FIELD(element, move_x, move_y) ||
7092 SPRING_CAN_ENTER_FIELD(element, x, y + 1))
7093 MovDir[x][y] = MV_NONE;
7098 else if (element == EL_ROBOT ||
7099 element == EL_SATELLITE ||
7100 element == EL_PENGUIN ||
7101 element == EL_EMC_ANDROID)
7103 int attr_x = -1, attr_y = -1;
7105 if (game.all_players_gone)
7107 attr_x = game.exit_x;
7108 attr_y = game.exit_y;
7114 for (i = 0; i < MAX_PLAYERS; i++)
7116 struct PlayerInfo *player = &stored_player[i];
7117 int jx = player->jx, jy = player->jy;
7119 if (!player->active)
7123 ABS(jx - x) + ABS(jy - y) < ABS(attr_x - x) + ABS(attr_y - y))
7131 if (element == EL_ROBOT &&
7132 game.robot_wheel_x >= 0 &&
7133 game.robot_wheel_y >= 0 &&
7134 (Tile[game.robot_wheel_x][game.robot_wheel_y] == EL_ROBOT_WHEEL_ACTIVE ||
7135 game.engine_version < VERSION_IDENT(3,1,0,0)))
7137 attr_x = game.robot_wheel_x;
7138 attr_y = game.robot_wheel_y;
7141 if (element == EL_PENGUIN)
7144 static int xy[4][2] =
7152 for (i = 0; i < NUM_DIRECTIONS; i++)
7154 int ex = x + xy[i][0];
7155 int ey = y + xy[i][1];
7157 if (IN_LEV_FIELD(ex, ey) && (Tile[ex][ey] == EL_EXIT_OPEN ||
7158 Tile[ex][ey] == EL_EM_EXIT_OPEN ||
7159 Tile[ex][ey] == EL_STEEL_EXIT_OPEN ||
7160 Tile[ex][ey] == EL_EM_STEEL_EXIT_OPEN))
7169 MovDir[x][y] = MV_NONE;
7171 MovDir[x][y] |= (game.all_players_gone ? MV_RIGHT : MV_LEFT);
7172 else if (attr_x > x)
7173 MovDir[x][y] |= (game.all_players_gone ? MV_LEFT : MV_RIGHT);
7175 MovDir[x][y] |= (game.all_players_gone ? MV_DOWN : MV_UP);
7176 else if (attr_y > y)
7177 MovDir[x][y] |= (game.all_players_gone ? MV_UP : MV_DOWN);
7179 if (element == EL_ROBOT)
7183 if (MovDir[x][y] & MV_HORIZONTAL && MovDir[x][y] & MV_VERTICAL)
7184 MovDir[x][y] &= (RND(2) ? MV_HORIZONTAL : MV_VERTICAL);
7185 Moving2Blocked(x, y, &newx, &newy);
7187 if (IN_LEV_FIELD(newx, newy) && IS_FREE_OR_PLAYER(newx, newy))
7188 MovDelay[x][y] = 8 + 8 * !RND(3);
7190 MovDelay[x][y] = 16;
7192 else if (element == EL_PENGUIN)
7198 if (MovDir[x][y] & MV_HORIZONTAL && MovDir[x][y] & MV_VERTICAL)
7200 boolean first_horiz = RND(2);
7201 int new_move_dir = MovDir[x][y];
7204 new_move_dir & (first_horiz ? MV_HORIZONTAL : MV_VERTICAL);
7205 Moving2Blocked(x, y, &newx, &newy);
7207 if (PENGUIN_CAN_ENTER_FIELD(element, newx, newy))
7211 new_move_dir & (!first_horiz ? MV_HORIZONTAL : MV_VERTICAL);
7212 Moving2Blocked(x, y, &newx, &newy);
7214 if (PENGUIN_CAN_ENTER_FIELD(element, newx, newy))
7217 MovDir[x][y] = old_move_dir;
7221 else if (element == EL_SATELLITE)
7227 if (MovDir[x][y] & MV_HORIZONTAL && MovDir[x][y] & MV_VERTICAL)
7229 boolean first_horiz = RND(2);
7230 int new_move_dir = MovDir[x][y];
7233 new_move_dir & (first_horiz ? MV_HORIZONTAL : MV_VERTICAL);
7234 Moving2Blocked(x, y, &newx, &newy);
7236 if (SATELLITE_CAN_ENTER_FIELD(newx, newy))
7240 new_move_dir & (!first_horiz ? MV_HORIZONTAL : MV_VERTICAL);
7241 Moving2Blocked(x, y, &newx, &newy);
7243 if (SATELLITE_CAN_ENTER_FIELD(newx, newy))
7246 MovDir[x][y] = old_move_dir;
7250 else if (element == EL_EMC_ANDROID)
7252 static int check_pos[16] =
7254 -1, // 0 => (invalid)
7257 -1, // 3 => (invalid)
7259 0, // 5 => MV_LEFT | MV_UP
7260 2, // 6 => MV_RIGHT | MV_UP
7261 -1, // 7 => (invalid)
7263 6, // 9 => MV_LEFT | MV_DOWN
7264 4, // 10 => MV_RIGHT | MV_DOWN
7265 -1, // 11 => (invalid)
7266 -1, // 12 => (invalid)
7267 -1, // 13 => (invalid)
7268 -1, // 14 => (invalid)
7269 -1, // 15 => (invalid)
7277 { -1, -1, MV_LEFT | MV_UP },
7279 { +1, -1, MV_RIGHT | MV_UP },
7280 { +1, 0, MV_RIGHT },
7281 { +1, +1, MV_RIGHT | MV_DOWN },
7283 { -1, +1, MV_LEFT | MV_DOWN },
7286 int start_pos, check_order;
7287 boolean can_clone = FALSE;
7290 // check if there is any free field around current position
7291 for (i = 0; i < 8; i++)
7293 int newx = x + check_xy[i].dx;
7294 int newy = y + check_xy[i].dy;
7296 if (IN_LEV_FIELD_AND_IS_FREE(newx, newy))
7304 if (can_clone) // randomly find an element to clone
7308 start_pos = check_pos[RND(8)];
7309 check_order = (RND(2) ? -1 : +1);
7311 for (i = 0; i < 8; i++)
7313 int pos_raw = start_pos + i * check_order;
7314 int pos = (pos_raw + 8) % 8;
7315 int newx = x + check_xy[pos].dx;
7316 int newy = y + check_xy[pos].dy;
7318 if (ANDROID_CAN_CLONE_FIELD(newx, newy))
7320 element_info[element].move_leave_type = LEAVE_TYPE_LIMITED;
7321 element_info[element].move_leave_element = EL_TRIGGER_ELEMENT;
7323 Store[x][y] = Tile[newx][newy];
7332 if (can_clone) // randomly find a direction to move
7336 start_pos = check_pos[RND(8)];
7337 check_order = (RND(2) ? -1 : +1);
7339 for (i = 0; i < 8; i++)
7341 int pos_raw = start_pos + i * check_order;
7342 int pos = (pos_raw + 8) % 8;
7343 int newx = x + check_xy[pos].dx;
7344 int newy = y + check_xy[pos].dy;
7345 int new_move_dir = check_xy[pos].dir;
7347 if (IN_LEV_FIELD_AND_IS_FREE(newx, newy))
7349 MovDir[x][y] = new_move_dir;
7350 MovDelay[x][y] = level.android_clone_time * 8 + 1;
7359 if (can_clone) // cloning and moving successful
7362 // cannot clone -- try to move towards player
7364 start_pos = check_pos[MovDir[x][y] & 0x0f];
7365 check_order = (RND(2) ? -1 : +1);
7367 for (i = 0; i < 3; i++)
7369 // first check start_pos, then previous/next or (next/previous) pos
7370 int pos_raw = start_pos + (i < 2 ? i : -1) * check_order;
7371 int pos = (pos_raw + 8) % 8;
7372 int newx = x + check_xy[pos].dx;
7373 int newy = y + check_xy[pos].dy;
7374 int new_move_dir = check_xy[pos].dir;
7376 if (IS_PLAYER(newx, newy))
7379 if (ANDROID_CAN_ENTER_FIELD(element, newx, newy))
7381 MovDir[x][y] = new_move_dir;
7382 MovDelay[x][y] = level.android_move_time * 8 + 1;
7389 else if (move_pattern == MV_TURNING_LEFT ||
7390 move_pattern == MV_TURNING_RIGHT ||
7391 move_pattern == MV_TURNING_LEFT_RIGHT ||
7392 move_pattern == MV_TURNING_RIGHT_LEFT ||
7393 move_pattern == MV_TURNING_RANDOM ||
7394 move_pattern == MV_ALL_DIRECTIONS)
7396 boolean can_turn_left =
7397 CUSTOM_ELEMENT_CAN_ENTER_FIELD(element, left_x, left_y);
7398 boolean can_turn_right =
7399 CUSTOM_ELEMENT_CAN_ENTER_FIELD(element, right_x,right_y);
7401 if (element_info[element].move_stepsize == 0) // "not moving"
7404 if (move_pattern == MV_TURNING_LEFT)
7405 MovDir[x][y] = left_dir;
7406 else if (move_pattern == MV_TURNING_RIGHT)
7407 MovDir[x][y] = right_dir;
7408 else if (move_pattern == MV_TURNING_LEFT_RIGHT)
7409 MovDir[x][y] = (can_turn_left || !can_turn_right ? left_dir : right_dir);
7410 else if (move_pattern == MV_TURNING_RIGHT_LEFT)
7411 MovDir[x][y] = (can_turn_right || !can_turn_left ? right_dir : left_dir);
7412 else if (move_pattern == MV_TURNING_RANDOM)
7413 MovDir[x][y] = (can_turn_left && !can_turn_right ? left_dir :
7414 can_turn_right && !can_turn_left ? right_dir :
7415 RND(2) ? left_dir : right_dir);
7416 else if (can_turn_left && can_turn_right)
7417 MovDir[x][y] = (RND(3) ? (RND(2) ? left_dir : right_dir) : back_dir);
7418 else if (can_turn_left)
7419 MovDir[x][y] = (RND(2) ? left_dir : back_dir);
7420 else if (can_turn_right)
7421 MovDir[x][y] = (RND(2) ? right_dir : back_dir);
7423 MovDir[x][y] = back_dir;
7425 MovDelay[x][y] = GET_NEW_MOVE_DELAY(element);
7427 else if (move_pattern == MV_HORIZONTAL ||
7428 move_pattern == MV_VERTICAL)
7430 if (move_pattern & old_move_dir)
7431 MovDir[x][y] = back_dir;
7432 else if (move_pattern == MV_HORIZONTAL)
7433 MovDir[x][y] = (RND(2) ? MV_LEFT : MV_RIGHT);
7434 else if (move_pattern == MV_VERTICAL)
7435 MovDir[x][y] = (RND(2) ? MV_UP : MV_DOWN);
7437 MovDelay[x][y] = GET_NEW_MOVE_DELAY(element);
7439 else if (move_pattern & MV_ANY_DIRECTION)
7441 MovDir[x][y] = move_pattern;
7442 MovDelay[x][y] = GET_NEW_MOVE_DELAY(element);
7444 else if (move_pattern & MV_WIND_DIRECTION)
7446 MovDir[x][y] = game.wind_direction;
7447 MovDelay[x][y] = GET_NEW_MOVE_DELAY(element);
7449 else if (move_pattern == MV_ALONG_LEFT_SIDE)
7451 if (CUSTOM_ELEMENT_CAN_ENTER_FIELD(element, left_x, left_y))
7452 MovDir[x][y] = left_dir;
7453 else if (!CUSTOM_ELEMENT_CAN_ENTER_FIELD(element, move_x, move_y))
7454 MovDir[x][y] = right_dir;
7456 if (MovDir[x][y] != old_move_dir)
7457 MovDelay[x][y] = GET_NEW_MOVE_DELAY(element);
7459 else if (move_pattern == MV_ALONG_RIGHT_SIDE)
7461 if (CUSTOM_ELEMENT_CAN_ENTER_FIELD(element, right_x, right_y))
7462 MovDir[x][y] = right_dir;
7463 else if (!CUSTOM_ELEMENT_CAN_ENTER_FIELD(element, move_x, move_y))
7464 MovDir[x][y] = left_dir;
7466 if (MovDir[x][y] != old_move_dir)
7467 MovDelay[x][y] = GET_NEW_MOVE_DELAY(element);
7469 else if (move_pattern == MV_TOWARDS_PLAYER ||
7470 move_pattern == MV_AWAY_FROM_PLAYER)
7472 int attr_x = -1, attr_y = -1;
7474 boolean move_away = (move_pattern == MV_AWAY_FROM_PLAYER);
7476 if (game.all_players_gone)
7478 attr_x = game.exit_x;
7479 attr_y = game.exit_y;
7485 for (i = 0; i < MAX_PLAYERS; i++)
7487 struct PlayerInfo *player = &stored_player[i];
7488 int jx = player->jx, jy = player->jy;
7490 if (!player->active)
7494 ABS(jx - x) + ABS(jy - y) < ABS(attr_x - x) + ABS(attr_y - y))
7502 MovDir[x][y] = MV_NONE;
7504 MovDir[x][y] |= (move_away ? MV_RIGHT : MV_LEFT);
7505 else if (attr_x > x)
7506 MovDir[x][y] |= (move_away ? MV_LEFT : MV_RIGHT);
7508 MovDir[x][y] |= (move_away ? MV_DOWN : MV_UP);
7509 else if (attr_y > y)
7510 MovDir[x][y] |= (move_away ? MV_UP : MV_DOWN);
7512 MovDelay[x][y] = GET_NEW_MOVE_DELAY(element);
7514 if (MovDir[x][y] & MV_HORIZONTAL && MovDir[x][y] & MV_VERTICAL)
7516 boolean first_horiz = RND(2);
7517 int new_move_dir = MovDir[x][y];
7519 if (element_info[element].move_stepsize == 0) // "not moving"
7521 first_horiz = (ABS(attr_x - x) >= ABS(attr_y - y));
7522 MovDir[x][y] &= (first_horiz ? MV_HORIZONTAL : MV_VERTICAL);
7528 new_move_dir & (first_horiz ? MV_HORIZONTAL : MV_VERTICAL);
7529 Moving2Blocked(x, y, &newx, &newy);
7531 if (CUSTOM_ELEMENT_CAN_ENTER_FIELD(element, newx, newy))
7535 new_move_dir & (!first_horiz ? MV_HORIZONTAL : MV_VERTICAL);
7536 Moving2Blocked(x, y, &newx, &newy);
7538 if (CUSTOM_ELEMENT_CAN_ENTER_FIELD(element, newx, newy))
7541 MovDir[x][y] = old_move_dir;
7544 else if (move_pattern == MV_WHEN_PUSHED ||
7545 move_pattern == MV_WHEN_DROPPED)
7547 if (!CUSTOM_ELEMENT_CAN_ENTER_FIELD(element, move_x, move_y))
7548 MovDir[x][y] = MV_NONE;
7552 else if (move_pattern & MV_MAZE_RUNNER_STYLE)
7554 static int test_xy[7][2] =
7564 static int test_dir[7] =
7574 boolean hunter_mode = (move_pattern == MV_MAZE_HUNTER);
7575 int move_preference = -1000000; // start with very low preference
7576 int new_move_dir = MV_NONE;
7577 int start_test = RND(4);
7580 for (i = 0; i < NUM_DIRECTIONS; i++)
7582 int move_dir = test_dir[start_test + i];
7583 int move_dir_preference;
7585 xx = x + test_xy[start_test + i][0];
7586 yy = y + test_xy[start_test + i][1];
7588 if (hunter_mode && IN_LEV_FIELD(xx, yy) &&
7589 (IS_PLAYER(xx, yy) || Tile[xx][yy] == EL_PLAYER_IS_LEAVING))
7591 new_move_dir = move_dir;
7596 if (!CUSTOM_ELEMENT_CAN_ENTER_FIELD(element, xx, yy))
7599 move_dir_preference = -1 * RunnerVisit[xx][yy];
7600 if (hunter_mode && PlayerVisit[xx][yy] > 0)
7601 move_dir_preference = PlayerVisit[xx][yy];
7603 if (move_dir_preference > move_preference)
7605 // prefer field that has not been visited for the longest time
7606 move_preference = move_dir_preference;
7607 new_move_dir = move_dir;
7609 else if (move_dir_preference == move_preference &&
7610 move_dir == old_move_dir)
7612 // prefer last direction when all directions are preferred equally
7613 move_preference = move_dir_preference;
7614 new_move_dir = move_dir;
7618 MovDir[x][y] = new_move_dir;
7619 if (old_move_dir != new_move_dir)
7620 MovDelay[x][y] = GET_NEW_MOVE_DELAY(element);
7624 static void TurnRound(int x, int y)
7626 int direction = MovDir[x][y];
7630 GfxDir[x][y] = MovDir[x][y];
7632 if (direction != MovDir[x][y])
7636 GfxAction[x][y] = ACTION_TURNING_FROM_LEFT + MV_DIR_TO_BIT(direction);
7638 ResetGfxFrame(x, y);
7641 static boolean JustBeingPushed(int x, int y)
7645 for (i = 0; i < MAX_PLAYERS; i++)
7647 struct PlayerInfo *player = &stored_player[i];
7649 if (player->active && player->is_pushing && player->MovPos)
7651 int next_jx = player->jx + (player->jx - player->last_jx);
7652 int next_jy = player->jy + (player->jy - player->last_jy);
7654 if (x == next_jx && y == next_jy)
7662 static void StartMoving(int x, int y)
7664 boolean started_moving = FALSE; // some elements can fall _and_ move
7665 int element = Tile[x][y];
7670 if (MovDelay[x][y] == 0)
7671 GfxAction[x][y] = ACTION_DEFAULT;
7673 if (CAN_FALL(element) && y < lev_fieldy - 1)
7675 if ((x > 0 && IS_PLAYER(x - 1, y)) ||
7676 (x < lev_fieldx - 1 && IS_PLAYER(x + 1, y)))
7677 if (JustBeingPushed(x, y))
7680 if (element == EL_QUICKSAND_FULL)
7682 if (IS_FREE(x, y + 1))
7684 InitMovingField(x, y, MV_DOWN);
7685 started_moving = TRUE;
7687 Tile[x][y] = EL_QUICKSAND_EMPTYING;
7688 #if USE_QUICKSAND_BD_ROCK_BUGFIX
7689 if (Store[x][y] != EL_ROCK && Store[x][y] != EL_BD_ROCK)
7690 Store[x][y] = EL_ROCK;
7692 Store[x][y] = EL_ROCK;
7695 PlayLevelSoundAction(x, y, ACTION_EMPTYING);
7697 else if (Tile[x][y + 1] == EL_QUICKSAND_EMPTY)
7699 if (!MovDelay[x][y])
7701 MovDelay[x][y] = TILEY + 1;
7703 ResetGfxAnimation(x, y);
7704 ResetGfxAnimation(x, y + 1);
7709 DrawLevelElement(x, y, EL_QUICKSAND_EMPTYING);
7710 DrawLevelElement(x, y + 1, EL_QUICKSAND_FILLING);
7717 Tile[x][y] = EL_QUICKSAND_EMPTY;
7718 Tile[x][y + 1] = EL_QUICKSAND_FULL;
7719 Store[x][y + 1] = Store[x][y];
7722 PlayLevelSoundAction(x, y, ACTION_FILLING);
7724 else if (Tile[x][y + 1] == EL_QUICKSAND_FAST_EMPTY)
7726 if (!MovDelay[x][y])
7728 MovDelay[x][y] = TILEY + 1;
7730 ResetGfxAnimation(x, y);
7731 ResetGfxAnimation(x, y + 1);
7736 DrawLevelElement(x, y, EL_QUICKSAND_EMPTYING);
7737 DrawLevelElement(x, y + 1, EL_QUICKSAND_FAST_FILLING);
7744 Tile[x][y] = EL_QUICKSAND_EMPTY;
7745 Tile[x][y + 1] = EL_QUICKSAND_FAST_FULL;
7746 Store[x][y + 1] = Store[x][y];
7749 PlayLevelSoundAction(x, y, ACTION_FILLING);
7752 else if (element == EL_QUICKSAND_FAST_FULL)
7754 if (IS_FREE(x, y + 1))
7756 InitMovingField(x, y, MV_DOWN);
7757 started_moving = TRUE;
7759 Tile[x][y] = EL_QUICKSAND_FAST_EMPTYING;
7760 #if USE_QUICKSAND_BD_ROCK_BUGFIX
7761 if (Store[x][y] != EL_ROCK && Store[x][y] != EL_BD_ROCK)
7762 Store[x][y] = EL_ROCK;
7764 Store[x][y] = EL_ROCK;
7767 PlayLevelSoundAction(x, y, ACTION_EMPTYING);
7769 else if (Tile[x][y + 1] == EL_QUICKSAND_FAST_EMPTY)
7771 if (!MovDelay[x][y])
7773 MovDelay[x][y] = TILEY + 1;
7775 ResetGfxAnimation(x, y);
7776 ResetGfxAnimation(x, y + 1);
7781 DrawLevelElement(x, y, EL_QUICKSAND_FAST_EMPTYING);
7782 DrawLevelElement(x, y + 1, EL_QUICKSAND_FAST_FILLING);
7789 Tile[x][y] = EL_QUICKSAND_FAST_EMPTY;
7790 Tile[x][y + 1] = EL_QUICKSAND_FAST_FULL;
7791 Store[x][y + 1] = Store[x][y];
7794 PlayLevelSoundAction(x, y, ACTION_FILLING);
7796 else if (Tile[x][y + 1] == EL_QUICKSAND_EMPTY)
7798 if (!MovDelay[x][y])
7800 MovDelay[x][y] = TILEY + 1;
7802 ResetGfxAnimation(x, y);
7803 ResetGfxAnimation(x, y + 1);
7808 DrawLevelElement(x, y, EL_QUICKSAND_FAST_EMPTYING);
7809 DrawLevelElement(x, y + 1, EL_QUICKSAND_FILLING);
7816 Tile[x][y] = EL_QUICKSAND_FAST_EMPTY;
7817 Tile[x][y + 1] = EL_QUICKSAND_FULL;
7818 Store[x][y + 1] = Store[x][y];
7821 PlayLevelSoundAction(x, y, ACTION_FILLING);
7824 else if ((element == EL_ROCK || element == EL_BD_ROCK) &&
7825 Tile[x][y + 1] == EL_QUICKSAND_EMPTY)
7827 InitMovingField(x, y, MV_DOWN);
7828 started_moving = TRUE;
7830 Tile[x][y] = EL_QUICKSAND_FILLING;
7831 Store[x][y] = element;
7833 PlayLevelSoundAction(x, y, ACTION_FILLING);
7835 else if ((element == EL_ROCK || element == EL_BD_ROCK) &&
7836 Tile[x][y + 1] == EL_QUICKSAND_FAST_EMPTY)
7838 InitMovingField(x, y, MV_DOWN);
7839 started_moving = TRUE;
7841 Tile[x][y] = EL_QUICKSAND_FAST_FILLING;
7842 Store[x][y] = element;
7844 PlayLevelSoundAction(x, y, ACTION_FILLING);
7846 else if (element == EL_MAGIC_WALL_FULL)
7848 if (IS_FREE(x, y + 1))
7850 InitMovingField(x, y, MV_DOWN);
7851 started_moving = TRUE;
7853 Tile[x][y] = EL_MAGIC_WALL_EMPTYING;
7854 Store[x][y] = EL_CHANGED(Store[x][y]);
7856 else if (Tile[x][y + 1] == EL_MAGIC_WALL_ACTIVE)
7858 if (!MovDelay[x][y])
7859 MovDelay[x][y] = TILEY / 4 + 1;
7868 Tile[x][y] = EL_MAGIC_WALL_ACTIVE;
7869 Tile[x][y + 1] = EL_MAGIC_WALL_FULL;
7870 Store[x][y + 1] = EL_CHANGED(Store[x][y]);
7874 else if (element == EL_BD_MAGIC_WALL_FULL)
7876 if (IS_FREE(x, y + 1))
7878 InitMovingField(x, y, MV_DOWN);
7879 started_moving = TRUE;
7881 Tile[x][y] = EL_BD_MAGIC_WALL_EMPTYING;
7882 Store[x][y] = EL_CHANGED_BD(Store[x][y]);
7884 else if (Tile[x][y + 1] == EL_BD_MAGIC_WALL_ACTIVE)
7886 if (!MovDelay[x][y])
7887 MovDelay[x][y] = TILEY / 4 + 1;
7896 Tile[x][y] = EL_BD_MAGIC_WALL_ACTIVE;
7897 Tile[x][y + 1] = EL_BD_MAGIC_WALL_FULL;
7898 Store[x][y + 1] = EL_CHANGED_BD(Store[x][y]);
7902 else if (element == EL_DC_MAGIC_WALL_FULL)
7904 if (IS_FREE(x, y + 1))
7906 InitMovingField(x, y, MV_DOWN);
7907 started_moving = TRUE;
7909 Tile[x][y] = EL_DC_MAGIC_WALL_EMPTYING;
7910 Store[x][y] = EL_CHANGED_DC(Store[x][y]);
7912 else if (Tile[x][y + 1] == EL_DC_MAGIC_WALL_ACTIVE)
7914 if (!MovDelay[x][y])
7915 MovDelay[x][y] = TILEY / 4 + 1;
7924 Tile[x][y] = EL_DC_MAGIC_WALL_ACTIVE;
7925 Tile[x][y + 1] = EL_DC_MAGIC_WALL_FULL;
7926 Store[x][y + 1] = EL_CHANGED_DC(Store[x][y]);
7930 else if ((CAN_PASS_MAGIC_WALL(element) &&
7931 (Tile[x][y + 1] == EL_MAGIC_WALL_ACTIVE ||
7932 Tile[x][y + 1] == EL_BD_MAGIC_WALL_ACTIVE)) ||
7933 (CAN_PASS_DC_MAGIC_WALL(element) &&
7934 (Tile[x][y + 1] == EL_DC_MAGIC_WALL_ACTIVE)))
7937 InitMovingField(x, y, MV_DOWN);
7938 started_moving = TRUE;
7941 (Tile[x][y + 1] == EL_MAGIC_WALL_ACTIVE ? EL_MAGIC_WALL_FILLING :
7942 Tile[x][y + 1] == EL_BD_MAGIC_WALL_ACTIVE ? EL_BD_MAGIC_WALL_FILLING :
7943 EL_DC_MAGIC_WALL_FILLING);
7944 Store[x][y] = element;
7946 else if (CAN_FALL(element) && Tile[x][y + 1] == EL_ACID)
7948 SplashAcid(x, y + 1);
7950 InitMovingField(x, y, MV_DOWN);
7951 started_moving = TRUE;
7953 Store[x][y] = EL_ACID;
7956 (game.engine_version >= VERSION_IDENT(3,1,0,0) &&
7957 CheckImpact[x][y] && !IS_FREE(x, y + 1)) ||
7958 (game.engine_version >= VERSION_IDENT(3,0,7,0) &&
7959 CAN_FALL(element) && WasJustFalling[x][y] &&
7960 (Tile[x][y + 1] == EL_BLOCKED || IS_PLAYER(x, y + 1))) ||
7962 (game.engine_version < VERSION_IDENT(2,2,0,7) &&
7963 CAN_FALL(element) && WasJustMoving[x][y] && !Pushed[x][y + 1] &&
7964 (Tile[x][y + 1] == EL_BLOCKED)))
7966 /* this is needed for a special case not covered by calling "Impact()"
7967 from "ContinueMoving()": if an element moves to a tile directly below
7968 another element which was just falling on that tile (which was empty
7969 in the previous frame), the falling element above would just stop
7970 instead of smashing the element below (in previous version, the above
7971 element was just checked for "moving" instead of "falling", resulting
7972 in incorrect smashes caused by horizontal movement of the above
7973 element; also, the case of the player being the element to smash was
7974 simply not covered here... :-/ ) */
7976 CheckCollision[x][y] = 0;
7977 CheckImpact[x][y] = 0;
7981 else if (IS_FREE(x, y + 1) && element == EL_SPRING && level.use_spring_bug)
7983 if (MovDir[x][y] == MV_NONE)
7985 InitMovingField(x, y, MV_DOWN);
7986 started_moving = TRUE;
7989 else if (IS_FREE(x, y + 1) || Tile[x][y + 1] == EL_DIAMOND_BREAKING)
7991 if (WasJustFalling[x][y]) // prevent animation from being restarted
7992 MovDir[x][y] = MV_DOWN;
7994 InitMovingField(x, y, MV_DOWN);
7995 started_moving = TRUE;
7997 else if (element == EL_AMOEBA_DROP)
7999 Tile[x][y] = EL_AMOEBA_GROWING;
8000 Store[x][y] = EL_AMOEBA_WET;
8002 else if (((IS_SLIPPERY(Tile[x][y + 1]) && !IS_PLAYER(x, y + 1)) ||
8003 (IS_EM_SLIPPERY_WALL(Tile[x][y + 1]) && IS_GEM(element))) &&
8004 !IS_FALLING(x, y + 1) && !WasJustMoving[x][y + 1] &&
8005 element != EL_DX_SUPABOMB && element != EL_SP_DISK_ORANGE)
8007 boolean can_fall_left = (x > 0 && IS_FREE(x - 1, y) &&
8008 (IS_FREE(x - 1, y + 1) ||
8009 Tile[x - 1][y + 1] == EL_ACID));
8010 boolean can_fall_right = (x < lev_fieldx - 1 && IS_FREE(x + 1, y) &&
8011 (IS_FREE(x + 1, y + 1) ||
8012 Tile[x + 1][y + 1] == EL_ACID));
8013 boolean can_fall_any = (can_fall_left || can_fall_right);
8014 boolean can_fall_both = (can_fall_left && can_fall_right);
8015 int slippery_type = element_info[Tile[x][y + 1]].slippery_type;
8017 if (can_fall_any && slippery_type != SLIPPERY_ANY_RANDOM)
8019 if (slippery_type == SLIPPERY_ANY_LEFT_RIGHT && can_fall_both)
8020 can_fall_right = FALSE;
8021 else if (slippery_type == SLIPPERY_ANY_RIGHT_LEFT && can_fall_both)
8022 can_fall_left = FALSE;
8023 else if (slippery_type == SLIPPERY_ONLY_LEFT)
8024 can_fall_right = FALSE;
8025 else if (slippery_type == SLIPPERY_ONLY_RIGHT)
8026 can_fall_left = FALSE;
8028 can_fall_any = (can_fall_left || can_fall_right);
8029 can_fall_both = FALSE;
8034 if (element == EL_BD_ROCK || element == EL_BD_DIAMOND)
8035 can_fall_right = FALSE; // slip down on left side
8037 can_fall_left = !(can_fall_right = RND(2));
8039 can_fall_both = FALSE;
8044 // if not determined otherwise, prefer left side for slipping down
8045 InitMovingField(x, y, can_fall_left ? MV_LEFT : MV_RIGHT);
8046 started_moving = TRUE;
8049 else if (IS_BELT_ACTIVE(Tile[x][y + 1]))
8051 boolean left_is_free = (x > 0 && IS_FREE(x - 1, y));
8052 boolean right_is_free = (x < lev_fieldx - 1 && IS_FREE(x + 1, y));
8053 int belt_nr = getBeltNrFromBeltActiveElement(Tile[x][y + 1]);
8054 int belt_dir = game.belt_dir[belt_nr];
8056 if ((belt_dir == MV_LEFT && left_is_free) ||
8057 (belt_dir == MV_RIGHT && right_is_free))
8059 int nextx = (belt_dir == MV_LEFT ? x - 1 : x + 1);
8061 InitMovingField(x, y, belt_dir);
8062 started_moving = TRUE;
8064 Pushed[x][y] = TRUE;
8065 Pushed[nextx][y] = TRUE;
8067 GfxAction[x][y] = ACTION_DEFAULT;
8071 MovDir[x][y] = 0; // if element was moving, stop it
8076 // not "else if" because of elements that can fall and move (EL_SPRING)
8077 if (CAN_MOVE(element) && !started_moving)
8079 int move_pattern = element_info[element].move_pattern;
8082 Moving2Blocked(x, y, &newx, &newy);
8084 if (IS_PUSHABLE(element) && JustBeingPushed(x, y))
8087 if (game.engine_version >= VERSION_IDENT(3,1,0,0) &&
8088 CheckCollision[x][y] && !IN_LEV_FIELD_AND_IS_FREE(newx, newy))
8090 WasJustMoving[x][y] = 0;
8091 CheckCollision[x][y] = 0;
8093 TestIfElementHitsCustomElement(x, y, MovDir[x][y]);
8095 if (Tile[x][y] != element) // element has changed
8099 if (!MovDelay[x][y]) // start new movement phase
8101 // all objects that can change their move direction after each step
8102 // (YAMYAM, DARK_YAMYAM and PACMAN go straight until they hit a wall
8104 if (element != EL_YAMYAM &&
8105 element != EL_DARK_YAMYAM &&
8106 element != EL_PACMAN &&
8107 !(move_pattern & MV_ANY_DIRECTION) &&
8108 move_pattern != MV_TURNING_LEFT &&
8109 move_pattern != MV_TURNING_RIGHT &&
8110 move_pattern != MV_TURNING_LEFT_RIGHT &&
8111 move_pattern != MV_TURNING_RIGHT_LEFT &&
8112 move_pattern != MV_TURNING_RANDOM)
8116 if (MovDelay[x][y] && (element == EL_BUG ||
8117 element == EL_SPACESHIP ||
8118 element == EL_SP_SNIKSNAK ||
8119 element == EL_SP_ELECTRON ||
8120 element == EL_MOLE))
8121 TEST_DrawLevelField(x, y);
8125 if (MovDelay[x][y]) // wait some time before next movement
8129 if (element == EL_ROBOT ||
8130 element == EL_YAMYAM ||
8131 element == EL_DARK_YAMYAM)
8133 DrawLevelElementAnimationIfNeeded(x, y, element);
8134 PlayLevelSoundAction(x, y, ACTION_WAITING);
8136 else if (element == EL_SP_ELECTRON)
8137 DrawLevelElementAnimationIfNeeded(x, y, element);
8138 else if (element == EL_DRAGON)
8141 int dir = MovDir[x][y];
8142 int dx = (dir == MV_LEFT ? -1 : dir == MV_RIGHT ? +1 : 0);
8143 int dy = (dir == MV_UP ? -1 : dir == MV_DOWN ? +1 : 0);
8144 int graphic = (dir == MV_LEFT ? IMG_FLAMES_1_LEFT :
8145 dir == MV_RIGHT ? IMG_FLAMES_1_RIGHT :
8146 dir == MV_UP ? IMG_FLAMES_1_UP :
8147 dir == MV_DOWN ? IMG_FLAMES_1_DOWN : IMG_EMPTY);
8148 int frame = getGraphicAnimationFrame(graphic, GfxFrame[x][y]);
8150 GfxAction[x][y] = ACTION_ATTACKING;
8152 if (IS_PLAYER(x, y))
8153 DrawPlayerField(x, y);
8155 TEST_DrawLevelField(x, y);
8157 PlayLevelSoundActionIfLoop(x, y, ACTION_ATTACKING);
8159 for (i = 1; i <= 3; i++)
8161 int xx = x + i * dx;
8162 int yy = y + i * dy;
8163 int sx = SCREENX(xx);
8164 int sy = SCREENY(yy);
8165 int flame_graphic = graphic + (i - 1);
8167 if (!IN_LEV_FIELD(xx, yy) || IS_DRAGONFIRE_PROOF(Tile[xx][yy]))
8172 int flamed = MovingOrBlocked2Element(xx, yy);
8174 if (IS_CLASSIC_ENEMY(flamed) || CAN_EXPLODE_BY_DRAGONFIRE(flamed))
8177 RemoveMovingField(xx, yy);
8179 ChangeDelay[xx][yy] = 0;
8181 Tile[xx][yy] = EL_FLAMES;
8183 if (IN_SCR_FIELD(sx, sy))
8185 TEST_DrawLevelFieldCrumbled(xx, yy);
8186 DrawGraphic(sx, sy, flame_graphic, frame);
8191 if (Tile[xx][yy] == EL_FLAMES)
8192 Tile[xx][yy] = EL_EMPTY;
8193 TEST_DrawLevelField(xx, yy);
8198 if (MovDelay[x][y]) // element still has to wait some time
8200 PlayLevelSoundAction(x, y, ACTION_WAITING);
8206 // now make next step
8208 Moving2Blocked(x, y, &newx, &newy); // get next screen position
8210 if (DONT_COLLIDE_WITH(element) &&
8211 IN_LEV_FIELD(newx, newy) && IS_PLAYER(newx, newy) &&
8212 !PLAYER_ENEMY_PROTECTED(newx, newy))
8214 TestIfBadThingRunsIntoPlayer(x, y, MovDir[x][y]);
8219 else if (CAN_MOVE_INTO_ACID(element) &&
8220 IN_LEV_FIELD(newx, newy) && Tile[newx][newy] == EL_ACID &&
8221 !IS_MV_DIAGONAL(MovDir[x][y]) &&
8222 (MovDir[x][y] == MV_DOWN ||
8223 game.engine_version >= VERSION_IDENT(3,1,0,0)))
8225 SplashAcid(newx, newy);
8226 Store[x][y] = EL_ACID;
8228 else if (element == EL_PENGUIN && IN_LEV_FIELD(newx, newy))
8230 if (Tile[newx][newy] == EL_EXIT_OPEN ||
8231 Tile[newx][newy] == EL_EM_EXIT_OPEN ||
8232 Tile[newx][newy] == EL_STEEL_EXIT_OPEN ||
8233 Tile[newx][newy] == EL_EM_STEEL_EXIT_OPEN)
8236 TEST_DrawLevelField(x, y);
8238 PlayLevelSound(newx, newy, SND_PENGUIN_PASSING);
8239 if (IN_SCR_FIELD(SCREENX(newx), SCREENY(newy)))
8240 DrawGraphicThruMask(SCREENX(newx),SCREENY(newy), el2img(element), 0);
8242 game.friends_still_needed--;
8243 if (!game.friends_still_needed &&
8245 game.all_players_gone)
8250 else if (IS_FOOD_PENGUIN(Tile[newx][newy]))
8252 if (DigField(local_player, x, y, newx, newy, 0,0, DF_DIG) == MP_MOVING)
8253 TEST_DrawLevelField(newx, newy);
8255 GfxDir[x][y] = MovDir[x][y] = MV_NONE;
8257 else if (!IS_FREE(newx, newy))
8259 GfxAction[x][y] = ACTION_WAITING;
8261 if (IS_PLAYER(x, y))
8262 DrawPlayerField(x, y);
8264 TEST_DrawLevelField(x, y);
8269 else if (element == EL_PIG && IN_LEV_FIELD(newx, newy))
8271 if (IS_FOOD_PIG(Tile[newx][newy]))
8273 if (IS_MOVING(newx, newy))
8274 RemoveMovingField(newx, newy);
8277 Tile[newx][newy] = EL_EMPTY;
8278 TEST_DrawLevelField(newx, newy);
8281 PlayLevelSound(x, y, SND_PIG_DIGGING);
8283 else if (!IS_FREE(newx, newy))
8285 if (IS_PLAYER(x, y))
8286 DrawPlayerField(x, y);
8288 TEST_DrawLevelField(x, y);
8293 else if (element == EL_EMC_ANDROID && IN_LEV_FIELD(newx, newy))
8295 if (Store[x][y] != EL_EMPTY)
8297 boolean can_clone = FALSE;
8300 // check if element to clone is still there
8301 for (yy = y - 1; yy <= y + 1; yy++) for (xx = x - 1; xx <= x + 1; xx++)
8303 if (IN_LEV_FIELD(xx, yy) && Tile[xx][yy] == Store[x][y])
8311 // cannot clone or target field not free anymore -- do not clone
8312 if (!can_clone || !ANDROID_CAN_ENTER_FIELD(element, newx, newy))
8313 Store[x][y] = EL_EMPTY;
8316 if (ANDROID_CAN_ENTER_FIELD(element, newx, newy))
8318 if (IS_MV_DIAGONAL(MovDir[x][y]))
8320 int diagonal_move_dir = MovDir[x][y];
8321 int stored = Store[x][y];
8322 int change_delay = 8;
8325 // android is moving diagonally
8327 CreateField(x, y, EL_DIAGONAL_SHRINKING);
8329 Store[x][y] = (stored == EL_ACID ? EL_EMPTY : stored);
8330 GfxElement[x][y] = EL_EMC_ANDROID;
8331 GfxAction[x][y] = ACTION_SHRINKING;
8332 GfxDir[x][y] = diagonal_move_dir;
8333 ChangeDelay[x][y] = change_delay;
8335 graphic = el_act_dir2img(GfxElement[x][y], GfxAction[x][y],
8338 DrawLevelGraphicAnimation(x, y, graphic);
8339 PlayLevelSoundAction(x, y, ACTION_SHRINKING);
8341 if (Tile[newx][newy] == EL_ACID)
8343 SplashAcid(newx, newy);
8348 CreateField(newx, newy, EL_DIAGONAL_GROWING);
8350 Store[newx][newy] = EL_EMC_ANDROID;
8351 GfxElement[newx][newy] = EL_EMC_ANDROID;
8352 GfxAction[newx][newy] = ACTION_GROWING;
8353 GfxDir[newx][newy] = diagonal_move_dir;
8354 ChangeDelay[newx][newy] = change_delay;
8356 graphic = el_act_dir2img(GfxElement[newx][newy],
8357 GfxAction[newx][newy], GfxDir[newx][newy]);
8359 DrawLevelGraphicAnimation(newx, newy, graphic);
8360 PlayLevelSoundAction(newx, newy, ACTION_GROWING);
8366 Tile[newx][newy] = EL_EMPTY;
8367 TEST_DrawLevelField(newx, newy);
8369 PlayLevelSoundAction(x, y, ACTION_DIGGING);
8372 else if (!IS_FREE(newx, newy))
8377 else if (IS_CUSTOM_ELEMENT(element) &&
8378 CUSTOM_ELEMENT_CAN_ENTER_FIELD(element, newx, newy))
8380 if (!DigFieldByCE(newx, newy, element))
8383 if (move_pattern & MV_MAZE_RUNNER_STYLE)
8385 RunnerVisit[x][y] = FrameCounter;
8386 PlayerVisit[x][y] /= 8; // expire player visit path
8389 else if (element == EL_DRAGON && IN_LEV_FIELD(newx, newy))
8391 if (!IS_FREE(newx, newy))
8393 if (IS_PLAYER(x, y))
8394 DrawPlayerField(x, y);
8396 TEST_DrawLevelField(x, y);
8402 boolean wanna_flame = !RND(10);
8403 int dx = newx - x, dy = newy - y;
8404 int newx1 = newx + 1 * dx, newy1 = newy + 1 * dy;
8405 int newx2 = newx + 2 * dx, newy2 = newy + 2 * dy;
8406 int element1 = (IN_LEV_FIELD(newx1, newy1) ?
8407 MovingOrBlocked2Element(newx1, newy1) : EL_STEELWALL);
8408 int element2 = (IN_LEV_FIELD(newx2, newy2) ?
8409 MovingOrBlocked2Element(newx2, newy2) : EL_STEELWALL);
8412 IS_CLASSIC_ENEMY(element1) ||
8413 IS_CLASSIC_ENEMY(element2)) &&
8414 element1 != EL_DRAGON && element2 != EL_DRAGON &&
8415 element1 != EL_FLAMES && element2 != EL_FLAMES)
8417 ResetGfxAnimation(x, y);
8418 GfxAction[x][y] = ACTION_ATTACKING;
8420 if (IS_PLAYER(x, y))
8421 DrawPlayerField(x, y);
8423 TEST_DrawLevelField(x, y);
8425 PlayLevelSound(x, y, SND_DRAGON_ATTACKING);
8427 MovDelay[x][y] = 50;
8429 Tile[newx][newy] = EL_FLAMES;
8430 if (IN_LEV_FIELD(newx1, newy1) && Tile[newx1][newy1] == EL_EMPTY)
8431 Tile[newx1][newy1] = EL_FLAMES;
8432 if (IN_LEV_FIELD(newx2, newy2) && Tile[newx2][newy2] == EL_EMPTY)
8433 Tile[newx2][newy2] = EL_FLAMES;
8439 else if (element == EL_YAMYAM && IN_LEV_FIELD(newx, newy) &&
8440 Tile[newx][newy] == EL_DIAMOND)
8442 if (IS_MOVING(newx, newy))
8443 RemoveMovingField(newx, newy);
8446 Tile[newx][newy] = EL_EMPTY;
8447 TEST_DrawLevelField(newx, newy);
8450 PlayLevelSound(x, y, SND_YAMYAM_DIGGING);
8452 else if (element == EL_DARK_YAMYAM && IN_LEV_FIELD(newx, newy) &&
8453 IS_FOOD_DARK_YAMYAM(Tile[newx][newy]))
8455 if (AmoebaNr[newx][newy])
8457 AmoebaCnt2[AmoebaNr[newx][newy]]--;
8458 if (Tile[newx][newy] == EL_AMOEBA_FULL ||
8459 Tile[newx][newy] == EL_BD_AMOEBA)
8460 AmoebaCnt[AmoebaNr[newx][newy]]--;
8463 if (IS_MOVING(newx, newy))
8465 RemoveMovingField(newx, newy);
8469 Tile[newx][newy] = EL_EMPTY;
8470 TEST_DrawLevelField(newx, newy);
8473 PlayLevelSound(x, y, SND_DARK_YAMYAM_DIGGING);
8475 else if ((element == EL_PACMAN || element == EL_MOLE)
8476 && IN_LEV_FIELD(newx, newy) && IS_AMOEBOID(Tile[newx][newy]))
8478 if (AmoebaNr[newx][newy])
8480 AmoebaCnt2[AmoebaNr[newx][newy]]--;
8481 if (Tile[newx][newy] == EL_AMOEBA_FULL ||
8482 Tile[newx][newy] == EL_BD_AMOEBA)
8483 AmoebaCnt[AmoebaNr[newx][newy]]--;
8486 if (element == EL_MOLE)
8488 Tile[newx][newy] = EL_AMOEBA_SHRINKING;
8489 PlayLevelSound(x, y, SND_MOLE_DIGGING);
8491 ResetGfxAnimation(x, y);
8492 GfxAction[x][y] = ACTION_DIGGING;
8493 TEST_DrawLevelField(x, y);
8495 MovDelay[newx][newy] = 0; // start amoeba shrinking delay
8497 return; // wait for shrinking amoeba
8499 else // element == EL_PACMAN
8501 Tile[newx][newy] = EL_EMPTY;
8502 TEST_DrawLevelField(newx, newy);
8503 PlayLevelSound(x, y, SND_PACMAN_DIGGING);
8506 else if (element == EL_MOLE && IN_LEV_FIELD(newx, newy) &&
8507 (Tile[newx][newy] == EL_AMOEBA_SHRINKING ||
8508 (Tile[newx][newy] == EL_EMPTY && Stop[newx][newy])))
8510 // wait for shrinking amoeba to completely disappear
8513 else if (!IN_LEV_FIELD(newx, newy) || !IS_FREE(newx, newy))
8515 // object was running against a wall
8519 if (GFX_ELEMENT(element) != EL_SAND) // !!! FIX THIS (crumble) !!!
8520 DrawLevelElementAnimation(x, y, element);
8522 if (DONT_TOUCH(element))
8523 TestIfBadThingTouchesPlayer(x, y);
8528 InitMovingField(x, y, MovDir[x][y]);
8530 PlayLevelSoundAction(x, y, ACTION_MOVING);
8534 ContinueMoving(x, y);
8537 void ContinueMoving(int x, int y)
8539 int element = Tile[x][y];
8540 struct ElementInfo *ei = &element_info[element];
8541 int direction = MovDir[x][y];
8542 int dx = (direction == MV_LEFT ? -1 : direction == MV_RIGHT ? +1 : 0);
8543 int dy = (direction == MV_UP ? -1 : direction == MV_DOWN ? +1 : 0);
8544 int newx = x + dx, newy = y + dy;
8545 int stored = Store[x][y];
8546 int stored_new = Store[newx][newy];
8547 boolean pushed_by_player = (Pushed[x][y] && IS_PLAYER(x, y));
8548 boolean pushed_by_conveyor = (Pushed[x][y] && !IS_PLAYER(x, y));
8549 boolean last_line = (newy == lev_fieldy - 1);
8550 boolean use_step_delay = (GET_MAX_STEP_DELAY(element) != 0);
8552 if (pushed_by_player) // special case: moving object pushed by player
8554 MovPos[x][y] = SIGN(MovPos[x][y]) * (TILEX - ABS(PLAYERINFO(x,y)->MovPos));
8556 else if (use_step_delay) // special case: moving object has step delay
8558 if (!MovDelay[x][y])
8559 MovPos[x][y] += getElementMoveStepsize(x, y);
8564 MovDelay[x][y] = GET_NEW_STEP_DELAY(element);
8568 TEST_DrawLevelField(x, y);
8570 return; // element is still waiting
8573 else // normal case: generically moving object
8575 MovPos[x][y] += getElementMoveStepsize(x, y);
8578 if (ABS(MovPos[x][y]) < TILEX)
8580 TEST_DrawLevelField(x, y);
8582 return; // element is still moving
8585 // element reached destination field
8587 Tile[x][y] = EL_EMPTY;
8588 Tile[newx][newy] = element;
8589 MovPos[x][y] = 0; // force "not moving" for "crumbled sand"
8591 if (Store[x][y] == EL_ACID) // element is moving into acid pool
8593 element = Tile[newx][newy] = EL_ACID;
8595 else if (element == EL_MOLE)
8597 Tile[x][y] = EL_SAND;
8599 TEST_DrawLevelFieldCrumbledNeighbours(x, y);
8601 else if (element == EL_QUICKSAND_FILLING)
8603 element = Tile[newx][newy] = get_next_element(element);
8604 Store[newx][newy] = Store[x][y];
8606 else if (element == EL_QUICKSAND_EMPTYING)
8608 Tile[x][y] = get_next_element(element);
8609 element = Tile[newx][newy] = Store[x][y];
8611 else if (element == EL_QUICKSAND_FAST_FILLING)
8613 element = Tile[newx][newy] = get_next_element(element);
8614 Store[newx][newy] = Store[x][y];
8616 else if (element == EL_QUICKSAND_FAST_EMPTYING)
8618 Tile[x][y] = get_next_element(element);
8619 element = Tile[newx][newy] = Store[x][y];
8621 else if (element == EL_MAGIC_WALL_FILLING)
8623 element = Tile[newx][newy] = get_next_element(element);
8624 if (!game.magic_wall_active)
8625 element = Tile[newx][newy] = EL_MAGIC_WALL_DEAD;
8626 Store[newx][newy] = Store[x][y];
8628 else if (element == EL_MAGIC_WALL_EMPTYING)
8630 Tile[x][y] = get_next_element(element);
8631 if (!game.magic_wall_active)
8632 Tile[x][y] = EL_MAGIC_WALL_DEAD;
8633 element = Tile[newx][newy] = Store[x][y];
8635 InitField(newx, newy, FALSE);
8637 else if (element == EL_BD_MAGIC_WALL_FILLING)
8639 element = Tile[newx][newy] = get_next_element(element);
8640 if (!game.magic_wall_active)
8641 element = Tile[newx][newy] = EL_BD_MAGIC_WALL_DEAD;
8642 Store[newx][newy] = Store[x][y];
8644 else if (element == EL_BD_MAGIC_WALL_EMPTYING)
8646 Tile[x][y] = get_next_element(element);
8647 if (!game.magic_wall_active)
8648 Tile[x][y] = EL_BD_MAGIC_WALL_DEAD;
8649 element = Tile[newx][newy] = Store[x][y];
8651 InitField(newx, newy, FALSE);
8653 else if (element == EL_DC_MAGIC_WALL_FILLING)
8655 element = Tile[newx][newy] = get_next_element(element);
8656 if (!game.magic_wall_active)
8657 element = Tile[newx][newy] = EL_DC_MAGIC_WALL_DEAD;
8658 Store[newx][newy] = Store[x][y];
8660 else if (element == EL_DC_MAGIC_WALL_EMPTYING)
8662 Tile[x][y] = get_next_element(element);
8663 if (!game.magic_wall_active)
8664 Tile[x][y] = EL_DC_MAGIC_WALL_DEAD;
8665 element = Tile[newx][newy] = Store[x][y];
8667 InitField(newx, newy, FALSE);
8669 else if (element == EL_AMOEBA_DROPPING)
8671 Tile[x][y] = get_next_element(element);
8672 element = Tile[newx][newy] = Store[x][y];
8674 else if (element == EL_SOKOBAN_OBJECT)
8677 Tile[x][y] = Back[x][y];
8679 if (Back[newx][newy])
8680 Tile[newx][newy] = EL_SOKOBAN_FIELD_FULL;
8682 Back[x][y] = Back[newx][newy] = 0;
8685 Store[x][y] = EL_EMPTY;
8690 MovDelay[newx][newy] = 0;
8692 if (CAN_CHANGE_OR_HAS_ACTION(element))
8694 // copy element change control values to new field
8695 ChangeDelay[newx][newy] = ChangeDelay[x][y];
8696 ChangePage[newx][newy] = ChangePage[x][y];
8697 ChangeCount[newx][newy] = ChangeCount[x][y];
8698 ChangeEvent[newx][newy] = ChangeEvent[x][y];
8701 CustomValue[newx][newy] = CustomValue[x][y];
8703 ChangeDelay[x][y] = 0;
8704 ChangePage[x][y] = -1;
8705 ChangeCount[x][y] = 0;
8706 ChangeEvent[x][y] = -1;
8708 CustomValue[x][y] = 0;
8710 // copy animation control values to new field
8711 GfxFrame[newx][newy] = GfxFrame[x][y];
8712 GfxRandom[newx][newy] = GfxRandom[x][y]; // keep same random value
8713 GfxAction[newx][newy] = GfxAction[x][y]; // keep action one frame
8714 GfxDir[newx][newy] = GfxDir[x][y]; // keep element direction
8716 Pushed[x][y] = Pushed[newx][newy] = FALSE;
8718 // some elements can leave other elements behind after moving
8719 if (ei->move_leave_element != EL_EMPTY &&
8720 (ei->move_leave_type == LEAVE_TYPE_UNLIMITED || stored != EL_EMPTY) &&
8721 (!IS_PLAYER(x, y) || IS_WALKABLE(ei->move_leave_element)))
8723 int move_leave_element = ei->move_leave_element;
8725 // this makes it possible to leave the removed element again
8726 if (ei->move_leave_element == EL_TRIGGER_ELEMENT)
8727 move_leave_element = (stored == EL_ACID ? EL_EMPTY : stored);
8729 Tile[x][y] = move_leave_element;
8731 if (element_info[Tile[x][y]].move_direction_initial == MV_START_PREVIOUS)
8732 MovDir[x][y] = direction;
8734 InitField(x, y, FALSE);
8736 if (GFX_CRUMBLED(Tile[x][y]))
8737 TEST_DrawLevelFieldCrumbledNeighbours(x, y);
8739 if (ELEM_IS_PLAYER(move_leave_element))
8740 RelocatePlayer(x, y, move_leave_element);
8743 // do this after checking for left-behind element
8744 ResetGfxAnimation(x, y); // reset animation values for old field
8746 if (!CAN_MOVE(element) ||
8747 (CAN_FALL(element) && direction == MV_DOWN &&
8748 (element == EL_SPRING ||
8749 element_info[element].move_pattern == MV_WHEN_PUSHED ||
8750 element_info[element].move_pattern == MV_WHEN_DROPPED)))
8751 GfxDir[x][y] = MovDir[newx][newy] = 0;
8753 TEST_DrawLevelField(x, y);
8754 TEST_DrawLevelField(newx, newy);
8756 Stop[newx][newy] = TRUE; // ignore this element until the next frame
8758 // prevent pushed element from moving on in pushed direction
8759 if (pushed_by_player && CAN_MOVE(element) &&
8760 element_info[element].move_pattern & MV_ANY_DIRECTION &&
8761 !(element_info[element].move_pattern & direction))
8762 TurnRound(newx, newy);
8764 // prevent elements on conveyor belt from moving on in last direction
8765 if (pushed_by_conveyor && CAN_FALL(element) &&
8766 direction & MV_HORIZONTAL)
8767 MovDir[newx][newy] = 0;
8769 if (!pushed_by_player)
8771 int nextx = newx + dx, nexty = newy + dy;
8772 boolean check_collision_again = IN_LEV_FIELD_AND_IS_FREE(nextx, nexty);
8774 WasJustMoving[newx][newy] = CHECK_DELAY_MOVING;
8776 if (CAN_FALL(element) && direction == MV_DOWN)
8777 WasJustFalling[newx][newy] = CHECK_DELAY_FALLING;
8779 if ((!CAN_FALL(element) || direction == MV_DOWN) && check_collision_again)
8780 CheckCollision[newx][newy] = CHECK_DELAY_COLLISION;
8782 if (CAN_FALL(element) && direction == MV_DOWN && check_collision_again)
8783 CheckImpact[newx][newy] = CHECK_DELAY_IMPACT;
8786 if (DONT_TOUCH(element)) // object may be nasty to player or others
8788 TestIfBadThingTouchesPlayer(newx, newy);
8789 TestIfBadThingTouchesFriend(newx, newy);
8791 if (!IS_CUSTOM_ELEMENT(element))
8792 TestIfBadThingTouchesOtherBadThing(newx, newy);
8794 else if (element == EL_PENGUIN)
8795 TestIfFriendTouchesBadThing(newx, newy);
8797 if (DONT_GET_HIT_BY(element))
8799 TestIfGoodThingGetsHitByBadThing(newx, newy, direction);
8802 // give the player one last chance (one more frame) to move away
8803 if (CAN_FALL(element) && direction == MV_DOWN &&
8804 (last_line || (!IS_FREE(x, newy + 1) &&
8805 (!IS_PLAYER(x, newy + 1) ||
8806 game.engine_version < VERSION_IDENT(3,1,1,0)))))
8809 if (pushed_by_player && !game.use_change_when_pushing_bug)
8811 int push_side = MV_DIR_OPPOSITE(direction);
8812 struct PlayerInfo *player = PLAYERINFO(x, y);
8814 CheckElementChangeByPlayer(newx, newy, element, CE_PUSHED_BY_PLAYER,
8815 player->index_bit, push_side);
8816 CheckTriggeredElementChangeByPlayer(newx,newy, element, CE_PLAYER_PUSHES_X,
8817 player->index_bit, push_side);
8820 if (element == EL_EMC_ANDROID && pushed_by_player) // make another move
8821 MovDelay[newx][newy] = 1;
8823 CheckTriggeredElementChangeBySide(x, y, element, CE_MOVE_OF_X, direction);
8825 TestIfElementTouchesCustomElement(x, y); // empty or new element
8826 TestIfElementHitsCustomElement(newx, newy, direction);
8827 TestIfPlayerTouchesCustomElement(newx, newy);
8828 TestIfElementTouchesCustomElement(newx, newy);
8830 if (IS_CUSTOM_ELEMENT(element) && ei->move_enter_element != EL_EMPTY &&
8831 IS_EQUAL_OR_IN_GROUP(stored_new, ei->move_enter_element))
8832 CheckElementChangeBySide(newx, newy, element, stored_new, CE_DIGGING_X,
8833 MV_DIR_OPPOSITE(direction));
8836 int AmoebaNeighbourNr(int ax, int ay)
8839 int element = Tile[ax][ay];
8841 static int xy[4][2] =
8849 for (i = 0; i < NUM_DIRECTIONS; i++)
8851 int x = ax + xy[i][0];
8852 int y = ay + xy[i][1];
8854 if (!IN_LEV_FIELD(x, y))
8857 if (Tile[x][y] == element && AmoebaNr[x][y] > 0)
8858 group_nr = AmoebaNr[x][y];
8864 static void AmoebaMerge(int ax, int ay)
8866 int i, x, y, xx, yy;
8867 int new_group_nr = AmoebaNr[ax][ay];
8868 static int xy[4][2] =
8876 if (new_group_nr == 0)
8879 for (i = 0; i < NUM_DIRECTIONS; i++)
8884 if (!IN_LEV_FIELD(x, y))
8887 if ((Tile[x][y] == EL_AMOEBA_FULL ||
8888 Tile[x][y] == EL_BD_AMOEBA ||
8889 Tile[x][y] == EL_AMOEBA_DEAD) &&
8890 AmoebaNr[x][y] != new_group_nr)
8892 int old_group_nr = AmoebaNr[x][y];
8894 if (old_group_nr == 0)
8897 AmoebaCnt[new_group_nr] += AmoebaCnt[old_group_nr];
8898 AmoebaCnt[old_group_nr] = 0;
8899 AmoebaCnt2[new_group_nr] += AmoebaCnt2[old_group_nr];
8900 AmoebaCnt2[old_group_nr] = 0;
8902 SCAN_PLAYFIELD(xx, yy)
8904 if (AmoebaNr[xx][yy] == old_group_nr)
8905 AmoebaNr[xx][yy] = new_group_nr;
8911 void AmoebaToDiamond(int ax, int ay)
8915 if (Tile[ax][ay] == EL_AMOEBA_DEAD)
8917 int group_nr = AmoebaNr[ax][ay];
8922 Debug("game:playing:AmoebaToDiamond", "ax = %d, ay = %d", ax, ay);
8923 Debug("game:playing:AmoebaToDiamond", "This should never happen!");
8929 SCAN_PLAYFIELD(x, y)
8931 if (Tile[x][y] == EL_AMOEBA_DEAD && AmoebaNr[x][y] == group_nr)
8934 Tile[x][y] = EL_AMOEBA_TO_DIAMOND;
8938 PlayLevelSound(ax, ay, (IS_GEM(level.amoeba_content) ?
8939 SND_AMOEBA_TURNING_TO_GEM :
8940 SND_AMOEBA_TURNING_TO_ROCK));
8945 static int xy[4][2] =
8953 for (i = 0; i < NUM_DIRECTIONS; i++)
8958 if (!IN_LEV_FIELD(x, y))
8961 if (Tile[x][y] == EL_AMOEBA_TO_DIAMOND)
8963 PlayLevelSound(x, y, (IS_GEM(level.amoeba_content) ?
8964 SND_AMOEBA_TURNING_TO_GEM :
8965 SND_AMOEBA_TURNING_TO_ROCK));
8972 static void AmoebaToDiamondBD(int ax, int ay, int new_element)
8975 int group_nr = AmoebaNr[ax][ay];
8976 boolean done = FALSE;
8981 Debug("game:playing:AmoebaToDiamondBD", "ax = %d, ay = %d", ax, ay);
8982 Debug("game:playing:AmoebaToDiamondBD", "This should never happen!");
8988 SCAN_PLAYFIELD(x, y)
8990 if (AmoebaNr[x][y] == group_nr &&
8991 (Tile[x][y] == EL_AMOEBA_DEAD ||
8992 Tile[x][y] == EL_BD_AMOEBA ||
8993 Tile[x][y] == EL_AMOEBA_GROWING))
8996 Tile[x][y] = new_element;
8997 InitField(x, y, FALSE);
8998 TEST_DrawLevelField(x, y);
9004 PlayLevelSound(ax, ay, (new_element == EL_BD_ROCK ?
9005 SND_BD_AMOEBA_TURNING_TO_ROCK :
9006 SND_BD_AMOEBA_TURNING_TO_GEM));
9009 static void AmoebaGrowing(int x, int y)
9011 static unsigned int sound_delay = 0;
9012 static unsigned int sound_delay_value = 0;
9014 if (!MovDelay[x][y]) // start new growing cycle
9018 if (DelayReached(&sound_delay, sound_delay_value))
9020 PlayLevelSoundElementAction(x, y, Store[x][y], ACTION_GROWING);
9021 sound_delay_value = 30;
9025 if (MovDelay[x][y]) // wait some time before growing bigger
9028 if (MovDelay[x][y]/2 && IN_SCR_FIELD(SCREENX(x), SCREENY(y)))
9030 int frame = getGraphicAnimationFrame(IMG_AMOEBA_GROWING,
9031 6 - MovDelay[x][y]);
9033 DrawGraphic(SCREENX(x), SCREENY(y), IMG_AMOEBA_GROWING, frame);
9036 if (!MovDelay[x][y])
9038 Tile[x][y] = Store[x][y];
9040 TEST_DrawLevelField(x, y);
9045 static void AmoebaShrinking(int x, int y)
9047 static unsigned int sound_delay = 0;
9048 static unsigned int sound_delay_value = 0;
9050 if (!MovDelay[x][y]) // start new shrinking cycle
9054 if (DelayReached(&sound_delay, sound_delay_value))
9055 sound_delay_value = 30;
9058 if (MovDelay[x][y]) // wait some time before shrinking
9061 if (MovDelay[x][y]/2 && IN_SCR_FIELD(SCREENX(x), SCREENY(y)))
9063 int frame = getGraphicAnimationFrame(IMG_AMOEBA_SHRINKING,
9064 6 - MovDelay[x][y]);
9066 DrawGraphic(SCREENX(x), SCREENY(y), IMG_AMOEBA_SHRINKING, frame);
9069 if (!MovDelay[x][y])
9071 Tile[x][y] = EL_EMPTY;
9072 TEST_DrawLevelField(x, y);
9074 // don't let mole enter this field in this cycle;
9075 // (give priority to objects falling to this field from above)
9081 static void AmoebaReproduce(int ax, int ay)
9084 int element = Tile[ax][ay];
9085 int graphic = el2img(element);
9086 int newax = ax, neway = ay;
9087 boolean can_drop = (element == EL_AMOEBA_WET || element == EL_EMC_DRIPPER);
9088 static int xy[4][2] =
9096 if (!level.amoeba_speed && element != EL_EMC_DRIPPER)
9098 Tile[ax][ay] = EL_AMOEBA_DEAD;
9099 TEST_DrawLevelField(ax, ay);
9103 if (IS_ANIMATED(graphic))
9104 DrawLevelGraphicAnimationIfNeeded(ax, ay, graphic);
9106 if (!MovDelay[ax][ay]) // start making new amoeba field
9107 MovDelay[ax][ay] = RND(FRAMES_PER_SECOND * 25 / (1 + level.amoeba_speed));
9109 if (MovDelay[ax][ay]) // wait some time before making new amoeba
9112 if (MovDelay[ax][ay])
9116 if (can_drop) // EL_AMOEBA_WET or EL_EMC_DRIPPER
9119 int x = ax + xy[start][0];
9120 int y = ay + xy[start][1];
9122 if (!IN_LEV_FIELD(x, y))
9125 if (IS_FREE(x, y) ||
9126 CAN_GROW_INTO(Tile[x][y]) ||
9127 Tile[x][y] == EL_QUICKSAND_EMPTY ||
9128 Tile[x][y] == EL_QUICKSAND_FAST_EMPTY)
9134 if (newax == ax && neway == ay)
9137 else // normal or "filled" (BD style) amoeba
9140 boolean waiting_for_player = FALSE;
9142 for (i = 0; i < NUM_DIRECTIONS; i++)
9144 int j = (start + i) % 4;
9145 int x = ax + xy[j][0];
9146 int y = ay + xy[j][1];
9148 if (!IN_LEV_FIELD(x, y))
9151 if (IS_FREE(x, y) ||
9152 CAN_GROW_INTO(Tile[x][y]) ||
9153 Tile[x][y] == EL_QUICKSAND_EMPTY ||
9154 Tile[x][y] == EL_QUICKSAND_FAST_EMPTY)
9160 else if (IS_PLAYER(x, y))
9161 waiting_for_player = TRUE;
9164 if (newax == ax && neway == ay) // amoeba cannot grow
9166 if (i == 4 && (!waiting_for_player || element == EL_BD_AMOEBA))
9168 Tile[ax][ay] = EL_AMOEBA_DEAD;
9169 TEST_DrawLevelField(ax, ay);
9170 AmoebaCnt[AmoebaNr[ax][ay]]--;
9172 if (AmoebaCnt[AmoebaNr[ax][ay]] <= 0) // amoeba is completely dead
9174 if (element == EL_AMOEBA_FULL)
9175 AmoebaToDiamond(ax, ay);
9176 else if (element == EL_BD_AMOEBA)
9177 AmoebaToDiamondBD(ax, ay, level.amoeba_content);
9182 else if (element == EL_AMOEBA_FULL || element == EL_BD_AMOEBA)
9184 // amoeba gets larger by growing in some direction
9186 int new_group_nr = AmoebaNr[ax][ay];
9189 if (new_group_nr == 0)
9191 Debug("game:playing:AmoebaReproduce", "newax = %d, neway = %d",
9193 Debug("game:playing:AmoebaReproduce", "This should never happen!");
9199 AmoebaNr[newax][neway] = new_group_nr;
9200 AmoebaCnt[new_group_nr]++;
9201 AmoebaCnt2[new_group_nr]++;
9203 // if amoeba touches other amoeba(s) after growing, unify them
9204 AmoebaMerge(newax, neway);
9206 if (element == EL_BD_AMOEBA && AmoebaCnt2[new_group_nr] >= 200)
9208 AmoebaToDiamondBD(newax, neway, EL_BD_ROCK);
9214 if (!can_drop || neway < ay || !IS_FREE(newax, neway) ||
9215 (neway == lev_fieldy - 1 && newax != ax))
9217 Tile[newax][neway] = EL_AMOEBA_GROWING; // creation of new amoeba
9218 Store[newax][neway] = element;
9220 else if (neway == ay || element == EL_EMC_DRIPPER)
9222 Tile[newax][neway] = EL_AMOEBA_DROP; // drop left/right of amoeba
9224 PlayLevelSoundAction(newax, neway, ACTION_GROWING);
9228 InitMovingField(ax, ay, MV_DOWN); // drop dripping from amoeba
9229 Tile[ax][ay] = EL_AMOEBA_DROPPING;
9230 Store[ax][ay] = EL_AMOEBA_DROP;
9231 ContinueMoving(ax, ay);
9235 TEST_DrawLevelField(newax, neway);
9238 static void Life(int ax, int ay)
9242 int element = Tile[ax][ay];
9243 int graphic = el2img(element);
9244 int *life_parameter = (element == EL_GAME_OF_LIFE ? level.game_of_life :
9246 boolean changed = FALSE;
9248 if (IS_ANIMATED(graphic))
9249 DrawLevelGraphicAnimationIfNeeded(ax, ay, graphic);
9254 if (!MovDelay[ax][ay]) // start new "game of life" cycle
9255 MovDelay[ax][ay] = life_time;
9257 if (MovDelay[ax][ay]) // wait some time before next cycle
9260 if (MovDelay[ax][ay])
9264 for (y1 = -1; y1 < 2; y1++) for (x1 = -1; x1 < 2; x1++)
9266 int xx = ax+x1, yy = ay+y1;
9267 int old_element = Tile[xx][yy];
9268 int num_neighbours = 0;
9270 if (!IN_LEV_FIELD(xx, yy))
9273 for (y2 = -1; y2 < 2; y2++) for (x2 = -1; x2 < 2; x2++)
9275 int x = xx+x2, y = yy+y2;
9277 if (!IN_LEV_FIELD(x, y) || (x == xx && y == yy))
9280 boolean is_player_cell = (element == EL_GAME_OF_LIFE && IS_PLAYER(x, y));
9281 boolean is_neighbour = FALSE;
9283 if (level.use_life_bugs)
9285 (((Tile[x][y] == element || is_player_cell) && !Stop[x][y]) ||
9286 (IS_FREE(x, y) && Stop[x][y]));
9289 (Last[x][y] == element || is_player_cell);
9295 boolean is_free = FALSE;
9297 if (level.use_life_bugs)
9298 is_free = (IS_FREE(xx, yy));
9300 is_free = (IS_FREE(xx, yy) && Last[xx][yy] == EL_EMPTY);
9302 if (xx == ax && yy == ay) // field in the middle
9304 if (num_neighbours < life_parameter[0] ||
9305 num_neighbours > life_parameter[1])
9307 Tile[xx][yy] = EL_EMPTY;
9308 if (Tile[xx][yy] != old_element)
9309 TEST_DrawLevelField(xx, yy);
9310 Stop[xx][yy] = TRUE;
9314 else if (is_free || CAN_GROW_INTO(Tile[xx][yy]))
9315 { // free border field
9316 if (num_neighbours >= life_parameter[2] &&
9317 num_neighbours <= life_parameter[3])
9319 Tile[xx][yy] = element;
9320 MovDelay[xx][yy] = (element == EL_GAME_OF_LIFE ? 0 : life_time-1);
9321 if (Tile[xx][yy] != old_element)
9322 TEST_DrawLevelField(xx, yy);
9323 Stop[xx][yy] = TRUE;
9330 PlayLevelSound(ax, ay, element == EL_BIOMAZE ? SND_BIOMAZE_GROWING :
9331 SND_GAME_OF_LIFE_GROWING);
9334 static void InitRobotWheel(int x, int y)
9336 ChangeDelay[x][y] = level.time_wheel * FRAMES_PER_SECOND;
9339 static void RunRobotWheel(int x, int y)
9341 PlayLevelSound(x, y, SND_ROBOT_WHEEL_ACTIVE);
9344 static void StopRobotWheel(int x, int y)
9346 if (game.robot_wheel_x == x &&
9347 game.robot_wheel_y == y)
9349 game.robot_wheel_x = -1;
9350 game.robot_wheel_y = -1;
9351 game.robot_wheel_active = FALSE;
9355 static void InitTimegateWheel(int x, int y)
9357 ChangeDelay[x][y] = level.time_timegate * FRAMES_PER_SECOND;
9360 static void RunTimegateWheel(int x, int y)
9362 PlayLevelSound(x, y, SND_CLASS_TIMEGATE_SWITCH_ACTIVE);
9365 static void InitMagicBallDelay(int x, int y)
9367 ChangeDelay[x][y] = (level.ball_time + 1) * 8 + 1;
9370 static void ActivateMagicBall(int bx, int by)
9374 if (level.ball_random)
9376 int pos_border = RND(8); // select one of the eight border elements
9377 int pos_content = (pos_border > 3 ? pos_border + 1 : pos_border);
9378 int xx = pos_content % 3;
9379 int yy = pos_content / 3;
9384 if (IN_LEV_FIELD(x, y) && Tile[x][y] == EL_EMPTY)
9385 CreateField(x, y, level.ball_content[game.ball_content_nr].e[xx][yy]);
9389 for (y = by - 1; y <= by + 1; y++) for (x = bx - 1; x <= bx + 1; x++)
9391 int xx = x - bx + 1;
9392 int yy = y - by + 1;
9394 if (IN_LEV_FIELD(x, y) && Tile[x][y] == EL_EMPTY)
9395 CreateField(x, y, level.ball_content[game.ball_content_nr].e[xx][yy]);
9399 game.ball_content_nr = (game.ball_content_nr + 1) % level.num_ball_contents;
9402 static void CheckExit(int x, int y)
9404 if (game.gems_still_needed > 0 ||
9405 game.sokoban_fields_still_needed > 0 ||
9406 game.sokoban_objects_still_needed > 0 ||
9407 game.lights_still_needed > 0)
9409 int element = Tile[x][y];
9410 int graphic = el2img(element);
9412 if (IS_ANIMATED(graphic))
9413 DrawLevelGraphicAnimationIfNeeded(x, y, graphic);
9418 // do not re-open exit door closed after last player
9419 if (game.all_players_gone)
9422 Tile[x][y] = EL_EXIT_OPENING;
9424 PlayLevelSoundNearest(x, y, SND_CLASS_EXIT_OPENING);
9427 static void CheckExitEM(int x, int y)
9429 if (game.gems_still_needed > 0 ||
9430 game.sokoban_fields_still_needed > 0 ||
9431 game.sokoban_objects_still_needed > 0 ||
9432 game.lights_still_needed > 0)
9434 int element = Tile[x][y];
9435 int graphic = el2img(element);
9437 if (IS_ANIMATED(graphic))
9438 DrawLevelGraphicAnimationIfNeeded(x, y, graphic);
9443 // do not re-open exit door closed after last player
9444 if (game.all_players_gone)
9447 Tile[x][y] = EL_EM_EXIT_OPENING;
9449 PlayLevelSoundNearest(x, y, SND_CLASS_EM_EXIT_OPENING);
9452 static void CheckExitSteel(int x, int y)
9454 if (game.gems_still_needed > 0 ||
9455 game.sokoban_fields_still_needed > 0 ||
9456 game.sokoban_objects_still_needed > 0 ||
9457 game.lights_still_needed > 0)
9459 int element = Tile[x][y];
9460 int graphic = el2img(element);
9462 if (IS_ANIMATED(graphic))
9463 DrawLevelGraphicAnimationIfNeeded(x, y, graphic);
9468 // do not re-open exit door closed after last player
9469 if (game.all_players_gone)
9472 Tile[x][y] = EL_STEEL_EXIT_OPENING;
9474 PlayLevelSoundNearest(x, y, SND_CLASS_STEEL_EXIT_OPENING);
9477 static void CheckExitSteelEM(int x, int y)
9479 if (game.gems_still_needed > 0 ||
9480 game.sokoban_fields_still_needed > 0 ||
9481 game.sokoban_objects_still_needed > 0 ||
9482 game.lights_still_needed > 0)
9484 int element = Tile[x][y];
9485 int graphic = el2img(element);
9487 if (IS_ANIMATED(graphic))
9488 DrawLevelGraphicAnimationIfNeeded(x, y, graphic);
9493 // do not re-open exit door closed after last player
9494 if (game.all_players_gone)
9497 Tile[x][y] = EL_EM_STEEL_EXIT_OPENING;
9499 PlayLevelSoundNearest(x, y, SND_CLASS_EM_STEEL_EXIT_OPENING);
9502 static void CheckExitSP(int x, int y)
9504 if (game.gems_still_needed > 0)
9506 int element = Tile[x][y];
9507 int graphic = el2img(element);
9509 if (IS_ANIMATED(graphic))
9510 DrawLevelGraphicAnimationIfNeeded(x, y, graphic);
9515 // do not re-open exit door closed after last player
9516 if (game.all_players_gone)
9519 Tile[x][y] = EL_SP_EXIT_OPENING;
9521 PlayLevelSoundNearest(x, y, SND_CLASS_SP_EXIT_OPENING);
9524 static void CloseAllOpenTimegates(void)
9528 SCAN_PLAYFIELD(x, y)
9530 int element = Tile[x][y];
9532 if (element == EL_TIMEGATE_OPEN || element == EL_TIMEGATE_OPENING)
9534 Tile[x][y] = EL_TIMEGATE_CLOSING;
9536 PlayLevelSoundAction(x, y, ACTION_CLOSING);
9541 static void DrawTwinkleOnField(int x, int y)
9543 if (!IN_SCR_FIELD(SCREENX(x), SCREENY(y)) || IS_MOVING(x, y))
9546 if (Tile[x][y] == EL_BD_DIAMOND)
9549 if (MovDelay[x][y] == 0) // next animation frame
9550 MovDelay[x][y] = 11 * !GetSimpleRandom(500);
9552 if (MovDelay[x][y] != 0) // wait some time before next frame
9556 DrawLevelElementAnimation(x, y, Tile[x][y]);
9558 if (MovDelay[x][y] != 0)
9560 int frame = getGraphicAnimationFrame(IMG_TWINKLE_WHITE,
9561 10 - MovDelay[x][y]);
9563 DrawGraphicThruMask(SCREENX(x), SCREENY(y), IMG_TWINKLE_WHITE, frame);
9568 static void MauerWaechst(int x, int y)
9572 if (!MovDelay[x][y]) // next animation frame
9573 MovDelay[x][y] = 3 * delay;
9575 if (MovDelay[x][y]) // wait some time before next frame
9579 if (IN_SCR_FIELD(SCREENX(x), SCREENY(y)))
9581 int graphic = el_dir2img(Tile[x][y], GfxDir[x][y]);
9582 int frame = getGraphicAnimationFrame(graphic, 17 - MovDelay[x][y]);
9584 DrawGraphic(SCREENX(x), SCREENY(y), graphic, frame);
9587 if (!MovDelay[x][y])
9589 if (MovDir[x][y] == MV_LEFT)
9591 if (IN_LEV_FIELD(x - 1, y) && IS_WALL(Tile[x - 1][y]))
9592 TEST_DrawLevelField(x - 1, y);
9594 else if (MovDir[x][y] == MV_RIGHT)
9596 if (IN_LEV_FIELD(x + 1, y) && IS_WALL(Tile[x + 1][y]))
9597 TEST_DrawLevelField(x + 1, y);
9599 else if (MovDir[x][y] == MV_UP)
9601 if (IN_LEV_FIELD(x, y - 1) && IS_WALL(Tile[x][y - 1]))
9602 TEST_DrawLevelField(x, y - 1);
9606 if (IN_LEV_FIELD(x, y + 1) && IS_WALL(Tile[x][y + 1]))
9607 TEST_DrawLevelField(x, y + 1);
9610 Tile[x][y] = Store[x][y];
9612 GfxDir[x][y] = MovDir[x][y] = MV_NONE;
9613 TEST_DrawLevelField(x, y);
9618 static void MauerAbleger(int ax, int ay)
9620 int element = Tile[ax][ay];
9621 int graphic = el2img(element);
9622 boolean oben_frei = FALSE, unten_frei = FALSE;
9623 boolean links_frei = FALSE, rechts_frei = FALSE;
9624 boolean oben_massiv = FALSE, unten_massiv = FALSE;
9625 boolean links_massiv = FALSE, rechts_massiv = FALSE;
9626 boolean new_wall = FALSE;
9628 if (IS_ANIMATED(graphic))
9629 DrawLevelGraphicAnimationIfNeeded(ax, ay, graphic);
9631 if (!MovDelay[ax][ay]) // start building new wall
9632 MovDelay[ax][ay] = 6;
9634 if (MovDelay[ax][ay]) // wait some time before building new wall
9637 if (MovDelay[ax][ay])
9641 if (IN_LEV_FIELD(ax, ay-1) && IS_FREE(ax, ay-1))
9643 if (IN_LEV_FIELD(ax, ay+1) && IS_FREE(ax, ay+1))
9645 if (IN_LEV_FIELD(ax-1, ay) && IS_FREE(ax-1, ay))
9647 if (IN_LEV_FIELD(ax+1, ay) && IS_FREE(ax+1, ay))
9650 if (element == EL_EXPANDABLE_WALL_VERTICAL ||
9651 element == EL_EXPANDABLE_WALL_ANY)
9655 Tile[ax][ay-1] = EL_EXPANDABLE_WALL_GROWING;
9656 Store[ax][ay-1] = element;
9657 GfxDir[ax][ay-1] = MovDir[ax][ay-1] = MV_UP;
9658 if (IN_SCR_FIELD(SCREENX(ax), SCREENY(ay-1)))
9659 DrawGraphic(SCREENX(ax), SCREENY(ay - 1),
9660 IMG_EXPANDABLE_WALL_GROWING_UP, 0);
9665 Tile[ax][ay+1] = EL_EXPANDABLE_WALL_GROWING;
9666 Store[ax][ay+1] = element;
9667 GfxDir[ax][ay+1] = MovDir[ax][ay+1] = MV_DOWN;
9668 if (IN_SCR_FIELD(SCREENX(ax), SCREENY(ay+1)))
9669 DrawGraphic(SCREENX(ax), SCREENY(ay + 1),
9670 IMG_EXPANDABLE_WALL_GROWING_DOWN, 0);
9675 if (element == EL_EXPANDABLE_WALL_HORIZONTAL ||
9676 element == EL_EXPANDABLE_WALL_ANY ||
9677 element == EL_EXPANDABLE_WALL ||
9678 element == EL_BD_EXPANDABLE_WALL)
9682 Tile[ax-1][ay] = EL_EXPANDABLE_WALL_GROWING;
9683 Store[ax-1][ay] = element;
9684 GfxDir[ax-1][ay] = MovDir[ax-1][ay] = MV_LEFT;
9685 if (IN_SCR_FIELD(SCREENX(ax-1), SCREENY(ay)))
9686 DrawGraphic(SCREENX(ax - 1), SCREENY(ay),
9687 IMG_EXPANDABLE_WALL_GROWING_LEFT, 0);
9693 Tile[ax+1][ay] = EL_EXPANDABLE_WALL_GROWING;
9694 Store[ax+1][ay] = element;
9695 GfxDir[ax+1][ay] = MovDir[ax+1][ay] = MV_RIGHT;
9696 if (IN_SCR_FIELD(SCREENX(ax+1), SCREENY(ay)))
9697 DrawGraphic(SCREENX(ax + 1), SCREENY(ay),
9698 IMG_EXPANDABLE_WALL_GROWING_RIGHT, 0);
9703 if (element == EL_EXPANDABLE_WALL && (links_frei || rechts_frei))
9704 TEST_DrawLevelField(ax, ay);
9706 if (!IN_LEV_FIELD(ax, ay-1) || IS_WALL(Tile[ax][ay-1]))
9708 if (!IN_LEV_FIELD(ax, ay+1) || IS_WALL(Tile[ax][ay+1]))
9709 unten_massiv = TRUE;
9710 if (!IN_LEV_FIELD(ax-1, ay) || IS_WALL(Tile[ax-1][ay]))
9711 links_massiv = TRUE;
9712 if (!IN_LEV_FIELD(ax+1, ay) || IS_WALL(Tile[ax+1][ay]))
9713 rechts_massiv = TRUE;
9715 if (((oben_massiv && unten_massiv) ||
9716 element == EL_EXPANDABLE_WALL_HORIZONTAL ||
9717 element == EL_EXPANDABLE_WALL) &&
9718 ((links_massiv && rechts_massiv) ||
9719 element == EL_EXPANDABLE_WALL_VERTICAL))
9720 Tile[ax][ay] = EL_WALL;
9723 PlayLevelSoundAction(ax, ay, ACTION_GROWING);
9726 static void MauerAblegerStahl(int ax, int ay)
9728 int element = Tile[ax][ay];
9729 int graphic = el2img(element);
9730 boolean oben_frei = FALSE, unten_frei = FALSE;
9731 boolean links_frei = FALSE, rechts_frei = FALSE;
9732 boolean oben_massiv = FALSE, unten_massiv = FALSE;
9733 boolean links_massiv = FALSE, rechts_massiv = FALSE;
9734 boolean new_wall = FALSE;
9736 if (IS_ANIMATED(graphic))
9737 DrawLevelGraphicAnimationIfNeeded(ax, ay, graphic);
9739 if (!MovDelay[ax][ay]) // start building new wall
9740 MovDelay[ax][ay] = 6;
9742 if (MovDelay[ax][ay]) // wait some time before building new wall
9745 if (MovDelay[ax][ay])
9749 if (IN_LEV_FIELD(ax, ay-1) && IS_FREE(ax, ay-1))
9751 if (IN_LEV_FIELD(ax, ay+1) && IS_FREE(ax, ay+1))
9753 if (IN_LEV_FIELD(ax-1, ay) && IS_FREE(ax-1, ay))
9755 if (IN_LEV_FIELD(ax+1, ay) && IS_FREE(ax+1, ay))
9758 if (element == EL_EXPANDABLE_STEELWALL_VERTICAL ||
9759 element == EL_EXPANDABLE_STEELWALL_ANY)
9763 Tile[ax][ay-1] = EL_EXPANDABLE_STEELWALL_GROWING;
9764 Store[ax][ay-1] = element;
9765 GfxDir[ax][ay-1] = MovDir[ax][ay-1] = MV_UP;
9766 if (IN_SCR_FIELD(SCREENX(ax), SCREENY(ay-1)))
9767 DrawGraphic(SCREENX(ax), SCREENY(ay - 1),
9768 IMG_EXPANDABLE_STEELWALL_GROWING_UP, 0);
9773 Tile[ax][ay+1] = EL_EXPANDABLE_STEELWALL_GROWING;
9774 Store[ax][ay+1] = element;
9775 GfxDir[ax][ay+1] = MovDir[ax][ay+1] = MV_DOWN;
9776 if (IN_SCR_FIELD(SCREENX(ax), SCREENY(ay+1)))
9777 DrawGraphic(SCREENX(ax), SCREENY(ay + 1),
9778 IMG_EXPANDABLE_STEELWALL_GROWING_DOWN, 0);
9783 if (element == EL_EXPANDABLE_STEELWALL_HORIZONTAL ||
9784 element == EL_EXPANDABLE_STEELWALL_ANY)
9788 Tile[ax-1][ay] = EL_EXPANDABLE_STEELWALL_GROWING;
9789 Store[ax-1][ay] = element;
9790 GfxDir[ax-1][ay] = MovDir[ax-1][ay] = MV_LEFT;
9791 if (IN_SCR_FIELD(SCREENX(ax-1), SCREENY(ay)))
9792 DrawGraphic(SCREENX(ax - 1), SCREENY(ay),
9793 IMG_EXPANDABLE_STEELWALL_GROWING_LEFT, 0);
9799 Tile[ax+1][ay] = EL_EXPANDABLE_STEELWALL_GROWING;
9800 Store[ax+1][ay] = element;
9801 GfxDir[ax+1][ay] = MovDir[ax+1][ay] = MV_RIGHT;
9802 if (IN_SCR_FIELD(SCREENX(ax+1), SCREENY(ay)))
9803 DrawGraphic(SCREENX(ax + 1), SCREENY(ay),
9804 IMG_EXPANDABLE_STEELWALL_GROWING_RIGHT, 0);
9809 if (!IN_LEV_FIELD(ax, ay-1) || IS_WALL(Tile[ax][ay-1]))
9811 if (!IN_LEV_FIELD(ax, ay+1) || IS_WALL(Tile[ax][ay+1]))
9812 unten_massiv = TRUE;
9813 if (!IN_LEV_FIELD(ax-1, ay) || IS_WALL(Tile[ax-1][ay]))
9814 links_massiv = TRUE;
9815 if (!IN_LEV_FIELD(ax+1, ay) || IS_WALL(Tile[ax+1][ay]))
9816 rechts_massiv = TRUE;
9818 if (((oben_massiv && unten_massiv) ||
9819 element == EL_EXPANDABLE_STEELWALL_HORIZONTAL) &&
9820 ((links_massiv && rechts_massiv) ||
9821 element == EL_EXPANDABLE_STEELWALL_VERTICAL))
9822 Tile[ax][ay] = EL_STEELWALL;
9825 PlayLevelSoundAction(ax, ay, ACTION_GROWING);
9828 static void CheckForDragon(int x, int y)
9831 boolean dragon_found = FALSE;
9832 static int xy[4][2] =
9840 for (i = 0; i < NUM_DIRECTIONS; i++)
9842 for (j = 0; j < 4; j++)
9844 int xx = x + j * xy[i][0], yy = y + j * xy[i][1];
9846 if (IN_LEV_FIELD(xx, yy) &&
9847 (Tile[xx][yy] == EL_FLAMES || Tile[xx][yy] == EL_DRAGON))
9849 if (Tile[xx][yy] == EL_DRAGON)
9850 dragon_found = TRUE;
9859 for (i = 0; i < NUM_DIRECTIONS; i++)
9861 for (j = 0; j < 3; j++)
9863 int xx = x + j * xy[i][0], yy = y + j * xy[i][1];
9865 if (IN_LEV_FIELD(xx, yy) && Tile[xx][yy] == EL_FLAMES)
9867 Tile[xx][yy] = EL_EMPTY;
9868 TEST_DrawLevelField(xx, yy);
9877 static void InitBuggyBase(int x, int y)
9879 int element = Tile[x][y];
9880 int activating_delay = FRAMES_PER_SECOND / 4;
9883 (element == EL_SP_BUGGY_BASE ?
9884 2 * FRAMES_PER_SECOND + RND(5 * FRAMES_PER_SECOND) - activating_delay :
9885 element == EL_SP_BUGGY_BASE_ACTIVATING ?
9887 element == EL_SP_BUGGY_BASE_ACTIVE ?
9888 1 * FRAMES_PER_SECOND + RND(1 * FRAMES_PER_SECOND) : 1);
9891 static void WarnBuggyBase(int x, int y)
9894 static int xy[4][2] =
9902 for (i = 0; i < NUM_DIRECTIONS; i++)
9904 int xx = x + xy[i][0];
9905 int yy = y + xy[i][1];
9907 if (IN_LEV_FIELD(xx, yy) && IS_PLAYER(xx, yy))
9909 PlayLevelSound(x, y, SND_SP_BUGGY_BASE_ACTIVE);
9916 static void InitTrap(int x, int y)
9918 ChangeDelay[x][y] = 2 * FRAMES_PER_SECOND + RND(5 * FRAMES_PER_SECOND);
9921 static void ActivateTrap(int x, int y)
9923 PlayLevelSound(x, y, SND_TRAP_ACTIVATING);
9926 static void ChangeActiveTrap(int x, int y)
9928 int graphic = IMG_TRAP_ACTIVE;
9930 // if new animation frame was drawn, correct crumbled sand border
9931 if (IS_NEW_FRAME(GfxFrame[x][y], graphic))
9932 TEST_DrawLevelFieldCrumbled(x, y);
9935 static int getSpecialActionElement(int element, int number, int base_element)
9937 return (element != EL_EMPTY ? element :
9938 number != -1 ? base_element + number - 1 :
9942 static int getModifiedActionNumber(int value_old, int operator, int operand,
9943 int value_min, int value_max)
9945 int value_new = (operator == CA_MODE_SET ? operand :
9946 operator == CA_MODE_ADD ? value_old + operand :
9947 operator == CA_MODE_SUBTRACT ? value_old - operand :
9948 operator == CA_MODE_MULTIPLY ? value_old * operand :
9949 operator == CA_MODE_DIVIDE ? value_old / MAX(1, operand) :
9950 operator == CA_MODE_MODULO ? value_old % MAX(1, operand) :
9953 return (value_new < value_min ? value_min :
9954 value_new > value_max ? value_max :
9958 static void ExecuteCustomElementAction(int x, int y, int element, int page)
9960 struct ElementInfo *ei = &element_info[element];
9961 struct ElementChangeInfo *change = &ei->change_page[page];
9962 int target_element = change->target_element;
9963 int action_type = change->action_type;
9964 int action_mode = change->action_mode;
9965 int action_arg = change->action_arg;
9966 int action_element = change->action_element;
9969 if (!change->has_action)
9972 // ---------- determine action paramater values -----------------------------
9974 int level_time_value =
9975 (level.time > 0 ? TimeLeft :
9978 int action_arg_element_raw =
9979 (action_arg == CA_ARG_PLAYER_TRIGGER ? change->actual_trigger_player :
9980 action_arg == CA_ARG_ELEMENT_TRIGGER ? change->actual_trigger_element :
9981 action_arg == CA_ARG_ELEMENT_TARGET ? change->target_element :
9982 action_arg == CA_ARG_ELEMENT_ACTION ? change->action_element :
9983 action_arg == CA_ARG_INVENTORY_RM_TRIGGER ? change->actual_trigger_element:
9984 action_arg == CA_ARG_INVENTORY_RM_TARGET ? change->target_element :
9985 action_arg == CA_ARG_INVENTORY_RM_ACTION ? change->action_element :
9987 int action_arg_element = GetElementFromGroupElement(action_arg_element_raw);
9989 int action_arg_direction =
9990 (action_arg >= CA_ARG_DIRECTION_LEFT &&
9991 action_arg <= CA_ARG_DIRECTION_DOWN ? action_arg - CA_ARG_DIRECTION :
9992 action_arg == CA_ARG_DIRECTION_TRIGGER ?
9993 change->actual_trigger_side :
9994 action_arg == CA_ARG_DIRECTION_TRIGGER_BACK ?
9995 MV_DIR_OPPOSITE(change->actual_trigger_side) :
9998 int action_arg_number_min =
9999 (action_type == CA_SET_PLAYER_SPEED ? STEPSIZE_NOT_MOVING :
10002 int action_arg_number_max =
10003 (action_type == CA_SET_PLAYER_SPEED ? STEPSIZE_EVEN_FASTER :
10004 action_type == CA_SET_LEVEL_GEMS ? 999 :
10005 action_type == CA_SET_LEVEL_TIME ? 9999 :
10006 action_type == CA_SET_LEVEL_SCORE ? 99999 :
10007 action_type == CA_SET_CE_VALUE ? 9999 :
10008 action_type == CA_SET_CE_SCORE ? 9999 :
10011 int action_arg_number_reset =
10012 (action_type == CA_SET_PLAYER_SPEED ? level.initial_player_stepsize[0] :
10013 action_type == CA_SET_LEVEL_GEMS ? level.gems_needed :
10014 action_type == CA_SET_LEVEL_TIME ? level.time :
10015 action_type == CA_SET_LEVEL_SCORE ? 0 :
10016 action_type == CA_SET_CE_VALUE ? GET_NEW_CE_VALUE(element) :
10017 action_type == CA_SET_CE_SCORE ? 0 :
10020 int action_arg_number =
10021 (action_arg <= CA_ARG_MAX ? action_arg :
10022 action_arg >= CA_ARG_SPEED_NOT_MOVING &&
10023 action_arg <= CA_ARG_SPEED_EVEN_FASTER ? (action_arg - CA_ARG_SPEED) :
10024 action_arg == CA_ARG_SPEED_RESET ? action_arg_number_reset :
10025 action_arg == CA_ARG_NUMBER_MIN ? action_arg_number_min :
10026 action_arg == CA_ARG_NUMBER_MAX ? action_arg_number_max :
10027 action_arg == CA_ARG_NUMBER_RESET ? action_arg_number_reset :
10028 action_arg == CA_ARG_NUMBER_CE_VALUE ? CustomValue[x][y] :
10029 action_arg == CA_ARG_NUMBER_CE_SCORE ? ei->collect_score :
10030 action_arg == CA_ARG_NUMBER_CE_DELAY ? GET_CE_DELAY_VALUE(change) :
10031 action_arg == CA_ARG_NUMBER_LEVEL_TIME ? level_time_value :
10032 action_arg == CA_ARG_NUMBER_LEVEL_GEMS ? game.gems_still_needed :
10033 action_arg == CA_ARG_NUMBER_LEVEL_SCORE ? game.score :
10034 action_arg == CA_ARG_ELEMENT_CV_TARGET ? GET_NEW_CE_VALUE(target_element):
10035 action_arg == CA_ARG_ELEMENT_CV_TRIGGER ? change->actual_trigger_ce_value:
10036 action_arg == CA_ARG_ELEMENT_CV_ACTION ? GET_NEW_CE_VALUE(action_element):
10037 action_arg == CA_ARG_ELEMENT_CS_TARGET ? GET_CE_SCORE(target_element) :
10038 action_arg == CA_ARG_ELEMENT_CS_TRIGGER ? change->actual_trigger_ce_score:
10039 action_arg == CA_ARG_ELEMENT_CS_ACTION ? GET_CE_SCORE(action_element) :
10040 action_arg == CA_ARG_ELEMENT_NR_TARGET ? change->target_element :
10041 action_arg == CA_ARG_ELEMENT_NR_TRIGGER ? change->actual_trigger_element :
10042 action_arg == CA_ARG_ELEMENT_NR_ACTION ? change->action_element :
10045 int action_arg_number_old =
10046 (action_type == CA_SET_LEVEL_GEMS ? game.gems_still_needed :
10047 action_type == CA_SET_LEVEL_TIME ? TimeLeft :
10048 action_type == CA_SET_LEVEL_SCORE ? game.score :
10049 action_type == CA_SET_CE_VALUE ? CustomValue[x][y] :
10050 action_type == CA_SET_CE_SCORE ? ei->collect_score :
10053 int action_arg_number_new =
10054 getModifiedActionNumber(action_arg_number_old,
10055 action_mode, action_arg_number,
10056 action_arg_number_min, action_arg_number_max);
10058 int trigger_player_bits =
10059 (change->actual_trigger_player_bits != CH_PLAYER_NONE ?
10060 change->actual_trigger_player_bits : change->trigger_player);
10062 int action_arg_player_bits =
10063 (action_arg >= CA_ARG_PLAYER_1 &&
10064 action_arg <= CA_ARG_PLAYER_4 ? action_arg - CA_ARG_PLAYER :
10065 action_arg == CA_ARG_PLAYER_TRIGGER ? trigger_player_bits :
10066 action_arg == CA_ARG_PLAYER_ACTION ? 1 << GET_PLAYER_NR(action_element) :
10069 // ---------- execute action -----------------------------------------------
10071 switch (action_type)
10078 // ---------- level actions ----------------------------------------------
10080 case CA_RESTART_LEVEL:
10082 game.restart_level = TRUE;
10087 case CA_SHOW_ENVELOPE:
10089 int element = getSpecialActionElement(action_arg_element,
10090 action_arg_number, EL_ENVELOPE_1);
10092 if (IS_ENVELOPE(element))
10093 local_player->show_envelope = element;
10098 case CA_SET_LEVEL_TIME:
10100 if (level.time > 0) // only modify limited time value
10102 TimeLeft = action_arg_number_new;
10104 game_panel_controls[GAME_PANEL_TIME].value = TimeLeft;
10106 DisplayGameControlValues();
10108 if (!TimeLeft && setup.time_limit)
10109 for (i = 0; i < MAX_PLAYERS; i++)
10110 KillPlayer(&stored_player[i]);
10116 case CA_SET_LEVEL_SCORE:
10118 game.score = action_arg_number_new;
10120 game_panel_controls[GAME_PANEL_SCORE].value = game.score;
10122 DisplayGameControlValues();
10127 case CA_SET_LEVEL_GEMS:
10129 game.gems_still_needed = action_arg_number_new;
10131 game.snapshot.collected_item = TRUE;
10133 game_panel_controls[GAME_PANEL_GEMS].value = game.gems_still_needed;
10135 DisplayGameControlValues();
10140 case CA_SET_LEVEL_WIND:
10142 game.wind_direction = action_arg_direction;
10147 case CA_SET_LEVEL_RANDOM_SEED:
10149 // ensure that setting a new random seed while playing is predictable
10150 InitRND(action_arg_number_new ? action_arg_number_new : RND(1000000) + 1);
10155 // ---------- player actions ---------------------------------------------
10157 case CA_MOVE_PLAYER:
10158 case CA_MOVE_PLAYER_NEW:
10160 // automatically move to the next field in specified direction
10161 for (i = 0; i < MAX_PLAYERS; i++)
10162 if (trigger_player_bits & (1 << i))
10163 if (action_type == CA_MOVE_PLAYER ||
10164 stored_player[i].MovPos == 0)
10165 stored_player[i].programmed_action = action_arg_direction;
10170 case CA_EXIT_PLAYER:
10172 for (i = 0; i < MAX_PLAYERS; i++)
10173 if (action_arg_player_bits & (1 << i))
10174 ExitPlayer(&stored_player[i]);
10176 if (game.players_still_needed == 0)
10182 case CA_KILL_PLAYER:
10184 for (i = 0; i < MAX_PLAYERS; i++)
10185 if (action_arg_player_bits & (1 << i))
10186 KillPlayer(&stored_player[i]);
10191 case CA_SET_PLAYER_KEYS:
10193 int key_state = (action_mode == CA_MODE_ADD ? TRUE : FALSE);
10194 int element = getSpecialActionElement(action_arg_element,
10195 action_arg_number, EL_KEY_1);
10197 if (IS_KEY(element))
10199 for (i = 0; i < MAX_PLAYERS; i++)
10201 if (trigger_player_bits & (1 << i))
10203 stored_player[i].key[KEY_NR(element)] = key_state;
10205 DrawGameDoorValues();
10213 case CA_SET_PLAYER_SPEED:
10215 for (i = 0; i < MAX_PLAYERS; i++)
10217 if (trigger_player_bits & (1 << i))
10219 int move_stepsize = TILEX / stored_player[i].move_delay_value;
10221 if (action_arg == CA_ARG_SPEED_FASTER &&
10222 stored_player[i].cannot_move)
10224 action_arg_number = STEPSIZE_VERY_SLOW;
10226 else if (action_arg == CA_ARG_SPEED_SLOWER ||
10227 action_arg == CA_ARG_SPEED_FASTER)
10229 action_arg_number = 2;
10230 action_mode = (action_arg == CA_ARG_SPEED_SLOWER ? CA_MODE_DIVIDE :
10233 else if (action_arg == CA_ARG_NUMBER_RESET)
10235 action_arg_number = level.initial_player_stepsize[i];
10239 getModifiedActionNumber(move_stepsize,
10242 action_arg_number_min,
10243 action_arg_number_max);
10245 SetPlayerMoveSpeed(&stored_player[i], move_stepsize, FALSE);
10252 case CA_SET_PLAYER_SHIELD:
10254 for (i = 0; i < MAX_PLAYERS; i++)
10256 if (trigger_player_bits & (1 << i))
10258 if (action_arg == CA_ARG_SHIELD_OFF)
10260 stored_player[i].shield_normal_time_left = 0;
10261 stored_player[i].shield_deadly_time_left = 0;
10263 else if (action_arg == CA_ARG_SHIELD_NORMAL)
10265 stored_player[i].shield_normal_time_left = 999999;
10267 else if (action_arg == CA_ARG_SHIELD_DEADLY)
10269 stored_player[i].shield_normal_time_left = 999999;
10270 stored_player[i].shield_deadly_time_left = 999999;
10278 case CA_SET_PLAYER_GRAVITY:
10280 for (i = 0; i < MAX_PLAYERS; i++)
10282 if (trigger_player_bits & (1 << i))
10284 stored_player[i].gravity =
10285 (action_arg == CA_ARG_GRAVITY_OFF ? FALSE :
10286 action_arg == CA_ARG_GRAVITY_ON ? TRUE :
10287 action_arg == CA_ARG_GRAVITY_TOGGLE ? !stored_player[i].gravity :
10288 stored_player[i].gravity);
10295 case CA_SET_PLAYER_ARTWORK:
10297 for (i = 0; i < MAX_PLAYERS; i++)
10299 if (trigger_player_bits & (1 << i))
10301 int artwork_element = action_arg_element;
10303 if (action_arg == CA_ARG_ELEMENT_RESET)
10305 (level.use_artwork_element[i] ? level.artwork_element[i] :
10306 stored_player[i].element_nr);
10308 if (stored_player[i].artwork_element != artwork_element)
10309 stored_player[i].Frame = 0;
10311 stored_player[i].artwork_element = artwork_element;
10313 SetPlayerWaiting(&stored_player[i], FALSE);
10315 // set number of special actions for bored and sleeping animation
10316 stored_player[i].num_special_action_bored =
10317 get_num_special_action(artwork_element,
10318 ACTION_BORING_1, ACTION_BORING_LAST);
10319 stored_player[i].num_special_action_sleeping =
10320 get_num_special_action(artwork_element,
10321 ACTION_SLEEPING_1, ACTION_SLEEPING_LAST);
10328 case CA_SET_PLAYER_INVENTORY:
10330 for (i = 0; i < MAX_PLAYERS; i++)
10332 struct PlayerInfo *player = &stored_player[i];
10335 if (trigger_player_bits & (1 << i))
10337 int inventory_element = action_arg_element;
10339 if (action_arg == CA_ARG_ELEMENT_TARGET ||
10340 action_arg == CA_ARG_ELEMENT_TRIGGER ||
10341 action_arg == CA_ARG_ELEMENT_ACTION)
10343 int element = inventory_element;
10344 int collect_count = element_info[element].collect_count_initial;
10346 if (!IS_CUSTOM_ELEMENT(element))
10349 if (collect_count == 0)
10350 player->inventory_infinite_element = element;
10352 for (k = 0; k < collect_count; k++)
10353 if (player->inventory_size < MAX_INVENTORY_SIZE)
10354 player->inventory_element[player->inventory_size++] =
10357 else if (action_arg == CA_ARG_INVENTORY_RM_TARGET ||
10358 action_arg == CA_ARG_INVENTORY_RM_TRIGGER ||
10359 action_arg == CA_ARG_INVENTORY_RM_ACTION)
10361 if (player->inventory_infinite_element != EL_UNDEFINED &&
10362 IS_EQUAL_OR_IN_GROUP(player->inventory_infinite_element,
10363 action_arg_element_raw))
10364 player->inventory_infinite_element = EL_UNDEFINED;
10366 for (k = 0, j = 0; j < player->inventory_size; j++)
10368 if (!IS_EQUAL_OR_IN_GROUP(player->inventory_element[j],
10369 action_arg_element_raw))
10370 player->inventory_element[k++] = player->inventory_element[j];
10373 player->inventory_size = k;
10375 else if (action_arg == CA_ARG_INVENTORY_RM_FIRST)
10377 if (player->inventory_size > 0)
10379 for (j = 0; j < player->inventory_size - 1; j++)
10380 player->inventory_element[j] = player->inventory_element[j + 1];
10382 player->inventory_size--;
10385 else if (action_arg == CA_ARG_INVENTORY_RM_LAST)
10387 if (player->inventory_size > 0)
10388 player->inventory_size--;
10390 else if (action_arg == CA_ARG_INVENTORY_RM_ALL)
10392 player->inventory_infinite_element = EL_UNDEFINED;
10393 player->inventory_size = 0;
10395 else if (action_arg == CA_ARG_INVENTORY_RESET)
10397 player->inventory_infinite_element = EL_UNDEFINED;
10398 player->inventory_size = 0;
10400 if (level.use_initial_inventory[i])
10402 for (j = 0; j < level.initial_inventory_size[i]; j++)
10404 int element = level.initial_inventory_content[i][j];
10405 int collect_count = element_info[element].collect_count_initial;
10407 if (!IS_CUSTOM_ELEMENT(element))
10410 if (collect_count == 0)
10411 player->inventory_infinite_element = element;
10413 for (k = 0; k < collect_count; k++)
10414 if (player->inventory_size < MAX_INVENTORY_SIZE)
10415 player->inventory_element[player->inventory_size++] =
10426 // ---------- CE actions -------------------------------------------------
10428 case CA_SET_CE_VALUE:
10430 int last_ce_value = CustomValue[x][y];
10432 CustomValue[x][y] = action_arg_number_new;
10434 if (CustomValue[x][y] != last_ce_value)
10436 CheckElementChange(x, y, element, EL_UNDEFINED, CE_VALUE_CHANGES);
10437 CheckTriggeredElementChange(x, y, element, CE_VALUE_CHANGES_OF_X);
10439 if (CustomValue[x][y] == 0)
10441 // reset change counter (else CE_VALUE_GETS_ZERO would not work)
10442 ChangeCount[x][y] = 0; // allow at least one more change
10444 CheckElementChange(x, y, element, EL_UNDEFINED, CE_VALUE_GETS_ZERO);
10445 CheckTriggeredElementChange(x, y, element, CE_VALUE_GETS_ZERO_OF_X);
10452 case CA_SET_CE_SCORE:
10454 int last_ce_score = ei->collect_score;
10456 ei->collect_score = action_arg_number_new;
10458 if (ei->collect_score != last_ce_score)
10460 CheckElementChange(x, y, element, EL_UNDEFINED, CE_SCORE_CHANGES);
10461 CheckTriggeredElementChange(x, y, element, CE_SCORE_CHANGES_OF_X);
10463 if (ei->collect_score == 0)
10467 // reset change counter (else CE_SCORE_GETS_ZERO would not work)
10468 ChangeCount[x][y] = 0; // allow at least one more change
10470 CheckElementChange(x, y, element, EL_UNDEFINED, CE_SCORE_GETS_ZERO);
10471 CheckTriggeredElementChange(x, y, element, CE_SCORE_GETS_ZERO_OF_X);
10474 This is a very special case that seems to be a mixture between
10475 CheckElementChange() and CheckTriggeredElementChange(): while
10476 the first one only affects single elements that are triggered
10477 directly, the second one affects multiple elements in the playfield
10478 that are triggered indirectly by another element. This is a third
10479 case: Changing the CE score always affects multiple identical CEs,
10480 so every affected CE must be checked, not only the single CE for
10481 which the CE score was changed in the first place (as every instance
10482 of that CE shares the same CE score, and therefore also can change)!
10484 SCAN_PLAYFIELD(xx, yy)
10486 if (Tile[xx][yy] == element)
10487 CheckElementChange(xx, yy, element, EL_UNDEFINED,
10488 CE_SCORE_GETS_ZERO);
10496 case CA_SET_CE_ARTWORK:
10498 int artwork_element = action_arg_element;
10499 boolean reset_frame = FALSE;
10502 if (action_arg == CA_ARG_ELEMENT_RESET)
10503 artwork_element = (ei->use_gfx_element ? ei->gfx_element_initial :
10506 if (ei->gfx_element != artwork_element)
10507 reset_frame = TRUE;
10509 ei->gfx_element = artwork_element;
10511 SCAN_PLAYFIELD(xx, yy)
10513 if (Tile[xx][yy] == element)
10517 ResetGfxAnimation(xx, yy);
10518 ResetRandomAnimationValue(xx, yy);
10521 TEST_DrawLevelField(xx, yy);
10528 // ---------- engine actions ---------------------------------------------
10530 case CA_SET_ENGINE_SCAN_MODE:
10532 InitPlayfieldScanMode(action_arg);
10542 static void CreateFieldExt(int x, int y, int element, boolean is_change)
10544 int old_element = Tile[x][y];
10545 int new_element = GetElementFromGroupElement(element);
10546 int previous_move_direction = MovDir[x][y];
10547 int last_ce_value = CustomValue[x][y];
10548 boolean player_explosion_protected = PLAYER_EXPLOSION_PROTECTED(x, y);
10549 boolean new_element_is_player = ELEM_IS_PLAYER(new_element);
10550 boolean add_player_onto_element = (new_element_is_player &&
10551 new_element != EL_SOKOBAN_FIELD_PLAYER &&
10552 IS_WALKABLE(old_element));
10554 if (!add_player_onto_element)
10556 if (IS_MOVING(x, y) || IS_BLOCKED(x, y))
10557 RemoveMovingField(x, y);
10561 Tile[x][y] = new_element;
10563 if (element_info[new_element].move_direction_initial == MV_START_PREVIOUS)
10564 MovDir[x][y] = previous_move_direction;
10566 if (element_info[new_element].use_last_ce_value)
10567 CustomValue[x][y] = last_ce_value;
10569 InitField_WithBug1(x, y, FALSE);
10571 new_element = Tile[x][y]; // element may have changed
10573 ResetGfxAnimation(x, y);
10574 ResetRandomAnimationValue(x, y);
10576 TEST_DrawLevelField(x, y);
10578 if (GFX_CRUMBLED(new_element))
10579 TEST_DrawLevelFieldCrumbledNeighbours(x, y);
10582 // check if element under the player changes from accessible to unaccessible
10583 // (needed for special case of dropping element which then changes)
10584 // (must be checked after creating new element for walkable group elements)
10585 if (IS_PLAYER(x, y) && !player_explosion_protected &&
10586 IS_ACCESSIBLE(old_element) && !IS_ACCESSIBLE(new_element))
10593 // "ChangeCount" not set yet to allow "entered by player" change one time
10594 if (new_element_is_player)
10595 RelocatePlayer(x, y, new_element);
10598 ChangeCount[x][y]++; // count number of changes in the same frame
10600 TestIfBadThingTouchesPlayer(x, y);
10601 TestIfPlayerTouchesCustomElement(x, y);
10602 TestIfElementTouchesCustomElement(x, y);
10605 static void CreateField(int x, int y, int element)
10607 CreateFieldExt(x, y, element, FALSE);
10610 static void CreateElementFromChange(int x, int y, int element)
10612 element = GET_VALID_RUNTIME_ELEMENT(element);
10614 if (game.engine_version >= VERSION_IDENT(3,2,0,7))
10616 int old_element = Tile[x][y];
10618 // prevent changed element from moving in same engine frame
10619 // unless both old and new element can either fall or move
10620 if ((!CAN_FALL(old_element) || !CAN_FALL(element)) &&
10621 (!CAN_MOVE(old_element) || !CAN_MOVE(element)))
10625 CreateFieldExt(x, y, element, TRUE);
10628 static boolean ChangeElement(int x, int y, int element, int page)
10630 struct ElementInfo *ei = &element_info[element];
10631 struct ElementChangeInfo *change = &ei->change_page[page];
10632 int ce_value = CustomValue[x][y];
10633 int ce_score = ei->collect_score;
10634 int target_element;
10635 int old_element = Tile[x][y];
10637 // always use default change event to prevent running into a loop
10638 if (ChangeEvent[x][y] == -1)
10639 ChangeEvent[x][y] = CE_DELAY;
10641 if (ChangeEvent[x][y] == CE_DELAY)
10643 // reset actual trigger element, trigger player and action element
10644 change->actual_trigger_element = EL_EMPTY;
10645 change->actual_trigger_player = EL_EMPTY;
10646 change->actual_trigger_player_bits = CH_PLAYER_NONE;
10647 change->actual_trigger_side = CH_SIDE_NONE;
10648 change->actual_trigger_ce_value = 0;
10649 change->actual_trigger_ce_score = 0;
10652 // do not change elements more than a specified maximum number of changes
10653 if (ChangeCount[x][y] >= game.max_num_changes_per_frame)
10656 ChangeCount[x][y]++; // count number of changes in the same frame
10658 if (change->explode)
10665 if (change->use_target_content)
10667 boolean complete_replace = TRUE;
10668 boolean can_replace[3][3];
10671 for (yy = 0; yy < 3; yy++) for (xx = 0; xx < 3 ; xx++)
10674 boolean is_walkable;
10675 boolean is_diggable;
10676 boolean is_collectible;
10677 boolean is_removable;
10678 boolean is_destructible;
10679 int ex = x + xx - 1;
10680 int ey = y + yy - 1;
10681 int content_element = change->target_content.e[xx][yy];
10684 can_replace[xx][yy] = TRUE;
10686 if (ex == x && ey == y) // do not check changing element itself
10689 if (content_element == EL_EMPTY_SPACE)
10691 can_replace[xx][yy] = FALSE; // do not replace border with space
10696 if (!IN_LEV_FIELD(ex, ey))
10698 can_replace[xx][yy] = FALSE;
10699 complete_replace = FALSE;
10706 if (IS_MOVING(ex, ey) || IS_BLOCKED(ex, ey))
10707 e = MovingOrBlocked2Element(ex, ey);
10709 is_empty = (IS_FREE(ex, ey) ||
10710 (IS_FREE_OR_PLAYER(ex, ey) && IS_WALKABLE(content_element)));
10712 is_walkable = (is_empty || IS_WALKABLE(e));
10713 is_diggable = (is_empty || IS_DIGGABLE(e));
10714 is_collectible = (is_empty || IS_COLLECTIBLE(e));
10715 is_destructible = (is_empty || !IS_INDESTRUCTIBLE(e));
10716 is_removable = (is_diggable || is_collectible);
10718 can_replace[xx][yy] =
10719 (((change->replace_when == CP_WHEN_EMPTY && is_empty) ||
10720 (change->replace_when == CP_WHEN_WALKABLE && is_walkable) ||
10721 (change->replace_when == CP_WHEN_DIGGABLE && is_diggable) ||
10722 (change->replace_when == CP_WHEN_COLLECTIBLE && is_collectible) ||
10723 (change->replace_when == CP_WHEN_REMOVABLE && is_removable) ||
10724 (change->replace_when == CP_WHEN_DESTRUCTIBLE && is_destructible)) &&
10725 !(IS_PLAYER(ex, ey) && ELEM_IS_PLAYER(content_element)));
10727 if (!can_replace[xx][yy])
10728 complete_replace = FALSE;
10731 if (!change->only_if_complete || complete_replace)
10733 boolean something_has_changed = FALSE;
10735 if (change->only_if_complete && change->use_random_replace &&
10736 RND(100) < change->random_percentage)
10739 for (yy = 0; yy < 3; yy++) for (xx = 0; xx < 3 ; xx++)
10741 int ex = x + xx - 1;
10742 int ey = y + yy - 1;
10743 int content_element;
10745 if (can_replace[xx][yy] && (!change->use_random_replace ||
10746 RND(100) < change->random_percentage))
10748 if (IS_MOVING(ex, ey) || IS_BLOCKED(ex, ey))
10749 RemoveMovingField(ex, ey);
10751 ChangeEvent[ex][ey] = ChangeEvent[x][y];
10753 content_element = change->target_content.e[xx][yy];
10754 target_element = GET_TARGET_ELEMENT(element, content_element, change,
10755 ce_value, ce_score);
10757 CreateElementFromChange(ex, ey, target_element);
10759 something_has_changed = TRUE;
10761 // for symmetry reasons, freeze newly created border elements
10762 if (ex != x || ey != y)
10763 Stop[ex][ey] = TRUE; // no more moving in this frame
10767 if (something_has_changed)
10769 PlayLevelSoundElementAction(x, y, element, ACTION_CHANGING);
10770 PlayLevelSoundElementAction(x, y, element, ACTION_PAGE_1 + page);
10776 target_element = GET_TARGET_ELEMENT(element, change->target_element, change,
10777 ce_value, ce_score);
10779 if (element == EL_DIAGONAL_GROWING ||
10780 element == EL_DIAGONAL_SHRINKING)
10782 target_element = Store[x][y];
10784 Store[x][y] = EL_EMPTY;
10787 CreateElementFromChange(x, y, target_element);
10789 PlayLevelSoundElementAction(x, y, element, ACTION_CHANGING);
10790 PlayLevelSoundElementAction(x, y, element, ACTION_PAGE_1 + page);
10793 // this uses direct change before indirect change
10794 CheckTriggeredElementChangeByPage(x, y, old_element, CE_CHANGE_OF_X, page);
10799 static void HandleElementChange(int x, int y, int page)
10801 int element = MovingOrBlocked2Element(x, y);
10802 struct ElementInfo *ei = &element_info[element];
10803 struct ElementChangeInfo *change = &ei->change_page[page];
10804 boolean handle_action_before_change = FALSE;
10807 if (!CAN_CHANGE_OR_HAS_ACTION(element) &&
10808 !CAN_CHANGE_OR_HAS_ACTION(Back[x][y]))
10810 Debug("game:playing:HandleElementChange", "%d,%d: element = %d ('%s')",
10811 x, y, element, element_info[element].token_name);
10812 Debug("game:playing:HandleElementChange", "This should never happen!");
10816 // this can happen with classic bombs on walkable, changing elements
10817 if (!CAN_CHANGE_OR_HAS_ACTION(element))
10822 if (ChangeDelay[x][y] == 0) // initialize element change
10824 ChangeDelay[x][y] = GET_CHANGE_DELAY(change) + 1;
10826 if (change->can_change)
10828 // !!! not clear why graphic animation should be reset at all here !!!
10829 // !!! UPDATE: but is needed for correct Snake Bite tail animation !!!
10830 // !!! SOLUTION: do not reset if graphics engine set to 4 or above !!!
10833 GRAPHICAL BUG ADDRESSED BY CHECKING GRAPHICS ENGINE VERSION:
10835 When using an animation frame delay of 1 (this only happens with
10836 "sp_zonk.moving.left/right" in the classic graphics), the default
10837 (non-moving) animation shows wrong animation frames (while the
10838 moving animation, like "sp_zonk.moving.left/right", is correct,
10839 so this graphical bug never shows up with the classic graphics).
10840 For an animation with 4 frames, this causes wrong frames 0,0,1,2
10841 be drawn instead of the correct frames 0,1,2,3. This is caused by
10842 "GfxFrame[][]" being reset *twice* (in two successive frames) after
10843 an element change: First when the change delay ("ChangeDelay[][]")
10844 counter has reached zero after decrementing, then a second time in
10845 the next frame (after "GfxFrame[][]" was already incremented) when
10846 "ChangeDelay[][]" is reset to the initial delay value again.
10848 This causes frame 0 to be drawn twice, while the last frame won't
10849 be drawn anymore, resulting in the wrong frame sequence 0,0,1,2.
10851 As some animations may already be cleverly designed around this bug
10852 (at least the "Snake Bite" snake tail animation does this), it cannot
10853 simply be fixed here without breaking such existing animations.
10854 Unfortunately, it cannot easily be detected if a graphics set was
10855 designed "before" or "after" the bug was fixed. As a workaround,
10856 a new graphics set option "game.graphics_engine_version" was added
10857 to be able to specify the game's major release version for which the
10858 graphics set was designed, which can then be used to decide if the
10859 bugfix should be used (version 4 and above) or not (version 3 or
10860 below, or if no version was specified at all, as with old sets).
10862 (The wrong/fixed animation frames can be tested with the test level set
10863 "test_gfxframe" and level "000", which contains a specially prepared
10864 custom element at level position (x/y) == (11/9) which uses the zonk
10865 animation mentioned above. Using "game.graphics_engine_version: 4"
10866 fixes the wrong animation frames, showing the correct frames 0,1,2,3.
10867 This can also be seen from the debug output for this test element.)
10870 // when a custom element is about to change (for example by change delay),
10871 // do not reset graphic animation when the custom element is moving
10872 if (game.graphics_engine_version < 4 &&
10875 ResetGfxAnimation(x, y);
10876 ResetRandomAnimationValue(x, y);
10879 if (change->pre_change_function)
10880 change->pre_change_function(x, y);
10884 ChangeDelay[x][y]--;
10886 if (ChangeDelay[x][y] != 0) // continue element change
10888 if (change->can_change)
10890 int graphic = el_act_dir2img(element, GfxAction[x][y], GfxDir[x][y]);
10892 if (IS_ANIMATED(graphic))
10893 DrawLevelGraphicAnimationIfNeeded(x, y, graphic);
10895 if (change->change_function)
10896 change->change_function(x, y);
10899 else // finish element change
10901 if (ChangePage[x][y] != -1) // remember page from delayed change
10903 page = ChangePage[x][y];
10904 ChangePage[x][y] = -1;
10906 change = &ei->change_page[page];
10909 if (IS_MOVING(x, y)) // never change a running system ;-)
10911 ChangeDelay[x][y] = 1; // try change after next move step
10912 ChangePage[x][y] = page; // remember page to use for change
10917 // special case: set new level random seed before changing element
10918 if (change->has_action && change->action_type == CA_SET_LEVEL_RANDOM_SEED)
10919 handle_action_before_change = TRUE;
10921 if (change->has_action && handle_action_before_change)
10922 ExecuteCustomElementAction(x, y, element, page);
10924 if (change->can_change)
10926 if (ChangeElement(x, y, element, page))
10928 if (change->post_change_function)
10929 change->post_change_function(x, y);
10933 if (change->has_action && !handle_action_before_change)
10934 ExecuteCustomElementAction(x, y, element, page);
10938 static boolean CheckTriggeredElementChangeExt(int trigger_x, int trigger_y,
10939 int trigger_element,
10941 int trigger_player,
10945 boolean change_done_any = FALSE;
10946 int trigger_page_bits = (trigger_page < 0 ? CH_PAGE_ANY : 1 << trigger_page);
10949 if (!(trigger_events[trigger_element][trigger_event]))
10952 RECURSION_LOOP_DETECTION_START(trigger_element, FALSE);
10954 for (i = 0; i < NUM_CUSTOM_ELEMENTS; i++)
10956 int element = EL_CUSTOM_START + i;
10957 boolean change_done = FALSE;
10960 if (!CAN_CHANGE_OR_HAS_ACTION(element) ||
10961 !HAS_ANY_CHANGE_EVENT(element, trigger_event))
10964 for (p = 0; p < element_info[element].num_change_pages; p++)
10966 struct ElementChangeInfo *change = &element_info[element].change_page[p];
10968 if (change->can_change_or_has_action &&
10969 change->has_event[trigger_event] &&
10970 change->trigger_side & trigger_side &&
10971 change->trigger_player & trigger_player &&
10972 change->trigger_page & trigger_page_bits &&
10973 IS_EQUAL_OR_IN_GROUP(trigger_element, change->trigger_element))
10975 change->actual_trigger_element = trigger_element;
10976 change->actual_trigger_player = GET_PLAYER_FROM_BITS(trigger_player);
10977 change->actual_trigger_player_bits = trigger_player;
10978 change->actual_trigger_side = trigger_side;
10979 change->actual_trigger_ce_value = CustomValue[trigger_x][trigger_y];
10980 change->actual_trigger_ce_score = GET_CE_SCORE(trigger_element);
10982 if ((change->can_change && !change_done) || change->has_action)
10986 SCAN_PLAYFIELD(x, y)
10988 if (Tile[x][y] == element)
10990 if (change->can_change && !change_done)
10992 // if element already changed in this frame, not only prevent
10993 // another element change (checked in ChangeElement()), but
10994 // also prevent additional element actions for this element
10996 if (ChangeCount[x][y] >= game.max_num_changes_per_frame &&
10997 !level.use_action_after_change_bug)
11000 ChangeDelay[x][y] = 1;
11001 ChangeEvent[x][y] = trigger_event;
11003 HandleElementChange(x, y, p);
11005 else if (change->has_action)
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 ExecuteCustomElementAction(x, y, element, p);
11016 PlayLevelSoundElementAction(x, y, element, ACTION_PAGE_1 + p);
11021 if (change->can_change)
11023 change_done = TRUE;
11024 change_done_any = TRUE;
11031 RECURSION_LOOP_DETECTION_END();
11033 return change_done_any;
11036 static boolean CheckElementChangeExt(int x, int y,
11038 int trigger_element,
11040 int trigger_player,
11043 boolean change_done = FALSE;
11046 if (!CAN_CHANGE_OR_HAS_ACTION(element) ||
11047 !HAS_ANY_CHANGE_EVENT(element, trigger_event))
11050 if (Tile[x][y] == EL_BLOCKED)
11052 Blocked2Moving(x, y, &x, &y);
11053 element = Tile[x][y];
11056 // check if element has already changed or is about to change after moving
11057 if ((game.engine_version < VERSION_IDENT(3,2,0,7) &&
11058 Tile[x][y] != element) ||
11060 (game.engine_version >= VERSION_IDENT(3,2,0,7) &&
11061 (ChangeCount[x][y] >= game.max_num_changes_per_frame ||
11062 ChangePage[x][y] != -1)))
11065 RECURSION_LOOP_DETECTION_START(trigger_element, FALSE);
11067 for (p = 0; p < element_info[element].num_change_pages; p++)
11069 struct ElementChangeInfo *change = &element_info[element].change_page[p];
11071 /* check trigger element for all events where the element that is checked
11072 for changing interacts with a directly adjacent element -- this is
11073 different to element changes that affect other elements to change on the
11074 whole playfield (which is handeld by CheckTriggeredElementChangeExt()) */
11075 boolean check_trigger_element =
11076 (trigger_event == CE_TOUCHING_X ||
11077 trigger_event == CE_HITTING_X ||
11078 trigger_event == CE_HIT_BY_X ||
11079 trigger_event == CE_DIGGING_X); // this one was forgotten until 3.2.3
11081 if (change->can_change_or_has_action &&
11082 change->has_event[trigger_event] &&
11083 change->trigger_side & trigger_side &&
11084 change->trigger_player & trigger_player &&
11085 (!check_trigger_element ||
11086 IS_EQUAL_OR_IN_GROUP(trigger_element, change->trigger_element)))
11088 change->actual_trigger_element = trigger_element;
11089 change->actual_trigger_player = GET_PLAYER_FROM_BITS(trigger_player);
11090 change->actual_trigger_player_bits = trigger_player;
11091 change->actual_trigger_side = trigger_side;
11092 change->actual_trigger_ce_value = CustomValue[x][y];
11093 change->actual_trigger_ce_score = GET_CE_SCORE(trigger_element);
11095 // special case: trigger element not at (x,y) position for some events
11096 if (check_trigger_element)
11108 { 0, 0 }, { 0, 0 }, { 0, 0 },
11112 int xx = x + move_xy[MV_DIR_OPPOSITE(trigger_side)].dx;
11113 int yy = y + move_xy[MV_DIR_OPPOSITE(trigger_side)].dy;
11115 change->actual_trigger_ce_value = CustomValue[xx][yy];
11116 change->actual_trigger_ce_score = GET_CE_SCORE(trigger_element);
11119 if (change->can_change && !change_done)
11121 ChangeDelay[x][y] = 1;
11122 ChangeEvent[x][y] = trigger_event;
11124 HandleElementChange(x, y, p);
11126 change_done = TRUE;
11128 else if (change->has_action)
11130 ExecuteCustomElementAction(x, y, element, p);
11131 PlayLevelSoundElementAction(x, y, element, ACTION_PAGE_1 + p);
11136 RECURSION_LOOP_DETECTION_END();
11138 return change_done;
11141 static void PlayPlayerSound(struct PlayerInfo *player)
11143 int jx = player->jx, jy = player->jy;
11144 int sound_element = player->artwork_element;
11145 int last_action = player->last_action_waiting;
11146 int action = player->action_waiting;
11148 if (player->is_waiting)
11150 if (action != last_action)
11151 PlayLevelSoundElementAction(jx, jy, sound_element, action);
11153 PlayLevelSoundElementActionIfLoop(jx, jy, sound_element, action);
11157 if (action != last_action)
11158 StopSound(element_info[sound_element].sound[last_action]);
11160 if (last_action == ACTION_SLEEPING)
11161 PlayLevelSoundElementAction(jx, jy, sound_element, ACTION_AWAKENING);
11165 static void PlayAllPlayersSound(void)
11169 for (i = 0; i < MAX_PLAYERS; i++)
11170 if (stored_player[i].active)
11171 PlayPlayerSound(&stored_player[i]);
11174 static void SetPlayerWaiting(struct PlayerInfo *player, boolean is_waiting)
11176 boolean last_waiting = player->is_waiting;
11177 int move_dir = player->MovDir;
11179 player->dir_waiting = move_dir;
11180 player->last_action_waiting = player->action_waiting;
11184 if (!last_waiting) // not waiting -> waiting
11186 player->is_waiting = TRUE;
11188 player->frame_counter_bored =
11190 game.player_boring_delay_fixed +
11191 GetSimpleRandom(game.player_boring_delay_random);
11192 player->frame_counter_sleeping =
11194 game.player_sleeping_delay_fixed +
11195 GetSimpleRandom(game.player_sleeping_delay_random);
11197 InitPlayerGfxAnimation(player, ACTION_WAITING, move_dir);
11200 if (game.player_sleeping_delay_fixed +
11201 game.player_sleeping_delay_random > 0 &&
11202 player->anim_delay_counter == 0 &&
11203 player->post_delay_counter == 0 &&
11204 FrameCounter >= player->frame_counter_sleeping)
11205 player->is_sleeping = TRUE;
11206 else if (game.player_boring_delay_fixed +
11207 game.player_boring_delay_random > 0 &&
11208 FrameCounter >= player->frame_counter_bored)
11209 player->is_bored = TRUE;
11211 player->action_waiting = (player->is_sleeping ? ACTION_SLEEPING :
11212 player->is_bored ? ACTION_BORING :
11215 if (player->is_sleeping && player->use_murphy)
11217 // special case for sleeping Murphy when leaning against non-free tile
11219 if (!IN_LEV_FIELD(player->jx - 1, player->jy) ||
11220 (Tile[player->jx - 1][player->jy] != EL_EMPTY &&
11221 !IS_MOVING(player->jx - 1, player->jy)))
11222 move_dir = MV_LEFT;
11223 else if (!IN_LEV_FIELD(player->jx + 1, player->jy) ||
11224 (Tile[player->jx + 1][player->jy] != EL_EMPTY &&
11225 !IS_MOVING(player->jx + 1, player->jy)))
11226 move_dir = MV_RIGHT;
11228 player->is_sleeping = FALSE;
11230 player->dir_waiting = move_dir;
11233 if (player->is_sleeping)
11235 if (player->num_special_action_sleeping > 0)
11237 if (player->anim_delay_counter == 0 && player->post_delay_counter == 0)
11239 int last_special_action = player->special_action_sleeping;
11240 int num_special_action = player->num_special_action_sleeping;
11241 int special_action =
11242 (last_special_action == ACTION_DEFAULT ? ACTION_SLEEPING_1 :
11243 last_special_action == ACTION_SLEEPING ? ACTION_SLEEPING :
11244 last_special_action < ACTION_SLEEPING_1 + num_special_action - 1 ?
11245 last_special_action + 1 : ACTION_SLEEPING);
11246 int special_graphic =
11247 el_act_dir2img(player->artwork_element, special_action, move_dir);
11249 player->anim_delay_counter =
11250 graphic_info[special_graphic].anim_delay_fixed +
11251 GetSimpleRandom(graphic_info[special_graphic].anim_delay_random);
11252 player->post_delay_counter =
11253 graphic_info[special_graphic].post_delay_fixed +
11254 GetSimpleRandom(graphic_info[special_graphic].post_delay_random);
11256 player->special_action_sleeping = special_action;
11259 if (player->anim_delay_counter > 0)
11261 player->action_waiting = player->special_action_sleeping;
11262 player->anim_delay_counter--;
11264 else if (player->post_delay_counter > 0)
11266 player->post_delay_counter--;
11270 else if (player->is_bored)
11272 if (player->num_special_action_bored > 0)
11274 if (player->anim_delay_counter == 0 && player->post_delay_counter == 0)
11276 int special_action =
11277 ACTION_BORING_1 + GetSimpleRandom(player->num_special_action_bored);
11278 int special_graphic =
11279 el_act_dir2img(player->artwork_element, special_action, move_dir);
11281 player->anim_delay_counter =
11282 graphic_info[special_graphic].anim_delay_fixed +
11283 GetSimpleRandom(graphic_info[special_graphic].anim_delay_random);
11284 player->post_delay_counter =
11285 graphic_info[special_graphic].post_delay_fixed +
11286 GetSimpleRandom(graphic_info[special_graphic].post_delay_random);
11288 player->special_action_bored = special_action;
11291 if (player->anim_delay_counter > 0)
11293 player->action_waiting = player->special_action_bored;
11294 player->anim_delay_counter--;
11296 else if (player->post_delay_counter > 0)
11298 player->post_delay_counter--;
11303 else if (last_waiting) // waiting -> not waiting
11305 player->is_waiting = FALSE;
11306 player->is_bored = FALSE;
11307 player->is_sleeping = FALSE;
11309 player->frame_counter_bored = -1;
11310 player->frame_counter_sleeping = -1;
11312 player->anim_delay_counter = 0;
11313 player->post_delay_counter = 0;
11315 player->dir_waiting = player->MovDir;
11316 player->action_waiting = ACTION_DEFAULT;
11318 player->special_action_bored = ACTION_DEFAULT;
11319 player->special_action_sleeping = ACTION_DEFAULT;
11323 static void CheckSaveEngineSnapshot(struct PlayerInfo *player)
11325 if ((!player->is_moving && player->was_moving) ||
11326 (player->MovPos == 0 && player->was_moving) ||
11327 (player->is_snapping && !player->was_snapping) ||
11328 (player->is_dropping && !player->was_dropping))
11330 if (!CheckSaveEngineSnapshotToList())
11333 player->was_moving = FALSE;
11334 player->was_snapping = TRUE;
11335 player->was_dropping = TRUE;
11339 if (player->is_moving)
11340 player->was_moving = TRUE;
11342 if (!player->is_snapping)
11343 player->was_snapping = FALSE;
11345 if (!player->is_dropping)
11346 player->was_dropping = FALSE;
11349 static struct MouseActionInfo mouse_action_last = { 0 };
11350 struct MouseActionInfo mouse_action = player->effective_mouse_action;
11351 boolean new_released = (!mouse_action.button && mouse_action_last.button);
11354 CheckSaveEngineSnapshotToList();
11356 mouse_action_last = mouse_action;
11359 static void CheckSingleStepMode(struct PlayerInfo *player)
11361 if (tape.single_step && tape.recording && !tape.pausing)
11363 // as it is called "single step mode", just return to pause mode when the
11364 // player stopped moving after one tile (or never starts moving at all)
11365 // (reverse logic needed here in case single step mode used in team mode)
11366 if (player->is_moving ||
11367 player->is_pushing ||
11368 player->is_dropping_pressed ||
11369 player->effective_mouse_action.button)
11370 game.enter_single_step_mode = FALSE;
11373 CheckSaveEngineSnapshot(player);
11376 static byte PlayerActions(struct PlayerInfo *player, byte player_action)
11378 int left = player_action & JOY_LEFT;
11379 int right = player_action & JOY_RIGHT;
11380 int up = player_action & JOY_UP;
11381 int down = player_action & JOY_DOWN;
11382 int button1 = player_action & JOY_BUTTON_1;
11383 int button2 = player_action & JOY_BUTTON_2;
11384 int dx = (left ? -1 : right ? 1 : 0);
11385 int dy = (up ? -1 : down ? 1 : 0);
11387 if (!player->active || tape.pausing)
11393 SnapField(player, dx, dy);
11397 DropElement(player);
11399 MovePlayer(player, dx, dy);
11402 CheckSingleStepMode(player);
11404 SetPlayerWaiting(player, FALSE);
11406 return player_action;
11410 // no actions for this player (no input at player's configured device)
11412 DigField(player, 0, 0, 0, 0, 0, 0, DF_NO_PUSH);
11413 SnapField(player, 0, 0);
11414 CheckGravityMovementWhenNotMoving(player);
11416 if (player->MovPos == 0)
11417 SetPlayerWaiting(player, TRUE);
11419 if (player->MovPos == 0) // needed for tape.playing
11420 player->is_moving = FALSE;
11422 player->is_dropping = FALSE;
11423 player->is_dropping_pressed = FALSE;
11424 player->drop_pressed_delay = 0;
11426 CheckSingleStepMode(player);
11432 static void SetMouseActionFromTapeAction(struct MouseActionInfo *mouse_action,
11435 if (!tape.use_mouse_actions)
11438 mouse_action->lx = tape_action[TAPE_ACTION_LX];
11439 mouse_action->ly = tape_action[TAPE_ACTION_LY];
11440 mouse_action->button = tape_action[TAPE_ACTION_BUTTON];
11443 static void SetTapeActionFromMouseAction(byte *tape_action,
11444 struct MouseActionInfo *mouse_action)
11446 if (!tape.use_mouse_actions)
11449 tape_action[TAPE_ACTION_LX] = mouse_action->lx;
11450 tape_action[TAPE_ACTION_LY] = mouse_action->ly;
11451 tape_action[TAPE_ACTION_BUTTON] = mouse_action->button;
11454 static void CheckLevelSolved(void)
11456 if (level.game_engine_type == GAME_ENGINE_TYPE_EM)
11458 if (game_em.level_solved &&
11459 !game_em.game_over) // game won
11463 game_em.game_over = TRUE;
11465 game.all_players_gone = TRUE;
11468 if (game_em.game_over) // game lost
11469 game.all_players_gone = TRUE;
11471 else if (level.game_engine_type == GAME_ENGINE_TYPE_SP)
11473 if (game_sp.level_solved &&
11474 !game_sp.game_over) // game won
11478 game_sp.game_over = TRUE;
11480 game.all_players_gone = TRUE;
11483 if (game_sp.game_over) // game lost
11484 game.all_players_gone = TRUE;
11486 else if (level.game_engine_type == GAME_ENGINE_TYPE_MM)
11488 if (game_mm.level_solved &&
11489 !game_mm.game_over) // game won
11493 game_mm.game_over = TRUE;
11495 game.all_players_gone = TRUE;
11498 if (game_mm.game_over) // game lost
11499 game.all_players_gone = TRUE;
11503 static void CheckLevelTime(void)
11507 if (TimeFrames >= FRAMES_PER_SECOND)
11512 for (i = 0; i < MAX_PLAYERS; i++)
11514 struct PlayerInfo *player = &stored_player[i];
11516 if (SHIELD_ON(player))
11518 player->shield_normal_time_left--;
11520 if (player->shield_deadly_time_left > 0)
11521 player->shield_deadly_time_left--;
11525 if (!game.LevelSolved && !level.use_step_counter)
11533 if (TimeLeft <= 10 && setup.time_limit)
11534 PlaySound(SND_GAME_RUNNING_OUT_OF_TIME);
11536 /* this does not make sense: game_panel_controls[GAME_PANEL_TIME].value
11537 is reset from other values in UpdateGameDoorValues() -- FIX THIS */
11539 game_panel_controls[GAME_PANEL_TIME].value = TimeLeft;
11541 if (!TimeLeft && setup.time_limit)
11543 if (level.game_engine_type == GAME_ENGINE_TYPE_EM)
11544 game_em.lev->killed_out_of_time = TRUE;
11546 for (i = 0; i < MAX_PLAYERS; i++)
11547 KillPlayer(&stored_player[i]);
11550 else if (game.no_time_limit && !game.all_players_gone)
11552 game_panel_controls[GAME_PANEL_TIME].value = TimePlayed;
11555 game_em.lev->time = (game.no_time_limit ? TimePlayed : TimeLeft);
11558 if (tape.recording || tape.playing)
11559 DrawVideoDisplay(VIDEO_STATE_TIME_ON, TapeTime);
11562 if (tape.recording || tape.playing)
11563 DrawVideoDisplay(VIDEO_STATE_FRAME_ON, FrameCounter);
11565 UpdateAndDisplayGameControlValues();
11568 void AdvanceFrameAndPlayerCounters(int player_nr)
11572 // advance frame counters (global frame counter and time frame counter)
11576 // advance player counters (counters for move delay, move animation etc.)
11577 for (i = 0; i < MAX_PLAYERS; i++)
11579 boolean advance_player_counters = (player_nr == -1 || player_nr == i);
11580 int move_delay_value = stored_player[i].move_delay_value;
11581 int move_frames = MOVE_DELAY_NORMAL_SPEED / move_delay_value;
11583 if (!advance_player_counters) // not all players may be affected
11586 if (move_frames == 0) // less than one move per game frame
11588 int stepsize = TILEX / move_delay_value;
11589 int delay = move_delay_value / MOVE_DELAY_NORMAL_SPEED;
11590 int count = (stored_player[i].is_moving ?
11591 ABS(stored_player[i].MovPos) / stepsize : FrameCounter);
11593 if (count % delay == 0)
11597 stored_player[i].Frame += move_frames;
11599 if (stored_player[i].MovPos != 0)
11600 stored_player[i].StepFrame += move_frames;
11602 if (stored_player[i].move_delay > 0)
11603 stored_player[i].move_delay--;
11605 // due to bugs in previous versions, counter must count up, not down
11606 if (stored_player[i].push_delay != -1)
11607 stored_player[i].push_delay++;
11609 if (stored_player[i].drop_delay > 0)
11610 stored_player[i].drop_delay--;
11612 if (stored_player[i].is_dropping_pressed)
11613 stored_player[i].drop_pressed_delay++;
11617 void StartGameActions(boolean init_network_game, boolean record_tape,
11620 unsigned int new_random_seed = InitRND(random_seed);
11623 TapeStartRecording(new_random_seed);
11625 if (init_network_game)
11627 SendToServer_LevelFile();
11628 SendToServer_StartPlaying();
11636 static void GameActionsExt(void)
11639 static unsigned int game_frame_delay = 0;
11641 unsigned int game_frame_delay_value;
11642 byte *recorded_player_action;
11643 byte summarized_player_action = 0;
11644 byte tape_action[MAX_TAPE_ACTIONS] = { 0 };
11647 // detect endless loops, caused by custom element programming
11648 if (recursion_loop_detected && recursion_loop_depth == 0)
11650 char *message = getStringCat3("Internal Error! Element ",
11651 EL_NAME(recursion_loop_element),
11652 " caused endless loop! Quit the game?");
11654 Warn("element '%s' caused endless loop in game engine",
11655 EL_NAME(recursion_loop_element));
11657 RequestQuitGameExt(FALSE, level_editor_test_game, message);
11659 recursion_loop_detected = FALSE; // if game should be continued
11666 if (game.restart_level)
11667 StartGameActions(network.enabled, setup.autorecord, level.random_seed);
11669 CheckLevelSolved();
11671 if (game.LevelSolved && !game.LevelSolved_GameEnd)
11674 if (game.all_players_gone && !TAPE_IS_STOPPED(tape))
11677 if (game_status != GAME_MODE_PLAYING) // status might have changed
11680 game_frame_delay_value =
11681 (tape.playing && tape.fast_forward ? FfwdFrameDelay : GameFrameDelay);
11683 if (tape.playing && tape.warp_forward && !tape.pausing)
11684 game_frame_delay_value = 0;
11686 SetVideoFrameDelay(game_frame_delay_value);
11688 // (de)activate virtual buttons depending on current game status
11689 if (strEqual(setup.touch.control_type, TOUCH_CONTROL_VIRTUAL_BUTTONS))
11691 if (game.all_players_gone) // if no players there to be controlled anymore
11692 SetOverlayActive(FALSE);
11693 else if (!tape.playing) // if game continues after tape stopped playing
11694 SetOverlayActive(TRUE);
11699 // ---------- main game synchronization point ----------
11701 int skip = WaitUntilDelayReached(&game_frame_delay, game_frame_delay_value);
11703 Debug("game:playing:skip", "skip == %d", skip);
11706 // ---------- main game synchronization point ----------
11708 WaitUntilDelayReached(&game_frame_delay, game_frame_delay_value);
11712 if (network_playing && !network_player_action_received)
11714 // try to get network player actions in time
11716 // last chance to get network player actions without main loop delay
11717 HandleNetworking();
11719 // game was quit by network peer
11720 if (game_status != GAME_MODE_PLAYING)
11723 // check if network player actions still missing and game still running
11724 if (!network_player_action_received && !checkGameEnded())
11725 return; // failed to get network player actions in time
11727 // do not yet reset "network_player_action_received" (for tape.pausing)
11733 // at this point we know that we really continue executing the game
11735 network_player_action_received = FALSE;
11737 // when playing tape, read previously recorded player input from tape data
11738 recorded_player_action = (tape.playing ? TapePlayAction() : NULL);
11740 local_player->effective_mouse_action = local_player->mouse_action;
11742 if (recorded_player_action != NULL)
11743 SetMouseActionFromTapeAction(&local_player->effective_mouse_action,
11744 recorded_player_action);
11746 // TapePlayAction() may return NULL when toggling to "pause before death"
11750 if (tape.set_centered_player)
11752 game.centered_player_nr_next = tape.centered_player_nr_next;
11753 game.set_centered_player = TRUE;
11756 for (i = 0; i < MAX_PLAYERS; i++)
11758 summarized_player_action |= stored_player[i].action;
11760 if (!network_playing && (game.team_mode || tape.playing))
11761 stored_player[i].effective_action = stored_player[i].action;
11764 if (network_playing && !checkGameEnded())
11765 SendToServer_MovePlayer(summarized_player_action);
11767 // summarize all actions at local players mapped input device position
11768 // (this allows using different input devices in single player mode)
11769 if (!network.enabled && !game.team_mode)
11770 stored_player[map_player_action[local_player->index_nr]].effective_action =
11771 summarized_player_action;
11773 // summarize all actions at centered player in local team mode
11774 if (tape.recording &&
11775 setup.team_mode && !network.enabled &&
11776 setup.input_on_focus &&
11777 game.centered_player_nr != -1)
11779 for (i = 0; i < MAX_PLAYERS; i++)
11780 stored_player[map_player_action[i]].effective_action =
11781 (i == game.centered_player_nr ? summarized_player_action : 0);
11784 if (recorded_player_action != NULL)
11785 for (i = 0; i < MAX_PLAYERS; i++)
11786 stored_player[i].effective_action = recorded_player_action[i];
11788 for (i = 0; i < MAX_PLAYERS; i++)
11790 tape_action[i] = stored_player[i].effective_action;
11792 /* (this may happen in the RND game engine if a player was not present on
11793 the playfield on level start, but appeared later from a custom element */
11794 if (setup.team_mode &&
11797 !tape.player_participates[i])
11798 tape.player_participates[i] = TRUE;
11801 SetTapeActionFromMouseAction(tape_action,
11802 &local_player->effective_mouse_action);
11804 // only record actions from input devices, but not programmed actions
11805 if (tape.recording)
11806 TapeRecordAction(tape_action);
11808 // remember if game was played (especially after tape stopped playing)
11809 if (!tape.playing && summarized_player_action)
11810 game.GamePlayed = TRUE;
11812 #if USE_NEW_PLAYER_ASSIGNMENTS
11813 // !!! also map player actions in single player mode !!!
11814 // if (game.team_mode)
11817 byte mapped_action[MAX_PLAYERS];
11819 #if DEBUG_PLAYER_ACTIONS
11820 for (i = 0; i < MAX_PLAYERS; i++)
11821 DebugContinued("", "%d, ", stored_player[i].effective_action);
11824 for (i = 0; i < MAX_PLAYERS; i++)
11825 mapped_action[i] = stored_player[map_player_action[i]].effective_action;
11827 for (i = 0; i < MAX_PLAYERS; i++)
11828 stored_player[i].effective_action = mapped_action[i];
11830 #if DEBUG_PLAYER_ACTIONS
11831 DebugContinued("", "=> ");
11832 for (i = 0; i < MAX_PLAYERS; i++)
11833 DebugContinued("", "%d, ", stored_player[i].effective_action);
11834 DebugContinued("game:playing:player", "\n");
11837 #if DEBUG_PLAYER_ACTIONS
11840 for (i = 0; i < MAX_PLAYERS; i++)
11841 DebugContinued("", "%d, ", stored_player[i].effective_action);
11842 DebugContinued("game:playing:player", "\n");
11847 for (i = 0; i < MAX_PLAYERS; i++)
11849 // allow engine snapshot in case of changed movement attempt
11850 if ((game.snapshot.last_action[i] & KEY_MOTION) !=
11851 (stored_player[i].effective_action & KEY_MOTION))
11852 game.snapshot.changed_action = TRUE;
11854 // allow engine snapshot in case of snapping/dropping attempt
11855 if ((game.snapshot.last_action[i] & KEY_BUTTON) == 0 &&
11856 (stored_player[i].effective_action & KEY_BUTTON) != 0)
11857 game.snapshot.changed_action = TRUE;
11859 game.snapshot.last_action[i] = stored_player[i].effective_action;
11862 if (level.game_engine_type == GAME_ENGINE_TYPE_EM)
11864 GameActions_EM_Main();
11866 else if (level.game_engine_type == GAME_ENGINE_TYPE_SP)
11868 GameActions_SP_Main();
11870 else if (level.game_engine_type == GAME_ENGINE_TYPE_MM)
11872 GameActions_MM_Main();
11876 GameActions_RND_Main();
11879 BlitScreenToBitmap(backbuffer);
11881 CheckLevelSolved();
11884 AdvanceFrameAndPlayerCounters(-1); // advance counters for all players
11886 if (global.show_frames_per_second)
11888 static unsigned int fps_counter = 0;
11889 static int fps_frames = 0;
11890 unsigned int fps_delay_ms = Counter() - fps_counter;
11894 if (fps_delay_ms >= 500) // calculate FPS every 0.5 seconds
11896 global.frames_per_second = 1000 * (float)fps_frames / fps_delay_ms;
11899 fps_counter = Counter();
11901 // always draw FPS to screen after FPS value was updated
11902 redraw_mask |= REDRAW_FPS;
11905 // only draw FPS if no screen areas are deactivated (invisible warp mode)
11906 if (GetDrawDeactivationMask() == REDRAW_NONE)
11907 redraw_mask |= REDRAW_FPS;
11911 static void GameActions_CheckSaveEngineSnapshot(void)
11913 if (!game.snapshot.save_snapshot)
11916 // clear flag for saving snapshot _before_ saving snapshot
11917 game.snapshot.save_snapshot = FALSE;
11919 SaveEngineSnapshotToList();
11922 void GameActions(void)
11926 GameActions_CheckSaveEngineSnapshot();
11929 void GameActions_EM_Main(void)
11931 byte effective_action[MAX_PLAYERS];
11932 boolean warp_mode = (tape.playing && tape.warp_forward && !tape.pausing);
11935 for (i = 0; i < MAX_PLAYERS; i++)
11936 effective_action[i] = stored_player[i].effective_action;
11938 GameActions_EM(effective_action, warp_mode);
11941 void GameActions_SP_Main(void)
11943 byte effective_action[MAX_PLAYERS];
11944 boolean warp_mode = (tape.playing && tape.warp_forward && !tape.pausing);
11947 for (i = 0; i < MAX_PLAYERS; i++)
11948 effective_action[i] = stored_player[i].effective_action;
11950 GameActions_SP(effective_action, warp_mode);
11952 for (i = 0; i < MAX_PLAYERS; i++)
11954 if (stored_player[i].force_dropping)
11955 stored_player[i].action |= KEY_BUTTON_DROP;
11957 stored_player[i].force_dropping = FALSE;
11961 void GameActions_MM_Main(void)
11963 boolean warp_mode = (tape.playing && tape.warp_forward && !tape.pausing);
11965 GameActions_MM(local_player->effective_mouse_action, warp_mode);
11968 void GameActions_RND_Main(void)
11973 void GameActions_RND(void)
11975 static struct MouseActionInfo mouse_action_last = { 0 };
11976 struct MouseActionInfo mouse_action = local_player->effective_mouse_action;
11977 int magic_wall_x = 0, magic_wall_y = 0;
11978 int i, x, y, element, graphic, last_gfx_frame;
11980 InitPlayfieldScanModeVars();
11982 if (game.engine_version >= VERSION_IDENT(3,2,0,7))
11984 SCAN_PLAYFIELD(x, y)
11986 ChangeCount[x][y] = 0;
11987 ChangeEvent[x][y] = -1;
11991 if (game.set_centered_player)
11993 boolean all_players_fit_to_screen = checkIfAllPlayersFitToScreen_RND();
11995 // switching to "all players" only possible if all players fit to screen
11996 if (game.centered_player_nr_next == -1 && !all_players_fit_to_screen)
11998 game.centered_player_nr_next = game.centered_player_nr;
11999 game.set_centered_player = FALSE;
12002 // do not switch focus to non-existing (or non-active) player
12003 if (game.centered_player_nr_next >= 0 &&
12004 !stored_player[game.centered_player_nr_next].active)
12006 game.centered_player_nr_next = game.centered_player_nr;
12007 game.set_centered_player = FALSE;
12011 if (game.set_centered_player &&
12012 ScreenMovPos == 0) // screen currently aligned at tile position
12016 if (game.centered_player_nr_next == -1)
12018 setScreenCenteredToAllPlayers(&sx, &sy);
12022 sx = stored_player[game.centered_player_nr_next].jx;
12023 sy = stored_player[game.centered_player_nr_next].jy;
12026 game.centered_player_nr = game.centered_player_nr_next;
12027 game.set_centered_player = FALSE;
12029 DrawRelocateScreen(0, 0, sx, sy, MV_NONE, TRUE, setup.quick_switch);
12030 DrawGameDoorValues();
12033 // check single step mode (set flag and clear again if any player is active)
12034 game.enter_single_step_mode =
12035 (tape.single_step && tape.recording && !tape.pausing);
12037 for (i = 0; i < MAX_PLAYERS; i++)
12039 int actual_player_action = stored_player[i].effective_action;
12042 /* !!! THIS BREAKS THE FOLLOWING TAPES: !!!
12043 - rnd_equinox_tetrachloride 048
12044 - rnd_equinox_tetrachloride_ii 096
12045 - rnd_emanuel_schmieg 002
12046 - doctor_sloan_ww 001, 020
12048 if (stored_player[i].MovPos == 0)
12049 CheckGravityMovement(&stored_player[i]);
12052 // overwrite programmed action with tape action
12053 if (stored_player[i].programmed_action)
12054 actual_player_action = stored_player[i].programmed_action;
12056 PlayerActions(&stored_player[i], actual_player_action);
12058 ScrollPlayer(&stored_player[i], SCROLL_GO_ON);
12061 // single step pause mode may already have been toggled by "ScrollPlayer()"
12062 if (game.enter_single_step_mode && !tape.pausing)
12063 TapeTogglePause(TAPE_TOGGLE_AUTOMATIC);
12065 ScrollScreen(NULL, SCROLL_GO_ON);
12067 /* for backwards compatibility, the following code emulates a fixed bug that
12068 occured when pushing elements (causing elements that just made their last
12069 pushing step to already (if possible) make their first falling step in the
12070 same game frame, which is bad); this code is also needed to use the famous
12071 "spring push bug" which is used in older levels and might be wanted to be
12072 used also in newer levels, but in this case the buggy pushing code is only
12073 affecting the "spring" element and no other elements */
12075 if (game.engine_version < VERSION_IDENT(2,2,0,7) || level.use_spring_bug)
12077 for (i = 0; i < MAX_PLAYERS; i++)
12079 struct PlayerInfo *player = &stored_player[i];
12080 int x = player->jx;
12081 int y = player->jy;
12083 if (player->active && player->is_pushing && player->is_moving &&
12085 (game.engine_version < VERSION_IDENT(2,2,0,7) ||
12086 Tile[x][y] == EL_SPRING))
12088 ContinueMoving(x, y);
12090 // continue moving after pushing (this is actually a bug)
12091 if (!IS_MOVING(x, y))
12092 Stop[x][y] = FALSE;
12097 SCAN_PLAYFIELD(x, y)
12099 Last[x][y] = Tile[x][y];
12101 ChangeCount[x][y] = 0;
12102 ChangeEvent[x][y] = -1;
12104 // this must be handled before main playfield loop
12105 if (Tile[x][y] == EL_PLAYER_IS_LEAVING)
12108 if (MovDelay[x][y] <= 0)
12112 if (Tile[x][y] == EL_ELEMENT_SNAPPING)
12115 if (MovDelay[x][y] <= 0)
12117 int element = Store[x][y];
12118 int move_direction = MovDir[x][y];
12119 int player_index_bit = Store2[x][y];
12125 TEST_DrawLevelField(x, y);
12127 TestFieldAfterSnapping(x, y, element, move_direction, player_index_bit);
12132 if (ChangePage[x][y] != -1 && ChangeDelay[x][y] != 1)
12134 Debug("game:playing:GameActions_RND", "x = %d, y = %d: ChangePage != -1",
12136 Debug("game:playing:GameActions_RND", "This should never happen!");
12138 ChangePage[x][y] = -1;
12142 Stop[x][y] = FALSE;
12143 if (WasJustMoving[x][y] > 0)
12144 WasJustMoving[x][y]--;
12145 if (WasJustFalling[x][y] > 0)
12146 WasJustFalling[x][y]--;
12147 if (CheckCollision[x][y] > 0)
12148 CheckCollision[x][y]--;
12149 if (CheckImpact[x][y] > 0)
12150 CheckImpact[x][y]--;
12154 /* reset finished pushing action (not done in ContinueMoving() to allow
12155 continuous pushing animation for elements with zero push delay) */
12156 if (GfxAction[x][y] == ACTION_PUSHING && !IS_MOVING(x, y))
12158 ResetGfxAnimation(x, y);
12159 TEST_DrawLevelField(x, y);
12163 if (IS_BLOCKED(x, y))
12167 Blocked2Moving(x, y, &oldx, &oldy);
12168 if (!IS_MOVING(oldx, oldy))
12170 Debug("game:playing:GameActions_RND", "(BLOCKED => MOVING) context corrupted!");
12171 Debug("game:playing:GameActions_RND", "BLOCKED: x = %d, y = %d", x, y);
12172 Debug("game:playing:GameActions_RND", "!MOVING: oldx = %d, oldy = %d", oldx, oldy);
12173 Debug("game:playing:GameActions_RND", "This should never happen!");
12179 if (mouse_action.button)
12181 int new_button = (mouse_action.button && mouse_action_last.button == 0);
12182 int ch_button = CH_SIDE_FROM_BUTTON(mouse_action.button);
12184 x = mouse_action.lx;
12185 y = mouse_action.ly;
12186 element = Tile[x][y];
12190 CheckElementChangeByMouse(x, y, element, CE_CLICKED_BY_MOUSE, ch_button);
12191 CheckTriggeredElementChangeByMouse(x, y, element, CE_MOUSE_CLICKED_ON_X,
12195 CheckElementChangeByMouse(x, y, element, CE_PRESSED_BY_MOUSE, ch_button);
12196 CheckTriggeredElementChangeByMouse(x, y, element, CE_MOUSE_PRESSED_ON_X,
12200 SCAN_PLAYFIELD(x, y)
12202 element = Tile[x][y];
12203 graphic = el_act_dir2img(element, GfxAction[x][y], GfxDir[x][y]);
12204 last_gfx_frame = GfxFrame[x][y];
12206 ResetGfxFrame(x, y);
12208 if (GfxFrame[x][y] != last_gfx_frame && !Stop[x][y])
12209 DrawLevelGraphicAnimation(x, y, graphic);
12211 if (ANIM_MODE(graphic) == ANIM_RANDOM &&
12212 IS_NEXT_FRAME(GfxFrame[x][y], graphic))
12213 ResetRandomAnimationValue(x, y);
12215 SetRandomAnimationValue(x, y);
12217 PlayLevelSoundActionIfLoop(x, y, GfxAction[x][y]);
12219 if (IS_INACTIVE(element))
12221 if (IS_ANIMATED(graphic))
12222 DrawLevelGraphicAnimationIfNeeded(x, y, graphic);
12227 // this may take place after moving, so 'element' may have changed
12228 if (IS_CHANGING(x, y) &&
12229 (game.engine_version < VERSION_IDENT(3,0,7,1) || !Stop[x][y]))
12231 int page = element_info[element].event_page_nr[CE_DELAY];
12233 HandleElementChange(x, y, page);
12235 element = Tile[x][y];
12236 graphic = el_act_dir2img(element, GfxAction[x][y], GfxDir[x][y]);
12239 if (!IS_MOVING(x, y) && (CAN_FALL(element) || CAN_MOVE(element)))
12243 element = Tile[x][y];
12244 graphic = el_act_dir2img(element, GfxAction[x][y], GfxDir[x][y]);
12246 if (IS_ANIMATED(graphic) &&
12247 !IS_MOVING(x, y) &&
12249 DrawLevelGraphicAnimationIfNeeded(x, y, graphic);
12251 if (IS_GEM(element) || element == EL_SP_INFOTRON)
12252 TEST_DrawTwinkleOnField(x, y);
12254 else if (element == EL_ACID)
12257 DrawLevelGraphicAnimationIfNeeded(x, y, graphic);
12259 else if ((element == EL_EXIT_OPEN ||
12260 element == EL_EM_EXIT_OPEN ||
12261 element == EL_SP_EXIT_OPEN ||
12262 element == EL_STEEL_EXIT_OPEN ||
12263 element == EL_EM_STEEL_EXIT_OPEN ||
12264 element == EL_SP_TERMINAL ||
12265 element == EL_SP_TERMINAL_ACTIVE ||
12266 element == EL_EXTRA_TIME ||
12267 element == EL_SHIELD_NORMAL ||
12268 element == EL_SHIELD_DEADLY) &&
12269 IS_ANIMATED(graphic))
12270 DrawLevelGraphicAnimationIfNeeded(x, y, graphic);
12271 else if (IS_MOVING(x, y))
12272 ContinueMoving(x, y);
12273 else if (IS_ACTIVE_BOMB(element))
12274 CheckDynamite(x, y);
12275 else if (element == EL_AMOEBA_GROWING)
12276 AmoebaGrowing(x, y);
12277 else if (element == EL_AMOEBA_SHRINKING)
12278 AmoebaShrinking(x, y);
12280 #if !USE_NEW_AMOEBA_CODE
12281 else if (IS_AMOEBALIVE(element))
12282 AmoebaReproduce(x, y);
12285 else if (element == EL_GAME_OF_LIFE || element == EL_BIOMAZE)
12287 else if (element == EL_EXIT_CLOSED)
12289 else if (element == EL_EM_EXIT_CLOSED)
12291 else if (element == EL_STEEL_EXIT_CLOSED)
12292 CheckExitSteel(x, y);
12293 else if (element == EL_EM_STEEL_EXIT_CLOSED)
12294 CheckExitSteelEM(x, y);
12295 else if (element == EL_SP_EXIT_CLOSED)
12297 else if (element == EL_EXPANDABLE_WALL_GROWING ||
12298 element == EL_EXPANDABLE_STEELWALL_GROWING)
12299 MauerWaechst(x, y);
12300 else if (element == EL_EXPANDABLE_WALL ||
12301 element == EL_EXPANDABLE_WALL_HORIZONTAL ||
12302 element == EL_EXPANDABLE_WALL_VERTICAL ||
12303 element == EL_EXPANDABLE_WALL_ANY ||
12304 element == EL_BD_EXPANDABLE_WALL)
12305 MauerAbleger(x, y);
12306 else if (element == EL_EXPANDABLE_STEELWALL_HORIZONTAL ||
12307 element == EL_EXPANDABLE_STEELWALL_VERTICAL ||
12308 element == EL_EXPANDABLE_STEELWALL_ANY)
12309 MauerAblegerStahl(x, y);
12310 else if (element == EL_FLAMES)
12311 CheckForDragon(x, y);
12312 else if (element == EL_EXPLOSION)
12313 ; // drawing of correct explosion animation is handled separately
12314 else if (element == EL_ELEMENT_SNAPPING ||
12315 element == EL_DIAGONAL_SHRINKING ||
12316 element == EL_DIAGONAL_GROWING)
12318 graphic = el_act_dir2img(GfxElement[x][y], GfxAction[x][y],GfxDir[x][y]);
12320 DrawLevelGraphicAnimationIfNeeded(x, y, graphic);
12322 else if (IS_ANIMATED(graphic) && !IS_CHANGING(x, y))
12323 DrawLevelGraphicAnimationIfNeeded(x, y, graphic);
12325 if (IS_BELT_ACTIVE(element))
12326 PlayLevelSoundAction(x, y, ACTION_ACTIVE);
12328 if (game.magic_wall_active)
12330 int jx = local_player->jx, jy = local_player->jy;
12332 // play the element sound at the position nearest to the player
12333 if ((element == EL_MAGIC_WALL_FULL ||
12334 element == EL_MAGIC_WALL_ACTIVE ||
12335 element == EL_MAGIC_WALL_EMPTYING ||
12336 element == EL_BD_MAGIC_WALL_FULL ||
12337 element == EL_BD_MAGIC_WALL_ACTIVE ||
12338 element == EL_BD_MAGIC_WALL_EMPTYING ||
12339 element == EL_DC_MAGIC_WALL_FULL ||
12340 element == EL_DC_MAGIC_WALL_ACTIVE ||
12341 element == EL_DC_MAGIC_WALL_EMPTYING) &&
12342 ABS(x - jx) + ABS(y - jy) <
12343 ABS(magic_wall_x - jx) + ABS(magic_wall_y - jy))
12351 #if USE_NEW_AMOEBA_CODE
12352 // new experimental amoeba growth stuff
12353 if (!(FrameCounter % 8))
12355 static unsigned int random = 1684108901;
12357 for (i = 0; i < level.amoeba_speed * 28 / 8; i++)
12359 x = RND(lev_fieldx);
12360 y = RND(lev_fieldy);
12361 element = Tile[x][y];
12363 if (!IS_PLAYER(x,y) &&
12364 (element == EL_EMPTY ||
12365 CAN_GROW_INTO(element) ||
12366 element == EL_QUICKSAND_EMPTY ||
12367 element == EL_QUICKSAND_FAST_EMPTY ||
12368 element == EL_ACID_SPLASH_LEFT ||
12369 element == EL_ACID_SPLASH_RIGHT))
12371 if ((IN_LEV_FIELD(x, y-1) && Tile[x][y-1] == EL_AMOEBA_WET) ||
12372 (IN_LEV_FIELD(x-1, y) && Tile[x-1][y] == EL_AMOEBA_WET) ||
12373 (IN_LEV_FIELD(x+1, y) && Tile[x+1][y] == EL_AMOEBA_WET) ||
12374 (IN_LEV_FIELD(x, y+1) && Tile[x][y+1] == EL_AMOEBA_WET))
12375 Tile[x][y] = EL_AMOEBA_DROP;
12378 random = random * 129 + 1;
12383 game.explosions_delayed = FALSE;
12385 SCAN_PLAYFIELD(x, y)
12387 element = Tile[x][y];
12389 if (ExplodeField[x][y])
12390 Explode(x, y, EX_PHASE_START, ExplodeField[x][y]);
12391 else if (element == EL_EXPLOSION)
12392 Explode(x, y, ExplodePhase[x][y], EX_TYPE_NORMAL);
12394 ExplodeField[x][y] = EX_TYPE_NONE;
12397 game.explosions_delayed = TRUE;
12399 if (game.magic_wall_active)
12401 if (!(game.magic_wall_time_left % 4))
12403 int element = Tile[magic_wall_x][magic_wall_y];
12405 if (element == EL_BD_MAGIC_WALL_FULL ||
12406 element == EL_BD_MAGIC_WALL_ACTIVE ||
12407 element == EL_BD_MAGIC_WALL_EMPTYING)
12408 PlayLevelSound(magic_wall_x, magic_wall_y, SND_BD_MAGIC_WALL_ACTIVE);
12409 else if (element == EL_DC_MAGIC_WALL_FULL ||
12410 element == EL_DC_MAGIC_WALL_ACTIVE ||
12411 element == EL_DC_MAGIC_WALL_EMPTYING)
12412 PlayLevelSound(magic_wall_x, magic_wall_y, SND_DC_MAGIC_WALL_ACTIVE);
12414 PlayLevelSound(magic_wall_x, magic_wall_y, SND_MAGIC_WALL_ACTIVE);
12417 if (game.magic_wall_time_left > 0)
12419 game.magic_wall_time_left--;
12421 if (!game.magic_wall_time_left)
12423 SCAN_PLAYFIELD(x, y)
12425 element = Tile[x][y];
12427 if (element == EL_MAGIC_WALL_ACTIVE ||
12428 element == EL_MAGIC_WALL_FULL)
12430 Tile[x][y] = EL_MAGIC_WALL_DEAD;
12431 TEST_DrawLevelField(x, y);
12433 else if (element == EL_BD_MAGIC_WALL_ACTIVE ||
12434 element == EL_BD_MAGIC_WALL_FULL)
12436 Tile[x][y] = EL_BD_MAGIC_WALL_DEAD;
12437 TEST_DrawLevelField(x, y);
12439 else if (element == EL_DC_MAGIC_WALL_ACTIVE ||
12440 element == EL_DC_MAGIC_WALL_FULL)
12442 Tile[x][y] = EL_DC_MAGIC_WALL_DEAD;
12443 TEST_DrawLevelField(x, y);
12447 game.magic_wall_active = FALSE;
12452 if (game.light_time_left > 0)
12454 game.light_time_left--;
12456 if (game.light_time_left == 0)
12457 RedrawAllLightSwitchesAndInvisibleElements();
12460 if (game.timegate_time_left > 0)
12462 game.timegate_time_left--;
12464 if (game.timegate_time_left == 0)
12465 CloseAllOpenTimegates();
12468 if (game.lenses_time_left > 0)
12470 game.lenses_time_left--;
12472 if (game.lenses_time_left == 0)
12473 RedrawAllInvisibleElementsForLenses();
12476 if (game.magnify_time_left > 0)
12478 game.magnify_time_left--;
12480 if (game.magnify_time_left == 0)
12481 RedrawAllInvisibleElementsForMagnifier();
12484 for (i = 0; i < MAX_PLAYERS; i++)
12486 struct PlayerInfo *player = &stored_player[i];
12488 if (SHIELD_ON(player))
12490 if (player->shield_deadly_time_left)
12491 PlayLevelSound(player->jx, player->jy, SND_SHIELD_DEADLY_ACTIVE);
12492 else if (player->shield_normal_time_left)
12493 PlayLevelSound(player->jx, player->jy, SND_SHIELD_NORMAL_ACTIVE);
12497 #if USE_DELAYED_GFX_REDRAW
12498 SCAN_PLAYFIELD(x, y)
12500 if (GfxRedraw[x][y] != GFX_REDRAW_NONE)
12502 /* !!! PROBLEM: THIS REDRAWS THE PLAYFIELD _AFTER_ THE SCAN, BUT TILES
12503 !!! MAY HAVE CHANGED AFTER BEING DRAWN DURING PLAYFIELD SCAN !!! */
12505 if (GfxRedraw[x][y] & GFX_REDRAW_TILE)
12506 DrawLevelField(x, y);
12508 if (GfxRedraw[x][y] & GFX_REDRAW_TILE_CRUMBLED)
12509 DrawLevelFieldCrumbled(x, y);
12511 if (GfxRedraw[x][y] & GFX_REDRAW_TILE_CRUMBLED_NEIGHBOURS)
12512 DrawLevelFieldCrumbledNeighbours(x, y);
12514 if (GfxRedraw[x][y] & GFX_REDRAW_TILE_TWINKLED)
12515 DrawTwinkleOnField(x, y);
12518 GfxRedraw[x][y] = GFX_REDRAW_NONE;
12523 PlayAllPlayersSound();
12525 for (i = 0; i < MAX_PLAYERS; i++)
12527 struct PlayerInfo *player = &stored_player[i];
12529 if (player->show_envelope != 0 && (!player->active ||
12530 player->MovPos == 0))
12532 ShowEnvelope(player->show_envelope - EL_ENVELOPE_1);
12534 player->show_envelope = 0;
12538 // use random number generator in every frame to make it less predictable
12539 if (game.engine_version >= VERSION_IDENT(3,1,1,0))
12542 mouse_action_last = mouse_action;
12545 static boolean AllPlayersInSight(struct PlayerInfo *player, int x, int y)
12547 int min_x = x, min_y = y, max_x = x, max_y = y;
12548 int scr_fieldx = getScreenFieldSizeX();
12549 int scr_fieldy = getScreenFieldSizeY();
12552 for (i = 0; i < MAX_PLAYERS; i++)
12554 int jx = stored_player[i].jx, jy = stored_player[i].jy;
12556 if (!stored_player[i].active || &stored_player[i] == player)
12559 min_x = MIN(min_x, jx);
12560 min_y = MIN(min_y, jy);
12561 max_x = MAX(max_x, jx);
12562 max_y = MAX(max_y, jy);
12565 return (max_x - min_x < scr_fieldx && max_y - min_y < scr_fieldy);
12568 static boolean AllPlayersInVisibleScreen(void)
12572 for (i = 0; i < MAX_PLAYERS; i++)
12574 int jx = stored_player[i].jx, jy = stored_player[i].jy;
12576 if (!stored_player[i].active)
12579 if (!IN_VIS_FIELD(SCREENX(jx), SCREENY(jy)))
12586 void ScrollLevel(int dx, int dy)
12588 int scroll_offset = 2 * TILEX_VAR;
12591 BlitBitmap(drawto_field, drawto_field,
12592 FX + TILEX_VAR * (dx == -1) - scroll_offset,
12593 FY + TILEY_VAR * (dy == -1) - scroll_offset,
12594 SXSIZE - TILEX_VAR * (dx != 0) + 2 * scroll_offset,
12595 SYSIZE - TILEY_VAR * (dy != 0) + 2 * scroll_offset,
12596 FX + TILEX_VAR * (dx == 1) - scroll_offset,
12597 FY + TILEY_VAR * (dy == 1) - scroll_offset);
12601 x = (dx == 1 ? BX1 : BX2);
12602 for (y = BY1; y <= BY2; y++)
12603 DrawScreenField(x, y);
12608 y = (dy == 1 ? BY1 : BY2);
12609 for (x = BX1; x <= BX2; x++)
12610 DrawScreenField(x, y);
12613 redraw_mask |= REDRAW_FIELD;
12616 static boolean canFallDown(struct PlayerInfo *player)
12618 int jx = player->jx, jy = player->jy;
12620 return (IN_LEV_FIELD(jx, jy + 1) &&
12621 (IS_FREE(jx, jy + 1) ||
12622 (Tile[jx][jy + 1] == EL_ACID && player->can_fall_into_acid)) &&
12623 IS_WALKABLE_FROM(Tile[jx][jy], MV_DOWN) &&
12624 !IS_WALKABLE_INSIDE(Tile[jx][jy]));
12627 static boolean canPassField(int x, int y, int move_dir)
12629 int opposite_dir = MV_DIR_OPPOSITE(move_dir);
12630 int dx = (move_dir & MV_LEFT ? -1 : move_dir & MV_RIGHT ? +1 : 0);
12631 int dy = (move_dir & MV_UP ? -1 : move_dir & MV_DOWN ? +1 : 0);
12632 int nextx = x + dx;
12633 int nexty = y + dy;
12634 int element = Tile[x][y];
12636 return (IS_PASSABLE_FROM(element, opposite_dir) &&
12637 !CAN_MOVE(element) &&
12638 IN_LEV_FIELD(nextx, nexty) && !IS_PLAYER(nextx, nexty) &&
12639 IS_WALKABLE_FROM(Tile[nextx][nexty], move_dir) &&
12640 (level.can_pass_to_walkable || IS_FREE(nextx, nexty)));
12643 static boolean canMoveToValidFieldWithGravity(int x, int y, int move_dir)
12645 int opposite_dir = MV_DIR_OPPOSITE(move_dir);
12646 int dx = (move_dir & MV_LEFT ? -1 : move_dir & MV_RIGHT ? +1 : 0);
12647 int dy = (move_dir & MV_UP ? -1 : move_dir & MV_DOWN ? +1 : 0);
12651 return (IN_LEV_FIELD(newx, newy) && !IS_FREE_OR_PLAYER(newx, newy) &&
12652 IS_GRAVITY_REACHABLE(Tile[newx][newy]) &&
12653 (IS_DIGGABLE(Tile[newx][newy]) ||
12654 IS_WALKABLE_FROM(Tile[newx][newy], opposite_dir) ||
12655 canPassField(newx, newy, move_dir)));
12658 static void CheckGravityMovement(struct PlayerInfo *player)
12660 if (player->gravity && !player->programmed_action)
12662 int move_dir_horizontal = player->effective_action & MV_HORIZONTAL;
12663 int move_dir_vertical = player->effective_action & MV_VERTICAL;
12664 boolean player_is_snapping = (player->effective_action & JOY_BUTTON_1);
12665 int jx = player->jx, jy = player->jy;
12666 boolean player_is_moving_to_valid_field =
12667 (!player_is_snapping &&
12668 (canMoveToValidFieldWithGravity(jx, jy, move_dir_horizontal) ||
12669 canMoveToValidFieldWithGravity(jx, jy, move_dir_vertical)));
12670 boolean player_can_fall_down = canFallDown(player);
12672 if (player_can_fall_down &&
12673 !player_is_moving_to_valid_field)
12674 player->programmed_action = MV_DOWN;
12678 static void CheckGravityMovementWhenNotMoving(struct PlayerInfo *player)
12680 return CheckGravityMovement(player);
12682 if (player->gravity && !player->programmed_action)
12684 int jx = player->jx, jy = player->jy;
12685 boolean field_under_player_is_free =
12686 (IN_LEV_FIELD(jx, jy + 1) && IS_FREE(jx, jy + 1));
12687 boolean player_is_standing_on_valid_field =
12688 (IS_WALKABLE_INSIDE(Tile[jx][jy]) ||
12689 (IS_WALKABLE(Tile[jx][jy]) &&
12690 !(element_info[Tile[jx][jy]].access_direction & MV_DOWN)));
12692 if (field_under_player_is_free && !player_is_standing_on_valid_field)
12693 player->programmed_action = MV_DOWN;
12698 MovePlayerOneStep()
12699 -----------------------------------------------------------------------------
12700 dx, dy: direction (non-diagonal) to try to move the player to
12701 real_dx, real_dy: direction as read from input device (can be diagonal)
12704 boolean MovePlayerOneStep(struct PlayerInfo *player,
12705 int dx, int dy, int real_dx, int real_dy)
12707 int jx = player->jx, jy = player->jy;
12708 int new_jx = jx + dx, new_jy = jy + dy;
12710 boolean player_can_move = !player->cannot_move;
12712 if (!player->active || (!dx && !dy))
12713 return MP_NO_ACTION;
12715 player->MovDir = (dx < 0 ? MV_LEFT :
12716 dx > 0 ? MV_RIGHT :
12718 dy > 0 ? MV_DOWN : MV_NONE);
12720 if (!IN_LEV_FIELD(new_jx, new_jy))
12721 return MP_NO_ACTION;
12723 if (!player_can_move)
12725 if (player->MovPos == 0)
12727 player->is_moving = FALSE;
12728 player->is_digging = FALSE;
12729 player->is_collecting = FALSE;
12730 player->is_snapping = FALSE;
12731 player->is_pushing = FALSE;
12735 if (!network.enabled && game.centered_player_nr == -1 &&
12736 !AllPlayersInSight(player, new_jx, new_jy))
12737 return MP_NO_ACTION;
12739 can_move = DigField(player, jx, jy, new_jx, new_jy, real_dx,real_dy, DF_DIG);
12740 if (can_move != MP_MOVING)
12743 // check if DigField() has caused relocation of the player
12744 if (player->jx != jx || player->jy != jy)
12745 return MP_NO_ACTION; // <-- !!! CHECK THIS [-> MP_ACTION ?] !!!
12747 StorePlayer[jx][jy] = 0;
12748 player->last_jx = jx;
12749 player->last_jy = jy;
12750 player->jx = new_jx;
12751 player->jy = new_jy;
12752 StorePlayer[new_jx][new_jy] = player->element_nr;
12754 if (player->move_delay_value_next != -1)
12756 player->move_delay_value = player->move_delay_value_next;
12757 player->move_delay_value_next = -1;
12761 (dx > 0 || dy > 0 ? -1 : 1) * (TILEX - TILEX / player->move_delay_value);
12763 player->step_counter++;
12765 PlayerVisit[jx][jy] = FrameCounter;
12767 player->is_moving = TRUE;
12770 // should better be called in MovePlayer(), but this breaks some tapes
12771 ScrollPlayer(player, SCROLL_INIT);
12777 boolean MovePlayer(struct PlayerInfo *player, int dx, int dy)
12779 int jx = player->jx, jy = player->jy;
12780 int old_jx = jx, old_jy = jy;
12781 int moved = MP_NO_ACTION;
12783 if (!player->active)
12788 if (player->MovPos == 0)
12790 player->is_moving = FALSE;
12791 player->is_digging = FALSE;
12792 player->is_collecting = FALSE;
12793 player->is_snapping = FALSE;
12794 player->is_pushing = FALSE;
12800 if (player->move_delay > 0)
12803 player->move_delay = -1; // set to "uninitialized" value
12805 // store if player is automatically moved to next field
12806 player->is_auto_moving = (player->programmed_action != MV_NONE);
12808 // remove the last programmed player action
12809 player->programmed_action = 0;
12811 if (player->MovPos)
12813 // should only happen if pre-1.2 tape recordings are played
12814 // this is only for backward compatibility
12816 int original_move_delay_value = player->move_delay_value;
12819 Debug("game:playing:MovePlayer",
12820 "THIS SHOULD ONLY HAPPEN WITH PRE-1.2 LEVEL TAPES. [%d]",
12824 // scroll remaining steps with finest movement resolution
12825 player->move_delay_value = MOVE_DELAY_NORMAL_SPEED;
12827 while (player->MovPos)
12829 ScrollPlayer(player, SCROLL_GO_ON);
12830 ScrollScreen(NULL, SCROLL_GO_ON);
12832 AdvanceFrameAndPlayerCounters(player->index_nr);
12835 BackToFront_WithFrameDelay(0);
12838 player->move_delay_value = original_move_delay_value;
12841 player->is_active = FALSE;
12843 if (player->last_move_dir & MV_HORIZONTAL)
12845 if (!(moved |= MovePlayerOneStep(player, 0, dy, dx, dy)))
12846 moved |= MovePlayerOneStep(player, dx, 0, dx, dy);
12850 if (!(moved |= MovePlayerOneStep(player, dx, 0, dx, dy)))
12851 moved |= MovePlayerOneStep(player, 0, dy, dx, dy);
12854 if (!moved && !player->is_active)
12856 player->is_moving = FALSE;
12857 player->is_digging = FALSE;
12858 player->is_collecting = FALSE;
12859 player->is_snapping = FALSE;
12860 player->is_pushing = FALSE;
12866 if (moved & MP_MOVING && !ScreenMovPos &&
12867 (player->index_nr == game.centered_player_nr ||
12868 game.centered_player_nr == -1))
12870 int old_scroll_x = scroll_x, old_scroll_y = scroll_y;
12872 if (!IN_VIS_FIELD(SCREENX(jx), SCREENY(jy)))
12874 // actual player has left the screen -- scroll in that direction
12875 if (jx != old_jx) // player has moved horizontally
12876 scroll_x += (jx - old_jx);
12877 else // player has moved vertically
12878 scroll_y += (jy - old_jy);
12882 int offset_raw = game.scroll_delay_value;
12884 if (jx != old_jx) // player has moved horizontally
12886 int offset = MIN(offset_raw, (SCR_FIELDX - 2) / 2);
12887 int offset_x = offset * (player->MovDir == MV_LEFT ? +1 : -1);
12888 int new_scroll_x = jx - MIDPOSX + offset_x;
12890 if ((player->MovDir == MV_LEFT && scroll_x > new_scroll_x) ||
12891 (player->MovDir == MV_RIGHT && scroll_x < new_scroll_x))
12892 scroll_x = new_scroll_x;
12894 // don't scroll over playfield boundaries
12895 scroll_x = MIN(MAX(SBX_Left, scroll_x), SBX_Right);
12897 // don't scroll more than one field at a time
12898 scroll_x = old_scroll_x + SIGN(scroll_x - old_scroll_x);
12900 // don't scroll against the player's moving direction
12901 if ((player->MovDir == MV_LEFT && scroll_x > old_scroll_x) ||
12902 (player->MovDir == MV_RIGHT && scroll_x < old_scroll_x))
12903 scroll_x = old_scroll_x;
12905 else // player has moved vertically
12907 int offset = MIN(offset_raw, (SCR_FIELDY - 2) / 2);
12908 int offset_y = offset * (player->MovDir == MV_UP ? +1 : -1);
12909 int new_scroll_y = jy - MIDPOSY + offset_y;
12911 if ((player->MovDir == MV_UP && scroll_y > new_scroll_y) ||
12912 (player->MovDir == MV_DOWN && scroll_y < new_scroll_y))
12913 scroll_y = new_scroll_y;
12915 // don't scroll over playfield boundaries
12916 scroll_y = MIN(MAX(SBY_Upper, scroll_y), SBY_Lower);
12918 // don't scroll more than one field at a time
12919 scroll_y = old_scroll_y + SIGN(scroll_y - old_scroll_y);
12921 // don't scroll against the player's moving direction
12922 if ((player->MovDir == MV_UP && scroll_y > old_scroll_y) ||
12923 (player->MovDir == MV_DOWN && scroll_y < old_scroll_y))
12924 scroll_y = old_scroll_y;
12928 if (scroll_x != old_scroll_x || scroll_y != old_scroll_y)
12930 if (!network.enabled && game.centered_player_nr == -1 &&
12931 !AllPlayersInVisibleScreen())
12933 scroll_x = old_scroll_x;
12934 scroll_y = old_scroll_y;
12938 ScrollScreen(player, SCROLL_INIT);
12939 ScrollLevel(old_scroll_x - scroll_x, old_scroll_y - scroll_y);
12944 player->StepFrame = 0;
12946 if (moved & MP_MOVING)
12948 if (old_jx != jx && old_jy == jy)
12949 player->MovDir = (old_jx < jx ? MV_RIGHT : MV_LEFT);
12950 else if (old_jx == jx && old_jy != jy)
12951 player->MovDir = (old_jy < jy ? MV_DOWN : MV_UP);
12953 TEST_DrawLevelField(jx, jy); // for "crumbled sand"
12955 player->last_move_dir = player->MovDir;
12956 player->is_moving = TRUE;
12957 player->is_snapping = FALSE;
12958 player->is_switching = FALSE;
12959 player->is_dropping = FALSE;
12960 player->is_dropping_pressed = FALSE;
12961 player->drop_pressed_delay = 0;
12964 // should better be called here than above, but this breaks some tapes
12965 ScrollPlayer(player, SCROLL_INIT);
12970 CheckGravityMovementWhenNotMoving(player);
12972 player->is_moving = FALSE;
12974 /* at this point, the player is allowed to move, but cannot move right now
12975 (e.g. because of something blocking the way) -- ensure that the player
12976 is also allowed to move in the next frame (in old versions before 3.1.1,
12977 the player was forced to wait again for eight frames before next try) */
12979 if (game.engine_version >= VERSION_IDENT(3,1,1,0))
12980 player->move_delay = 0; // allow direct movement in the next frame
12983 if (player->move_delay == -1) // not yet initialized by DigField()
12984 player->move_delay = player->move_delay_value;
12986 if (game.engine_version < VERSION_IDENT(3,0,7,0))
12988 TestIfPlayerTouchesBadThing(jx, jy);
12989 TestIfPlayerTouchesCustomElement(jx, jy);
12992 if (!player->active)
12993 RemovePlayer(player);
12998 void ScrollPlayer(struct PlayerInfo *player, int mode)
13000 int jx = player->jx, jy = player->jy;
13001 int last_jx = player->last_jx, last_jy = player->last_jy;
13002 int move_stepsize = TILEX / player->move_delay_value;
13004 if (!player->active)
13007 if (player->MovPos == 0 && mode == SCROLL_GO_ON) // player not moving
13010 if (mode == SCROLL_INIT)
13012 player->actual_frame_counter = FrameCounter;
13013 player->GfxPos = move_stepsize * (player->MovPos / move_stepsize);
13015 if ((player->block_last_field || player->block_delay_adjustment > 0) &&
13016 Tile[last_jx][last_jy] == EL_EMPTY)
13018 int last_field_block_delay = 0; // start with no blocking at all
13019 int block_delay_adjustment = player->block_delay_adjustment;
13021 // if player blocks last field, add delay for exactly one move
13022 if (player->block_last_field)
13024 last_field_block_delay += player->move_delay_value;
13026 // when blocking enabled, prevent moving up despite gravity
13027 if (player->gravity && player->MovDir == MV_UP)
13028 block_delay_adjustment = -1;
13031 // add block delay adjustment (also possible when not blocking)
13032 last_field_block_delay += block_delay_adjustment;
13034 Tile[last_jx][last_jy] = EL_PLAYER_IS_LEAVING;
13035 MovDelay[last_jx][last_jy] = last_field_block_delay + 1;
13038 if (player->MovPos != 0) // player has not yet reached destination
13041 else if (!FrameReached(&player->actual_frame_counter, 1))
13044 if (player->MovPos != 0)
13046 player->MovPos += (player->MovPos > 0 ? -1 : 1) * move_stepsize;
13047 player->GfxPos = move_stepsize * (player->MovPos / move_stepsize);
13049 // before DrawPlayer() to draw correct player graphic for this case
13050 if (player->MovPos == 0)
13051 CheckGravityMovement(player);
13054 if (player->MovPos == 0) // player reached destination field
13056 if (player->move_delay_reset_counter > 0)
13058 player->move_delay_reset_counter--;
13060 if (player->move_delay_reset_counter == 0)
13062 // continue with normal speed after quickly moving through gate
13063 HALVE_PLAYER_SPEED(player);
13065 // be able to make the next move without delay
13066 player->move_delay = 0;
13070 player->last_jx = jx;
13071 player->last_jy = jy;
13073 if (Tile[jx][jy] == EL_EXIT_OPEN ||
13074 Tile[jx][jy] == EL_EM_EXIT_OPEN ||
13075 Tile[jx][jy] == EL_EM_EXIT_OPENING ||
13076 Tile[jx][jy] == EL_STEEL_EXIT_OPEN ||
13077 Tile[jx][jy] == EL_EM_STEEL_EXIT_OPEN ||
13078 Tile[jx][jy] == EL_EM_STEEL_EXIT_OPENING ||
13079 Tile[jx][jy] == EL_SP_EXIT_OPEN ||
13080 Tile[jx][jy] == EL_SP_EXIT_OPENING) // <-- special case
13082 ExitPlayer(player);
13084 if (game.players_still_needed == 0 &&
13085 (game.friends_still_needed == 0 ||
13086 IS_SP_ELEMENT(Tile[jx][jy])))
13090 // this breaks one level: "machine", level 000
13092 int move_direction = player->MovDir;
13093 int enter_side = MV_DIR_OPPOSITE(move_direction);
13094 int leave_side = move_direction;
13095 int old_jx = last_jx;
13096 int old_jy = last_jy;
13097 int old_element = Tile[old_jx][old_jy];
13098 int new_element = Tile[jx][jy];
13100 if (IS_CUSTOM_ELEMENT(old_element))
13101 CheckElementChangeByPlayer(old_jx, old_jy, old_element,
13103 player->index_bit, leave_side);
13105 CheckTriggeredElementChangeByPlayer(old_jx, old_jy, old_element,
13106 CE_PLAYER_LEAVES_X,
13107 player->index_bit, leave_side);
13109 if (IS_CUSTOM_ELEMENT(new_element))
13110 CheckElementChangeByPlayer(jx, jy, new_element, CE_ENTERED_BY_PLAYER,
13111 player->index_bit, enter_side);
13113 CheckTriggeredElementChangeByPlayer(jx, jy, new_element,
13114 CE_PLAYER_ENTERS_X,
13115 player->index_bit, enter_side);
13117 CheckTriggeredElementChangeBySide(jx, jy, player->initial_element,
13118 CE_MOVE_OF_X, move_direction);
13121 if (game.engine_version >= VERSION_IDENT(3,0,7,0))
13123 TestIfPlayerTouchesBadThing(jx, jy);
13124 TestIfPlayerTouchesCustomElement(jx, jy);
13126 /* needed because pushed element has not yet reached its destination,
13127 so it would trigger a change event at its previous field location */
13128 if (!player->is_pushing)
13129 TestIfElementTouchesCustomElement(jx, jy); // for empty space
13131 if (level.finish_dig_collect &&
13132 (player->is_digging || player->is_collecting))
13134 int last_element = player->last_removed_element;
13135 int move_direction = player->MovDir;
13136 int enter_side = MV_DIR_OPPOSITE(move_direction);
13137 int change_event = (player->is_digging ? CE_PLAYER_DIGS_X :
13138 CE_PLAYER_COLLECTS_X);
13140 CheckTriggeredElementChangeByPlayer(jx, jy, last_element, change_event,
13141 player->index_bit, enter_side);
13143 player->last_removed_element = EL_UNDEFINED;
13146 if (!player->active)
13147 RemovePlayer(player);
13150 if (level.use_step_counter)
13160 if (TimeLeft <= 10 && setup.time_limit && !game.LevelSolved)
13161 PlaySound(SND_GAME_RUNNING_OUT_OF_TIME);
13163 game_panel_controls[GAME_PANEL_TIME].value = TimeLeft;
13165 DisplayGameControlValues();
13167 if (!TimeLeft && setup.time_limit && !game.LevelSolved)
13168 for (i = 0; i < MAX_PLAYERS; i++)
13169 KillPlayer(&stored_player[i]);
13171 else if (game.no_time_limit && !game.all_players_gone)
13173 game_panel_controls[GAME_PANEL_TIME].value = TimePlayed;
13175 DisplayGameControlValues();
13179 if (tape.single_step && tape.recording && !tape.pausing &&
13180 !player->programmed_action)
13181 TapeTogglePause(TAPE_TOGGLE_AUTOMATIC);
13183 if (!player->programmed_action)
13184 CheckSaveEngineSnapshot(player);
13188 void ScrollScreen(struct PlayerInfo *player, int mode)
13190 static unsigned int screen_frame_counter = 0;
13192 if (mode == SCROLL_INIT)
13194 // set scrolling step size according to actual player's moving speed
13195 ScrollStepSize = TILEX / player->move_delay_value;
13197 screen_frame_counter = FrameCounter;
13198 ScreenMovDir = player->MovDir;
13199 ScreenMovPos = player->MovPos;
13200 ScreenGfxPos = ScrollStepSize * (ScreenMovPos / ScrollStepSize);
13203 else if (!FrameReached(&screen_frame_counter, 1))
13208 ScreenMovPos += (ScreenMovPos > 0 ? -1 : 1) * ScrollStepSize;
13209 ScreenGfxPos = ScrollStepSize * (ScreenMovPos / ScrollStepSize);
13210 redraw_mask |= REDRAW_FIELD;
13213 ScreenMovDir = MV_NONE;
13216 void TestIfPlayerTouchesCustomElement(int x, int y)
13218 static int xy[4][2] =
13225 static int trigger_sides[4][2] =
13227 // center side border side
13228 { CH_SIDE_TOP, CH_SIDE_BOTTOM }, // check top
13229 { CH_SIDE_LEFT, CH_SIDE_RIGHT }, // check left
13230 { CH_SIDE_RIGHT, CH_SIDE_LEFT }, // check right
13231 { CH_SIDE_BOTTOM, CH_SIDE_TOP } // check bottom
13233 static int touch_dir[4] =
13235 MV_LEFT | MV_RIGHT,
13240 int center_element = Tile[x][y]; // should always be non-moving!
13243 for (i = 0; i < NUM_DIRECTIONS; i++)
13245 int xx = x + xy[i][0];
13246 int yy = y + xy[i][1];
13247 int center_side = trigger_sides[i][0];
13248 int border_side = trigger_sides[i][1];
13249 int border_element;
13251 if (!IN_LEV_FIELD(xx, yy))
13254 if (IS_PLAYER(x, y)) // player found at center element
13256 struct PlayerInfo *player = PLAYERINFO(x, y);
13258 if (game.engine_version < VERSION_IDENT(3,0,7,0))
13259 border_element = Tile[xx][yy]; // may be moving!
13260 else if (!IS_MOVING(xx, yy) && !IS_BLOCKED(xx, yy))
13261 border_element = Tile[xx][yy];
13262 else if (MovDir[xx][yy] & touch_dir[i]) // elements are touching
13263 border_element = MovingOrBlocked2Element(xx, yy);
13265 continue; // center and border element do not touch
13267 CheckElementChangeByPlayer(xx, yy, border_element, CE_TOUCHED_BY_PLAYER,
13268 player->index_bit, border_side);
13269 CheckTriggeredElementChangeByPlayer(xx, yy, border_element,
13270 CE_PLAYER_TOUCHES_X,
13271 player->index_bit, border_side);
13274 /* use player element that is initially defined in the level playfield,
13275 not the player element that corresponds to the runtime player number
13276 (example: a level that contains EL_PLAYER_3 as the only player would
13277 incorrectly give EL_PLAYER_1 for "player->element_nr") */
13278 int player_element = PLAYERINFO(x, y)->initial_element;
13280 CheckElementChangeBySide(xx, yy, border_element, player_element,
13281 CE_TOUCHING_X, border_side);
13284 else if (IS_PLAYER(xx, yy)) // player found at border element
13286 struct PlayerInfo *player = PLAYERINFO(xx, yy);
13288 if (game.engine_version >= VERSION_IDENT(3,0,7,0))
13290 if (player->MovPos != 0 && !(player->MovDir & touch_dir[i]))
13291 continue; // center and border element do not touch
13294 CheckElementChangeByPlayer(x, y, center_element, CE_TOUCHED_BY_PLAYER,
13295 player->index_bit, center_side);
13296 CheckTriggeredElementChangeByPlayer(x, y, center_element,
13297 CE_PLAYER_TOUCHES_X,
13298 player->index_bit, center_side);
13301 /* use player element that is initially defined in the level playfield,
13302 not the player element that corresponds to the runtime player number
13303 (example: a level that contains EL_PLAYER_3 as the only player would
13304 incorrectly give EL_PLAYER_1 for "player->element_nr") */
13305 int player_element = PLAYERINFO(xx, yy)->initial_element;
13307 CheckElementChangeBySide(x, y, center_element, player_element,
13308 CE_TOUCHING_X, center_side);
13316 void TestIfElementTouchesCustomElement(int x, int y)
13318 static int xy[4][2] =
13325 static int trigger_sides[4][2] =
13327 // center side border side
13328 { CH_SIDE_TOP, CH_SIDE_BOTTOM }, // check top
13329 { CH_SIDE_LEFT, CH_SIDE_RIGHT }, // check left
13330 { CH_SIDE_RIGHT, CH_SIDE_LEFT }, // check right
13331 { CH_SIDE_BOTTOM, CH_SIDE_TOP } // check bottom
13333 static int touch_dir[4] =
13335 MV_LEFT | MV_RIGHT,
13340 boolean change_center_element = FALSE;
13341 int center_element = Tile[x][y]; // should always be non-moving!
13342 int border_element_old[NUM_DIRECTIONS];
13345 for (i = 0; i < NUM_DIRECTIONS; i++)
13347 int xx = x + xy[i][0];
13348 int yy = y + xy[i][1];
13349 int border_element;
13351 border_element_old[i] = -1;
13353 if (!IN_LEV_FIELD(xx, yy))
13356 if (game.engine_version < VERSION_IDENT(3,0,7,0))
13357 border_element = Tile[xx][yy]; // may be moving!
13358 else if (!IS_MOVING(xx, yy) && !IS_BLOCKED(xx, yy))
13359 border_element = Tile[xx][yy];
13360 else if (MovDir[xx][yy] & touch_dir[i]) // elements are touching
13361 border_element = MovingOrBlocked2Element(xx, yy);
13363 continue; // center and border element do not touch
13365 border_element_old[i] = border_element;
13368 for (i = 0; i < NUM_DIRECTIONS; i++)
13370 int xx = x + xy[i][0];
13371 int yy = y + xy[i][1];
13372 int center_side = trigger_sides[i][0];
13373 int border_element = border_element_old[i];
13375 if (border_element == -1)
13378 // check for change of border element
13379 CheckElementChangeBySide(xx, yy, border_element, center_element,
13380 CE_TOUCHING_X, center_side);
13382 // (center element cannot be player, so we dont have to check this here)
13385 for (i = 0; i < NUM_DIRECTIONS; i++)
13387 int xx = x + xy[i][0];
13388 int yy = y + xy[i][1];
13389 int border_side = trigger_sides[i][1];
13390 int border_element = border_element_old[i];
13392 if (border_element == -1)
13395 // check for change of center element (but change it only once)
13396 if (!change_center_element)
13397 change_center_element =
13398 CheckElementChangeBySide(x, y, center_element, border_element,
13399 CE_TOUCHING_X, border_side);
13401 if (IS_PLAYER(xx, yy))
13403 /* use player element that is initially defined in the level playfield,
13404 not the player element that corresponds to the runtime player number
13405 (example: a level that contains EL_PLAYER_3 as the only player would
13406 incorrectly give EL_PLAYER_1 for "player->element_nr") */
13407 int player_element = PLAYERINFO(xx, yy)->initial_element;
13409 CheckElementChangeBySide(x, y, center_element, player_element,
13410 CE_TOUCHING_X, border_side);
13415 void TestIfElementHitsCustomElement(int x, int y, int direction)
13417 int dx = (direction == MV_LEFT ? -1 : direction == MV_RIGHT ? +1 : 0);
13418 int dy = (direction == MV_UP ? -1 : direction == MV_DOWN ? +1 : 0);
13419 int hitx = x + dx, hity = y + dy;
13420 int hitting_element = Tile[x][y];
13421 int touched_element;
13423 if (IN_LEV_FIELD(hitx, hity) && IS_FREE(hitx, hity))
13426 touched_element = (IN_LEV_FIELD(hitx, hity) ?
13427 MovingOrBlocked2Element(hitx, hity) : EL_STEELWALL);
13429 if (IN_LEV_FIELD(hitx, hity))
13431 int opposite_direction = MV_DIR_OPPOSITE(direction);
13432 int hitting_side = direction;
13433 int touched_side = opposite_direction;
13434 boolean object_hit = (!IS_MOVING(hitx, hity) ||
13435 MovDir[hitx][hity] != direction ||
13436 ABS(MovPos[hitx][hity]) <= TILEY / 2);
13442 CheckElementChangeBySide(x, y, hitting_element, touched_element,
13443 CE_HITTING_X, touched_side);
13445 CheckElementChangeBySide(hitx, hity, touched_element, hitting_element,
13446 CE_HIT_BY_X, hitting_side);
13448 CheckElementChangeBySide(hitx, hity, touched_element, hitting_element,
13449 CE_HIT_BY_SOMETHING, opposite_direction);
13451 if (IS_PLAYER(hitx, hity))
13453 /* use player element that is initially defined in the level playfield,
13454 not the player element that corresponds to the runtime player number
13455 (example: a level that contains EL_PLAYER_3 as the only player would
13456 incorrectly give EL_PLAYER_1 for "player->element_nr") */
13457 int player_element = PLAYERINFO(hitx, hity)->initial_element;
13459 CheckElementChangeBySide(x, y, hitting_element, player_element,
13460 CE_HITTING_X, touched_side);
13465 // "hitting something" is also true when hitting the playfield border
13466 CheckElementChangeBySide(x, y, hitting_element, touched_element,
13467 CE_HITTING_SOMETHING, direction);
13470 void TestIfGoodThingHitsBadThing(int good_x, int good_y, int good_move_dir)
13472 int i, kill_x = -1, kill_y = -1;
13474 int bad_element = -1;
13475 static int test_xy[4][2] =
13482 static int test_dir[4] =
13490 for (i = 0; i < NUM_DIRECTIONS; i++)
13492 int test_x, test_y, test_move_dir, test_element;
13494 test_x = good_x + test_xy[i][0];
13495 test_y = good_y + test_xy[i][1];
13497 if (!IN_LEV_FIELD(test_x, test_y))
13501 (IS_MOVING(test_x, test_y) ? MovDir[test_x][test_y] : MV_NONE);
13503 test_element = MovingOrBlocked2ElementIfNotLeaving(test_x, test_y);
13505 /* 1st case: good thing is moving towards DONT_RUN_INTO style bad thing;
13506 2nd case: DONT_TOUCH style bad thing does not move away from good thing
13508 if ((DONT_RUN_INTO(test_element) && good_move_dir == test_dir[i]) ||
13509 (DONT_TOUCH(test_element) && test_move_dir != test_dir[i]))
13513 bad_element = test_element;
13519 if (kill_x != -1 || kill_y != -1)
13521 if (IS_PLAYER(good_x, good_y))
13523 struct PlayerInfo *player = PLAYERINFO(good_x, good_y);
13525 if (player->shield_deadly_time_left > 0 &&
13526 !IS_INDESTRUCTIBLE(bad_element))
13527 Bang(kill_x, kill_y);
13528 else if (!PLAYER_ENEMY_PROTECTED(good_x, good_y))
13529 KillPlayer(player);
13532 Bang(good_x, good_y);
13536 void TestIfBadThingHitsGoodThing(int bad_x, int bad_y, int bad_move_dir)
13538 int i, kill_x = -1, kill_y = -1;
13539 int bad_element = Tile[bad_x][bad_y];
13540 static int test_xy[4][2] =
13547 static int touch_dir[4] =
13549 MV_LEFT | MV_RIGHT,
13554 static int test_dir[4] =
13562 if (bad_element == EL_EXPLOSION) // skip just exploding bad things
13565 for (i = 0; i < NUM_DIRECTIONS; i++)
13567 int test_x, test_y, test_move_dir, test_element;
13569 test_x = bad_x + test_xy[i][0];
13570 test_y = bad_y + test_xy[i][1];
13572 if (!IN_LEV_FIELD(test_x, test_y))
13576 (IS_MOVING(test_x, test_y) ? MovDir[test_x][test_y] : MV_NONE);
13578 test_element = Tile[test_x][test_y];
13580 /* 1st case: good thing is moving towards DONT_RUN_INTO style bad thing;
13581 2nd case: DONT_TOUCH style bad thing does not move away from good thing
13583 if ((DONT_RUN_INTO(bad_element) && bad_move_dir == test_dir[i]) ||
13584 (DONT_TOUCH(bad_element) && test_move_dir != test_dir[i]))
13586 // good thing is player or penguin that does not move away
13587 if (IS_PLAYER(test_x, test_y))
13589 struct PlayerInfo *player = PLAYERINFO(test_x, test_y);
13591 if (bad_element == EL_ROBOT && player->is_moving)
13592 continue; // robot does not kill player if he is moving
13594 if (game.engine_version >= VERSION_IDENT(3,0,7,0))
13596 if (player->MovPos != 0 && !(player->MovDir & touch_dir[i]))
13597 continue; // center and border element do not touch
13605 else if (test_element == EL_PENGUIN)
13615 if (kill_x != -1 || kill_y != -1)
13617 if (IS_PLAYER(kill_x, kill_y))
13619 struct PlayerInfo *player = PLAYERINFO(kill_x, kill_y);
13621 if (player->shield_deadly_time_left > 0 &&
13622 !IS_INDESTRUCTIBLE(bad_element))
13623 Bang(bad_x, bad_y);
13624 else if (!PLAYER_ENEMY_PROTECTED(kill_x, kill_y))
13625 KillPlayer(player);
13628 Bang(kill_x, kill_y);
13632 void TestIfGoodThingGetsHitByBadThing(int bad_x, int bad_y, int bad_move_dir)
13634 int bad_element = Tile[bad_x][bad_y];
13635 int dx = (bad_move_dir == MV_LEFT ? -1 : bad_move_dir == MV_RIGHT ? +1 : 0);
13636 int dy = (bad_move_dir == MV_UP ? -1 : bad_move_dir == MV_DOWN ? +1 : 0);
13637 int test_x = bad_x + dx, test_y = bad_y + dy;
13638 int test_move_dir, test_element;
13639 int kill_x = -1, kill_y = -1;
13641 if (!IN_LEV_FIELD(test_x, test_y))
13645 (IS_MOVING(test_x, test_y) ? MovDir[test_x][test_y] : MV_NONE);
13647 test_element = Tile[test_x][test_y];
13649 if (test_move_dir != bad_move_dir)
13651 // good thing can be player or penguin that does not move away
13652 if (IS_PLAYER(test_x, test_y))
13654 struct PlayerInfo *player = PLAYERINFO(test_x, test_y);
13656 /* (note: in comparison to DONT_RUN_TO and DONT_TOUCH, also handle the
13657 player as being hit when he is moving towards the bad thing, because
13658 the "get hit by" condition would be lost after the player stops) */
13659 if (player->MovPos != 0 && player->MovDir == bad_move_dir)
13660 return; // player moves away from bad thing
13665 else if (test_element == EL_PENGUIN)
13672 if (kill_x != -1 || kill_y != -1)
13674 if (IS_PLAYER(kill_x, kill_y))
13676 struct PlayerInfo *player = PLAYERINFO(kill_x, kill_y);
13678 if (player->shield_deadly_time_left > 0 &&
13679 !IS_INDESTRUCTIBLE(bad_element))
13680 Bang(bad_x, bad_y);
13681 else if (!PLAYER_ENEMY_PROTECTED(kill_x, kill_y))
13682 KillPlayer(player);
13685 Bang(kill_x, kill_y);
13689 void TestIfPlayerTouchesBadThing(int x, int y)
13691 TestIfGoodThingHitsBadThing(x, y, MV_NONE);
13694 void TestIfPlayerRunsIntoBadThing(int x, int y, int move_dir)
13696 TestIfGoodThingHitsBadThing(x, y, move_dir);
13699 void TestIfBadThingTouchesPlayer(int x, int y)
13701 TestIfBadThingHitsGoodThing(x, y, MV_NONE);
13704 void TestIfBadThingRunsIntoPlayer(int x, int y, int move_dir)
13706 TestIfBadThingHitsGoodThing(x, y, move_dir);
13709 void TestIfFriendTouchesBadThing(int x, int y)
13711 TestIfGoodThingHitsBadThing(x, y, MV_NONE);
13714 void TestIfBadThingTouchesFriend(int x, int y)
13716 TestIfBadThingHitsGoodThing(x, y, MV_NONE);
13719 void TestIfBadThingTouchesOtherBadThing(int bad_x, int bad_y)
13721 int i, kill_x = bad_x, kill_y = bad_y;
13722 static int xy[4][2] =
13730 for (i = 0; i < NUM_DIRECTIONS; i++)
13734 x = bad_x + xy[i][0];
13735 y = bad_y + xy[i][1];
13736 if (!IN_LEV_FIELD(x, y))
13739 element = Tile[x][y];
13740 if (IS_AMOEBOID(element) || element == EL_GAME_OF_LIFE ||
13741 element == EL_AMOEBA_GROWING || element == EL_AMOEBA_DROP)
13749 if (kill_x != bad_x || kill_y != bad_y)
13750 Bang(bad_x, bad_y);
13753 void KillPlayer(struct PlayerInfo *player)
13755 int jx = player->jx, jy = player->jy;
13757 if (!player->active)
13761 Debug("game:playing:KillPlayer",
13762 "0: killed == %d, active == %d, reanimated == %d",
13763 player->killed, player->active, player->reanimated);
13766 /* the following code was introduced to prevent an infinite loop when calling
13768 -> CheckTriggeredElementChangeExt()
13769 -> ExecuteCustomElementAction()
13771 -> (infinitely repeating the above sequence of function calls)
13772 which occurs when killing the player while having a CE with the setting
13773 "kill player X when explosion of <player X>"; the solution using a new
13774 field "player->killed" was chosen for backwards compatibility, although
13775 clever use of the fields "player->active" etc. would probably also work */
13777 if (player->killed)
13781 player->killed = TRUE;
13783 // remove accessible field at the player's position
13784 Tile[jx][jy] = EL_EMPTY;
13786 // deactivate shield (else Bang()/Explode() would not work right)
13787 player->shield_normal_time_left = 0;
13788 player->shield_deadly_time_left = 0;
13791 Debug("game:playing:KillPlayer",
13792 "1: killed == %d, active == %d, reanimated == %d",
13793 player->killed, player->active, player->reanimated);
13799 Debug("game:playing:KillPlayer",
13800 "2: killed == %d, active == %d, reanimated == %d",
13801 player->killed, player->active, player->reanimated);
13804 if (player->reanimated) // killed player may have been reanimated
13805 player->killed = player->reanimated = FALSE;
13807 BuryPlayer(player);
13810 static void KillPlayerUnlessEnemyProtected(int x, int y)
13812 if (!PLAYER_ENEMY_PROTECTED(x, y))
13813 KillPlayer(PLAYERINFO(x, y));
13816 static void KillPlayerUnlessExplosionProtected(int x, int y)
13818 if (!PLAYER_EXPLOSION_PROTECTED(x, y))
13819 KillPlayer(PLAYERINFO(x, y));
13822 void BuryPlayer(struct PlayerInfo *player)
13824 int jx = player->jx, jy = player->jy;
13826 if (!player->active)
13829 PlayLevelSoundElementAction(jx, jy, player->artwork_element, ACTION_DYING);
13830 PlayLevelSound(jx, jy, SND_GAME_LOSING);
13832 RemovePlayer(player);
13834 player->buried = TRUE;
13836 if (game.all_players_gone)
13837 game.GameOver = TRUE;
13840 void RemovePlayer(struct PlayerInfo *player)
13842 int jx = player->jx, jy = player->jy;
13843 int i, found = FALSE;
13845 player->present = FALSE;
13846 player->active = FALSE;
13848 // required for some CE actions (even if the player is not active anymore)
13849 player->MovPos = 0;
13851 if (!ExplodeField[jx][jy])
13852 StorePlayer[jx][jy] = 0;
13854 if (player->is_moving)
13855 TEST_DrawLevelField(player->last_jx, player->last_jy);
13857 for (i = 0; i < MAX_PLAYERS; i++)
13858 if (stored_player[i].active)
13863 game.all_players_gone = TRUE;
13864 game.GameOver = TRUE;
13867 game.exit_x = game.robot_wheel_x = jx;
13868 game.exit_y = game.robot_wheel_y = jy;
13871 void ExitPlayer(struct PlayerInfo *player)
13873 DrawPlayer(player); // needed here only to cleanup last field
13874 RemovePlayer(player);
13876 if (game.players_still_needed > 0)
13877 game.players_still_needed--;
13880 static void SetFieldForSnapping(int x, int y, int element, int direction,
13881 int player_index_bit)
13883 struct ElementInfo *ei = &element_info[element];
13884 int direction_bit = MV_DIR_TO_BIT(direction);
13885 int graphic_snapping = ei->direction_graphic[ACTION_SNAPPING][direction_bit];
13886 int action = (graphic_snapping != IMG_EMPTY_SPACE ? ACTION_SNAPPING :
13887 IS_DIGGABLE(element) ? ACTION_DIGGING : ACTION_COLLECTING);
13889 Tile[x][y] = EL_ELEMENT_SNAPPING;
13890 MovDelay[x][y] = MOVE_DELAY_NORMAL_SPEED + 1 - 1;
13891 MovDir[x][y] = direction;
13892 Store[x][y] = element;
13893 Store2[x][y] = player_index_bit;
13895 ResetGfxAnimation(x, y);
13897 GfxElement[x][y] = element;
13898 GfxAction[x][y] = action;
13899 GfxDir[x][y] = direction;
13900 GfxFrame[x][y] = -1;
13903 static void TestFieldAfterSnapping(int x, int y, int element, int direction,
13904 int player_index_bit)
13906 TestIfElementTouchesCustomElement(x, y); // for empty space
13908 if (level.finish_dig_collect)
13910 int dig_side = MV_DIR_OPPOSITE(direction);
13912 CheckTriggeredElementChangeByPlayer(x, y, element, CE_PLAYER_SNAPS_X,
13913 player_index_bit, dig_side);
13918 =============================================================================
13919 checkDiagonalPushing()
13920 -----------------------------------------------------------------------------
13921 check if diagonal input device direction results in pushing of object
13922 (by checking if the alternative direction is walkable, diggable, ...)
13923 =============================================================================
13926 static boolean checkDiagonalPushing(struct PlayerInfo *player,
13927 int x, int y, int real_dx, int real_dy)
13929 int jx, jy, dx, dy, xx, yy;
13931 if (real_dx == 0 || real_dy == 0) // no diagonal direction => push
13934 // diagonal direction: check alternative direction
13939 xx = jx + (dx == 0 ? real_dx : 0);
13940 yy = jy + (dy == 0 ? real_dy : 0);
13942 return (!IN_LEV_FIELD(xx, yy) || IS_SOLID_FOR_PUSHING(Tile[xx][yy]));
13946 =============================================================================
13948 -----------------------------------------------------------------------------
13949 x, y: field next to player (non-diagonal) to try to dig to
13950 real_dx, real_dy: direction as read from input device (can be diagonal)
13951 =============================================================================
13954 static int DigField(struct PlayerInfo *player,
13955 int oldx, int oldy, int x, int y,
13956 int real_dx, int real_dy, int mode)
13958 boolean is_player = (IS_PLAYER(oldx, oldy) || mode != DF_DIG);
13959 boolean player_was_pushing = player->is_pushing;
13960 boolean player_can_move = (!player->cannot_move && mode != DF_SNAP);
13961 boolean player_can_move_or_snap = (!player->cannot_move || mode == DF_SNAP);
13962 int jx = oldx, jy = oldy;
13963 int dx = x - jx, dy = y - jy;
13964 int nextx = x + dx, nexty = y + dy;
13965 int move_direction = (dx == -1 ? MV_LEFT :
13966 dx == +1 ? MV_RIGHT :
13968 dy == +1 ? MV_DOWN : MV_NONE);
13969 int opposite_direction = MV_DIR_OPPOSITE(move_direction);
13970 int dig_side = MV_DIR_OPPOSITE(move_direction);
13971 int old_element = Tile[jx][jy];
13972 int element = MovingOrBlocked2ElementIfNotLeaving(x, y);
13975 if (is_player) // function can also be called by EL_PENGUIN
13977 if (player->MovPos == 0)
13979 player->is_digging = FALSE;
13980 player->is_collecting = FALSE;
13983 if (player->MovPos == 0) // last pushing move finished
13984 player->is_pushing = FALSE;
13986 if (mode == DF_NO_PUSH) // player just stopped pushing
13988 player->is_switching = FALSE;
13989 player->push_delay = -1;
13991 return MP_NO_ACTION;
13995 if (IS_TUBE(Back[jx][jy]) && game.engine_version >= VERSION_IDENT(2,2,0,0))
13996 old_element = Back[jx][jy];
13998 // in case of element dropped at player position, check background
13999 else if (Back[jx][jy] != EL_EMPTY &&
14000 game.engine_version >= VERSION_IDENT(2,2,0,0))
14001 old_element = Back[jx][jy];
14003 if (IS_WALKABLE(old_element) && !ACCESS_FROM(old_element, move_direction))
14004 return MP_NO_ACTION; // field has no opening in this direction
14006 if (IS_PASSABLE(old_element) && !ACCESS_FROM(old_element,opposite_direction))
14007 return MP_NO_ACTION; // field has no opening in this direction
14009 if (player_can_move && element == EL_ACID && move_direction == MV_DOWN)
14013 Tile[jx][jy] = player->artwork_element;
14014 InitMovingField(jx, jy, MV_DOWN);
14015 Store[jx][jy] = EL_ACID;
14016 ContinueMoving(jx, jy);
14017 BuryPlayer(player);
14019 return MP_DONT_RUN_INTO;
14022 if (player_can_move && DONT_RUN_INTO(element))
14024 TestIfPlayerRunsIntoBadThing(jx, jy, player->MovDir);
14026 return MP_DONT_RUN_INTO;
14029 if (IS_MOVING(x, y) || IS_PLAYER(x, y))
14030 return MP_NO_ACTION;
14032 collect_count = element_info[element].collect_count_initial;
14034 if (!is_player && !IS_COLLECTIBLE(element)) // penguin cannot collect it
14035 return MP_NO_ACTION;
14037 if (game.engine_version < VERSION_IDENT(2,2,0,0))
14038 player_can_move = player_can_move_or_snap;
14040 if (mode == DF_SNAP && !IS_SNAPPABLE(element) &&
14041 game.engine_version >= VERSION_IDENT(2,2,0,0))
14043 CheckElementChangeByPlayer(x, y, element, CE_SNAPPED_BY_PLAYER,
14044 player->index_bit, dig_side);
14045 CheckTriggeredElementChangeByPlayer(x, y, element, CE_PLAYER_SNAPS_X,
14046 player->index_bit, dig_side);
14048 if (element == EL_DC_LANDMINE)
14051 if (Tile[x][y] != element) // field changed by snapping
14054 return MP_NO_ACTION;
14057 if (player->gravity && is_player && !player->is_auto_moving &&
14058 canFallDown(player) && move_direction != MV_DOWN &&
14059 !canMoveToValidFieldWithGravity(jx, jy, move_direction))
14060 return MP_NO_ACTION; // player cannot walk here due to gravity
14062 if (player_can_move &&
14063 IS_WALKABLE(element) && ACCESS_FROM(element, opposite_direction))
14065 int sound_element = SND_ELEMENT(element);
14066 int sound_action = ACTION_WALKING;
14068 if (IS_RND_GATE(element))
14070 if (!player->key[RND_GATE_NR(element)])
14071 return MP_NO_ACTION;
14073 else if (IS_RND_GATE_GRAY(element))
14075 if (!player->key[RND_GATE_GRAY_NR(element)])
14076 return MP_NO_ACTION;
14078 else if (IS_RND_GATE_GRAY_ACTIVE(element))
14080 if (!player->key[RND_GATE_GRAY_ACTIVE_NR(element)])
14081 return MP_NO_ACTION;
14083 else if (element == EL_EXIT_OPEN ||
14084 element == EL_EM_EXIT_OPEN ||
14085 element == EL_EM_EXIT_OPENING ||
14086 element == EL_STEEL_EXIT_OPEN ||
14087 element == EL_EM_STEEL_EXIT_OPEN ||
14088 element == EL_EM_STEEL_EXIT_OPENING ||
14089 element == EL_SP_EXIT_OPEN ||
14090 element == EL_SP_EXIT_OPENING)
14092 sound_action = ACTION_PASSING; // player is passing exit
14094 else if (element == EL_EMPTY)
14096 sound_action = ACTION_MOVING; // nothing to walk on
14099 // play sound from background or player, whatever is available
14100 if (element_info[sound_element].sound[sound_action] != SND_UNDEFINED)
14101 PlayLevelSoundElementAction(x, y, sound_element, sound_action);
14103 PlayLevelSoundElementAction(x, y, player->artwork_element, sound_action);
14105 else if (player_can_move &&
14106 IS_PASSABLE(element) && canPassField(x, y, move_direction))
14108 if (!ACCESS_FROM(element, opposite_direction))
14109 return MP_NO_ACTION; // field not accessible from this direction
14111 if (CAN_MOVE(element)) // only fixed elements can be passed!
14112 return MP_NO_ACTION;
14114 if (IS_EM_GATE(element))
14116 if (!player->key[EM_GATE_NR(element)])
14117 return MP_NO_ACTION;
14119 else if (IS_EM_GATE_GRAY(element))
14121 if (!player->key[EM_GATE_GRAY_NR(element)])
14122 return MP_NO_ACTION;
14124 else if (IS_EM_GATE_GRAY_ACTIVE(element))
14126 if (!player->key[EM_GATE_GRAY_ACTIVE_NR(element)])
14127 return MP_NO_ACTION;
14129 else if (IS_EMC_GATE(element))
14131 if (!player->key[EMC_GATE_NR(element)])
14132 return MP_NO_ACTION;
14134 else if (IS_EMC_GATE_GRAY(element))
14136 if (!player->key[EMC_GATE_GRAY_NR(element)])
14137 return MP_NO_ACTION;
14139 else if (IS_EMC_GATE_GRAY_ACTIVE(element))
14141 if (!player->key[EMC_GATE_GRAY_ACTIVE_NR(element)])
14142 return MP_NO_ACTION;
14144 else if (element == EL_DC_GATE_WHITE ||
14145 element == EL_DC_GATE_WHITE_GRAY ||
14146 element == EL_DC_GATE_WHITE_GRAY_ACTIVE)
14148 if (player->num_white_keys == 0)
14149 return MP_NO_ACTION;
14151 player->num_white_keys--;
14153 else if (IS_SP_PORT(element))
14155 if (element == EL_SP_GRAVITY_PORT_LEFT ||
14156 element == EL_SP_GRAVITY_PORT_RIGHT ||
14157 element == EL_SP_GRAVITY_PORT_UP ||
14158 element == EL_SP_GRAVITY_PORT_DOWN)
14159 player->gravity = !player->gravity;
14160 else if (element == EL_SP_GRAVITY_ON_PORT_LEFT ||
14161 element == EL_SP_GRAVITY_ON_PORT_RIGHT ||
14162 element == EL_SP_GRAVITY_ON_PORT_UP ||
14163 element == EL_SP_GRAVITY_ON_PORT_DOWN)
14164 player->gravity = TRUE;
14165 else if (element == EL_SP_GRAVITY_OFF_PORT_LEFT ||
14166 element == EL_SP_GRAVITY_OFF_PORT_RIGHT ||
14167 element == EL_SP_GRAVITY_OFF_PORT_UP ||
14168 element == EL_SP_GRAVITY_OFF_PORT_DOWN)
14169 player->gravity = FALSE;
14172 // automatically move to the next field with double speed
14173 player->programmed_action = move_direction;
14175 if (player->move_delay_reset_counter == 0)
14177 player->move_delay_reset_counter = 2; // two double speed steps
14179 DOUBLE_PLAYER_SPEED(player);
14182 PlayLevelSoundAction(x, y, ACTION_PASSING);
14184 else if (player_can_move_or_snap && IS_DIGGABLE(element))
14188 if (mode != DF_SNAP)
14190 GfxElement[x][y] = GFX_ELEMENT(element);
14191 player->is_digging = TRUE;
14194 PlayLevelSoundElementAction(x, y, element, ACTION_DIGGING);
14196 // use old behaviour for old levels (digging)
14197 if (!level.finish_dig_collect)
14199 CheckTriggeredElementChangeByPlayer(x, y, element, CE_PLAYER_DIGS_X,
14200 player->index_bit, dig_side);
14202 // if digging triggered player relocation, finish digging tile
14203 if (mode == DF_DIG && (player->jx != jx || player->jy != jy))
14204 SetFieldForSnapping(x, y, element, move_direction, player->index_bit);
14207 if (mode == DF_SNAP)
14209 if (level.block_snap_field)
14210 SetFieldForSnapping(x, y, element, move_direction, player->index_bit);
14212 TestFieldAfterSnapping(x, y, element, move_direction, player->index_bit);
14214 // use old behaviour for old levels (snapping)
14215 if (!level.finish_dig_collect)
14216 CheckTriggeredElementChangeByPlayer(x, y, element, CE_PLAYER_SNAPS_X,
14217 player->index_bit, dig_side);
14220 else if (player_can_move_or_snap && IS_COLLECTIBLE(element))
14224 if (is_player && mode != DF_SNAP)
14226 GfxElement[x][y] = element;
14227 player->is_collecting = TRUE;
14230 if (element == EL_SPEED_PILL)
14232 player->move_delay_value = MOVE_DELAY_HIGH_SPEED;
14234 else if (element == EL_EXTRA_TIME && level.time > 0)
14236 TimeLeft += level.extra_time;
14238 game_panel_controls[GAME_PANEL_TIME].value = TimeLeft;
14240 DisplayGameControlValues();
14242 else if (element == EL_SHIELD_NORMAL || element == EL_SHIELD_DEADLY)
14244 player->shield_normal_time_left += level.shield_normal_time;
14245 if (element == EL_SHIELD_DEADLY)
14246 player->shield_deadly_time_left += level.shield_deadly_time;
14248 else if (element == EL_DYNAMITE ||
14249 element == EL_EM_DYNAMITE ||
14250 element == EL_SP_DISK_RED)
14252 if (player->inventory_size < MAX_INVENTORY_SIZE)
14253 player->inventory_element[player->inventory_size++] = element;
14255 DrawGameDoorValues();
14257 else if (element == EL_DYNABOMB_INCREASE_NUMBER)
14259 player->dynabomb_count++;
14260 player->dynabombs_left++;
14262 else if (element == EL_DYNABOMB_INCREASE_SIZE)
14264 player->dynabomb_size++;
14266 else if (element == EL_DYNABOMB_INCREASE_POWER)
14268 player->dynabomb_xl = TRUE;
14270 else if (IS_KEY(element))
14272 player->key[KEY_NR(element)] = TRUE;
14274 DrawGameDoorValues();
14276 else if (element == EL_DC_KEY_WHITE)
14278 player->num_white_keys++;
14280 // display white keys?
14281 // DrawGameDoorValues();
14283 else if (IS_ENVELOPE(element))
14285 player->show_envelope = element;
14287 else if (element == EL_EMC_LENSES)
14289 game.lenses_time_left = level.lenses_time * FRAMES_PER_SECOND;
14291 RedrawAllInvisibleElementsForLenses();
14293 else if (element == EL_EMC_MAGNIFIER)
14295 game.magnify_time_left = level.magnify_time * FRAMES_PER_SECOND;
14297 RedrawAllInvisibleElementsForMagnifier();
14299 else if (IS_DROPPABLE(element) ||
14300 IS_THROWABLE(element)) // can be collected and dropped
14304 if (collect_count == 0)
14305 player->inventory_infinite_element = element;
14307 for (i = 0; i < collect_count; i++)
14308 if (player->inventory_size < MAX_INVENTORY_SIZE)
14309 player->inventory_element[player->inventory_size++] = element;
14311 DrawGameDoorValues();
14313 else if (collect_count > 0)
14315 game.gems_still_needed -= collect_count;
14316 if (game.gems_still_needed < 0)
14317 game.gems_still_needed = 0;
14319 game.snapshot.collected_item = TRUE;
14321 game_panel_controls[GAME_PANEL_GEMS].value = game.gems_still_needed;
14323 DisplayGameControlValues();
14326 RaiseScoreElement(element);
14327 PlayLevelSoundElementAction(x, y, element, ACTION_COLLECTING);
14329 // use old behaviour for old levels (collecting)
14330 if (!level.finish_dig_collect && is_player)
14332 CheckTriggeredElementChangeByPlayer(x, y, element, CE_PLAYER_COLLECTS_X,
14333 player->index_bit, dig_side);
14335 // if collecting triggered player relocation, finish collecting tile
14336 if (mode == DF_DIG && (player->jx != jx || player->jy != jy))
14337 SetFieldForSnapping(x, y, element, move_direction, player->index_bit);
14340 if (mode == DF_SNAP)
14342 if (level.block_snap_field)
14343 SetFieldForSnapping(x, y, element, move_direction, player->index_bit);
14345 TestFieldAfterSnapping(x, y, element, move_direction, player->index_bit);
14347 // use old behaviour for old levels (snapping)
14348 if (!level.finish_dig_collect)
14349 CheckTriggeredElementChangeByPlayer(x, y, element, CE_PLAYER_SNAPS_X,
14350 player->index_bit, dig_side);
14353 else if (player_can_move_or_snap && IS_PUSHABLE(element))
14355 if (mode == DF_SNAP && element != EL_BD_ROCK)
14356 return MP_NO_ACTION;
14358 if (CAN_FALL(element) && dy)
14359 return MP_NO_ACTION;
14361 if (CAN_FALL(element) && IN_LEV_FIELD(x, y + 1) && IS_FREE(x, y + 1) &&
14362 !(element == EL_SPRING && level.use_spring_bug))
14363 return MP_NO_ACTION;
14365 if (CAN_MOVE(element) && GET_MAX_MOVE_DELAY(element) == 0 &&
14366 ((move_direction & MV_VERTICAL &&
14367 ((element_info[element].move_pattern & MV_LEFT &&
14368 IN_LEV_FIELD(x - 1, y) && IS_FREE(x - 1, y)) ||
14369 (element_info[element].move_pattern & MV_RIGHT &&
14370 IN_LEV_FIELD(x + 1, y) && IS_FREE(x + 1, y)))) ||
14371 (move_direction & MV_HORIZONTAL &&
14372 ((element_info[element].move_pattern & MV_UP &&
14373 IN_LEV_FIELD(x, y - 1) && IS_FREE(x, y - 1)) ||
14374 (element_info[element].move_pattern & MV_DOWN &&
14375 IN_LEV_FIELD(x, y + 1) && IS_FREE(x, y + 1))))))
14376 return MP_NO_ACTION;
14378 // do not push elements already moving away faster than player
14379 if (CAN_MOVE(element) && MovDir[x][y] == move_direction &&
14380 ABS(getElementMoveStepsize(x, y)) > MOVE_STEPSIZE_NORMAL)
14381 return MP_NO_ACTION;
14383 if (game.engine_version >= VERSION_IDENT(3,1,0,0))
14385 if (player->push_delay_value == -1 || !player_was_pushing)
14386 player->push_delay_value = GET_NEW_PUSH_DELAY(element);
14388 else if (game.engine_version >= VERSION_IDENT(3,0,7,1))
14390 if (player->push_delay_value == -1)
14391 player->push_delay_value = GET_NEW_PUSH_DELAY(element);
14393 else if (game.engine_version >= VERSION_IDENT(2,2,0,7))
14395 if (!player->is_pushing)
14396 player->push_delay_value = GET_NEW_PUSH_DELAY(element);
14399 player->is_pushing = TRUE;
14400 player->is_active = TRUE;
14402 if (!(IN_LEV_FIELD(nextx, nexty) &&
14403 (IS_FREE(nextx, nexty) ||
14404 (IS_SB_ELEMENT(element) &&
14405 Tile[nextx][nexty] == EL_SOKOBAN_FIELD_EMPTY) ||
14406 (IS_CUSTOM_ELEMENT(element) &&
14407 CUSTOM_ELEMENT_CAN_ENTER_FIELD(element, nextx, nexty)))))
14408 return MP_NO_ACTION;
14410 if (!checkDiagonalPushing(player, x, y, real_dx, real_dy))
14411 return MP_NO_ACTION;
14413 if (player->push_delay == -1) // new pushing; restart delay
14414 player->push_delay = 0;
14416 if (player->push_delay < player->push_delay_value &&
14417 !(tape.playing && tape.file_version < FILE_VERSION_2_0) &&
14418 element != EL_SPRING && element != EL_BALLOON)
14420 // make sure that there is no move delay before next try to push
14421 if (game.engine_version >= VERSION_IDENT(3,0,7,1))
14422 player->move_delay = 0;
14424 return MP_NO_ACTION;
14427 if (IS_CUSTOM_ELEMENT(element) &&
14428 CUSTOM_ELEMENT_CAN_ENTER_FIELD(element, nextx, nexty))
14430 if (!DigFieldByCE(nextx, nexty, element))
14431 return MP_NO_ACTION;
14434 if (IS_SB_ELEMENT(element))
14436 boolean sokoban_task_solved = FALSE;
14438 if (element == EL_SOKOBAN_FIELD_FULL)
14440 Back[x][y] = EL_SOKOBAN_FIELD_EMPTY;
14442 IncrementSokobanFieldsNeeded();
14443 IncrementSokobanObjectsNeeded();
14446 if (Tile[nextx][nexty] == EL_SOKOBAN_FIELD_EMPTY)
14448 Back[nextx][nexty] = EL_SOKOBAN_FIELD_EMPTY;
14450 DecrementSokobanFieldsNeeded();
14451 DecrementSokobanObjectsNeeded();
14453 // sokoban object was pushed from empty field to sokoban field
14454 if (Back[x][y] == EL_EMPTY)
14455 sokoban_task_solved = TRUE;
14458 Tile[x][y] = EL_SOKOBAN_OBJECT;
14460 if (Back[x][y] == Back[nextx][nexty])
14461 PlayLevelSoundAction(x, y, ACTION_PUSHING);
14462 else if (Back[x][y] != 0)
14463 PlayLevelSoundElementAction(x, y, EL_SOKOBAN_FIELD_FULL,
14466 PlayLevelSoundElementAction(nextx, nexty, EL_SOKOBAN_FIELD_EMPTY,
14469 if (sokoban_task_solved &&
14470 game.sokoban_fields_still_needed == 0 &&
14471 game.sokoban_objects_still_needed == 0 &&
14472 (game.emulation == EMU_SOKOBAN || level.auto_exit_sokoban))
14474 game.players_still_needed = 0;
14478 PlayLevelSound(x, y, SND_GAME_SOKOBAN_SOLVING);
14482 PlayLevelSoundElementAction(x, y, element, ACTION_PUSHING);
14484 InitMovingField(x, y, move_direction);
14485 GfxAction[x][y] = ACTION_PUSHING;
14487 if (mode == DF_SNAP)
14488 ContinueMoving(x, y);
14490 MovPos[x][y] = (dx != 0 ? dx : dy);
14492 Pushed[x][y] = TRUE;
14493 Pushed[nextx][nexty] = TRUE;
14495 if (game.engine_version < VERSION_IDENT(2,2,0,7))
14496 player->push_delay_value = GET_NEW_PUSH_DELAY(element);
14498 player->push_delay_value = -1; // get new value later
14500 // check for element change _after_ element has been pushed
14501 if (game.use_change_when_pushing_bug)
14503 CheckElementChangeByPlayer(x, y, element, CE_PUSHED_BY_PLAYER,
14504 player->index_bit, dig_side);
14505 CheckTriggeredElementChangeByPlayer(x, y, element, CE_PLAYER_PUSHES_X,
14506 player->index_bit, dig_side);
14509 else if (IS_SWITCHABLE(element))
14511 if (PLAYER_SWITCHING(player, x, y))
14513 CheckTriggeredElementChangeByPlayer(x, y, element, CE_PLAYER_PRESSES_X,
14514 player->index_bit, dig_side);
14519 player->is_switching = TRUE;
14520 player->switch_x = x;
14521 player->switch_y = y;
14523 PlayLevelSoundElementAction(x, y, element, ACTION_ACTIVATING);
14525 if (element == EL_ROBOT_WHEEL)
14527 Tile[x][y] = EL_ROBOT_WHEEL_ACTIVE;
14529 game.robot_wheel_x = x;
14530 game.robot_wheel_y = y;
14531 game.robot_wheel_active = TRUE;
14533 TEST_DrawLevelField(x, y);
14535 else if (element == EL_SP_TERMINAL)
14539 SCAN_PLAYFIELD(xx, yy)
14541 if (Tile[xx][yy] == EL_SP_DISK_YELLOW)
14545 else if (Tile[xx][yy] == EL_SP_TERMINAL)
14547 Tile[xx][yy] = EL_SP_TERMINAL_ACTIVE;
14549 ResetGfxAnimation(xx, yy);
14550 TEST_DrawLevelField(xx, yy);
14554 else if (IS_BELT_SWITCH(element))
14556 ToggleBeltSwitch(x, y);
14558 else if (element == EL_SWITCHGATE_SWITCH_UP ||
14559 element == EL_SWITCHGATE_SWITCH_DOWN ||
14560 element == EL_DC_SWITCHGATE_SWITCH_UP ||
14561 element == EL_DC_SWITCHGATE_SWITCH_DOWN)
14563 ToggleSwitchgateSwitch(x, y);
14565 else if (element == EL_LIGHT_SWITCH ||
14566 element == EL_LIGHT_SWITCH_ACTIVE)
14568 ToggleLightSwitch(x, y);
14570 else if (element == EL_TIMEGATE_SWITCH ||
14571 element == EL_DC_TIMEGATE_SWITCH)
14573 ActivateTimegateSwitch(x, y);
14575 else if (element == EL_BALLOON_SWITCH_LEFT ||
14576 element == EL_BALLOON_SWITCH_RIGHT ||
14577 element == EL_BALLOON_SWITCH_UP ||
14578 element == EL_BALLOON_SWITCH_DOWN ||
14579 element == EL_BALLOON_SWITCH_NONE ||
14580 element == EL_BALLOON_SWITCH_ANY)
14582 game.wind_direction = (element == EL_BALLOON_SWITCH_LEFT ? MV_LEFT :
14583 element == EL_BALLOON_SWITCH_RIGHT ? MV_RIGHT :
14584 element == EL_BALLOON_SWITCH_UP ? MV_UP :
14585 element == EL_BALLOON_SWITCH_DOWN ? MV_DOWN :
14586 element == EL_BALLOON_SWITCH_NONE ? MV_NONE :
14589 else if (element == EL_LAMP)
14591 Tile[x][y] = EL_LAMP_ACTIVE;
14592 game.lights_still_needed--;
14594 ResetGfxAnimation(x, y);
14595 TEST_DrawLevelField(x, y);
14597 else if (element == EL_TIME_ORB_FULL)
14599 Tile[x][y] = EL_TIME_ORB_EMPTY;
14601 if (level.time > 0 || level.use_time_orb_bug)
14603 TimeLeft += level.time_orb_time;
14604 game.no_time_limit = FALSE;
14606 game_panel_controls[GAME_PANEL_TIME].value = TimeLeft;
14608 DisplayGameControlValues();
14611 ResetGfxAnimation(x, y);
14612 TEST_DrawLevelField(x, y);
14614 else if (element == EL_EMC_MAGIC_BALL_SWITCH ||
14615 element == EL_EMC_MAGIC_BALL_SWITCH_ACTIVE)
14619 game.ball_active = !game.ball_active;
14621 SCAN_PLAYFIELD(xx, yy)
14623 int e = Tile[xx][yy];
14625 if (game.ball_active)
14627 if (e == EL_EMC_MAGIC_BALL)
14628 CreateField(xx, yy, EL_EMC_MAGIC_BALL_ACTIVE);
14629 else if (e == EL_EMC_MAGIC_BALL_SWITCH)
14630 CreateField(xx, yy, EL_EMC_MAGIC_BALL_SWITCH_ACTIVE);
14634 if (e == EL_EMC_MAGIC_BALL_ACTIVE)
14635 CreateField(xx, yy, EL_EMC_MAGIC_BALL);
14636 else if (e == EL_EMC_MAGIC_BALL_SWITCH_ACTIVE)
14637 CreateField(xx, yy, EL_EMC_MAGIC_BALL_SWITCH);
14642 CheckTriggeredElementChangeByPlayer(x, y, element, CE_SWITCH_OF_X,
14643 player->index_bit, dig_side);
14645 CheckTriggeredElementChangeByPlayer(x, y, element, CE_PLAYER_SWITCHES_X,
14646 player->index_bit, dig_side);
14648 CheckTriggeredElementChangeByPlayer(x, y, element, CE_PLAYER_PRESSES_X,
14649 player->index_bit, dig_side);
14655 if (!PLAYER_SWITCHING(player, x, y))
14657 player->is_switching = TRUE;
14658 player->switch_x = x;
14659 player->switch_y = y;
14661 CheckElementChangeByPlayer(x, y, element, CE_SWITCHED,
14662 player->index_bit, dig_side);
14663 CheckTriggeredElementChangeByPlayer(x, y, element, CE_SWITCH_OF_X,
14664 player->index_bit, dig_side);
14666 CheckElementChangeByPlayer(x, y, element, CE_SWITCHED_BY_PLAYER,
14667 player->index_bit, dig_side);
14668 CheckTriggeredElementChangeByPlayer(x, y, element, CE_PLAYER_SWITCHES_X,
14669 player->index_bit, dig_side);
14672 CheckElementChangeByPlayer(x, y, element, CE_PRESSED_BY_PLAYER,
14673 player->index_bit, dig_side);
14674 CheckTriggeredElementChangeByPlayer(x, y, element, CE_PLAYER_PRESSES_X,
14675 player->index_bit, dig_side);
14677 return MP_NO_ACTION;
14680 player->push_delay = -1;
14682 if (is_player) // function can also be called by EL_PENGUIN
14684 if (Tile[x][y] != element) // really digged/collected something
14686 player->is_collecting = !player->is_digging;
14687 player->is_active = TRUE;
14689 player->last_removed_element = element;
14696 static boolean DigFieldByCE(int x, int y, int digging_element)
14698 int element = Tile[x][y];
14700 if (!IS_FREE(x, y))
14702 int action = (IS_DIGGABLE(element) ? ACTION_DIGGING :
14703 IS_COLLECTIBLE(element) ? ACTION_COLLECTING :
14706 // no element can dig solid indestructible elements
14707 if (IS_INDESTRUCTIBLE(element) &&
14708 !IS_DIGGABLE(element) &&
14709 !IS_COLLECTIBLE(element))
14712 if (AmoebaNr[x][y] &&
14713 (element == EL_AMOEBA_FULL ||
14714 element == EL_BD_AMOEBA ||
14715 element == EL_AMOEBA_GROWING))
14717 AmoebaCnt[AmoebaNr[x][y]]--;
14718 AmoebaCnt2[AmoebaNr[x][y]]--;
14721 if (IS_MOVING(x, y))
14722 RemoveMovingField(x, y);
14726 TEST_DrawLevelField(x, y);
14729 // if digged element was about to explode, prevent the explosion
14730 ExplodeField[x][y] = EX_TYPE_NONE;
14732 PlayLevelSoundAction(x, y, action);
14735 Store[x][y] = EL_EMPTY;
14737 // this makes it possible to leave the removed element again
14738 if (IS_EQUAL_OR_IN_GROUP(element, MOVE_ENTER_EL(digging_element)))
14739 Store[x][y] = element;
14744 static boolean SnapField(struct PlayerInfo *player, int dx, int dy)
14746 int jx = player->jx, jy = player->jy;
14747 int x = jx + dx, y = jy + dy;
14748 int snap_direction = (dx == -1 ? MV_LEFT :
14749 dx == +1 ? MV_RIGHT :
14751 dy == +1 ? MV_DOWN : MV_NONE);
14752 boolean can_continue_snapping = (level.continuous_snapping &&
14753 WasJustFalling[x][y] < CHECK_DELAY_FALLING);
14755 if (player->MovPos != 0 && game.engine_version >= VERSION_IDENT(2,2,0,0))
14758 if (!player->active || !IN_LEV_FIELD(x, y))
14766 if (player->MovPos == 0)
14767 player->is_pushing = FALSE;
14769 player->is_snapping = FALSE;
14771 if (player->MovPos == 0)
14773 player->is_moving = FALSE;
14774 player->is_digging = FALSE;
14775 player->is_collecting = FALSE;
14781 // prevent snapping with already pressed snap key when not allowed
14782 if (player->is_snapping && !can_continue_snapping)
14785 player->MovDir = snap_direction;
14787 if (player->MovPos == 0)
14789 player->is_moving = FALSE;
14790 player->is_digging = FALSE;
14791 player->is_collecting = FALSE;
14794 player->is_dropping = FALSE;
14795 player->is_dropping_pressed = FALSE;
14796 player->drop_pressed_delay = 0;
14798 if (DigField(player, jx, jy, x, y, 0, 0, DF_SNAP) == MP_NO_ACTION)
14801 player->is_snapping = TRUE;
14802 player->is_active = TRUE;
14804 if (player->MovPos == 0)
14806 player->is_moving = FALSE;
14807 player->is_digging = FALSE;
14808 player->is_collecting = FALSE;
14811 if (player->MovPos != 0) // prevent graphic bugs in versions < 2.2.0
14812 TEST_DrawLevelField(player->last_jx, player->last_jy);
14814 TEST_DrawLevelField(x, y);
14819 static boolean DropElement(struct PlayerInfo *player)
14821 int old_element, new_element;
14822 int dropx = player->jx, dropy = player->jy;
14823 int drop_direction = player->MovDir;
14824 int drop_side = drop_direction;
14825 int drop_element = get_next_dropped_element(player);
14827 /* do not drop an element on top of another element; when holding drop key
14828 pressed without moving, dropped element must move away before the next
14829 element can be dropped (this is especially important if the next element
14830 is dynamite, which can be placed on background for historical reasons) */
14831 if (PLAYER_DROPPING(player, dropx, dropy) && Tile[dropx][dropy] != EL_EMPTY)
14834 if (IS_THROWABLE(drop_element))
14836 dropx += GET_DX_FROM_DIR(drop_direction);
14837 dropy += GET_DY_FROM_DIR(drop_direction);
14839 if (!IN_LEV_FIELD(dropx, dropy))
14843 old_element = Tile[dropx][dropy]; // old element at dropping position
14844 new_element = drop_element; // default: no change when dropping
14846 // check if player is active, not moving and ready to drop
14847 if (!player->active || player->MovPos || player->drop_delay > 0)
14850 // check if player has anything that can be dropped
14851 if (new_element == EL_UNDEFINED)
14854 // only set if player has anything that can be dropped
14855 player->is_dropping_pressed = TRUE;
14857 // check if drop key was pressed long enough for EM style dynamite
14858 if (new_element == EL_EM_DYNAMITE && player->drop_pressed_delay < 40)
14861 // check if anything can be dropped at the current position
14862 if (IS_ACTIVE_BOMB(old_element) || old_element == EL_EXPLOSION)
14865 // collected custom elements can only be dropped on empty fields
14866 if (IS_CUSTOM_ELEMENT(new_element) && old_element != EL_EMPTY)
14869 if (old_element != EL_EMPTY)
14870 Back[dropx][dropy] = old_element; // store old element on this field
14872 ResetGfxAnimation(dropx, dropy);
14873 ResetRandomAnimationValue(dropx, dropy);
14875 if (player->inventory_size > 0 ||
14876 player->inventory_infinite_element != EL_UNDEFINED)
14878 if (player->inventory_size > 0)
14880 player->inventory_size--;
14882 DrawGameDoorValues();
14884 if (new_element == EL_DYNAMITE)
14885 new_element = EL_DYNAMITE_ACTIVE;
14886 else if (new_element == EL_EM_DYNAMITE)
14887 new_element = EL_EM_DYNAMITE_ACTIVE;
14888 else if (new_element == EL_SP_DISK_RED)
14889 new_element = EL_SP_DISK_RED_ACTIVE;
14892 Tile[dropx][dropy] = new_element;
14894 if (IN_SCR_FIELD(SCREENX(dropx), SCREENY(dropy)))
14895 DrawGraphicThruMask(SCREENX(dropx), SCREENY(dropy),
14896 el2img(Tile[dropx][dropy]), 0);
14898 PlayLevelSoundAction(dropx, dropy, ACTION_DROPPING);
14900 // needed if previous element just changed to "empty" in the last frame
14901 ChangeCount[dropx][dropy] = 0; // allow at least one more change
14903 CheckElementChangeByPlayer(dropx, dropy, new_element, CE_DROPPED_BY_PLAYER,
14904 player->index_bit, drop_side);
14905 CheckTriggeredElementChangeByPlayer(dropx, dropy, new_element,
14907 player->index_bit, drop_side);
14909 TestIfElementTouchesCustomElement(dropx, dropy);
14911 else // player is dropping a dyna bomb
14913 player->dynabombs_left--;
14915 Tile[dropx][dropy] = new_element;
14917 if (IN_SCR_FIELD(SCREENX(dropx), SCREENY(dropy)))
14918 DrawGraphicThruMask(SCREENX(dropx), SCREENY(dropy),
14919 el2img(Tile[dropx][dropy]), 0);
14921 PlayLevelSoundAction(dropx, dropy, ACTION_DROPPING);
14924 if (Tile[dropx][dropy] == new_element) // uninitialized unless CE change
14925 InitField_WithBug1(dropx, dropy, FALSE);
14927 new_element = Tile[dropx][dropy]; // element might have changed
14929 if (IS_CUSTOM_ELEMENT(new_element) && CAN_MOVE(new_element) &&
14930 element_info[new_element].move_pattern == MV_WHEN_DROPPED)
14932 if (element_info[new_element].move_direction_initial == MV_START_AUTOMATIC)
14933 MovDir[dropx][dropy] = drop_direction;
14935 ChangeCount[dropx][dropy] = 0; // allow at least one more change
14937 // do not cause impact style collision by dropping elements that can fall
14938 CheckCollision[dropx][dropy] = CHECK_DELAY_COLLISION;
14941 player->drop_delay = GET_NEW_DROP_DELAY(drop_element);
14942 player->is_dropping = TRUE;
14944 player->drop_pressed_delay = 0;
14945 player->is_dropping_pressed = FALSE;
14947 player->drop_x = dropx;
14948 player->drop_y = dropy;
14953 // ----------------------------------------------------------------------------
14954 // game sound playing functions
14955 // ----------------------------------------------------------------------------
14957 static int *loop_sound_frame = NULL;
14958 static int *loop_sound_volume = NULL;
14960 void InitPlayLevelSound(void)
14962 int num_sounds = getSoundListSize();
14964 checked_free(loop_sound_frame);
14965 checked_free(loop_sound_volume);
14967 loop_sound_frame = checked_calloc(num_sounds * sizeof(int));
14968 loop_sound_volume = checked_calloc(num_sounds * sizeof(int));
14971 static void PlayLevelSound(int x, int y, int nr)
14973 int sx = SCREENX(x), sy = SCREENY(y);
14974 int volume, stereo_position;
14975 int max_distance = 8;
14976 int type = (IS_LOOP_SOUND(nr) ? SND_CTRL_PLAY_LOOP : SND_CTRL_PLAY_SOUND);
14978 if ((!setup.sound_simple && !IS_LOOP_SOUND(nr)) ||
14979 (!setup.sound_loops && IS_LOOP_SOUND(nr)))
14982 if (!IN_LEV_FIELD(x, y) ||
14983 sx < -max_distance || sx >= SCR_FIELDX + max_distance ||
14984 sy < -max_distance || sy >= SCR_FIELDY + max_distance)
14987 volume = SOUND_MAX_VOLUME;
14989 if (!IN_SCR_FIELD(sx, sy))
14991 int dx = ABS(sx - SCR_FIELDX / 2) - SCR_FIELDX / 2;
14992 int dy = ABS(sy - SCR_FIELDY / 2) - SCR_FIELDY / 2;
14994 volume -= volume * (dx > dy ? dx : dy) / max_distance;
14997 stereo_position = (SOUND_MAX_LEFT +
14998 (sx + max_distance) * SOUND_MAX_LEFT2RIGHT /
14999 (SCR_FIELDX + 2 * max_distance));
15001 if (IS_LOOP_SOUND(nr))
15003 /* This assures that quieter loop sounds do not overwrite louder ones,
15004 while restarting sound volume comparison with each new game frame. */
15006 if (loop_sound_volume[nr] > volume && loop_sound_frame[nr] == FrameCounter)
15009 loop_sound_volume[nr] = volume;
15010 loop_sound_frame[nr] = FrameCounter;
15013 PlaySoundExt(nr, volume, stereo_position, type);
15016 static void PlayLevelSoundNearest(int x, int y, int sound_action)
15018 PlayLevelSound(x < LEVELX(BX1) ? LEVELX(BX1) :
15019 x > LEVELX(BX2) ? LEVELX(BX2) : x,
15020 y < LEVELY(BY1) ? LEVELY(BY1) :
15021 y > LEVELY(BY2) ? LEVELY(BY2) : y,
15025 static void PlayLevelSoundAction(int x, int y, int action)
15027 PlayLevelSoundElementAction(x, y, Tile[x][y], action);
15030 static void PlayLevelSoundElementAction(int x, int y, int element, int action)
15032 int sound_effect = element_info[SND_ELEMENT(element)].sound[action];
15034 if (sound_effect != SND_UNDEFINED)
15035 PlayLevelSound(x, y, sound_effect);
15038 static void PlayLevelSoundElementActionIfLoop(int x, int y, int element,
15041 int sound_effect = element_info[SND_ELEMENT(element)].sound[action];
15043 if (sound_effect != SND_UNDEFINED && IS_LOOP_SOUND(sound_effect))
15044 PlayLevelSound(x, y, sound_effect);
15047 static void PlayLevelSoundActionIfLoop(int x, int y, int action)
15049 int sound_effect = element_info[SND_ELEMENT(Tile[x][y])].sound[action];
15051 if (sound_effect != SND_UNDEFINED && IS_LOOP_SOUND(sound_effect))
15052 PlayLevelSound(x, y, sound_effect);
15055 static void StopLevelSoundActionIfLoop(int x, int y, int action)
15057 int sound_effect = element_info[SND_ELEMENT(Tile[x][y])].sound[action];
15059 if (sound_effect != SND_UNDEFINED && IS_LOOP_SOUND(sound_effect))
15060 StopSound(sound_effect);
15063 static int getLevelMusicNr(void)
15065 if (levelset.music[level_nr] != MUS_UNDEFINED)
15066 return levelset.music[level_nr]; // from config file
15068 return MAP_NOCONF_MUSIC(level_nr); // from music dir
15071 static void FadeLevelSounds(void)
15076 static void FadeLevelMusic(void)
15078 int music_nr = getLevelMusicNr();
15079 char *curr_music = getCurrentlyPlayingMusicFilename();
15080 char *next_music = getMusicInfoEntryFilename(music_nr);
15082 if (!strEqual(curr_music, next_music))
15086 void FadeLevelSoundsAndMusic(void)
15092 static void PlayLevelMusic(void)
15094 int music_nr = getLevelMusicNr();
15095 char *curr_music = getCurrentlyPlayingMusicFilename();
15096 char *next_music = getMusicInfoEntryFilename(music_nr);
15098 if (!strEqual(curr_music, next_music))
15099 PlayMusicLoop(music_nr);
15102 void PlayLevelSound_EM(int xx, int yy, int element_em, int sample)
15104 int element = (element_em > -1 ? map_element_EM_to_RND_game(element_em) : 0);
15106 int x = xx - offset;
15107 int y = yy - offset;
15112 PlayLevelSoundElementAction(x, y, element, ACTION_WALKING);
15116 PlayLevelSoundElementAction(x, y, element, ACTION_PUSHING);
15120 PlayLevelSoundElementAction(x, y, element, ACTION_IMPACT);
15124 PlayLevelSoundElementAction(x, y, element, ACTION_IMPACT);
15128 PlayLevelSoundElementAction(x, y, element, ACTION_BREAKING);
15132 PlayLevelSoundElementAction(x, y, element, ACTION_MOVING);
15136 PlayLevelSoundElementAction(x, y, element, ACTION_MOVING);
15139 case SOUND_android_clone:
15140 PlayLevelSoundElementAction(x, y, element, ACTION_DROPPING);
15143 case SOUND_android_move:
15144 PlayLevelSoundElementAction(x, y, element, ACTION_MOVING);
15148 PlayLevelSoundElementAction(x, y, element, ACTION_IMPACT);
15152 PlayLevelSoundElementAction(x, y, element, ACTION_EATING);
15156 PlayLevelSoundElementAction(x, y, element, ACTION_WAITING);
15159 case SOUND_eater_eat:
15160 PlayLevelSoundElementAction(x, y, element, ACTION_DIGGING);
15164 PlayLevelSoundElementAction(x, y, element, ACTION_MOVING);
15167 case SOUND_collect:
15168 PlayLevelSoundElementAction(x, y, element, ACTION_COLLECTING);
15171 case SOUND_diamond:
15172 PlayLevelSoundElementAction(x, y, element, ACTION_IMPACT);
15176 // !!! CHECK THIS !!!
15178 PlayLevelSoundElementAction(x, y, element, ACTION_BREAKING);
15180 PlayLevelSoundElementAction(x, y, element, ACTION_SMASHED_BY_ROCK);
15184 case SOUND_wonderfall:
15185 PlayLevelSoundElementAction(x, y, element, ACTION_FILLING);
15189 PlayLevelSoundElementAction(x, y, element, ACTION_IMPACT);
15193 PlayLevelSoundElementAction(x, y, element, ACTION_PUSHING);
15197 PlayLevelSoundElementAction(x, y, element, ACTION_DIGGING);
15201 PlayLevelSoundElementAction(x, y, element, ACTION_SPLASHING);
15205 PlayLevelSoundElementAction(x, y, element, ACTION_DROPPING);
15209 PlayLevelSoundElementAction(x, y, element, ACTION_GROWING);
15213 PlayLevelSoundElementAction(x, y, element, ACTION_ACTIVE);
15217 PlayLevelSoundElementAction(x, y, element, ACTION_PASSING);
15220 case SOUND_exit_open:
15221 PlayLevelSoundElementAction(x, y, element, ACTION_OPENING);
15224 case SOUND_exit_leave:
15225 PlayLevelSoundElementAction(x, y, element, ACTION_PASSING);
15228 case SOUND_dynamite:
15229 PlayLevelSoundElementAction(x, y, element, ACTION_DROPPING);
15233 PlayLevelSoundElementAction(x, y, element, ACTION_ACTIVE);
15237 PlayLevelSoundElementAction(x, y, element, ACTION_ACTIVATING);
15241 PlayLevelSoundElementAction(x, y, element, ACTION_ACTIVE);
15245 PlayLevelSoundElementAction(x, y, element, ACTION_EXPLODING);
15249 PlayLevelSoundElementAction(x, y, element, ACTION_DYING);
15253 PlaySound(SND_GAME_RUNNING_OUT_OF_TIME);
15257 PlayLevelSoundElementAction(x, y, element, ACTION_DEFAULT);
15262 void PlayLevelSound_SP(int xx, int yy, int element_sp, int action_sp)
15264 int element = map_element_SP_to_RND(element_sp);
15265 int action = map_action_SP_to_RND(action_sp);
15266 int offset = (setup.sp_show_border_elements ? 0 : 1);
15267 int x = xx - offset;
15268 int y = yy - offset;
15270 PlayLevelSoundElementAction(x, y, element, action);
15273 void PlayLevelSound_MM(int xx, int yy, int element_mm, int action_mm)
15275 int element = map_element_MM_to_RND(element_mm);
15276 int action = map_action_MM_to_RND(action_mm);
15278 int x = xx - offset;
15279 int y = yy - offset;
15281 if (!IS_MM_ELEMENT(element))
15282 element = EL_MM_DEFAULT;
15284 PlayLevelSoundElementAction(x, y, element, action);
15287 void PlaySound_MM(int sound_mm)
15289 int sound = map_sound_MM_to_RND(sound_mm);
15291 if (sound == SND_UNDEFINED)
15297 void PlaySoundLoop_MM(int sound_mm)
15299 int sound = map_sound_MM_to_RND(sound_mm);
15301 if (sound == SND_UNDEFINED)
15304 PlaySoundLoop(sound);
15307 void StopSound_MM(int sound_mm)
15309 int sound = map_sound_MM_to_RND(sound_mm);
15311 if (sound == SND_UNDEFINED)
15317 void RaiseScore(int value)
15319 game.score += value;
15321 game_panel_controls[GAME_PANEL_SCORE].value = game.score;
15323 DisplayGameControlValues();
15326 void RaiseScoreElement(int element)
15331 case EL_BD_DIAMOND:
15332 case EL_EMERALD_YELLOW:
15333 case EL_EMERALD_RED:
15334 case EL_EMERALD_PURPLE:
15335 case EL_SP_INFOTRON:
15336 RaiseScore(level.score[SC_EMERALD]);
15339 RaiseScore(level.score[SC_DIAMOND]);
15342 RaiseScore(level.score[SC_CRYSTAL]);
15345 RaiseScore(level.score[SC_PEARL]);
15348 case EL_BD_BUTTERFLY:
15349 case EL_SP_ELECTRON:
15350 RaiseScore(level.score[SC_BUG]);
15353 case EL_BD_FIREFLY:
15354 case EL_SP_SNIKSNAK:
15355 RaiseScore(level.score[SC_SPACESHIP]);
15358 case EL_DARK_YAMYAM:
15359 RaiseScore(level.score[SC_YAMYAM]);
15362 RaiseScore(level.score[SC_ROBOT]);
15365 RaiseScore(level.score[SC_PACMAN]);
15368 RaiseScore(level.score[SC_NUT]);
15371 case EL_EM_DYNAMITE:
15372 case EL_SP_DISK_RED:
15373 case EL_DYNABOMB_INCREASE_NUMBER:
15374 case EL_DYNABOMB_INCREASE_SIZE:
15375 case EL_DYNABOMB_INCREASE_POWER:
15376 RaiseScore(level.score[SC_DYNAMITE]);
15378 case EL_SHIELD_NORMAL:
15379 case EL_SHIELD_DEADLY:
15380 RaiseScore(level.score[SC_SHIELD]);
15382 case EL_EXTRA_TIME:
15383 RaiseScore(level.extra_time_score);
15397 case EL_DC_KEY_WHITE:
15398 RaiseScore(level.score[SC_KEY]);
15401 RaiseScore(element_info[element].collect_score);
15406 void RequestQuitGameExt(boolean skip_request, boolean quick_quit, char *message)
15408 if (skip_request || Request(message, REQ_ASK | REQ_STAY_CLOSED))
15412 // prevent short reactivation of overlay buttons while closing door
15413 SetOverlayActive(FALSE);
15415 // door may still be open due to skipped or envelope style request
15416 CloseDoor(DOOR_CLOSE_1);
15419 if (network.enabled)
15420 SendToServer_StopPlaying(NETWORK_STOP_BY_PLAYER);
15424 FadeSkipNextFadeIn();
15426 SetGameStatus(GAME_MODE_MAIN);
15431 else // continue playing the game
15433 if (tape.playing && tape.deactivate_display)
15434 TapeDeactivateDisplayOff(TRUE);
15436 OpenDoor(DOOR_OPEN_1 | DOOR_COPY_BACK);
15438 if (tape.playing && tape.deactivate_display)
15439 TapeDeactivateDisplayOn();
15443 void RequestQuitGame(boolean escape_key_pressed)
15445 boolean ask_on_escape = (setup.ask_on_escape && setup.ask_on_quit_game);
15446 boolean quick_quit = ((escape_key_pressed && !ask_on_escape) ||
15447 level_editor_test_game);
15448 boolean skip_request = (game.all_players_gone || !setup.ask_on_quit_game ||
15451 RequestQuitGameExt(skip_request, quick_quit,
15452 "Do you really want to quit the game?");
15455 void RequestRestartGame(char *message)
15457 game.restart_game_message = NULL;
15459 boolean has_started_game = hasStartedNetworkGame();
15460 int request_mode = (has_started_game ? REQ_ASK : REQ_CONFIRM);
15462 if (Request(message, request_mode | REQ_STAY_CLOSED) && has_started_game)
15464 StartGameActions(network.enabled, setup.autorecord, level.random_seed);
15468 // needed in case of envelope request to close game panel
15469 CloseDoor(DOOR_CLOSE_1);
15471 SetGameStatus(GAME_MODE_MAIN);
15477 void CheckGameOver(void)
15479 static boolean last_game_over = FALSE;
15480 static int game_over_delay = 0;
15481 int game_over_delay_value = 50;
15482 boolean game_over = checkGameFailed();
15484 // do not handle game over if request dialog is already active
15485 if (game.request_active)
15488 // do not ask to play again if game was never actually played
15489 if (!game.GamePlayed)
15494 last_game_over = FALSE;
15495 game_over_delay = game_over_delay_value;
15500 if (game_over_delay > 0)
15507 if (last_game_over != game_over)
15508 game.restart_game_message = (hasStartedNetworkGame() ?
15509 "Game over! Play it again?" :
15512 last_game_over = game_over;
15515 boolean checkGameSolved(void)
15517 // set for all game engines if level was solved
15518 return game.LevelSolved_GameEnd;
15521 boolean checkGameFailed(void)
15523 if (level.game_engine_type == GAME_ENGINE_TYPE_EM)
15524 return (game_em.game_over && !game_em.level_solved);
15525 else if (level.game_engine_type == GAME_ENGINE_TYPE_SP)
15526 return (game_sp.game_over && !game_sp.level_solved);
15527 else if (level.game_engine_type == GAME_ENGINE_TYPE_MM)
15528 return (game_mm.game_over && !game_mm.level_solved);
15529 else // GAME_ENGINE_TYPE_RND
15530 return (game.GameOver && !game.LevelSolved);
15533 boolean checkGameEnded(void)
15535 return (checkGameSolved() || checkGameFailed());
15539 // ----------------------------------------------------------------------------
15540 // random generator functions
15541 // ----------------------------------------------------------------------------
15543 unsigned int InitEngineRandom_RND(int seed)
15545 game.num_random_calls = 0;
15547 return InitEngineRandom(seed);
15550 unsigned int RND(int max)
15554 game.num_random_calls++;
15556 return GetEngineRandom(max);
15563 // ----------------------------------------------------------------------------
15564 // game engine snapshot handling functions
15565 // ----------------------------------------------------------------------------
15567 struct EngineSnapshotInfo
15569 // runtime values for custom element collect score
15570 int collect_score[NUM_CUSTOM_ELEMENTS];
15572 // runtime values for group element choice position
15573 int choice_pos[NUM_GROUP_ELEMENTS];
15575 // runtime values for belt position animations
15576 int belt_graphic[4][NUM_BELT_PARTS];
15577 int belt_anim_mode[4][NUM_BELT_PARTS];
15580 static struct EngineSnapshotInfo engine_snapshot_rnd;
15581 static char *snapshot_level_identifier = NULL;
15582 static int snapshot_level_nr = -1;
15584 static void SaveEngineSnapshotValues_RND(void)
15586 static int belt_base_active_element[4] =
15588 EL_CONVEYOR_BELT_1_LEFT_ACTIVE,
15589 EL_CONVEYOR_BELT_2_LEFT_ACTIVE,
15590 EL_CONVEYOR_BELT_3_LEFT_ACTIVE,
15591 EL_CONVEYOR_BELT_4_LEFT_ACTIVE
15595 for (i = 0; i < NUM_CUSTOM_ELEMENTS; i++)
15597 int element = EL_CUSTOM_START + i;
15599 engine_snapshot_rnd.collect_score[i] = element_info[element].collect_score;
15602 for (i = 0; i < NUM_GROUP_ELEMENTS; i++)
15604 int element = EL_GROUP_START + i;
15606 engine_snapshot_rnd.choice_pos[i] = element_info[element].group->choice_pos;
15609 for (i = 0; i < 4; i++)
15611 for (j = 0; j < NUM_BELT_PARTS; j++)
15613 int element = belt_base_active_element[i] + j;
15614 int graphic = el2img(element);
15615 int anim_mode = graphic_info[graphic].anim_mode;
15617 engine_snapshot_rnd.belt_graphic[i][j] = graphic;
15618 engine_snapshot_rnd.belt_anim_mode[i][j] = anim_mode;
15623 static void LoadEngineSnapshotValues_RND(void)
15625 unsigned int num_random_calls = game.num_random_calls;
15628 for (i = 0; i < NUM_CUSTOM_ELEMENTS; i++)
15630 int element = EL_CUSTOM_START + i;
15632 element_info[element].collect_score = engine_snapshot_rnd.collect_score[i];
15635 for (i = 0; i < NUM_GROUP_ELEMENTS; i++)
15637 int element = EL_GROUP_START + i;
15639 element_info[element].group->choice_pos = engine_snapshot_rnd.choice_pos[i];
15642 for (i = 0; i < 4; i++)
15644 for (j = 0; j < NUM_BELT_PARTS; j++)
15646 int graphic = engine_snapshot_rnd.belt_graphic[i][j];
15647 int anim_mode = engine_snapshot_rnd.belt_anim_mode[i][j];
15649 graphic_info[graphic].anim_mode = anim_mode;
15653 if (level.game_engine_type == GAME_ENGINE_TYPE_RND)
15655 InitRND(tape.random_seed);
15656 for (i = 0; i < num_random_calls; i++)
15660 if (game.num_random_calls != num_random_calls)
15662 Error("number of random calls out of sync");
15663 Error("number of random calls should be %d", num_random_calls);
15664 Error("number of random calls is %d", game.num_random_calls);
15666 Fail("this should not happen -- please debug");
15670 void FreeEngineSnapshotSingle(void)
15672 FreeSnapshotSingle();
15674 setString(&snapshot_level_identifier, NULL);
15675 snapshot_level_nr = -1;
15678 void FreeEngineSnapshotList(void)
15680 FreeSnapshotList();
15683 static ListNode *SaveEngineSnapshotBuffers(void)
15685 ListNode *buffers = NULL;
15687 // copy some special values to a structure better suited for the snapshot
15689 if (level.game_engine_type == GAME_ENGINE_TYPE_RND)
15690 SaveEngineSnapshotValues_RND();
15691 if (level.game_engine_type == GAME_ENGINE_TYPE_EM)
15692 SaveEngineSnapshotValues_EM();
15693 if (level.game_engine_type == GAME_ENGINE_TYPE_SP)
15694 SaveEngineSnapshotValues_SP(&buffers);
15695 if (level.game_engine_type == GAME_ENGINE_TYPE_MM)
15696 SaveEngineSnapshotValues_MM(&buffers);
15698 // save values stored in special snapshot structure
15700 if (level.game_engine_type == GAME_ENGINE_TYPE_RND)
15701 SaveSnapshotBuffer(&buffers, ARGS_ADDRESS_AND_SIZEOF(engine_snapshot_rnd));
15702 if (level.game_engine_type == GAME_ENGINE_TYPE_EM)
15703 SaveSnapshotBuffer(&buffers, ARGS_ADDRESS_AND_SIZEOF(engine_snapshot_em));
15704 if (level.game_engine_type == GAME_ENGINE_TYPE_SP)
15705 SaveSnapshotBuffer(&buffers, ARGS_ADDRESS_AND_SIZEOF(engine_snapshot_sp));
15706 if (level.game_engine_type == GAME_ENGINE_TYPE_MM)
15707 SaveSnapshotBuffer(&buffers, ARGS_ADDRESS_AND_SIZEOF(engine_snapshot_mm));
15709 // save further RND engine values
15711 SaveSnapshotBuffer(&buffers, ARGS_ADDRESS_AND_SIZEOF(stored_player));
15712 SaveSnapshotBuffer(&buffers, ARGS_ADDRESS_AND_SIZEOF(game));
15713 SaveSnapshotBuffer(&buffers, ARGS_ADDRESS_AND_SIZEOF(tape));
15715 SaveSnapshotBuffer(&buffers, ARGS_ADDRESS_AND_SIZEOF(FrameCounter));
15716 SaveSnapshotBuffer(&buffers, ARGS_ADDRESS_AND_SIZEOF(TimeFrames));
15717 SaveSnapshotBuffer(&buffers, ARGS_ADDRESS_AND_SIZEOF(TimePlayed));
15718 SaveSnapshotBuffer(&buffers, ARGS_ADDRESS_AND_SIZEOF(TimeLeft));
15719 SaveSnapshotBuffer(&buffers, ARGS_ADDRESS_AND_SIZEOF(TapeTime));
15721 SaveSnapshotBuffer(&buffers, ARGS_ADDRESS_AND_SIZEOF(ScreenMovDir));
15722 SaveSnapshotBuffer(&buffers, ARGS_ADDRESS_AND_SIZEOF(ScreenMovPos));
15723 SaveSnapshotBuffer(&buffers, ARGS_ADDRESS_AND_SIZEOF(ScreenGfxPos));
15725 SaveSnapshotBuffer(&buffers, ARGS_ADDRESS_AND_SIZEOF(ScrollStepSize));
15727 SaveSnapshotBuffer(&buffers, ARGS_ADDRESS_AND_SIZEOF(AmoebaCnt));
15728 SaveSnapshotBuffer(&buffers, ARGS_ADDRESS_AND_SIZEOF(AmoebaCnt2));
15730 SaveSnapshotBuffer(&buffers, ARGS_ADDRESS_AND_SIZEOF(Tile));
15731 SaveSnapshotBuffer(&buffers, ARGS_ADDRESS_AND_SIZEOF(MovPos));
15732 SaveSnapshotBuffer(&buffers, ARGS_ADDRESS_AND_SIZEOF(MovDir));
15733 SaveSnapshotBuffer(&buffers, ARGS_ADDRESS_AND_SIZEOF(MovDelay));
15734 SaveSnapshotBuffer(&buffers, ARGS_ADDRESS_AND_SIZEOF(ChangeDelay));
15735 SaveSnapshotBuffer(&buffers, ARGS_ADDRESS_AND_SIZEOF(ChangePage));
15736 SaveSnapshotBuffer(&buffers, ARGS_ADDRESS_AND_SIZEOF(CustomValue));
15737 SaveSnapshotBuffer(&buffers, ARGS_ADDRESS_AND_SIZEOF(Store));
15738 SaveSnapshotBuffer(&buffers, ARGS_ADDRESS_AND_SIZEOF(Store2));
15739 SaveSnapshotBuffer(&buffers, ARGS_ADDRESS_AND_SIZEOF(StorePlayer));
15740 SaveSnapshotBuffer(&buffers, ARGS_ADDRESS_AND_SIZEOF(Back));
15741 SaveSnapshotBuffer(&buffers, ARGS_ADDRESS_AND_SIZEOF(AmoebaNr));
15742 SaveSnapshotBuffer(&buffers, ARGS_ADDRESS_AND_SIZEOF(WasJustMoving));
15743 SaveSnapshotBuffer(&buffers, ARGS_ADDRESS_AND_SIZEOF(WasJustFalling));
15744 SaveSnapshotBuffer(&buffers, ARGS_ADDRESS_AND_SIZEOF(CheckCollision));
15745 SaveSnapshotBuffer(&buffers, ARGS_ADDRESS_AND_SIZEOF(CheckImpact));
15746 SaveSnapshotBuffer(&buffers, ARGS_ADDRESS_AND_SIZEOF(Stop));
15747 SaveSnapshotBuffer(&buffers, ARGS_ADDRESS_AND_SIZEOF(Pushed));
15749 SaveSnapshotBuffer(&buffers, ARGS_ADDRESS_AND_SIZEOF(ChangeCount));
15750 SaveSnapshotBuffer(&buffers, ARGS_ADDRESS_AND_SIZEOF(ChangeEvent));
15752 SaveSnapshotBuffer(&buffers, ARGS_ADDRESS_AND_SIZEOF(ExplodePhase));
15753 SaveSnapshotBuffer(&buffers, ARGS_ADDRESS_AND_SIZEOF(ExplodeDelay));
15754 SaveSnapshotBuffer(&buffers, ARGS_ADDRESS_AND_SIZEOF(ExplodeField));
15756 SaveSnapshotBuffer(&buffers, ARGS_ADDRESS_AND_SIZEOF(RunnerVisit));
15757 SaveSnapshotBuffer(&buffers, ARGS_ADDRESS_AND_SIZEOF(PlayerVisit));
15759 SaveSnapshotBuffer(&buffers, ARGS_ADDRESS_AND_SIZEOF(GfxFrame));
15760 SaveSnapshotBuffer(&buffers, ARGS_ADDRESS_AND_SIZEOF(GfxRandom));
15761 SaveSnapshotBuffer(&buffers, ARGS_ADDRESS_AND_SIZEOF(GfxElement));
15762 SaveSnapshotBuffer(&buffers, ARGS_ADDRESS_AND_SIZEOF(GfxAction));
15763 SaveSnapshotBuffer(&buffers, ARGS_ADDRESS_AND_SIZEOF(GfxDir));
15765 SaveSnapshotBuffer(&buffers, ARGS_ADDRESS_AND_SIZEOF(scroll_x));
15766 SaveSnapshotBuffer(&buffers, ARGS_ADDRESS_AND_SIZEOF(scroll_y));
15769 ListNode *node = engine_snapshot_list_rnd;
15772 while (node != NULL)
15774 num_bytes += ((struct EngineSnapshotNodeInfo *)node->content)->size;
15779 Debug("game:playing:SaveEngineSnapshotBuffers",
15780 "size of engine snapshot: %d bytes", num_bytes);
15786 void SaveEngineSnapshotSingle(void)
15788 ListNode *buffers = SaveEngineSnapshotBuffers();
15790 // finally save all snapshot buffers to single snapshot
15791 SaveSnapshotSingle(buffers);
15793 // save level identification information
15794 setString(&snapshot_level_identifier, leveldir_current->identifier);
15795 snapshot_level_nr = level_nr;
15798 boolean CheckSaveEngineSnapshotToList(void)
15800 boolean save_snapshot =
15801 ((game.snapshot.mode == SNAPSHOT_MODE_EVERY_STEP) ||
15802 (game.snapshot.mode == SNAPSHOT_MODE_EVERY_MOVE &&
15803 game.snapshot.changed_action) ||
15804 (game.snapshot.mode == SNAPSHOT_MODE_EVERY_COLLECT &&
15805 game.snapshot.collected_item));
15807 game.snapshot.changed_action = FALSE;
15808 game.snapshot.collected_item = FALSE;
15809 game.snapshot.save_snapshot = save_snapshot;
15811 return save_snapshot;
15814 void SaveEngineSnapshotToList(void)
15816 if (game.snapshot.mode == SNAPSHOT_MODE_OFF ||
15820 ListNode *buffers = SaveEngineSnapshotBuffers();
15822 // finally save all snapshot buffers to snapshot list
15823 SaveSnapshotToList(buffers);
15826 void SaveEngineSnapshotToListInitial(void)
15828 FreeEngineSnapshotList();
15830 SaveEngineSnapshotToList();
15833 static void LoadEngineSnapshotValues(void)
15835 // restore special values from snapshot structure
15837 if (level.game_engine_type == GAME_ENGINE_TYPE_RND)
15838 LoadEngineSnapshotValues_RND();
15839 if (level.game_engine_type == GAME_ENGINE_TYPE_EM)
15840 LoadEngineSnapshotValues_EM();
15841 if (level.game_engine_type == GAME_ENGINE_TYPE_SP)
15842 LoadEngineSnapshotValues_SP();
15843 if (level.game_engine_type == GAME_ENGINE_TYPE_MM)
15844 LoadEngineSnapshotValues_MM();
15847 void LoadEngineSnapshotSingle(void)
15849 LoadSnapshotSingle();
15851 LoadEngineSnapshotValues();
15854 static void LoadEngineSnapshot_Undo(int steps)
15856 LoadSnapshotFromList_Older(steps);
15858 LoadEngineSnapshotValues();
15861 static void LoadEngineSnapshot_Redo(int steps)
15863 LoadSnapshotFromList_Newer(steps);
15865 LoadEngineSnapshotValues();
15868 boolean CheckEngineSnapshotSingle(void)
15870 return (strEqual(snapshot_level_identifier, leveldir_current->identifier) &&
15871 snapshot_level_nr == level_nr);
15874 boolean CheckEngineSnapshotList(void)
15876 return CheckSnapshotList();
15880 // ---------- new game button stuff -------------------------------------------
15887 boolean *setup_value;
15888 boolean allowed_on_tape;
15889 boolean is_touch_button;
15891 } gamebutton_info[NUM_GAME_BUTTONS] =
15894 IMG_GFX_GAME_BUTTON_STOP, &game.button.stop,
15895 GAME_CTRL_ID_STOP, NULL,
15896 TRUE, FALSE, "stop game"
15899 IMG_GFX_GAME_BUTTON_PAUSE, &game.button.pause,
15900 GAME_CTRL_ID_PAUSE, NULL,
15901 TRUE, FALSE, "pause game"
15904 IMG_GFX_GAME_BUTTON_PLAY, &game.button.play,
15905 GAME_CTRL_ID_PLAY, NULL,
15906 TRUE, FALSE, "play game"
15909 IMG_GFX_GAME_BUTTON_UNDO, &game.button.undo,
15910 GAME_CTRL_ID_UNDO, NULL,
15911 TRUE, FALSE, "undo step"
15914 IMG_GFX_GAME_BUTTON_REDO, &game.button.redo,
15915 GAME_CTRL_ID_REDO, NULL,
15916 TRUE, FALSE, "redo step"
15919 IMG_GFX_GAME_BUTTON_SAVE, &game.button.save,
15920 GAME_CTRL_ID_SAVE, NULL,
15921 TRUE, FALSE, "save game"
15924 IMG_GFX_GAME_BUTTON_PAUSE2, &game.button.pause2,
15925 GAME_CTRL_ID_PAUSE2, NULL,
15926 TRUE, FALSE, "pause game"
15929 IMG_GFX_GAME_BUTTON_LOAD, &game.button.load,
15930 GAME_CTRL_ID_LOAD, NULL,
15931 TRUE, FALSE, "load game"
15934 IMG_GFX_GAME_BUTTON_PANEL_STOP, &game.button.panel_stop,
15935 GAME_CTRL_ID_PANEL_STOP, NULL,
15936 FALSE, FALSE, "stop game"
15939 IMG_GFX_GAME_BUTTON_PANEL_PAUSE, &game.button.panel_pause,
15940 GAME_CTRL_ID_PANEL_PAUSE, NULL,
15941 FALSE, FALSE, "pause game"
15944 IMG_GFX_GAME_BUTTON_PANEL_PLAY, &game.button.panel_play,
15945 GAME_CTRL_ID_PANEL_PLAY, NULL,
15946 FALSE, FALSE, "play game"
15949 IMG_GFX_GAME_BUTTON_TOUCH_STOP, &game.button.touch_stop,
15950 GAME_CTRL_ID_TOUCH_STOP, NULL,
15951 FALSE, TRUE, "stop game"
15954 IMG_GFX_GAME_BUTTON_TOUCH_PAUSE, &game.button.touch_pause,
15955 GAME_CTRL_ID_TOUCH_PAUSE, NULL,
15956 FALSE, TRUE, "pause game"
15959 IMG_GFX_GAME_BUTTON_SOUND_MUSIC, &game.button.sound_music,
15960 SOUND_CTRL_ID_MUSIC, &setup.sound_music,
15961 TRUE, FALSE, "background music on/off"
15964 IMG_GFX_GAME_BUTTON_SOUND_LOOPS, &game.button.sound_loops,
15965 SOUND_CTRL_ID_LOOPS, &setup.sound_loops,
15966 TRUE, FALSE, "sound loops on/off"
15969 IMG_GFX_GAME_BUTTON_SOUND_SIMPLE, &game.button.sound_simple,
15970 SOUND_CTRL_ID_SIMPLE, &setup.sound_simple,
15971 TRUE, FALSE, "normal sounds on/off"
15974 IMG_GFX_GAME_BUTTON_PANEL_SOUND_MUSIC, &game.button.panel_sound_music,
15975 SOUND_CTRL_ID_PANEL_MUSIC, &setup.sound_music,
15976 FALSE, FALSE, "background music on/off"
15979 IMG_GFX_GAME_BUTTON_PANEL_SOUND_LOOPS, &game.button.panel_sound_loops,
15980 SOUND_CTRL_ID_PANEL_LOOPS, &setup.sound_loops,
15981 FALSE, FALSE, "sound loops on/off"
15984 IMG_GFX_GAME_BUTTON_PANEL_SOUND_SIMPLE, &game.button.panel_sound_simple,
15985 SOUND_CTRL_ID_PANEL_SIMPLE, &setup.sound_simple,
15986 FALSE, FALSE, "normal sounds on/off"
15990 void CreateGameButtons(void)
15994 for (i = 0; i < NUM_GAME_BUTTONS; i++)
15996 int graphic = gamebutton_info[i].graphic;
15997 struct GraphicInfo *gfx = &graphic_info[graphic];
15998 struct XY *pos = gamebutton_info[i].pos;
15999 struct GadgetInfo *gi;
16002 unsigned int event_mask;
16003 boolean is_touch_button = gamebutton_info[i].is_touch_button;
16004 boolean allowed_on_tape = gamebutton_info[i].allowed_on_tape;
16005 boolean on_tape = (tape.show_game_buttons && allowed_on_tape);
16006 int base_x = (is_touch_button ? 0 : on_tape ? VX : DX);
16007 int base_y = (is_touch_button ? 0 : on_tape ? VY : DY);
16008 int gd_x = gfx->src_x;
16009 int gd_y = gfx->src_y;
16010 int gd_xp = gfx->src_x + gfx->pressed_xoffset;
16011 int gd_yp = gfx->src_y + gfx->pressed_yoffset;
16012 int gd_xa = gfx->src_x + gfx->active_xoffset;
16013 int gd_ya = gfx->src_y + gfx->active_yoffset;
16014 int gd_xap = gfx->src_x + gfx->active_xoffset + gfx->pressed_xoffset;
16015 int gd_yap = gfx->src_y + gfx->active_yoffset + gfx->pressed_yoffset;
16016 int x = (is_touch_button ? pos->x : GDI_ACTIVE_POS(pos->x));
16017 int y = (is_touch_button ? pos->y : GDI_ACTIVE_POS(pos->y));
16020 if (gfx->bitmap == NULL)
16022 game_gadget[id] = NULL;
16027 if (id == GAME_CTRL_ID_STOP ||
16028 id == GAME_CTRL_ID_PANEL_STOP ||
16029 id == GAME_CTRL_ID_TOUCH_STOP ||
16030 id == GAME_CTRL_ID_PLAY ||
16031 id == GAME_CTRL_ID_PANEL_PLAY ||
16032 id == GAME_CTRL_ID_SAVE ||
16033 id == GAME_CTRL_ID_LOAD)
16035 button_type = GD_TYPE_NORMAL_BUTTON;
16037 event_mask = GD_EVENT_RELEASED;
16039 else if (id == GAME_CTRL_ID_UNDO ||
16040 id == GAME_CTRL_ID_REDO)
16042 button_type = GD_TYPE_NORMAL_BUTTON;
16044 event_mask = GD_EVENT_PRESSED | GD_EVENT_REPEATED;
16048 button_type = GD_TYPE_CHECK_BUTTON;
16049 checked = (gamebutton_info[i].setup_value != NULL ?
16050 *gamebutton_info[i].setup_value : FALSE);
16051 event_mask = GD_EVENT_PRESSED;
16054 gi = CreateGadget(GDI_CUSTOM_ID, id,
16055 GDI_IMAGE_ID, graphic,
16056 GDI_INFO_TEXT, gamebutton_info[i].infotext,
16059 GDI_WIDTH, gfx->width,
16060 GDI_HEIGHT, gfx->height,
16061 GDI_TYPE, button_type,
16062 GDI_STATE, GD_BUTTON_UNPRESSED,
16063 GDI_CHECKED, checked,
16064 GDI_DESIGN_UNPRESSED, gfx->bitmap, gd_x, gd_y,
16065 GDI_DESIGN_PRESSED, gfx->bitmap, gd_xp, gd_yp,
16066 GDI_ALT_DESIGN_UNPRESSED, gfx->bitmap, gd_xa, gd_ya,
16067 GDI_ALT_DESIGN_PRESSED, gfx->bitmap, gd_xap, gd_yap,
16068 GDI_DIRECT_DRAW, FALSE,
16069 GDI_OVERLAY_TOUCH_BUTTON, is_touch_button,
16070 GDI_EVENT_MASK, event_mask,
16071 GDI_CALLBACK_ACTION, HandleGameButtons,
16075 Fail("cannot create gadget");
16077 game_gadget[id] = gi;
16081 void FreeGameButtons(void)
16085 for (i = 0; i < NUM_GAME_BUTTONS; i++)
16086 FreeGadget(game_gadget[i]);
16089 static void UnmapGameButtonsAtSamePosition(int id)
16093 for (i = 0; i < NUM_GAME_BUTTONS; i++)
16095 gamebutton_info[i].pos->x == gamebutton_info[id].pos->x &&
16096 gamebutton_info[i].pos->y == gamebutton_info[id].pos->y)
16097 UnmapGadget(game_gadget[i]);
16100 static void UnmapGameButtonsAtSamePosition_All(void)
16102 if (setup.show_snapshot_buttons)
16104 UnmapGameButtonsAtSamePosition(GAME_CTRL_ID_SAVE);
16105 UnmapGameButtonsAtSamePosition(GAME_CTRL_ID_PAUSE2);
16106 UnmapGameButtonsAtSamePosition(GAME_CTRL_ID_LOAD);
16110 UnmapGameButtonsAtSamePosition(GAME_CTRL_ID_STOP);
16111 UnmapGameButtonsAtSamePosition(GAME_CTRL_ID_PAUSE);
16112 UnmapGameButtonsAtSamePosition(GAME_CTRL_ID_PLAY);
16114 UnmapGameButtonsAtSamePosition(GAME_CTRL_ID_PANEL_STOP);
16115 UnmapGameButtonsAtSamePosition(GAME_CTRL_ID_PANEL_PAUSE);
16116 UnmapGameButtonsAtSamePosition(GAME_CTRL_ID_PANEL_PLAY);
16120 static void MapGameButtonsAtSamePosition(int id)
16124 for (i = 0; i < NUM_GAME_BUTTONS; i++)
16126 gamebutton_info[i].pos->x == gamebutton_info[id].pos->x &&
16127 gamebutton_info[i].pos->y == gamebutton_info[id].pos->y)
16128 MapGadget(game_gadget[i]);
16130 UnmapGameButtonsAtSamePosition_All();
16133 void MapUndoRedoButtons(void)
16135 UnmapGameButtonsAtSamePosition(GAME_CTRL_ID_UNDO);
16136 UnmapGameButtonsAtSamePosition(GAME_CTRL_ID_REDO);
16138 MapGadget(game_gadget[GAME_CTRL_ID_UNDO]);
16139 MapGadget(game_gadget[GAME_CTRL_ID_REDO]);
16142 void UnmapUndoRedoButtons(void)
16144 UnmapGadget(game_gadget[GAME_CTRL_ID_UNDO]);
16145 UnmapGadget(game_gadget[GAME_CTRL_ID_REDO]);
16147 MapGameButtonsAtSamePosition(GAME_CTRL_ID_UNDO);
16148 MapGameButtonsAtSamePosition(GAME_CTRL_ID_REDO);
16151 void ModifyPauseButtons(void)
16155 GAME_CTRL_ID_PAUSE,
16156 GAME_CTRL_ID_PAUSE2,
16157 GAME_CTRL_ID_PANEL_PAUSE,
16158 GAME_CTRL_ID_TOUCH_PAUSE,
16163 for (i = 0; ids[i] > -1; i++)
16164 ModifyGadget(game_gadget[ids[i]], GDI_CHECKED, tape.pausing, GDI_END);
16167 static void MapGameButtonsExt(boolean on_tape)
16171 for (i = 0; i < NUM_GAME_BUTTONS; i++)
16172 if ((!on_tape || gamebutton_info[i].allowed_on_tape) &&
16173 i != GAME_CTRL_ID_UNDO &&
16174 i != GAME_CTRL_ID_REDO)
16175 MapGadget(game_gadget[i]);
16177 UnmapGameButtonsAtSamePosition_All();
16179 RedrawGameButtons();
16182 static void UnmapGameButtonsExt(boolean on_tape)
16186 for (i = 0; i < NUM_GAME_BUTTONS; i++)
16187 if (!on_tape || gamebutton_info[i].allowed_on_tape)
16188 UnmapGadget(game_gadget[i]);
16191 static void RedrawGameButtonsExt(boolean on_tape)
16195 for (i = 0; i < NUM_GAME_BUTTONS; i++)
16196 if (!on_tape || gamebutton_info[i].allowed_on_tape)
16197 RedrawGadget(game_gadget[i]);
16200 static void SetGadgetState(struct GadgetInfo *gi, boolean state)
16205 gi->checked = state;
16208 static void RedrawSoundButtonGadget(int id)
16210 int id2 = (id == SOUND_CTRL_ID_MUSIC ? SOUND_CTRL_ID_PANEL_MUSIC :
16211 id == SOUND_CTRL_ID_LOOPS ? SOUND_CTRL_ID_PANEL_LOOPS :
16212 id == SOUND_CTRL_ID_SIMPLE ? SOUND_CTRL_ID_PANEL_SIMPLE :
16213 id == SOUND_CTRL_ID_PANEL_MUSIC ? SOUND_CTRL_ID_MUSIC :
16214 id == SOUND_CTRL_ID_PANEL_LOOPS ? SOUND_CTRL_ID_LOOPS :
16215 id == SOUND_CTRL_ID_PANEL_SIMPLE ? SOUND_CTRL_ID_SIMPLE :
16218 SetGadgetState(game_gadget[id2], *gamebutton_info[id2].setup_value);
16219 RedrawGadget(game_gadget[id2]);
16222 void MapGameButtons(void)
16224 MapGameButtonsExt(FALSE);
16227 void UnmapGameButtons(void)
16229 UnmapGameButtonsExt(FALSE);
16232 void RedrawGameButtons(void)
16234 RedrawGameButtonsExt(FALSE);
16237 void MapGameButtonsOnTape(void)
16239 MapGameButtonsExt(TRUE);
16242 void UnmapGameButtonsOnTape(void)
16244 UnmapGameButtonsExt(TRUE);
16247 void RedrawGameButtonsOnTape(void)
16249 RedrawGameButtonsExt(TRUE);
16252 static void GameUndoRedoExt(void)
16254 ClearPlayerAction();
16256 tape.pausing = TRUE;
16259 UpdateAndDisplayGameControlValues();
16261 DrawCompleteVideoDisplay();
16262 DrawVideoDisplay(VIDEO_STATE_TIME_ON, TapeTime);
16263 DrawVideoDisplay(VIDEO_STATE_FRAME_ON, FrameCounter);
16264 DrawVideoDisplay(VIDEO_STATE_1STEP(tape.single_step), 0);
16269 static void GameUndo(int steps)
16271 if (!CheckEngineSnapshotList())
16274 LoadEngineSnapshot_Undo(steps);
16279 static void GameRedo(int steps)
16281 if (!CheckEngineSnapshotList())
16284 LoadEngineSnapshot_Redo(steps);
16289 static void HandleGameButtonsExt(int id, int button)
16291 static boolean game_undo_executed = FALSE;
16292 int steps = BUTTON_STEPSIZE(button);
16293 boolean handle_game_buttons =
16294 (game_status == GAME_MODE_PLAYING ||
16295 (game_status == GAME_MODE_MAIN && tape.show_game_buttons));
16297 if (!handle_game_buttons)
16302 case GAME_CTRL_ID_STOP:
16303 case GAME_CTRL_ID_PANEL_STOP:
16304 case GAME_CTRL_ID_TOUCH_STOP:
16305 if (game_status == GAME_MODE_MAIN)
16311 RequestQuitGame(FALSE);
16315 case GAME_CTRL_ID_PAUSE:
16316 case GAME_CTRL_ID_PAUSE2:
16317 case GAME_CTRL_ID_PANEL_PAUSE:
16318 case GAME_CTRL_ID_TOUCH_PAUSE:
16319 if (network.enabled && game_status == GAME_MODE_PLAYING)
16322 SendToServer_ContinuePlaying();
16324 SendToServer_PausePlaying();
16327 TapeTogglePause(TAPE_TOGGLE_MANUAL);
16329 game_undo_executed = FALSE;
16333 case GAME_CTRL_ID_PLAY:
16334 case GAME_CTRL_ID_PANEL_PLAY:
16335 if (game_status == GAME_MODE_MAIN)
16337 StartGameActions(network.enabled, setup.autorecord, level.random_seed);
16339 else if (tape.pausing)
16341 if (network.enabled)
16342 SendToServer_ContinuePlaying();
16344 TapeTogglePause(TAPE_TOGGLE_MANUAL | TAPE_TOGGLE_PLAY_PAUSE);
16348 case GAME_CTRL_ID_UNDO:
16349 // Important: When using "save snapshot when collecting an item" mode,
16350 // load last (current) snapshot for first "undo" after pressing "pause"
16351 // (else the last-but-one snapshot would be loaded, because the snapshot
16352 // pointer already points to the last snapshot when pressing "pause",
16353 // which is fine for "every step/move" mode, but not for "every collect")
16354 if (game.snapshot.mode == SNAPSHOT_MODE_EVERY_COLLECT &&
16355 !game_undo_executed)
16358 game_undo_executed = TRUE;
16363 case GAME_CTRL_ID_REDO:
16367 case GAME_CTRL_ID_SAVE:
16371 case GAME_CTRL_ID_LOAD:
16375 case SOUND_CTRL_ID_MUSIC:
16376 case SOUND_CTRL_ID_PANEL_MUSIC:
16377 if (setup.sound_music)
16379 setup.sound_music = FALSE;
16383 else if (audio.music_available)
16385 setup.sound = setup.sound_music = TRUE;
16387 SetAudioMode(setup.sound);
16389 if (game_status == GAME_MODE_PLAYING)
16393 RedrawSoundButtonGadget(id);
16397 case SOUND_CTRL_ID_LOOPS:
16398 case SOUND_CTRL_ID_PANEL_LOOPS:
16399 if (setup.sound_loops)
16400 setup.sound_loops = FALSE;
16401 else if (audio.loops_available)
16403 setup.sound = setup.sound_loops = TRUE;
16405 SetAudioMode(setup.sound);
16408 RedrawSoundButtonGadget(id);
16412 case SOUND_CTRL_ID_SIMPLE:
16413 case SOUND_CTRL_ID_PANEL_SIMPLE:
16414 if (setup.sound_simple)
16415 setup.sound_simple = FALSE;
16416 else if (audio.sound_available)
16418 setup.sound = setup.sound_simple = TRUE;
16420 SetAudioMode(setup.sound);
16423 RedrawSoundButtonGadget(id);
16432 static void HandleGameButtons(struct GadgetInfo *gi)
16434 HandleGameButtonsExt(gi->custom_id, gi->event.button);
16437 void HandleSoundButtonKeys(Key key)
16439 if (key == setup.shortcut.sound_simple)
16440 ClickOnGadget(game_gadget[SOUND_CTRL_ID_SIMPLE], MB_LEFTBUTTON);
16441 else if (key == setup.shortcut.sound_loops)
16442 ClickOnGadget(game_gadget[SOUND_CTRL_ID_LOOPS], MB_LEFTBUTTON);
16443 else if (key == setup.shortcut.sound_music)
16444 ClickOnGadget(game_gadget[SOUND_CTRL_ID_MUSIC], MB_LEFTBUTTON);