src/game.c

   1 /***********************************************************
   2 * Rocks'n'Diamonds -- McDuffin Strikes Back!               *
   3 *----------------------------------------------------------*
   4 * (c) 1995-2002 Artsoft Entertainment                      *
   5 *               Holger Schemel                             *
   6 *               Detmolder Strasse 189                      *
   7 *               33604 Bielefeld                            *
   8 *               Germany                                    *
   9 *               e-mail: info@artsoft.org                   *
  10 *----------------------------------------------------------*
  11 * game.c                                                   *
  12 ***********************************************************/
  13
  14 #include "libgame/libgame.h"
  15
  16 #include "game.h"
  17 #include "init.h"
  18 #include "tools.h"
  19 #include "screens.h"
  20 #include "files.h"
  21 #include "tape.h"
  22 #include "network.h"
  23
  24 /* EXPERIMENTAL STUFF */
  25 #define USE_NEW_AMOEBA_CODE     FALSE
  26
  27 /* EXPERIMENTAL STUFF */
  28 #define USE_NEW_STUFF                   (                         1)
  29
  30 #define USE_NEW_SP_SLIPPERY             (USE_NEW_STUFF          * 1)
  31 #define USE_NEW_COLLECT_COUNT           (USE_NEW_STUFF          * 1)
  32 #define USE_NEW_PLAYER_ANIM             (USE_NEW_STUFF          * 1)
  33 #define USE_NEW_ALL_SLIPPERY            (USE_NEW_STUFF          * 1)
  34 #define USE_NEW_PLAYER_SPEED            (USE_NEW_STUFF          * 1)
  35 #define USE_NEW_DELAYED_ACTION          (USE_NEW_STUFF          * 1)
  36
  37 /* for DigField() */
  38 #define DF_NO_PUSH              0
  39 #define DF_DIG                  1
  40 #define DF_SNAP                 2
  41
  42 /* for MovePlayer() */
  43 #define MF_NO_ACTION            0
  44 #define MF_MOVING               1
  45 #define MF_ACTION               2
  46
  47 /* for ScrollPlayer() */
  48 #define SCROLL_INIT             0
  49 #define SCROLL_GO_ON            1
  50
  51 /* for Explode() */
  52 #define EX_PHASE_START          0
  53 #define EX_TYPE_NONE            0
  54 #define EX_TYPE_NORMAL          (1 << 0)
  55 #define EX_TYPE_CENTER          (1 << 1)
  56 #define EX_TYPE_BORDER          (1 << 2)
  57 #define EX_TYPE_CROSS           (1 << 3)
  58 #define EX_TYPE_SINGLE_TILE     (EX_TYPE_CENTER | EX_TYPE_BORDER)
  59
  60 /* special positions in the game control window (relative to control window) */
  61 #define XX_LEVEL                37
  62 #define YY_LEVEL                20
  63 #define XX_EMERALDS             29
  64 #define YY_EMERALDS             54
  65 #define XX_DYNAMITE             29
  66 #define YY_DYNAMITE             89
  67 #define XX_KEYS                 18
  68 #define YY_KEYS                 123
  69 #define XX_SCORE                15
  70 #define YY_SCORE                159
  71 #define XX_TIME1                29
  72 #define XX_TIME2                30
  73 #define YY_TIME                 194
  74
  75 /* special positions in the game control window (relative to main window) */
  76 #define DX_LEVEL                (DX + XX_LEVEL)
  77 #define DY_LEVEL                (DY + YY_LEVEL)
  78 #define DX_EMERALDS             (DX + XX_EMERALDS)
  79 #define DY_EMERALDS             (DY + YY_EMERALDS)
  80 #define DX_DYNAMITE             (DX + XX_DYNAMITE)
  81 #define DY_DYNAMITE             (DY + YY_DYNAMITE)
  82 #define DX_KEYS                 (DX + XX_KEYS)
  83 #define DY_KEYS                 (DY + YY_KEYS)
  84 #define DX_SCORE                (DX + XX_SCORE)
  85 #define DY_SCORE                (DY + YY_SCORE)
  86 #define DX_TIME1                (DX + XX_TIME1)
  87 #define DX_TIME2                (DX + XX_TIME2)
  88 #define DY_TIME                 (DY + YY_TIME)
  89
  90 /* values for initial player move delay (initial delay counter value) */
  91 #define INITIAL_MOVE_DELAY_OFF  -1
  92 #define INITIAL_MOVE_DELAY_ON   0
  93
  94 /* values for player movement speed (which is in fact a delay value) */
  95 #define MOVE_DELAY_MIN_SPEED    32
  96 #define MOVE_DELAY_NORMAL_SPEED 8
  97 #define MOVE_DELAY_HIGH_SPEED   4
  98 #define MOVE_DELAY_MAX_SPEED    1
  99
 100 #if 0
 101 #define DOUBLE_MOVE_DELAY(x)    (x = (x <= MOVE_DELAY_HIGH_SPEED ? x * 2 : x))
 102 #define HALVE_MOVE_DELAY(x)     (x = (x >= MOVE_DELAY_HIGH_SPEED ? x / 2 : x))
 103 #else
 104 #define DOUBLE_MOVE_DELAY(x)    (x = (x < MOVE_DELAY_MIN_SPEED ? x * 2 : x))
 105 #define HALVE_MOVE_DELAY(x)     (x = (x > MOVE_DELAY_MAX_SPEED ? x / 2 : x))
 106 #endif
 107 #define DOUBLE_PLAYER_SPEED(p)  (HALVE_MOVE_DELAY((p)->move_delay_value))
 108 #define HALVE_PLAYER_SPEED(p)   (DOUBLE_MOVE_DELAY((p)->move_delay_value))
 109
 110 /* values for other actions */
 111 #define MOVE_STEPSIZE_NORMAL    (TILEX / MOVE_DELAY_NORMAL_SPEED)
 112 #define MOVE_STEPSIZE_MIN       (1)
 113 #define MOVE_STEPSIZE_MAX       (TILEX)
 114
 115 #define GET_DX_FROM_DIR(d)      ((d) == MV_LEFT ? -1 : (d) == MV_RIGHT ? 1 : 0)
 116 #define GET_DY_FROM_DIR(d)      ((d) == MV_UP   ? -1 : (d) == MV_DOWN  ? 1 : 0)
 117
 118 #define INIT_GFX_RANDOM()       (SimpleRND(1000000))
 119
 120 #define GET_NEW_PUSH_DELAY(e)   (   (element_info[e].push_delay_fixed) + \
 121                                  RND(element_info[e].push_delay_random))
 122 #define GET_NEW_DROP_DELAY(e)   (   (element_info[e].drop_delay_fixed) + \
 123                                  RND(element_info[e].drop_delay_random))
 124 #define GET_NEW_MOVE_DELAY(e)   (   (element_info[e].move_delay_fixed) + \
 125                                  RND(element_info[e].move_delay_random))
 126 #define GET_MAX_MOVE_DELAY(e)   (   (element_info[e].move_delay_fixed) + \
 127                                     (element_info[e].move_delay_random))
 128 #define GET_CHANGE_DELAY(c)     (   ((c)->delay_fixed  * (c)->delay_frames) + \
 129                                  RND((c)->delay_random * (c)->delay_frames))
 130
 131 #define GET_TARGET_ELEMENT(e, ch)                                       \
 132         ((e) == EL_TRIGGER_ELEMENT ? (ch)->actual_trigger_element :     \
 133          (e) == EL_TRIGGER_PLAYER  ? (ch)->actual_trigger_player : (e))
 134
 135 #define GET_VALID_PLAYER_ELEMENT(e)                                     \
 136         ((e) >= EL_PLAYER_1 && (e) <= EL_PLAYER_4 ? (e) : EL_PLAYER_1)
 137
 138 #define CAN_GROW_INTO(e)                                                \
 139         ((e) == EL_SAND || (IS_DIGGABLE(e) && level.grow_into_diggable))
 140
 141 #define ELEMENT_CAN_ENTER_FIELD_BASE_X(x, y, condition)                 \
 142                 (IN_LEV_FIELD(x, y) && (IS_FREE(x, y) ||                \
 143                                         (condition)))
 144
 145 #define ELEMENT_CAN_ENTER_FIELD_BASE_2(e, x, y, condition)              \
 146                 (IN_LEV_FIELD(x, y) && (IS_FREE(x, y) ||                \
 147                                         (CAN_MOVE_INTO_ACID(e) &&       \
 148                                          Feld[x][y] == EL_ACID) ||      \
 149                                         (condition)))
 150
 151 #define ELEMENT_CAN_ENTER_FIELD_BASE_3(e, x, y, condition)              \
 152                 (IN_LEV_FIELD(x, y) && (IS_FREE_OR_PLAYER(x, y) ||      \
 153                                         (CAN_MOVE_INTO_ACID(e) &&       \
 154                                          Feld[x][y] == EL_ACID) ||      \
 155                                         (condition)))
 156
 157 #define ELEMENT_CAN_ENTER_FIELD_BASE_4(e, x, y, condition)              \
 158                 (IN_LEV_FIELD(x, y) && (IS_FREE(x, y) ||                \
 159                                         (condition) ||                  \
 160                                         (CAN_MOVE_INTO_ACID(e) &&       \
 161                                          Feld[x][y] == EL_ACID) ||      \
 162                                         (DONT_COLLIDE_WITH(e) &&        \
 163                                          IS_PLAYER(x, y) &&             \
 164                                          !PLAYER_ENEMY_PROTECTED(x, y))))
 165
 166 #define ELEMENT_CAN_ENTER_FIELD(e, x, y)                                \
 167         ELEMENT_CAN_ENTER_FIELD_BASE_4(e, x, y, 0)
 168
 169 #define SATELLITE_CAN_ENTER_FIELD(x, y)                                 \
 170         ELEMENT_CAN_ENTER_FIELD_BASE_2(EL_SATELLITE, x, y, 0)
 171
 172 #define ENEMY_CAN_ENTER_FIELD(e, x, y)                                  \
 173         ELEMENT_CAN_ENTER_FIELD_BASE_2(e, x, y, 0)
 174
 175 #define YAMYAM_CAN_ENTER_FIELD(e, x, y)                                 \
 176         ELEMENT_CAN_ENTER_FIELD_BASE_3(e, x, y, Feld[x][y] == EL_DIAMOND)
 177
 178 #define DARK_YAMYAM_CAN_ENTER_FIELD(e, x, y)                            \
 179         ELEMENT_CAN_ENTER_FIELD_BASE_3(e, x,y, IS_FOOD_DARK_YAMYAM(Feld[x][y]))
 180
 181 #define PACMAN_CAN_ENTER_FIELD(e, x, y)                                 \
 182         ELEMENT_CAN_ENTER_FIELD_BASE_3(e, x, y, IS_AMOEBOID(Feld[x][y]))
 183
 184 #define PIG_CAN_ENTER_FIELD(e, x, y)                                    \
 185         ELEMENT_CAN_ENTER_FIELD_BASE_2(e, x, y, IS_FOOD_PIG(Feld[x][y]))
 186
 187 #define PENGUIN_CAN_ENTER_FIELD(e, x, y)                                \
 188         ELEMENT_CAN_ENTER_FIELD_BASE_2(e, x, y, (Feld[x][y] == EL_EXIT_OPEN ||\
 189                                                  IS_FOOD_PENGUIN(Feld[x][y])))
 190 #define DRAGON_CAN_ENTER_FIELD(e, x, y)                                 \
 191         ELEMENT_CAN_ENTER_FIELD_BASE_2(e, x, y, 0)
 192
 193 #define MOLE_CAN_ENTER_FIELD(e, x, y, condition)                        \
 194         ELEMENT_CAN_ENTER_FIELD_BASE_2(e, x, y, (condition))
 195
 196 #define SPRING_CAN_ENTER_FIELD(e, x, y)                                 \
 197         ELEMENT_CAN_ENTER_FIELD_BASE_2(e, x, y, 0)
 198
 199 #define GROUP_NR(e)             ((e) - EL_GROUP_START)
 200 #define MOVE_ENTER_EL(e)        (element_info[e].move_enter_element)
 201 #define IS_IN_GROUP(e, nr)      (element_info[e].in_group[nr] == TRUE)
 202 #define IS_IN_GROUP_EL(e, ge)   (IS_IN_GROUP(e, (ge) - EL_GROUP_START))
 203
 204 #define IS_EQUAL_OR_IN_GROUP(e, ge)                                     \
 205         (IS_GROUP_ELEMENT(ge) ? IS_IN_GROUP(e, GROUP_NR(ge)) : (e) == (ge))
 206
 207 #define CE_ENTER_FIELD_COND(e, x, y)                                    \
 208                 (!IS_PLAYER(x, y) &&                                    \
 209                  IS_EQUAL_OR_IN_GROUP(Feld[x][y], MOVE_ENTER_EL(e)))
 210
 211 #define CUSTOM_ELEMENT_CAN_ENTER_FIELD(e, x, y)                         \
 212         ELEMENT_CAN_ENTER_FIELD_BASE_4(e, x, y, CE_ENTER_FIELD_COND(e, x, y))
 213
 214 #define IN_LEV_FIELD_AND_IS_FREE(x, y)  (IN_LEV_FIELD(x, y) &&  IS_FREE(x, y))
 215 #define IN_LEV_FIELD_AND_NOT_FREE(x, y) (IN_LEV_FIELD(x, y) && !IS_FREE(x, y))
 216
 217 #define ACCESS_FROM(e, d)               (element_info[e].access_direction &(d))
 218 #define IS_WALKABLE_FROM(e, d)          (IS_WALKABLE(e)   && ACCESS_FROM(e, d))
 219 #define IS_PASSABLE_FROM(e, d)          (IS_PASSABLE(e)   && ACCESS_FROM(e, d))
 220 #define IS_ACCESSIBLE_FROM(e, d)        (IS_ACCESSIBLE(e) && ACCESS_FROM(e, d))
 221
 222 /* game button identifiers */
 223 #define GAME_CTRL_ID_STOP               0
 224 #define GAME_CTRL_ID_PAUSE              1
 225 #define GAME_CTRL_ID_PLAY               2
 226 #define SOUND_CTRL_ID_MUSIC             3
 227 #define SOUND_CTRL_ID_LOOPS             4
 228 #define SOUND_CTRL_ID_SIMPLE            5
 229
 230 #define NUM_GAME_BUTTONS                6
 231
 232
 233 /* forward declaration for internal use */
 234
 235 static void AdvanceFrameAndPlayerCounters(int);
 236
 237 static boolean MovePlayerOneStep(struct PlayerInfo *, int, int, int, int);
 238 static boolean MovePlayer(struct PlayerInfo *, int, int);
 239 static void ScrollPlayer(struct PlayerInfo *, int);
 240 static void ScrollScreen(struct PlayerInfo *, int);
 241
 242 int DigField(struct PlayerInfo *, int, int, int, int, int, int, int);
 243
 244 static void InitBeltMovement(void);
 245 static void CloseAllOpenTimegates(void);
 246 static void CheckGravityMovement(struct PlayerInfo *);
 247 static void CheckGravityMovementWhenNotMoving(struct PlayerInfo *);
 248 static void KillPlayerUnlessEnemyProtected(int, int);
 249 static void KillPlayerUnlessExplosionProtected(int, int);
 250
 251 static void TestIfPlayerTouchesCustomElement(int, int);
 252 static void TestIfElementTouchesCustomElement(int, int);
 253 static void TestIfElementHitsCustomElement(int, int, int);
 254 #if 0
 255 static void TestIfElementSmashesCustomElement(int, int, int);
 256 #endif
 257
 258 static void ChangeElement(int, int, int);
 259
 260 static boolean CheckTriggeredElementChangeExt(int, int, int,int,int);
 261 #define CheckTriggeredElementChange(e, ev)                              \
 262         CheckTriggeredElementChangeExt(e, ev, CH_PLAYER_ANY, CH_SIDE_ANY, -1)
 263 #define CheckTriggeredElementChangeByPlayer(e, ev, p, s)                \
 264         CheckTriggeredElementChangeExt(e, ev, p, s, -1)
 265 #define CheckTriggeredElementChangeBySide(e, ev, s)                     \
 266         CheckTriggeredElementChangeExt(e, ev, CH_PLAYER_ANY, s, -1)
 267 #define CheckTriggeredElementChangeByPage(e, ev, p)                     \
 268         CheckTriggeredElementChangeExt(e, ev, CH_PLAYER_ANY, CH_SIDE_ANY, p)
 269
 270 static boolean CheckElementChangeExt(int, int, int, int, int, int, int);
 271 #define CheckElementChange(x, y, e, te, ev)                             \
 272         CheckElementChangeExt(x, y, e, te, ev, CH_PLAYER_ANY, CH_SIDE_ANY)
 273 #define CheckElementChangeByPlayer(x, y, e, ev, p, s)                   \
 274         CheckElementChangeExt(x, y, e, EL_EMPTY, ev, p, s)
 275 #define CheckElementChangeBySide(x, y, e, te, ev, s)                    \
 276         CheckElementChangeExt(x, y, e, te, ev, CH_PLAYER_ANY, s)
 277
 278 static void PlayLevelSound(int, int, int);
 279 static void PlayLevelSoundNearest(int, int, int);
 280 static void PlayLevelSoundAction(int, int, int);
 281 static void PlayLevelSoundElementAction(int, int, int, int);
 282 static void PlayLevelSoundElementActionIfLoop(int, int, int, int);
 283 static void PlayLevelSoundActionIfLoop(int, int, int);
 284 static void StopLevelSoundActionIfLoop(int, int, int);
 285 static void PlayLevelMusic();
 286
 287 static void MapGameButtons();
 288 static void HandleGameButtons(struct GadgetInfo *);
 289
 290 static struct GadgetInfo *game_gadget[NUM_GAME_BUTTONS];
 291
 292
 293 /* ------------------------------------------------------------------------- */
 294 /* definition of elements that automatically change to other elements after  */
 295 /* a specified time, eventually calling a function when changing             */
 296 /* ------------------------------------------------------------------------- */
 297
 298 /* forward declaration for changer functions */
 299 static void InitBuggyBase(int x, int y);
 300 static void WarnBuggyBase(int x, int y);
 301
 302 static void InitTrap(int x, int y);
 303 static void ActivateTrap(int x, int y);
 304 static void ChangeActiveTrap(int x, int y);
 305
 306 static void InitRobotWheel(int x, int y);
 307 static void RunRobotWheel(int x, int y);
 308 static void StopRobotWheel(int x, int y);
 309
 310 static void InitTimegateWheel(int x, int y);
 311 static void RunTimegateWheel(int x, int y);
 312
 313 struct ChangingElementInfo
 314 {
 315   int element;
 316   int target_element;
 317   int change_delay;
 318   void (*pre_change_function)(int x, int y);
 319   void (*change_function)(int x, int y);
 320   void (*post_change_function)(int x, int y);
 321 };
 322
 323 static struct ChangingElementInfo change_delay_list[] =
 324 {
 325   {
 326     EL_NUT_BREAKING,
 327     EL_EMERALD,
 328     6,
 329     NULL,
 330     NULL,
 331     NULL
 332   },
 333   {
 334     EL_PEARL_BREAKING,
 335     EL_EMPTY,
 336     8,
 337     NULL,
 338     NULL,
 339     NULL
 340   },
 341   {
 342     EL_EXIT_OPENING,
 343     EL_EXIT_OPEN,
 344     29,
 345     NULL,
 346     NULL,
 347     NULL
 348   },
 349   {
 350     EL_EXIT_CLOSING,
 351     EL_EXIT_CLOSED,
 352     29,
 353     NULL,
 354     NULL,
 355     NULL
 356   },
 357   {
 358     EL_SP_EXIT_OPENING,
 359     EL_SP_EXIT_OPEN,
 360     29,
 361     NULL,
 362     NULL,
 363     NULL
 364   },
 365   {
 366     EL_SP_EXIT_CLOSING,
 367     EL_SP_EXIT_CLOSED,
 368     29,
 369     NULL,
 370     NULL,
 371     NULL
 372   },
 373   {
 374     EL_SWITCHGATE_OPENING,
 375     EL_SWITCHGATE_OPEN,
 376     29,
 377     NULL,
 378     NULL,
 379     NULL
 380   },
 381   {
 382     EL_SWITCHGATE_CLOSING,
 383     EL_SWITCHGATE_CLOSED,
 384     29,
 385     NULL,
 386     NULL,
 387     NULL
 388   },
 389   {
 390     EL_TIMEGATE_OPENING,
 391     EL_TIMEGATE_OPEN,
 392     29,
 393     NULL,
 394     NULL,
 395     NULL
 396   },
 397   {
 398     EL_TIMEGATE_CLOSING,
 399     EL_TIMEGATE_CLOSED,
 400     29,
 401     NULL,
 402     NULL,
 403     NULL
 404   },
 405
 406   {
 407     EL_ACID_SPLASH_LEFT,
 408     EL_EMPTY,
 409     8,
 410     NULL,
 411     NULL,
 412     NULL
 413   },
 414   {
 415     EL_ACID_SPLASH_RIGHT,
 416     EL_EMPTY,
 417     8,
 418     NULL,
 419     NULL,
 420     NULL
 421   },
 422   {
 423     EL_SP_BUGGY_BASE,
 424     EL_SP_BUGGY_BASE_ACTIVATING,
 425     0,
 426     InitBuggyBase,
 427     NULL,
 428     NULL
 429   },
 430   {
 431     EL_SP_BUGGY_BASE_ACTIVATING,
 432     EL_SP_BUGGY_BASE_ACTIVE,
 433     0,
 434     InitBuggyBase,
 435     NULL,
 436     NULL
 437   },
 438   {
 439     EL_SP_BUGGY_BASE_ACTIVE,
 440     EL_SP_BUGGY_BASE,
 441     0,
 442     InitBuggyBase,
 443     WarnBuggyBase,
 444     NULL
 445   },
 446   {
 447     EL_TRAP,
 448     EL_TRAP_ACTIVE,
 449     0,
 450     InitTrap,
 451     NULL,
 452     ActivateTrap
 453   },
 454   {
 455     EL_TRAP_ACTIVE,
 456     EL_TRAP,
 457     31,
 458     NULL,
 459     ChangeActiveTrap,
 460     NULL
 461   },
 462   {
 463     EL_ROBOT_WHEEL_ACTIVE,
 464     EL_ROBOT_WHEEL,
 465     0,
 466     InitRobotWheel,
 467     RunRobotWheel,
 468     StopRobotWheel
 469   },
 470   {
 471     EL_TIMEGATE_SWITCH_ACTIVE,
 472     EL_TIMEGATE_SWITCH,
 473     0,
 474     InitTimegateWheel,
 475     RunTimegateWheel,
 476     NULL
 477   },
 478
 479   {
 480     EL_UNDEFINED,
 481     EL_UNDEFINED,
 482     -1,
 483     NULL,
 484     NULL,
 485     NULL
 486   }
 487 };
 488
 489 struct
 490 {
 491   int element;
 492   int push_delay_fixed, push_delay_random;
 493 }
 494 push_delay_list[] =
 495 {
 496   { EL_SPRING,                  0, 0 },
 497   { EL_BALLOON,                 0, 0 },
 498
 499   { EL_SOKOBAN_OBJECT,          2, 0 },
 500   { EL_SOKOBAN_FIELD_FULL,      2, 0 },
 501   { EL_SATELLITE,               2, 0 },
 502   { EL_SP_DISK_YELLOW,          2, 0 },
 503
 504   { EL_UNDEFINED,               0, 0 },
 505 };
 506
 507 struct
 508 {
 509   int element;
 510   int move_stepsize;
 511 }
 512 move_stepsize_list[] =
 513 {
 514   { EL_AMOEBA_DROP,             2 },
 515   { EL_AMOEBA_DROPPING,         2 },
 516   { EL_QUICKSAND_FILLING,       1 },
 517   { EL_QUICKSAND_EMPTYING,      1 },
 518   { EL_MAGIC_WALL_FILLING,      2 },
 519   { EL_BD_MAGIC_WALL_FILLING,   2 },
 520   { EL_MAGIC_WALL_EMPTYING,     2 },
 521   { EL_BD_MAGIC_WALL_EMPTYING,  2 },
 522
 523   { EL_UNDEFINED,               0 },
 524 };
 525
 526 struct
 527 {
 528   int element;
 529   int count;
 530 }
 531 collect_count_list[] =
 532 {
 533   { EL_EMERALD,                 1 },
 534   { EL_BD_DIAMOND,              1 },
 535   { EL_EMERALD_YELLOW,          1 },
 536   { EL_EMERALD_RED,             1 },
 537   { EL_EMERALD_PURPLE,          1 },
 538   { EL_DIAMOND,                 3 },
 539   { EL_SP_INFOTRON,             1 },
 540   { EL_PEARL,                   5 },
 541   { EL_CRYSTAL,                 8 },
 542
 543   { EL_UNDEFINED,               0 },
 544 };
 545
 546 struct
 547 {
 548   int element;
 549   int direction;
 550 }
 551 access_direction_list[] =
 552 {
 553   { EL_TUBE_ANY,                        MV_LEFT | MV_RIGHT | MV_UP | MV_DOWN },
 554   { EL_TUBE_VERTICAL,                                        MV_UP | MV_DOWN },
 555   { EL_TUBE_HORIZONTAL,                 MV_LEFT | MV_RIGHT                   },
 556   { EL_TUBE_VERTICAL_LEFT,              MV_LEFT |            MV_UP | MV_DOWN },
 557   { EL_TUBE_VERTICAL_RIGHT,                       MV_RIGHT | MV_UP | MV_DOWN },
 558   { EL_TUBE_HORIZONTAL_UP,              MV_LEFT | MV_RIGHT | MV_UP           },
 559   { EL_TUBE_HORIZONTAL_DOWN,            MV_LEFT | MV_RIGHT |         MV_DOWN },
 560   { EL_TUBE_LEFT_UP,                    MV_LEFT |            MV_UP           },
 561   { EL_TUBE_LEFT_DOWN,                  MV_LEFT |                    MV_DOWN },
 562   { EL_TUBE_RIGHT_UP,                             MV_RIGHT | MV_UP           },
 563   { EL_TUBE_RIGHT_DOWN,                           MV_RIGHT |         MV_DOWN },
 564
 565   { EL_SP_PORT_LEFT,                              MV_RIGHT                   },
 566   { EL_SP_PORT_RIGHT,                   MV_LEFT                              },
 567   { EL_SP_PORT_UP,                                                   MV_DOWN },
 568   { EL_SP_PORT_DOWN,                                         MV_UP           },
 569   { EL_SP_PORT_HORIZONTAL,              MV_LEFT | MV_RIGHT                   },
 570   { EL_SP_PORT_VERTICAL,                                     MV_UP | MV_DOWN },
 571   { EL_SP_PORT_ANY,                     MV_LEFT | MV_RIGHT | MV_UP | MV_DOWN },
 572   { EL_SP_GRAVITY_PORT_LEFT,                      MV_RIGHT                   },
 573   { EL_SP_GRAVITY_PORT_RIGHT,           MV_LEFT                              },
 574   { EL_SP_GRAVITY_PORT_UP,                                           MV_DOWN },
 575   { EL_SP_GRAVITY_PORT_DOWN,                                 MV_UP           },
 576   { EL_SP_GRAVITY_ON_PORT_LEFT,                   MV_RIGHT                   },
 577   { EL_SP_GRAVITY_ON_PORT_RIGHT,        MV_LEFT                              },
 578   { EL_SP_GRAVITY_ON_PORT_UP,                                        MV_DOWN },
 579   { EL_SP_GRAVITY_ON_PORT_DOWN,                              MV_UP           },
 580   { EL_SP_GRAVITY_OFF_PORT_LEFT,                  MV_RIGHT                   },
 581   { EL_SP_GRAVITY_OFF_PORT_RIGHT,       MV_LEFT                              },
 582   { EL_SP_GRAVITY_OFF_PORT_UP,                                       MV_DOWN },
 583   { EL_SP_GRAVITY_OFF_PORT_DOWN,                             MV_UP           },
 584
 585   { EL_UNDEFINED,                       MV_NO_MOVING                         }
 586 };
 587
 588 static boolean trigger_events[MAX_NUM_ELEMENTS][NUM_CHANGE_EVENTS];
 589
 590 #define IS_AUTO_CHANGING(e)     (element_info[e].has_change_event[CE_DELAY])
 591 #define IS_JUST_CHANGING(x, y)  (ChangeDelay[x][y] != 0)
 592 #define IS_CHANGING(x, y)       (IS_AUTO_CHANGING(Feld[x][y]) || \
 593                                  IS_JUST_CHANGING(x, y))
 594
 595 #define CE_PAGE(e, ce)          (element_info[e].event_page[ce])
 596
 597
 598 void GetPlayerConfig()
 599 {
 600   if (!audio.sound_available)
 601     setup.sound_simple = FALSE;
 602
 603   if (!audio.loops_available)
 604     setup.sound_loops = FALSE;
 605
 606   if (!audio.music_available)
 607     setup.sound_music = FALSE;
 608
 609   if (!video.fullscreen_available)
 610     setup.fullscreen = FALSE;
 611
 612   setup.sound = (setup.sound_simple || setup.sound_loops || setup.sound_music);
 613
 614   SetAudioMode(setup.sound);
 615   InitJoysticks();
 616 }
 617
 618 static int getBeltNrFromBeltElement(int element)
 619 {
 620   return (element < EL_CONVEYOR_BELT_2_LEFT ? 0 :
 621           element < EL_CONVEYOR_BELT_3_LEFT ? 1 :
 622           element < EL_CONVEYOR_BELT_4_LEFT ? 2 : 3);
 623 }
 624
 625 static int getBeltNrFromBeltActiveElement(int element)
 626 {
 627   return (element < EL_CONVEYOR_BELT_2_LEFT_ACTIVE ? 0 :
 628           element < EL_CONVEYOR_BELT_3_LEFT_ACTIVE ? 1 :
 629           element < EL_CONVEYOR_BELT_4_LEFT_ACTIVE ? 2 : 3);
 630 }
 631
 632 static int getBeltNrFromBeltSwitchElement(int element)
 633 {
 634   return (element < EL_CONVEYOR_BELT_2_SWITCH_LEFT ? 0 :
 635           element < EL_CONVEYOR_BELT_3_SWITCH_LEFT ? 1 :
 636           element < EL_CONVEYOR_BELT_4_SWITCH_LEFT ? 2 : 3);
 637 }
 638
 639 static int getBeltDirNrFromBeltSwitchElement(int element)
 640 {
 641   static int belt_base_element[4] =
 642   {
 643     EL_CONVEYOR_BELT_1_SWITCH_LEFT,
 644     EL_CONVEYOR_BELT_2_SWITCH_LEFT,
 645     EL_CONVEYOR_BELT_3_SWITCH_LEFT,
 646     EL_CONVEYOR_BELT_4_SWITCH_LEFT
 647   };
 648
 649   int belt_nr = getBeltNrFromBeltSwitchElement(element);
 650   int belt_dir_nr = element - belt_base_element[belt_nr];
 651
 652   return (belt_dir_nr % 3);
 653 }
 654
 655 static int getBeltDirFromBeltSwitchElement(int element)
 656 {
 657   static int belt_move_dir[3] =
 658   {
 659     MV_LEFT,
 660     MV_NO_MOVING,
 661     MV_RIGHT
 662   };
 663
 664   int belt_dir_nr = getBeltDirNrFromBeltSwitchElement(element);
 665
 666   return belt_move_dir[belt_dir_nr];
 667 }
 668
 669 static void InitPlayerField(int x, int y, int element, boolean init_game)
 670 {
 671   if (element == EL_SP_MURPHY)
 672   {
 673     if (init_game)
 674     {
 675       if (stored_player[0].present)
 676       {
 677         Feld[x][y] = EL_SP_MURPHY_CLONE;
 678
 679         return;
 680       }
 681       else
 682       {
 683         stored_player[0].use_murphy_graphic = TRUE;
 684       }
 685
 686       Feld[x][y] = EL_PLAYER_1;
 687     }
 688   }
 689
 690   if (init_game)
 691   {
 692     struct PlayerInfo *player = &stored_player[Feld[x][y] - EL_PLAYER_1];
 693     int jx = player->jx, jy = player->jy;
 694
 695     player->present = TRUE;
 696
 697     player->block_last_field = (element == EL_SP_MURPHY ?
 698                                 level.sp_block_last_field :
 699                                 level.block_last_field);
 700
 701     /* ---------- initialize player's last field block delay --------------- */
 702
 703     /* always start with reliable default value (no adjustment needed) */
 704     player->block_delay_adjustment = 0;
 705
 706     /* special case 1: in Supaplex, Murphy blocks last field one more frame */
 707     if (player->block_last_field && element == EL_SP_MURPHY)
 708       player->block_delay_adjustment = 1;
 709
 710     /* special case 2: in game engines before 3.1.1, blocking was different */
 711     if (game.use_block_last_field_bug)
 712       player->block_delay_adjustment = (player->block_last_field ? -1 : 1);
 713
 714     if (!options.network || player->connected)
 715     {
 716       player->active = TRUE;
 717
 718       /* remove potentially duplicate players */
 719       if (StorePlayer[jx][jy] == Feld[x][y])
 720         StorePlayer[jx][jy] = 0;
 721
 722       StorePlayer[x][y] = Feld[x][y];
 723
 724       if (options.debug)
 725       {
 726         printf("Player %d activated.\n", player->element_nr);
 727         printf("[Local player is %d and currently %s.]\n",
 728                local_player->element_nr,
 729                local_player->active ? "active" : "not active");
 730       }
 731     }
 732
 733     Feld[x][y] = EL_EMPTY;
 734
 735     player->jx = player->last_jx = x;
 736     player->jy = player->last_jy = y;
 737   }
 738 }
 739
 740 static void InitField(int x, int y, boolean init_game)
 741 {
 742   int element = Feld[x][y];
 743
 744   switch (element)
 745   {
 746     case EL_SP_MURPHY:
 747     case EL_PLAYER_1:
 748     case EL_PLAYER_2:
 749     case EL_PLAYER_3:
 750     case EL_PLAYER_4:
 751       InitPlayerField(x, y, element, init_game);
 752       break;
 753
 754     case EL_SOKOBAN_FIELD_PLAYER:
 755       element = Feld[x][y] = EL_PLAYER_1;
 756       InitField(x, y, init_game);
 757
 758       element = Feld[x][y] = EL_SOKOBAN_FIELD_EMPTY;
 759       InitField(x, y, init_game);
 760       break;
 761
 762     case EL_SOKOBAN_FIELD_EMPTY:
 763       local_player->sokobanfields_still_needed++;
 764       break;
 765
 766     case EL_STONEBLOCK:
 767       if (x < lev_fieldx-1 && Feld[x+1][y] == EL_ACID)
 768         Feld[x][y] = EL_ACID_POOL_TOPLEFT;
 769       else if (x > 0 && Feld[x-1][y] == EL_ACID)
 770         Feld[x][y] = EL_ACID_POOL_TOPRIGHT;
 771       else if (y > 0 && Feld[x][y-1] == EL_ACID_POOL_TOPLEFT)
 772         Feld[x][y] = EL_ACID_POOL_BOTTOMLEFT;
 773       else if (y > 0 && Feld[x][y-1] == EL_ACID)
 774         Feld[x][y] = EL_ACID_POOL_BOTTOM;
 775       else if (y > 0 && Feld[x][y-1] == EL_ACID_POOL_TOPRIGHT)
 776         Feld[x][y] = EL_ACID_POOL_BOTTOMRIGHT;
 777       break;
 778
 779     case EL_BUG_RIGHT:
 780     case EL_BUG_UP:
 781     case EL_BUG_LEFT:
 782     case EL_BUG_DOWN:
 783     case EL_BUG:
 784     case EL_SPACESHIP_RIGHT:
 785     case EL_SPACESHIP_UP:
 786     case EL_SPACESHIP_LEFT:
 787     case EL_SPACESHIP_DOWN:
 788     case EL_SPACESHIP:
 789     case EL_BD_BUTTERFLY_RIGHT:
 790     case EL_BD_BUTTERFLY_UP:
 791     case EL_BD_BUTTERFLY_LEFT:
 792     case EL_BD_BUTTERFLY_DOWN:
 793     case EL_BD_BUTTERFLY:
 794     case EL_BD_FIREFLY_RIGHT:
 795     case EL_BD_FIREFLY_UP:
 796     case EL_BD_FIREFLY_LEFT:
 797     case EL_BD_FIREFLY_DOWN:
 798     case EL_BD_FIREFLY:
 799     case EL_PACMAN_RIGHT:
 800     case EL_PACMAN_UP:
 801     case EL_PACMAN_LEFT:
 802     case EL_PACMAN_DOWN:
 803     case EL_YAMYAM:
 804     case EL_DARK_YAMYAM:
 805     case EL_ROBOT:
 806     case EL_PACMAN:
 807     case EL_SP_SNIKSNAK:
 808     case EL_SP_ELECTRON:
 809     case EL_MOLE_LEFT:
 810     case EL_MOLE_RIGHT:
 811     case EL_MOLE_UP:
 812     case EL_MOLE_DOWN:
 813     case EL_MOLE:
 814       InitMovDir(x, y);
 815       break;
 816
 817     case EL_AMOEBA_FULL:
 818     case EL_BD_AMOEBA:
 819       InitAmoebaNr(x, y);
 820       break;
 821
 822     case EL_AMOEBA_DROP:
 823       if (y == lev_fieldy - 1)
 824       {
 825         Feld[x][y] = EL_AMOEBA_GROWING;
 826         Store[x][y] = EL_AMOEBA_WET;
 827       }
 828       break;
 829
 830     case EL_DYNAMITE_ACTIVE:
 831     case EL_SP_DISK_RED_ACTIVE:
 832     case EL_DYNABOMB_PLAYER_1_ACTIVE:
 833     case EL_DYNABOMB_PLAYER_2_ACTIVE:
 834     case EL_DYNABOMB_PLAYER_3_ACTIVE:
 835     case EL_DYNABOMB_PLAYER_4_ACTIVE:
 836       MovDelay[x][y] = 96;
 837       break;
 838
 839     case EL_LAMP:
 840       local_player->lights_still_needed++;
 841       break;
 842
 843     case EL_PENGUIN:
 844       local_player->friends_still_needed++;
 845       break;
 846
 847     case EL_PIG:
 848     case EL_DRAGON:
 849       GfxDir[x][y] = MovDir[x][y] = 1 << RND(4);
 850       break;
 851
 852     case EL_CONVEYOR_BELT_1_SWITCH_LEFT:
 853     case EL_CONVEYOR_BELT_1_SWITCH_MIDDLE:
 854     case EL_CONVEYOR_BELT_1_SWITCH_RIGHT:
 855     case EL_CONVEYOR_BELT_2_SWITCH_LEFT:
 856     case EL_CONVEYOR_BELT_2_SWITCH_MIDDLE:
 857     case EL_CONVEYOR_BELT_2_SWITCH_RIGHT:
 858     case EL_CONVEYOR_BELT_3_SWITCH_LEFT:
 859     case EL_CONVEYOR_BELT_3_SWITCH_MIDDLE:
 860     case EL_CONVEYOR_BELT_3_SWITCH_RIGHT:
 861     case EL_CONVEYOR_BELT_4_SWITCH_LEFT:
 862     case EL_CONVEYOR_BELT_4_SWITCH_MIDDLE:
 863     case EL_CONVEYOR_BELT_4_SWITCH_RIGHT:
 864       if (init_game)
 865       {
 866         int belt_nr = getBeltNrFromBeltSwitchElement(Feld[x][y]);
 867         int belt_dir = getBeltDirFromBeltSwitchElement(Feld[x][y]);
 868         int belt_dir_nr = getBeltDirNrFromBeltSwitchElement(Feld[x][y]);
 869
 870         if (game.belt_dir_nr[belt_nr] == 3)     /* initial value */
 871         {
 872           game.belt_dir[belt_nr] = belt_dir;
 873           game.belt_dir_nr[belt_nr] = belt_dir_nr;
 874         }
 875         else    /* more than one switch -- set it like the first switch */
 876         {
 877           Feld[x][y] = Feld[x][y] - belt_dir_nr + game.belt_dir_nr[belt_nr];
 878         }
 879       }
 880       break;
 881
 882     case EL_SWITCHGATE_SWITCH_DOWN:     /* always start with same switch pos */
 883       if (init_game)
 884         Feld[x][y] = EL_SWITCHGATE_SWITCH_UP;
 885       break;
 886
 887     case EL_LIGHT_SWITCH_ACTIVE:
 888       if (init_game)
 889         game.light_time_left = level.time_light * FRAMES_PER_SECOND;
 890       break;
 891
 892     default:
 893       if (IS_CUSTOM_ELEMENT(element) && CAN_MOVE(element))
 894         InitMovDir(x, y);
 895       else if (IS_GROUP_ELEMENT(element))
 896       {
 897         struct ElementGroupInfo *group = element_info[element].group;
 898         int last_anim_random_frame = gfx.anim_random_frame;
 899         int element_pos;
 900
 901         if (group->choice_mode == ANIM_RANDOM)
 902           gfx.anim_random_frame = RND(group->num_elements_resolved);
 903
 904         element_pos = getAnimationFrame(group->num_elements_resolved, 1,
 905                                         group->choice_mode, 0,
 906                                         group->choice_pos);
 907
 908         if (group->choice_mode == ANIM_RANDOM)
 909           gfx.anim_random_frame = last_anim_random_frame;
 910
 911         group->choice_pos++;
 912
 913         Feld[x][y] = group->element_resolved[element_pos];
 914
 915         InitField(x, y, init_game);
 916       }
 917       break;
 918   }
 919
 920 #if USE_NEW_COLLECT_COUNT
 921   Count[x][y] = element_info[Feld[x][y]].collect_count_initial;
 922 #endif
 923 }
 924
 925 static inline void InitField_WithBug1(int x, int y, boolean init_game)
 926 {
 927   InitField(x, y, init_game);
 928
 929   /* not needed to call InitMovDir() -- already done by InitField()! */
 930   if (game.engine_version < VERSION_IDENT(3,1,0,0) &&
 931       CAN_MOVE(Feld[x][y]))
 932     InitMovDir(x, y);
 933 }
 934
 935 static inline void InitField_WithBug2(int x, int y, boolean init_game)
 936 {
 937   int old_element = Feld[x][y];
 938
 939   InitField(x, y, init_game);
 940
 941   /* not needed to call InitMovDir() -- already done by InitField()! */
 942   if (game.engine_version < VERSION_IDENT(3,1,0,0) &&
 943       CAN_MOVE(old_element) &&
 944       (old_element < EL_MOLE_LEFT || old_element > EL_MOLE_DOWN))
 945     InitMovDir(x, y);
 946
 947   /* this case is in fact a combination of not less than three bugs:
 948      first, it calls InitMovDir() for elements that can move, although this is
 949      already done by InitField(); then, it checks the element that was at this
 950      field _before_ the call to InitField() (which can change it); lastly, it
 951      was not called for "mole with direction" elements, which were treated as
 952      "cannot move" due to (fixed) wrong element initialization in "src/init.c"
 953   */
 954 }
 955
 956 inline void DrawGameValue_Emeralds(int value)
 957 {
 958   DrawText(DX_EMERALDS, DY_EMERALDS, int2str(value, 3), FONT_TEXT_2);
 959 }
 960
 961 inline void DrawGameValue_Dynamite(int value)
 962 {
 963   DrawText(DX_DYNAMITE, DY_DYNAMITE, int2str(value, 3), FONT_TEXT_2);
 964 }
 965
 966 inline void DrawGameValue_Keys(int key[MAX_NUM_KEYS])
 967 {
 968   int i;
 969
 970   /* currently only 4 of 8 possible keys are displayed */
 971   for (i = 0; i < STD_NUM_KEYS; i++)
 972   {
 973     if (key[i])
 974       DrawMiniGraphicExt(drawto, DX_KEYS + i * MINI_TILEX, DY_KEYS,
 975                          el2edimg(EL_KEY_1 + i));
 976     else
 977       BlitBitmap(graphic_info[IMG_GLOBAL_DOOR].bitmap, drawto,
 978                  DOOR_GFX_PAGEX5 + XX_KEYS + i * MINI_TILEX, YY_KEYS,
 979                  MINI_TILEX, MINI_TILEY, DX_KEYS + i * MINI_TILEX, DY_KEYS);
 980   }
 981 }
 982
 983 inline void DrawGameValue_Score(int value)
 984 {
 985   DrawText(DX_SCORE, DY_SCORE, int2str(value, 5), FONT_TEXT_2);
 986 }
 987
 988 inline void DrawGameValue_Time(int value)
 989 {
 990   if (value < 1000)
 991     DrawText(DX_TIME1, DY_TIME, int2str(value, 3), FONT_TEXT_2);
 992   else
 993     DrawText(DX_TIME2, DY_TIME, int2str(value, 4), FONT_LEVEL_NUMBER);
 994 }
 995
 996 inline void DrawGameValue_Level(int value)
 997 {
 998   if (level_nr < 100)
 999     DrawText(DX_LEVEL, DY_LEVEL, int2str(value, 2), FONT_TEXT_2);
1000   else
1001   {
1002     /* misuse area for displaying emeralds to draw bigger level number */
1003     DrawTextExt(drawto, DX_EMERALDS, DY_EMERALDS,
1004                 int2str(value, 3), FONT_LEVEL_NUMBER, BLIT_OPAQUE);
1005
1006     /* now copy it to the area for displaying level number */
1007     BlitBitmap(drawto, drawto,
1008                DX_EMERALDS, DY_EMERALDS + 1,
1009                getFontWidth(FONT_LEVEL_NUMBER) * 3,
1010                getFontHeight(FONT_LEVEL_NUMBER) - 1,
1011                DX_LEVEL - 1, DY_LEVEL + 1);
1012
1013     /* restore the area for displaying emeralds */
1014     DrawGameValue_Emeralds(local_player->gems_still_needed);
1015
1016     /* yes, this is all really ugly :-) */
1017   }
1018 }
1019
1020 void DrawAllGameValues(int emeralds, int dynamite, int score, int time,
1021                        int key_bits)
1022 {
1023   int key[MAX_NUM_KEYS];
1024   int i;
1025
1026   for (i = 0; i < MAX_NUM_KEYS; i++)
1027     key[i] = key_bits & (1 << i);
1028
1029   DrawGameValue_Level(level_nr);
1030
1031   DrawGameValue_Emeralds(emeralds);
1032   DrawGameValue_Dynamite(dynamite);
1033   DrawGameValue_Score(score);
1034   DrawGameValue_Time(time);
1035
1036   DrawGameValue_Keys(key);
1037 }
1038
1039 void DrawGameDoorValues()
1040 {
1041   int i;
1042
1043   if (level.game_engine_type == GAME_ENGINE_TYPE_EM)
1044   {
1045     DrawGameDoorValues_EM();
1046
1047     return;
1048   }
1049
1050   DrawGameValue_Level(level_nr);
1051
1052   DrawGameValue_Emeralds(local_player->gems_still_needed);
1053   DrawGameValue_Dynamite(local_player->inventory_size);
1054   DrawGameValue_Score(local_player->score);
1055   DrawGameValue_Time(TimeLeft);
1056
1057   for (i = 0; i < MAX_PLAYERS; i++)
1058     DrawGameValue_Keys(stored_player[i].key);
1059 }
1060
1061 static void resolve_group_element(int group_element, int recursion_depth)
1062 {
1063   static int group_nr;
1064   static struct ElementGroupInfo *group;
1065   struct ElementGroupInfo *actual_group = element_info[group_element].group;
1066   int i;
1067
1068   if (recursion_depth > NUM_GROUP_ELEMENTS)     /* recursion too deep */
1069   {
1070     Error(ERR_WARN, "recursion too deep when resolving group element %d",
1071           group_element - EL_GROUP_START + 1);
1072
1073     /* replace element which caused too deep recursion by question mark */
1074     group->element_resolved[group->num_elements_resolved++] = EL_UNKNOWN;
1075
1076     return;
1077   }
1078
1079   if (recursion_depth == 0)                     /* initialization */
1080   {
1081     group = element_info[group_element].group;
1082     group_nr = group_element - EL_GROUP_START;
1083
1084     group->num_elements_resolved = 0;
1085     group->choice_pos = 0;
1086   }
1087
1088   for (i = 0; i < actual_group->num_elements; i++)
1089   {
1090     int element = actual_group->element[i];
1091
1092     if (group->num_elements_resolved == NUM_FILE_ELEMENTS)
1093       break;
1094
1095     if (IS_GROUP_ELEMENT(element))
1096       resolve_group_element(element, recursion_depth + 1);
1097     else
1098     {
1099       group->element_resolved[group->num_elements_resolved++] = element;
1100       element_info[element].in_group[group_nr] = TRUE;
1101     }
1102   }
1103 }
1104
1105
1106 /*
1107   =============================================================================
1108   InitGameEngine()
1109   -----------------------------------------------------------------------------
1110   initialize game engine due to level / tape version number
1111   =============================================================================
1112 */
1113
1114 static void InitGameEngine()
1115 {
1116   int i, j, k, l;
1117
1118   /* set game engine from tape file when re-playing, else from level file */
1119   game.engine_version = (tape.playing ? tape.engine_version :
1120                          level.game_version);
1121
1122   /* ---------------------------------------------------------------------- */
1123   /* set flags for bugs and changes according to active game engine version */
1124   /* ---------------------------------------------------------------------- */
1125
1126   /*
1127     Summary of bugfix/change:
1128     Fixed handling for custom elements that change when pushed by the player.
1129
1130     Fixed/changed in version:
1131     3.1.0
1132
1133     Description:
1134     Before 3.1.0, custom elements that "change when pushing" changed directly
1135     after the player started pushing them (until then handled in "DigField()").
1136     Since 3.1.0, these custom elements are not changed until the "pushing"
1137     move of the element is finished (now handled in "ContinueMoving()").
1138
1139     Affected levels/tapes:
1140     The first condition is generally needed for all levels/tapes before version
1141     3.1.0, which might use the old behaviour before it was changed; known tapes
1142     that are affected are some tapes from the level set "Walpurgis Gardens" by
1143     Jamie Cullen.
1144     The second condition is an exception from the above case and is needed for
1145     the special case of tapes recorded with game (not engine!) version 3.1.0 or
1146     above (including some development versions of 3.1.0), but before it was
1147     known that this change would break tapes like the above and was fixed in
1148     3.1.1, so that the changed behaviour was active although the engine version
1149     while recording maybe was before 3.1.0. There is at least one tape that is
1150     affected by this exception, which is the tape for the one-level set "Bug
1151     Machine" by Juergen Bonhagen.
1152   */
1153
1154   game.use_change_when_pushing_bug =
1155     (game.engine_version < VERSION_IDENT(3,1,0,0) &&
1156      !(tape.playing &&
1157        tape.game_version >= VERSION_IDENT(3,1,0,0) &&
1158        tape.game_version <  VERSION_IDENT(3,1,1,0)));
1159
1160   /*
1161     Summary of bugfix/change:
1162     Fixed handling for blocking the field the player leaves when moving.
1163
1164     Fixed/changed in version:
1165     3.1.1
1166
1167     Description:
1168     Before 3.1.1, when "block last field when moving" was enabled, the field
1169     the player is leaving when moving was blocked for the time of the move,
1170     and was directly unblocked afterwards. This resulted in the last field
1171     being blocked for exactly one less than the number of frames of one player
1172     move. Additionally, even when blocking was disabled, the last field was
1173     blocked for exactly one frame.
1174     Since 3.1.1, due to changes in player movement handling, the last field
1175     is not blocked at all when blocking is disabled. When blocking is enabled,
1176     the last field is blocked for exactly the number of frames of one player
1177     move. Additionally, if the player is Murphy, the hero of Supaplex, the
1178     last field is blocked for exactly one more than the number of frames of
1179     one player move.
1180
1181     Affected levels/tapes:
1182     (!!! yet to be determined -- probably many !!!)
1183   */
1184
1185   game.use_block_last_field_bug =
1186     (game.engine_version < VERSION_IDENT(3,1,1,0));
1187
1188   /* ---------------------------------------------------------------------- */
1189
1190   /* dynamically adjust element properties according to game engine version */
1191   InitElementPropertiesEngine(game.engine_version);
1192
1193 #if 0
1194   printf("level %d: level version == %06d\n", level_nr, level.game_version);
1195   printf("          tape version == %06d [%s] [file: %06d]\n",
1196          tape.engine_version, (tape.playing ? "PLAYING" : "RECORDING"),
1197          tape.file_version);
1198   printf("       => game.engine_version == %06d\n", game.engine_version);
1199 #endif
1200
1201   /* ---------- recursively resolve group elements ------------------------- */
1202
1203   for (i = 0; i < MAX_NUM_ELEMENTS; i++)
1204     for (j = 0; j < NUM_GROUP_ELEMENTS; j++)
1205       element_info[i].in_group[j] = FALSE;
1206
1207   for (i = 0; i < NUM_GROUP_ELEMENTS; i++)
1208     resolve_group_element(EL_GROUP_START + i, 0);
1209
1210   /* ---------- initialize player's initial move delay --------------------- */
1211
1212   /* dynamically adjust player properties according to level information */
1213   game.initial_move_delay_value =
1214     (level.double_speed ? MOVE_DELAY_HIGH_SPEED : MOVE_DELAY_NORMAL_SPEED);
1215
1216   /* dynamically adjust player properties according to game engine version */
1217   game.initial_move_delay = (game.engine_version <= VERSION_IDENT(2,0,1,0) ?
1218                              game.initial_move_delay_value : 0);
1219
1220   /* ---------- initialize player's initial push delay --------------------- */
1221
1222   /* dynamically adjust player properties according to game engine version */
1223   game.initial_push_delay_value =
1224     (game.engine_version < VERSION_IDENT(3,0,7,1) ? 5 : -1);
1225
1226   /* ---------- initialize changing elements ------------------------------- */
1227
1228   /* initialize changing elements information */
1229   for (i = 0; i < MAX_NUM_ELEMENTS; i++)
1230   {
1231     struct ElementInfo *ei = &element_info[i];
1232
1233     /* this pointer might have been changed in the level editor */
1234     ei->change = &ei->change_page[0];
1235
1236     if (!IS_CUSTOM_ELEMENT(i))
1237     {
1238       ei->change->target_element = EL_EMPTY_SPACE;
1239       ei->change->delay_fixed = 0;
1240       ei->change->delay_random = 0;
1241       ei->change->delay_frames = 1;
1242     }
1243
1244     for (j = 0; j < NUM_CHANGE_EVENTS; j++)
1245     {
1246       ei->has_change_event[j] = FALSE;
1247
1248       ei->event_page_nr[j] = 0;
1249       ei->event_page[j] = &ei->change_page[0];
1250     }
1251   }
1252
1253   /* add changing elements from pre-defined list */
1254   for (i = 0; change_delay_list[i].element != EL_UNDEFINED; i++)
1255   {
1256     struct ChangingElementInfo *ch_delay = &change_delay_list[i];
1257     struct ElementInfo *ei = &element_info[ch_delay->element];
1258
1259     ei->change->target_element       = ch_delay->target_element;
1260     ei->change->delay_fixed          = ch_delay->change_delay;
1261
1262     ei->change->pre_change_function  = ch_delay->pre_change_function;
1263     ei->change->change_function      = ch_delay->change_function;
1264     ei->change->post_change_function = ch_delay->post_change_function;
1265
1266     ei->change->can_change = TRUE;
1267     ei->change->can_change_or_has_action = TRUE;
1268
1269     ei->has_change_event[CE_DELAY] = TRUE;
1270
1271     SET_PROPERTY(ch_delay->element, EP_CAN_CHANGE, TRUE);
1272     SET_PROPERTY(ch_delay->element, EP_CAN_CHANGE_OR_HAS_ACTION, TRUE);
1273   }
1274
1275   /* ---------- initialize internal run-time variables ------------- */
1276
1277   for (i = 0; i < NUM_CUSTOM_ELEMENTS; i++)
1278   {
1279     struct ElementInfo *ei = &element_info[EL_CUSTOM_START + i];
1280
1281     for (j = 0; j < ei->num_change_pages; j++)
1282     {
1283       ei->change_page[j].can_change_or_has_action =
1284         (ei->change_page[j].can_change |
1285          ei->change_page[j].has_action);
1286     }
1287   }
1288
1289   /* add change events from custom element configuration */
1290   for (i = 0; i < NUM_CUSTOM_ELEMENTS; i++)
1291   {
1292     struct ElementInfo *ei = &element_info[EL_CUSTOM_START + i];
1293
1294     for (j = 0; j < ei->num_change_pages; j++)
1295     {
1296       if (!ei->change_page[j].can_change_or_has_action)
1297         continue;
1298
1299       for (k = 0; k < NUM_CHANGE_EVENTS; k++)
1300       {
1301         /* only add event page for the first page found with this event */
1302         if (ei->change_page[j].has_event[k] && !(ei->has_change_event[k]))
1303         {
1304           ei->has_change_event[k] = TRUE;
1305
1306           ei->event_page_nr[k] = j;
1307           ei->event_page[k] = &ei->change_page[j];
1308         }
1309       }
1310     }
1311   }
1312
1313   /* ---------- initialize run-time trigger player and element ------------- */
1314
1315   for (i = 0; i < NUM_CUSTOM_ELEMENTS; i++)
1316   {
1317     struct ElementInfo *ei = &element_info[EL_CUSTOM_START + i];
1318
1319     for (j = 0; j < ei->num_change_pages; j++)
1320     {
1321       ei->change_page[j].actual_trigger_element = EL_EMPTY;
1322       ei->change_page[j].actual_trigger_player = EL_PLAYER_1;
1323     }
1324   }
1325
1326   /* ---------- initialize trigger events ---------------------------------- */
1327
1328   /* initialize trigger events information */
1329   for (i = 0; i < MAX_NUM_ELEMENTS; i++)
1330     for (j = 0; j < NUM_CHANGE_EVENTS; j++)
1331       trigger_events[i][j] = FALSE;
1332
1333   /* add trigger events from element change event properties */
1334   for (i = 0; i < MAX_NUM_ELEMENTS; i++)
1335   {
1336     struct ElementInfo *ei = &element_info[i];
1337
1338     for (j = 0; j < ei->num_change_pages; j++)
1339     {
1340       if (!ei->change_page[j].can_change_or_has_action)
1341         continue;
1342
1343       if (ei->change_page[j].has_event[CE_BY_OTHER_ACTION])
1344       {
1345         int trigger_element = ei->change_page[j].trigger_element;
1346
1347         for (k = 0; k < NUM_CHANGE_EVENTS; k++)
1348         {
1349           if (ei->change_page[j].has_event[k])
1350           {
1351             if (IS_GROUP_ELEMENT(trigger_element))
1352             {
1353               struct ElementGroupInfo *group =
1354                 element_info[trigger_element].group;
1355
1356               for (l = 0; l < group->num_elements_resolved; l++)
1357                 trigger_events[group->element_resolved[l]][k] = TRUE;
1358             }
1359             else
1360               trigger_events[trigger_element][k] = TRUE;
1361           }
1362         }
1363       }
1364     }
1365   }
1366
1367   /* ---------- initialize push delay -------------------------------------- */
1368
1369   /* initialize push delay values to default */
1370   for (i = 0; i < MAX_NUM_ELEMENTS; i++)
1371   {
1372     if (!IS_CUSTOM_ELEMENT(i))
1373     {
1374       element_info[i].push_delay_fixed  = game.default_push_delay_fixed;
1375       element_info[i].push_delay_random = game.default_push_delay_random;
1376     }
1377   }
1378
1379   /* set push delay value for certain elements from pre-defined list */
1380   for (i = 0; push_delay_list[i].element != EL_UNDEFINED; i++)
1381   {
1382     int e = push_delay_list[i].element;
1383
1384     element_info[e].push_delay_fixed  = push_delay_list[i].push_delay_fixed;
1385     element_info[e].push_delay_random = push_delay_list[i].push_delay_random;
1386   }
1387
1388   /* set push delay value for Supaplex elements for newer engine versions */
1389   if (game.engine_version >= VERSION_IDENT(3,1,0,0))
1390   {
1391     for (i = 0; i < MAX_NUM_ELEMENTS; i++)
1392     {
1393       if (IS_SP_ELEMENT(i))
1394       {
1395         /* set SP push delay to just enough to push under a falling zonk */
1396         int delay = (game.engine_version >= VERSION_IDENT(3,1,1,0) ? 8 : 6);
1397
1398         element_info[i].push_delay_fixed  = delay;
1399         element_info[i].push_delay_random = 0;
1400       }
1401     }
1402   }
1403
1404   /* ---------- initialize move stepsize ----------------------------------- */
1405
1406   /* initialize move stepsize values to default */
1407   for (i = 0; i < MAX_NUM_ELEMENTS; i++)
1408     if (!IS_CUSTOM_ELEMENT(i))
1409       element_info[i].move_stepsize = MOVE_STEPSIZE_NORMAL;
1410
1411   /* set move stepsize value for certain elements from pre-defined list */
1412   for (i = 0; move_stepsize_list[i].element != EL_UNDEFINED; i++)
1413   {
1414     int e = move_stepsize_list[i].element;
1415
1416     element_info[e].move_stepsize = move_stepsize_list[i].move_stepsize;
1417   }
1418
1419   /* ---------- initialize collect score ----------------------------------- */
1420
1421   /* initialize collect score values for custom elements from initial value */
1422   for (i = 0; i < MAX_NUM_ELEMENTS; i++)
1423     if (IS_CUSTOM_ELEMENT(i))
1424       element_info[i].collect_score = element_info[i].collect_score_initial;
1425
1426   /* ---------- initialize collect count ----------------------------------- */
1427
1428   /* initialize collect count values for non-custom elements */
1429   for (i = 0; i < MAX_NUM_ELEMENTS; i++)
1430     if (!IS_CUSTOM_ELEMENT(i))
1431       element_info[i].collect_count_initial = 0;
1432
1433   /* add collect count values for all elements from pre-defined list */
1434   for (i = 0; collect_count_list[i].element != EL_UNDEFINED; i++)
1435     element_info[collect_count_list[i].element].collect_count_initial =
1436       collect_count_list[i].count;
1437
1438   /* ---------- initialize access direction -------------------------------- */
1439
1440   /* initialize access direction values to default (access from every side) */
1441   for (i = 0; i < MAX_NUM_ELEMENTS; i++)
1442     if (!IS_CUSTOM_ELEMENT(i))
1443       element_info[i].access_direction = MV_ALL_DIRECTIONS;
1444
1445   /* set access direction value for certain elements from pre-defined list */
1446   for (i = 0; access_direction_list[i].element != EL_UNDEFINED; i++)
1447     element_info[access_direction_list[i].element].access_direction =
1448       access_direction_list[i].direction;
1449 }
1450
1451
1452 /*
1453   =============================================================================
1454   InitGame()
1455   -----------------------------------------------------------------------------
1456   initialize and start new game
1457   =============================================================================
1458 */
1459
1460 void InitGame()
1461 {
1462   boolean emulate_bd = TRUE;    /* unless non-BOULDERDASH elements found */
1463   boolean emulate_sb = TRUE;    /* unless non-SOKOBAN     elements found */
1464   boolean emulate_sp = TRUE;    /* unless non-SUPAPLEX    elements found */
1465   int i, j, k, x, y;
1466
1467   InitGameEngine();
1468
1469   /* don't play tapes over network */
1470   network_playing = (options.network && !tape.playing);
1471
1472   for (i = 0; i < MAX_PLAYERS; i++)
1473   {
1474     struct PlayerInfo *player = &stored_player[i];
1475
1476     player->index_nr = i;
1477     player->index_bit = (1 << i);
1478     player->element_nr = EL_PLAYER_1 + i;
1479
1480     player->present = FALSE;
1481     player->active = FALSE;
1482
1483     player->action = 0;
1484     player->effective_action = 0;
1485     player->programmed_action = 0;
1486
1487     player->score = 0;
1488     player->gems_still_needed = level.gems_needed;
1489     player->sokobanfields_still_needed = 0;
1490     player->lights_still_needed = 0;
1491     player->friends_still_needed = 0;
1492
1493     for (j = 0; j < MAX_NUM_KEYS; j++)
1494       player->key[j] = FALSE;
1495
1496     player->dynabomb_count = 0;
1497     player->dynabomb_size = 1;
1498     player->dynabombs_left = 0;
1499     player->dynabomb_xl = FALSE;
1500
1501     player->MovDir = MV_NO_MOVING;
1502     player->MovPos = 0;
1503     player->GfxPos = 0;
1504     player->GfxDir = MV_NO_MOVING;
1505     player->GfxAction = ACTION_DEFAULT;
1506     player->Frame = 0;
1507     player->StepFrame = 0;
1508
1509     player->use_murphy_graphic = FALSE;
1510
1511     player->block_last_field = FALSE;   /* initialized in InitPlayerField() */
1512     player->block_delay_adjustment = 0; /* initialized in InitPlayerField() */
1513
1514     player->can_fall_into_acid = CAN_MOVE_INTO_ACID(player->element_nr);
1515
1516     player->actual_frame_counter = 0;
1517
1518     player->step_counter = 0;
1519
1520     player->last_move_dir = MV_NO_MOVING;
1521
1522     player->is_waiting = FALSE;
1523     player->is_moving = FALSE;
1524     player->is_auto_moving = FALSE;
1525     player->is_digging = FALSE;
1526     player->is_snapping = FALSE;
1527     player->is_collecting = FALSE;
1528     player->is_pushing = FALSE;
1529     player->is_switching = FALSE;
1530     player->is_dropping = FALSE;
1531
1532     player->is_bored = FALSE;
1533     player->is_sleeping = FALSE;
1534
1535     player->frame_counter_bored = -1;
1536     player->frame_counter_sleeping = -1;
1537
1538     player->anim_delay_counter = 0;
1539     player->post_delay_counter = 0;
1540
1541     player->action_waiting = ACTION_DEFAULT;
1542     player->last_action_waiting = ACTION_DEFAULT;
1543     player->special_action_bored = ACTION_DEFAULT;
1544     player->special_action_sleeping = ACTION_DEFAULT;
1545
1546     player->num_special_action_bored = 0;
1547     player->num_special_action_sleeping = 0;
1548
1549     /* determine number of special actions for bored and sleeping animation */
1550     for (j = ACTION_BORING_1; j <= ACTION_BORING_LAST; j++)
1551     {
1552       boolean found = FALSE;
1553
1554       for (k = 0; k < NUM_DIRECTIONS; k++)
1555         if (el_act_dir2img(player->element_nr, j, k) !=
1556             el_act_dir2img(player->element_nr, ACTION_DEFAULT, k))
1557           found = TRUE;
1558
1559       if (found)
1560         player->num_special_action_bored++;
1561       else
1562         break;
1563     }
1564     for (j = ACTION_SLEEPING_1; j <= ACTION_SLEEPING_LAST; j++)
1565     {
1566       boolean found = FALSE;
1567
1568       for (k = 0; k < NUM_DIRECTIONS; k++)
1569         if (el_act_dir2img(player->element_nr, j, k) !=
1570             el_act_dir2img(player->element_nr, ACTION_DEFAULT, k))
1571           found = TRUE;
1572
1573       if (found)
1574         player->num_special_action_sleeping++;
1575       else
1576         break;
1577     }
1578
1579     player->switch_x = -1;
1580     player->switch_y = -1;
1581
1582     player->drop_x = -1;
1583     player->drop_y = -1;
1584
1585     player->show_envelope = 0;
1586
1587     player->move_delay       = game.initial_move_delay;
1588     player->move_delay_value = game.initial_move_delay_value;
1589
1590     player->move_delay_value_next = -1;
1591
1592     player->move_delay_reset_counter = 0;
1593
1594     player->push_delay       = -1;      /* initialized when pushing starts */
1595     player->push_delay_value = game.initial_push_delay_value;
1596
1597     player->drop_delay = 0;
1598
1599     player->last_jx = player->last_jy = 0;
1600     player->jx = player->jy = 0;
1601
1602     player->shield_normal_time_left = 0;
1603     player->shield_deadly_time_left = 0;
1604
1605     player->inventory_infinite_element = EL_UNDEFINED;
1606     player->inventory_size = 0;
1607
1608     DigField(player, 0, 0, 0, 0, 0, 0, DF_NO_PUSH);
1609     SnapField(player, 0, 0);
1610
1611     player->LevelSolved = FALSE;
1612     player->GameOver = FALSE;
1613   }
1614
1615   network_player_action_received = FALSE;
1616
1617 #if defined(NETWORK_AVALIABLE)
1618   /* initial null action */
1619   if (network_playing)
1620     SendToServer_MovePlayer(MV_NO_MOVING);
1621 #endif
1622
1623   ZX = ZY = -1;
1624   ExitX = ExitY = -1;
1625
1626   FrameCounter = 0;
1627   TimeFrames = 0;
1628   TimePlayed = 0;
1629   TimeLeft = level.time;
1630   TapeTime = 0;
1631
1632   ScreenMovDir = MV_NO_MOVING;
1633   ScreenMovPos = 0;
1634   ScreenGfxPos = 0;
1635
1636   ScrollStepSize = 0;   /* will be correctly initialized by ScrollScreen() */
1637
1638   AllPlayersGone = FALSE;
1639
1640   game.yamyam_content_nr = 0;
1641   game.magic_wall_active = FALSE;
1642   game.magic_wall_time_left = 0;
1643   game.light_time_left = 0;
1644   game.timegate_time_left = 0;
1645   game.switchgate_pos = 0;
1646   game.balloon_dir = MV_NO_MOVING;
1647   game.gravity = level.initial_gravity;
1648   game.explosions_delayed = TRUE;
1649
1650   game.envelope_active = FALSE;
1651
1652   for (i = 0; i < NUM_BELTS; i++)
1653   {
1654     game.belt_dir[i] = MV_NO_MOVING;
1655     game.belt_dir_nr[i] = 3;            /* not moving, next moving left */
1656   }
1657
1658   for (i = 0; i < MAX_NUM_AMOEBA; i++)
1659     AmoebaCnt[i] = AmoebaCnt2[i] = 0;
1660
1661   for (x = 0; x < lev_fieldx; x++)
1662   {
1663     for (y = 0; y < lev_fieldy; y++)
1664     {
1665       Feld[x][y] = level.field[x][y];
1666       MovPos[x][y] = MovDir[x][y] = MovDelay[x][y] = 0;
1667       ChangeDelay[x][y] = 0;
1668       ChangePage[x][y] = -1;
1669 #if USE_NEW_COLLECT_COUNT
1670       Count[x][y] = 0;          /* initialized in InitField() */
1671 #endif
1672       Store[x][y] = Store2[x][y] = StorePlayer[x][y] = Back[x][y] = 0;
1673       AmoebaNr[x][y] = 0;
1674       WasJustMoving[x][y] = 0;
1675       WasJustFalling[x][y] = 0;
1676       CheckCollision[x][y] = 0;
1677       Stop[x][y] = FALSE;
1678       Pushed[x][y] = FALSE;
1679
1680       Changed[x][y] = FALSE;
1681       ChangeEvent[x][y] = -1;
1682
1683       ExplodePhase[x][y] = 0;
1684       ExplodeDelay[x][y] = 0;
1685       ExplodeField[x][y] = EX_TYPE_NONE;
1686
1687       RunnerVisit[x][y] = 0;
1688       PlayerVisit[x][y] = 0;
1689
1690       GfxFrame[x][y] = 0;
1691       GfxRandom[x][y] = INIT_GFX_RANDOM();
1692       GfxElement[x][y] = EL_UNDEFINED;
1693       GfxAction[x][y] = ACTION_DEFAULT;
1694       GfxDir[x][y] = MV_NO_MOVING;
1695     }
1696   }
1697
1698   for (y = 0; y < lev_fieldy; y++)
1699   {
1700     for (x = 0; x < lev_fieldx; x++)
1701     {
1702       if (emulate_bd && !IS_BD_ELEMENT(Feld[x][y]))
1703         emulate_bd = FALSE;
1704       if (emulate_sb && !IS_SB_ELEMENT(Feld[x][y]))
1705         emulate_sb = FALSE;
1706       if (emulate_sp && !IS_SP_ELEMENT(Feld[x][y]))
1707         emulate_sp = FALSE;
1708
1709       InitField(x, y, TRUE);
1710     }
1711   }
1712
1713   InitBeltMovement();
1714
1715   game.emulation = (emulate_bd ? EMU_BOULDERDASH :
1716                     emulate_sb ? EMU_SOKOBAN :
1717                     emulate_sp ? EMU_SUPAPLEX : EMU_NONE);
1718
1719 #if USE_NEW_ALL_SLIPPERY
1720   /* initialize type of slippery elements */
1721   for (i = 0; i < MAX_NUM_ELEMENTS; i++)
1722   {
1723     if (!IS_CUSTOM_ELEMENT(i))
1724     {
1725       /* default: elements slip down either to the left or right randomly */
1726       element_info[i].slippery_type = SLIPPERY_ANY_RANDOM;
1727
1728       /* SP style elements prefer to slip down on the left side */
1729       if (game.engine_version >= VERSION_IDENT(3,1,1,0) && IS_SP_ELEMENT(i))
1730         element_info[i].slippery_type = SLIPPERY_ANY_LEFT_RIGHT;
1731
1732       /* BD style elements prefer to slip down on the left side */
1733       if (game.emulation == EMU_BOULDERDASH)
1734         element_info[i].slippery_type = SLIPPERY_ANY_LEFT_RIGHT;
1735     }
1736   }
1737 #endif
1738
1739   /* initialize explosion and ignition delay */
1740   for (i = 0; i < MAX_NUM_ELEMENTS; i++)
1741   {
1742     if (!IS_CUSTOM_ELEMENT(i))
1743     {
1744       int num_phase = 8;
1745       int delay = (((IS_SP_ELEMENT(i) && i != EL_EMPTY_SPACE) &&
1746                     game.engine_version >= VERSION_IDENT(3,1,0,0)) ||
1747                    game.emulation == EMU_SUPAPLEX ? 3 : 2);
1748       int last_phase = (num_phase + 1) * delay;
1749       int half_phase = (num_phase / 2) * delay;
1750
1751       element_info[i].explosion_delay = last_phase - 1;
1752       element_info[i].ignition_delay = half_phase;
1753
1754       if (i == EL_BLACK_ORB)
1755         element_info[i].ignition_delay = 1;
1756     }
1757
1758 #if 0
1759     if (element_info[i].explosion_delay < 1)    /* !!! check again !!! */
1760       element_info[i].explosion_delay = 1;
1761
1762     if (element_info[i].ignition_delay < 1)     /* !!! check again !!! */
1763       element_info[i].ignition_delay = 1;
1764 #endif
1765   }
1766
1767   /* correct non-moving belts to start moving left */
1768   for (i = 0; i < NUM_BELTS; i++)
1769     if (game.belt_dir[i] == MV_NO_MOVING)
1770       game.belt_dir_nr[i] = 3;          /* not moving, next moving left */
1771
1772   /* check if any connected player was not found in playfield */
1773   for (i = 0; i < MAX_PLAYERS; i++)
1774   {
1775     struct PlayerInfo *player = &stored_player[i];
1776
1777     if (player->connected && !player->present)
1778     {
1779       for (j = 0; j < MAX_PLAYERS; j++)
1780       {
1781         struct PlayerInfo *some_player = &stored_player[j];
1782         int jx = some_player->jx, jy = some_player->jy;
1783
1784         /* assign first free player found that is present in the playfield */
1785         if (some_player->present && !some_player->connected)
1786         {
1787           player->present = TRUE;
1788           player->active = TRUE;
1789
1790           some_player->present = FALSE;
1791           some_player->active = FALSE;
1792
1793 #if 0
1794           player->element_nr = some_player->element_nr;
1795 #endif
1796
1797           player->block_last_field       = some_player->block_last_field;
1798           player->block_delay_adjustment = some_player->block_delay_adjustment;
1799
1800           StorePlayer[jx][jy] = player->element_nr;
1801           player->jx = player->last_jx = jx;
1802           player->jy = player->last_jy = jy;
1803
1804           break;
1805         }
1806       }
1807     }
1808   }
1809
1810   if (tape.playing)
1811   {
1812     /* when playing a tape, eliminate all players which do not participate */
1813
1814     for (i = 0; i < MAX_PLAYERS; i++)
1815     {
1816       if (stored_player[i].active && !tape.player_participates[i])
1817       {
1818         struct PlayerInfo *player = &stored_player[i];
1819         int jx = player->jx, jy = player->jy;
1820
1821         player->active = FALSE;
1822         StorePlayer[jx][jy] = 0;
1823         Feld[jx][jy] = EL_EMPTY;
1824       }
1825     }
1826   }
1827   else if (!options.network && !setup.team_mode)        /* && !tape.playing */
1828   {
1829     /* when in single player mode, eliminate all but the first active player */
1830
1831     for (i = 0; i < MAX_PLAYERS; i++)
1832     {
1833       if (stored_player[i].active)
1834       {
1835         for (j = i + 1; j < MAX_PLAYERS; j++)
1836         {
1837           if (stored_player[j].active)
1838           {
1839             struct PlayerInfo *player = &stored_player[j];
1840             int jx = player->jx, jy = player->jy;
1841
1842             player->active = FALSE;
1843             player->present = FALSE;
1844
1845             StorePlayer[jx][jy] = 0;
1846             Feld[jx][jy] = EL_EMPTY;
1847           }
1848         }
1849       }
1850     }
1851   }
1852
1853   /* when recording the game, store which players take part in the game */
1854   if (tape.recording)
1855   {
1856     for (i = 0; i < MAX_PLAYERS; i++)
1857       if (stored_player[i].active)
1858         tape.player_participates[i] = TRUE;
1859   }
1860
1861   if (options.debug)
1862   {
1863     for (i = 0; i < MAX_PLAYERS; i++)
1864     {
1865       struct PlayerInfo *player = &stored_player[i];
1866
1867       printf("Player %d: present == %d, connected == %d, active == %d.\n",
1868              i+1,
1869              player->present,
1870              player->connected,
1871              player->active);
1872       if (local_player == player)
1873         printf("Player  %d is local player.\n", i+1);
1874     }
1875   }
1876
1877   if (BorderElement == EL_EMPTY)
1878   {
1879     SBX_Left = 0;
1880     SBX_Right = lev_fieldx - SCR_FIELDX;
1881     SBY_Upper = 0;
1882     SBY_Lower = lev_fieldy - SCR_FIELDY;
1883   }
1884   else
1885   {
1886     SBX_Left = -1;
1887     SBX_Right = lev_fieldx - SCR_FIELDX + 1;
1888     SBY_Upper = -1;
1889     SBY_Lower = lev_fieldy - SCR_FIELDY + 1;
1890   }
1891
1892   if (lev_fieldx + (SBX_Left == -1 ? 2 : 0) <= SCR_FIELDX)
1893     SBX_Left = SBX_Right = -1 * (SCR_FIELDX - lev_fieldx) / 2;
1894
1895   if (lev_fieldy + (SBY_Upper == -1 ? 2 : 0) <= SCR_FIELDY)
1896     SBY_Upper = SBY_Lower = -1 * (SCR_FIELDY - lev_fieldy) / 2;
1897
1898   /* if local player not found, look for custom element that might create
1899      the player (make some assumptions about the right custom element) */
1900   if (!local_player->present)
1901   {
1902     int start_x = 0, start_y = 0;
1903     int found_rating = 0;
1904     int found_element = EL_UNDEFINED;
1905
1906     for (y = 0; y < lev_fieldy; y++) for (x = 0; x < lev_fieldx; x++)
1907     {
1908       int element = Feld[x][y];
1909       int content;
1910       int xx, yy;
1911       boolean is_player;
1912
1913       if (!IS_CUSTOM_ELEMENT(element))
1914         continue;
1915
1916       if (CAN_CHANGE(element))
1917       {
1918         for (i = 0; i < element_info[element].num_change_pages; i++)
1919         {
1920           content = element_info[element].change_page[i].target_element;
1921           is_player = ELEM_IS_PLAYER(content);
1922
1923           if (is_player && (found_rating < 3 || element < found_element))
1924           {
1925             start_x = x;
1926             start_y = y;
1927
1928             found_rating = 3;
1929             found_element = element;
1930           }
1931         }
1932       }
1933
1934       for (yy = 0; yy < 3; yy++) for (xx = 0; xx < 3; xx++)
1935       {
1936         content = element_info[element].content.e[xx][yy];
1937         is_player = ELEM_IS_PLAYER(content);
1938
1939         if (is_player && (found_rating < 2 || element < found_element))
1940         {
1941           start_x = x + xx - 1;
1942           start_y = y + yy - 1;
1943
1944           found_rating = 2;
1945           found_element = element;
1946         }
1947
1948         if (!CAN_CHANGE(element))
1949           continue;
1950
1951         for (i = 0; i < element_info[element].num_change_pages; i++)
1952         {
1953           content =
1954             element_info[element].change_page[i].target_content.e[xx][yy];
1955
1956           is_player = ELEM_IS_PLAYER(content);
1957
1958           if (is_player && (found_rating < 1 || element < found_element))
1959           {
1960             start_x = x + xx - 1;
1961             start_y = y + yy - 1;
1962
1963             found_rating = 1;
1964             found_element = element;
1965           }
1966         }
1967       }
1968     }
1969
1970     scroll_x = (start_x < SBX_Left  + MIDPOSX ? SBX_Left :
1971                 start_x > SBX_Right + MIDPOSX ? SBX_Right :
1972                 start_x - MIDPOSX);
1973
1974     scroll_y = (start_y < SBY_Upper + MIDPOSY ? SBY_Upper :
1975                 start_y > SBY_Lower + MIDPOSY ? SBY_Lower :
1976                 start_y - MIDPOSY);
1977   }
1978   else
1979   {
1980     scroll_x = (local_player->jx < SBX_Left  + MIDPOSX ? SBX_Left :
1981                 local_player->jx > SBX_Right + MIDPOSX ? SBX_Right :
1982                 local_player->jx - MIDPOSX);
1983
1984     scroll_y = (local_player->jy < SBY_Upper + MIDPOSY ? SBY_Upper :
1985                 local_player->jy > SBY_Lower + MIDPOSY ? SBY_Lower :
1986                 local_player->jy - MIDPOSY);
1987   }
1988
1989   if (!game.restart_level)
1990     CloseDoor(DOOR_CLOSE_1);
1991
1992   /* !!! FIX THIS (START) !!! */
1993   if (level.game_engine_type == GAME_ENGINE_TYPE_EM)
1994   {
1995     InitGameEngine_EM();
1996   }
1997   else
1998   {
1999     DrawLevel();
2000     DrawAllPlayers();
2001
2002     /* after drawing the level, correct some elements */
2003     if (game.timegate_time_left == 0)
2004       CloseAllOpenTimegates();
2005
2006     if (setup.soft_scrolling)
2007       BlitBitmap(fieldbuffer, backbuffer, FX, FY, SXSIZE, SYSIZE, SX, SY);
2008
2009     redraw_mask |= REDRAW_FROM_BACKBUFFER;
2010     FadeToFront();
2011   }
2012   /* !!! FIX THIS (END) !!! */
2013
2014   if (!game.restart_level)
2015   {
2016     /* copy default game door content to main double buffer */
2017     BlitBitmap(graphic_info[IMG_GLOBAL_DOOR].bitmap, drawto,
2018                DOOR_GFX_PAGEX5, DOOR_GFX_PAGEY1, DXSIZE, DYSIZE, DX, DY);
2019   }
2020
2021   DrawGameDoorValues();
2022
2023   if (!game.restart_level)
2024   {
2025     UnmapGameButtons();
2026     UnmapTapeButtons();
2027     game_gadget[SOUND_CTRL_ID_MUSIC]->checked = setup.sound_music;
2028     game_gadget[SOUND_CTRL_ID_LOOPS]->checked = setup.sound_loops;
2029     game_gadget[SOUND_CTRL_ID_SIMPLE]->checked = setup.sound_simple;
2030     MapGameButtons();
2031     MapTapeButtons();
2032
2033     /* copy actual game door content to door double buffer for OpenDoor() */
2034     BlitBitmap(drawto, bitmap_db_door,
2035                DX, DY, DXSIZE, DYSIZE, DOOR_GFX_PAGEX1, DOOR_GFX_PAGEY1);
2036
2037     OpenDoor(DOOR_OPEN_ALL);
2038
2039     PlaySoundStereo(SND_GAME_STARTING, SOUND_MIDDLE);
2040
2041     if (setup.sound_music)
2042       PlayLevelMusic();
2043
2044     KeyboardAutoRepeatOffUnlessAutoplay();
2045
2046     if (options.debug)
2047     {
2048       for (i = 0; i < MAX_PLAYERS; i++)
2049         printf("Player %d %sactive.\n",
2050                i + 1, (stored_player[i].active ? "" : "not "));
2051     }
2052   }
2053
2054   game.restart_level = FALSE;
2055 }
2056
2057 void UpdateEngineValues(int actual_scroll_x, int actual_scroll_y)
2058 {
2059   /* this is used for non-R'n'D game engines to update certain engine values */
2060
2061   /* needed to determine if sounds are played within the visible screen area */
2062   scroll_x = actual_scroll_x;
2063   scroll_y = actual_scroll_y;
2064 }
2065
2066 void InitMovDir(int x, int y)
2067 {
2068   int i, element = Feld[x][y];
2069   static int xy[4][2] =
2070   {
2071     {  0, +1 },
2072     { +1,  0 },
2073     {  0, -1 },
2074     { -1,  0 }
2075   };
2076   static int direction[3][4] =
2077   {
2078     { MV_RIGHT, MV_UP,   MV_LEFT,  MV_DOWN },
2079     { MV_LEFT,  MV_DOWN, MV_RIGHT, MV_UP },
2080     { MV_LEFT,  MV_RIGHT, MV_UP, MV_DOWN }
2081   };
2082
2083   switch(element)
2084   {
2085     case EL_BUG_RIGHT:
2086     case EL_BUG_UP:
2087     case EL_BUG_LEFT:
2088     case EL_BUG_DOWN:
2089       Feld[x][y] = EL_BUG;
2090       MovDir[x][y] = direction[0][element - EL_BUG_RIGHT];
2091       break;
2092
2093     case EL_SPACESHIP_RIGHT:
2094     case EL_SPACESHIP_UP:
2095     case EL_SPACESHIP_LEFT:
2096     case EL_SPACESHIP_DOWN:
2097       Feld[x][y] = EL_SPACESHIP;
2098       MovDir[x][y] = direction[0][element - EL_SPACESHIP_RIGHT];
2099       break;
2100
2101     case EL_BD_BUTTERFLY_RIGHT:
2102     case EL_BD_BUTTERFLY_UP:
2103     case EL_BD_BUTTERFLY_LEFT:
2104     case EL_BD_BUTTERFLY_DOWN:
2105       Feld[x][y] = EL_BD_BUTTERFLY;
2106       MovDir[x][y] = direction[0][element - EL_BD_BUTTERFLY_RIGHT];
2107       break;
2108
2109     case EL_BD_FIREFLY_RIGHT:
2110     case EL_BD_FIREFLY_UP:
2111     case EL_BD_FIREFLY_LEFT:
2112     case EL_BD_FIREFLY_DOWN:
2113       Feld[x][y] = EL_BD_FIREFLY;
2114       MovDir[x][y] = direction[0][element - EL_BD_FIREFLY_RIGHT];
2115       break;
2116
2117     case EL_PACMAN_RIGHT:
2118     case EL_PACMAN_UP:
2119     case EL_PACMAN_LEFT:
2120     case EL_PACMAN_DOWN:
2121       Feld[x][y] = EL_PACMAN;
2122       MovDir[x][y] = direction[0][element - EL_PACMAN_RIGHT];
2123       break;
2124
2125     case EL_SP_SNIKSNAK:
2126       MovDir[x][y] = MV_UP;
2127       break;
2128
2129     case EL_SP_ELECTRON:
2130       MovDir[x][y] = MV_LEFT;
2131       break;
2132
2133     case EL_MOLE_LEFT:
2134     case EL_MOLE_RIGHT:
2135     case EL_MOLE_UP:
2136     case EL_MOLE_DOWN:
2137       Feld[x][y] = EL_MOLE;
2138       MovDir[x][y] = direction[2][element - EL_MOLE_LEFT];
2139       break;
2140
2141     default:
2142       if (IS_CUSTOM_ELEMENT(element))
2143       {
2144         struct ElementInfo *ei = &element_info[element];
2145         int move_direction_initial = ei->move_direction_initial;
2146         int move_pattern = ei->move_pattern;
2147
2148         if (move_direction_initial == MV_START_PREVIOUS)
2149         {
2150           if (MovDir[x][y] != MV_NO_MOVING)
2151             return;
2152
2153           move_direction_initial = MV_START_AUTOMATIC;
2154         }
2155
2156         if (move_direction_initial == MV_START_RANDOM)
2157           MovDir[x][y] = 1 << RND(4);
2158         else if (move_direction_initial & MV_ANY_DIRECTION)
2159           MovDir[x][y] = move_direction_initial;
2160         else if (move_pattern == MV_ALL_DIRECTIONS ||
2161                  move_pattern == MV_TURNING_LEFT ||
2162                  move_pattern == MV_TURNING_RIGHT ||
2163                  move_pattern == MV_TURNING_LEFT_RIGHT ||
2164                  move_pattern == MV_TURNING_RIGHT_LEFT ||
2165                  move_pattern == MV_TURNING_RANDOM)
2166           MovDir[x][y] = 1 << RND(4);
2167         else if (move_pattern == MV_HORIZONTAL)
2168           MovDir[x][y] = (RND(2) ? MV_LEFT : MV_RIGHT);
2169         else if (move_pattern == MV_VERTICAL)
2170           MovDir[x][y] = (RND(2) ? MV_UP : MV_DOWN);
2171         else if (move_pattern & MV_ANY_DIRECTION)
2172           MovDir[x][y] = element_info[element].move_pattern;
2173         else if (move_pattern == MV_ALONG_LEFT_SIDE ||
2174                  move_pattern == MV_ALONG_RIGHT_SIDE)
2175         {
2176           /* use random direction as default start direction */
2177           if (game.engine_version >= VERSION_IDENT(3,1,0,0))
2178             MovDir[x][y] = 1 << RND(4);
2179
2180           for (i = 0; i < NUM_DIRECTIONS; i++)
2181           {
2182             int x1 = x + xy[i][0];
2183             int y1 = y + xy[i][1];
2184
2185             if (!IN_LEV_FIELD(x1, y1) || !IS_FREE(x1, y1))
2186             {
2187               if (move_pattern == MV_ALONG_RIGHT_SIDE)
2188                 MovDir[x][y] = direction[0][i];
2189               else
2190                 MovDir[x][y] = direction[1][i];
2191
2192               break;
2193             }
2194           }
2195         }
2196       }
2197       else
2198       {
2199         MovDir[x][y] = 1 << RND(4);
2200
2201         if (element != EL_BUG &&
2202             element != EL_SPACESHIP &&
2203             element != EL_BD_BUTTERFLY &&
2204             element != EL_BD_FIREFLY)
2205           break;
2206
2207         for (i = 0; i < NUM_DIRECTIONS; i++)
2208         {
2209           int x1 = x + xy[i][0];
2210           int y1 = y + xy[i][1];
2211
2212           if (!IN_LEV_FIELD(x1, y1) || !IS_FREE(x1, y1))
2213           {
2214             if (element == EL_BUG || element == EL_BD_BUTTERFLY)
2215             {
2216               MovDir[x][y] = direction[0][i];
2217               break;
2218             }
2219             else if (element == EL_SPACESHIP || element == EL_BD_FIREFLY ||
2220                      element == EL_SP_SNIKSNAK || element == EL_SP_ELECTRON)
2221             {
2222               MovDir[x][y] = direction[1][i];
2223               break;
2224             }
2225           }
2226         }
2227       }
2228       break;
2229   }
2230
2231   GfxDir[x][y] = MovDir[x][y];
2232 }
2233
2234 void InitAmoebaNr(int x, int y)
2235 {
2236   int i;
2237   int group_nr = AmoebeNachbarNr(x, y);
2238
2239   if (group_nr == 0)
2240   {
2241     for (i = 1; i < MAX_NUM_AMOEBA; i++)
2242     {
2243       if (AmoebaCnt[i] == 0)
2244       {
2245         group_nr = i;
2246         break;
2247       }
2248     }
2249   }
2250
2251   AmoebaNr[x][y] = group_nr;
2252   AmoebaCnt[group_nr]++;
2253   AmoebaCnt2[group_nr]++;
2254 }
2255
2256 void GameWon()
2257 {
2258   int hi_pos;
2259   boolean raise_level = FALSE;
2260
2261   if (local_player->MovPos)
2262     return;
2263
2264   if (tape.auto_play)           /* tape might already be stopped here */
2265     tape.auto_play_level_solved = TRUE;
2266
2267   local_player->LevelSolved = FALSE;
2268
2269   PlaySoundStereo(SND_GAME_WINNING, SOUND_MIDDLE);
2270
2271   if (TimeLeft)
2272   {
2273     if (!tape.playing && setup.sound_loops)
2274       PlaySoundExt(SND_GAME_LEVELTIME_BONUS, SOUND_MAX_VOLUME, SOUND_MIDDLE,
2275                    SND_CTRL_PLAY_LOOP);
2276
2277     while (TimeLeft > 0)
2278     {
2279       if (!tape.playing && !setup.sound_loops)
2280         PlaySoundStereo(SND_GAME_LEVELTIME_BONUS, SOUND_MIDDLE);
2281       if (TimeLeft > 0 && !(TimeLeft % 10))
2282         RaiseScore(level.score[SC_TIME_BONUS]);
2283       if (TimeLeft > 100 && !(TimeLeft % 10))
2284         TimeLeft -= 10;
2285       else
2286         TimeLeft--;
2287
2288       DrawGameValue_Time(TimeLeft);
2289
2290       BackToFront();
2291
2292       if (!tape.playing)
2293         Delay(10);
2294     }
2295
2296     if (!tape.playing && setup.sound_loops)
2297       StopSound(SND_GAME_LEVELTIME_BONUS);
2298   }
2299   else if (level.time == 0)             /* level without time limit */
2300   {
2301     if (!tape.playing && setup.sound_loops)
2302       PlaySoundExt(SND_GAME_LEVELTIME_BONUS, SOUND_MAX_VOLUME, SOUND_MIDDLE,
2303                    SND_CTRL_PLAY_LOOP);
2304
2305     while (TimePlayed < 999)
2306     {
2307       if (!tape.playing && !setup.sound_loops)
2308         PlaySoundStereo(SND_GAME_LEVELTIME_BONUS, SOUND_MIDDLE);
2309       if (TimePlayed < 999 && !(TimePlayed % 10))
2310         RaiseScore(level.score[SC_TIME_BONUS]);
2311       if (TimePlayed < 900 && !(TimePlayed % 10))
2312         TimePlayed += 10;
2313       else
2314         TimePlayed++;
2315
2316       DrawGameValue_Time(TimePlayed);
2317
2318       BackToFront();
2319
2320       if (!tape.playing)
2321         Delay(10);
2322     }
2323
2324     if (!tape.playing && setup.sound_loops)
2325       StopSound(SND_GAME_LEVELTIME_BONUS);
2326   }
2327
2328   /* close exit door after last player */
2329   if (AllPlayersGone && ExitX >= 0 && ExitY >= 0 &&
2330       (Feld[ExitX][ExitY] == EL_EXIT_OPEN ||
2331        Feld[ExitX][ExitY] == EL_SP_EXIT_OPEN))
2332   {
2333     int element = Feld[ExitX][ExitY];
2334
2335     Feld[ExitX][ExitY] = (element == EL_EXIT_OPEN ? EL_EXIT_CLOSING :
2336                           EL_SP_EXIT_CLOSING);
2337
2338     PlayLevelSoundElementAction(ExitX, ExitY, element, ACTION_CLOSING);
2339   }
2340
2341   /* player disappears */
2342   if (ExitX >= 0 && ExitY >= 0)
2343     DrawLevelField(ExitX, ExitY);
2344
2345   BackToFront();
2346
2347   if (tape.playing)
2348     return;
2349
2350   CloseDoor(DOOR_CLOSE_1);
2351
2352   if (tape.recording)
2353   {
2354     TapeStop();
2355     SaveTape(tape.level_nr);            /* Ask to save tape */
2356   }
2357
2358   if (level_nr == leveldir_current->handicap_level)
2359   {
2360     leveldir_current->handicap_level++;
2361     SaveLevelSetup_SeriesInfo();
2362   }
2363
2364   if (level_editor_test_game)
2365     local_player->score = -1;   /* no highscore when playing from editor */
2366   else if (level_nr < leveldir_current->last_level)
2367     raise_level = TRUE;         /* advance to next level */
2368
2369   if ((hi_pos = NewHiScore()) >= 0)
2370   {
2371     game_status = GAME_MODE_SCORES;
2372     DrawHallOfFame(hi_pos);
2373     if (raise_level)
2374     {
2375       level_nr++;
2376       TapeErase();
2377     }
2378   }
2379   else
2380   {
2381     game_status = GAME_MODE_MAIN;
2382     if (raise_level)
2383     {
2384       level_nr++;
2385       TapeErase();
2386     }
2387     DrawMainMenu();
2388   }
2389
2390   BackToFront();
2391 }
2392
2393 int NewHiScore()
2394 {
2395   int k, l;
2396   int position = -1;
2397
2398   LoadScore(level_nr);
2399
2400   if (strcmp(setup.player_name, EMPTY_PLAYER_NAME) == 0 ||
2401       local_player->score < highscore[MAX_SCORE_ENTRIES - 1].Score)
2402     return -1;
2403
2404   for (k = 0; k < MAX_SCORE_ENTRIES; k++)
2405   {
2406     if (local_player->score > highscore[k].Score)
2407     {
2408       /* player has made it to the hall of fame */
2409
2410       if (k < MAX_SCORE_ENTRIES - 1)
2411       {
2412         int m = MAX_SCORE_ENTRIES - 1;
2413
2414 #ifdef ONE_PER_NAME
2415         for (l = k; l < MAX_SCORE_ENTRIES; l++)
2416           if (!strcmp(setup.player_name, highscore[l].Name))
2417             m = l;
2418         if (m == k)     /* player's new highscore overwrites his old one */
2419           goto put_into_list;
2420 #endif
2421
2422         for (l = m; l > k; l--)
2423         {
2424           strcpy(highscore[l].Name, highscore[l - 1].Name);
2425           highscore[l].Score = highscore[l - 1].Score;
2426         }
2427       }
2428
2429 #ifdef ONE_PER_NAME
2430       put_into_list:
2431 #endif
2432       strncpy(highscore[k].Name, setup.player_name, MAX_PLAYER_NAME_LEN);
2433       highscore[k].Name[MAX_PLAYER_NAME_LEN] = '\0';
2434       highscore[k].Score = local_player->score;
2435       position = k;
2436       break;
2437     }
2438
2439 #ifdef ONE_PER_NAME
2440     else if (!strncmp(setup.player_name, highscore[k].Name,
2441                       MAX_PLAYER_NAME_LEN))
2442       break;    /* player already there with a higher score */
2443 #endif
2444
2445   }
2446
2447   if (position >= 0)
2448     SaveScore(level_nr);
2449
2450   return position;
2451 }
2452
2453 inline static int getElementMoveStepsize(int x, int y)
2454 {
2455   int element = Feld[x][y];
2456   int direction = MovDir[x][y];
2457   int dx = (direction == MV_LEFT ? -1 : direction == MV_RIGHT ? +1 : 0);
2458   int dy = (direction == MV_UP   ? -1 : direction == MV_DOWN  ? +1 : 0);
2459   int horiz_move = (dx != 0);
2460   int sign = (horiz_move ? dx : dy);
2461   int step = sign * element_info[element].move_stepsize;
2462
2463   /* special values for move stepsize for spring and things on conveyor belt */
2464   if (horiz_move)
2465   {
2466 #if 0
2467     if (element == EL_SPRING)
2468       step = sign * MOVE_STEPSIZE_NORMAL * 2;
2469     else if (CAN_FALL(element) && !CAN_MOVE(element) &&
2470              y < lev_fieldy - 1 && IS_BELT_ACTIVE(Feld[x][y + 1]))
2471       step = sign * MOVE_STEPSIZE_NORMAL / 2;
2472 #else
2473     if (CAN_FALL(element) &&
2474         y < lev_fieldy - 1 && IS_BELT_ACTIVE(Feld[x][y + 1]))
2475       step = sign * MOVE_STEPSIZE_NORMAL / 2;
2476     else if (element == EL_SPRING)
2477       step = sign * MOVE_STEPSIZE_NORMAL * 2;
2478 #endif
2479   }
2480
2481   return step;
2482 }
2483
2484 void InitPlayerGfxAnimation(struct PlayerInfo *player, int action, int dir)
2485 {
2486   if (player->GfxAction != action || player->GfxDir != dir)
2487   {
2488 #if 0
2489     printf("Player frame reset! (%d => %d, %d => %d)\n",
2490            player->GfxAction, action, player->GfxDir, dir);
2491 #endif
2492
2493     player->GfxAction = action;
2494     player->GfxDir = dir;
2495     player->Frame = 0;
2496     player->StepFrame = 0;
2497   }
2498 }
2499
2500 static void ResetRandomAnimationValue(int x, int y)
2501 {
2502   GfxRandom[x][y] = INIT_GFX_RANDOM();
2503 }
2504
2505 static void ResetGfxAnimation(int x, int y)
2506 {
2507   GfxFrame[x][y] = 0;
2508   GfxAction[x][y] = ACTION_DEFAULT;
2509   GfxDir[x][y] = MovDir[x][y];
2510 }
2511
2512 void InitMovingField(int x, int y, int direction)
2513 {
2514   int element = Feld[x][y];
2515   int dx = (direction == MV_LEFT ? -1 : direction == MV_RIGHT ? +1 : 0);
2516   int dy = (direction == MV_UP   ? -1 : direction == MV_DOWN  ? +1 : 0);
2517   int newx = x + dx;
2518   int newy = y + dy;
2519
2520   if (!WasJustMoving[x][y] || direction != MovDir[x][y])
2521     ResetGfxAnimation(x, y);
2522
2523   MovDir[x][y] = direction;
2524   GfxDir[x][y] = direction;
2525   GfxAction[x][y] = (direction == MV_DOWN && CAN_FALL(element) ?
2526                      ACTION_FALLING : ACTION_MOVING);
2527
2528   /* this is needed for CEs with property "can move" / "not moving" */
2529
2530   if (getElementMoveStepsize(x, y) != 0)        /* moving or being moved */
2531   {
2532     if (Feld[newx][newy] == EL_EMPTY)
2533       Feld[newx][newy] = EL_BLOCKED;
2534
2535     MovDir[newx][newy] = MovDir[x][y];
2536
2537 #if USE_NEW_COLLECT_COUNT
2538     Count[newx][newy] = Count[x][y];
2539 #endif
2540
2541     GfxFrame[newx][newy] = GfxFrame[x][y];
2542     GfxRandom[newx][newy] = GfxRandom[x][y];
2543     GfxAction[newx][newy] = GfxAction[x][y];
2544     GfxDir[newx][newy] = GfxDir[x][y];
2545   }
2546 }
2547
2548 void Moving2Blocked(int x, int y, int *goes_to_x, int *goes_to_y)
2549 {
2550   int direction = MovDir[x][y];
2551   int newx = x + (direction == MV_LEFT ? -1 : direction == MV_RIGHT ? +1 : 0);
2552   int newy = y + (direction == MV_UP   ? -1 : direction == MV_DOWN  ? +1 : 0);
2553
2554   *goes_to_x = newx;
2555   *goes_to_y = newy;
2556 }
2557
2558 void Blocked2Moving(int x, int y, int *comes_from_x, int *comes_from_y)
2559 {
2560   int oldx = x, oldy = y;
2561   int direction = MovDir[x][y];
2562
2563   if (direction == MV_LEFT)
2564     oldx++;
2565   else if (direction == MV_RIGHT)
2566     oldx--;
2567   else if (direction == MV_UP)
2568     oldy++;
2569   else if (direction == MV_DOWN)
2570     oldy--;
2571
2572   *comes_from_x = oldx;
2573   *comes_from_y = oldy;
2574 }
2575
2576 int MovingOrBlocked2Element(int x, int y)
2577 {
2578   int element = Feld[x][y];
2579
2580   if (element == EL_BLOCKED)
2581   {
2582     int oldx, oldy;
2583
2584     Blocked2Moving(x, y, &oldx, &oldy);
2585     return Feld[oldx][oldy];
2586   }
2587   else
2588     return element;
2589 }
2590
2591 static int MovingOrBlocked2ElementIfNotLeaving(int x, int y)
2592 {
2593   /* like MovingOrBlocked2Element(), but if element is moving
2594      and (x,y) is the field the moving element is just leaving,
2595      return EL_BLOCKED instead of the element value */
2596   int element = Feld[x][y];
2597
2598   if (IS_MOVING(x, y))
2599   {
2600     if (element == EL_BLOCKED)
2601     {
2602       int oldx, oldy;
2603
2604       Blocked2Moving(x, y, &oldx, &oldy);
2605       return Feld[oldx][oldy];
2606     }
2607     else
2608       return EL_BLOCKED;
2609   }
2610   else
2611     return element;
2612 }
2613
2614 static void RemoveField(int x, int y)
2615 {
2616   Feld[x][y] = EL_EMPTY;
2617
2618   MovPos[x][y] = 0;
2619   MovDir[x][y] = 0;
2620   MovDelay[x][y] = 0;
2621
2622 #if USE_NEW_COLLECT_COUNT
2623   Count[x][y] = 0;
2624 #endif
2625
2626   AmoebaNr[x][y] = 0;
2627   ChangeDelay[x][y] = 0;
2628   ChangePage[x][y] = -1;
2629   Pushed[x][y] = FALSE;
2630
2631 #if 0
2632   ExplodeField[x][y] = EX_TYPE_NONE;
2633 #endif
2634
2635   GfxElement[x][y] = EL_UNDEFINED;
2636   GfxAction[x][y] = ACTION_DEFAULT;
2637   GfxDir[x][y] = MV_NO_MOVING;
2638 }
2639
2640 void RemoveMovingField(int x, int y)
2641 {
2642   int oldx = x, oldy = y, newx = x, newy = y;
2643   int element = Feld[x][y];
2644   int next_element = EL_UNDEFINED;
2645
2646   if (element != EL_BLOCKED && !IS_MOVING(x, y))
2647     return;
2648
2649   if (IS_MOVING(x, y))
2650   {
2651     Moving2Blocked(x, y, &newx, &newy);
2652
2653     if (Feld[newx][newy] != EL_BLOCKED)
2654     {
2655       /* element is moving, but target field is not free (blocked), but
2656          already occupied by something different (example: acid pool);
2657          in this case, only remove the moving field, but not the target */
2658
2659       RemoveField(oldx, oldy);
2660
2661       Store[oldx][oldy] = Store2[oldx][oldy] = 0;
2662
2663       DrawLevelField(oldx, oldy);
2664
2665       return;
2666     }
2667   }
2668   else if (element == EL_BLOCKED)
2669   {
2670     Blocked2Moving(x, y, &oldx, &oldy);
2671     if (!IS_MOVING(oldx, oldy))
2672       return;
2673   }
2674
2675   if (element == EL_BLOCKED &&
2676       (Feld[oldx][oldy] == EL_QUICKSAND_EMPTYING ||
2677        Feld[oldx][oldy] == EL_MAGIC_WALL_EMPTYING ||
2678        Feld[oldx][oldy] == EL_BD_MAGIC_WALL_EMPTYING ||
2679        Feld[oldx][oldy] == EL_AMOEBA_DROPPING))
2680     next_element = get_next_element(Feld[oldx][oldy]);
2681
2682   RemoveField(oldx, oldy);
2683   RemoveField(newx, newy);
2684
2685   Store[oldx][oldy] = Store2[oldx][oldy] = 0;
2686
2687   if (next_element != EL_UNDEFINED)
2688     Feld[oldx][oldy] = next_element;
2689
2690   DrawLevelField(oldx, oldy);
2691   DrawLevelField(newx, newy);
2692 }
2693
2694 void DrawDynamite(int x, int y)
2695 {
2696   int sx = SCREENX(x), sy = SCREENY(y);
2697   int graphic = el2img(Feld[x][y]);
2698   int frame;
2699
2700   if (!IN_SCR_FIELD(sx, sy) || IS_PLAYER(x, y))
2701     return;
2702
2703   if (IS_WALKABLE_INSIDE(Back[x][y]))
2704     return;
2705
2706   if (Back[x][y])
2707     DrawGraphic(sx, sy, el2img(Back[x][y]), 0);
2708   else if (Store[x][y])
2709     DrawGraphic(sx, sy, el2img(Store[x][y]), 0);
2710
2711   frame = getGraphicAnimationFrame(graphic, GfxFrame[x][y]);
2712
2713   if (Back[x][y] || Store[x][y])
2714     DrawGraphicThruMask(sx, sy, graphic, frame);
2715   else
2716     DrawGraphic(sx, sy, graphic, frame);
2717 }
2718
2719 void CheckDynamite(int x, int y)
2720 {
2721   if (MovDelay[x][y] != 0)      /* dynamite is still waiting to explode */
2722   {
2723     MovDelay[x][y]--;
2724
2725     if (MovDelay[x][y] != 0)
2726     {
2727       DrawDynamite(x, y);
2728       PlayLevelSoundActionIfLoop(x, y, ACTION_ACTIVE);
2729
2730       return;
2731     }
2732   }
2733
2734   StopLevelSoundActionIfLoop(x, y, ACTION_ACTIVE);
2735
2736   Bang(x, y);
2737 }
2738
2739 void DrawRelocatePlayer(struct PlayerInfo *player)
2740 {
2741   boolean ffwd_delay = (tape.playing && tape.fast_forward);
2742   boolean no_delay = (tape.warp_forward);
2743   int frame_delay_value = (ffwd_delay ? FfwdFrameDelay : GameFrameDelay);
2744   int wait_delay_value = (no_delay ? 0 : frame_delay_value);
2745   int jx = player->jx;
2746   int jy = player->jy;
2747
2748   if (level.instant_relocation)
2749   {
2750     int offset = (setup.scroll_delay ? 3 : 0);
2751
2752     if (!IN_VIS_FIELD(SCREENX(jx), SCREENY(jy)))
2753     {
2754       scroll_x = (local_player->jx < SBX_Left  + MIDPOSX ? SBX_Left :
2755                   local_player->jx > SBX_Right + MIDPOSX ? SBX_Right :
2756                   local_player->jx - MIDPOSX);
2757
2758       scroll_y = (local_player->jy < SBY_Upper + MIDPOSY ? SBY_Upper :
2759                   local_player->jy > SBY_Lower + MIDPOSY ? SBY_Lower :
2760                   local_player->jy - MIDPOSY);
2761     }
2762     else
2763     {
2764       if ((player->MovDir == MV_LEFT  && scroll_x > jx - MIDPOSX + offset) ||
2765           (player->MovDir == MV_RIGHT && scroll_x < jx - MIDPOSX - offset))
2766         scroll_x = jx - MIDPOSX + (scroll_x < jx-MIDPOSX ? -offset : +offset);
2767
2768       if ((player->MovDir == MV_UP  && scroll_y > jy - MIDPOSY + offset) ||
2769           (player->MovDir == MV_DOWN && scroll_y < jy - MIDPOSY - offset))
2770         scroll_y = jy - MIDPOSY + (scroll_y < jy-MIDPOSY ? -offset : +offset);
2771
2772       /* don't scroll over playfield boundaries */
2773       if (scroll_x < SBX_Left || scroll_x > SBX_Right)
2774         scroll_x = (scroll_x < SBX_Left ? SBX_Left : SBX_Right);
2775
2776       /* don't scroll over playfield boundaries */
2777       if (scroll_y < SBY_Upper || scroll_y > SBY_Lower)
2778         scroll_y = (scroll_y < SBY_Upper ? SBY_Upper : SBY_Lower);
2779     }
2780
2781     RedrawPlayfield(TRUE, 0,0,0,0);
2782   }
2783   else
2784   {
2785     int scroll_xx = -999, scroll_yy = -999;
2786
2787     ScrollScreen(NULL, SCROLL_GO_ON);   /* scroll last frame to full tile */
2788
2789     while (scroll_xx != scroll_x || scroll_yy != scroll_y)
2790     {
2791       int dx = 0, dy = 0;
2792       int fx = FX, fy = FY;
2793
2794       scroll_xx = (local_player->jx < SBX_Left  + MIDPOSX ? SBX_Left :
2795                    local_player->jx > SBX_Right + MIDPOSX ? SBX_Right :
2796                    local_player->jx - MIDPOSX);
2797
2798       scroll_yy = (local_player->jy < SBY_Upper + MIDPOSY ? SBY_Upper :
2799                    local_player->jy > SBY_Lower + MIDPOSY ? SBY_Lower :
2800                    local_player->jy - MIDPOSY);
2801
2802       dx = (scroll_xx < scroll_x ? +1 : scroll_xx > scroll_x ? -1 : 0);
2803       dy = (scroll_yy < scroll_y ? +1 : scroll_yy > scroll_y ? -1 : 0);
2804
2805       if (dx == 0 && dy == 0)           /* no scrolling needed at all */
2806         break;
2807
2808       scroll_x -= dx;
2809       scroll_y -= dy;
2810
2811       fx += dx * TILEX / 2;
2812       fy += dy * TILEY / 2;
2813
2814       ScrollLevel(dx, dy);
2815       DrawAllPlayers();
2816
2817       /* scroll in two steps of half tile size to make things smoother */
2818       BlitBitmap(drawto_field, window, fx, fy, SXSIZE, SYSIZE, SX, SY);
2819       FlushDisplay();
2820       Delay(wait_delay_value);
2821
2822       /* scroll second step to align at full tile size */
2823       BackToFront();
2824       Delay(wait_delay_value);
2825     }
2826
2827     DrawPlayer(player);
2828     BackToFront();
2829     Delay(wait_delay_value);
2830   }
2831 }
2832
2833 void RelocatePlayer(int jx, int jy, int el_player_raw)
2834 {
2835   int el_player = GET_VALID_PLAYER_ELEMENT(el_player_raw);
2836   struct PlayerInfo *player = &stored_player[el_player - EL_PLAYER_1];
2837   boolean ffwd_delay = (tape.playing && tape.fast_forward);
2838   boolean no_delay = (tape.warp_forward);
2839   int frame_delay_value = (ffwd_delay ? FfwdFrameDelay : GameFrameDelay);
2840   int wait_delay_value = (no_delay ? 0 : frame_delay_value);
2841   int old_jx = player->jx;
2842   int old_jy = player->jy;
2843   int old_element = Feld[old_jx][old_jy];
2844   int element = Feld[jx][jy];
2845   boolean player_relocated = (old_jx != jx || old_jy != jy);
2846
2847   int move_dir_horiz = (jx < old_jx ? MV_LEFT : jx > old_jx ? MV_RIGHT : 0);
2848   int move_dir_vert  = (jy < old_jy ? MV_UP   : jy > old_jy ? MV_DOWN  : 0);
2849   int enter_side_horiz = MV_DIR_OPPOSITE(move_dir_horiz);
2850   int enter_side_vert  = MV_DIR_OPPOSITE(move_dir_vert);
2851   int leave_side_horiz = move_dir_horiz;
2852   int leave_side_vert  = move_dir_vert;
2853   int enter_side = enter_side_horiz | enter_side_vert;
2854   int leave_side = leave_side_horiz | leave_side_vert;
2855
2856   if (player->GameOver)         /* do not reanimate dead player */
2857     return;
2858
2859   if (!player_relocated)        /* no need to relocate the player */
2860     return;
2861
2862   if (IS_PLAYER(jx, jy))        /* player already placed at new position */
2863   {
2864     RemoveField(jx, jy);        /* temporarily remove newly placed player */
2865     DrawLevelField(jx, jy);
2866   }
2867
2868   if (player->present)
2869   {
2870     while (player->MovPos)
2871     {
2872       ScrollPlayer(player, SCROLL_GO_ON);
2873       ScrollScreen(NULL, SCROLL_GO_ON);
2874
2875       AdvanceFrameAndPlayerCounters(player->index_nr);
2876
2877       DrawPlayer(player);
2878
2879       BackToFront();
2880       Delay(wait_delay_value);
2881     }
2882
2883     DrawPlayer(player);         /* needed here only to cleanup last field */
2884     DrawLevelField(player->jx, player->jy);     /* remove player graphic */
2885
2886     player->is_moving = FALSE;
2887   }
2888
2889   if (IS_CUSTOM_ELEMENT(old_element))
2890     CheckElementChangeByPlayer(old_jx, old_jy, old_element,
2891                                CE_LEFT_BY_PLAYER,
2892                                player->index_bit, leave_side);
2893
2894   CheckTriggeredElementChangeByPlayer(old_element, CE_PLAYER_LEAVES_X,
2895                                       player->index_bit, leave_side);
2896
2897   Feld[jx][jy] = el_player;
2898   InitPlayerField(jx, jy, el_player, TRUE);
2899
2900   if (!ELEM_IS_PLAYER(element)) /* player may be set on walkable element */
2901   {
2902     Feld[jx][jy] = element;
2903     InitField(jx, jy, FALSE);
2904   }
2905
2906   if (player == local_player)   /* only visually relocate local player */
2907     DrawRelocatePlayer(player);
2908
2909   TestIfPlayerTouchesBadThing(jx, jy);
2910   TestIfPlayerTouchesCustomElement(jx, jy);
2911
2912   if (IS_CUSTOM_ELEMENT(element))
2913     CheckElementChangeByPlayer(jx, jy, element, CE_ENTERED_BY_PLAYER,
2914                                player->index_bit, enter_side);
2915
2916   CheckTriggeredElementChangeByPlayer(element, CE_PLAYER_ENTERS_X,
2917                                       player->index_bit, enter_side);
2918 }
2919
2920 void Explode(int ex, int ey, int phase, int mode)
2921 {
2922   int x, y;
2923   int last_phase;
2924   int border_element;
2925
2926   /* !!! eliminate this variable !!! */
2927   int delay = (game.emulation == EMU_SUPAPLEX ? 3 : 2);
2928
2929   if (game.explosions_delayed)
2930   {
2931     ExplodeField[ex][ey] = mode;
2932     return;
2933   }
2934
2935   if (phase == EX_PHASE_START)          /* initialize 'Store[][]' field */
2936   {
2937     int center_element = Feld[ex][ey];
2938
2939 #if 0
2940     /* --- This is only really needed (and now handled) in "Impact()". --- */
2941     /* do not explode moving elements that left the explode field in time */
2942     if (game.engine_version >= VERSION_IDENT(2,2,0,7) &&
2943         center_element == EL_EMPTY &&
2944         (mode == EX_TYPE_NORMAL || mode == EX_TYPE_CENTER))
2945       return;
2946 #endif
2947
2948     if (mode == EX_TYPE_NORMAL ||
2949         mode == EX_TYPE_CENTER ||
2950         mode == EX_TYPE_CROSS)
2951       PlayLevelSoundAction(ex, ey, ACTION_EXPLODING);
2952
2953     /* remove things displayed in background while burning dynamite */
2954     if (Back[ex][ey] != EL_EMPTY && !IS_INDESTRUCTIBLE(Back[ex][ey]))
2955       Back[ex][ey] = 0;
2956
2957     if (IS_MOVING(ex, ey) || IS_BLOCKED(ex, ey))
2958     {
2959       /* put moving element to center field (and let it explode there) */
2960       center_element = MovingOrBlocked2Element(ex, ey);
2961       RemoveMovingField(ex, ey);
2962       Feld[ex][ey] = center_element;
2963     }
2964
2965     last_phase = element_info[center_element].explosion_delay + 1;
2966
2967     for (y = ey - 1; y <= ey + 1; y++) for (x = ex - 1; x <= ex + 1; x++)
2968     {
2969       int xx = x - ex + 1;
2970       int yy = y - ey + 1;
2971       int element;
2972
2973       if (!IN_LEV_FIELD(x, y) ||
2974           (mode & EX_TYPE_SINGLE_TILE && (x != ex || y != ey)) ||
2975           (mode == EX_TYPE_CROSS      && (x != ex && y != ey)))
2976         continue;
2977
2978       element = Feld[x][y];
2979
2980       if (IS_MOVING(x, y) || IS_BLOCKED(x, y))
2981       {
2982         element = MovingOrBlocked2Element(x, y);
2983
2984         if (!IS_EXPLOSION_PROOF(element))
2985           RemoveMovingField(x, y);
2986       }
2987
2988       /* indestructible elements can only explode in center (but not flames) */
2989       if ((IS_EXPLOSION_PROOF(element) && (x != ex || y != ey ||
2990                                            mode == EX_TYPE_BORDER)) ||
2991           element == EL_FLAMES)
2992         continue;
2993
2994       /* no idea why this was changed from 3.0.8 to 3.1.0 -- this causes buggy
2995          behaviour, for example when touching a yamyam that explodes to rocks
2996          with active deadly shield, a rock is created under the player !!! */
2997       /* (case 1 (surely buggy): >= 3.1.0, case 2 (maybe buggy): <= 3.0.8) */
2998 #if 0
2999       if (IS_PLAYER(x, y) && SHIELD_ON(PLAYERINFO(x, y)) &&
3000           (game.engine_version < VERSION_IDENT(3,1,0,0) ||
3001            (x == ex && y == ey && mode != EX_TYPE_BORDER)))
3002 #else
3003       if (IS_PLAYER(x, y) && SHIELD_ON(PLAYERINFO(x, y)))
3004 #endif
3005       {
3006         if (IS_ACTIVE_BOMB(element))
3007         {
3008           /* re-activate things under the bomb like gate or penguin */
3009           Feld[x][y] = (Back[x][y] ? Back[x][y] : EL_EMPTY);
3010           Back[x][y] = 0;
3011         }
3012
3013         continue;
3014       }
3015
3016       /* save walkable background elements while explosion on same tile */
3017       if (IS_WALKABLE(element) && IS_INDESTRUCTIBLE(element) &&
3018           (x != ex || y != ey || mode == EX_TYPE_BORDER))
3019         Back[x][y] = element;
3020
3021       /* ignite explodable elements reached by other explosion */
3022       if (element == EL_EXPLOSION)
3023         element = Store2[x][y];
3024
3025       if (AmoebaNr[x][y] &&
3026           (element == EL_AMOEBA_FULL ||
3027            element == EL_BD_AMOEBA ||
3028            element == EL_AMOEBA_GROWING))
3029       {
3030         AmoebaCnt[AmoebaNr[x][y]]--;
3031         AmoebaCnt2[AmoebaNr[x][y]]--;
3032       }
3033
3034       RemoveField(x, y);
3035
3036       if (IS_PLAYER(ex, ey) && !PLAYER_EXPLOSION_PROTECTED(ex, ey))
3037       {
3038         switch(StorePlayer[ex][ey])
3039         {
3040           case EL_PLAYER_2:
3041             Store[x][y] = EL_PLAYER_IS_EXPLODING_2;
3042             break;
3043           case EL_PLAYER_3:
3044             Store[x][y] = EL_PLAYER_IS_EXPLODING_3;
3045             break;
3046           case EL_PLAYER_4:
3047             Store[x][y] = EL_PLAYER_IS_EXPLODING_4;
3048             break;
3049           case EL_PLAYER_1:
3050           default:
3051             Store[x][y] = EL_PLAYER_IS_EXPLODING_1;
3052             break;
3053         }
3054
3055         if (PLAYERINFO(ex, ey)->use_murphy_graphic)
3056           Store[x][y] = EL_EMPTY;
3057       }
3058       else if (center_element == EL_MOLE)
3059         Store[x][y] = EL_EMERALD_RED;
3060       else if (center_element == EL_PENGUIN)
3061         Store[x][y] = EL_EMERALD_PURPLE;
3062       else if (center_element == EL_BUG)
3063         Store[x][y] = ((x == ex && y == ey) ? EL_DIAMOND : EL_EMERALD);
3064       else if (center_element == EL_BD_BUTTERFLY)
3065         Store[x][y] = EL_BD_DIAMOND;
3066       else if (center_element == EL_SP_ELECTRON)
3067         Store[x][y] = EL_SP_INFOTRON;
3068       else if (center_element == EL_AMOEBA_TO_DIAMOND)
3069         Store[x][y] = level.amoeba_content;
3070       else if (center_element == EL_YAMYAM)
3071         Store[x][y] = level.yamyam_content[game.yamyam_content_nr].e[xx][yy];
3072       else if (IS_CUSTOM_ELEMENT(center_element) &&
3073                element_info[center_element].content.e[xx][yy] != EL_EMPTY)
3074         Store[x][y] = element_info[center_element].content.e[xx][yy];
3075       else if (element == EL_WALL_EMERALD)
3076         Store[x][y] = EL_EMERALD;
3077       else if (element == EL_WALL_DIAMOND)
3078         Store[x][y] = EL_DIAMOND;
3079       else if (element == EL_WALL_BD_DIAMOND)
3080         Store[x][y] = EL_BD_DIAMOND;
3081       else if (element == EL_WALL_EMERALD_YELLOW)
3082         Store[x][y] = EL_EMERALD_YELLOW;
3083       else if (element == EL_WALL_EMERALD_RED)
3084         Store[x][y] = EL_EMERALD_RED;
3085       else if (element == EL_WALL_EMERALD_PURPLE)
3086         Store[x][y] = EL_EMERALD_PURPLE;
3087       else if (element == EL_WALL_PEARL)
3088         Store[x][y] = EL_PEARL;
3089       else if (element == EL_WALL_CRYSTAL)
3090         Store[x][y] = EL_CRYSTAL;
3091       else if (IS_CUSTOM_ELEMENT(element) && !CAN_EXPLODE(element))
3092         Store[x][y] = element_info[element].content.e[1][1];
3093       else
3094         Store[x][y] = EL_EMPTY;
3095
3096       if (x != ex || y != ey || mode == EX_TYPE_BORDER ||
3097           center_element == EL_AMOEBA_TO_DIAMOND)
3098         Store2[x][y] = element;
3099
3100       Feld[x][y] = EL_EXPLOSION;
3101       GfxElement[x][y] = center_element;
3102
3103       ExplodePhase[x][y] = 1;
3104       ExplodeDelay[x][y] = last_phase;
3105
3106       Stop[x][y] = TRUE;
3107     }
3108
3109     if (center_element == EL_YAMYAM)
3110       game.yamyam_content_nr =
3111         (game.yamyam_content_nr + 1) % level.num_yamyam_contents;
3112
3113     return;
3114   }
3115
3116   if (Stop[ex][ey])
3117     return;
3118
3119   x = ex;
3120   y = ey;
3121
3122   if (phase == 1)
3123     GfxFrame[x][y] = 0;         /* restart explosion animation */
3124
3125   last_phase = ExplodeDelay[x][y];
3126
3127   ExplodePhase[x][y] = (phase < last_phase ? phase + 1 : 0);
3128
3129 #ifdef DEBUG
3130
3131   /* activate this even in non-DEBUG version until cause for crash in
3132      getGraphicAnimationFrame() (see below) is found and eliminated */
3133
3134 #endif
3135 #if 1
3136
3137   if (GfxElement[x][y] == EL_UNDEFINED)
3138   {
3139     printf("\n\n");
3140     printf("Explode(): x = %d, y = %d: GfxElement == EL_UNDEFINED\n", x, y);
3141     printf("Explode(): This should never happen!\n");
3142     printf("\n\n");
3143
3144     GfxElement[x][y] = EL_EMPTY;
3145   }
3146 #endif
3147
3148   border_element = Store2[x][y];
3149   if (IS_PLAYER(x, y) && !PLAYER_EXPLOSION_PROTECTED(x, y))
3150     border_element = StorePlayer[x][y];
3151
3152   if (phase == element_info[border_element].ignition_delay ||
3153       phase == last_phase)
3154   {
3155     boolean border_explosion = FALSE;
3156
3157     if (IS_PLAYER(x, y) && PLAYERINFO(x, y)->present &&
3158         !PLAYER_EXPLOSION_PROTECTED(x, y))
3159     {
3160       KillPlayerUnlessExplosionProtected(x, y);
3161       border_explosion = TRUE;
3162     }
3163     else if (CAN_EXPLODE_BY_EXPLOSION(border_element))
3164     {
3165       Feld[x][y] = Store2[x][y];
3166       Store2[x][y] = 0;
3167       Bang(x, y);
3168       border_explosion = TRUE;
3169     }
3170     else if (border_element == EL_AMOEBA_TO_DIAMOND)
3171     {
3172       AmoebeUmwandeln(x, y);
3173       Store2[x][y] = 0;
3174       border_explosion = TRUE;
3175     }
3176
3177     /* if an element just explodes due to another explosion (chain-reaction),
3178        do not immediately end the new explosion when it was the last frame of
3179        the explosion (as it would be done in the following "if"-statement!) */
3180     if (border_explosion && phase == last_phase)
3181       return;
3182   }
3183
3184   if (phase == last_phase)
3185   {
3186     int element;
3187
3188     element = Feld[x][y] = Store[x][y];
3189     Store[x][y] = Store2[x][y] = 0;
3190     GfxElement[x][y] = EL_UNDEFINED;
3191
3192     /* player can escape from explosions and might therefore be still alive */
3193     if (element >= EL_PLAYER_IS_EXPLODING_1 &&
3194         element <= EL_PLAYER_IS_EXPLODING_4)
3195       Feld[x][y] = (stored_player[element - EL_PLAYER_IS_EXPLODING_1].active ?
3196                     EL_EMPTY :
3197                     element == EL_PLAYER_IS_EXPLODING_1 ? EL_EMERALD_YELLOW :
3198                     element == EL_PLAYER_IS_EXPLODING_2 ? EL_EMERALD_RED :
3199                     element == EL_PLAYER_IS_EXPLODING_3 ? EL_EMERALD :
3200                     EL_EMERALD_PURPLE);
3201
3202     /* restore probably existing indestructible background element */
3203     if (Back[x][y] && IS_INDESTRUCTIBLE(Back[x][y]))
3204       element = Feld[x][y] = Back[x][y];
3205     Back[x][y] = 0;
3206
3207     MovDir[x][y] = MovPos[x][y] = MovDelay[x][y] = 0;
3208     GfxDir[x][y] = MV_NO_MOVING;
3209     ChangeDelay[x][y] = 0;
3210     ChangePage[x][y] = -1;
3211
3212 #if USE_NEW_COLLECT_COUNT
3213     Count[x][y] = 0;
3214 #endif
3215
3216     InitField_WithBug2(x, y, FALSE);
3217
3218     DrawLevelField(x, y);
3219
3220     TestIfElementTouchesCustomElement(x, y);
3221
3222     if (GFX_CRUMBLED(element))
3223       DrawLevelFieldCrumbledSandNeighbours(x, y);
3224
3225     if (IS_PLAYER(x, y) && !PLAYERINFO(x, y)->present)
3226       StorePlayer[x][y] = 0;
3227
3228     if (ELEM_IS_PLAYER(element))
3229       RelocatePlayer(x, y, element);
3230   }
3231   else if (IN_SCR_FIELD(SCREENX(x), SCREENY(y)))
3232   {
3233     int graphic = el_act2img(GfxElement[x][y], ACTION_EXPLODING);
3234     int frame = getGraphicAnimationFrame(graphic, GfxFrame[x][y]);
3235
3236     if (phase == delay)
3237       DrawLevelFieldCrumbledSand(x, y);
3238
3239     if (IS_WALKABLE_OVER(Back[x][y]) && Back[x][y] != EL_EMPTY)
3240     {
3241       DrawLevelElement(x, y, Back[x][y]);
3242       DrawGraphicThruMask(SCREENX(x), SCREENY(y), graphic, frame);
3243     }
3244     else if (IS_WALKABLE_UNDER(Back[x][y]))
3245     {
3246       DrawGraphic(SCREENX(x), SCREENY(y), graphic, frame);
3247       DrawLevelElementThruMask(x, y, Back[x][y]);
3248     }
3249     else if (!IS_WALKABLE_INSIDE(Back[x][y]))
3250       DrawGraphic(SCREENX(x), SCREENY(y), graphic, frame);
3251   }
3252 }
3253
3254 void DynaExplode(int ex, int ey)
3255 {
3256   int i, j;
3257   int dynabomb_element = Feld[ex][ey];
3258   int dynabomb_size = 1;
3259   boolean dynabomb_xl = FALSE;
3260   struct PlayerInfo *player;
3261   static int xy[4][2] =
3262   {
3263     { 0, -1 },
3264     { -1, 0 },
3265     { +1, 0 },
3266     { 0, +1 }
3267   };
3268
3269   if (IS_ACTIVE_BOMB(dynabomb_element))
3270   {
3271     player = &stored_player[dynabomb_element - EL_DYNABOMB_PLAYER_1_ACTIVE];
3272     dynabomb_size = player->dynabomb_size;
3273     dynabomb_xl = player->dynabomb_xl;
3274     player->dynabombs_left++;
3275   }
3276
3277   Explode(ex, ey, EX_PHASE_START, EX_TYPE_CENTER);
3278
3279   for (i = 0; i < NUM_DIRECTIONS; i++)
3280   {
3281     for (j = 1; j <= dynabomb_size; j++)
3282     {
3283       int x = ex + j * xy[i][0];
3284       int y = ey + j * xy[i][1];
3285       int element;
3286
3287       if (!IN_LEV_FIELD(x, y) || IS_INDESTRUCTIBLE(Feld[x][y]))
3288         break;
3289
3290       element = Feld[x][y];
3291
3292       /* do not restart explosions of fields with active bombs */
3293       if (element == EL_EXPLOSION && IS_ACTIVE_BOMB(Store2[x][y]))
3294         continue;
3295
3296       Explode(x, y, EX_PHASE_START, EX_TYPE_BORDER);
3297
3298       if (element != EL_EMPTY && element != EL_EXPLOSION &&
3299           !IS_DIGGABLE(element) && !dynabomb_xl)
3300         break;
3301     }
3302   }
3303 }
3304
3305 void Bang(int x, int y)
3306 {
3307   int element = MovingOrBlocked2Element(x, y);
3308
3309   if (IS_PLAYER(x, y) && !PLAYER_EXPLOSION_PROTECTED(x, y))
3310   {
3311     struct PlayerInfo *player = PLAYERINFO(x, y);
3312
3313     element = Feld[x][y] = (player->use_murphy_graphic ? EL_SP_MURPHY :
3314                             player->element_nr);
3315   }
3316
3317   switch(element)
3318   {
3319     case EL_BUG:
3320     case EL_SPACESHIP:
3321     case EL_BD_BUTTERFLY:
3322     case EL_BD_FIREFLY:
3323     case EL_YAMYAM:
3324     case EL_DARK_YAMYAM:
3325     case EL_ROBOT:
3326     case EL_PACMAN:
3327     case EL_MOLE:
3328       RaiseScoreElement(element);
3329       Explode(x, y, EX_PHASE_START, EX_TYPE_NORMAL);
3330       break;
3331     case EL_DYNABOMB_PLAYER_1_ACTIVE:
3332     case EL_DYNABOMB_PLAYER_2_ACTIVE:
3333     case EL_DYNABOMB_PLAYER_3_ACTIVE:
3334     case EL_DYNABOMB_PLAYER_4_ACTIVE:
3335     case EL_DYNABOMB_INCREASE_NUMBER:
3336     case EL_DYNABOMB_INCREASE_SIZE:
3337     case EL_DYNABOMB_INCREASE_POWER:
3338       DynaExplode(x, y);
3339       break;
3340     case EL_PENGUIN:
3341     case EL_LAMP:
3342     case EL_LAMP_ACTIVE:
3343     case EL_AMOEBA_TO_DIAMOND:
3344       if (IS_PLAYER(x, y))
3345         Explode(x, y, EX_PHASE_START, EX_TYPE_NORMAL);
3346       else
3347         Explode(x, y, EX_PHASE_START, EX_TYPE_CENTER);
3348       break;
3349     default:
3350       if (element_info[element].explosion_type == EXPLODES_CROSS)
3351         Explode(x, y, EX_PHASE_START, EX_TYPE_CROSS);
3352       else if (element_info[element].explosion_type == EXPLODES_1X1)
3353         Explode(x, y, EX_PHASE_START, EX_TYPE_CENTER);
3354       else
3355         Explode(x, y, EX_PHASE_START, EX_TYPE_NORMAL);
3356       break;
3357   }
3358
3359   CheckTriggeredElementChange(element, CE_EXPLOSION_OF_X);
3360 }
3361
3362 void SplashAcid(int x, int y)
3363 {
3364   if (IN_LEV_FIELD(x - 1, y - 1) && IS_FREE(x - 1, y - 1) &&
3365       (!IN_LEV_FIELD(x - 1, y - 2) ||
3366        !CAN_FALL(MovingOrBlocked2Element(x - 1, y - 2))))
3367     Feld[x - 1][y - 1] = EL_ACID_SPLASH_LEFT;
3368
3369   if (IN_LEV_FIELD(x + 1, y - 1) && IS_FREE(x + 1, y - 1) &&
3370       (!IN_LEV_FIELD(x + 1, y - 2) ||
3371        !CAN_FALL(MovingOrBlocked2Element(x + 1, y - 2))))
3372     Feld[x + 1][y - 1] = EL_ACID_SPLASH_RIGHT;
3373
3374   PlayLevelSound(x, y, SND_ACID_SPLASHING);
3375 }
3376
3377 static void InitBeltMovement()
3378 {
3379   static int belt_base_element[4] =
3380   {
3381     EL_CONVEYOR_BELT_1_LEFT,
3382     EL_CONVEYOR_BELT_2_LEFT,
3383     EL_CONVEYOR_BELT_3_LEFT,
3384     EL_CONVEYOR_BELT_4_LEFT
3385   };
3386   static int belt_base_active_element[4] =
3387   {
3388     EL_CONVEYOR_BELT_1_LEFT_ACTIVE,
3389     EL_CONVEYOR_BELT_2_LEFT_ACTIVE,
3390     EL_CONVEYOR_BELT_3_LEFT_ACTIVE,
3391     EL_CONVEYOR_BELT_4_LEFT_ACTIVE
3392   };
3393
3394   int x, y, i, j;
3395
3396   /* set frame order for belt animation graphic according to belt direction */
3397   for (i = 0; i < NUM_BELTS; i++)
3398   {
3399     int belt_nr = i;
3400
3401     for (j = 0; j < NUM_BELT_PARTS; j++)
3402     {
3403       int element = belt_base_active_element[belt_nr] + j;
3404       int graphic = el2img(element);
3405
3406       if (game.belt_dir[i] == MV_LEFT)
3407         graphic_info[graphic].anim_mode &= ~ANIM_REVERSE;
3408       else
3409         graphic_info[graphic].anim_mode |=  ANIM_REVERSE;
3410     }
3411   }
3412
3413   for (y = 0; y < lev_fieldy; y++)
3414   {
3415     for (x = 0; x < lev_fieldx; x++)
3416     {
3417       int element = Feld[x][y];
3418
3419       for (i = 0; i < NUM_BELTS; i++)
3420       {
3421         if (IS_BELT(element) && game.belt_dir[i] != MV_NO_MOVING)
3422         {
3423           int e_belt_nr = getBeltNrFromBeltElement(element);
3424           int belt_nr = i;
3425
3426           if (e_belt_nr == belt_nr)
3427           {
3428             int belt_part = Feld[x][y] - belt_base_element[belt_nr];
3429
3430             Feld[x][y] = belt_base_active_element[belt_nr] + belt_part;
3431           }
3432         }
3433       }
3434     }
3435   }
3436 }
3437
3438 static void ToggleBeltSwitch(int x, int y)
3439 {
3440   static int belt_base_element[4] =
3441   {
3442     EL_CONVEYOR_BELT_1_LEFT,
3443     EL_CONVEYOR_BELT_2_LEFT,
3444     EL_CONVEYOR_BELT_3_LEFT,
3445     EL_CONVEYOR_BELT_4_LEFT
3446   };
3447   static int belt_base_active_element[4] =
3448   {
3449     EL_CONVEYOR_BELT_1_LEFT_ACTIVE,
3450     EL_CONVEYOR_BELT_2_LEFT_ACTIVE,
3451     EL_CONVEYOR_BELT_3_LEFT_ACTIVE,
3452     EL_CONVEYOR_BELT_4_LEFT_ACTIVE
3453   };
3454   static int belt_base_switch_element[4] =
3455   {
3456     EL_CONVEYOR_BELT_1_SWITCH_LEFT,
3457     EL_CONVEYOR_BELT_2_SWITCH_LEFT,
3458     EL_CONVEYOR_BELT_3_SWITCH_LEFT,
3459     EL_CONVEYOR_BELT_4_SWITCH_LEFT
3460   };
3461   static int belt_move_dir[4] =
3462   {
3463     MV_LEFT,
3464     MV_NO_MOVING,
3465     MV_RIGHT,
3466     MV_NO_MOVING,
3467   };
3468
3469   int element = Feld[x][y];
3470   int belt_nr = getBeltNrFromBeltSwitchElement(element);
3471   int belt_dir_nr = (game.belt_dir_nr[belt_nr] + 1) % 4;
3472   int belt_dir = belt_move_dir[belt_dir_nr];
3473   int xx, yy, i;
3474
3475   if (!IS_BELT_SWITCH(element))
3476     return;
3477
3478   game.belt_dir_nr[belt_nr] = belt_dir_nr;
3479   game.belt_dir[belt_nr] = belt_dir;
3480
3481   if (belt_dir_nr == 3)
3482     belt_dir_nr = 1;
3483
3484   /* set frame order for belt animation graphic according to belt direction */
3485   for (i = 0; i < NUM_BELT_PARTS; i++)
3486   {
3487     int element = belt_base_active_element[belt_nr] + i;
3488     int graphic = el2img(element);
3489
3490     if (belt_dir == MV_LEFT)
3491       graphic_info[graphic].anim_mode &= ~ANIM_REVERSE;
3492     else
3493       graphic_info[graphic].anim_mode |=  ANIM_REVERSE;
3494   }
3495
3496   for (yy = 0; yy < lev_fieldy; yy++)
3497   {
3498     for (xx = 0; xx < lev_fieldx; xx++)
3499     {
3500       int element = Feld[xx][yy];
3501
3502       if (IS_BELT_SWITCH(element))
3503       {
3504         int e_belt_nr = getBeltNrFromBeltSwitchElement(element);
3505
3506         if (e_belt_nr == belt_nr)
3507         {
3508           Feld[xx][yy] = belt_base_switch_element[belt_nr] + belt_dir_nr;
3509           DrawLevelField(xx, yy);
3510         }
3511       }
3512       else if (IS_BELT(element) && belt_dir != MV_NO_MOVING)
3513       {
3514         int e_belt_nr = getBeltNrFromBeltElement(element);
3515
3516         if (e_belt_nr == belt_nr)
3517         {
3518           int belt_part = Feld[xx][yy] - belt_base_element[belt_nr];
3519
3520           Feld[xx][yy] = belt_base_active_element[belt_nr] + belt_part;
3521           DrawLevelField(xx, yy);
3522         }
3523       }
3524       else if (IS_BELT_ACTIVE(element) && belt_dir == MV_NO_MOVING)
3525       {
3526         int e_belt_nr = getBeltNrFromBeltActiveElement(element);
3527
3528         if (e_belt_nr == belt_nr)
3529         {
3530           int belt_part = Feld[xx][yy] - belt_base_active_element[belt_nr];
3531
3532           Feld[xx][yy] = belt_base_element[belt_nr] + belt_part;
3533           DrawLevelField(xx, yy);
3534         }
3535       }
3536     }
3537   }
3538 }
3539
3540 static void ToggleSwitchgateSwitch(int x, int y)
3541 {
3542   int xx, yy;
3543
3544   game.switchgate_pos = !game.switchgate_pos;
3545
3546   for (yy = 0; yy < lev_fieldy; yy++)
3547   {
3548     for (xx = 0; xx < lev_fieldx; xx++)
3549     {
3550       int element = Feld[xx][yy];
3551
3552       if (element == EL_SWITCHGATE_SWITCH_UP ||
3553           element == EL_SWITCHGATE_SWITCH_DOWN)
3554       {
3555         Feld[xx][yy] = EL_SWITCHGATE_SWITCH_UP + game.switchgate_pos;
3556         DrawLevelField(xx, yy);
3557       }
3558       else if (element == EL_SWITCHGATE_OPEN ||
3559                element == EL_SWITCHGATE_OPENING)
3560       {
3561         Feld[xx][yy] = EL_SWITCHGATE_CLOSING;
3562
3563         PlayLevelSoundAction(xx, yy, ACTION_CLOSING);
3564       }
3565       else if (element == EL_SWITCHGATE_CLOSED ||
3566                element == EL_SWITCHGATE_CLOSING)
3567       {
3568         Feld[xx][yy] = EL_SWITCHGATE_OPENING;
3569
3570         PlayLevelSoundAction(xx, yy, ACTION_OPENING);
3571       }
3572     }
3573   }
3574 }
3575
3576 static int getInvisibleActiveFromInvisibleElement(int element)
3577 {
3578   return (element == EL_INVISIBLE_STEELWALL ? EL_INVISIBLE_STEELWALL_ACTIVE :
3579           element == EL_INVISIBLE_WALL      ? EL_INVISIBLE_WALL_ACTIVE :
3580           element == EL_INVISIBLE_SAND      ? EL_INVISIBLE_SAND_ACTIVE :
3581           element);
3582 }
3583
3584 static int getInvisibleFromInvisibleActiveElement(int element)
3585 {
3586   return (element == EL_INVISIBLE_STEELWALL_ACTIVE ? EL_INVISIBLE_STEELWALL :
3587           element == EL_INVISIBLE_WALL_ACTIVE      ? EL_INVISIBLE_WALL :
3588           element == EL_INVISIBLE_SAND_ACTIVE      ? EL_INVISIBLE_SAND :
3589           element);
3590 }
3591
3592 static void RedrawAllLightSwitchesAndInvisibleElements()
3593 {
3594   int x, y;
3595
3596   for (y = 0; y < lev_fieldy; y++)
3597   {
3598     for (x = 0; x < lev_fieldx; x++)
3599     {
3600       int element = Feld[x][y];
3601
3602       if (element == EL_LIGHT_SWITCH &&
3603           game.light_time_left > 0)
3604       {
3605         Feld[x][y] = EL_LIGHT_SWITCH_ACTIVE;
3606         DrawLevelField(x, y);
3607       }
3608       else if (element == EL_LIGHT_SWITCH_ACTIVE &&
3609                game.light_time_left == 0)
3610       {
3611         Feld[x][y] = EL_LIGHT_SWITCH;
3612         DrawLevelField(x, y);
3613       }
3614       else if (element == EL_INVISIBLE_STEELWALL ||
3615                element == EL_INVISIBLE_WALL ||
3616                element == EL_INVISIBLE_SAND)
3617       {
3618         if (game.light_time_left > 0)
3619           Feld[x][y] = getInvisibleActiveFromInvisibleElement(element);
3620
3621         DrawLevelField(x, y);
3622
3623         /* uncrumble neighbour fields, if needed */
3624         if (element == EL_INVISIBLE_SAND)
3625           DrawLevelFieldCrumbledSandNeighbours(x, y);
3626       }
3627       else if (element == EL_INVISIBLE_STEELWALL_ACTIVE ||
3628                element == EL_INVISIBLE_WALL_ACTIVE ||
3629                element == EL_INVISIBLE_SAND_ACTIVE)
3630       {
3631         if (game.light_time_left == 0)
3632           Feld[x][y] = getInvisibleFromInvisibleActiveElement(element);
3633
3634         DrawLevelField(x, y);
3635
3636         /* re-crumble neighbour fields, if needed */
3637         if (element == EL_INVISIBLE_SAND)
3638           DrawLevelFieldCrumbledSandNeighbours(x, y);
3639       }
3640     }
3641   }
3642 }
3643
3644 static void ToggleLightSwitch(int x, int y)
3645 {
3646   int element = Feld[x][y];
3647
3648   game.light_time_left =
3649     (element == EL_LIGHT_SWITCH ?
3650      level.time_light * FRAMES_PER_SECOND : 0);
3651
3652   RedrawAllLightSwitchesAndInvisibleElements();
3653 }
3654
3655 static void ActivateTimegateSwitch(int x, int y)
3656 {
3657   int xx, yy;
3658
3659   game.timegate_time_left = level.time_timegate * FRAMES_PER_SECOND;
3660
3661   for (yy = 0; yy < lev_fieldy; yy++)
3662   {
3663     for (xx = 0; xx < lev_fieldx; xx++)
3664     {
3665       int element = Feld[xx][yy];
3666
3667       if (element == EL_TIMEGATE_CLOSED ||
3668           element == EL_TIMEGATE_CLOSING)
3669       {
3670         Feld[xx][yy] = EL_TIMEGATE_OPENING;
3671         PlayLevelSound(xx, yy, SND_TIMEGATE_OPENING);
3672       }
3673
3674       /*
3675       else if (element == EL_TIMEGATE_SWITCH_ACTIVE)
3676       {
3677         Feld[xx][yy] = EL_TIMEGATE_SWITCH;
3678         DrawLevelField(xx, yy);
3679       }
3680       */
3681
3682     }
3683   }
3684
3685   Feld[x][y] = EL_TIMEGATE_SWITCH_ACTIVE;
3686 }
3687
3688 void Impact(int x, int y)
3689 {
3690   boolean last_line = (y == lev_fieldy - 1);
3691   boolean object_hit = FALSE;
3692   boolean impact = (last_line || object_hit);
3693   int element = Feld[x][y];
3694   int smashed = EL_STEELWALL;
3695
3696   if (!last_line)       /* check if element below was hit */
3697   {
3698     if (Feld[x][y + 1] == EL_PLAYER_IS_LEAVING)
3699       return;
3700
3701     object_hit = (!IS_FREE(x, y + 1) && (!IS_MOVING(x, y + 1) ||
3702                                          MovDir[x][y + 1] != MV_DOWN ||
3703                                          MovPos[x][y + 1] <= TILEY / 2));
3704
3705     /* do not smash moving elements that left the smashed field in time */
3706     if (game.engine_version >= VERSION_IDENT(2,2,0,7) && IS_MOVING(x, y + 1) &&
3707         ABS(MovPos[x][y + 1] + getElementMoveStepsize(x, y + 1)) >= TILEX)
3708       object_hit = FALSE;
3709
3710     if (object_hit)
3711       smashed = MovingOrBlocked2Element(x, y + 1);
3712
3713     impact = (last_line || object_hit);
3714   }
3715
3716   if (!last_line && smashed == EL_ACID) /* element falls into acid */
3717   {
3718     SplashAcid(x, y + 1);
3719     return;
3720   }
3721
3722   /* !!! not sufficient for all cases -- see EL_PEARL below !!! */
3723   /* only reset graphic animation if graphic really changes after impact */
3724   if (impact &&
3725       el_act_dir2img(element, GfxAction[x][y], MV_DOWN) != el2img(element))
3726   {
3727     ResetGfxAnimation(x, y);
3728     DrawLevelField(x, y);
3729   }
3730
3731   if (impact && CAN_EXPLODE_IMPACT(element))
3732   {
3733     Bang(x, y);
3734     return;
3735   }
3736   else if (impact && element == EL_PEARL)
3737   {
3738     ResetGfxAnimation(x, y);
3739
3740     Feld[x][y] = EL_PEARL_BREAKING;
3741     PlayLevelSound(x, y, SND_PEARL_BREAKING);
3742     return;
3743   }
3744   else if (impact && CheckElementChange(x, y, element, smashed, CE_IMPACT))
3745   {
3746     PlayLevelSoundElementAction(x, y, element, ACTION_IMPACT);
3747
3748     return;
3749   }
3750
3751   if (impact && element == EL_AMOEBA_DROP)
3752   {
3753     if (object_hit && IS_PLAYER(x, y + 1))
3754       KillPlayerUnlessEnemyProtected(x, y + 1);
3755     else if (object_hit && smashed == EL_PENGUIN)
3756       Bang(x, y + 1);
3757     else
3758     {
3759       Feld[x][y] = EL_AMOEBA_GROWING;
3760       Store[x][y] = EL_AMOEBA_WET;
3761
3762       ResetRandomAnimationValue(x, y);
3763     }
3764     return;
3765   }
3766
3767   if (object_hit)               /* check which object was hit */
3768   {
3769     if (CAN_PASS_MAGIC_WALL(element) &&
3770         (smashed == EL_MAGIC_WALL ||
3771          smashed == EL_BD_MAGIC_WALL))
3772     {
3773       int xx, yy;
3774       int activated_magic_wall =
3775         (smashed == EL_MAGIC_WALL ? EL_MAGIC_WALL_ACTIVE :
3776          EL_BD_MAGIC_WALL_ACTIVE);
3777
3778       /* activate magic wall / mill */
3779       for (yy = 0; yy < lev_fieldy; yy++)
3780         for (xx = 0; xx < lev_fieldx; xx++)
3781           if (Feld[xx][yy] == smashed)
3782             Feld[xx][yy] = activated_magic_wall;
3783
3784       game.magic_wall_time_left = level.time_magic_wall * FRAMES_PER_SECOND;
3785       game.magic_wall_active = TRUE;
3786
3787       PlayLevelSound(x, y, (smashed == EL_MAGIC_WALL ?
3788                             SND_MAGIC_WALL_ACTIVATING :
3789                             SND_BD_MAGIC_WALL_ACTIVATING));
3790     }
3791
3792     if (IS_PLAYER(x, y + 1))
3793     {
3794       if (CAN_SMASH_PLAYER(element))
3795       {
3796         KillPlayerUnlessEnemyProtected(x, y + 1);
3797         return;
3798       }
3799     }
3800     else if (smashed == EL_PENGUIN)
3801     {
3802       if (CAN_SMASH_PLAYER(element))
3803       {
3804         Bang(x, y + 1);
3805         return;
3806       }
3807     }
3808     else if (element == EL_BD_DIAMOND)
3809     {
3810       if (IS_CLASSIC_ENEMY(smashed) && IS_BD_ELEMENT(smashed))
3811       {
3812         Bang(x, y + 1);
3813         return;
3814       }
3815     }
3816     else if (((element == EL_SP_INFOTRON ||
3817                element == EL_SP_ZONK) &&
3818               (smashed == EL_SP_SNIKSNAK ||
3819                smashed == EL_SP_ELECTRON ||
3820                smashed == EL_SP_DISK_ORANGE)) ||
3821              (element == EL_SP_INFOTRON &&
3822               smashed == EL_SP_DISK_YELLOW))
3823     {
3824       Bang(x, y + 1);
3825       return;
3826     }
3827     else if (CAN_SMASH_EVERYTHING(element))
3828     {
3829       if (IS_CLASSIC_ENEMY(smashed) ||
3830           CAN_EXPLODE_SMASHED(smashed))
3831       {
3832         Bang(x, y + 1);
3833         return;
3834       }
3835       else if (!IS_MOVING(x, y + 1) && !IS_BLOCKED(x, y + 1))
3836       {
3837         if (smashed == EL_LAMP ||
3838             smashed == EL_LAMP_ACTIVE)
3839         {
3840           Bang(x, y + 1);
3841           return;
3842         }
3843         else if (smashed == EL_NUT)
3844         {
3845           Feld[x][y + 1] = EL_NUT_BREAKING;
3846           PlayLevelSound(x, y, SND_NUT_BREAKING);
3847           RaiseScoreElement(EL_NUT);
3848           return;
3849         }
3850         else if (smashed == EL_PEARL)
3851         {
3852           ResetGfxAnimation(x, y);
3853
3854           Feld[x][y + 1] = EL_PEARL_BREAKING;
3855           PlayLevelSound(x, y, SND_PEARL_BREAKING);
3856           return;
3857         }
3858         else if (smashed == EL_DIAMOND)
3859         {
3860           Feld[x][y + 1] = EL_DIAMOND_BREAKING;
3861           PlayLevelSound(x, y, SND_DIAMOND_BREAKING);
3862           return;
3863         }
3864         else if (IS_BELT_SWITCH(smashed))
3865         {
3866           ToggleBeltSwitch(x, y + 1);
3867         }
3868         else if (smashed == EL_SWITCHGATE_SWITCH_UP ||
3869                  smashed == EL_SWITCHGATE_SWITCH_DOWN)
3870         {
3871           ToggleSwitchgateSwitch(x, y + 1);
3872         }
3873         else if (smashed == EL_LIGHT_SWITCH ||
3874                  smashed == EL_LIGHT_SWITCH_ACTIVE)
3875         {
3876           ToggleLightSwitch(x, y + 1);
3877         }
3878         else
3879         {
3880 #if 0
3881           TestIfElementSmashesCustomElement(x, y, MV_DOWN);
3882 #endif
3883
3884           CheckElementChange(x, y + 1, smashed, element, CE_SMASHED);
3885
3886           CheckElementChangeBySide(x, y + 1, smashed, element,
3887                                    CE_SWITCHED, CH_SIDE_TOP);
3888           CheckTriggeredElementChangeBySide(smashed, CE_SWITCH_OF_X,
3889                                             CH_SIDE_TOP);
3890         }
3891       }
3892       else
3893       {
3894         CheckElementChange(x, y + 1, smashed, element, CE_SMASHED);
3895       }
3896     }
3897   }
3898
3899   /* play sound of magic wall / mill */
3900   if (!last_line &&
3901       (Feld[x][y + 1] == EL_MAGIC_WALL_ACTIVE ||
3902        Feld[x][y + 1] == EL_BD_MAGIC_WALL_ACTIVE))
3903   {
3904     if (Feld[x][y + 1] == EL_MAGIC_WALL_ACTIVE)
3905       PlayLevelSound(x, y, SND_MAGIC_WALL_FILLING);
3906     else if (Feld[x][y + 1] == EL_BD_MAGIC_WALL_ACTIVE)
3907       PlayLevelSound(x, y, SND_BD_MAGIC_WALL_FILLING);
3908
3909     return;
3910   }
3911
3912   /* play sound of object that hits the ground */
3913   if (last_line || object_hit)
3914     PlayLevelSoundElementAction(x, y, element, ACTION_IMPACT);
3915 }
3916
3917 inline static void TurnRoundExt(int x, int y)
3918 {
3919   static struct
3920   {
3921     int x, y;
3922   } move_xy[] =
3923   {
3924     {  0,  0 },
3925     { -1,  0 },
3926     { +1,  0 },
3927     {  0,  0 },
3928     {  0, -1 },
3929     {  0,  0 }, { 0, 0 }, { 0, 0 },
3930     {  0, +1 }
3931   };
3932   static struct
3933   {
3934     int left, right, back;
3935   } turn[] =
3936   {
3937     { 0,        0,              0        },
3938     { MV_DOWN,  MV_UP,          MV_RIGHT },
3939     { MV_UP,    MV_DOWN,        MV_LEFT  },
3940     { 0,        0,              0        },
3941     { MV_LEFT,  MV_RIGHT,       MV_DOWN  },
3942     { 0,        0,              0        },
3943     { 0,        0,              0        },
3944     { 0,        0,              0        },
3945     { MV_RIGHT, MV_LEFT,        MV_UP    }
3946   };
3947
3948   int element = Feld[x][y];
3949   int move_pattern = element_info[element].move_pattern;
3950
3951   int old_move_dir = MovDir[x][y];
3952   int left_dir  = turn[old_move_dir].left;
3953   int right_dir = turn[old_move_dir].right;
3954   int back_dir  = turn[old_move_dir].back;
3955
3956   int left_dx  = move_xy[left_dir].x,     left_dy  = move_xy[left_dir].y;
3957   int right_dx = move_xy[right_dir].x,    right_dy = move_xy[right_dir].y;
3958   int move_dx  = move_xy[old_move_dir].x, move_dy  = move_xy[old_move_dir].y;
3959   int back_dx  = move_xy[back_dir].x,     back_dy  = move_xy[back_dir].y;
3960
3961   int left_x  = x + left_dx,  left_y  = y + left_dy;
3962   int right_x = x + right_dx, right_y = y + right_dy;
3963   int move_x  = x + move_dx,  move_y  = y + move_dy;
3964
3965   int xx, yy;
3966
3967   if (element == EL_BUG || element == EL_BD_BUTTERFLY)
3968   {
3969     TestIfBadThingTouchesOtherBadThing(x, y);
3970
3971     if (ENEMY_CAN_ENTER_FIELD(element, right_x, right_y))
3972       MovDir[x][y] = right_dir;
3973     else if (!ENEMY_CAN_ENTER_FIELD(element, move_x, move_y))
3974       MovDir[x][y] = left_dir;
3975
3976     if (element == EL_BUG && MovDir[x][y] != old_move_dir)
3977       MovDelay[x][y] = 9;
3978     else if (element == EL_BD_BUTTERFLY)     /* && MovDir[x][y] == left_dir) */
3979       MovDelay[x][y] = 1;
3980   }
3981   else if (element == EL_SPACESHIP || element == EL_BD_FIREFLY)
3982   {
3983     TestIfBadThingTouchesOtherBadThing(x, y);
3984
3985     if (ENEMY_CAN_ENTER_FIELD(element, left_x, left_y))
3986       MovDir[x][y] = left_dir;
3987     else if (!ENEMY_CAN_ENTER_FIELD(element, move_x, move_y))
3988       MovDir[x][y] = right_dir;
3989
3990     if (element == EL_SPACESHIP && MovDir[x][y] != old_move_dir)
3991       MovDelay[x][y] = 9;
3992     else if (element == EL_BD_FIREFLY)      /* && MovDir[x][y] == right_dir) */
3993       MovDelay[x][y] = 1;
3994   }
3995   else if (element == EL_SP_SNIKSNAK || element == EL_SP_ELECTRON)
3996   {
3997     TestIfBadThingTouchesOtherBadThing(x, y);
3998
3999     if (ELEMENT_CAN_ENTER_FIELD_BASE_4(element, left_x, left_y, 0))
4000       MovDir[x][y] = left_dir;
4001     else if (!ELEMENT_CAN_ENTER_FIELD_BASE_4(element, move_x, move_y, 0))
4002       MovDir[x][y] = right_dir;
4003
4004     if (MovDir[x][y] != old_move_dir)
4005       MovDelay[x][y] = 9;
4006   }
4007   else if (element == EL_YAMYAM)
4008   {
4009     boolean can_turn_left  = YAMYAM_CAN_ENTER_FIELD(element, left_x, left_y);
4010     boolean can_turn_right = YAMYAM_CAN_ENTER_FIELD(element, right_x, right_y);
4011
4012     if (can_turn_left && can_turn_right)
4013       MovDir[x][y] = (RND(3) ? (RND(2) ? left_dir : right_dir) : back_dir);
4014     else if (can_turn_left)
4015       MovDir[x][y] = (RND(2) ? left_dir : back_dir);
4016     else if (can_turn_right)
4017       MovDir[x][y] = (RND(2) ? right_dir : back_dir);
4018     else
4019       MovDir[x][y] = back_dir;
4020
4021     MovDelay[x][y] = 16 + 16 * RND(3);
4022   }
4023   else if (element == EL_DARK_YAMYAM)
4024   {
4025     boolean can_turn_left  = DARK_YAMYAM_CAN_ENTER_FIELD(element,
4026                                                          left_x, left_y);
4027     boolean can_turn_right = DARK_YAMYAM_CAN_ENTER_FIELD(element,
4028                                                          right_x, right_y);
4029
4030     if (can_turn_left && can_turn_right)
4031       MovDir[x][y] = (RND(3) ? (RND(2) ? left_dir : right_dir) : back_dir);
4032     else if (can_turn_left)
4033       MovDir[x][y] = (RND(2) ? left_dir : back_dir);
4034     else if (can_turn_right)
4035       MovDir[x][y] = (RND(2) ? right_dir : back_dir);
4036     else
4037       MovDir[x][y] = back_dir;
4038
4039     MovDelay[x][y] = 16 + 16 * RND(3);
4040   }
4041   else if (element == EL_PACMAN)
4042   {
4043     boolean can_turn_left  = PACMAN_CAN_ENTER_FIELD(element, left_x, left_y);
4044     boolean can_turn_right = PACMAN_CAN_ENTER_FIELD(element, right_x, right_y);
4045
4046     if (can_turn_left && can_turn_right)
4047       MovDir[x][y] = (RND(3) ? (RND(2) ? left_dir : right_dir) : back_dir);
4048     else if (can_turn_left)
4049       MovDir[x][y] = (RND(2) ? left_dir : back_dir);
4050     else if (can_turn_right)
4051       MovDir[x][y] = (RND(2) ? right_dir : back_dir);
4052     else
4053       MovDir[x][y] = back_dir;
4054
4055     MovDelay[x][y] = 6 + RND(40);
4056   }
4057   else if (element == EL_PIG)
4058   {
4059     boolean can_turn_left  = PIG_CAN_ENTER_FIELD(element, left_x, left_y);
4060     boolean can_turn_right = PIG_CAN_ENTER_FIELD(element, right_x, right_y);
4061     boolean can_move_on    = PIG_CAN_ENTER_FIELD(element, move_x, move_y);
4062     boolean should_turn_left, should_turn_right, should_move_on;
4063     int rnd_value = 24;
4064     int rnd = RND(rnd_value);
4065
4066     should_turn_left = (can_turn_left &&
4067                         (!can_move_on ||
4068                          IN_LEV_FIELD_AND_NOT_FREE(x + back_dx + left_dx,
4069                                                    y + back_dy + left_dy)));
4070     should_turn_right = (can_turn_right &&
4071                          (!can_move_on ||
4072                           IN_LEV_FIELD_AND_NOT_FREE(x + back_dx + right_dx,
4073                                                     y + back_dy + right_dy)));
4074     should_move_on = (can_move_on &&
4075                       (!can_turn_left ||
4076                        !can_turn_right ||
4077                        IN_LEV_FIELD_AND_NOT_FREE(x + move_dx + left_dx,
4078                                                  y + move_dy + left_dy) ||
4079                        IN_LEV_FIELD_AND_NOT_FREE(x + move_dx + right_dx,
4080                                                  y + move_dy + right_dy)));
4081
4082     if (should_turn_left || should_turn_right || should_move_on)
4083     {
4084       if (should_turn_left && should_turn_right && should_move_on)
4085         MovDir[x][y] = (rnd < rnd_value / 3     ? left_dir :
4086                         rnd < 2 * rnd_value / 3 ? right_dir :
4087                         old_move_dir);
4088       else if (should_turn_left && should_turn_right)
4089         MovDir[x][y] = (rnd < rnd_value / 2 ? left_dir : right_dir);
4090       else if (should_turn_left && should_move_on)
4091         MovDir[x][y] = (rnd < rnd_value / 2 ? left_dir : old_move_dir);
4092       else if (should_turn_right && should_move_on)
4093         MovDir[x][y] = (rnd < rnd_value / 2 ? right_dir : old_move_dir);
4094       else if (should_turn_left)
4095         MovDir[x][y] = left_dir;
4096       else if (should_turn_right)
4097         MovDir[x][y] = right_dir;
4098       else if (should_move_on)
4099         MovDir[x][y] = old_move_dir;
4100     }
4101     else if (can_move_on && rnd > rnd_value / 8)
4102       MovDir[x][y] = old_move_dir;
4103     else if (can_turn_left && can_turn_right)
4104       MovDir[x][y] = (rnd < rnd_value / 2 ? left_dir : right_dir);
4105     else if (can_turn_left && rnd > rnd_value / 8)
4106       MovDir[x][y] = left_dir;
4107     else if (can_turn_right && rnd > rnd_value/8)
4108       MovDir[x][y] = right_dir;
4109     else
4110       MovDir[x][y] = back_dir;
4111
4112     xx = x + move_xy[MovDir[x][y]].x;
4113     yy = y + move_xy[MovDir[x][y]].y;
4114
4115     if (!IN_LEV_FIELD(xx, yy) ||
4116         (!IS_FREE(xx, yy) && !IS_FOOD_PIG(Feld[xx][yy])))
4117       MovDir[x][y] = old_move_dir;
4118
4119     MovDelay[x][y] = 0;
4120   }
4121   else if (element == EL_DRAGON)
4122   {
4123     boolean can_turn_left  = DRAGON_CAN_ENTER_FIELD(element, left_x, left_y);
4124     boolean can_turn_right = DRAGON_CAN_ENTER_FIELD(element, right_x, right_y);
4125     boolean can_move_on    = DRAGON_CAN_ENTER_FIELD(element, move_x, move_y);
4126     int rnd_value = 24;
4127     int rnd = RND(rnd_value);
4128
4129     if (can_move_on && rnd > rnd_value / 8)
4130       MovDir[x][y] = old_move_dir;
4131     else if (can_turn_left && can_turn_right)
4132       MovDir[x][y] = (rnd < rnd_value / 2 ? left_dir : right_dir);
4133     else if (can_turn_left && rnd > rnd_value / 8)
4134       MovDir[x][y] = left_dir;
4135     else if (can_turn_right && rnd > rnd_value / 8)
4136       MovDir[x][y] = right_dir;
4137     else
4138       MovDir[x][y] = back_dir;
4139
4140     xx = x + move_xy[MovDir[x][y]].x;
4141     yy = y + move_xy[MovDir[x][y]].y;
4142
4143     if (!IN_LEV_FIELD_AND_IS_FREE(xx, yy))
4144       MovDir[x][y] = old_move_dir;
4145
4146     MovDelay[x][y] = 0;
4147   }
4148   else if (element == EL_MOLE)
4149   {
4150     boolean can_move_on =
4151       (MOLE_CAN_ENTER_FIELD(element, move_x, move_y,
4152                             IS_AMOEBOID(Feld[move_x][move_y]) ||
4153                             Feld[move_x][move_y] == EL_AMOEBA_SHRINKING));
4154     if (!can_move_on)
4155     {
4156       boolean can_turn_left =
4157         (MOLE_CAN_ENTER_FIELD(element, left_x, left_y,
4158                               IS_AMOEBOID(Feld[left_x][left_y])));
4159
4160       boolean can_turn_right =
4161         (MOLE_CAN_ENTER_FIELD(element, right_x, right_y,
4162                               IS_AMOEBOID(Feld[right_x][right_y])));
4163
4164       if (can_turn_left && can_turn_right)
4165         MovDir[x][y] = (RND(2) ? left_dir : right_dir);
4166       else if (can_turn_left)
4167         MovDir[x][y] = left_dir;
4168       else
4169         MovDir[x][y] = right_dir;
4170     }
4171
4172     if (MovDir[x][y] != old_move_dir)
4173       MovDelay[x][y] = 9;
4174   }
4175   else if (element == EL_BALLOON)
4176   {
4177     MovDir[x][y] = game.balloon_dir;
4178     MovDelay[x][y] = 0;
4179   }
4180   else if (element == EL_SPRING)
4181   {
4182     if (MovDir[x][y] & MV_HORIZONTAL &&
4183         (!SPRING_CAN_ENTER_FIELD(element, move_x, move_y) ||
4184          SPRING_CAN_ENTER_FIELD(element, x, y + 1)))
4185       MovDir[x][y] = MV_NO_MOVING;
4186
4187     MovDelay[x][y] = 0;
4188   }
4189   else if (element == EL_ROBOT ||
4190            element == EL_SATELLITE ||
4191            element == EL_PENGUIN)
4192   {
4193     int attr_x = -1, attr_y = -1;
4194
4195     if (AllPlayersGone)
4196     {
4197       attr_x = ExitX;
4198       attr_y = ExitY;
4199     }
4200     else
4201     {
4202       int i;
4203
4204       for (i = 0; i < MAX_PLAYERS; i++)
4205       {
4206         struct PlayerInfo *player = &stored_player[i];
4207         int jx = player->jx, jy = player->jy;
4208
4209         if (!player->active)
4210           continue;
4211
4212         if (attr_x == -1 ||
4213             ABS(jx - x) + ABS(jy - y) < ABS(attr_x - x) + ABS(attr_y - y))
4214         {
4215           attr_x = jx;
4216           attr_y = jy;
4217         }
4218       }
4219     }
4220
4221     if (element == EL_ROBOT && ZX >= 0 && ZY >= 0 &&
4222         (Feld[ZX][ZY] == EL_ROBOT_WHEEL_ACTIVE ||
4223          game.engine_version < VERSION_IDENT(3,1,0,0)))
4224     {
4225       attr_x = ZX;
4226       attr_y = ZY;
4227     }
4228
4229     if (element == EL_PENGUIN)
4230     {
4231       int i;
4232       static int xy[4][2] =
4233       {
4234         { 0, -1 },
4235         { -1, 0 },
4236         { +1, 0 },
4237         { 0, +1 }
4238       };
4239
4240       for (i = 0; i < NUM_DIRECTIONS; i++)
4241       {
4242         int ex = x + xy[i][0];
4243         int ey = y + xy[i][1];
4244
4245         if (IN_LEV_FIELD(ex, ey) && Feld[ex][ey] == EL_EXIT_OPEN)
4246         {
4247           attr_x = ex;
4248           attr_y = ey;
4249           break;
4250         }
4251       }
4252     }
4253
4254     MovDir[x][y] = MV_NO_MOVING;
4255     if (attr_x < x)
4256       MovDir[x][y] |= (AllPlayersGone ? MV_RIGHT : MV_LEFT);
4257     else if (attr_x > x)
4258       MovDir[x][y] |= (AllPlayersGone ? MV_LEFT : MV_RIGHT);
4259     if (attr_y < y)
4260       MovDir[x][y] |= (AllPlayersGone ? MV_DOWN : MV_UP);
4261     else if (attr_y > y)
4262       MovDir[x][y] |= (AllPlayersGone ? MV_UP : MV_DOWN);
4263
4264     if (element == EL_ROBOT)
4265     {
4266       int newx, newy;
4267
4268       if (MovDir[x][y] & MV_HORIZONTAL && MovDir[x][y] & MV_VERTICAL)
4269         MovDir[x][y] &= (RND(2) ? MV_HORIZONTAL : MV_VERTICAL);
4270       Moving2Blocked(x, y, &newx, &newy);
4271
4272       if (IN_LEV_FIELD(newx, newy) && IS_FREE_OR_PLAYER(newx, newy))
4273         MovDelay[x][y] = 8 + 8 * !RND(3);
4274       else
4275         MovDelay[x][y] = 16;
4276     }
4277     else if (element == EL_PENGUIN)
4278     {
4279       int newx, newy;
4280
4281       MovDelay[x][y] = 1;
4282
4283       if (MovDir[x][y] & MV_HORIZONTAL && MovDir[x][y] & MV_VERTICAL)
4284       {
4285         boolean first_horiz = RND(2);
4286         int new_move_dir = MovDir[x][y];
4287
4288         MovDir[x][y] =
4289           new_move_dir & (first_horiz ? MV_HORIZONTAL : MV_VERTICAL);
4290         Moving2Blocked(x, y, &newx, &newy);
4291
4292         if (PENGUIN_CAN_ENTER_FIELD(EL_PENGUIN, newx, newy))
4293           return;
4294
4295         MovDir[x][y] =
4296           new_move_dir & (!first_horiz ? MV_HORIZONTAL : MV_VERTICAL);
4297         Moving2Blocked(x, y, &newx, &newy);
4298
4299         if (PENGUIN_CAN_ENTER_FIELD(EL_PENGUIN, newx, newy))
4300           return;
4301
4302         MovDir[x][y] = old_move_dir;
4303         return;
4304       }
4305     }
4306     else        /* (element == EL_SATELLITE) */
4307     {
4308       int newx, newy;
4309
4310       MovDelay[x][y] = 1;
4311
4312       if (MovDir[x][y] & MV_HORIZONTAL && MovDir[x][y] & MV_VERTICAL)
4313       {
4314         boolean first_horiz = RND(2);
4315         int new_move_dir = MovDir[x][y];
4316
4317         MovDir[x][y] =
4318           new_move_dir & (first_horiz ? MV_HORIZONTAL : MV_VERTICAL);
4319         Moving2Blocked(x, y, &newx, &newy);
4320
4321         if (SATELLITE_CAN_ENTER_FIELD(newx, newy))
4322           return;
4323
4324         MovDir[x][y] =
4325           new_move_dir & (!first_horiz ? MV_HORIZONTAL : MV_VERTICAL);
4326         Moving2Blocked(x, y, &newx, &newy);
4327
4328         if (SATELLITE_CAN_ENTER_FIELD(newx, newy))
4329           return;
4330
4331         MovDir[x][y] = old_move_dir;
4332         return;
4333       }
4334     }
4335   }
4336   else if (move_pattern == MV_TURNING_LEFT ||
4337            move_pattern == MV_TURNING_RIGHT ||
4338            move_pattern == MV_TURNING_LEFT_RIGHT ||
4339            move_pattern == MV_TURNING_RIGHT_LEFT ||
4340            move_pattern == MV_TURNING_RANDOM ||
4341            move_pattern == MV_ALL_DIRECTIONS)
4342   {
4343     boolean can_turn_left =
4344       CUSTOM_ELEMENT_CAN_ENTER_FIELD(element, left_x, left_y);
4345     boolean can_turn_right =
4346       CUSTOM_ELEMENT_CAN_ENTER_FIELD(element, right_x,right_y);
4347
4348     if (element_info[element].move_stepsize == 0)       /* "not moving" */
4349       return;
4350
4351     if (move_pattern == MV_TURNING_LEFT)
4352       MovDir[x][y] = left_dir;
4353     else if (move_pattern == MV_TURNING_RIGHT)
4354       MovDir[x][y] = right_dir;
4355     else if (move_pattern == MV_TURNING_LEFT_RIGHT)
4356       MovDir[x][y] = (can_turn_left || !can_turn_right ? left_dir : right_dir);
4357     else if (move_pattern == MV_TURNING_RIGHT_LEFT)
4358       MovDir[x][y] = (can_turn_right || !can_turn_left ? right_dir : left_dir);
4359     else if (move_pattern == MV_TURNING_RANDOM)
4360       MovDir[x][y] = (can_turn_left && !can_turn_right ? left_dir :
4361                       can_turn_right && !can_turn_left ? right_dir :
4362                       RND(2) ? left_dir : right_dir);
4363     else if (can_turn_left && can_turn_right)
4364       MovDir[x][y] = (RND(3) ? (RND(2) ? left_dir : right_dir) : back_dir);
4365     else if (can_turn_left)
4366       MovDir[x][y] = (RND(2) ? left_dir : back_dir);
4367     else if (can_turn_right)
4368       MovDir[x][y] = (RND(2) ? right_dir : back_dir);
4369     else
4370       MovDir[x][y] = back_dir;
4371
4372     MovDelay[x][y] = GET_NEW_MOVE_DELAY(element);
4373   }
4374   else if (move_pattern == MV_HORIZONTAL ||
4375            move_pattern == MV_VERTICAL)
4376   {
4377     if (move_pattern & old_move_dir)
4378       MovDir[x][y] = back_dir;
4379     else if (move_pattern == MV_HORIZONTAL)
4380       MovDir[x][y] = (RND(2) ? MV_LEFT : MV_RIGHT);
4381     else if (move_pattern == MV_VERTICAL)
4382       MovDir[x][y] = (RND(2) ? MV_UP : MV_DOWN);
4383
4384     MovDelay[x][y] = GET_NEW_MOVE_DELAY(element);
4385   }
4386   else if (move_pattern & MV_ANY_DIRECTION)
4387   {
4388     MovDir[x][y] = move_pattern;
4389     MovDelay[x][y] = GET_NEW_MOVE_DELAY(element);
4390   }
4391   else if (move_pattern == MV_ALONG_LEFT_SIDE)
4392   {
4393     if (CUSTOM_ELEMENT_CAN_ENTER_FIELD(element, left_x, left_y))
4394       MovDir[x][y] = left_dir;
4395     else if (!CUSTOM_ELEMENT_CAN_ENTER_FIELD(element, move_x, move_y))
4396       MovDir[x][y] = right_dir;
4397
4398     if (MovDir[x][y] != old_move_dir)
4399       MovDelay[x][y] = GET_NEW_MOVE_DELAY(element);
4400   }
4401   else if (move_pattern == MV_ALONG_RIGHT_SIDE)
4402   {
4403     if (CUSTOM_ELEMENT_CAN_ENTER_FIELD(element, right_x, right_y))
4404       MovDir[x][y] = right_dir;
4405     else if (!CUSTOM_ELEMENT_CAN_ENTER_FIELD(element, move_x, move_y))
4406       MovDir[x][y] = left_dir;
4407
4408     if (MovDir[x][y] != old_move_dir)
4409       MovDelay[x][y] = GET_NEW_MOVE_DELAY(element);
4410   }
4411   else if (move_pattern == MV_TOWARDS_PLAYER ||
4412            move_pattern == MV_AWAY_FROM_PLAYER)
4413   {
4414     int attr_x = -1, attr_y = -1;
4415     int newx, newy;
4416     boolean move_away = (move_pattern == MV_AWAY_FROM_PLAYER);
4417
4418     if (AllPlayersGone)
4419     {
4420       attr_x = ExitX;
4421       attr_y = ExitY;
4422     }
4423     else
4424     {
4425       int i;
4426
4427       for (i = 0; i < MAX_PLAYERS; i++)
4428       {
4429         struct PlayerInfo *player = &stored_player[i];
4430         int jx = player->jx, jy = player->jy;
4431
4432         if (!player->active)
4433           continue;
4434
4435         if (attr_x == -1 ||
4436             ABS(jx - x) + ABS(jy - y) < ABS(attr_x - x) + ABS(attr_y - y))
4437         {
4438           attr_x = jx;
4439           attr_y = jy;
4440         }
4441       }
4442     }
4443
4444     MovDir[x][y] = MV_NO_MOVING;
4445     if (attr_x < x)
4446       MovDir[x][y] |= (move_away ? MV_RIGHT : MV_LEFT);
4447     else if (attr_x > x)
4448       MovDir[x][y] |= (move_away ? MV_LEFT : MV_RIGHT);
4449     if (attr_y < y)
4450       MovDir[x][y] |= (move_away ? MV_DOWN : MV_UP);
4451     else if (attr_y > y)
4452       MovDir[x][y] |= (move_away ? MV_UP : MV_DOWN);
4453
4454     MovDelay[x][y] = GET_NEW_MOVE_DELAY(element);
4455
4456     if (MovDir[x][y] & MV_HORIZONTAL && MovDir[x][y] & MV_VERTICAL)
4457     {
4458       boolean first_horiz = RND(2);
4459       int new_move_dir = MovDir[x][y];
4460
4461       if (element_info[element].move_stepsize == 0)     /* "not moving" */
4462       {
4463         first_horiz = (ABS(attr_x - x) >= ABS(attr_y - y));
4464         MovDir[x][y] &= (first_horiz ? MV_HORIZONTAL : MV_VERTICAL);
4465
4466         return;
4467       }
4468
4469       MovDir[x][y] =
4470         new_move_dir & (first_horiz ? MV_HORIZONTAL : MV_VERTICAL);
4471       Moving2Blocked(x, y, &newx, &newy);
4472
4473       if (CUSTOM_ELEMENT_CAN_ENTER_FIELD(element, newx, newy))
4474         return;
4475
4476       MovDir[x][y] =
4477         new_move_dir & (!first_horiz ? MV_HORIZONTAL : MV_VERTICAL);
4478       Moving2Blocked(x, y, &newx, &newy);
4479
4480       if (CUSTOM_ELEMENT_CAN_ENTER_FIELD(element, newx, newy))
4481         return;
4482
4483       MovDir[x][y] = old_move_dir;
4484     }
4485   }
4486   else if (move_pattern == MV_WHEN_PUSHED ||
4487            move_pattern == MV_WHEN_DROPPED)
4488   {
4489     if (!CUSTOM_ELEMENT_CAN_ENTER_FIELD(element, move_x, move_y))
4490       MovDir[x][y] = MV_NO_MOVING;
4491
4492     MovDelay[x][y] = 0;
4493   }
4494   else if (move_pattern & MV_MAZE_RUNNER_STYLE)
4495   {
4496     static int test_xy[7][2] =
4497     {
4498       { 0, -1 },
4499       { -1, 0 },
4500       { +1, 0 },
4501       { 0, +1 },
4502       { 0, -1 },
4503       { -1, 0 },
4504       { +1, 0 },
4505     };
4506     static int test_dir[7] =
4507     {
4508       MV_UP,
4509       MV_LEFT,
4510       MV_RIGHT,
4511       MV_DOWN,
4512       MV_UP,
4513       MV_LEFT,
4514       MV_RIGHT,
4515     };
4516     boolean hunter_mode = (move_pattern == MV_MAZE_HUNTER);
4517     int move_preference = -1000000;     /* start with very low preference */
4518     int new_move_dir = MV_NO_MOVING;
4519     int start_test = RND(4);
4520     int i;
4521
4522     for (i = 0; i < NUM_DIRECTIONS; i++)
4523     {
4524       int move_dir = test_dir[start_test + i];
4525       int move_dir_preference;
4526
4527       xx = x + test_xy[start_test + i][0];
4528       yy = y + test_xy[start_test + i][1];
4529
4530       if (hunter_mode && IN_LEV_FIELD(xx, yy) &&
4531           (IS_PLAYER(xx, yy) || Feld[xx][yy] == EL_PLAYER_IS_LEAVING))
4532       {
4533         new_move_dir = move_dir;
4534
4535         break;
4536       }
4537
4538       if (!CUSTOM_ELEMENT_CAN_ENTER_FIELD(element, xx, yy))
4539         continue;
4540
4541       move_dir_preference = -1 * RunnerVisit[xx][yy];
4542       if (hunter_mode && PlayerVisit[xx][yy] > 0)
4543         move_dir_preference = PlayerVisit[xx][yy];
4544
4545       if (move_dir_preference > move_preference)
4546       {
4547         /* prefer field that has not been visited for the longest time */
4548         move_preference = move_dir_preference;
4549         new_move_dir = move_dir;
4550       }
4551       else if (move_dir_preference == move_preference &&
4552                move_dir == old_move_dir)
4553       {
4554         /* prefer last direction when all directions are preferred equally */
4555         move_preference = move_dir_preference;
4556         new_move_dir = move_dir;
4557       }
4558     }
4559
4560     MovDir[x][y] = new_move_dir;
4561     if (old_move_dir != new_move_dir)
4562       MovDelay[x][y] = GET_NEW_MOVE_DELAY(element);
4563   }
4564 }
4565
4566 static void TurnRound(int x, int y)
4567 {
4568   int direction = MovDir[x][y];
4569
4570   TurnRoundExt(x, y);
4571
4572   GfxDir[x][y] = MovDir[x][y];
4573
4574   if (direction != MovDir[x][y])
4575     GfxFrame[x][y] = 0;
4576
4577   if (MovDelay[x][y])
4578     GfxAction[x][y] = ACTION_TURNING_FROM_LEFT + MV_DIR_BIT(direction);
4579 }
4580
4581 static boolean JustBeingPushed(int x, int y)
4582 {
4583   int i;
4584
4585   for (i = 0; i < MAX_PLAYERS; i++)
4586   {
4587     struct PlayerInfo *player = &stored_player[i];
4588
4589     if (player->active && player->is_pushing && player->MovPos)
4590     {
4591       int next_jx = player->jx + (player->jx - player->last_jx);
4592       int next_jy = player->jy + (player->jy - player->last_jy);
4593
4594       if (x == next_jx && y == next_jy)
4595         return TRUE;
4596     }
4597   }
4598
4599   return FALSE;
4600 }
4601
4602 void StartMoving(int x, int y)
4603 {
4604   boolean started_moving = FALSE;       /* some elements can fall _and_ move */
4605   int element = Feld[x][y];
4606
4607   if (Stop[x][y])
4608     return;
4609
4610   if (MovDelay[x][y] == 0)
4611     GfxAction[x][y] = ACTION_DEFAULT;
4612
4613   if (CAN_FALL(element) && y < lev_fieldy - 1)
4614   {
4615     if ((x > 0              && IS_PLAYER(x - 1, y)) ||
4616         (x < lev_fieldx - 1 && IS_PLAYER(x + 1, y)))
4617       if (JustBeingPushed(x, y))
4618         return;
4619
4620     if (element == EL_QUICKSAND_FULL)
4621     {
4622       if (IS_FREE(x, y + 1))
4623       {
4624         InitMovingField(x, y, MV_DOWN);
4625         started_moving = TRUE;
4626
4627         Feld[x][y] = EL_QUICKSAND_EMPTYING;
4628         Store[x][y] = EL_ROCK;
4629
4630         PlayLevelSoundAction(x, y, ACTION_EMPTYING);
4631       }
4632       else if (Feld[x][y + 1] == EL_QUICKSAND_EMPTY)
4633       {
4634         if (!MovDelay[x][y])
4635           MovDelay[x][y] = TILEY + 1;
4636
4637         if (MovDelay[x][y])
4638         {
4639           MovDelay[x][y]--;
4640           if (MovDelay[x][y])
4641             return;
4642         }
4643
4644         Feld[x][y] = EL_QUICKSAND_EMPTY;
4645         Feld[x][y + 1] = EL_QUICKSAND_FULL;
4646         Store[x][y + 1] = Store[x][y];
4647         Store[x][y] = 0;
4648
4649         PlayLevelSoundAction(x, y, ACTION_FILLING);
4650       }
4651     }
4652     else if ((element == EL_ROCK || element == EL_BD_ROCK) &&
4653              Feld[x][y + 1] == EL_QUICKSAND_EMPTY)
4654     {
4655       InitMovingField(x, y, MV_DOWN);
4656       started_moving = TRUE;
4657
4658       Feld[x][y] = EL_QUICKSAND_FILLING;
4659       Store[x][y] = element;
4660
4661       PlayLevelSoundAction(x, y, ACTION_FILLING);
4662     }
4663     else if (element == EL_MAGIC_WALL_FULL)
4664     {
4665       if (IS_FREE(x, y + 1))
4666       {
4667         InitMovingField(x, y, MV_DOWN);
4668         started_moving = TRUE;
4669
4670         Feld[x][y] = EL_MAGIC_WALL_EMPTYING;
4671         Store[x][y] = EL_CHANGED(Store[x][y]);
4672       }
4673       else if (Feld[x][y + 1] == EL_MAGIC_WALL_ACTIVE)
4674       {
4675         if (!MovDelay[x][y])
4676           MovDelay[x][y] = TILEY/4 + 1;
4677
4678         if (MovDelay[x][y])
4679         {
4680           MovDelay[x][y]--;
4681           if (MovDelay[x][y])
4682             return;
4683         }
4684
4685         Feld[x][y] = EL_MAGIC_WALL_ACTIVE;
4686         Feld[x][y + 1] = EL_MAGIC_WALL_FULL;
4687         Store[x][y + 1] = EL_CHANGED(Store[x][y]);
4688         Store[x][y] = 0;
4689       }
4690     }
4691     else if (element == EL_BD_MAGIC_WALL_FULL)
4692     {
4693       if (IS_FREE(x, y + 1))
4694       {
4695         InitMovingField(x, y, MV_DOWN);
4696         started_moving = TRUE;
4697
4698         Feld[x][y] = EL_BD_MAGIC_WALL_EMPTYING;
4699         Store[x][y] = EL_CHANGED2(Store[x][y]);
4700       }
4701       else if (Feld[x][y + 1] == EL_BD_MAGIC_WALL_ACTIVE)
4702       {
4703         if (!MovDelay[x][y])
4704           MovDelay[x][y] = TILEY/4 + 1;
4705
4706         if (MovDelay[x][y])
4707         {
4708           MovDelay[x][y]--;
4709           if (MovDelay[x][y])
4710             return;
4711         }
4712
4713         Feld[x][y] = EL_BD_MAGIC_WALL_ACTIVE;
4714         Feld[x][y + 1] = EL_BD_MAGIC_WALL_FULL;
4715         Store[x][y + 1] = EL_CHANGED2(Store[x][y]);
4716         Store[x][y] = 0;
4717       }
4718     }
4719     else if (CAN_PASS_MAGIC_WALL(element) &&
4720              (Feld[x][y + 1] == EL_MAGIC_WALL_ACTIVE ||
4721               Feld[x][y + 1] == EL_BD_MAGIC_WALL_ACTIVE))
4722     {
4723       InitMovingField(x, y, MV_DOWN);
4724       started_moving = TRUE;
4725
4726       Feld[x][y] =
4727         (Feld[x][y + 1] == EL_MAGIC_WALL_ACTIVE ? EL_MAGIC_WALL_FILLING :
4728          EL_BD_MAGIC_WALL_FILLING);
4729       Store[x][y] = element;
4730     }
4731     else if (CAN_FALL(element) && Feld[x][y + 1] == EL_ACID)
4732     {
4733       SplashAcid(x, y + 1);
4734
4735       InitMovingField(x, y, MV_DOWN);
4736       started_moving = TRUE;
4737
4738       Store[x][y] = EL_ACID;
4739     }
4740     else if ((game.engine_version >= VERSION_IDENT(3,1,0,0) &&
4741               CheckCollision[x][y] && !IS_FREE(x, y + 1)) ||
4742
4743              (game.engine_version >= VERSION_IDENT(3,0,7,0) &&
4744               CAN_FALL(element) && WasJustFalling[x][y] &&
4745               (Feld[x][y + 1] == EL_BLOCKED || IS_PLAYER(x, y + 1))) ||
4746
4747              (game.engine_version < VERSION_IDENT(2,2,0,7) &&
4748               CAN_FALL(element) && WasJustMoving[x][y] && !Pushed[x][y + 1] &&
4749               (Feld[x][y + 1] == EL_BLOCKED)))
4750     {
4751       /* this is needed for a special case not covered by calling "Impact()"
4752          from "ContinueMoving()": if an element moves to a tile directly below
4753          another element which was just falling on that tile (which was empty
4754          in the previous frame), the falling element above would just stop
4755          instead of smashing the element below (in previous version, the above
4756          element was just checked for "moving" instead of "falling", resulting
4757          in incorrect smashes caused by horizontal movement of the above
4758          element; also, the case of the player being the element to smash was
4759          simply not covered here... :-/ ) */
4760
4761       CheckCollision[x][y] = 0;
4762
4763       Impact(x, y);
4764     }
4765     else if (IS_FREE(x, y + 1) && element == EL_SPRING && level.use_spring_bug)
4766     {
4767       if (MovDir[x][y] == MV_NO_MOVING)
4768       {
4769         InitMovingField(x, y, MV_DOWN);
4770         started_moving = TRUE;
4771       }
4772     }
4773     else if (IS_FREE(x, y + 1) || Feld[x][y + 1] == EL_DIAMOND_BREAKING)
4774     {
4775       if (WasJustFalling[x][y]) /* prevent animation from being restarted */
4776         MovDir[x][y] = MV_DOWN;
4777
4778       InitMovingField(x, y, MV_DOWN);
4779       started_moving = TRUE;
4780     }
4781     else if (element == EL_AMOEBA_DROP)
4782     {
4783       Feld[x][y] = EL_AMOEBA_GROWING;
4784       Store[x][y] = EL_AMOEBA_WET;
4785     }
4786     else if (((IS_SLIPPERY(Feld[x][y + 1]) && !IS_PLAYER(x, y + 1)) ||
4787               (IS_EM_SLIPPERY_WALL(Feld[x][y + 1]) && IS_GEM(element))) &&
4788              !IS_FALLING(x, y + 1) && !WasJustMoving[x][y + 1] &&
4789              element != EL_DX_SUPABOMB && element != EL_SP_DISK_ORANGE)
4790     {
4791       boolean can_fall_left  = (x > 0 && IS_FREE(x - 1, y) &&
4792                                 (IS_FREE(x - 1, y + 1) ||
4793                                  Feld[x - 1][y + 1] == EL_ACID));
4794       boolean can_fall_right = (x < lev_fieldx - 1 && IS_FREE(x + 1, y) &&
4795                                 (IS_FREE(x + 1, y + 1) ||
4796                                  Feld[x + 1][y + 1] == EL_ACID));
4797       boolean can_fall_any  = (can_fall_left || can_fall_right);
4798       boolean can_fall_both = (can_fall_left && can_fall_right);
4799       int slippery_type = element_info[Feld[x][y + 1]].slippery_type;
4800
4801 #if USE_NEW_ALL_SLIPPERY
4802       if (can_fall_any && slippery_type != SLIPPERY_ANY_RANDOM)
4803       {
4804         if (slippery_type == SLIPPERY_ANY_LEFT_RIGHT && can_fall_both)
4805           can_fall_right = FALSE;
4806         else if (slippery_type == SLIPPERY_ANY_RIGHT_LEFT && can_fall_both)
4807           can_fall_left = FALSE;
4808         else if (slippery_type == SLIPPERY_ONLY_LEFT)
4809           can_fall_right = FALSE;
4810         else if (slippery_type == SLIPPERY_ONLY_RIGHT)
4811           can_fall_left = FALSE;
4812
4813         can_fall_any  = (can_fall_left || can_fall_right);
4814         can_fall_both = FALSE;
4815       }
4816 #else
4817       if (can_fall_any && IS_CUSTOM_ELEMENT(Feld[x][y + 1]))
4818       {
4819         if (slippery_type == SLIPPERY_ONLY_LEFT)
4820           can_fall_right = FALSE;
4821         else if (slippery_type == SLIPPERY_ONLY_RIGHT)
4822           can_fall_left = FALSE;
4823         else if (slippery_type == SLIPPERY_ANY_LEFT_RIGHT && can_fall_both)
4824           can_fall_right = FALSE;
4825         else if (slippery_type == SLIPPERY_ANY_RIGHT_LEFT && can_fall_both)
4826           can_fall_left = FALSE;
4827
4828         can_fall_any  = (can_fall_left || can_fall_right);
4829         can_fall_both = (can_fall_left && can_fall_right);
4830       }
4831 #endif
4832
4833 #if USE_NEW_ALL_SLIPPERY
4834 #else
4835 #if USE_NEW_SP_SLIPPERY
4836       /* !!! better use the same properties as for custom elements here !!! */
4837       else if (game.engine_version >= VERSION_IDENT(3,1,1,0) &&
4838                can_fall_both && IS_SP_ELEMENT(Feld[x][y + 1]))
4839       {
4840         can_fall_right = FALSE;         /* slip down on left side */
4841         can_fall_both = FALSE;
4842       }
4843 #endif
4844 #endif
4845
4846 #if USE_NEW_ALL_SLIPPERY
4847       if (can_fall_both)
4848       {
4849         if (element == EL_BD_ROCK || element == EL_BD_DIAMOND)
4850           can_fall_right = FALSE;       /* slip down on left side */
4851         else
4852           can_fall_left = !(can_fall_right = RND(2));
4853
4854         can_fall_both = FALSE;
4855       }
4856 #else
4857       if (can_fall_both)
4858       {
4859         if (game.emulation == EMU_BOULDERDASH ||
4860             element == EL_BD_ROCK || element == EL_BD_DIAMOND)
4861           can_fall_right = FALSE;       /* slip down on left side */
4862         else
4863           can_fall_left = !(can_fall_right = RND(2));
4864
4865         can_fall_both = FALSE;
4866       }
4867 #endif
4868
4869       if (can_fall_any)
4870       {
4871         /* if not determined otherwise, prefer left side for slipping down */
4872         InitMovingField(x, y, can_fall_left ? MV_LEFT : MV_RIGHT);
4873         started_moving = TRUE;
4874       }
4875     }
4876 #if 0
4877     else if (IS_BELT_ACTIVE(Feld[x][y + 1]) && !CAN_MOVE(element))
4878 #else
4879     else if (IS_BELT_ACTIVE(Feld[x][y + 1]))
4880 #endif
4881     {
4882       boolean left_is_free  = (x > 0 && IS_FREE(x - 1, y));
4883       boolean right_is_free = (x < lev_fieldx - 1 && IS_FREE(x + 1, y));
4884       int belt_nr = getBeltNrFromBeltActiveElement(Feld[x][y + 1]);
4885       int belt_dir = game.belt_dir[belt_nr];
4886
4887       if ((belt_dir == MV_LEFT  && left_is_free) ||
4888           (belt_dir == MV_RIGHT && right_is_free))
4889       {
4890         int nextx = (belt_dir == MV_LEFT ? x - 1 : x + 1);
4891
4892         InitMovingField(x, y, belt_dir);
4893         started_moving = TRUE;
4894
4895         Pushed[x][y] = TRUE;
4896         Pushed[nextx][y] = TRUE;
4897
4898         GfxAction[x][y] = ACTION_DEFAULT;
4899       }
4900       else
4901       {
4902         MovDir[x][y] = 0;       /* if element was moving, stop it */
4903       }
4904     }
4905   }
4906
4907   /* not "else if" because of elements that can fall and move (EL_SPRING) */
4908 #if 0
4909   if (CAN_MOVE(element) && !started_moving && MovDir[x][y] != MV_NO_MOVING)
4910 #else
4911   if (CAN_MOVE(element) && !started_moving)
4912 #endif
4913   {
4914     int move_pattern = element_info[element].move_pattern;
4915     int newx, newy;
4916
4917 #if 0
4918 #if DEBUG
4919     if (MovDir[x][y] == MV_NO_MOVING)
4920     {
4921       printf("StartMoving(): %d,%d: element %d ['%s'] not moving\n",
4922              x, y, element, element_info[element].token_name);
4923       printf("StartMoving(): This should never happen!\n");
4924     }
4925 #endif
4926 #endif
4927
4928     Moving2Blocked(x, y, &newx, &newy);
4929
4930     if (IS_PUSHABLE(element) && JustBeingPushed(x, y))
4931       return;
4932
4933     if (game.engine_version >= VERSION_IDENT(3,1,0,0) &&
4934         CheckCollision[x][y] && !IN_LEV_FIELD_AND_IS_FREE(newx, newy))
4935     {
4936       WasJustMoving[x][y] = 0;
4937       CheckCollision[x][y] = 0;
4938
4939       TestIfElementHitsCustomElement(x, y, MovDir[x][y]);
4940
4941       if (Feld[x][y] != element)        /* element has changed */
4942         return;
4943     }
4944
4945     if (!MovDelay[x][y])        /* start new movement phase */
4946     {
4947       /* all objects that can change their move direction after each step
4948          (YAMYAM, DARK_YAMYAM and PACMAN go straight until they hit a wall */
4949
4950       if (element != EL_YAMYAM &&
4951           element != EL_DARK_YAMYAM &&
4952           element != EL_PACMAN &&
4953           !(move_pattern & MV_ANY_DIRECTION) &&
4954           move_pattern != MV_TURNING_LEFT &&
4955           move_pattern != MV_TURNING_RIGHT &&
4956           move_pattern != MV_TURNING_LEFT_RIGHT &&
4957           move_pattern != MV_TURNING_RIGHT_LEFT &&
4958           move_pattern != MV_TURNING_RANDOM)
4959       {
4960         TurnRound(x, y);
4961
4962         if (MovDelay[x][y] && (element == EL_BUG ||
4963                                element == EL_SPACESHIP ||
4964                                element == EL_SP_SNIKSNAK ||
4965                                element == EL_SP_ELECTRON ||
4966                                element == EL_MOLE))
4967           DrawLevelField(x, y);
4968       }
4969     }
4970
4971     if (MovDelay[x][y])         /* wait some time before next movement */
4972     {
4973       MovDelay[x][y]--;
4974
4975       if (element == EL_ROBOT ||
4976           element == EL_YAMYAM ||
4977           element == EL_DARK_YAMYAM)
4978       {
4979         DrawLevelElementAnimationIfNeeded(x, y, element);
4980         PlayLevelSoundAction(x, y, ACTION_WAITING);
4981       }
4982       else if (element == EL_SP_ELECTRON)
4983         DrawLevelElementAnimationIfNeeded(x, y, element);
4984       else if (element == EL_DRAGON)
4985       {
4986         int i;
4987         int dir = MovDir[x][y];
4988         int dx = (dir == MV_LEFT ? -1 : dir == MV_RIGHT ? +1 : 0);
4989         int dy = (dir == MV_UP   ? -1 : dir == MV_DOWN  ? +1 : 0);
4990         int graphic = (dir == MV_LEFT   ? IMG_FLAMES_1_LEFT :
4991                        dir == MV_RIGHT  ? IMG_FLAMES_1_RIGHT :
4992                        dir == MV_UP     ? IMG_FLAMES_1_UP :
4993                        dir == MV_DOWN   ? IMG_FLAMES_1_DOWN : IMG_EMPTY);
4994         int frame = getGraphicAnimationFrame(graphic, GfxFrame[x][y]);
4995
4996         GfxAction[x][y] = ACTION_ATTACKING;
4997
4998         if (IS_PLAYER(x, y))
4999           DrawPlayerField(x, y);
5000         else
5001           DrawLevelField(x, y);
5002
5003         PlayLevelSoundActionIfLoop(x, y, ACTION_ATTACKING);
5004
5005         for (i = 1; i <= 3; i++)
5006         {
5007           int xx = x + i * dx;
5008           int yy = y + i * dy;
5009           int sx = SCREENX(xx);
5010           int sy = SCREENY(yy);
5011           int flame_graphic = graphic + (i - 1);
5012
5013           if (!IN_LEV_FIELD(xx, yy) || IS_DRAGONFIRE_PROOF(Feld[xx][yy]))
5014             break;
5015
5016           if (MovDelay[x][y])
5017           {
5018             int flamed = MovingOrBlocked2Element(xx, yy);
5019
5020             /* !!! */
5021 #if 0
5022             if (IS_CLASSIC_ENEMY(flamed) || CAN_EXPLODE_BY_DRAGONFIRE(flamed))
5023               Bang(xx, yy);
5024             else if (IS_MOVING(xx, yy) || IS_BLOCKED(xx, yy))
5025               RemoveMovingField(xx, yy);
5026             else
5027               RemoveField(xx, yy);
5028 #else
5029             if (IS_CLASSIC_ENEMY(flamed) || CAN_EXPLODE_BY_DRAGONFIRE(flamed))
5030               Bang(xx, yy);
5031             else
5032               RemoveMovingField(xx, yy);
5033 #endif
5034
5035             ChangeDelay[xx][yy] = 0;
5036
5037             Feld[xx][yy] = EL_FLAMES;
5038
5039             if (IN_SCR_FIELD(sx, sy))
5040             {
5041               DrawLevelFieldCrumbledSand(xx, yy);
5042               DrawGraphic(sx, sy, flame_graphic, frame);
5043             }
5044           }
5045           else
5046           {
5047             if (Feld[xx][yy] == EL_FLAMES)
5048               Feld[xx][yy] = EL_EMPTY;
5049             DrawLevelField(xx, yy);
5050           }
5051         }
5052       }
5053
5054       if (MovDelay[x][y])       /* element still has to wait some time */
5055       {
5056         PlayLevelSoundAction(x, y, ACTION_WAITING);
5057
5058         return;
5059       }
5060     }
5061
5062     /* now make next step */
5063
5064     Moving2Blocked(x, y, &newx, &newy); /* get next screen position */
5065
5066     if (DONT_COLLIDE_WITH(element) &&
5067         IN_LEV_FIELD(newx, newy) && IS_PLAYER(newx, newy) &&
5068         !PLAYER_ENEMY_PROTECTED(newx, newy))
5069     {
5070       TestIfBadThingRunsIntoPlayer(x, y, MovDir[x][y]);
5071
5072       return;
5073     }
5074
5075     else if (CAN_MOVE_INTO_ACID(element) &&
5076              IN_LEV_FIELD(newx, newy) && Feld[newx][newy] == EL_ACID &&
5077              (MovDir[x][y] == MV_DOWN ||
5078               game.engine_version >= VERSION_IDENT(3,1,0,0)))
5079     {
5080       SplashAcid(newx, newy);
5081       Store[x][y] = EL_ACID;
5082     }
5083     else if (element == EL_PENGUIN && IN_LEV_FIELD(newx, newy))
5084     {
5085       if (Feld[newx][newy] == EL_EXIT_OPEN)
5086       {
5087         RemoveField(x, y);
5088         DrawLevelField(x, y);
5089
5090         PlayLevelSound(newx, newy, SND_PENGUIN_PASSING);
5091         if (IN_SCR_FIELD(SCREENX(newx), SCREENY(newy)))
5092           DrawGraphicThruMask(SCREENX(newx),SCREENY(newy), el2img(element), 0);
5093
5094         local_player->friends_still_needed--;
5095         if (!local_player->friends_still_needed &&
5096             !local_player->GameOver && AllPlayersGone)
5097           local_player->LevelSolved = local_player->GameOver = TRUE;
5098
5099         return;
5100       }
5101       else if (IS_FOOD_PENGUIN(Feld[newx][newy]))
5102       {
5103         if (DigField(local_player, x, y, newx, newy, 0,0, DF_DIG) == MF_MOVING)
5104           DrawLevelField(newx, newy);
5105         else
5106           GfxDir[x][y] = MovDir[x][y] = MV_NO_MOVING;
5107       }
5108       else if (!IS_FREE(newx, newy))
5109       {
5110         GfxAction[x][y] = ACTION_WAITING;
5111
5112         if (IS_PLAYER(x, y))
5113           DrawPlayerField(x, y);
5114         else
5115           DrawLevelField(x, y);
5116
5117         return;
5118       }
5119     }
5120     else if (element == EL_PIG && IN_LEV_FIELD(newx, newy))
5121     {
5122       if (IS_FOOD_PIG(Feld[newx][newy]))
5123       {
5124         if (IS_MOVING(newx, newy))
5125           RemoveMovingField(newx, newy);
5126         else
5127         {
5128           Feld[newx][newy] = EL_EMPTY;
5129           DrawLevelField(newx, newy);
5130         }
5131
5132         PlayLevelSound(x, y, SND_PIG_DIGGING);
5133       }
5134       else if (!IS_FREE(newx, newy))
5135       {
5136         if (IS_PLAYER(x, y))
5137           DrawPlayerField(x, y);
5138         else
5139           DrawLevelField(x, y);
5140
5141         return;
5142       }
5143     }
5144     else if (IS_CUSTOM_ELEMENT(element) &&
5145              CUSTOM_ELEMENT_CAN_ENTER_FIELD(element, newx, newy))
5146     {
5147       int new_element = Feld[newx][newy];
5148
5149       if (!IS_FREE(newx, newy))
5150       {
5151         int action = (IS_DIGGABLE(new_element) ? ACTION_DIGGING :
5152                       IS_COLLECTIBLE(new_element) ? ACTION_COLLECTING :
5153                       ACTION_BREAKING);
5154
5155         /* no element can dig solid indestructible elements */
5156         if (IS_INDESTRUCTIBLE(new_element) &&
5157             !IS_DIGGABLE(new_element) &&
5158             !IS_COLLECTIBLE(new_element))
5159           return;
5160
5161         if (AmoebaNr[newx][newy] &&
5162             (new_element == EL_AMOEBA_FULL ||
5163              new_element == EL_BD_AMOEBA ||
5164              new_element == EL_AMOEBA_GROWING))
5165         {
5166           AmoebaCnt[AmoebaNr[newx][newy]]--;
5167           AmoebaCnt2[AmoebaNr[newx][newy]]--;
5168         }
5169
5170         if (IS_MOVING(newx, newy))
5171           RemoveMovingField(newx, newy);
5172         else
5173         {
5174           RemoveField(newx, newy);
5175           DrawLevelField(newx, newy);
5176         }
5177
5178         /* if digged element was about to explode, prevent the explosion */
5179         ExplodeField[newx][newy] = EX_TYPE_NONE;
5180
5181         PlayLevelSoundAction(x, y, action);
5182       }
5183
5184       Store[newx][newy] = EL_EMPTY;
5185       if (IS_EQUAL_OR_IN_GROUP(new_element, MOVE_ENTER_EL(element)))
5186       {
5187         int move_leave_element = element_info[element].move_leave_element;
5188
5189         /* this makes it possible to leave the removed element again */
5190         Store[newx][newy] = (move_leave_element == EL_TRIGGER_ELEMENT ?
5191                              new_element : move_leave_element);
5192       }
5193
5194       if (move_pattern & MV_MAZE_RUNNER_STYLE)
5195       {
5196         RunnerVisit[x][y] = FrameCounter;
5197         PlayerVisit[x][y] /= 8;         /* expire player visit path */
5198       }
5199     }
5200     else if (element == EL_DRAGON && IN_LEV_FIELD(newx, newy))
5201     {
5202       if (!IS_FREE(newx, newy))
5203       {
5204         if (IS_PLAYER(x, y))
5205           DrawPlayerField(x, y);
5206         else
5207           DrawLevelField(x, y);
5208
5209         return;
5210       }
5211       else
5212       {
5213         boolean wanna_flame = !RND(10);
5214         int dx = newx - x, dy = newy - y;
5215         int newx1 = newx + 1 * dx, newy1 = newy + 1 * dy;
5216         int newx2 = newx + 2 * dx, newy2 = newy + 2 * dy;
5217         int element1 = (IN_LEV_FIELD(newx1, newy1) ?
5218                         MovingOrBlocked2Element(newx1, newy1) : EL_STEELWALL);
5219         int element2 = (IN_LEV_FIELD(newx2, newy2) ?
5220                         MovingOrBlocked2Element(newx2, newy2) : EL_STEELWALL);
5221
5222         if ((wanna_flame ||
5223              IS_CLASSIC_ENEMY(element1) ||
5224              IS_CLASSIC_ENEMY(element2)) &&
5225             element1 != EL_DRAGON && element2 != EL_DRAGON &&
5226             element1 != EL_FLAMES && element2 != EL_FLAMES)
5227         {
5228           ResetGfxAnimation(x, y);
5229           GfxAction[x][y] = ACTION_ATTACKING;
5230
5231           if (IS_PLAYER(x, y))
5232             DrawPlayerField(x, y);
5233           else
5234             DrawLevelField(x, y);
5235
5236           PlayLevelSound(x, y, SND_DRAGON_ATTACKING);
5237
5238           MovDelay[x][y] = 50;
5239
5240           /* !!! */
5241 #if 0
5242           RemoveField(newx, newy);
5243 #endif
5244           Feld[newx][newy] = EL_FLAMES;
5245           if (IN_LEV_FIELD(newx1, newy1) && Feld[newx1][newy1] == EL_EMPTY)
5246           {
5247 #if 0
5248             RemoveField(newx1, newy1);
5249 #endif
5250             Feld[newx1][newy1] = EL_FLAMES;
5251           }
5252           if (IN_LEV_FIELD(newx2, newy2) && Feld[newx2][newy2] == EL_EMPTY)
5253           {
5254 #if 0
5255             RemoveField(newx2, newy2);
5256 #endif
5257             Feld[newx2][newy2] = EL_FLAMES;
5258           }
5259
5260           return;
5261         }
5262       }
5263     }
5264     else if (element == EL_YAMYAM && IN_LEV_FIELD(newx, newy) &&
5265              Feld[newx][newy] == EL_DIAMOND)
5266     {
5267       if (IS_MOVING(newx, newy))
5268         RemoveMovingField(newx, newy);
5269       else
5270       {
5271         Feld[newx][newy] = EL_EMPTY;
5272         DrawLevelField(newx, newy);
5273       }
5274
5275       PlayLevelSound(x, y, SND_YAMYAM_DIGGING);
5276     }
5277     else if (element == EL_DARK_YAMYAM && IN_LEV_FIELD(newx, newy) &&
5278              IS_FOOD_DARK_YAMYAM(Feld[newx][newy]))
5279     {
5280       if (AmoebaNr[newx][newy])
5281       {
5282         AmoebaCnt2[AmoebaNr[newx][newy]]--;
5283         if (Feld[newx][newy] == EL_AMOEBA_FULL ||
5284             Feld[newx][newy] == EL_BD_AMOEBA)
5285           AmoebaCnt[AmoebaNr[newx][newy]]--;
5286       }
5287
5288 #if 0
5289       /* !!! test !!! */
5290       if (IS_MOVING(newx, newy) || IS_BLOCKED(newx, newy))
5291       {
5292         RemoveMovingField(newx, newy);
5293       }
5294 #else
5295       if (IS_MOVING(newx, newy))
5296       {
5297         RemoveMovingField(newx, newy);
5298       }
5299 #endif
5300       else
5301       {
5302         Feld[newx][newy] = EL_EMPTY;
5303         DrawLevelField(newx, newy);
5304       }
5305
5306       PlayLevelSound(x, y, SND_DARK_YAMYAM_DIGGING);
5307     }
5308     else if ((element == EL_PACMAN || element == EL_MOLE)
5309              && IN_LEV_FIELD(newx, newy) && IS_AMOEBOID(Feld[newx][newy]))
5310     {
5311       if (AmoebaNr[newx][newy])
5312       {
5313         AmoebaCnt2[AmoebaNr[newx][newy]]--;
5314         if (Feld[newx][newy] == EL_AMOEBA_FULL ||
5315             Feld[newx][newy] == EL_BD_AMOEBA)
5316           AmoebaCnt[AmoebaNr[newx][newy]]--;
5317       }
5318
5319       if (element == EL_MOLE)
5320       {
5321         Feld[newx][newy] = EL_AMOEBA_SHRINKING;
5322         PlayLevelSound(x, y, SND_MOLE_DIGGING);
5323
5324         ResetGfxAnimation(x, y);
5325         GfxAction[x][y] = ACTION_DIGGING;
5326         DrawLevelField(x, y);
5327
5328         MovDelay[newx][newy] = 0;       /* start amoeba shrinking delay */
5329
5330         return;                         /* wait for shrinking amoeba */
5331       }
5332       else      /* element == EL_PACMAN */
5333       {
5334         Feld[newx][newy] = EL_EMPTY;
5335         DrawLevelField(newx, newy);
5336         PlayLevelSound(x, y, SND_PACMAN_DIGGING);
5337       }
5338     }
5339     else if (element == EL_MOLE && IN_LEV_FIELD(newx, newy) &&
5340              (Feld[newx][newy] == EL_AMOEBA_SHRINKING ||
5341               (Feld[newx][newy] == EL_EMPTY && Stop[newx][newy])))
5342     {
5343       /* wait for shrinking amoeba to completely disappear */
5344       return;
5345     }
5346     else if (!IN_LEV_FIELD(newx, newy) || !IS_FREE(newx, newy))
5347     {
5348       /* object was running against a wall */
5349
5350       TurnRound(x, y);
5351
5352 #if 0
5353       /* !!! NEW "CE_BLOCKED" STUFF !!! -- DOES NOT WORK YET... !!! */
5354       if (move_pattern & MV_ANY_DIRECTION &&
5355           move_pattern == MovDir[x][y])
5356       {
5357         int blocking_element =
5358           (IN_LEV_FIELD(newx, newy) ? Feld[newx][newy] : BorderElement);
5359
5360         CheckElementChangeBySide(x, y, element, blocking_element, CE_BLOCKED,
5361                                  MovDir[x][y]);
5362
5363         element = Feld[x][y];   /* element might have changed */
5364       }
5365 #endif
5366
5367       if (GFX_ELEMENT(element) != EL_SAND)     /* !!! FIX THIS (crumble) !!! */
5368         DrawLevelElementAnimation(x, y, element);
5369
5370       if (DONT_TOUCH(element))
5371         TestIfBadThingTouchesPlayer(x, y);
5372
5373       return;
5374     }
5375
5376     InitMovingField(x, y, MovDir[x][y]);
5377
5378     PlayLevelSoundAction(x, y, ACTION_MOVING);
5379   }
5380
5381   if (MovDir[x][y])
5382     ContinueMoving(x, y);
5383 }
5384
5385 void ContinueMoving(int x, int y)
5386 {
5387   int element = Feld[x][y];
5388   int stored = Store[x][y];
5389   struct ElementInfo *ei = &element_info[element];
5390   int direction = MovDir[x][y];
5391   int dx = (direction == MV_LEFT ? -1 : direction == MV_RIGHT ? +1 : 0);
5392   int dy = (direction == MV_UP   ? -1 : direction == MV_DOWN  ? +1 : 0);
5393   int newx = x + dx, newy = y + dy;
5394   boolean pushed_by_player   = (Pushed[x][y] && IS_PLAYER(x, y));
5395   boolean pushed_by_conveyor = (Pushed[x][y] && !IS_PLAYER(x, y));
5396   boolean last_line = (newy == lev_fieldy - 1);
5397
5398   MovPos[x][y] += getElementMoveStepsize(x, y);
5399
5400   if (pushed_by_player) /* special case: moving object pushed by player */
5401     MovPos[x][y] = SIGN(MovPos[x][y]) * (TILEX - ABS(PLAYERINFO(x,y)->MovPos));
5402
5403   if (ABS(MovPos[x][y]) < TILEX)
5404   {
5405     DrawLevelField(x, y);
5406
5407     return;     /* element is still moving */
5408   }
5409
5410   /* element reached destination field */
5411
5412   Feld[x][y] = EL_EMPTY;
5413   Feld[newx][newy] = element;
5414   MovPos[x][y] = 0;     /* force "not moving" for "crumbled sand" */
5415
5416   if (Store[x][y] == EL_ACID)   /* element is moving into acid pool */
5417   {
5418     element = Feld[newx][newy] = EL_ACID;
5419   }
5420   else if (element == EL_MOLE)
5421   {
5422     Feld[x][y] = EL_SAND;
5423
5424     DrawLevelFieldCrumbledSandNeighbours(x, y);
5425   }
5426   else if (element == EL_QUICKSAND_FILLING)
5427   {
5428     element = Feld[newx][newy] = get_next_element(element);
5429     Store[newx][newy] = Store[x][y];
5430   }
5431   else if (element == EL_QUICKSAND_EMPTYING)
5432   {
5433     Feld[x][y] = get_next_element(element);
5434     element = Feld[newx][newy] = Store[x][y];
5435   }
5436   else if (element == EL_MAGIC_WALL_FILLING)
5437   {
5438     element = Feld[newx][newy] = get_next_element(element);
5439     if (!game.magic_wall_active)
5440       element = Feld[newx][newy] = EL_MAGIC_WALL_DEAD;
5441     Store[newx][newy] = Store[x][y];
5442   }
5443   else if (element == EL_MAGIC_WALL_EMPTYING)
5444   {
5445     Feld[x][y] = get_next_element(element);
5446     if (!game.magic_wall_active)
5447       Feld[x][y] = EL_MAGIC_WALL_DEAD;
5448     element = Feld[newx][newy] = Store[x][y];
5449
5450 #if USE_NEW_COLLECT_COUNT
5451     InitField(newx, newy, FALSE);
5452 #endif
5453   }
5454   else if (element == EL_BD_MAGIC_WALL_FILLING)
5455   {
5456     element = Feld[newx][newy] = get_next_element(element);
5457     if (!game.magic_wall_active)
5458       element = Feld[newx][newy] = EL_BD_MAGIC_WALL_DEAD;
5459     Store[newx][newy] = Store[x][y];
5460   }
5461   else if (element == EL_BD_MAGIC_WALL_EMPTYING)
5462   {
5463     Feld[x][y] = get_next_element(element);
5464     if (!game.magic_wall_active)
5465       Feld[x][y] = EL_BD_MAGIC_WALL_DEAD;
5466     element = Feld[newx][newy] = Store[x][y];
5467
5468 #if USE_NEW_COLLECT_COUNT
5469     InitField(newx, newy, FALSE);
5470 #endif
5471   }
5472   else if (element == EL_AMOEBA_DROPPING)
5473   {
5474     Feld[x][y] = get_next_element(element);
5475     element = Feld[newx][newy] = Store[x][y];
5476   }
5477   else if (element == EL_SOKOBAN_OBJECT)
5478   {
5479     if (Back[x][y])
5480       Feld[x][y] = Back[x][y];
5481
5482     if (Back[newx][newy])
5483       Feld[newx][newy] = EL_SOKOBAN_FIELD_FULL;
5484
5485     Back[x][y] = Back[newx][newy] = 0;
5486   }
5487
5488   Store[x][y] = EL_EMPTY;
5489   MovPos[x][y] = 0;
5490   MovDir[x][y] = 0;
5491   MovDelay[x][y] = 0;
5492
5493   MovDelay[newx][newy] = 0;
5494
5495   if (CAN_CHANGE(element))
5496   {
5497     /* copy element change control values to new field */
5498     ChangeDelay[newx][newy] = ChangeDelay[x][y];
5499     ChangePage[newx][newy]  = ChangePage[x][y];
5500     Changed[newx][newy]     = Changed[x][y];
5501     ChangeEvent[newx][newy] = ChangeEvent[x][y];
5502
5503 #if USE_NEW_COLLECT_COUNT
5504     Count[newx][newy] = Count[x][y];
5505 #endif
5506   }
5507
5508   ChangeDelay[x][y] = 0;
5509   ChangePage[x][y] = -1;
5510   Changed[x][y] = FALSE;
5511   ChangeEvent[x][y] = -1;
5512
5513 #if USE_NEW_COLLECT_COUNT
5514   Count[x][y] = 0;
5515 #endif
5516
5517   /* copy animation control values to new field */
5518   GfxFrame[newx][newy]  = GfxFrame[x][y];
5519   GfxRandom[newx][newy] = GfxRandom[x][y];      /* keep same random value */
5520   GfxAction[newx][newy] = GfxAction[x][y];      /* keep action one frame  */
5521   GfxDir[newx][newy]    = GfxDir[x][y];         /* keep element direction */
5522
5523   Pushed[x][y] = Pushed[newx][newy] = FALSE;
5524
5525   /* some elements can leave other elements behind after moving */
5526   if (IS_CUSTOM_ELEMENT(element) && ei->move_leave_element != EL_EMPTY &&
5527       (ei->move_leave_type == LEAVE_TYPE_UNLIMITED || stored != EL_EMPTY) &&
5528       (!IS_PLAYER(x, y) || IS_WALKABLE(ei->move_leave_element)))
5529   {
5530     int move_leave_element = ei->move_leave_element;
5531
5532     /* this makes it possible to leave the removed element again */
5533     if (ei->move_leave_type == LEAVE_TYPE_LIMITED &&
5534         ei->move_leave_element == EL_TRIGGER_ELEMENT)
5535       move_leave_element = stored;
5536
5537     Feld[x][y] = move_leave_element;
5538
5539     if (element_info[Feld[x][y]].move_direction_initial == MV_START_PREVIOUS)
5540       MovDir[x][y] = direction;
5541
5542     InitField(x, y, FALSE);
5543
5544     if (GFX_CRUMBLED(Feld[x][y]))
5545       DrawLevelFieldCrumbledSandNeighbours(x, y);
5546
5547     if (ELEM_IS_PLAYER(move_leave_element))
5548       RelocatePlayer(x, y, move_leave_element);
5549   }
5550
5551   /* do this after checking for left-behind element */
5552   ResetGfxAnimation(x, y);      /* reset animation values for old field */
5553
5554   if (!CAN_MOVE(element) ||
5555       (CAN_FALL(element) && direction == MV_DOWN &&
5556        (element == EL_SPRING ||
5557         element_info[element].move_pattern == MV_WHEN_PUSHED ||
5558         element_info[element].move_pattern == MV_WHEN_DROPPED)))
5559     GfxDir[x][y] = MovDir[newx][newy] = 0;
5560
5561   DrawLevelField(x, y);
5562   DrawLevelField(newx, newy);
5563
5564   Stop[newx][newy] = TRUE;      /* ignore this element until the next frame */
5565
5566   /* prevent pushed element from moving on in pushed direction */
5567   if (pushed_by_player && CAN_MOVE(element) &&
5568       element_info[element].move_pattern & MV_ANY_DIRECTION &&
5569       !(element_info[element].move_pattern & direction))
5570     TurnRound(newx, newy);
5571
5572   /* prevent elements on conveyor belt from moving on in last direction */
5573   if (pushed_by_conveyor && CAN_FALL(element) &&
5574       direction & MV_HORIZONTAL)
5575     MovDir[newx][newy] = 0;
5576
5577   if (!pushed_by_player)
5578   {
5579     int nextx = newx + dx, nexty = newy + dy;
5580     boolean check_collision_again = IN_LEV_FIELD_AND_IS_FREE(nextx, nexty);
5581
5582     WasJustMoving[newx][newy] = 3;
5583
5584     if (CAN_FALL(element) && direction == MV_DOWN)
5585       WasJustFalling[newx][newy] = 3;
5586
5587     if ((!CAN_FALL(element) || direction == MV_DOWN) && check_collision_again)
5588       CheckCollision[newx][newy] = 2;
5589   }
5590
5591   if (DONT_TOUCH(element))      /* object may be nasty to player or others */
5592   {
5593     TestIfBadThingTouchesPlayer(newx, newy);
5594     TestIfBadThingTouchesFriend(newx, newy);
5595
5596     if (!IS_CUSTOM_ELEMENT(element))
5597       TestIfBadThingTouchesOtherBadThing(newx, newy);
5598   }
5599   else if (element == EL_PENGUIN)
5600     TestIfFriendTouchesBadThing(newx, newy);
5601
5602   /* give the player one last chance (one more frame) to move away */
5603   if (CAN_FALL(element) && direction == MV_DOWN &&
5604       (last_line || (!IS_FREE(x, newy + 1) &&
5605                      (!IS_PLAYER(x, newy + 1) ||
5606                       game.engine_version < VERSION_IDENT(3,1,1,0)))))
5607     Impact(x, newy);
5608
5609   if (pushed_by_player && !game.use_change_when_pushing_bug)
5610   {
5611     int dig_side = MV_DIR_OPPOSITE(direction);
5612     struct PlayerInfo *player = PLAYERINFO(x, y);
5613
5614     CheckElementChangeByPlayer(newx, newy, element, CE_PUSHED_BY_PLAYER,
5615                                player->index_bit, dig_side);
5616     CheckTriggeredElementChangeByPlayer(element, CE_PLAYER_PUSHES_X,
5617                                         player->index_bit, dig_side);
5618   }
5619
5620   TestIfElementTouchesCustomElement(x, y);      /* empty or new element */
5621
5622   TestIfElementHitsCustomElement(newx, newy, direction);
5623   TestIfPlayerTouchesCustomElement(newx, newy);
5624   TestIfElementTouchesCustomElement(newx, newy);
5625 }
5626
5627 int AmoebeNachbarNr(int ax, int ay)
5628 {
5629   int i;
5630   int element = Feld[ax][ay];
5631   int group_nr = 0;
5632   static int xy[4][2] =
5633   {
5634     { 0, -1 },
5635     { -1, 0 },
5636     { +1, 0 },
5637     { 0, +1 }
5638   };
5639
5640   for (i = 0; i < NUM_DIRECTIONS; i++)
5641   {
5642     int x = ax + xy[i][0];
5643     int y = ay + xy[i][1];
5644
5645     if (!IN_LEV_FIELD(x, y))
5646       continue;
5647
5648     if (Feld[x][y] == element && AmoebaNr[x][y] > 0)
5649       group_nr = AmoebaNr[x][y];
5650   }
5651
5652   return group_nr;
5653 }
5654
5655 void AmoebenVereinigen(int ax, int ay)
5656 {
5657   int i, x, y, xx, yy;
5658   int new_group_nr = AmoebaNr[ax][ay];
5659   static int xy[4][2] =
5660   {
5661     { 0, -1 },
5662     { -1, 0 },
5663     { +1, 0 },
5664     { 0, +1 }
5665   };
5666
5667   if (new_group_nr == 0)
5668     return;
5669
5670   for (i = 0; i < NUM_DIRECTIONS; i++)
5671   {
5672     x = ax + xy[i][0];
5673     y = ay + xy[i][1];
5674
5675     if (!IN_LEV_FIELD(x, y))
5676       continue;
5677
5678     if ((Feld[x][y] == EL_AMOEBA_FULL ||
5679          Feld[x][y] == EL_BD_AMOEBA ||
5680          Feld[x][y] == EL_AMOEBA_DEAD) &&
5681         AmoebaNr[x][y] != new_group_nr)
5682     {
5683       int old_group_nr = AmoebaNr[x][y];
5684
5685       if (old_group_nr == 0)
5686         return;
5687
5688       AmoebaCnt[new_group_nr] += AmoebaCnt[old_group_nr];
5689       AmoebaCnt[old_group_nr] = 0;
5690       AmoebaCnt2[new_group_nr] += AmoebaCnt2[old_group_nr];
5691       AmoebaCnt2[old_group_nr] = 0;
5692
5693       for (yy = 0; yy < lev_fieldy; yy++)
5694       {
5695         for (xx = 0; xx < lev_fieldx; xx++)
5696         {
5697           if (AmoebaNr[xx][yy] == old_group_nr)
5698             AmoebaNr[xx][yy] = new_group_nr;
5699         }
5700       }
5701     }
5702   }
5703 }
5704
5705 void AmoebeUmwandeln(int ax, int ay)
5706 {
5707   int i, x, y;
5708
5709   if (Feld[ax][ay] == EL_AMOEBA_DEAD)
5710   {
5711     int group_nr = AmoebaNr[ax][ay];
5712
5713 #ifdef DEBUG
5714     if (group_nr == 0)
5715     {
5716       printf("AmoebeUmwandeln(): ax = %d, ay = %d\n", ax, ay);
5717       printf("AmoebeUmwandeln(): This should never happen!\n");
5718       return;
5719     }
5720 #endif
5721
5722     for (y = 0; y < lev_fieldy; y++)
5723     {
5724       for (x = 0; x < lev_fieldx; x++)
5725       {
5726         if (Feld[x][y] == EL_AMOEBA_DEAD && AmoebaNr[x][y] == group_nr)
5727         {
5728           AmoebaNr[x][y] = 0;
5729           Feld[x][y] = EL_AMOEBA_TO_DIAMOND;
5730         }
5731       }
5732     }
5733     PlayLevelSound(ax, ay, (IS_GEM(level.amoeba_content) ?
5734                             SND_AMOEBA_TURNING_TO_GEM :
5735                             SND_AMOEBA_TURNING_TO_ROCK));
5736     Bang(ax, ay);
5737   }
5738   else
5739   {
5740     static int xy[4][2] =
5741     {
5742       { 0, -1 },
5743       { -1, 0 },
5744       { +1, 0 },
5745       { 0, +1 }
5746     };
5747
5748     for (i = 0; i < NUM_DIRECTIONS; i++)
5749     {
5750       x = ax + xy[i][0];
5751       y = ay + xy[i][1];
5752
5753       if (!IN_LEV_FIELD(x, y))
5754         continue;
5755
5756       if (Feld[x][y] == EL_AMOEBA_TO_DIAMOND)
5757       {
5758         PlayLevelSound(x, y, (IS_GEM(level.amoeba_content) ?
5759                               SND_AMOEBA_TURNING_TO_GEM :
5760                               SND_AMOEBA_TURNING_TO_ROCK));
5761         Bang(x, y);
5762       }
5763     }
5764   }
5765 }
5766
5767 void AmoebeUmwandelnBD(int ax, int ay, int new_element)
5768 {
5769   int x, y;
5770   int group_nr = AmoebaNr[ax][ay];
5771   boolean done = FALSE;
5772
5773 #ifdef DEBUG
5774   if (group_nr == 0)
5775   {
5776     printf("AmoebeUmwandelnBD(): ax = %d, ay = %d\n", ax, ay);
5777     printf("AmoebeUmwandelnBD(): This should never happen!\n");
5778     return;
5779   }
5780 #endif
5781
5782   for (y = 0; y < lev_fieldy; y++)
5783   {
5784     for (x = 0; x < lev_fieldx; x++)
5785     {
5786       if (AmoebaNr[x][y] == group_nr &&
5787           (Feld[x][y] == EL_AMOEBA_DEAD ||
5788            Feld[x][y] == EL_BD_AMOEBA ||
5789            Feld[x][y] == EL_AMOEBA_GROWING))
5790       {
5791         AmoebaNr[x][y] = 0;
5792         Feld[x][y] = new_element;
5793         InitField(x, y, FALSE);
5794         DrawLevelField(x, y);
5795         done = TRUE;
5796       }
5797     }
5798   }
5799
5800   if (done)
5801     PlayLevelSound(ax, ay, (new_element == EL_BD_ROCK ?
5802                             SND_BD_AMOEBA_TURNING_TO_ROCK :
5803                             SND_BD_AMOEBA_TURNING_TO_GEM));
5804 }
5805
5806 void AmoebeWaechst(int x, int y)
5807 {
5808   static unsigned long sound_delay = 0;
5809   static unsigned long sound_delay_value = 0;
5810
5811   if (!MovDelay[x][y])          /* start new growing cycle */
5812   {
5813     MovDelay[x][y] = 7;
5814
5815     if (DelayReached(&sound_delay, sound_delay_value))
5816     {
5817       PlayLevelSoundElementAction(x, y, Store[x][y], ACTION_GROWING);
5818       sound_delay_value = 30;
5819     }
5820   }
5821
5822   if (MovDelay[x][y])           /* wait some time before growing bigger */
5823   {
5824     MovDelay[x][y]--;
5825     if (MovDelay[x][y]/2 && IN_SCR_FIELD(SCREENX(x), SCREENY(y)))
5826     {
5827       int frame = getGraphicAnimationFrame(IMG_AMOEBA_GROWING,
5828                                            6 - MovDelay[x][y]);
5829
5830       DrawGraphic(SCREENX(x), SCREENY(y), IMG_AMOEBA_GROWING, frame);
5831     }
5832
5833     if (!MovDelay[x][y])
5834     {
5835       Feld[x][y] = Store[x][y];
5836       Store[x][y] = 0;
5837       DrawLevelField(x, y);
5838     }
5839   }
5840 }
5841
5842 void AmoebaDisappearing(int x, int y)
5843 {
5844   static unsigned long sound_delay = 0;
5845   static unsigned long sound_delay_value = 0;
5846
5847   if (!MovDelay[x][y])          /* start new shrinking cycle */
5848   {
5849     MovDelay[x][y] = 7;
5850
5851     if (DelayReached(&sound_delay, sound_delay_value))
5852       sound_delay_value = 30;
5853   }
5854
5855   if (MovDelay[x][y])           /* wait some time before shrinking */
5856   {
5857     MovDelay[x][y]--;
5858     if (MovDelay[x][y]/2 && IN_SCR_FIELD(SCREENX(x), SCREENY(y)))
5859     {
5860       int frame = getGraphicAnimationFrame(IMG_AMOEBA_SHRINKING,
5861                                            6 - MovDelay[x][y]);
5862
5863       DrawGraphic(SCREENX(x), SCREENY(y), IMG_AMOEBA_SHRINKING, frame);
5864     }
5865
5866     if (!MovDelay[x][y])
5867     {
5868       Feld[x][y] = EL_EMPTY;
5869       DrawLevelField(x, y);
5870
5871       /* don't let mole enter this field in this cycle;
5872          (give priority to objects falling to this field from above) */
5873       Stop[x][y] = TRUE;
5874     }
5875   }
5876 }
5877
5878 void AmoebeAbleger(int ax, int ay)
5879 {
5880   int i;
5881   int element = Feld[ax][ay];
5882   int graphic = el2img(element);
5883   int newax = ax, neway = ay;
5884   static int xy[4][2] =
5885   {
5886     { 0, -1 },
5887     { -1, 0 },
5888     { +1, 0 },
5889     { 0, +1 }
5890   };
5891
5892   if (!level.amoeba_speed)
5893   {
5894     Feld[ax][ay] = EL_AMOEBA_DEAD;
5895     DrawLevelField(ax, ay);
5896     return;
5897   }
5898
5899   if (IS_ANIMATED(graphic))
5900     DrawLevelGraphicAnimationIfNeeded(ax, ay, graphic);
5901
5902   if (!MovDelay[ax][ay])        /* start making new amoeba field */
5903     MovDelay[ax][ay] = RND(FRAMES_PER_SECOND * 25 / (1 + level.amoeba_speed));
5904
5905   if (MovDelay[ax][ay])         /* wait some time before making new amoeba */
5906   {
5907     MovDelay[ax][ay]--;
5908     if (MovDelay[ax][ay])
5909       return;
5910   }
5911
5912   if (element == EL_AMOEBA_WET) /* object is an acid / amoeba drop */
5913   {
5914     int start = RND(4);
5915     int x = ax + xy[start][0];
5916     int y = ay + xy[start][1];
5917
5918     if (!IN_LEV_FIELD(x, y))
5919       return;
5920
5921     if (IS_FREE(x, y) ||
5922         CAN_GROW_INTO(Feld[x][y]) ||
5923         Feld[x][y] == EL_QUICKSAND_EMPTY)
5924     {
5925       newax = x;
5926       neway = y;
5927     }
5928
5929     if (newax == ax && neway == ay)
5930       return;
5931   }
5932   else                          /* normal or "filled" (BD style) amoeba */
5933   {
5934     int start = RND(4);
5935     boolean waiting_for_player = FALSE;
5936
5937     for (i = 0; i < NUM_DIRECTIONS; i++)
5938     {
5939       int j = (start + i) % 4;
5940       int x = ax + xy[j][0];
5941       int y = ay + xy[j][1];
5942
5943       if (!IN_LEV_FIELD(x, y))
5944         continue;
5945
5946       if (IS_FREE(x, y) ||
5947           CAN_GROW_INTO(Feld[x][y]) ||
5948           Feld[x][y] == EL_QUICKSAND_EMPTY)
5949       {
5950         newax = x;
5951         neway = y;
5952         break;
5953       }
5954       else if (IS_PLAYER(x, y))
5955         waiting_for_player = TRUE;
5956     }
5957
5958     if (newax == ax && neway == ay)             /* amoeba cannot grow */
5959     {
5960       if (i == 4 && (!waiting_for_player || element == EL_BD_AMOEBA))
5961       {
5962         Feld[ax][ay] = EL_AMOEBA_DEAD;
5963         DrawLevelField(ax, ay);
5964         AmoebaCnt[AmoebaNr[ax][ay]]--;
5965
5966         if (AmoebaCnt[AmoebaNr[ax][ay]] <= 0)   /* amoeba is completely dead */
5967         {
5968           if (element == EL_AMOEBA_FULL)
5969             AmoebeUmwandeln(ax, ay);
5970           else if (element == EL_BD_AMOEBA)
5971             AmoebeUmwandelnBD(ax, ay, level.amoeba_content);
5972         }
5973       }
5974       return;
5975     }
5976     else if (element == EL_AMOEBA_FULL || element == EL_BD_AMOEBA)
5977     {
5978       /* amoeba gets larger by growing in some direction */
5979
5980       int new_group_nr = AmoebaNr[ax][ay];
5981
5982 #ifdef DEBUG
5983   if (new_group_nr == 0)
5984   {
5985     printf("AmoebeAbleger(): newax = %d, neway = %d\n", newax, neway);
5986     printf("AmoebeAbleger(): This should never happen!\n");
5987     return;
5988   }
5989 #endif
5990
5991       AmoebaNr[newax][neway] = new_group_nr;
5992       AmoebaCnt[new_group_nr]++;
5993       AmoebaCnt2[new_group_nr]++;
5994
5995       /* if amoeba touches other amoeba(s) after growing, unify them */
5996       AmoebenVereinigen(newax, neway);
5997
5998       if (element == EL_BD_AMOEBA && AmoebaCnt2[new_group_nr] >= 200)
5999       {
6000         AmoebeUmwandelnBD(newax, neway, EL_BD_ROCK);
6001         return;
6002       }
6003     }
6004   }
6005
6006   if (element != EL_AMOEBA_WET || neway < ay || !IS_FREE(newax, neway) ||
6007       (neway == lev_fieldy - 1 && newax != ax))
6008   {
6009     Feld[newax][neway] = EL_AMOEBA_GROWING;     /* creation of new amoeba */
6010     Store[newax][neway] = element;
6011   }
6012   else if (neway == ay)
6013   {
6014     Feld[newax][neway] = EL_AMOEBA_DROP;        /* drop left/right of amoeba */
6015
6016     PlayLevelSoundAction(newax, neway, ACTION_GROWING);
6017   }
6018   else
6019   {
6020     InitMovingField(ax, ay, MV_DOWN);           /* drop dripping from amoeba */
6021     Feld[ax][ay] = EL_AMOEBA_DROPPING;
6022     Store[ax][ay] = EL_AMOEBA_DROP;
6023     ContinueMoving(ax, ay);
6024     return;
6025   }
6026
6027   DrawLevelField(newax, neway);
6028 }
6029
6030 void Life(int ax, int ay)
6031 {
6032   int x1, y1, x2, y2;
6033   static int life[4] = { 2, 3, 3, 3 };  /* parameters for "game of life" */
6034   int life_time = 40;
6035   int element = Feld[ax][ay];
6036   int graphic = el2img(element);
6037   boolean changed = FALSE;
6038
6039   if (IS_ANIMATED(graphic))
6040     DrawLevelGraphicAnimationIfNeeded(ax, ay, graphic);
6041
6042   if (Stop[ax][ay])
6043     return;
6044
6045   if (!MovDelay[ax][ay])        /* start new "game of life" cycle */
6046     MovDelay[ax][ay] = life_time;
6047
6048   if (MovDelay[ax][ay])         /* wait some time before next cycle */
6049   {
6050     MovDelay[ax][ay]--;
6051     if (MovDelay[ax][ay])
6052       return;
6053   }
6054
6055   for (y1 = -1; y1 < 2; y1++) for (x1 = -1; x1 < 2; x1++)
6056   {
6057     int xx = ax+x1, yy = ay+y1;
6058     int nachbarn = 0;
6059
6060     if (!IN_LEV_FIELD(xx, yy))
6061       continue;
6062
6063     for (y2 = -1; y2 < 2; y2++) for (x2 = -1; x2 < 2; x2++)
6064     {
6065       int x = xx+x2, y = yy+y2;
6066
6067       if (!IN_LEV_FIELD(x, y) || (x == xx && y == yy))
6068         continue;
6069
6070       if (((Feld[x][y] == element ||
6071             (element == EL_GAME_OF_LIFE && IS_PLAYER(x, y))) &&
6072            !Stop[x][y]) ||
6073           (IS_FREE(x, y) && Stop[x][y]))
6074         nachbarn++;
6075     }
6076
6077     if (xx == ax && yy == ay)           /* field in the middle */
6078     {
6079       if (nachbarn < life[0] || nachbarn > life[1])
6080       {
6081         Feld[xx][yy] = EL_EMPTY;
6082         if (!Stop[xx][yy])
6083           DrawLevelField(xx, yy);
6084         Stop[xx][yy] = TRUE;
6085         changed = TRUE;
6086       }
6087     }
6088     else if (IS_FREE(xx, yy) || CAN_GROW_INTO(Feld[xx][yy]))
6089     {                                   /* free border field */
6090       if (nachbarn >= life[2] && nachbarn <= life[3])
6091       {
6092         Feld[xx][yy] = element;
6093         MovDelay[xx][yy] = (element == EL_GAME_OF_LIFE ? 0 : life_time-1);
6094         if (!Stop[xx][yy])
6095           DrawLevelField(xx, yy);
6096         Stop[xx][yy] = TRUE;
6097         changed = TRUE;
6098       }
6099     }
6100   }
6101
6102   if (changed)
6103     PlayLevelSound(ax, ay, element == EL_BIOMAZE ? SND_BIOMAZE_GROWING :
6104                    SND_GAME_OF_LIFE_GROWING);
6105 }
6106
6107 static void InitRobotWheel(int x, int y)
6108 {
6109   ChangeDelay[x][y] = level.time_wheel * FRAMES_PER_SECOND;
6110 }
6111
6112 static void RunRobotWheel(int x, int y)
6113 {
6114   PlayLevelSound(x, y, SND_ROBOT_WHEEL_ACTIVE);
6115 }
6116
6117 static void StopRobotWheel(int x, int y)
6118 {
6119   if (ZX == x && ZY == y)
6120     ZX = ZY = -1;
6121 }
6122
6123 static void InitTimegateWheel(int x, int y)
6124 {
6125   ChangeDelay[x][y] = level.time_timegate * FRAMES_PER_SECOND;
6126 }
6127
6128 static void RunTimegateWheel(int x, int y)
6129 {
6130   PlayLevelSound(x, y, SND_TIMEGATE_SWITCH_ACTIVE);
6131 }
6132
6133 void CheckExit(int x, int y)
6134 {
6135   if (local_player->gems_still_needed > 0 ||
6136       local_player->sokobanfields_still_needed > 0 ||
6137       local_player->lights_still_needed > 0)
6138   {
6139     int element = Feld[x][y];
6140     int graphic = el2img(element);
6141
6142     if (IS_ANIMATED(graphic))
6143       DrawLevelGraphicAnimationIfNeeded(x, y, graphic);
6144
6145     return;
6146   }
6147
6148   if (AllPlayersGone)   /* do not re-open exit door closed after last player */
6149     return;
6150
6151   Feld[x][y] = EL_EXIT_OPENING;
6152
6153   PlayLevelSoundNearest(x, y, SND_CLASS_EXIT_OPENING);
6154 }
6155
6156 void CheckExitSP(int x, int y)
6157 {
6158   if (local_player->gems_still_needed > 0)
6159   {
6160     int element = Feld[x][y];
6161     int graphic = el2img(element);
6162
6163     if (IS_ANIMATED(graphic))
6164       DrawLevelGraphicAnimationIfNeeded(x, y, graphic);
6165
6166     return;
6167   }
6168
6169   if (AllPlayersGone)   /* do not re-open exit door closed after last player */
6170     return;
6171
6172   Feld[x][y] = EL_SP_EXIT_OPENING;
6173
6174   PlayLevelSoundNearest(x, y, SND_CLASS_SP_EXIT_OPENING);
6175 }
6176
6177 static void CloseAllOpenTimegates()
6178 {
6179   int x, y;
6180
6181   for (y = 0; y < lev_fieldy; y++)
6182   {
6183     for (x = 0; x < lev_fieldx; x++)
6184     {
6185       int element = Feld[x][y];
6186
6187       if (element == EL_TIMEGATE_OPEN || element == EL_TIMEGATE_OPENING)
6188       {
6189         Feld[x][y] = EL_TIMEGATE_CLOSING;
6190
6191         PlayLevelSoundAction(x, y, ACTION_CLOSING);
6192       }
6193     }
6194   }
6195 }
6196
6197 void EdelsteinFunkeln(int x, int y)
6198 {
6199   if (!IN_SCR_FIELD(SCREENX(x), SCREENY(y)) || IS_MOVING(x, y))
6200     return;
6201
6202   if (Feld[x][y] == EL_BD_DIAMOND)
6203     return;
6204
6205   if (MovDelay[x][y] == 0)      /* next animation frame */
6206     MovDelay[x][y] = 11 * !SimpleRND(500);
6207
6208   if (MovDelay[x][y] != 0)      /* wait some time before next frame */
6209   {
6210     MovDelay[x][y]--;
6211
6212     if (setup.direct_draw && MovDelay[x][y])
6213       SetDrawtoField(DRAW_BUFFERED);
6214
6215     DrawLevelElementAnimation(x, y, Feld[x][y]);
6216
6217     if (MovDelay[x][y] != 0)
6218     {
6219       int frame = getGraphicAnimationFrame(IMG_TWINKLE_WHITE,
6220                                            10 - MovDelay[x][y]);
6221
6222       DrawGraphicThruMask(SCREENX(x), SCREENY(y), IMG_TWINKLE_WHITE, frame);
6223
6224       if (setup.direct_draw)
6225       {
6226         int dest_x, dest_y;
6227
6228         dest_x = FX + SCREENX(x) * TILEX;
6229         dest_y = FY + SCREENY(y) * TILEY;
6230
6231         BlitBitmap(drawto_field, window,
6232                    dest_x, dest_y, TILEX, TILEY, dest_x, dest_y);
6233         SetDrawtoField(DRAW_DIRECT);
6234       }
6235     }
6236   }
6237 }
6238
6239 void MauerWaechst(int x, int y)
6240 {
6241   int delay = 6;
6242
6243   if (!MovDelay[x][y])          /* next animation frame */
6244     MovDelay[x][y] = 3 * delay;
6245
6246   if (MovDelay[x][y])           /* wait some time before next frame */
6247   {
6248     MovDelay[x][y]--;
6249
6250     if (IN_SCR_FIELD(SCREENX(x), SCREENY(y)))
6251     {
6252       int graphic = el_dir2img(Feld[x][y], GfxDir[x][y]);
6253       int frame = getGraphicAnimationFrame(graphic, 17 - MovDelay[x][y]);
6254
6255       DrawGraphic(SCREENX(x), SCREENY(y), graphic, frame);
6256     }
6257
6258     if (!MovDelay[x][y])
6259     {
6260       if (MovDir[x][y] == MV_LEFT)
6261       {
6262         if (IN_LEV_FIELD(x - 1, y) && IS_WALL(Feld[x - 1][y]))
6263           DrawLevelField(x - 1, y);
6264       }
6265       else if (MovDir[x][y] == MV_RIGHT)
6266       {
6267         if (IN_LEV_FIELD(x + 1, y) && IS_WALL(Feld[x + 1][y]))
6268           DrawLevelField(x + 1, y);
6269       }
6270       else if (MovDir[x][y] == MV_UP)
6271       {
6272         if (IN_LEV_FIELD(x, y - 1) && IS_WALL(Feld[x][y - 1]))
6273           DrawLevelField(x, y - 1);
6274       }
6275       else
6276       {
6277         if (IN_LEV_FIELD(x, y + 1) && IS_WALL(Feld[x][y + 1]))
6278           DrawLevelField(x, y + 1);
6279       }
6280
6281       Feld[x][y] = Store[x][y];
6282       Store[x][y] = 0;
6283       GfxDir[x][y] = MovDir[x][y] = MV_NO_MOVING;
6284       DrawLevelField(x, y);
6285     }
6286   }
6287 }
6288
6289 void MauerAbleger(int ax, int ay)
6290 {
6291   int element = Feld[ax][ay];
6292   int graphic = el2img(element);
6293   boolean oben_frei = FALSE, unten_frei = FALSE;
6294   boolean links_frei = FALSE, rechts_frei = FALSE;
6295   boolean oben_massiv = FALSE, unten_massiv = FALSE;
6296   boolean links_massiv = FALSE, rechts_massiv = FALSE;
6297   boolean new_wall = FALSE;
6298
6299   if (IS_ANIMATED(graphic))
6300     DrawLevelGraphicAnimationIfNeeded(ax, ay, graphic);
6301
6302   if (!MovDelay[ax][ay])        /* start building new wall */
6303     MovDelay[ax][ay] = 6;
6304
6305   if (MovDelay[ax][ay])         /* wait some time before building new wall */
6306   {
6307     MovDelay[ax][ay]--;
6308     if (MovDelay[ax][ay])
6309       return;
6310   }
6311
6312   if (IN_LEV_FIELD(ax, ay-1) && IS_FREE(ax, ay-1))
6313     oben_frei = TRUE;
6314   if (IN_LEV_FIELD(ax, ay+1) && IS_FREE(ax, ay+1))
6315     unten_frei = TRUE;
6316   if (IN_LEV_FIELD(ax-1, ay) && IS_FREE(ax-1, ay))
6317     links_frei = TRUE;
6318   if (IN_LEV_FIELD(ax+1, ay) && IS_FREE(ax+1, ay))
6319     rechts_frei = TRUE;
6320
6321   if (element == EL_EXPANDABLE_WALL_VERTICAL ||
6322       element == EL_EXPANDABLE_WALL_ANY)
6323   {
6324     if (oben_frei)
6325     {
6326       Feld[ax][ay-1] = EL_EXPANDABLE_WALL_GROWING;
6327       Store[ax][ay-1] = element;
6328       GfxDir[ax][ay-1] = MovDir[ax][ay-1] = MV_UP;
6329       if (IN_SCR_FIELD(SCREENX(ax), SCREENY(ay-1)))
6330         DrawGraphic(SCREENX(ax), SCREENY(ay - 1),
6331                     IMG_EXPANDABLE_WALL_GROWING_UP, 0);
6332       new_wall = TRUE;
6333     }
6334     if (unten_frei)
6335     {
6336       Feld[ax][ay+1] = EL_EXPANDABLE_WALL_GROWING;
6337       Store[ax][ay+1] = element;
6338       GfxDir[ax][ay+1] = MovDir[ax][ay+1] = MV_DOWN;
6339       if (IN_SCR_FIELD(SCREENX(ax), SCREENY(ay+1)))
6340         DrawGraphic(SCREENX(ax), SCREENY(ay + 1),
6341                     IMG_EXPANDABLE_WALL_GROWING_DOWN, 0);
6342       new_wall = TRUE;
6343     }
6344   }
6345
6346   if (element == EL_EXPANDABLE_WALL_HORIZONTAL ||
6347       element == EL_EXPANDABLE_WALL_ANY ||
6348       element == EL_EXPANDABLE_WALL)
6349   {
6350     if (links_frei)
6351     {
6352       Feld[ax-1][ay] = EL_EXPANDABLE_WALL_GROWING;
6353       Store[ax-1][ay] = element;
6354       GfxDir[ax-1][ay] = MovDir[ax-1][ay] = MV_LEFT;
6355       if (IN_SCR_FIELD(SCREENX(ax-1), SCREENY(ay)))
6356         DrawGraphic(SCREENX(ax - 1), SCREENY(ay),
6357                     IMG_EXPANDABLE_WALL_GROWING_LEFT, 0);
6358       new_wall = TRUE;
6359     }
6360
6361     if (rechts_frei)
6362     {
6363       Feld[ax+1][ay] = EL_EXPANDABLE_WALL_GROWING;
6364       Store[ax+1][ay] = element;
6365       GfxDir[ax+1][ay] = MovDir[ax+1][ay] = MV_RIGHT;
6366       if (IN_SCR_FIELD(SCREENX(ax+1), SCREENY(ay)))
6367         DrawGraphic(SCREENX(ax + 1), SCREENY(ay),
6368                     IMG_EXPANDABLE_WALL_GROWING_RIGHT, 0);
6369       new_wall = TRUE;
6370     }
6371   }
6372
6373   if (element == EL_EXPANDABLE_WALL && (links_frei || rechts_frei))
6374     DrawLevelField(ax, ay);
6375
6376   if (!IN_LEV_FIELD(ax, ay-1) || IS_WALL(Feld[ax][ay-1]))
6377     oben_massiv = TRUE;
6378   if (!IN_LEV_FIELD(ax, ay+1) || IS_WALL(Feld[ax][ay+1]))
6379     unten_massiv = TRUE;
6380   if (!IN_LEV_FIELD(ax-1, ay) || IS_WALL(Feld[ax-1][ay]))
6381     links_massiv = TRUE;
6382   if (!IN_LEV_FIELD(ax+1, ay) || IS_WALL(Feld[ax+1][ay]))
6383     rechts_massiv = TRUE;
6384
6385   if (((oben_massiv && unten_massiv) ||
6386        element == EL_EXPANDABLE_WALL_HORIZONTAL ||
6387        element == EL_EXPANDABLE_WALL) &&
6388       ((links_massiv && rechts_massiv) ||
6389        element == EL_EXPANDABLE_WALL_VERTICAL))
6390     Feld[ax][ay] = EL_WALL;
6391
6392   if (new_wall)
6393     PlayLevelSoundAction(ax, ay, ACTION_GROWING);
6394 }
6395
6396 void CheckForDragon(int x, int y)
6397 {
6398   int i, j;
6399   boolean dragon_found = FALSE;
6400   static int xy[4][2] =
6401   {
6402     { 0, -1 },
6403     { -1, 0 },
6404     { +1, 0 },
6405     { 0, +1 }
6406   };
6407
6408   for (i = 0; i < NUM_DIRECTIONS; i++)
6409   {
6410     for (j = 0; j < 4; j++)
6411     {
6412       int xx = x + j * xy[i][0], yy = y + j * xy[i][1];
6413
6414       if (IN_LEV_FIELD(xx, yy) &&
6415           (Feld[xx][yy] == EL_FLAMES || Feld[xx][yy] == EL_DRAGON))
6416       {
6417         if (Feld[xx][yy] == EL_DRAGON)
6418           dragon_found = TRUE;
6419       }
6420       else
6421         break;
6422     }
6423   }
6424
6425   if (!dragon_found)
6426   {
6427     for (i = 0; i < NUM_DIRECTIONS; i++)
6428     {
6429       for (j = 0; j < 3; j++)
6430       {
6431         int xx = x + j * xy[i][0], yy = y + j * xy[i][1];
6432
6433         if (IN_LEV_FIELD(xx, yy) && Feld[xx][yy] == EL_FLAMES)
6434         {
6435           Feld[xx][yy] = EL_EMPTY;
6436           DrawLevelField(xx, yy);
6437         }
6438         else
6439           break;
6440       }
6441     }
6442   }
6443 }
6444
6445 static void InitBuggyBase(int x, int y)
6446 {
6447   int element = Feld[x][y];
6448   int activating_delay = FRAMES_PER_SECOND / 4;
6449
6450   ChangeDelay[x][y] =
6451     (element == EL_SP_BUGGY_BASE ?
6452      2 * FRAMES_PER_SECOND + RND(5 * FRAMES_PER_SECOND) - activating_delay :
6453      element == EL_SP_BUGGY_BASE_ACTIVATING ?
6454      activating_delay :
6455      element == EL_SP_BUGGY_BASE_ACTIVE ?
6456      1 * FRAMES_PER_SECOND + RND(1 * FRAMES_PER_SECOND) : 1);
6457 }
6458
6459 static void WarnBuggyBase(int x, int y)
6460 {
6461   int i;
6462   static int xy[4][2] =
6463   {
6464     { 0, -1 },
6465     { -1, 0 },
6466     { +1, 0 },
6467     { 0, +1 }
6468   };
6469
6470   for (i = 0; i < NUM_DIRECTIONS; i++)
6471   {
6472     int xx = x + xy[i][0], yy = y + xy[i][1];
6473
6474     if (IS_PLAYER(xx, yy))
6475     {
6476       PlayLevelSound(x, y, SND_SP_BUGGY_BASE_ACTIVE);
6477
6478       break;
6479     }
6480   }
6481 }
6482
6483 static void InitTrap(int x, int y)
6484 {
6485   ChangeDelay[x][y] = 2 * FRAMES_PER_SECOND + RND(5 * FRAMES_PER_SECOND);
6486 }
6487
6488 static void ActivateTrap(int x, int y)
6489 {
6490   PlayLevelSound(x, y, SND_TRAP_ACTIVATING);
6491 }
6492
6493 static void ChangeActiveTrap(int x, int y)
6494 {
6495   int graphic = IMG_TRAP_ACTIVE;
6496
6497   /* if new animation frame was drawn, correct crumbled sand border */
6498   if (IS_NEW_FRAME(GfxFrame[x][y], graphic))
6499     DrawLevelFieldCrumbledSand(x, y);
6500 }
6501
6502 static int getSpecialActionElement(int element, int number, int base_element)
6503 {
6504   return (element != EL_EMPTY ? element :
6505           number != -1 ? base_element + number - 1 :
6506           EL_EMPTY);
6507 }
6508
6509 static int getModifiedActionNumber(int value_old, int operator, int operand,
6510                                    int value_min, int value_max)
6511 {
6512   int value_new = (operator == CA_MODE_SET      ? operand :
6513                    operator == CA_MODE_ADD      ? value_old + operand :
6514                    operator == CA_MODE_SUBTRACT ? value_old - operand :
6515                    operator == CA_MODE_MULTIPLY ? value_old * operand :
6516                    operator == CA_MODE_DIVIDE   ? value_old / MAX(1, operand) :
6517                    operator == CA_MODE_MODULO   ? value_old % MAX(1, operand) :
6518                    value_old);
6519
6520   return (value_new < value_min ? value_min :
6521           value_new > value_max ? value_max :
6522           value_new);
6523 }
6524
6525 static void ExecuteCustomElementAction(int x, int y, int element, int page)
6526 {
6527   struct ElementInfo *ei = &element_info[element];
6528   struct ElementChangeInfo *change = &ei->change_page[page];
6529   int action_type = change->action_type;
6530   int action_mode = change->action_mode;
6531   int action_arg = change->action_arg;
6532   int i;
6533
6534   if (!change->has_action)
6535     return;
6536
6537   /* ---------- determine action paramater values ---------- */
6538
6539   int action_arg_element =
6540     (action_arg == CA_ARG_PLAYER_TRIGGER  ? change->actual_trigger_player :
6541      action_arg == CA_ARG_ELEMENT_TRIGGER ? change->actual_trigger_element :
6542      action_arg == CA_ARG_ELEMENT_TARGET  ? change->target_element :
6543      EL_EMPTY);
6544
6545   int action_arg_number_min =
6546     (action_type == CA_SET_PLAYER_SPEED ? MOVE_STEPSIZE_MIN :
6547      CA_ARG_MIN);
6548
6549   int action_arg_number_max =
6550     (action_type == CA_SET_PLAYER_SPEED ? MOVE_STEPSIZE_MAX :
6551      action_type == CA_SET_GEMS ? 999 :
6552      action_type == CA_SET_TIME ? 9999 :
6553      action_type == CA_SET_SCORE ? 99999 :
6554      action_type == CA_SET_CE_SCORE ? 9999 :
6555      action_type == CA_SET_CE_COUNT ? 9999 :
6556      CA_ARG_MAX);
6557
6558   int action_arg_number_reset =
6559     (action_type == CA_SET_PLAYER_SPEED ? TILEX/game.initial_move_delay_value :
6560      action_type == CA_SET_GEMS ? level.gems_needed :
6561      action_type == CA_SET_TIME ? level.time :
6562      action_type == CA_SET_SCORE ? 0 :
6563      action_type == CA_SET_CE_SCORE ? 0 :
6564      action_type == CA_SET_CE_COUNT ? ei->collect_count_initial :
6565      0);
6566
6567   int action_arg_number_normal =
6568     (action_type == CA_SET_PLAYER_SPEED ? MOVE_STEPSIZE_NORMAL :
6569      action_arg_number_reset);
6570
6571   int action_arg_number =
6572     (action_arg <= CA_ARG_MAX ? action_arg :
6573      action_arg == CA_ARG_NUMBER_MIN ? action_arg_number_min :
6574      action_arg == CA_ARG_NUMBER_MAX ? action_arg_number_max :
6575      action_arg == CA_ARG_NUMBER_RESET ? action_arg_number_reset :
6576      action_arg == CA_ARG_NUMBER_NORMAL ? action_arg_number_normal :
6577      action_arg == CA_ARG_NUMBER_CE_SCORE ? ei->collect_score :
6578 #if USE_NEW_COLLECT_COUNT
6579      action_arg == CA_ARG_NUMBER_CE_COUNT ? Count[x][y] :
6580 #else
6581      action_arg == CA_ARG_NUMBER_CE_COUNT ? ei->collect_count_initial :
6582 #endif
6583      action_arg == CA_ARG_NUMBER_CE_DELAY ? GET_CHANGE_DELAY(change) :
6584      -1);
6585
6586   int action_arg_number_old =
6587     (action_type == CA_SET_GEMS ? local_player->gems_still_needed :
6588      action_type == CA_SET_TIME ? TimeLeft :
6589      action_type == CA_SET_SCORE ? local_player->score :
6590      action_type == CA_SET_CE_SCORE ? ei->collect_score :
6591      action_type == CA_SET_CE_COUNT ? Count[x][y] :
6592      0);
6593
6594   int action_arg_number_new =
6595     getModifiedActionNumber(action_arg_number_old,
6596                             action_mode, action_arg_number,
6597                             action_arg_number_min, action_arg_number_max);
6598
6599   /* (for explicit player choice, set invalid value to "no player") */
6600   int action_arg_player_bits =
6601     (action_arg == CA_ARG_PLAYER_ANY ? action_arg - CA_ARG_PLAYER :
6602      action_arg >= CA_ARG_PLAYER_1 &&
6603      action_arg <= CA_ARG_PLAYER_4 ? action_arg - CA_ARG_PLAYER :
6604      action_arg >= CA_ARG_1 &&
6605      action_arg <= CA_ARG_PLAYER_4 ? (1 << (action_arg - 1)) :
6606      action_arg_element >= EL_PLAYER_1 &&
6607      action_arg_element <= EL_PLAYER_4 ?
6608      (1 << (action_arg_element - EL_PLAYER_1)) :
6609      0);
6610
6611   /* (for implicit player choice, set invalid value to "all players") */
6612   int trigger_player_bits =
6613     (change->actual_trigger_player >= EL_PLAYER_1 &&
6614      change->actual_trigger_player <= EL_PLAYER_4 ?
6615      (1 << (change->actual_trigger_player - EL_PLAYER_1)) :
6616      PLAYER_BITS_ANY);
6617
6618   /* ---------- execute action  ---------- */
6619
6620   switch(action_type)
6621   {
6622     case CA_NO_ACTION:
6623     {
6624       return;
6625     }
6626
6627     case CA_EXIT_PLAYER:
6628     {
6629       for (i = 0; i < MAX_PLAYERS; i++)
6630         if (action_arg_player_bits & (1 << i))
6631           stored_player[i].LevelSolved = stored_player[i].GameOver = TRUE;
6632
6633       break;
6634     }
6635
6636     case CA_KILL_PLAYER:
6637     {
6638       for (i = 0; i < MAX_PLAYERS; i++)
6639         if (action_arg_player_bits & (1 << i))
6640           KillPlayer(&stored_player[i]);
6641
6642       break;
6643     }
6644
6645     case CA_RESTART_LEVEL:
6646     {
6647       game.restart_level = TRUE;
6648
6649       break;
6650     }
6651
6652     case CA_SHOW_ENVELOPE:
6653     {
6654       int element = getSpecialActionElement(action_arg_element,
6655                                             action_arg_number, EL_ENVELOPE_1);
6656
6657       if (IS_ENVELOPE(element))
6658         local_player->show_envelope = element;
6659
6660       break;
6661     }
6662
6663     case CA_ADD_KEY:
6664     {
6665       int element = getSpecialActionElement(action_arg_element,
6666                                             action_arg_number, EL_KEY_1);
6667
6668       if (IS_KEY(element))
6669       {
6670         for (i = 0; i < MAX_PLAYERS; i++)
6671         {
6672           if (trigger_player_bits & (1 << i))
6673           {
6674             stored_player[i].key[KEY_NR(element)] = TRUE;
6675
6676             DrawGameValue_Keys(stored_player[i].key);
6677
6678             redraw_mask |= REDRAW_DOOR_1;
6679           }
6680         }
6681       }
6682
6683       break;
6684     }
6685
6686     case CA_DEL_KEY:
6687     {
6688       int element = getSpecialActionElement(action_arg_element,
6689                                             action_arg_number, EL_KEY_1);
6690
6691       if (IS_KEY(element))
6692       {
6693         for (i = 0; i < MAX_PLAYERS; i++)
6694         {
6695           if (trigger_player_bits & (1 << i))
6696           {
6697             stored_player[i].key[KEY_NR(element)] = FALSE;
6698
6699             DrawGameValue_Keys(stored_player[i].key);
6700
6701             redraw_mask |= REDRAW_DOOR_1;
6702           }
6703         }
6704       }
6705
6706       break;
6707     }
6708
6709     case CA_SET_PLAYER_SPEED:
6710     {
6711       for (i = 0; i < MAX_PLAYERS; i++)
6712       {
6713         if (trigger_player_bits & (1 << i))
6714         {
6715           int move_stepsize = TILEX / stored_player[i].move_delay_value;
6716
6717           if (action_mode == CA_MODE_ADD || action_mode == CA_MODE_SUBTRACT)
6718           {
6719             /* translate "+" and "-" to "*" and "/" with powers of two */
6720             action_arg_number = 1 << action_arg_number;
6721             action_mode = (action_mode == CA_MODE_ADD ? CA_MODE_MULTIPLY :
6722                            CA_MODE_DIVIDE);
6723           }
6724
6725           move_stepsize =
6726             getModifiedActionNumber(move_stepsize,
6727                                     action_mode,
6728                                     action_arg_number,
6729                                     action_arg_number_min,
6730                                     action_arg_number_max);
6731
6732           /* make sure that value is power of 2 */
6733           move_stepsize = (1 << log_2(move_stepsize));
6734
6735           /* do no immediately change -- the player might just be moving */
6736           stored_player[i].move_delay_value_next = TILEX / move_stepsize;
6737
6738 #if 0
6739           printf("::: move_delay_value == %d [%d]\n",
6740                  stored_player[i].move_delay_value_next, action_arg_number);
6741 #endif
6742         }
6743       }
6744
6745       break;
6746     }
6747
6748     case CA_SET_GEMS:
6749     {
6750       local_player->gems_still_needed = action_arg_number_new;
6751
6752       DrawGameValue_Emeralds(local_player->gems_still_needed);
6753
6754       break;
6755     }
6756
6757     case CA_SET_TIME:
6758     {
6759       if (level.time > 0)       /* only modify limited time value */
6760       {
6761         TimeLeft = action_arg_number_new;
6762
6763         DrawGameValue_Time(TimeLeft);
6764
6765         if (!TimeLeft && setup.time_limit)
6766           for (i = 0; i < MAX_PLAYERS; i++)
6767             KillPlayer(&stored_player[i]);
6768       }
6769
6770       break;
6771     }
6772
6773     case CA_SET_SCORE:
6774     {
6775       local_player->score = action_arg_number_new;
6776
6777       DrawGameValue_Score(local_player->score);
6778
6779       break;
6780     }
6781
6782     case CA_SET_CE_SCORE:
6783     {
6784       ei->collect_score = action_arg_number_new;
6785
6786       break;
6787     }
6788
6789     case CA_SET_CE_COUNT:
6790     {
6791 #if USE_NEW_COLLECT_COUNT
6792       int count_last = Count[x][y];
6793
6794       Count[x][y] = action_arg_number_new;
6795
6796 #if 0
6797       printf("::: Count == %d\n", Count[x][y]);
6798 #endif
6799
6800       if (Count[x][y] == 0 && count_last > 0)
6801       {
6802 #if 0
6803         printf("::: CE_COUNT_AT_ZERO\n");
6804 #endif
6805
6806         CheckElementChange(x, y, element, EL_UNDEFINED, CE_COUNT_AT_ZERO);
6807         CheckTriggeredElementChange(element, CE_COUNT_AT_ZERO_OF_X);
6808       }
6809 #endif
6810
6811       break;
6812     }
6813
6814     case CA_SET_DYNABOMB_NUMBER:
6815     {
6816       printf("::: CA_SET_DYNABOMB_NUMBER -- not yet implemented\n");
6817
6818       break;
6819     }
6820
6821     case CA_SET_DYNABOMB_SIZE:
6822     {
6823       printf("::: CA_SET_DYNABOMB_SIZE -- not yet implemented\n");
6824
6825       break;
6826     }
6827
6828     case CA_SET_DYNABOMB_POWER:
6829     {
6830       printf("::: CA_SET_DYNABOMB_POWER -- not yet implemented\n");
6831
6832       break;
6833     }
6834
6835     case CA_TOGGLE_PLAYER_GRAVITY:
6836     {
6837       game.gravity = !game.gravity;
6838
6839       break;
6840     }
6841
6842     case CA_ENABLE_PLAYER_GRAVITY:
6843     {
6844       game.gravity = TRUE;
6845
6846       break;
6847     }
6848
6849     case CA_DISABLE_PLAYER_GRAVITY:
6850     {
6851       game.gravity = FALSE;
6852
6853       break;
6854     }
6855
6856     default:
6857       break;
6858   }
6859 }
6860
6861 static void ChangeElementNowExt(struct ElementChangeInfo *change,
6862                                 int x, int y, int target_element)
6863 {
6864   int previous_move_direction = MovDir[x][y];
6865   boolean add_player = (ELEM_IS_PLAYER(target_element) &&
6866                         IS_WALKABLE(Feld[x][y]));
6867
6868   /* check if element under player changes from accessible to unaccessible
6869      (needed for special case of dropping element which then changes) */
6870   if (IS_PLAYER(x, y) && !PLAYER_EXPLOSION_PROTECTED(x, y) &&
6871       IS_ACCESSIBLE(Feld[x][y]) && !IS_ACCESSIBLE(target_element))
6872   {
6873     Bang(x, y);
6874     return;
6875   }
6876
6877   if (!add_player)
6878   {
6879     if (IS_MOVING(x, y) || IS_BLOCKED(x, y))
6880       RemoveMovingField(x, y);
6881     else
6882       RemoveField(x, y);
6883
6884     Feld[x][y] = target_element;
6885
6886     ResetGfxAnimation(x, y);
6887     ResetRandomAnimationValue(x, y);
6888
6889     if (element_info[Feld[x][y]].move_direction_initial == MV_START_PREVIOUS)
6890       MovDir[x][y] = previous_move_direction;
6891
6892     InitField_WithBug1(x, y, FALSE);
6893
6894     DrawLevelField(x, y);
6895
6896     if (GFX_CRUMBLED(Feld[x][y]))
6897       DrawLevelFieldCrumbledSandNeighbours(x, y);
6898   }
6899
6900   /* "Changed[][]" not set yet to allow "entered by player" change one time */
6901   if (ELEM_IS_PLAYER(target_element))
6902     RelocatePlayer(x, y, target_element);
6903
6904 #if 1
6905   Changed[x][y] = TRUE;         /* ignore all further changes in this frame */
6906 #else
6907   Changed[x][y] |= ChangeEvent[x][y];   /* ignore same changes in this frame */
6908 #endif
6909
6910   TestIfBadThingTouchesPlayer(x, y);
6911   TestIfPlayerTouchesCustomElement(x, y);
6912   TestIfElementTouchesCustomElement(x, y);
6913 }
6914
6915 static boolean ChangeElementNow(int x, int y, int element, int page)
6916 {
6917   struct ElementChangeInfo *change = &element_info[element].change_page[page];
6918   int target_element;
6919   int old_element = Feld[x][y];
6920
6921   /* always use default change event to prevent running into a loop */
6922   if (ChangeEvent[x][y] == -1)
6923     ChangeEvent[x][y] = CE_DELAY;
6924
6925   if (ChangeEvent[x][y] == CE_DELAY)
6926   {
6927     /* reset actual trigger element, trigger player and action element */
6928     change->actual_trigger_element = EL_EMPTY;
6929     change->actual_trigger_player = EL_PLAYER_1;
6930   }
6931
6932 #if 1
6933   /* do not change any elements that have already changed in this frame */
6934   if (Changed[x][y])
6935     return FALSE;
6936 #else
6937   /* do not change already changed elements with same change event */
6938   if (Changed[x][y] & ChangeEvent[x][y])
6939     return FALSE;
6940 #endif
6941
6942 #if 1
6943   Changed[x][y] = TRUE;         /* ignore all further changes in this frame */
6944 #else
6945   Changed[x][y] |= ChangeEvent[x][y];   /* ignore same changes in this frame */
6946 #endif
6947
6948   if (change->explode)
6949   {
6950     Bang(x, y);
6951
6952     return TRUE;
6953   }
6954
6955   if (change->use_target_content)
6956   {
6957     boolean complete_replace = TRUE;
6958     boolean can_replace[3][3];
6959     int xx, yy;
6960
6961     for (yy = 0; yy < 3; yy++) for (xx = 0; xx < 3 ; xx++)
6962     {
6963       boolean is_empty;
6964       boolean is_walkable;
6965       boolean is_diggable;
6966       boolean is_collectible;
6967       boolean is_removable;
6968       boolean is_destructible;
6969       int ex = x + xx - 1;
6970       int ey = y + yy - 1;
6971       int content_element = change->target_content.e[xx][yy];
6972       int e;
6973
6974       can_replace[xx][yy] = TRUE;
6975
6976       if (ex == x && ey == y)   /* do not check changing element itself */
6977         continue;
6978
6979       if (content_element == EL_EMPTY_SPACE)
6980       {
6981         can_replace[xx][yy] = FALSE;    /* do not replace border with space */
6982
6983         continue;
6984       }
6985
6986       if (!IN_LEV_FIELD(ex, ey))
6987       {
6988         can_replace[xx][yy] = FALSE;
6989         complete_replace = FALSE;
6990
6991         continue;
6992       }
6993
6994       e = Feld[ex][ey];
6995
6996       if (IS_MOVING(ex, ey) || IS_BLOCKED(ex, ey))
6997         e = MovingOrBlocked2Element(ex, ey);
6998
6999       is_empty = (IS_FREE(ex, ey) ||
7000                   (IS_FREE_OR_PLAYER(ex, ey) && IS_WALKABLE(content_element)));
7001
7002       is_walkable     = (is_empty || IS_WALKABLE(e));
7003       is_diggable     = (is_empty || IS_DIGGABLE(e));
7004       is_collectible  = (is_empty || IS_COLLECTIBLE(e));
7005       is_destructible = (is_empty || !IS_INDESTRUCTIBLE(e));
7006       is_removable    = (is_diggable || is_collectible);
7007
7008       can_replace[xx][yy] =
7009         (((change->replace_when == CP_WHEN_EMPTY        && is_empty) ||
7010           (change->replace_when == CP_WHEN_WALKABLE     && is_walkable) ||
7011           (change->replace_when == CP_WHEN_DIGGABLE     && is_diggable) ||
7012           (change->replace_when == CP_WHEN_COLLECTIBLE  && is_collectible) ||
7013           (change->replace_when == CP_WHEN_REMOVABLE    && is_removable) ||
7014           (change->replace_when == CP_WHEN_DESTRUCTIBLE && is_destructible)) &&
7015          !(IS_PLAYER(ex, ey) && ELEM_IS_PLAYER(content_element)));
7016
7017       if (!can_replace[xx][yy])
7018         complete_replace = FALSE;
7019     }
7020
7021     if (!change->only_if_complete || complete_replace)
7022     {
7023       boolean something_has_changed = FALSE;
7024
7025       if (change->only_if_complete && change->use_random_replace &&
7026           RND(100) < change->random_percentage)
7027         return FALSE;
7028
7029       for (yy = 0; yy < 3; yy++) for (xx = 0; xx < 3 ; xx++)
7030       {
7031         int ex = x + xx - 1;
7032         int ey = y + yy - 1;
7033         int content_element;
7034
7035         if (can_replace[xx][yy] && (!change->use_random_replace ||
7036                                     RND(100) < change->random_percentage))
7037         {
7038           if (IS_MOVING(ex, ey) || IS_BLOCKED(ex, ey))
7039             RemoveMovingField(ex, ey);
7040
7041           ChangeEvent[ex][ey] = ChangeEvent[x][y];
7042
7043           content_element = change->target_content.e[xx][yy];
7044           target_element = GET_TARGET_ELEMENT(content_element, change);
7045
7046           ChangeElementNowExt(change, ex, ey, target_element);
7047
7048           something_has_changed = TRUE;
7049
7050           /* for symmetry reasons, freeze newly created border elements */
7051           if (ex != x || ey != y)
7052             Stop[ex][ey] = TRUE;        /* no more moving in this frame */
7053         }
7054       }
7055
7056       if (something_has_changed)
7057       {
7058         PlayLevelSoundElementAction(x, y, element, ACTION_CHANGING);
7059         PlayLevelSoundElementAction(x, y, element, ACTION_PAGE_1 + page);
7060       }
7061     }
7062   }
7063   else
7064   {
7065     target_element = GET_TARGET_ELEMENT(change->target_element, change);
7066
7067     ChangeElementNowExt(change, x, y, target_element);
7068
7069     PlayLevelSoundElementAction(x, y, element, ACTION_CHANGING);
7070     PlayLevelSoundElementAction(x, y, element, ACTION_PAGE_1 + page);
7071   }
7072
7073   /* this uses direct change before indirect change */
7074   CheckTriggeredElementChangeByPage(old_element, CE_CHANGE_OF_X, page);
7075
7076   return TRUE;
7077 }
7078
7079 #if USE_NEW_DELAYED_ACTION
7080
7081 static void ChangeElement(int x, int y, int page)
7082 {
7083   int element = MovingOrBlocked2Element(x, y);
7084   struct ElementInfo *ei = &element_info[element];
7085   struct ElementChangeInfo *change = &ei->change_page[page];
7086
7087 #ifdef DEBUG
7088   if (!CAN_CHANGE_OR_HAS_ACTION(element) &&
7089       !CAN_CHANGE_OR_HAS_ACTION(Back[x][y]))
7090   {
7091     printf("\n\n");
7092     printf("ChangeElement(): %d,%d: element = %d ('%s')\n",
7093            x, y, element, element_info[element].token_name);
7094     printf("ChangeElement(): This should never happen!\n");
7095     printf("\n\n");
7096   }
7097 #endif
7098
7099   /* this can happen with classic bombs on walkable, changing elements */
7100   if (!CAN_CHANGE_OR_HAS_ACTION(element))
7101   {
7102 #if 0
7103     if (!CAN_CHANGE(Back[x][y]))        /* prevent permanent repetition */
7104       ChangeDelay[x][y] = 0;
7105 #endif
7106
7107     return;
7108   }
7109
7110   if (ChangeDelay[x][y] == 0)           /* initialize element change */
7111   {
7112     ChangeDelay[x][y] = GET_CHANGE_DELAY(change) + 1;
7113
7114     if (change->can_change)
7115     {
7116       ResetGfxAnimation(x, y);
7117       ResetRandomAnimationValue(x, y);
7118
7119       if (change->pre_change_function)
7120         change->pre_change_function(x, y);
7121     }
7122   }
7123
7124   ChangeDelay[x][y]--;
7125
7126   if (ChangeDelay[x][y] != 0)           /* continue element change */
7127   {
7128     if (change->can_change)
7129     {
7130       int graphic = el_act_dir2img(element, GfxAction[x][y], GfxDir[x][y]);
7131
7132       if (IS_ANIMATED(graphic))
7133         DrawLevelGraphicAnimationIfNeeded(x, y, graphic);
7134
7135       if (change->change_function)
7136         change->change_function(x, y);
7137     }
7138   }
7139   else                                  /* finish element change */
7140   {
7141     if (ChangePage[x][y] != -1)         /* remember page from delayed change */
7142     {
7143       page = ChangePage[x][y];
7144       ChangePage[x][y] = -1;
7145
7146       change = &ei->change_page[page];
7147     }
7148
7149     if (IS_MOVING(x, y))                /* never change a running system ;-) */
7150     {
7151       ChangeDelay[x][y] = 1;            /* try change after next move step */
7152       ChangePage[x][y] = page;          /* remember page to use for change */
7153
7154       return;
7155     }
7156
7157     if (change->can_change)
7158     {
7159       if (ChangeElementNow(x, y, element, page))
7160       {
7161         if (change->post_change_function)
7162           change->post_change_function(x, y);
7163       }
7164     }
7165
7166     if (change->has_action)
7167       ExecuteCustomElementAction(x, y, element, page);
7168   }
7169 }
7170
7171 #else
7172
7173 static void ChangeElement(int x, int y, int page)
7174 {
7175   int element = MovingOrBlocked2Element(x, y);
7176   struct ElementInfo *ei = &element_info[element];
7177   struct ElementChangeInfo *change = &ei->change_page[page];
7178
7179 #ifdef DEBUG
7180   if (!CAN_CHANGE(element) && !CAN_CHANGE(Back[x][y]))
7181   {
7182     printf("\n\n");
7183     printf("ChangeElement(): %d,%d: element = %d ('%s')\n",
7184            x, y, element, element_info[element].token_name);
7185     printf("ChangeElement(): This should never happen!\n");
7186     printf("\n\n");
7187   }
7188 #endif
7189
7190   /* this can happen with classic bombs on walkable, changing elements */
7191   if (!CAN_CHANGE(element))
7192   {
7193 #if 0
7194     if (!CAN_CHANGE(Back[x][y]))        /* prevent permanent repetition */
7195       ChangeDelay[x][y] = 0;
7196 #endif
7197
7198     return;
7199   }
7200
7201   if (ChangeDelay[x][y] == 0)           /* initialize element change */
7202   {
7203     ChangeDelay[x][y] = GET_CHANGE_DELAY(change) + 1;
7204
7205     ResetGfxAnimation(x, y);
7206     ResetRandomAnimationValue(x, y);
7207
7208     if (change->pre_change_function)
7209       change->pre_change_function(x, y);
7210   }
7211
7212   ChangeDelay[x][y]--;
7213
7214   if (ChangeDelay[x][y] != 0)           /* continue element change */
7215   {
7216     int graphic = el_act_dir2img(element, GfxAction[x][y], GfxDir[x][y]);
7217
7218     if (IS_ANIMATED(graphic))
7219       DrawLevelGraphicAnimationIfNeeded(x, y, graphic);
7220
7221     if (change->change_function)
7222       change->change_function(x, y);
7223   }
7224   else                                  /* finish element change */
7225   {
7226     if (ChangePage[x][y] != -1)         /* remember page from delayed change */
7227     {
7228       page = ChangePage[x][y];
7229       ChangePage[x][y] = -1;
7230
7231       change = &ei->change_page[page];
7232     }
7233
7234     if (IS_MOVING(x, y))                /* never change a running system ;-) */
7235     {
7236       ChangeDelay[x][y] = 1;            /* try change after next move step */
7237       ChangePage[x][y] = page;          /* remember page to use for change */
7238
7239       return;
7240     }
7241
7242     if (ChangeElementNow(x, y, element, page))
7243     {
7244       if (change->post_change_function)
7245         change->post_change_function(x, y);
7246     }
7247   }
7248 }
7249
7250 #endif
7251
7252 static boolean CheckTriggeredElementChangeExt(int trigger_element,
7253                                               int trigger_event,
7254                                               int trigger_player,
7255                                               int trigger_side,
7256                                               int trigger_page)
7257 {
7258   boolean change_done_any = FALSE;
7259   int trigger_page_bits = (trigger_page < 0 ? CH_PAGE_ANY : 1 << trigger_page);
7260   int i;
7261
7262   if (!(trigger_events[trigger_element][trigger_event]))
7263     return FALSE;
7264
7265   for (i = 0; i < NUM_CUSTOM_ELEMENTS; i++)
7266   {
7267     int element = EL_CUSTOM_START + i;
7268     boolean change_done = FALSE;
7269     int p;
7270
7271     if (!CAN_CHANGE_OR_HAS_ACTION(element) ||
7272         !HAS_ANY_CHANGE_EVENT(element, trigger_event))
7273       continue;
7274
7275     for (p = 0; p < element_info[element].num_change_pages; p++)
7276     {
7277       struct ElementChangeInfo *change = &element_info[element].change_page[p];
7278
7279       if (change->can_change_or_has_action &&
7280           change->has_event[trigger_event] &&
7281           change->trigger_side & trigger_side &&
7282           change->trigger_player & trigger_player &&
7283           change->trigger_page & trigger_page_bits &&
7284           IS_EQUAL_OR_IN_GROUP(trigger_element, change->trigger_element))
7285       {
7286         change->actual_trigger_element = trigger_element;
7287         change->actual_trigger_player = EL_PLAYER_1 + log_2(trigger_player);
7288
7289         if ((change->can_change && !change_done) || change->has_action)
7290         {
7291           int x, y;
7292
7293           for (y = 0; y < lev_fieldy; y++) for (x = 0; x < lev_fieldx; x++)
7294           {
7295             if (Feld[x][y] == element)
7296             {
7297               if (change->can_change && !change_done)
7298               {
7299                 ChangeDelay[x][y] = 1;
7300                 ChangeEvent[x][y] = trigger_event;
7301                 ChangeElement(x, y, p);
7302               }
7303 #if USE_NEW_DELAYED_ACTION
7304               else if (change->has_action)
7305               {
7306                 ExecuteCustomElementAction(x, y, element, p);
7307                 PlayLevelSoundElementAction(x, y, element, ACTION_PAGE_1 + p);
7308               }
7309 #else
7310               if (change->has_action)
7311               {
7312                 ExecuteCustomElementAction(x, y, element, p);
7313                 PlayLevelSoundElementAction(x, y, element, ACTION_PAGE_1 + p);
7314               }
7315 #endif
7316             }
7317           }
7318
7319           if (change->can_change)
7320           {
7321             change_done = TRUE;
7322             change_done_any = TRUE;
7323           }
7324         }
7325       }
7326     }
7327   }
7328
7329   return change_done_any;
7330 }
7331
7332 static boolean CheckElementChangeExt(int x, int y,
7333                                      int element,
7334                                      int trigger_element,
7335                                      int trigger_event,
7336                                      int trigger_player,
7337                                      int trigger_side)
7338 {
7339   boolean change_done = FALSE;
7340   int p;
7341
7342   if (!CAN_CHANGE_OR_HAS_ACTION(element) ||
7343       !HAS_ANY_CHANGE_EVENT(element, trigger_event))
7344     return FALSE;
7345
7346   if (Feld[x][y] == EL_BLOCKED)
7347   {
7348     Blocked2Moving(x, y, &x, &y);
7349     element = Feld[x][y];
7350   }
7351
7352   if (Feld[x][y] != element)    /* check if element has already changed */
7353     return FALSE;
7354
7355   for (p = 0; p < element_info[element].num_change_pages; p++)
7356   {
7357     struct ElementChangeInfo *change = &element_info[element].change_page[p];
7358
7359     boolean check_trigger_element =
7360       (trigger_event == CE_TOUCHING_X ||
7361        trigger_event == CE_HITTING_X ||
7362        trigger_event == CE_HIT_BY_X);
7363
7364     if (change->can_change_or_has_action &&
7365         change->has_event[trigger_event] &&
7366         change->trigger_side & trigger_side &&
7367         change->trigger_player & trigger_player &&
7368         (!check_trigger_element ||
7369          IS_EQUAL_OR_IN_GROUP(trigger_element, change->trigger_element)))
7370     {
7371       change->actual_trigger_element = trigger_element;
7372       change->actual_trigger_player = EL_PLAYER_1 + log_2(trigger_player);
7373
7374       if (change->can_change && !change_done)
7375       {
7376         ChangeDelay[x][y] = 1;
7377         ChangeEvent[x][y] = trigger_event;
7378         ChangeElement(x, y, p);
7379
7380         change_done = TRUE;
7381       }
7382 #if USE_NEW_DELAYED_ACTION
7383       else if (change->has_action)
7384       {
7385         ExecuteCustomElementAction(x, y, element, p);
7386         PlayLevelSoundElementAction(x, y, element, ACTION_PAGE_1 + p);
7387       }
7388 #else
7389       if (change->has_action)
7390       {
7391         ExecuteCustomElementAction(x, y, element, p);
7392         PlayLevelSoundElementAction(x, y, element, ACTION_PAGE_1 + p);
7393       }
7394 #endif
7395     }
7396   }
7397
7398   return change_done;
7399 }
7400
7401 static void PlayPlayerSound(struct PlayerInfo *player)
7402 {
7403   int jx = player->jx, jy = player->jy;
7404   int element = player->element_nr;
7405   int last_action = player->last_action_waiting;
7406   int action = player->action_waiting;
7407
7408   if (player->is_waiting)
7409   {
7410     if (action != last_action)
7411       PlayLevelSoundElementAction(jx, jy, element, action);
7412     else
7413       PlayLevelSoundElementActionIfLoop(jx, jy, element, action);
7414   }
7415   else
7416   {
7417     if (action != last_action)
7418       StopSound(element_info[element].sound[last_action]);
7419
7420     if (last_action == ACTION_SLEEPING)
7421       PlayLevelSoundElementAction(jx, jy, element, ACTION_AWAKENING);
7422   }
7423 }
7424
7425 static void PlayAllPlayersSound()
7426 {
7427   int i;
7428
7429   for (i = 0; i < MAX_PLAYERS; i++)
7430     if (stored_player[i].active)
7431       PlayPlayerSound(&stored_player[i]);
7432 }
7433
7434 static void SetPlayerWaiting(struct PlayerInfo *player, boolean is_waiting)
7435 {
7436   boolean last_waiting = player->is_waiting;
7437   int move_dir = player->MovDir;
7438
7439   player->last_action_waiting = player->action_waiting;
7440
7441   if (is_waiting)
7442   {
7443     if (!last_waiting)          /* not waiting -> waiting */
7444     {
7445       player->is_waiting = TRUE;
7446
7447       player->frame_counter_bored =
7448         FrameCounter +
7449         game.player_boring_delay_fixed +
7450         SimpleRND(game.player_boring_delay_random);
7451       player->frame_counter_sleeping =
7452         FrameCounter +
7453         game.player_sleeping_delay_fixed +
7454         SimpleRND(game.player_sleeping_delay_random);
7455
7456       InitPlayerGfxAnimation(player, ACTION_WAITING, player->MovDir);
7457     }
7458
7459     if (game.player_sleeping_delay_fixed +
7460         game.player_sleeping_delay_random > 0 &&
7461         player->anim_delay_counter == 0 &&
7462         player->post_delay_counter == 0 &&
7463         FrameCounter >= player->frame_counter_sleeping)
7464       player->is_sleeping = TRUE;
7465     else if (game.player_boring_delay_fixed +
7466              game.player_boring_delay_random > 0 &&
7467              FrameCounter >= player->frame_counter_bored)
7468       player->is_bored = TRUE;
7469
7470     player->action_waiting = (player->is_sleeping ? ACTION_SLEEPING :
7471                               player->is_bored ? ACTION_BORING :
7472                               ACTION_WAITING);
7473
7474     if (player->is_sleeping)
7475     {
7476       if (player->num_special_action_sleeping > 0)
7477       {
7478         if (player->anim_delay_counter == 0 && player->post_delay_counter == 0)
7479         {
7480           int last_special_action = player->special_action_sleeping;
7481           int num_special_action = player->num_special_action_sleeping;
7482           int special_action =
7483             (last_special_action == ACTION_DEFAULT ? ACTION_SLEEPING_1 :
7484              last_special_action == ACTION_SLEEPING ? ACTION_SLEEPING :
7485              last_special_action < ACTION_SLEEPING_1 + num_special_action - 1 ?
7486              last_special_action + 1 : ACTION_SLEEPING);
7487           int special_graphic =
7488             el_act_dir2img(player->element_nr, special_action, move_dir);
7489
7490           player->anim_delay_counter =
7491             graphic_info[special_graphic].anim_delay_fixed +
7492             SimpleRND(graphic_info[special_graphic].anim_delay_random);
7493           player->post_delay_counter =
7494             graphic_info[special_graphic].post_delay_fixed +
7495             SimpleRND(graphic_info[special_graphic].post_delay_random);
7496
7497           player->special_action_sleeping = special_action;
7498         }
7499
7500         if (player->anim_delay_counter > 0)
7501         {
7502           player->action_waiting = player->special_action_sleeping;
7503           player->anim_delay_counter--;
7504         }
7505         else if (player->post_delay_counter > 0)
7506         {
7507           player->post_delay_counter--;
7508         }
7509       }
7510     }
7511     else if (player->is_bored)
7512     {
7513       if (player->num_special_action_bored > 0)
7514       {
7515         if (player->anim_delay_counter == 0 && player->post_delay_counter == 0)
7516         {
7517           int special_action =
7518             ACTION_BORING_1 + SimpleRND(player->num_special_action_bored);
7519           int special_graphic =
7520             el_act_dir2img(player->element_nr, special_action, move_dir);
7521
7522           player->anim_delay_counter =
7523             graphic_info[special_graphic].anim_delay_fixed +
7524             SimpleRND(graphic_info[special_graphic].anim_delay_random);
7525           player->post_delay_counter =
7526             graphic_info[special_graphic].post_delay_fixed +
7527             SimpleRND(graphic_info[special_graphic].post_delay_random);
7528
7529           player->special_action_bored = special_action;
7530         }
7531
7532         if (player->anim_delay_counter > 0)
7533         {
7534           player->action_waiting = player->special_action_bored;
7535           player->anim_delay_counter--;
7536         }
7537         else if (player->post_delay_counter > 0)
7538         {
7539           player->post_delay_counter--;
7540         }
7541       }
7542     }
7543   }
7544   else if (last_waiting)        /* waiting -> not waiting */
7545   {
7546     player->is_waiting = FALSE;
7547     player->is_bored = FALSE;
7548     player->is_sleeping = FALSE;
7549
7550     player->frame_counter_bored = -1;
7551     player->frame_counter_sleeping = -1;
7552
7553     player->anim_delay_counter = 0;
7554     player->post_delay_counter = 0;
7555
7556     player->action_waiting = ACTION_DEFAULT;
7557
7558     player->special_action_bored = ACTION_DEFAULT;
7559     player->special_action_sleeping = ACTION_DEFAULT;
7560   }
7561 }
7562
7563 static byte PlayerActions(struct PlayerInfo *player, byte player_action)
7564 {
7565   boolean moved = FALSE, snapped = FALSE, dropped = FALSE;
7566   int left      = player_action & JOY_LEFT;
7567   int right     = player_action & JOY_RIGHT;
7568   int up        = player_action & JOY_UP;
7569   int down      = player_action & JOY_DOWN;
7570   int button1   = player_action & JOY_BUTTON_1;
7571   int button2   = player_action & JOY_BUTTON_2;
7572   int dx        = (left ? -1    : right ? 1     : 0);
7573   int dy        = (up   ? -1    : down  ? 1     : 0);
7574
7575   if (!player->active || tape.pausing)
7576     return 0;
7577
7578   if (player_action)
7579   {
7580     if (button1)
7581       snapped = SnapField(player, dx, dy);
7582     else
7583     {
7584       if (button2)
7585         dropped = DropElement(player);
7586
7587       moved = MovePlayer(player, dx, dy);
7588     }
7589
7590     if (tape.single_step && tape.recording && !tape.pausing)
7591     {
7592       if (button1 || (dropped && !moved))
7593       {
7594         TapeTogglePause(TAPE_TOGGLE_AUTOMATIC);
7595         SnapField(player, 0, 0);                /* stop snapping */
7596       }
7597     }
7598
7599     SetPlayerWaiting(player, FALSE);
7600
7601     return player_action;
7602   }
7603   else
7604   {
7605     /* no actions for this player (no input at player's configured device) */
7606
7607     DigField(player, 0, 0, 0, 0, 0, 0, DF_NO_PUSH);
7608     SnapField(player, 0, 0);
7609     CheckGravityMovementWhenNotMoving(player);
7610
7611     if (player->MovPos == 0)
7612       SetPlayerWaiting(player, TRUE);
7613
7614     if (player->MovPos == 0)    /* needed for tape.playing */
7615       player->is_moving = FALSE;
7616
7617     player->is_dropping = FALSE;
7618
7619     return 0;
7620   }
7621 }
7622
7623 void AdvanceFrameAndPlayerCounters(int player_nr)
7624 {
7625   int i;
7626
7627   /* advance frame counters (global frame counter and time frame counter) */
7628   FrameCounter++;
7629   TimeFrames++;
7630
7631   /* advance player counters (counters for move delay, move animation etc.) */
7632   for (i = 0; i < MAX_PLAYERS; i++)
7633   {
7634     boolean advance_player_counters = (player_nr == -1 || player_nr == i);
7635     int move_delay_value = stored_player[i].move_delay_value;
7636     int move_frames = MOVE_DELAY_NORMAL_SPEED / move_delay_value;
7637
7638     if (!advance_player_counters)       /* not all players may be affected */
7639       continue;
7640
7641 #if USE_NEW_PLAYER_ANIM
7642     if (move_frames == 0)       /* less than one move per game frame */
7643     {
7644       int stepsize = TILEX / move_delay_value;
7645       int delay = move_delay_value / MOVE_DELAY_NORMAL_SPEED;
7646       int count = (stored_player[i].is_moving ?
7647                    ABS(stored_player[i].MovPos) / stepsize : FrameCounter);
7648
7649       if (count % delay == 0)
7650         move_frames = 1;
7651     }
7652 #endif
7653
7654     stored_player[i].Frame += move_frames;
7655
7656     if (stored_player[i].MovPos != 0)
7657       stored_player[i].StepFrame += move_frames;
7658
7659     if (stored_player[i].move_delay > 0)
7660       stored_player[i].move_delay--;
7661
7662     /* due to bugs in previous versions, counter must count up, not down */
7663     if (stored_player[i].push_delay != -1)
7664       stored_player[i].push_delay++;
7665
7666     if (stored_player[i].drop_delay > 0)
7667       stored_player[i].drop_delay--;
7668   }
7669 }
7670
7671 void GameActions()
7672 {
7673   static unsigned long game_frame_delay = 0;
7674   unsigned long game_frame_delay_value;
7675   int magic_wall_x = 0, magic_wall_y = 0;
7676   int i, x, y, element, graphic;
7677   byte *recorded_player_action;
7678   byte summarized_player_action = 0;
7679   byte tape_action[MAX_PLAYERS];
7680
7681   if (game_status != GAME_MODE_PLAYING)
7682     return;
7683
7684   game_frame_delay_value =
7685     (tape.playing && tape.fast_forward ? FfwdFrameDelay : GameFrameDelay);
7686
7687   if (tape.playing && tape.warp_forward && !tape.pausing)
7688     game_frame_delay_value = 0;
7689
7690   /* ---------- main game synchronization point ---------- */
7691
7692   WaitUntilDelayReached(&game_frame_delay, game_frame_delay_value);
7693
7694   if (network_playing && !network_player_action_received)
7695   {
7696     /* try to get network player actions in time */
7697
7698 #if defined(NETWORK_AVALIABLE)
7699     /* last chance to get network player actions without main loop delay */
7700     HandleNetworking();
7701 #endif
7702
7703     /* game was quit by network peer */
7704     if (game_status != GAME_MODE_PLAYING)
7705       return;
7706
7707     if (!network_player_action_received)
7708       return;           /* failed to get network player actions in time */
7709   }
7710
7711   if (tape.pausing)
7712     return;
7713
7714   recorded_player_action = (tape.playing ? TapePlayAction() : NULL);
7715
7716 #if 1
7717   /* !!! CHECK THIS (tape.pausing is always FALSE here!) !!! */
7718   if (recorded_player_action == NULL && tape.pausing)
7719     return;
7720 #endif
7721
7722   for (i = 0; i < MAX_PLAYERS; i++)
7723   {
7724     summarized_player_action |= stored_player[i].action;
7725
7726     if (!network_playing)
7727       stored_player[i].effective_action = stored_player[i].action;
7728   }
7729
7730 #if defined(NETWORK_AVALIABLE)
7731   if (network_playing)
7732     SendToServer_MovePlayer(summarized_player_action);
7733 #endif
7734
7735   if (!options.network && !setup.team_mode)
7736     local_player->effective_action = summarized_player_action;
7737
7738   if (recorded_player_action != NULL)
7739     for (i = 0; i < MAX_PLAYERS; i++)
7740       stored_player[i].effective_action = recorded_player_action[i];
7741
7742   for (i = 0; i < MAX_PLAYERS; i++)
7743   {
7744     tape_action[i] = stored_player[i].effective_action;
7745
7746     if (tape.recording && tape_action[i] && !tape.player_participates[i])
7747       tape.player_participates[i] = TRUE;    /* player just appeared from CE */
7748   }
7749
7750   /* only save actions from input devices, but not programmed actions */
7751   if (tape.recording)
7752     TapeRecordAction(tape_action);
7753
7754   for (i = 0; i < MAX_PLAYERS; i++)
7755   {
7756     int actual_player_action = stored_player[i].effective_action;
7757
7758 #if 1
7759     /* !!! THIS BREAKS THE FOLLOWING TAPES: !!!
7760        - rnd_equinox_tetrachloride 048
7761        - rnd_equinox_tetrachloride_ii 096
7762        - rnd_emanuel_schmieg 002
7763        - doctor_sloan_ww 001, 020
7764     */
7765     if (stored_player[i].MovPos == 0)
7766       CheckGravityMovement(&stored_player[i]);
7767 #endif
7768
7769     /* overwrite programmed action with tape action */
7770     if (stored_player[i].programmed_action)
7771       actual_player_action = stored_player[i].programmed_action;
7772
7773 #if 1
7774     PlayerActions(&stored_player[i], actual_player_action);
7775 #else
7776     tape_action[i] = PlayerActions(&stored_player[i], actual_player_action);
7777
7778     if (tape.recording && tape_action[i] && !tape.player_participates[i])
7779       tape.player_participates[i] = TRUE;    /* player just appeared from CE */
7780 #endif
7781
7782     ScrollPlayer(&stored_player[i], SCROLL_GO_ON);
7783   }
7784
7785   network_player_action_received = FALSE;
7786
7787   ScrollScreen(NULL, SCROLL_GO_ON);
7788
7789   /* for backwards compatibility, the following code emulates a fixed bug that
7790      occured when pushing elements (causing elements that just made their last
7791      pushing step to already (if possible) make their first falling step in the
7792      same game frame, which is bad); this code is also needed to use the famous
7793      "spring push bug" which is used in older levels and might be wanted to be
7794      used also in newer levels, but in this case the buggy pushing code is only
7795      affecting the "spring" element and no other elements */
7796
7797   if (game.engine_version < VERSION_IDENT(2,2,0,7) || level.use_spring_bug)
7798   {
7799     for (i = 0; i < MAX_PLAYERS; i++)
7800     {
7801       struct PlayerInfo *player = &stored_player[i];
7802       int x = player->jx;
7803       int y = player->jy;
7804
7805       if (player->active && player->is_pushing && player->is_moving &&
7806           IS_MOVING(x, y) &&
7807           (game.engine_version < VERSION_IDENT(2,2,0,7) ||
7808            Feld[x][y] == EL_SPRING))
7809       {
7810         ContinueMoving(x, y);
7811
7812         /* continue moving after pushing (this is actually a bug) */
7813         if (!IS_MOVING(x, y))
7814         {
7815           Stop[x][y] = FALSE;
7816         }
7817       }
7818     }
7819   }
7820
7821   for (y = 0; y < lev_fieldy; y++) for (x = 0; x < lev_fieldx; x++)
7822   {
7823     Changed[x][y] = FALSE;
7824     ChangeEvent[x][y] = -1;
7825
7826     /* this must be handled before main playfield loop */
7827     if (Feld[x][y] == EL_PLAYER_IS_LEAVING)
7828     {
7829       MovDelay[x][y]--;
7830       if (MovDelay[x][y] <= 0)
7831         RemoveField(x, y);
7832     }
7833
7834 #if DEBUG
7835     if (ChangePage[x][y] != -1 && ChangeDelay[x][y] != 1)
7836     {
7837       printf("GameActions(): x = %d, y = %d: ChangePage != -1\n", x, y);
7838       printf("GameActions(): This should never happen!\n");
7839
7840       ChangePage[x][y] = -1;
7841     }
7842 #endif
7843
7844     Stop[x][y] = FALSE;
7845     if (WasJustMoving[x][y] > 0)
7846       WasJustMoving[x][y]--;
7847     if (WasJustFalling[x][y] > 0)
7848       WasJustFalling[x][y]--;
7849     if (CheckCollision[x][y] > 0)
7850       CheckCollision[x][y]--;
7851
7852     GfxFrame[x][y]++;
7853
7854     /* reset finished pushing action (not done in ContinueMoving() to allow
7855        continous pushing animation for elements with zero push delay) */
7856     if (GfxAction[x][y] == ACTION_PUSHING && !IS_MOVING(x, y))
7857     {
7858       ResetGfxAnimation(x, y);
7859       DrawLevelField(x, y);
7860     }
7861
7862 #if DEBUG
7863     if (IS_BLOCKED(x, y))
7864     {
7865       int oldx, oldy;
7866
7867       Blocked2Moving(x, y, &oldx, &oldy);
7868       if (!IS_MOVING(oldx, oldy))
7869       {
7870         printf("GameActions(): (BLOCKED => MOVING) context corrupted!\n");
7871         printf("GameActions(): BLOCKED: x = %d, y = %d\n", x, y);
7872         printf("GameActions(): !MOVING: oldx = %d, oldy = %d\n", oldx, oldy);
7873         printf("GameActions(): This should never happen!\n");
7874       }
7875     }
7876 #endif
7877   }
7878
7879   for (y = 0; y < lev_fieldy; y++) for (x = 0; x < lev_fieldx; x++)
7880   {
7881     element = Feld[x][y];
7882     graphic = el_act_dir2img(element, GfxAction[x][y], GfxDir[x][y]);
7883
7884     if (graphic_info[graphic].anim_global_sync)
7885       GfxFrame[x][y] = FrameCounter;
7886
7887     if (ANIM_MODE(graphic) == ANIM_RANDOM &&
7888         IS_NEXT_FRAME(GfxFrame[x][y], graphic))
7889       ResetRandomAnimationValue(x, y);
7890
7891     SetRandomAnimationValue(x, y);
7892
7893     PlayLevelSoundActionIfLoop(x, y, GfxAction[x][y]);
7894
7895     if (IS_INACTIVE(element))
7896     {
7897       if (IS_ANIMATED(graphic))
7898         DrawLevelGraphicAnimationIfNeeded(x, y, graphic);
7899
7900       continue;
7901     }
7902
7903     /* this may take place after moving, so 'element' may have changed */
7904     if (IS_CHANGING(x, y) &&
7905         (game.engine_version < VERSION_IDENT(3,0,7,1) || !Stop[x][y]))
7906     {
7907       int page = element_info[element].event_page_nr[CE_DELAY];
7908 #if 0
7909       ChangeElement(x, y, ChangePage[x][y] != -1 ? ChangePage[x][y] : page);
7910 #else
7911
7912 #if 0
7913       printf("::: ChangeDelay == %d\n", ChangeDelay[x][y]);
7914 #endif
7915
7916 #if 1
7917       ChangeElement(x, y, page);
7918 #else
7919       if (CAN_CHANGE(element))
7920         ChangeElement(x, y, page);
7921
7922       if (HAS_ACTION(element))
7923         ExecuteCustomElementAction(x, y, element, page);
7924 #endif
7925
7926 #endif
7927
7928       element = Feld[x][y];
7929       graphic = el_act_dir2img(element, GfxAction[x][y], GfxDir[x][y]);
7930     }
7931
7932     if (!IS_MOVING(x, y) && (CAN_FALL(element) || CAN_MOVE(element)))
7933     {
7934       StartMoving(x, y);
7935
7936       element = Feld[x][y];
7937       graphic = el_act_dir2img(element, GfxAction[x][y], GfxDir[x][y]);
7938
7939       if (IS_ANIMATED(graphic) &&
7940           !IS_MOVING(x, y) &&
7941           !Stop[x][y])
7942         DrawLevelGraphicAnimationIfNeeded(x, y, graphic);
7943
7944       if (IS_GEM(element) || element == EL_SP_INFOTRON)
7945         EdelsteinFunkeln(x, y);
7946     }
7947     else if ((element == EL_ACID ||
7948               element == EL_EXIT_OPEN ||
7949               element == EL_SP_EXIT_OPEN ||
7950               element == EL_SP_TERMINAL ||
7951               element == EL_SP_TERMINAL_ACTIVE ||
7952               element == EL_EXTRA_TIME ||
7953               element == EL_SHIELD_NORMAL ||
7954               element == EL_SHIELD_DEADLY) &&
7955              IS_ANIMATED(graphic))
7956       DrawLevelGraphicAnimationIfNeeded(x, y, graphic);
7957     else if (IS_MOVING(x, y))
7958       ContinueMoving(x, y);
7959     else if (IS_ACTIVE_BOMB(element))
7960       CheckDynamite(x, y);
7961     else if (element == EL_AMOEBA_GROWING)
7962       AmoebeWaechst(x, y);
7963     else if (element == EL_AMOEBA_SHRINKING)
7964       AmoebaDisappearing(x, y);
7965
7966 #if !USE_NEW_AMOEBA_CODE
7967     else if (IS_AMOEBALIVE(element))
7968       AmoebeAbleger(x, y);
7969 #endif
7970
7971     else if (element == EL_GAME_OF_LIFE || element == EL_BIOMAZE)
7972       Life(x, y);
7973     else if (element == EL_EXIT_CLOSED)
7974       CheckExit(x, y);
7975     else if (element == EL_SP_EXIT_CLOSED)
7976       CheckExitSP(x, y);
7977     else if (element == EL_EXPANDABLE_WALL_GROWING)
7978       MauerWaechst(x, y);
7979     else if (element == EL_EXPANDABLE_WALL ||
7980              element == EL_EXPANDABLE_WALL_HORIZONTAL ||
7981              element == EL_EXPANDABLE_WALL_VERTICAL ||
7982              element == EL_EXPANDABLE_WALL_ANY)
7983       MauerAbleger(x, y);
7984     else if (element == EL_FLAMES)
7985       CheckForDragon(x, y);
7986     else if (element == EL_EXPLOSION)
7987       ; /* drawing of correct explosion animation is handled separately */
7988     else if (IS_ANIMATED(graphic) && !IS_CHANGING(x, y))
7989       DrawLevelGraphicAnimationIfNeeded(x, y, graphic);
7990
7991     if (IS_BELT_ACTIVE(element))
7992       PlayLevelSoundAction(x, y, ACTION_ACTIVE);
7993
7994     if (game.magic_wall_active)
7995     {
7996       int jx = local_player->jx, jy = local_player->jy;
7997
7998       /* play the element sound at the position nearest to the player */
7999       if ((element == EL_MAGIC_WALL_FULL ||
8000            element == EL_MAGIC_WALL_ACTIVE ||
8001            element == EL_MAGIC_WALL_EMPTYING ||
8002            element == EL_BD_MAGIC_WALL_FULL ||
8003            element == EL_BD_MAGIC_WALL_ACTIVE ||
8004            element == EL_BD_MAGIC_WALL_EMPTYING) &&
8005           ABS(x-jx) + ABS(y-jy) < ABS(magic_wall_x-jx) + ABS(magic_wall_y-jy))
8006       {
8007         magic_wall_x = x;
8008         magic_wall_y = y;
8009       }
8010     }
8011   }
8012
8013 #if USE_NEW_AMOEBA_CODE
8014   /* new experimental amoeba growth stuff */
8015   if (!(FrameCounter % 8))
8016   {
8017     static unsigned long random = 1684108901;
8018
8019     for (i = 0; i < level.amoeba_speed * 28 / 8; i++)
8020     {
8021       x = RND(lev_fieldx);
8022       y = RND(lev_fieldy);
8023       element = Feld[x][y];
8024
8025       if (!IS_PLAYER(x,y) &&
8026           (element == EL_EMPTY ||
8027            CAN_GROW_INTO(element) ||
8028            element == EL_QUICKSAND_EMPTY ||
8029            element == EL_ACID_SPLASH_LEFT ||
8030            element == EL_ACID_SPLASH_RIGHT))
8031       {
8032         if ((IN_LEV_FIELD(x, y-1) && Feld[x][y-1] == EL_AMOEBA_WET) ||
8033             (IN_LEV_FIELD(x-1, y) && Feld[x-1][y] == EL_AMOEBA_WET) ||
8034             (IN_LEV_FIELD(x+1, y) && Feld[x+1][y] == EL_AMOEBA_WET) ||
8035             (IN_LEV_FIELD(x, y+1) && Feld[x][y+1] == EL_AMOEBA_WET))
8036           Feld[x][y] = EL_AMOEBA_DROP;
8037       }
8038
8039       random = random * 129 + 1;
8040     }
8041   }
8042 #endif
8043
8044 #if 0
8045   if (game.explosions_delayed)
8046 #endif
8047   {
8048     game.explosions_delayed = FALSE;
8049
8050     for (y = 0; y < lev_fieldy; y++) for (x = 0; x < lev_fieldx; x++)
8051     {
8052       element = Feld[x][y];
8053
8054       if (ExplodeField[x][y])
8055         Explode(x, y, EX_PHASE_START, ExplodeField[x][y]);
8056       else if (element == EL_EXPLOSION)
8057         Explode(x, y, ExplodePhase[x][y], EX_TYPE_NORMAL);
8058
8059       ExplodeField[x][y] = EX_TYPE_NONE;
8060     }
8061
8062     game.explosions_delayed = TRUE;
8063   }
8064
8065   if (game.magic_wall_active)
8066   {
8067     if (!(game.magic_wall_time_left % 4))
8068     {
8069       int element = Feld[magic_wall_x][magic_wall_y];
8070
8071       if (element == EL_BD_MAGIC_WALL_FULL ||
8072           element == EL_BD_MAGIC_WALL_ACTIVE ||
8073           element == EL_BD_MAGIC_WALL_EMPTYING)
8074         PlayLevelSound(magic_wall_x, magic_wall_y, SND_BD_MAGIC_WALL_ACTIVE);
8075       else
8076         PlayLevelSound(magic_wall_x, magic_wall_y, SND_MAGIC_WALL_ACTIVE);
8077     }
8078
8079     if (game.magic_wall_time_left > 0)
8080     {
8081       game.magic_wall_time_left--;
8082       if (!game.magic_wall_time_left)
8083       {
8084         for (y = 0; y < lev_fieldy; y++) for (x = 0; x < lev_fieldx; x++)
8085         {
8086           element = Feld[x][y];
8087
8088           if (element == EL_MAGIC_WALL_ACTIVE ||
8089               element == EL_MAGIC_WALL_FULL)
8090           {
8091             Feld[x][y] = EL_MAGIC_WALL_DEAD;
8092             DrawLevelField(x, y);
8093           }
8094           else if (element == EL_BD_MAGIC_WALL_ACTIVE ||
8095                    element == EL_BD_MAGIC_WALL_FULL)
8096           {
8097             Feld[x][y] = EL_BD_MAGIC_WALL_DEAD;
8098             DrawLevelField(x, y);
8099           }
8100         }
8101
8102         game.magic_wall_active = FALSE;
8103       }
8104     }
8105   }
8106
8107   if (game.light_time_left > 0)
8108   {
8109     game.light_time_left--;
8110
8111     if (game.light_time_left == 0)
8112       RedrawAllLightSwitchesAndInvisibleElements();
8113   }
8114
8115   if (game.timegate_time_left > 0)
8116   {
8117     game.timegate_time_left--;
8118
8119     if (game.timegate_time_left == 0)
8120       CloseAllOpenTimegates();
8121   }
8122
8123   for (i = 0; i < MAX_PLAYERS; i++)
8124   {
8125     struct PlayerInfo *player = &stored_player[i];
8126
8127     if (SHIELD_ON(player))
8128     {
8129       if (player->shield_deadly_time_left)
8130         PlayLevelSound(player->jx, player->jy, SND_SHIELD_DEADLY_ACTIVE);
8131       else if (player->shield_normal_time_left)
8132         PlayLevelSound(player->jx, player->jy, SND_SHIELD_NORMAL_ACTIVE);
8133     }
8134   }
8135
8136   if (TimeFrames >= FRAMES_PER_SECOND)
8137   {
8138     TimeFrames = 0;
8139     TapeTime++;
8140
8141     for (i = 0; i < MAX_PLAYERS; i++)
8142     {
8143       struct PlayerInfo *player = &stored_player[i];
8144
8145       if (SHIELD_ON(player))
8146       {
8147         player->shield_normal_time_left--;
8148
8149         if (player->shield_deadly_time_left > 0)
8150           player->shield_deadly_time_left--;
8151       }
8152     }
8153
8154     if (!level.use_step_counter)
8155     {
8156       TimePlayed++;
8157
8158       if (TimeLeft > 0)
8159       {
8160         TimeLeft--;
8161
8162         if (TimeLeft <= 10 && setup.time_limit)
8163           PlaySoundStereo(SND_GAME_RUNNING_OUT_OF_TIME, SOUND_MIDDLE);
8164
8165         DrawGameValue_Time(TimeLeft);
8166
8167         if (!TimeLeft && setup.time_limit)
8168           for (i = 0; i < MAX_PLAYERS; i++)
8169             KillPlayer(&stored_player[i]);
8170       }
8171       else if (level.time == 0 && !AllPlayersGone) /* level w/o time limit */
8172         DrawGameValue_Time(TimePlayed);
8173     }
8174
8175     if (tape.recording || tape.playing)
8176       DrawVideoDisplay(VIDEO_STATE_TIME_ON, TapeTime);
8177   }
8178
8179   DrawAllPlayers();
8180   PlayAllPlayersSound();
8181
8182   if (options.debug)                    /* calculate frames per second */
8183   {
8184     static unsigned long fps_counter = 0;
8185     static int fps_frames = 0;
8186     unsigned long fps_delay_ms = Counter() - fps_counter;
8187
8188     fps_frames++;
8189
8190     if (fps_delay_ms >= 500)    /* calculate fps every 0.5 seconds */
8191     {
8192       global.frames_per_second = 1000 * (float)fps_frames / fps_delay_ms;
8193
8194       fps_frames = 0;
8195       fps_counter = Counter();
8196     }
8197
8198     redraw_mask |= REDRAW_FPS;
8199   }
8200
8201   AdvanceFrameAndPlayerCounters(-1);    /* advance counters for all players */
8202
8203   if (local_player->show_envelope != 0 && local_player->MovPos == 0)
8204   {
8205     ShowEnvelope(local_player->show_envelope - EL_ENVELOPE_1);
8206
8207     local_player->show_envelope = 0;
8208   }
8209
8210   /* use random number generator in every frame to make it less predictable */
8211   if (game.engine_version >= VERSION_IDENT(3,1,1,0))
8212     RND(1);
8213 }
8214
8215 static boolean AllPlayersInSight(struct PlayerInfo *player, int x, int y)
8216 {
8217   int min_x = x, min_y = y, max_x = x, max_y = y;
8218   int i;
8219
8220   for (i = 0; i < MAX_PLAYERS; i++)
8221   {
8222     int jx = stored_player[i].jx, jy = stored_player[i].jy;
8223
8224     if (!stored_player[i].active || &stored_player[i] == player)
8225       continue;
8226
8227     min_x = MIN(min_x, jx);
8228     min_y = MIN(min_y, jy);
8229     max_x = MAX(max_x, jx);
8230     max_y = MAX(max_y, jy);
8231   }
8232
8233   return (max_x - min_x < SCR_FIELDX && max_y - min_y < SCR_FIELDY);
8234 }
8235
8236 static boolean AllPlayersInVisibleScreen()
8237 {
8238   int i;
8239
8240   for (i = 0; i < MAX_PLAYERS; i++)
8241   {
8242     int jx = stored_player[i].jx, jy = stored_player[i].jy;
8243
8244     if (!stored_player[i].active)
8245       continue;
8246
8247     if (!IN_VIS_FIELD(SCREENX(jx), SCREENY(jy)))
8248       return FALSE;
8249   }
8250
8251   return TRUE;
8252 }
8253
8254 void ScrollLevel(int dx, int dy)
8255 {
8256   int softscroll_offset = (setup.soft_scrolling ? TILEX : 0);
8257   int x, y;
8258
8259   BlitBitmap(drawto_field, drawto_field,
8260              FX + TILEX * (dx == -1) - softscroll_offset,
8261              FY + TILEY * (dy == -1) - softscroll_offset,
8262              SXSIZE - TILEX * (dx!=0) + 2 * softscroll_offset,
8263              SYSIZE - TILEY * (dy!=0) + 2 * softscroll_offset,
8264              FX + TILEX * (dx == 1) - softscroll_offset,
8265              FY + TILEY * (dy == 1) - softscroll_offset);
8266
8267   if (dx)
8268   {
8269     x = (dx == 1 ? BX1 : BX2);
8270     for (y = BY1; y <= BY2; y++)
8271       DrawScreenField(x, y);
8272   }
8273
8274   if (dy)
8275   {
8276     y = (dy == 1 ? BY1 : BY2);
8277     for (x = BX1; x <= BX2; x++)
8278       DrawScreenField(x, y);
8279   }
8280
8281   redraw_mask |= REDRAW_FIELD;
8282 }
8283
8284 static boolean canFallDown(struct PlayerInfo *player)
8285 {
8286   int jx = player->jx, jy = player->jy;
8287
8288   return (IN_LEV_FIELD(jx, jy + 1) &&
8289           (IS_FREE(jx, jy + 1) ||
8290            (Feld[jx][jy + 1] == EL_ACID && player->can_fall_into_acid)) &&
8291           IS_WALKABLE_FROM(Feld[jx][jy], MV_DOWN) &&
8292           !IS_WALKABLE_INSIDE(Feld[jx][jy]));
8293 }
8294
8295 static boolean canPassField(int x, int y, int move_dir)
8296 {
8297   int opposite_dir = MV_DIR_OPPOSITE(move_dir);
8298   int dx = (move_dir & MV_LEFT ? -1 : move_dir & MV_RIGHT ? +1 : 0);
8299   int dy = (move_dir & MV_UP   ? -1 : move_dir & MV_DOWN  ? +1 : 0);
8300   int nextx = x + dx;
8301   int nexty = y + dy;
8302   int element = Feld[x][y];
8303
8304   return (IS_PASSABLE_FROM(element, opposite_dir) &&
8305           !CAN_MOVE(element) &&
8306           IN_LEV_FIELD(nextx, nexty) && !IS_PLAYER(nextx, nexty) &&
8307           IS_WALKABLE_FROM(Feld[nextx][nexty], move_dir) &&
8308           (level.can_pass_to_walkable || IS_FREE(nextx, nexty)));
8309 }
8310
8311 static boolean canMoveToValidFieldWithGravity(int x, int y, int move_dir)
8312 {
8313   int opposite_dir = MV_DIR_OPPOSITE(move_dir);
8314   int dx = (move_dir & MV_LEFT ? -1 : move_dir & MV_RIGHT ? +1 : 0);
8315   int dy = (move_dir & MV_UP   ? -1 : move_dir & MV_DOWN  ? +1 : 0);
8316   int newx = x + dx;
8317   int newy = y + dy;
8318
8319   return (IN_LEV_FIELD(newx, newy) && !IS_FREE_OR_PLAYER(newx, newy) &&
8320           IS_GRAVITY_REACHABLE(Feld[newx][newy]) &&
8321           (IS_DIGGABLE(Feld[newx][newy]) ||
8322            IS_WALKABLE_FROM(Feld[newx][newy], opposite_dir) ||
8323            canPassField(newx, newy, move_dir)));
8324 }
8325
8326 static void CheckGravityMovement(struct PlayerInfo *player)
8327 {
8328   if (game.gravity && !player->programmed_action)
8329   {
8330     int move_dir_horizontal = player->effective_action & MV_HORIZONTAL;
8331     int move_dir_vertical   = player->effective_action & MV_VERTICAL;
8332     boolean player_is_snapping = player->effective_action & JOY_BUTTON_1;
8333     int jx = player->jx, jy = player->jy;
8334     boolean player_is_moving_to_valid_field =
8335       (!player_is_snapping &&
8336        (canMoveToValidFieldWithGravity(jx, jy, move_dir_horizontal) ||
8337         canMoveToValidFieldWithGravity(jx, jy, move_dir_vertical)));
8338     boolean player_can_fall_down = canFallDown(player);
8339
8340     if (player_can_fall_down &&
8341         !player_is_moving_to_valid_field)
8342       player->programmed_action = MV_DOWN;
8343   }
8344 }
8345
8346 static void CheckGravityMovementWhenNotMoving(struct PlayerInfo *player)
8347 {
8348   return CheckGravityMovement(player);
8349
8350   if (game.gravity && !player->programmed_action)
8351   {
8352     int jx = player->jx, jy = player->jy;
8353     boolean field_under_player_is_free =
8354       (IN_LEV_FIELD(jx, jy + 1) && IS_FREE(jx, jy + 1));
8355     boolean player_is_standing_on_valid_field =
8356       (IS_WALKABLE_INSIDE(Feld[jx][jy]) ||
8357        (IS_WALKABLE(Feld[jx][jy]) &&
8358         !(element_info[Feld[jx][jy]].access_direction & MV_DOWN)));
8359
8360     if (field_under_player_is_free && !player_is_standing_on_valid_field)
8361       player->programmed_action = MV_DOWN;
8362   }
8363 }
8364
8365 /*
8366   MovePlayerOneStep()
8367   -----------------------------------------------------------------------------
8368   dx, dy:               direction (non-diagonal) to try to move the player to
8369   real_dx, real_dy:     direction as read from input device (can be diagonal)
8370 */
8371
8372 boolean MovePlayerOneStep(struct PlayerInfo *player,
8373                           int dx, int dy, int real_dx, int real_dy)
8374 {
8375   int jx = player->jx, jy = player->jy;
8376   int new_jx = jx + dx, new_jy = jy + dy;
8377   int element;
8378   int can_move;
8379
8380   if (!player->active || (!dx && !dy))
8381     return MF_NO_ACTION;
8382
8383   player->MovDir = (dx < 0 ? MV_LEFT :
8384                     dx > 0 ? MV_RIGHT :
8385                     dy < 0 ? MV_UP :
8386                     dy > 0 ? MV_DOWN :  MV_NO_MOVING);
8387
8388   if (!IN_LEV_FIELD(new_jx, new_jy))
8389     return MF_NO_ACTION;
8390
8391   if (!options.network && !AllPlayersInSight(player, new_jx, new_jy))
8392     return MF_NO_ACTION;
8393
8394   element = MovingOrBlocked2ElementIfNotLeaving(new_jx, new_jy);
8395
8396   if (DONT_RUN_INTO(element))
8397   {
8398     if (element == EL_ACID && dx == 0 && dy == 1)
8399     {
8400       SplashAcid(new_jx, new_jy);
8401       Feld[jx][jy] = EL_PLAYER_1;
8402       InitMovingField(jx, jy, MV_DOWN);
8403       Store[jx][jy] = EL_ACID;
8404       ContinueMoving(jx, jy);
8405       BuryPlayer(player);
8406     }
8407     else
8408       TestIfPlayerRunsIntoBadThing(jx, jy, player->MovDir);
8409
8410     return MF_MOVING;
8411   }
8412
8413   can_move = DigField(player, jx, jy, new_jx, new_jy, real_dx,real_dy, DF_DIG);
8414   if (can_move != MF_MOVING)
8415     return can_move;
8416
8417   /* check if DigField() has caused relocation of the player */
8418   if (player->jx != jx || player->jy != jy)
8419     return MF_NO_ACTION;        /* <-- !!! CHECK THIS [-> MF_ACTION ?] !!! */
8420
8421   StorePlayer[jx][jy] = 0;
8422   player->last_jx = jx;
8423   player->last_jy = jy;
8424   player->jx = new_jx;
8425   player->jy = new_jy;
8426   StorePlayer[new_jx][new_jy] = player->element_nr;
8427
8428   if (player->move_delay_value_next != -1)
8429   {
8430     player->move_delay_value = player->move_delay_value_next;
8431     player->move_delay_value_next = -1;
8432   }
8433
8434   player->MovPos =
8435     (dx > 0 || dy > 0 ? -1 : 1) * (TILEX - TILEX / player->move_delay_value);
8436
8437   player->step_counter++;
8438
8439   PlayerVisit[jx][jy] = FrameCounter;
8440
8441   ScrollPlayer(player, SCROLL_INIT);
8442
8443   return MF_MOVING;
8444 }
8445
8446 boolean MovePlayer(struct PlayerInfo *player, int dx, int dy)
8447 {
8448   int jx = player->jx, jy = player->jy;
8449   int old_jx = jx, old_jy = jy;
8450   int moved = MF_NO_ACTION;
8451
8452   if (!player->active)
8453     return FALSE;
8454
8455   if (!dx && !dy)
8456   {
8457     if (player->MovPos == 0)
8458     {
8459       player->is_moving = FALSE;
8460       player->is_digging = FALSE;
8461       player->is_collecting = FALSE;
8462       player->is_snapping = FALSE;
8463       player->is_pushing = FALSE;
8464     }
8465
8466     return FALSE;
8467   }
8468
8469   if (player->move_delay > 0)
8470     return FALSE;
8471
8472   player->move_delay = -1;              /* set to "uninitialized" value */
8473
8474   /* store if player is automatically moved to next field */
8475   player->is_auto_moving = (player->programmed_action != MV_NO_MOVING);
8476
8477   /* remove the last programmed player action */
8478   player->programmed_action = 0;
8479
8480   if (player->MovPos)
8481   {
8482     /* should only happen if pre-1.2 tape recordings are played */
8483     /* this is only for backward compatibility */
8484
8485     int original_move_delay_value = player->move_delay_value;
8486
8487 #if DEBUG
8488     printf("THIS SHOULD ONLY HAPPEN WITH PRE-1.2 LEVEL TAPES. [%ld]\n",
8489            tape.counter);
8490 #endif
8491
8492     /* scroll remaining steps with finest movement resolution */
8493     player->move_delay_value = MOVE_DELAY_NORMAL_SPEED;
8494
8495     while (player->MovPos)
8496     {
8497       ScrollPlayer(player, SCROLL_GO_ON);
8498       ScrollScreen(NULL, SCROLL_GO_ON);
8499
8500       AdvanceFrameAndPlayerCounters(player->index_nr);
8501
8502       DrawAllPlayers();
8503       BackToFront();
8504     }
8505
8506     player->move_delay_value = original_move_delay_value;
8507   }
8508
8509   if (player->last_move_dir & MV_HORIZONTAL)
8510   {
8511     if (!(moved |= MovePlayerOneStep(player, 0, dy, dx, dy)))
8512       moved |= MovePlayerOneStep(player, dx, 0, dx, dy);
8513   }
8514   else
8515   {
8516     if (!(moved |= MovePlayerOneStep(player, dx, 0, dx, dy)))
8517       moved |= MovePlayerOneStep(player, 0, dy, dx, dy);
8518   }
8519
8520   jx = player->jx;
8521   jy = player->jy;
8522
8523   if (moved & MF_MOVING && !ScreenMovPos &&
8524       (player == local_player || !options.network))
8525   {
8526     int old_scroll_x = scroll_x, old_scroll_y = scroll_y;
8527     int offset = (setup.scroll_delay ? 3 : 0);
8528
8529     if (!IN_VIS_FIELD(SCREENX(jx), SCREENY(jy)))
8530     {
8531       /* actual player has left the screen -- scroll in that direction */
8532       if (jx != old_jx)         /* player has moved horizontally */
8533         scroll_x += (jx - old_jx);
8534       else                      /* player has moved vertically */
8535         scroll_y += (jy - old_jy);
8536     }
8537     else
8538     {
8539       if (jx != old_jx)         /* player has moved horizontally */
8540       {
8541         if ((player->MovDir == MV_LEFT  && scroll_x > jx - MIDPOSX + offset) ||
8542             (player->MovDir == MV_RIGHT && scroll_x < jx - MIDPOSX - offset))
8543           scroll_x = jx-MIDPOSX + (scroll_x < jx-MIDPOSX ? -offset : +offset);
8544
8545         /* don't scroll over playfield boundaries */
8546         if (scroll_x < SBX_Left || scroll_x > SBX_Right)
8547           scroll_x = (scroll_x < SBX_Left ? SBX_Left : SBX_Right);
8548
8549         /* don't scroll more than one field at a time */
8550         scroll_x = old_scroll_x + SIGN(scroll_x - old_scroll_x);
8551
8552         /* don't scroll against the player's moving direction */
8553         if ((player->MovDir == MV_LEFT  && scroll_x > old_scroll_x) ||
8554             (player->MovDir == MV_RIGHT && scroll_x < old_scroll_x))
8555           scroll_x = old_scroll_x;
8556       }
8557       else                      /* player has moved vertically */
8558       {
8559         if ((player->MovDir == MV_UP   && scroll_y > jy - MIDPOSY + offset) ||
8560             (player->MovDir == MV_DOWN && scroll_y < jy - MIDPOSY - offset))
8561           scroll_y = jy-MIDPOSY + (scroll_y < jy-MIDPOSY ? -offset : +offset);
8562
8563         /* don't scroll over playfield boundaries */
8564         if (scroll_y < SBY_Upper || scroll_y > SBY_Lower)
8565           scroll_y = (scroll_y < SBY_Upper ? SBY_Upper : SBY_Lower);
8566
8567         /* don't scroll more than one field at a time */
8568         scroll_y = old_scroll_y + SIGN(scroll_y - old_scroll_y);
8569
8570         /* don't scroll against the player's moving direction */
8571         if ((player->MovDir == MV_UP   && scroll_y > old_scroll_y) ||
8572             (player->MovDir == MV_DOWN && scroll_y < old_scroll_y))
8573           scroll_y = old_scroll_y;
8574       }
8575     }
8576
8577     if (scroll_x != old_scroll_x || scroll_y != old_scroll_y)
8578     {
8579       if (!options.network && !AllPlayersInVisibleScreen())
8580       {
8581         scroll_x = old_scroll_x;
8582         scroll_y = old_scroll_y;
8583       }
8584       else
8585       {
8586         ScrollScreen(player, SCROLL_INIT);
8587         ScrollLevel(old_scroll_x - scroll_x, old_scroll_y - scroll_y);
8588       }
8589     }
8590   }
8591
8592   player->StepFrame = 0;
8593
8594   if (moved & MF_MOVING)
8595   {
8596     if (old_jx != jx && old_jy == jy)
8597       player->MovDir = (old_jx < jx ? MV_RIGHT : MV_LEFT);
8598     else if (old_jx == jx && old_jy != jy)
8599       player->MovDir = (old_jy < jy ? MV_DOWN : MV_UP);
8600
8601     DrawLevelField(jx, jy);     /* for "crumbled sand" */
8602
8603     player->last_move_dir = player->MovDir;
8604     player->is_moving = TRUE;
8605     player->is_snapping = FALSE;
8606     player->is_switching = FALSE;
8607     player->is_dropping = FALSE;
8608   }
8609   else
8610   {
8611     CheckGravityMovementWhenNotMoving(player);
8612
8613     player->is_moving = FALSE;
8614
8615     /* at this point, the player is allowed to move, but cannot move right now
8616        (e.g. because of something blocking the way) -- ensure that the player
8617        is also allowed to move in the next frame (in old versions before 3.1.1,
8618        the player was forced to wait again for eight frames before next try) */
8619
8620     if (game.engine_version >= VERSION_IDENT(3,1,1,0))
8621       player->move_delay = 0;   /* allow direct movement in the next frame */
8622   }
8623
8624   if (player->move_delay == -1)         /* not yet initialized by DigField() */
8625     player->move_delay = player->move_delay_value;
8626
8627   if (game.engine_version < VERSION_IDENT(3,0,7,0))
8628   {
8629     TestIfPlayerTouchesBadThing(jx, jy);
8630     TestIfPlayerTouchesCustomElement(jx, jy);
8631   }
8632
8633   if (!player->active)
8634     RemovePlayer(player);
8635
8636   return moved;
8637 }
8638
8639 void ScrollPlayer(struct PlayerInfo *player, int mode)
8640 {
8641   int jx = player->jx, jy = player->jy;
8642   int last_jx = player->last_jx, last_jy = player->last_jy;
8643   int move_stepsize = TILEX / player->move_delay_value;
8644
8645 #if USE_NEW_PLAYER_SPEED
8646   if (!player->active)
8647     return;
8648
8649   if (player->MovPos == 0 && mode == SCROLL_GO_ON)      /* player not moving */
8650     return;
8651 #else
8652   if (!player->active || player->MovPos == 0)
8653     return;
8654 #endif
8655
8656   if (mode == SCROLL_INIT)
8657   {
8658     player->actual_frame_counter = FrameCounter;
8659     player->GfxPos = move_stepsize * (player->MovPos / move_stepsize);
8660
8661     if ((player->block_last_field || player->block_delay_adjustment > 0) &&
8662         Feld[last_jx][last_jy] == EL_EMPTY)
8663     {
8664       int last_field_block_delay = 0;   /* start with no blocking at all */
8665       int block_delay_adjustment = player->block_delay_adjustment;
8666
8667       /* if player blocks last field, add delay for exactly one move */
8668       if (player->block_last_field)
8669       {
8670         last_field_block_delay += player->move_delay_value;
8671
8672         /* when blocking enabled, prevent moving up despite gravity */
8673         if (game.gravity && player->MovDir == MV_UP)
8674           block_delay_adjustment = -1;
8675       }
8676
8677       /* add block delay adjustment (also possible when not blocking) */
8678       last_field_block_delay += block_delay_adjustment;
8679
8680       Feld[last_jx][last_jy] = EL_PLAYER_IS_LEAVING;
8681       MovDelay[last_jx][last_jy] = last_field_block_delay + 1;
8682     }
8683
8684 #if USE_NEW_PLAYER_SPEED
8685     if (player->MovPos != 0)    /* player has not yet reached destination */
8686       return;
8687 #else
8688     return;
8689 #endif
8690   }
8691   else if (!FrameReached(&player->actual_frame_counter, 1))
8692     return;
8693
8694 #if 0
8695   printf("::: player->MovPos: %d -> %d\n",
8696          player->MovPos,
8697          player->MovPos + (player->MovPos > 0 ? -1 : 1) * move_stepsize);
8698 #endif
8699
8700 #if USE_NEW_PLAYER_SPEED
8701   if (player->MovPos != 0)
8702   {
8703     player->MovPos += (player->MovPos > 0 ? -1 : 1) * move_stepsize;
8704     player->GfxPos = move_stepsize * (player->MovPos / move_stepsize);
8705
8706     /* before DrawPlayer() to draw correct player graphic for this case */
8707     if (player->MovPos == 0)
8708       CheckGravityMovement(player);
8709   }
8710 #else
8711   player->MovPos += (player->MovPos > 0 ? -1 : 1) * move_stepsize;
8712   player->GfxPos = move_stepsize * (player->MovPos / move_stepsize);
8713
8714   /* before DrawPlayer() to draw correct player graphic for this case */
8715   if (player->MovPos == 0)
8716     CheckGravityMovement(player);
8717 #endif
8718
8719   if (player->MovPos == 0)      /* player reached destination field */
8720   {
8721 #if 0
8722     printf("::: player reached destination field\n");
8723 #endif
8724
8725     if (player->move_delay_reset_counter > 0)
8726     {
8727       player->move_delay_reset_counter--;
8728
8729       if (player->move_delay_reset_counter == 0)
8730       {
8731         /* continue with normal speed after quickly moving through gate */
8732         HALVE_PLAYER_SPEED(player);
8733
8734         /* be able to make the next move without delay */
8735         player->move_delay = 0;
8736       }
8737     }
8738
8739     player->last_jx = jx;
8740     player->last_jy = jy;
8741
8742     if (Feld[jx][jy] == EL_EXIT_OPEN ||
8743         Feld[jx][jy] == EL_SP_EXIT_OPEN ||
8744         Feld[jx][jy] == EL_SP_EXIT_OPENING)     /* <-- special case */
8745     {
8746       DrawPlayer(player);       /* needed here only to cleanup last field */
8747       RemovePlayer(player);
8748
8749       if (local_player->friends_still_needed == 0 ||
8750           IS_SP_ELEMENT(Feld[jx][jy]))
8751         player->LevelSolved = player->GameOver = TRUE;
8752     }
8753
8754     /* this breaks one level: "machine", level 000 */
8755     {
8756       int move_direction = player->MovDir;
8757       int enter_side = MV_DIR_OPPOSITE(move_direction);
8758       int leave_side = move_direction;
8759       int old_jx = last_jx;
8760       int old_jy = last_jy;
8761       int old_element = Feld[old_jx][old_jy];
8762       int new_element = Feld[jx][jy];
8763
8764       if (IS_CUSTOM_ELEMENT(old_element))
8765         CheckElementChangeByPlayer(old_jx, old_jy, old_element,
8766                                    CE_LEFT_BY_PLAYER,
8767                                    player->index_bit, leave_side);
8768
8769       CheckTriggeredElementChangeByPlayer(old_element, CE_PLAYER_LEAVES_X,
8770                                           player->index_bit, leave_side);
8771
8772       if (IS_CUSTOM_ELEMENT(new_element))
8773         CheckElementChangeByPlayer(jx, jy, new_element, CE_ENTERED_BY_PLAYER,
8774                                    player->index_bit, enter_side);
8775
8776       CheckTriggeredElementChangeByPlayer(new_element, CE_PLAYER_ENTERS_X,
8777                                           player->index_bit, enter_side);
8778     }
8779
8780     if (game.engine_version >= VERSION_IDENT(3,0,7,0))
8781     {
8782       TestIfPlayerTouchesBadThing(jx, jy);
8783       TestIfPlayerTouchesCustomElement(jx, jy);
8784
8785       /* needed because pushed element has not yet reached its destination,
8786          so it would trigger a change event at its previous field location */
8787       if (!player->is_pushing)
8788         TestIfElementTouchesCustomElement(jx, jy);      /* for empty space */
8789
8790       if (!player->active)
8791         RemovePlayer(player);
8792     }
8793
8794     if (level.use_step_counter)
8795     {
8796       int i;
8797
8798       TimePlayed++;
8799
8800       if (TimeLeft > 0)
8801       {
8802         TimeLeft--;
8803
8804         if (TimeLeft <= 10 && setup.time_limit)
8805           PlaySoundStereo(SND_GAME_RUNNING_OUT_OF_TIME, SOUND_MIDDLE);
8806
8807         DrawGameValue_Time(TimeLeft);
8808
8809         if (!TimeLeft && setup.time_limit)
8810           for (i = 0; i < MAX_PLAYERS; i++)
8811             KillPlayer(&stored_player[i]);
8812       }
8813       else if (level.time == 0 && !AllPlayersGone) /* level w/o time limit */
8814         DrawGameValue_Time(TimePlayed);
8815     }
8816
8817     if (tape.single_step && tape.recording && !tape.pausing &&
8818         !player->programmed_action)
8819       TapeTogglePause(TAPE_TOGGLE_AUTOMATIC);
8820   }
8821 }
8822
8823 void ScrollScreen(struct PlayerInfo *player, int mode)
8824 {
8825   static unsigned long screen_frame_counter = 0;
8826
8827   if (mode == SCROLL_INIT)
8828   {
8829     /* set scrolling step size according to actual player's moving speed */
8830     ScrollStepSize = TILEX / player->move_delay_value;
8831
8832     screen_frame_counter = FrameCounter;
8833     ScreenMovDir = player->MovDir;
8834     ScreenMovPos = player->MovPos;
8835     ScreenGfxPos = ScrollStepSize * (ScreenMovPos / ScrollStepSize);
8836     return;
8837   }
8838   else if (!FrameReached(&screen_frame_counter, 1))
8839     return;
8840
8841   if (ScreenMovPos)
8842   {
8843     ScreenMovPos += (ScreenMovPos > 0 ? -1 : 1) * ScrollStepSize;
8844     ScreenGfxPos = ScrollStepSize * (ScreenMovPos / ScrollStepSize);
8845     redraw_mask |= REDRAW_FIELD;
8846   }
8847   else
8848     ScreenMovDir = MV_NO_MOVING;
8849 }
8850
8851 void TestIfPlayerTouchesCustomElement(int x, int y)
8852 {
8853   static int xy[4][2] =
8854   {
8855     { 0, -1 },
8856     { -1, 0 },
8857     { +1, 0 },
8858     { 0, +1 }
8859   };
8860   static int trigger_sides[4][2] =
8861   {
8862     /* center side       border side */
8863     { CH_SIDE_TOP,      CH_SIDE_BOTTOM  },      /* check top    */
8864     { CH_SIDE_LEFT,     CH_SIDE_RIGHT   },      /* check left   */
8865     { CH_SIDE_RIGHT,    CH_SIDE_LEFT    },      /* check right  */
8866     { CH_SIDE_BOTTOM,   CH_SIDE_TOP     }       /* check bottom */
8867   };
8868   static int touch_dir[4] =
8869   {
8870     MV_LEFT | MV_RIGHT,
8871     MV_UP   | MV_DOWN,
8872     MV_UP   | MV_DOWN,
8873     MV_LEFT | MV_RIGHT
8874   };
8875   int center_element = Feld[x][y];      /* should always be non-moving! */
8876   int i;
8877
8878   for (i = 0; i < NUM_DIRECTIONS; i++)
8879   {
8880     int xx = x + xy[i][0];
8881     int yy = y + xy[i][1];
8882     int center_side = trigger_sides[i][0];
8883     int border_side = trigger_sides[i][1];
8884     int border_element;
8885
8886     if (!IN_LEV_FIELD(xx, yy))
8887       continue;
8888
8889     if (IS_PLAYER(x, y))
8890     {
8891       struct PlayerInfo *player = PLAYERINFO(x, y);
8892
8893       if (game.engine_version < VERSION_IDENT(3,0,7,0))
8894         border_element = Feld[xx][yy];          /* may be moving! */
8895       else if (!IS_MOVING(xx, yy) && !IS_BLOCKED(xx, yy))
8896         border_element = Feld[xx][yy];
8897       else if (MovDir[xx][yy] & touch_dir[i])   /* elements are touching */
8898         border_element = MovingOrBlocked2Element(xx, yy);
8899       else
8900         continue;               /* center and border element do not touch */
8901
8902       CheckElementChangeByPlayer(xx, yy, border_element, CE_TOUCHED_BY_PLAYER,
8903                                  player->index_bit, border_side);
8904       CheckTriggeredElementChangeByPlayer(border_element, CE_PLAYER_TOUCHES_X,
8905                                           player->index_bit, border_side);
8906     }
8907     else if (IS_PLAYER(xx, yy))
8908     {
8909       struct PlayerInfo *player = PLAYERINFO(xx, yy);
8910
8911       if (game.engine_version >= VERSION_IDENT(3,0,7,0))
8912       {
8913         if (player->MovPos != 0 && !(player->MovDir & touch_dir[i]))
8914           continue;             /* center and border element do not touch */
8915       }
8916
8917       CheckElementChangeByPlayer(x, y, center_element, CE_TOUCHED_BY_PLAYER,
8918                                  player->index_bit, center_side);
8919       CheckTriggeredElementChangeByPlayer(center_element, CE_PLAYER_TOUCHES_X,
8920                                           player->index_bit, center_side);
8921       break;
8922     }
8923   }
8924 }
8925
8926 void TestIfElementTouchesCustomElement(int x, int y)
8927 {
8928   static int xy[4][2] =
8929   {
8930     { 0, -1 },
8931     { -1, 0 },
8932     { +1, 0 },
8933     { 0, +1 }
8934   };
8935   static int trigger_sides[4][2] =
8936   {
8937     /* center side      border side */
8938     { CH_SIDE_TOP,      CH_SIDE_BOTTOM  },      /* check top    */
8939     { CH_SIDE_LEFT,     CH_SIDE_RIGHT   },      /* check left   */
8940     { CH_SIDE_RIGHT,    CH_SIDE_LEFT    },      /* check right  */
8941     { CH_SIDE_BOTTOM,   CH_SIDE_TOP     }       /* check bottom */
8942   };
8943   static int touch_dir[4] =
8944   {
8945     MV_LEFT | MV_RIGHT,
8946     MV_UP   | MV_DOWN,
8947     MV_UP   | MV_DOWN,
8948     MV_LEFT | MV_RIGHT
8949   };
8950   boolean change_center_element = FALSE;
8951   int center_element = Feld[x][y];      /* should always be non-moving! */
8952   int i;
8953
8954   for (i = 0; i < NUM_DIRECTIONS; i++)
8955   {
8956     int xx = x + xy[i][0];
8957     int yy = y + xy[i][1];
8958     int center_side = trigger_sides[i][0];
8959     int border_side = trigger_sides[i][1];
8960     int border_element;
8961
8962     if (!IN_LEV_FIELD(xx, yy))
8963       continue;
8964
8965     if (game.engine_version < VERSION_IDENT(3,0,7,0))
8966       border_element = Feld[xx][yy];    /* may be moving! */
8967     else if (!IS_MOVING(xx, yy) && !IS_BLOCKED(xx, yy))
8968       border_element = Feld[xx][yy];
8969     else if (MovDir[xx][yy] & touch_dir[i])     /* elements are touching */
8970       border_element = MovingOrBlocked2Element(xx, yy);
8971     else
8972       continue;                 /* center and border element do not touch */
8973
8974     /* check for change of center element (but change it only once) */
8975     if (!change_center_element)
8976       change_center_element =
8977         CheckElementChangeBySide(x, y, center_element, border_element,
8978                                  CE_TOUCHING_X, border_side);
8979
8980     /* check for change of border element */
8981     CheckElementChangeBySide(xx, yy, border_element, center_element,
8982                              CE_TOUCHING_X, center_side);
8983   }
8984 }
8985
8986 void TestIfElementHitsCustomElement(int x, int y, int direction)
8987 {
8988   int dx = (direction == MV_LEFT ? -1 : direction == MV_RIGHT ? +1 : 0);
8989   int dy = (direction == MV_UP   ? -1 : direction == MV_DOWN  ? +1 : 0);
8990   int hitx = x + dx, hity = y + dy;
8991   int hitting_element = Feld[x][y];
8992   int touched_element;
8993
8994   if (IN_LEV_FIELD(hitx, hity) && IS_FREE(hitx, hity))
8995     return;
8996
8997   touched_element = (IN_LEV_FIELD(hitx, hity) ?
8998                      MovingOrBlocked2Element(hitx, hity) : EL_STEELWALL);
8999
9000   if (IN_LEV_FIELD(hitx, hity))
9001   {
9002     int opposite_direction = MV_DIR_OPPOSITE(direction);
9003     int hitting_side = direction;
9004     int touched_side = opposite_direction;
9005     boolean object_hit = (!IS_MOVING(hitx, hity) ||
9006                           MovDir[hitx][hity] != direction ||
9007                           ABS(MovPos[hitx][hity]) <= TILEY / 2);
9008
9009     object_hit = TRUE;
9010
9011     if (object_hit)
9012     {
9013       CheckElementChangeBySide(x, y, hitting_element, touched_element,
9014                                CE_HITTING_X, touched_side);
9015
9016       CheckElementChangeBySide(hitx, hity, touched_element,
9017                                hitting_element, CE_HIT_BY_X, hitting_side);
9018
9019       CheckElementChangeBySide(hitx, hity, touched_element, hitting_element,
9020                                CE_HIT_BY_SOMETHING, opposite_direction);
9021     }
9022   }
9023
9024   /* "hitting something" is also true when hitting the playfield border */
9025   CheckElementChangeBySide(x, y, hitting_element, touched_element,
9026                            CE_HITTING_SOMETHING, direction);
9027 }
9028
9029 #if 0
9030 void TestIfElementSmashesCustomElement(int x, int y, int direction)
9031 {
9032   int dx = (direction == MV_LEFT ? -1 : direction == MV_RIGHT ? +1 : 0);
9033   int dy = (direction == MV_UP   ? -1 : direction == MV_DOWN  ? +1 : 0);
9034   int hitx = x + dx, hity = y + dy;
9035   int hitting_element = Feld[x][y];
9036   int touched_element;
9037 #if 0
9038   boolean object_hit = (IN_LEV_FIELD(hitx, hity) &&
9039                         !IS_FREE(hitx, hity) &&
9040                         (!IS_MOVING(hitx, hity) ||
9041                          MovDir[hitx][hity] != direction ||
9042                          ABS(MovPos[hitx][hity]) <= TILEY / 2));
9043 #endif
9044
9045   if (IN_LEV_FIELD(hitx, hity) && IS_FREE(hitx, hity))
9046     return;
9047
9048 #if 0
9049   if (IN_LEV_FIELD(hitx, hity) && !object_hit)
9050     return;
9051 #endif
9052
9053   touched_element = (IN_LEV_FIELD(hitx, hity) ?
9054                      MovingOrBlocked2Element(hitx, hity) : EL_STEELWALL);
9055
9056   CheckElementChangeBySide(x, y, hitting_element, touched_element,
9057                            EP_CAN_SMASH_EVERYTHING, direction);
9058
9059   if (IN_LEV_FIELD(hitx, hity))
9060   {
9061     int opposite_direction = MV_DIR_OPPOSITE(direction);
9062     int hitting_side = direction;
9063     int touched_side = opposite_direction;
9064 #if 0
9065     int touched_element = MovingOrBlocked2Element(hitx, hity);
9066 #endif
9067 #if 1
9068     boolean object_hit = (!IS_MOVING(hitx, hity) ||
9069                           MovDir[hitx][hity] != direction ||
9070                           ABS(MovPos[hitx][hity]) <= TILEY / 2);
9071
9072     object_hit = TRUE;
9073 #endif
9074
9075     if (object_hit)
9076     {
9077       int i;
9078
9079       CheckElementChangeBySide(hitx, hity, touched_element, hitting_element,
9080                                CE_SMASHED_BY_SOMETHING, opposite_direction);
9081
9082       CheckElementChangeBySide(x, y, hitting_element, touched_element,
9083                                CE_OTHER_IS_SMASHING, touched_side);
9084
9085       CheckElementChangeBySide(hitx, hity, touched_element, hitting_element,
9086                                CE_OTHER_GETS_SMASHED, hitting_side);
9087     }
9088   }
9089 }
9090 #endif
9091
9092 void TestIfGoodThingHitsBadThing(int good_x, int good_y, int good_move_dir)
9093 {
9094   int i, kill_x = -1, kill_y = -1;
9095   int bad_element = -1;
9096   static int test_xy[4][2] =
9097   {
9098     { 0, -1 },
9099     { -1, 0 },
9100     { +1, 0 },
9101     { 0, +1 }
9102   };
9103   static int test_dir[4] =
9104   {
9105     MV_UP,
9106     MV_LEFT,
9107     MV_RIGHT,
9108     MV_DOWN
9109   };
9110
9111   for (i = 0; i < NUM_DIRECTIONS; i++)
9112   {
9113     int test_x, test_y, test_move_dir, test_element;
9114
9115     test_x = good_x + test_xy[i][0];
9116     test_y = good_y + test_xy[i][1];
9117
9118     if (!IN_LEV_FIELD(test_x, test_y))
9119       continue;
9120
9121     test_move_dir =
9122       (IS_MOVING(test_x, test_y) ? MovDir[test_x][test_y] : MV_NO_MOVING);
9123
9124     test_element = MovingOrBlocked2ElementIfNotLeaving(test_x, test_y);
9125
9126     /* 1st case: good thing is moving towards DONT_RUN_INTO style bad thing;
9127        2nd case: DONT_TOUCH style bad thing does not move away from good thing
9128     */
9129     if ((DONT_RUN_INTO(test_element) && good_move_dir == test_dir[i]) ||
9130         (DONT_TOUCH(test_element)    && test_move_dir != test_dir[i]))
9131     {
9132       kill_x = test_x;
9133       kill_y = test_y;
9134       bad_element = test_element;
9135
9136       break;
9137     }
9138   }
9139
9140   if (kill_x != -1 || kill_y != -1)
9141   {
9142     if (IS_PLAYER(good_x, good_y))
9143     {
9144       struct PlayerInfo *player = PLAYERINFO(good_x, good_y);
9145
9146       if (player->shield_deadly_time_left > 0 &&
9147           !IS_INDESTRUCTIBLE(bad_element))
9148         Bang(kill_x, kill_y);
9149       else if (!PLAYER_ENEMY_PROTECTED(good_x, good_y))
9150         KillPlayer(player);
9151     }
9152     else
9153       Bang(good_x, good_y);
9154   }
9155 }
9156
9157 void TestIfBadThingHitsGoodThing(int bad_x, int bad_y, int bad_move_dir)
9158 {
9159   int i, kill_x = -1, kill_y = -1;
9160   int bad_element = Feld[bad_x][bad_y];
9161   static int test_xy[4][2] =
9162   {
9163     { 0, -1 },
9164     { -1, 0 },
9165     { +1, 0 },
9166     { 0, +1 }
9167   };
9168   static int touch_dir[4] =
9169   {
9170     MV_LEFT | MV_RIGHT,
9171     MV_UP   | MV_DOWN,
9172     MV_UP   | MV_DOWN,
9173     MV_LEFT | MV_RIGHT
9174   };
9175   static int test_dir[4] =
9176   {
9177     MV_UP,
9178     MV_LEFT,
9179     MV_RIGHT,
9180     MV_DOWN
9181   };
9182
9183   if (bad_element == EL_EXPLOSION)      /* skip just exploding bad things */
9184     return;
9185
9186   for (i = 0; i < NUM_DIRECTIONS; i++)
9187   {
9188     int test_x, test_y, test_move_dir, test_element;
9189
9190     test_x = bad_x + test_xy[i][0];
9191     test_y = bad_y + test_xy[i][1];
9192     if (!IN_LEV_FIELD(test_x, test_y))
9193       continue;
9194
9195     test_move_dir =
9196       (IS_MOVING(test_x, test_y) ? MovDir[test_x][test_y] : MV_NO_MOVING);
9197
9198     test_element = Feld[test_x][test_y];
9199
9200     /* 1st case: good thing is moving towards DONT_RUN_INTO style bad thing;
9201        2nd case: DONT_TOUCH style bad thing does not move away from good thing
9202     */
9203     if ((DONT_RUN_INTO(bad_element) &&  bad_move_dir == test_dir[i]) ||
9204         (DONT_TOUCH(bad_element)    && test_move_dir != test_dir[i]))
9205     {
9206       /* good thing is player or penguin that does not move away */
9207       if (IS_PLAYER(test_x, test_y))
9208       {
9209         struct PlayerInfo *player = PLAYERINFO(test_x, test_y);
9210
9211         if (bad_element == EL_ROBOT && player->is_moving)
9212           continue;     /* robot does not kill player if he is moving */
9213
9214         if (game.engine_version >= VERSION_IDENT(3,0,7,0))
9215         {
9216           if (player->MovPos != 0 && !(player->MovDir & touch_dir[i]))
9217             continue;           /* center and border element do not touch */
9218         }
9219
9220         kill_x = test_x;
9221         kill_y = test_y;
9222         break;
9223       }
9224       else if (test_element == EL_PENGUIN)
9225       {
9226         kill_x = test_x;
9227         kill_y = test_y;
9228         break;
9229       }
9230     }
9231   }
9232
9233   if (kill_x != -1 || kill_y != -1)
9234   {
9235     if (IS_PLAYER(kill_x, kill_y))
9236     {
9237       struct PlayerInfo *player = PLAYERINFO(kill_x, kill_y);
9238
9239       if (player->shield_deadly_time_left > 0 &&
9240           !IS_INDESTRUCTIBLE(bad_element))
9241         Bang(bad_x, bad_y);
9242       else if (!PLAYER_ENEMY_PROTECTED(kill_x, kill_y))
9243         KillPlayer(player);
9244     }
9245     else
9246       Bang(kill_x, kill_y);
9247   }
9248 }
9249
9250 void TestIfPlayerTouchesBadThing(int x, int y)
9251 {
9252   TestIfGoodThingHitsBadThing(x, y, MV_NO_MOVING);
9253 }
9254
9255 void TestIfPlayerRunsIntoBadThing(int x, int y, int move_dir)
9256 {
9257   TestIfGoodThingHitsBadThing(x, y, move_dir);
9258 }
9259
9260 void TestIfBadThingTouchesPlayer(int x, int y)
9261 {
9262   TestIfBadThingHitsGoodThing(x, y, MV_NO_MOVING);
9263 }
9264
9265 void TestIfBadThingRunsIntoPlayer(int x, int y, int move_dir)
9266 {
9267   TestIfBadThingHitsGoodThing(x, y, move_dir);
9268 }
9269
9270 void TestIfFriendTouchesBadThing(int x, int y)
9271 {
9272   TestIfGoodThingHitsBadThing(x, y, MV_NO_MOVING);
9273 }
9274
9275 void TestIfBadThingTouchesFriend(int x, int y)
9276 {
9277   TestIfBadThingHitsGoodThing(x, y, MV_NO_MOVING);
9278 }
9279
9280 void TestIfBadThingTouchesOtherBadThing(int bad_x, int bad_y)
9281 {
9282   int i, kill_x = bad_x, kill_y = bad_y;
9283   static int xy[4][2] =
9284   {
9285     { 0, -1 },
9286     { -1, 0 },
9287     { +1, 0 },
9288     { 0, +1 }
9289   };
9290
9291   for (i = 0; i < NUM_DIRECTIONS; i++)
9292   {
9293     int x, y, element;
9294
9295     x = bad_x + xy[i][0];
9296     y = bad_y + xy[i][1];
9297     if (!IN_LEV_FIELD(x, y))
9298       continue;
9299
9300     element = Feld[x][y];
9301     if (IS_AMOEBOID(element) || element == EL_GAME_OF_LIFE ||
9302         element == EL_AMOEBA_GROWING || element == EL_AMOEBA_DROP)
9303     {
9304       kill_x = x;
9305       kill_y = y;
9306       break;
9307     }
9308   }
9309
9310   if (kill_x != bad_x || kill_y != bad_y)
9311     Bang(bad_x, bad_y);
9312 }
9313
9314 void KillPlayer(struct PlayerInfo *player)
9315 {
9316   int jx = player->jx, jy = player->jy;
9317
9318   if (!player->active)
9319     return;
9320
9321   /* remove accessible field at the player's position */
9322   Feld[jx][jy] = EL_EMPTY;
9323
9324   /* deactivate shield (else Bang()/Explode() would not work right) */
9325   player->shield_normal_time_left = 0;
9326   player->shield_deadly_time_left = 0;
9327
9328   Bang(jx, jy);
9329   BuryPlayer(player);
9330 }
9331
9332 static void KillPlayerUnlessEnemyProtected(int x, int y)
9333 {
9334   if (!PLAYER_ENEMY_PROTECTED(x, y))
9335     KillPlayer(PLAYERINFO(x, y));
9336 }
9337
9338 static void KillPlayerUnlessExplosionProtected(int x, int y)
9339 {
9340   if (!PLAYER_EXPLOSION_PROTECTED(x, y))
9341     KillPlayer(PLAYERINFO(x, y));
9342 }
9343
9344 void BuryPlayer(struct PlayerInfo *player)
9345 {
9346   int jx = player->jx, jy = player->jy;
9347
9348   if (!player->active)
9349     return;
9350
9351   PlayLevelSoundElementAction(jx, jy, player->element_nr, ACTION_DYING);
9352   PlayLevelSound(jx, jy, SND_GAME_LOSING);
9353
9354   player->GameOver = TRUE;
9355   RemovePlayer(player);
9356 }
9357
9358 void RemovePlayer(struct PlayerInfo *player)
9359 {
9360   int jx = player->jx, jy = player->jy;
9361   int i, found = FALSE;
9362
9363   player->present = FALSE;
9364   player->active = FALSE;
9365
9366   if (!ExplodeField[jx][jy])
9367     StorePlayer[jx][jy] = 0;
9368
9369   if (player->is_moving)
9370     DrawLevelField(player->last_jx, player->last_jy);
9371
9372   for (i = 0; i < MAX_PLAYERS; i++)
9373     if (stored_player[i].active)
9374       found = TRUE;
9375
9376   if (!found)
9377     AllPlayersGone = TRUE;
9378
9379   ExitX = ZX = jx;
9380   ExitY = ZY = jy;
9381 }
9382
9383 /*
9384   =============================================================================
9385   checkDiagonalPushing()
9386   -----------------------------------------------------------------------------
9387   check if diagonal input device direction results in pushing of object
9388   (by checking if the alternative direction is walkable, diggable, ...)
9389   =============================================================================
9390 */
9391
9392 static boolean checkDiagonalPushing(struct PlayerInfo *player,
9393                                     int x, int y, int real_dx, int real_dy)
9394 {
9395   int jx, jy, dx, dy, xx, yy;
9396
9397   if (real_dx == 0 || real_dy == 0)     /* no diagonal direction => push */
9398     return TRUE;
9399
9400   /* diagonal direction: check alternative direction */
9401   jx = player->jx;
9402   jy = player->jy;
9403   dx = x - jx;
9404   dy = y - jy;
9405   xx = jx + (dx == 0 ? real_dx : 0);
9406   yy = jy + (dy == 0 ? real_dy : 0);
9407
9408   return (!IN_LEV_FIELD(xx, yy) || IS_SOLID_FOR_PUSHING(Feld[xx][yy]));
9409 }
9410
9411 /*
9412   =============================================================================
9413   DigField()
9414   -----------------------------------------------------------------------------
9415   x, y:                 field next to player (non-diagonal) to try to dig to
9416   real_dx, real_dy:     direction as read from input device (can be diagonal)
9417   =============================================================================
9418 */
9419
9420 int DigField(struct PlayerInfo *player,
9421              int oldx, int oldy, int x, int y,
9422              int real_dx, int real_dy, int mode)
9423 {
9424   boolean is_player = (IS_PLAYER(oldx, oldy) || mode != DF_DIG);
9425   boolean player_was_pushing = player->is_pushing;
9426   int jx = oldx, jy = oldy;
9427   int dx = x - jx, dy = y - jy;
9428   int nextx = x + dx, nexty = y + dy;
9429   int move_direction = (dx == -1 ? MV_LEFT :
9430                         dx == +1 ? MV_RIGHT :
9431                         dy == -1 ? MV_UP :
9432                         dy == +1 ? MV_DOWN : MV_NO_MOVING);
9433   int opposite_direction = MV_DIR_OPPOSITE(move_direction);
9434   int dig_side = MV_DIR_OPPOSITE(move_direction);
9435   int old_element = Feld[jx][jy];
9436   int element;
9437   int collect_count;
9438
9439   if (is_player)                /* function can also be called by EL_PENGUIN */
9440   {
9441     if (player->MovPos == 0)
9442     {
9443       player->is_digging = FALSE;
9444       player->is_collecting = FALSE;
9445     }
9446
9447     if (player->MovPos == 0)    /* last pushing move finished */
9448       player->is_pushing = FALSE;
9449
9450     if (mode == DF_NO_PUSH)     /* player just stopped pushing */
9451     {
9452       player->is_switching = FALSE;
9453       player->push_delay = -1;
9454
9455       return MF_NO_ACTION;
9456     }
9457   }
9458
9459   if (IS_MOVING(x, y) || IS_PLAYER(x, y))
9460     return MF_NO_ACTION;
9461
9462   if (IS_TUBE(Back[jx][jy]) && game.engine_version >= VERSION_IDENT(2,2,0,0))
9463     old_element = Back[jx][jy];
9464
9465   /* in case of element dropped at player position, check background */
9466   else if (Back[jx][jy] != EL_EMPTY &&
9467            game.engine_version >= VERSION_IDENT(2,2,0,0))
9468     old_element = Back[jx][jy];
9469
9470   if (IS_WALKABLE(old_element) && !ACCESS_FROM(old_element, move_direction))
9471     return MF_NO_ACTION;        /* field has no opening in this direction */
9472
9473   if (IS_PASSABLE(old_element) && !ACCESS_FROM(old_element,opposite_direction))
9474     return MF_NO_ACTION;        /* field has no opening in this direction */
9475
9476   element = Feld[x][y];
9477 #if USE_NEW_COLLECT_COUNT
9478   collect_count = Count[x][y];
9479 #else
9480   collect_count = element_info[element].collect_count_initial;
9481 #endif
9482
9483 #if 0
9484   if (element != EL_BLOCKED &&
9485       Count[x][y] != element_info[element].collect_count_initial)
9486     printf("::: %d: %d != %d\n",
9487            element,
9488            Count[x][y],
9489            element_info[element].collect_count_initial);
9490 #endif
9491
9492   if (!is_player && !IS_COLLECTIBLE(element))   /* penguin cannot collect it */
9493     return MF_NO_ACTION;
9494
9495   if (mode == DF_SNAP && !IS_SNAPPABLE(element) &&
9496       game.engine_version >= VERSION_IDENT(2,2,0,0))
9497     return MF_NO_ACTION;
9498
9499   if (game.gravity && is_player && !player->is_auto_moving &&
9500       canFallDown(player) && move_direction != MV_DOWN &&
9501       !canMoveToValidFieldWithGravity(jx, jy, move_direction))
9502     return MF_NO_ACTION;        /* player cannot walk here due to gravity */
9503
9504   if (IS_WALKABLE(element) && ACCESS_FROM(element, opposite_direction))
9505   {
9506     int sound_element = SND_ELEMENT(element);
9507     int sound_action = ACTION_WALKING;
9508
9509     if (IS_RND_GATE(element))
9510     {
9511       if (!player->key[RND_GATE_NR(element)])
9512         return MF_NO_ACTION;
9513     }
9514     else if (IS_RND_GATE_GRAY(element))
9515     {
9516       if (!player->key[RND_GATE_GRAY_NR(element)])
9517         return MF_NO_ACTION;
9518     }
9519     else if (element == EL_EXIT_OPEN ||
9520              element == EL_SP_EXIT_OPEN ||
9521              element == EL_SP_EXIT_OPENING)
9522     {
9523       sound_action = ACTION_PASSING;    /* player is passing exit */
9524     }
9525     else if (element == EL_EMPTY)
9526     {
9527       sound_action = ACTION_MOVING;             /* nothing to walk on */
9528     }
9529
9530     /* play sound from background or player, whatever is available */
9531     if (element_info[sound_element].sound[sound_action] != SND_UNDEFINED)
9532       PlayLevelSoundElementAction(x, y, sound_element, sound_action);
9533     else
9534       PlayLevelSoundElementAction(x, y, player->element_nr, sound_action);
9535   }
9536   else if (IS_PASSABLE(element) && canPassField(x, y, move_direction))
9537   {
9538     if (!ACCESS_FROM(element, opposite_direction))
9539       return MF_NO_ACTION;      /* field not accessible from this direction */
9540
9541     if (CAN_MOVE(element))      /* only fixed elements can be passed! */
9542       return MF_NO_ACTION;
9543
9544     if (IS_EM_GATE(element))
9545     {
9546       if (!player->key[EM_GATE_NR(element)])
9547         return MF_NO_ACTION;
9548     }
9549     else if (IS_EM_GATE_GRAY(element))
9550     {
9551       if (!player->key[EM_GATE_GRAY_NR(element)])
9552         return MF_NO_ACTION;
9553     }
9554     else if (IS_SP_PORT(element))
9555     {
9556       if (element == EL_SP_GRAVITY_PORT_LEFT ||
9557           element == EL_SP_GRAVITY_PORT_RIGHT ||
9558           element == EL_SP_GRAVITY_PORT_UP ||
9559           element == EL_SP_GRAVITY_PORT_DOWN)
9560         game.gravity = !game.gravity;
9561       else if (element == EL_SP_GRAVITY_ON_PORT_LEFT ||
9562                element == EL_SP_GRAVITY_ON_PORT_RIGHT ||
9563                element == EL_SP_GRAVITY_ON_PORT_UP ||
9564                element == EL_SP_GRAVITY_ON_PORT_DOWN)
9565         game.gravity = TRUE;
9566       else if (element == EL_SP_GRAVITY_OFF_PORT_LEFT ||
9567                element == EL_SP_GRAVITY_OFF_PORT_RIGHT ||
9568                element == EL_SP_GRAVITY_OFF_PORT_UP ||
9569                element == EL_SP_GRAVITY_OFF_PORT_DOWN)
9570         game.gravity = FALSE;
9571     }
9572
9573     /* automatically move to the next field with double speed */
9574     player->programmed_action = move_direction;
9575
9576     if (player->move_delay_reset_counter == 0)
9577     {
9578       player->move_delay_reset_counter = 2;     /* two double speed steps */
9579
9580       DOUBLE_PLAYER_SPEED(player);
9581     }
9582
9583     PlayLevelSoundAction(x, y, ACTION_PASSING);
9584   }
9585   else if (IS_DIGGABLE(element))
9586   {
9587     RemoveField(x, y);
9588
9589     if (mode != DF_SNAP)
9590     {
9591       GfxElement[x][y] = GFX_ELEMENT(element);
9592       player->is_digging = TRUE;
9593     }
9594
9595     PlayLevelSoundElementAction(x, y, element, ACTION_DIGGING);
9596
9597     CheckTriggeredElementChangeByPlayer(element, CE_PLAYER_DIGS_X,
9598                                         player->index_bit, dig_side);
9599
9600     if (mode == DF_SNAP)
9601       TestIfElementTouchesCustomElement(x, y);  /* for empty space */
9602   }
9603   else if (IS_COLLECTIBLE(element))
9604   {
9605     RemoveField(x, y);
9606
9607     if (is_player && mode != DF_SNAP)
9608     {
9609       GfxElement[x][y] = element;
9610       player->is_collecting = TRUE;
9611     }
9612
9613     if (element == EL_SPEED_PILL)
9614     {
9615       player->move_delay_value = MOVE_DELAY_HIGH_SPEED;
9616     }
9617     else if (element == EL_EXTRA_TIME && level.time > 0)
9618     {
9619       TimeLeft += 10;
9620       DrawGameValue_Time(TimeLeft);
9621     }
9622     else if (element == EL_SHIELD_NORMAL || element == EL_SHIELD_DEADLY)
9623     {
9624       player->shield_normal_time_left += 10;
9625       if (element == EL_SHIELD_DEADLY)
9626         player->shield_deadly_time_left += 10;
9627     }
9628     else if (element == EL_DYNAMITE || element == EL_SP_DISK_RED)
9629     {
9630       if (player->inventory_size < MAX_INVENTORY_SIZE)
9631         player->inventory_element[player->inventory_size++] = element;
9632
9633       DrawGameValue_Dynamite(local_player->inventory_size);
9634     }
9635     else if (element == EL_DYNABOMB_INCREASE_NUMBER)
9636     {
9637       player->dynabomb_count++;
9638       player->dynabombs_left++;
9639     }
9640     else if (element == EL_DYNABOMB_INCREASE_SIZE)
9641     {
9642       player->dynabomb_size++;
9643     }
9644     else if (element == EL_DYNABOMB_INCREASE_POWER)
9645     {
9646       player->dynabomb_xl = TRUE;
9647     }
9648     else if (IS_KEY(element))
9649     {
9650       player->key[KEY_NR(element)] = TRUE;
9651
9652       DrawGameValue_Keys(player->key);
9653
9654       redraw_mask |= REDRAW_DOOR_1;
9655     }
9656     else if (IS_ENVELOPE(element))
9657     {
9658       player->show_envelope = element;
9659     }
9660     else if (IS_DROPPABLE(element) ||
9661              IS_THROWABLE(element))     /* can be collected and dropped */
9662     {
9663       int i;
9664
9665       if (collect_count == 0)
9666         player->inventory_infinite_element = element;
9667       else
9668         for (i = 0; i < collect_count; i++)
9669           if (player->inventory_size < MAX_INVENTORY_SIZE)
9670             player->inventory_element[player->inventory_size++] = element;
9671
9672       DrawGameValue_Dynamite(local_player->inventory_size);
9673     }
9674     else if (collect_count > 0)
9675     {
9676       local_player->gems_still_needed -= collect_count;
9677       if (local_player->gems_still_needed < 0)
9678         local_player->gems_still_needed = 0;
9679
9680       DrawGameValue_Emeralds(local_player->gems_still_needed);
9681     }
9682
9683     RaiseScoreElement(element);
9684     PlayLevelSoundElementAction(x, y, element, ACTION_COLLECTING);
9685
9686     if (is_player)
9687       CheckTriggeredElementChangeByPlayer(element, CE_PLAYER_COLLECTS_X,
9688                                           player->index_bit, dig_side);
9689
9690     if (mode == DF_SNAP)
9691       TestIfElementTouchesCustomElement(x, y);  /* for empty space */
9692   }
9693   else if (IS_PUSHABLE(element))
9694   {
9695     if (mode == DF_SNAP && element != EL_BD_ROCK)
9696       return MF_NO_ACTION;
9697
9698     if (CAN_FALL(element) && dy)
9699       return MF_NO_ACTION;
9700
9701     if (CAN_FALL(element) && IN_LEV_FIELD(x, y + 1) && IS_FREE(x, y + 1) &&
9702         !(element == EL_SPRING && level.use_spring_bug))
9703       return MF_NO_ACTION;
9704
9705     if (CAN_MOVE(element) && GET_MAX_MOVE_DELAY(element) == 0 &&
9706         ((move_direction & MV_VERTICAL &&
9707           ((element_info[element].move_pattern & MV_LEFT &&
9708             IN_LEV_FIELD(x - 1, y) && IS_FREE(x - 1, y)) ||
9709            (element_info[element].move_pattern & MV_RIGHT &&
9710             IN_LEV_FIELD(x + 1, y) && IS_FREE(x + 1, y)))) ||
9711          (move_direction & MV_HORIZONTAL &&
9712           ((element_info[element].move_pattern & MV_UP &&
9713             IN_LEV_FIELD(x, y - 1) && IS_FREE(x, y - 1)) ||
9714            (element_info[element].move_pattern & MV_DOWN &&
9715             IN_LEV_FIELD(x, y + 1) && IS_FREE(x, y + 1))))))
9716       return MF_NO_ACTION;
9717
9718     /* do not push elements already moving away faster than player */
9719     if (CAN_MOVE(element) && MovDir[x][y] == move_direction &&
9720         ABS(getElementMoveStepsize(x, y)) > MOVE_STEPSIZE_NORMAL)
9721       return MF_NO_ACTION;
9722
9723     if (game.engine_version >= VERSION_IDENT(3,1,0,0))
9724     {
9725       if (player->push_delay_value == -1 || !player_was_pushing)
9726         player->push_delay_value = GET_NEW_PUSH_DELAY(element);
9727     }
9728     else if (game.engine_version >= VERSION_IDENT(3,0,7,1))
9729     {
9730       if (player->push_delay_value == -1)
9731         player->push_delay_value = GET_NEW_PUSH_DELAY(element);
9732     }
9733     else if (game.engine_version >= VERSION_IDENT(2,2,0,7))
9734     {
9735       if (!player->is_pushing)
9736         player->push_delay_value = GET_NEW_PUSH_DELAY(element);
9737     }
9738
9739     player->is_pushing = TRUE;
9740
9741     if (!(IN_LEV_FIELD(nextx, nexty) &&
9742           (IS_FREE(nextx, nexty) ||
9743            (Feld[nextx][nexty] == EL_SOKOBAN_FIELD_EMPTY &&
9744             IS_SB_ELEMENT(element)))))
9745       return MF_NO_ACTION;
9746
9747     if (!checkDiagonalPushing(player, x, y, real_dx, real_dy))
9748       return MF_NO_ACTION;
9749
9750     if (player->push_delay == -1)       /* new pushing; restart delay */
9751       player->push_delay = 0;
9752
9753     if (player->push_delay < player->push_delay_value &&
9754         !(tape.playing && tape.file_version < FILE_VERSION_2_0) &&
9755         element != EL_SPRING && element != EL_BALLOON)
9756     {
9757       /* make sure that there is no move delay before next try to push */
9758       if (game.engine_version >= VERSION_IDENT(3,0,7,1))
9759         player->move_delay = 0;
9760
9761       return MF_NO_ACTION;
9762     }
9763
9764     if (IS_SB_ELEMENT(element))
9765     {
9766       if (element == EL_SOKOBAN_FIELD_FULL)
9767       {
9768         Back[x][y] = EL_SOKOBAN_FIELD_EMPTY;
9769         local_player->sokobanfields_still_needed++;
9770       }
9771
9772       if (Feld[nextx][nexty] == EL_SOKOBAN_FIELD_EMPTY)
9773       {
9774         Back[nextx][nexty] = EL_SOKOBAN_FIELD_EMPTY;
9775         local_player->sokobanfields_still_needed--;
9776       }
9777
9778       Feld[x][y] = EL_SOKOBAN_OBJECT;
9779
9780       if (Back[x][y] == Back[nextx][nexty])
9781         PlayLevelSoundAction(x, y, ACTION_PUSHING);
9782       else if (Back[x][y] != 0)
9783         PlayLevelSoundElementAction(x, y, EL_SOKOBAN_FIELD_FULL,
9784                                     ACTION_EMPTYING);
9785       else
9786         PlayLevelSoundElementAction(nextx, nexty, EL_SOKOBAN_FIELD_EMPTY,
9787                                     ACTION_FILLING);
9788
9789       if (local_player->sokobanfields_still_needed == 0 &&
9790           game.emulation == EMU_SOKOBAN)
9791       {
9792         player->LevelSolved = player->GameOver = TRUE;
9793         PlayLevelSound(x, y, SND_GAME_SOKOBAN_SOLVING);
9794       }
9795     }
9796     else
9797       PlayLevelSoundElementAction(x, y, element, ACTION_PUSHING);
9798
9799     InitMovingField(x, y, move_direction);
9800     GfxAction[x][y] = ACTION_PUSHING;
9801
9802     if (mode == DF_SNAP)
9803       ContinueMoving(x, y);
9804     else
9805       MovPos[x][y] = (dx != 0 ? dx : dy);
9806
9807     Pushed[x][y] = TRUE;
9808     Pushed[nextx][nexty] = TRUE;
9809
9810     if (game.engine_version < VERSION_IDENT(2,2,0,7))
9811       player->push_delay_value = GET_NEW_PUSH_DELAY(element);
9812     else
9813       player->push_delay_value = -1;    /* get new value later */
9814
9815     /* check for element change _after_ element has been pushed */
9816     if (game.use_change_when_pushing_bug)
9817     {
9818       CheckElementChangeByPlayer(x, y, element, CE_PUSHED_BY_PLAYER,
9819                                  player->index_bit, dig_side);
9820       CheckTriggeredElementChangeByPlayer(element, CE_PLAYER_PUSHES_X,
9821                                           player->index_bit, dig_side);
9822     }
9823   }
9824   else if (IS_SWITCHABLE(element))
9825   {
9826     if (PLAYER_SWITCHING(player, x, y))
9827     {
9828       CheckTriggeredElementChangeByPlayer(element, CE_PLAYER_PRESSES_X,
9829                                           player->index_bit, dig_side);
9830
9831       return MF_ACTION;
9832     }
9833
9834     player->is_switching = TRUE;
9835     player->switch_x = x;
9836     player->switch_y = y;
9837
9838     PlayLevelSoundElementAction(x, y, element, ACTION_ACTIVATING);
9839
9840     if (element == EL_ROBOT_WHEEL)
9841     {
9842       Feld[x][y] = EL_ROBOT_WHEEL_ACTIVE;
9843       ZX = x;
9844       ZY = y;
9845
9846       DrawLevelField(x, y);
9847     }
9848     else if (element == EL_SP_TERMINAL)
9849     {
9850       int xx, yy;
9851
9852       for (yy = 0; yy < lev_fieldy; yy++) for (xx=0; xx < lev_fieldx; xx++)
9853       {
9854         if (Feld[xx][yy] == EL_SP_DISK_YELLOW)
9855           Bang(xx, yy);
9856         else if (Feld[xx][yy] == EL_SP_TERMINAL)
9857           Feld[xx][yy] = EL_SP_TERMINAL_ACTIVE;
9858       }
9859     }
9860     else if (IS_BELT_SWITCH(element))
9861     {
9862       ToggleBeltSwitch(x, y);
9863     }
9864     else if (element == EL_SWITCHGATE_SWITCH_UP ||
9865              element == EL_SWITCHGATE_SWITCH_DOWN)
9866     {
9867       ToggleSwitchgateSwitch(x, y);
9868     }
9869     else if (element == EL_LIGHT_SWITCH ||
9870              element == EL_LIGHT_SWITCH_ACTIVE)
9871     {
9872       ToggleLightSwitch(x, y);
9873     }
9874     else if (element == EL_TIMEGATE_SWITCH)
9875     {
9876       ActivateTimegateSwitch(x, y);
9877     }
9878     else if (element == EL_BALLOON_SWITCH_LEFT ||
9879              element == EL_BALLOON_SWITCH_RIGHT ||
9880              element == EL_BALLOON_SWITCH_UP ||
9881              element == EL_BALLOON_SWITCH_DOWN ||
9882              element == EL_BALLOON_SWITCH_ANY)
9883     {
9884       if (element == EL_BALLOON_SWITCH_ANY)
9885         game.balloon_dir = move_direction;
9886       else
9887         game.balloon_dir = (element == EL_BALLOON_SWITCH_LEFT  ? MV_LEFT :
9888                             element == EL_BALLOON_SWITCH_RIGHT ? MV_RIGHT :
9889                             element == EL_BALLOON_SWITCH_UP    ? MV_UP :
9890                             element == EL_BALLOON_SWITCH_DOWN  ? MV_DOWN :
9891                             MV_NO_MOVING);
9892     }
9893     else if (element == EL_LAMP)
9894     {
9895       Feld[x][y] = EL_LAMP_ACTIVE;
9896       local_player->lights_still_needed--;
9897
9898       ResetGfxAnimation(x, y);
9899       DrawLevelField(x, y);
9900     }
9901     else if (element == EL_TIME_ORB_FULL)
9902     {
9903       Feld[x][y] = EL_TIME_ORB_EMPTY;
9904       TimeLeft += 10;
9905       DrawGameValue_Time(TimeLeft);
9906
9907       ResetGfxAnimation(x, y);
9908       DrawLevelField(x, y);
9909     }
9910
9911     CheckTriggeredElementChangeByPlayer(element, CE_SWITCH_OF_X,
9912                                         player->index_bit, dig_side);
9913
9914     CheckTriggeredElementChangeByPlayer(element, CE_PLAYER_PRESSES_X,
9915                                         player->index_bit, dig_side);
9916
9917     return MF_ACTION;
9918   }
9919   else
9920   {
9921     if (!PLAYER_SWITCHING(player, x, y))
9922     {
9923       player->is_switching = TRUE;
9924       player->switch_x = x;
9925       player->switch_y = y;
9926
9927       CheckElementChangeByPlayer(x, y, element, CE_SWITCHED,
9928                                  player->index_bit, dig_side);
9929       CheckTriggeredElementChangeByPlayer(element, CE_SWITCH_OF_X,
9930                                           player->index_bit, dig_side);
9931     }
9932
9933     CheckElementChangeByPlayer(x, y, element, CE_PRESSED_BY_PLAYER,
9934                                player->index_bit, dig_side);
9935     CheckTriggeredElementChangeByPlayer(element, CE_PLAYER_PRESSES_X,
9936                                         player->index_bit, dig_side);
9937
9938     return MF_NO_ACTION;
9939   }
9940
9941   player->push_delay = -1;
9942
9943   if (is_player)                /* function can also be called by EL_PENGUIN */
9944   {
9945     if (Feld[x][y] != element)          /* really digged/collected something */
9946       player->is_collecting = !player->is_digging;
9947   }
9948
9949   return MF_MOVING;
9950 }
9951
9952 boolean SnapField(struct PlayerInfo *player, int dx, int dy)
9953 {
9954   int jx = player->jx, jy = player->jy;
9955   int x = jx + dx, y = jy + dy;
9956   int snap_direction = (dx == -1 ? MV_LEFT :
9957                         dx == +1 ? MV_RIGHT :
9958                         dy == -1 ? MV_UP :
9959                         dy == +1 ? MV_DOWN : MV_NO_MOVING);
9960
9961   if (player->MovPos != 0 && game.engine_version >= VERSION_IDENT(2,2,0,0))
9962     return FALSE;
9963
9964   if (!player->active || !IN_LEV_FIELD(x, y))
9965     return FALSE;
9966
9967   if (dx && dy)
9968     return FALSE;
9969
9970   if (!dx && !dy)
9971   {
9972     if (player->MovPos == 0)
9973       player->is_pushing = FALSE;
9974
9975     player->is_snapping = FALSE;
9976
9977     if (player->MovPos == 0)
9978     {
9979       player->is_moving = FALSE;
9980       player->is_digging = FALSE;
9981       player->is_collecting = FALSE;
9982     }
9983
9984     return FALSE;
9985   }
9986
9987   if (player->is_snapping)
9988     return FALSE;
9989
9990   player->MovDir = snap_direction;
9991
9992   if (player->MovPos == 0)
9993   {
9994     player->is_moving = FALSE;
9995     player->is_digging = FALSE;
9996     player->is_collecting = FALSE;
9997   }
9998
9999   player->is_dropping = FALSE;
10000
10001   if (DigField(player, jx, jy, x, y, 0, 0, DF_SNAP) == MF_NO_ACTION)
10002     return FALSE;
10003
10004   player->is_snapping = TRUE;
10005
10006   if (player->MovPos == 0)
10007   {
10008     player->is_moving = FALSE;
10009     player->is_digging = FALSE;
10010     player->is_collecting = FALSE;
10011   }
10012
10013   if (player->MovPos != 0)      /* prevent graphic bugs in versions < 2.2.0 */
10014     DrawLevelField(player->last_jx, player->last_jy);
10015
10016   DrawLevelField(x, y);
10017
10018   return TRUE;
10019 }
10020
10021 boolean DropElement(struct PlayerInfo *player)
10022 {
10023   int old_element, new_element;
10024   int dropx = player->jx, dropy = player->jy;
10025   int drop_direction = player->MovDir;
10026   int drop_side = drop_direction;
10027   int drop_element = (player->inventory_size > 0 ?
10028                       player->inventory_element[player->inventory_size - 1] :
10029                       player->inventory_infinite_element != EL_UNDEFINED ?
10030                       player->inventory_infinite_element :
10031                       player->dynabombs_left > 0 ?
10032                       EL_DYNABOMB_PLAYER_1_ACTIVE + player->index_nr :
10033                       EL_UNDEFINED);
10034
10035   /* do not drop an element on top of another element; when holding drop key
10036      pressed without moving, dropped element must move away before the next
10037      element can be dropped (this is especially important if the next element
10038      is dynamite, which can be placed on background for historical reasons) */
10039   if (PLAYER_DROPPING(player, dropx, dropy) && Feld[dropx][dropy] != EL_EMPTY)
10040     return MF_ACTION;
10041
10042   if (IS_THROWABLE(drop_element))
10043   {
10044     dropx += GET_DX_FROM_DIR(drop_direction);
10045     dropy += GET_DY_FROM_DIR(drop_direction);
10046
10047     if (!IN_LEV_FIELD(dropx, dropy))
10048       return FALSE;
10049   }
10050
10051   old_element = Feld[dropx][dropy];     /* old element at dropping position */
10052   new_element = drop_element;           /* default: no change when dropping */
10053
10054   /* check if player is active, not moving and ready to drop */
10055   if (!player->active || player->MovPos || player->drop_delay > 0)
10056     return FALSE;
10057
10058   /* check if player has anything that can be dropped */
10059   if (new_element == EL_UNDEFINED)
10060     return FALSE;
10061
10062   /* check if anything can be dropped at the current position */
10063   if (IS_ACTIVE_BOMB(old_element) || old_element == EL_EXPLOSION)
10064     return FALSE;
10065
10066   /* collected custom elements can only be dropped on empty fields */
10067   if (IS_CUSTOM_ELEMENT(new_element) && old_element != EL_EMPTY)
10068     return FALSE;
10069
10070   if (old_element != EL_EMPTY)
10071     Back[dropx][dropy] = old_element;   /* store old element on this field */
10072
10073   ResetGfxAnimation(dropx, dropy);
10074   ResetRandomAnimationValue(dropx, dropy);
10075
10076   if (player->inventory_size > 0 ||
10077       player->inventory_infinite_element != EL_UNDEFINED)
10078   {
10079     if (player->inventory_size > 0)
10080     {
10081       player->inventory_size--;
10082
10083       DrawGameValue_Dynamite(local_player->inventory_size);
10084
10085       if (new_element == EL_DYNAMITE)
10086         new_element = EL_DYNAMITE_ACTIVE;
10087       else if (new_element == EL_SP_DISK_RED)
10088         new_element = EL_SP_DISK_RED_ACTIVE;
10089     }
10090
10091     Feld[dropx][dropy] = new_element;
10092
10093     if (IN_SCR_FIELD(SCREENX(dropx), SCREENY(dropy)))
10094       DrawGraphicThruMask(SCREENX(dropx), SCREENY(dropy),
10095                           el2img(Feld[dropx][dropy]), 0);
10096
10097     PlayLevelSoundAction(dropx, dropy, ACTION_DROPPING);
10098
10099     /* needed if previous element just changed to "empty" in the last frame */
10100     Changed[dropx][dropy] = FALSE;              /* allow another change */
10101
10102     CheckElementChangeByPlayer(dropx, dropy, new_element, CE_DROPPED_BY_PLAYER,
10103                                player->index_bit, drop_side);
10104     CheckTriggeredElementChangeByPlayer(new_element, CE_PLAYER_DROPS_X,
10105                                         player->index_bit, drop_side);
10106
10107     TestIfElementTouchesCustomElement(dropx, dropy);
10108   }
10109   else          /* player is dropping a dyna bomb */
10110   {
10111     player->dynabombs_left--;
10112
10113     Feld[dropx][dropy] = new_element;
10114
10115     if (IN_SCR_FIELD(SCREENX(dropx), SCREENY(dropy)))
10116       DrawGraphicThruMask(SCREENX(dropx), SCREENY(dropy),
10117                           el2img(Feld[dropx][dropy]), 0);
10118
10119     PlayLevelSoundAction(dropx, dropy, ACTION_DROPPING);
10120   }
10121
10122   if (Feld[dropx][dropy] == new_element) /* uninitialized unless CE change */
10123     InitField_WithBug1(dropx, dropy, FALSE);
10124
10125   new_element = Feld[dropx][dropy];     /* element might have changed */
10126
10127   if (IS_CUSTOM_ELEMENT(new_element) && CAN_MOVE(new_element) &&
10128       element_info[new_element].move_pattern == MV_WHEN_DROPPED)
10129   {
10130     int move_direction, nextx, nexty;
10131
10132     if (element_info[new_element].move_direction_initial == MV_START_AUTOMATIC)
10133       MovDir[dropx][dropy] = drop_direction;
10134
10135     move_direction = MovDir[dropx][dropy];
10136     nextx = dropx + GET_DX_FROM_DIR(move_direction);
10137     nexty = dropy + GET_DY_FROM_DIR(move_direction);
10138
10139     Changed[dropx][dropy] = FALSE;              /* allow another change */
10140     CheckCollision[dropx][dropy] = 2;
10141   }
10142
10143   player->drop_delay = GET_NEW_DROP_DELAY(drop_element);
10144   player->is_dropping = TRUE;
10145
10146   player->drop_x = dropx;
10147   player->drop_y = dropy;
10148
10149   return TRUE;
10150 }
10151
10152 /* ------------------------------------------------------------------------- */
10153 /* game sound playing functions                                              */
10154 /* ------------------------------------------------------------------------- */
10155
10156 static int *loop_sound_frame = NULL;
10157 static int *loop_sound_volume = NULL;
10158
10159 void InitPlayLevelSound()
10160 {
10161   int num_sounds = getSoundListSize();
10162
10163   checked_free(loop_sound_frame);
10164   checked_free(loop_sound_volume);
10165
10166   loop_sound_frame  = checked_calloc(num_sounds * sizeof(int));
10167   loop_sound_volume = checked_calloc(num_sounds * sizeof(int));
10168 }
10169
10170 static void PlayLevelSound(int x, int y, int nr)
10171 {
10172   int sx = SCREENX(x), sy = SCREENY(y);
10173   int volume, stereo_position;
10174   int max_distance = 8;
10175   int type = (IS_LOOP_SOUND(nr) ? SND_CTRL_PLAY_LOOP : SND_CTRL_PLAY_SOUND);
10176
10177   if ((!setup.sound_simple && !IS_LOOP_SOUND(nr)) ||
10178       (!setup.sound_loops && IS_LOOP_SOUND(nr)))
10179     return;
10180
10181   if (!IN_LEV_FIELD(x, y) ||
10182       sx < -max_distance || sx >= SCR_FIELDX + max_distance ||
10183       sy < -max_distance || sy >= SCR_FIELDY + max_distance)
10184     return;
10185
10186   volume = SOUND_MAX_VOLUME;
10187
10188   if (!IN_SCR_FIELD(sx, sy))
10189   {
10190     int dx = ABS(sx - SCR_FIELDX / 2) - SCR_FIELDX / 2;
10191     int dy = ABS(sy - SCR_FIELDY / 2) - SCR_FIELDY / 2;
10192
10193     volume -= volume * (dx > dy ? dx : dy) / max_distance;
10194   }
10195
10196   stereo_position = (SOUND_MAX_LEFT +
10197                      (sx + max_distance) * SOUND_MAX_LEFT2RIGHT /
10198                      (SCR_FIELDX + 2 * max_distance));
10199
10200   if (IS_LOOP_SOUND(nr))
10201   {
10202     /* This assures that quieter loop sounds do not overwrite louder ones,
10203        while restarting sound volume comparison with each new game frame. */
10204
10205     if (loop_sound_volume[nr] > volume && loop_sound_frame[nr] == FrameCounter)
10206       return;
10207
10208     loop_sound_volume[nr] = volume;
10209     loop_sound_frame[nr] = FrameCounter;
10210   }
10211
10212   PlaySoundExt(nr, volume, stereo_position, type);
10213 }
10214
10215 static void PlayLevelSoundNearest(int x, int y, int sound_action)
10216 {
10217   PlayLevelSound(x < LEVELX(BX1) ? LEVELX(BX1) :
10218                  x > LEVELX(BX2) ? LEVELX(BX2) : x,
10219                  y < LEVELY(BY1) ? LEVELY(BY1) :
10220                  y > LEVELY(BY2) ? LEVELY(BY2) : y,
10221                  sound_action);
10222 }
10223
10224 static void PlayLevelSoundAction(int x, int y, int action)
10225 {
10226   PlayLevelSoundElementAction(x, y, Feld[x][y], action);
10227 }
10228
10229 static void PlayLevelSoundElementAction(int x, int y, int element, int action)
10230 {
10231   int sound_effect = element_info[SND_ELEMENT(element)].sound[action];
10232
10233   if (sound_effect != SND_UNDEFINED)
10234     PlayLevelSound(x, y, sound_effect);
10235 }
10236
10237 static void PlayLevelSoundElementActionIfLoop(int x, int y, int element,
10238                                               int action)
10239 {
10240   int sound_effect = element_info[SND_ELEMENT(element)].sound[action];
10241
10242   if (sound_effect != SND_UNDEFINED && IS_LOOP_SOUND(sound_effect))
10243     PlayLevelSound(x, y, sound_effect);
10244 }
10245
10246 static void PlayLevelSoundActionIfLoop(int x, int y, int action)
10247 {
10248   int sound_effect = element_info[SND_ELEMENT(Feld[x][y])].sound[action];
10249
10250   if (sound_effect != SND_UNDEFINED && IS_LOOP_SOUND(sound_effect))
10251     PlayLevelSound(x, y, sound_effect);
10252 }
10253
10254 static void StopLevelSoundActionIfLoop(int x, int y, int action)
10255 {
10256   int sound_effect = element_info[SND_ELEMENT(Feld[x][y])].sound[action];
10257
10258   if (sound_effect != SND_UNDEFINED && IS_LOOP_SOUND(sound_effect))
10259     StopSound(sound_effect);
10260 }
10261
10262 static void PlayLevelMusic()
10263 {
10264   if (levelset.music[level_nr] != MUS_UNDEFINED)
10265     PlayMusic(levelset.music[level_nr]);        /* from config file */
10266   else
10267     PlayMusic(MAP_NOCONF_MUSIC(level_nr));      /* from music dir */
10268 }
10269
10270 void PlayLevelSound_EM(int x, int y, int element_em, int sample)
10271 {
10272   int element = (element_em > -1 ? map_element_EM_to_RND(element_em) : 0);
10273
10274   switch (sample)
10275   {
10276     case SAMPLE_blank:
10277       PlayLevelSoundElementAction(x, y, element, ACTION_WALKING);
10278       break;
10279
10280     case SAMPLE_roll:
10281       PlayLevelSoundElementAction(x, y, element, ACTION_PUSHING);
10282       break;
10283
10284     case SAMPLE_stone:
10285       PlayLevelSoundElementAction(x, y, element, ACTION_IMPACT);
10286       break;
10287
10288     case SAMPLE_nut:
10289       PlayLevelSoundElementAction(x, y, element, ACTION_IMPACT);
10290       break;
10291
10292     case SAMPLE_crack:
10293       PlayLevelSoundElementAction(x, y, element, ACTION_BREAKING);
10294       break;
10295
10296     case SAMPLE_bug:
10297       PlayLevelSoundElementAction(x, y, element, ACTION_MOVING);
10298       break;
10299
10300     case SAMPLE_tank:
10301       PlayLevelSoundElementAction(x, y, element, ACTION_MOVING);
10302       break;
10303
10304     case SAMPLE_android_clone:
10305       PlayLevelSoundElementAction(x, y, element, ACTION_DROPPING);
10306       break;
10307
10308     case SAMPLE_android_move:
10309       PlayLevelSoundElementAction(x, y, element, ACTION_MOVING);
10310       break;
10311
10312     case SAMPLE_spring:
10313       PlayLevelSoundElementAction(x, y, element, ACTION_IMPACT);
10314       break;
10315
10316     case SAMPLE_slurp:
10317       PlayLevelSoundElementAction(x, y, element, ACTION_SLURPED_BY_SPRING);
10318       break;
10319
10320     case SAMPLE_eater:
10321       PlayLevelSoundElementAction(x, y, element, ACTION_WAITING);
10322       break;
10323
10324     case SAMPLE_eater_eat:
10325       PlayLevelSoundElementAction(x, y, element, ACTION_DIGGING);
10326       break;
10327
10328     case SAMPLE_alien:
10329       PlayLevelSoundElementAction(x, y, element, ACTION_MOVING);
10330       break;
10331
10332     case SAMPLE_collect:
10333       PlayLevelSoundElementAction(x, y, element, ACTION_COLLECTING);
10334       break;
10335
10336     case SAMPLE_diamond:
10337       PlayLevelSoundElementAction(x, y, element, ACTION_IMPACT);
10338       break;
10339
10340     case SAMPLE_squash:
10341       /* !!! CHECK THIS !!! */
10342 #if 1
10343       PlayLevelSoundElementAction(x, y, element, ACTION_BREAKING);
10344 #else
10345       PlayLevelSoundElementAction(x, y, element, ACTION_SMASHED_BY_ROCK);
10346 #endif
10347       break;
10348
10349     case SAMPLE_wonderfall:
10350       PlayLevelSoundElementAction(x, y, element, ACTION_FILLING);
10351       break;
10352
10353     case SAMPLE_drip:
10354       PlayLevelSoundElementAction(x, y, element, ACTION_IMPACT);
10355       break;
10356
10357     case SAMPLE_push:
10358       PlayLevelSoundElementAction(x, y, element, ACTION_PUSHING);
10359       break;
10360
10361     case SAMPLE_dirt:
10362       PlayLevelSoundElementAction(x, y, element, ACTION_DIGGING);
10363       break;
10364
10365     case SAMPLE_acid:
10366       PlayLevelSoundElementAction(x, y, element, ACTION_SPLASHING);
10367       break;
10368
10369     case SAMPLE_ball:
10370       PlayLevelSoundElementAction(x, y, element, ACTION_DROPPING);
10371       break;
10372
10373     case SAMPLE_grow:
10374       PlayLevelSoundElementAction(x, y, element, ACTION_GROWING);
10375       break;
10376
10377     case SAMPLE_wonder:
10378       PlayLevelSoundElementAction(x, y, element, ACTION_ACTIVE);
10379       break;
10380
10381     case SAMPLE_door:
10382       PlayLevelSoundElementAction(x, y, element, ACTION_PASSING);
10383       break;
10384
10385     case SAMPLE_exit_open:
10386       PlayLevelSoundElementAction(x, y, element, ACTION_OPENING);
10387       break;
10388
10389     case SAMPLE_exit_leave:
10390       PlayLevelSoundElementAction(x, y, element, ACTION_PASSING);
10391       break;
10392
10393     case SAMPLE_dynamite:
10394       PlayLevelSoundElementAction(x, y, element, ACTION_DROPPING);
10395       break;
10396
10397     case SAMPLE_tick:
10398       PlayLevelSoundElementAction(x, y, element, ACTION_ACTIVE);
10399       break;
10400
10401     case SAMPLE_press:
10402       PlayLevelSoundElementAction(x, y, element, ACTION_ACTIVATING);
10403       break;
10404
10405     case SAMPLE_wheel:
10406       PlayLevelSoundElementAction(x, y, element, ACTION_ACTIVE);
10407       break;
10408
10409     case SAMPLE_boom:
10410       PlayLevelSoundElementAction(x, y, element, ACTION_EXPLODING);
10411       break;
10412
10413     case SAMPLE_die:
10414       PlayLevelSoundElementAction(x, y, element, ACTION_DYING);
10415       break;
10416
10417     case SAMPLE_time:
10418       PlaySoundStereo(SND_GAME_RUNNING_OUT_OF_TIME, SOUND_MIDDLE);
10419       break;
10420
10421     default:
10422       PlayLevelSoundElementAction(x, y, element, ACTION_DEFAULT);
10423       break;
10424   }
10425 }
10426
10427 void RaiseScore(int value)
10428 {
10429   local_player->score += value;
10430
10431   DrawGameValue_Score(local_player->score);
10432 }
10433
10434 void RaiseScoreElement(int element)
10435 {
10436   switch(element)
10437   {
10438     case EL_EMERALD:
10439     case EL_BD_DIAMOND:
10440     case EL_EMERALD_YELLOW:
10441     case EL_EMERALD_RED:
10442     case EL_EMERALD_PURPLE:
10443     case EL_SP_INFOTRON:
10444       RaiseScore(level.score[SC_EMERALD]);
10445       break;
10446     case EL_DIAMOND:
10447       RaiseScore(level.score[SC_DIAMOND]);
10448       break;
10449     case EL_CRYSTAL:
10450       RaiseScore(level.score[SC_CRYSTAL]);
10451       break;
10452     case EL_PEARL:
10453       RaiseScore(level.score[SC_PEARL]);
10454       break;
10455     case EL_BUG:
10456     case EL_BD_BUTTERFLY:
10457     case EL_SP_ELECTRON:
10458       RaiseScore(level.score[SC_BUG]);
10459       break;
10460     case EL_SPACESHIP:
10461     case EL_BD_FIREFLY:
10462     case EL_SP_SNIKSNAK:
10463       RaiseScore(level.score[SC_SPACESHIP]);
10464       break;
10465     case EL_YAMYAM:
10466     case EL_DARK_YAMYAM:
10467       RaiseScore(level.score[SC_YAMYAM]);
10468       break;
10469     case EL_ROBOT:
10470       RaiseScore(level.score[SC_ROBOT]);
10471       break;
10472     case EL_PACMAN:
10473       RaiseScore(level.score[SC_PACMAN]);
10474       break;
10475     case EL_NUT:
10476       RaiseScore(level.score[SC_NUT]);
10477       break;
10478     case EL_DYNAMITE:
10479     case EL_SP_DISK_RED:
10480     case EL_DYNABOMB_INCREASE_NUMBER:
10481     case EL_DYNABOMB_INCREASE_SIZE:
10482     case EL_DYNABOMB_INCREASE_POWER:
10483       RaiseScore(level.score[SC_DYNAMITE]);
10484       break;
10485     case EL_SHIELD_NORMAL:
10486     case EL_SHIELD_DEADLY:
10487       RaiseScore(level.score[SC_SHIELD]);
10488       break;
10489     case EL_EXTRA_TIME:
10490       RaiseScore(level.score[SC_TIME_BONUS]);
10491       break;
10492     case EL_KEY_1:
10493     case EL_KEY_2:
10494     case EL_KEY_3:
10495     case EL_KEY_4:
10496     case EL_EM_KEY_1:
10497     case EL_EM_KEY_2:
10498     case EL_EM_KEY_3:
10499     case EL_EM_KEY_4:
10500     case EL_EMC_KEY_5:
10501     case EL_EMC_KEY_6:
10502     case EL_EMC_KEY_7:
10503     case EL_EMC_KEY_8:
10504       RaiseScore(level.score[SC_KEY]);
10505       break;
10506     default:
10507       RaiseScore(element_info[element].collect_score);
10508       break;
10509   }
10510 }
10511
10512 void RequestQuitGame(boolean ask_if_really_quit)
10513 {
10514   if (AllPlayersGone ||
10515       !ask_if_really_quit ||
10516       level_editor_test_game ||
10517       Request("Do you really want to quit the game ?",
10518               REQ_ASK | REQ_STAY_CLOSED))
10519   {
10520 #if defined(NETWORK_AVALIABLE)
10521     if (options.network)
10522       SendToServer_StopPlaying();
10523     else
10524 #endif
10525     {
10526       game_status = GAME_MODE_MAIN;
10527       DrawMainMenu();
10528     }
10529   }
10530   else
10531   {
10532     if (tape.playing && tape.deactivate_display)
10533       TapeDeactivateDisplayOff(TRUE);
10534
10535     OpenDoor(DOOR_OPEN_1 | DOOR_COPY_BACK);
10536
10537     if (tape.playing && tape.deactivate_display)
10538       TapeDeactivateDisplayOn();
10539   }
10540 }
10541
10542
10543 /* ---------- new game button stuff ---------------------------------------- */
10544
10545 /* graphic position values for game buttons */
10546 #define GAME_BUTTON_XSIZE       30
10547 #define GAME_BUTTON_YSIZE       30
10548 #define GAME_BUTTON_XPOS        5
10549 #define GAME_BUTTON_YPOS        215
10550 #define SOUND_BUTTON_XPOS       5
10551 #define SOUND_BUTTON_YPOS       (GAME_BUTTON_YPOS + GAME_BUTTON_YSIZE)
10552
10553 #define GAME_BUTTON_STOP_XPOS   (GAME_BUTTON_XPOS + 0 * GAME_BUTTON_XSIZE)
10554 #define GAME_BUTTON_PAUSE_XPOS  (GAME_BUTTON_XPOS + 1 * GAME_BUTTON_XSIZE)
10555 #define GAME_BUTTON_PLAY_XPOS   (GAME_BUTTON_XPOS + 2 * GAME_BUTTON_XSIZE)
10556 #define SOUND_BUTTON_MUSIC_XPOS (SOUND_BUTTON_XPOS + 0 * GAME_BUTTON_XSIZE)
10557 #define SOUND_BUTTON_LOOPS_XPOS (SOUND_BUTTON_XPOS + 1 * GAME_BUTTON_XSIZE)
10558 #define SOUND_BUTTON_SIMPLE_XPOS (SOUND_BUTTON_XPOS + 2 * GAME_BUTTON_XSIZE)
10559
10560 static struct
10561 {
10562   int x, y;
10563   int gadget_id;
10564   char *infotext;
10565 } gamebutton_info[NUM_GAME_BUTTONS] =
10566 {
10567   {
10568     GAME_BUTTON_STOP_XPOS,      GAME_BUTTON_YPOS,
10569     GAME_CTRL_ID_STOP,
10570     "stop game"
10571   },
10572   {
10573     GAME_BUTTON_PAUSE_XPOS,     GAME_BUTTON_YPOS,
10574     GAME_CTRL_ID_PAUSE,
10575     "pause game"
10576   },
10577   {
10578     GAME_BUTTON_PLAY_XPOS,      GAME_BUTTON_YPOS,
10579     GAME_CTRL_ID_PLAY,
10580     "play game"
10581   },
10582   {
10583     SOUND_BUTTON_MUSIC_XPOS,    SOUND_BUTTON_YPOS,
10584     SOUND_CTRL_ID_MUSIC,
10585     "background music on/off"
10586   },
10587   {
10588     SOUND_BUTTON_LOOPS_XPOS,    SOUND_BUTTON_YPOS,
10589     SOUND_CTRL_ID_LOOPS,
10590     "sound loops on/off"
10591   },
10592   {
10593     SOUND_BUTTON_SIMPLE_XPOS,   SOUND_BUTTON_YPOS,
10594     SOUND_CTRL_ID_SIMPLE,
10595     "normal sounds on/off"
10596   }
10597 };
10598
10599 void CreateGameButtons()
10600 {
10601   int i;
10602
10603   for (i = 0; i < NUM_GAME_BUTTONS; i++)
10604   {
10605     Bitmap *gd_bitmap = graphic_info[IMG_GLOBAL_DOOR].bitmap;
10606     struct GadgetInfo *gi;
10607     int button_type;
10608     boolean checked;
10609     unsigned long event_mask;
10610     int gd_xoffset, gd_yoffset;
10611     int gd_x1, gd_x2, gd_y1, gd_y2;
10612     int id = i;
10613
10614     gd_xoffset = gamebutton_info[i].x;
10615     gd_yoffset = gamebutton_info[i].y;
10616     gd_x1 = DOOR_GFX_PAGEX4 + gd_xoffset;
10617     gd_x2 = DOOR_GFX_PAGEX3 + gd_xoffset;
10618
10619     if (id == GAME_CTRL_ID_STOP ||
10620         id == GAME_CTRL_ID_PAUSE ||
10621         id == GAME_CTRL_ID_PLAY)
10622     {
10623       button_type = GD_TYPE_NORMAL_BUTTON;
10624       checked = FALSE;
10625       event_mask = GD_EVENT_RELEASED;
10626       gd_y1  = DOOR_GFX_PAGEY1 + gd_yoffset - GAME_BUTTON_YSIZE;
10627       gd_y2  = DOOR_GFX_PAGEY1 + gd_yoffset - GAME_BUTTON_YSIZE;
10628     }
10629     else
10630     {
10631       button_type = GD_TYPE_CHECK_BUTTON;
10632       checked =
10633         ((id == SOUND_CTRL_ID_MUSIC && setup.sound_music) ||
10634          (id == SOUND_CTRL_ID_LOOPS && setup.sound_loops) ||
10635          (id == SOUND_CTRL_ID_SIMPLE && setup.sound_simple) ? TRUE : FALSE);
10636       event_mask = GD_EVENT_PRESSED;
10637       gd_y1  = DOOR_GFX_PAGEY1 + gd_yoffset;
10638       gd_y2  = DOOR_GFX_PAGEY1 + gd_yoffset - GAME_BUTTON_YSIZE;
10639     }
10640
10641     gi = CreateGadget(GDI_CUSTOM_ID, id,
10642                       GDI_INFO_TEXT, gamebutton_info[i].infotext,
10643                       GDI_X, DX + gd_xoffset,
10644                       GDI_Y, DY + gd_yoffset,
10645                       GDI_WIDTH, GAME_BUTTON_XSIZE,
10646                       GDI_HEIGHT, GAME_BUTTON_YSIZE,
10647                       GDI_TYPE, button_type,
10648                       GDI_STATE, GD_BUTTON_UNPRESSED,
10649                       GDI_CHECKED, checked,
10650                       GDI_DESIGN_UNPRESSED, gd_bitmap, gd_x1, gd_y1,
10651                       GDI_DESIGN_PRESSED, gd_bitmap, gd_x2, gd_y1,
10652                       GDI_ALT_DESIGN_UNPRESSED, gd_bitmap, gd_x1, gd_y2,
10653                       GDI_ALT_DESIGN_PRESSED, gd_bitmap, gd_x2, gd_y2,
10654                       GDI_EVENT_MASK, event_mask,
10655                       GDI_CALLBACK_ACTION, HandleGameButtons,
10656                       GDI_END);
10657
10658     if (gi == NULL)
10659       Error(ERR_EXIT, "cannot create gadget");
10660
10661     game_gadget[id] = gi;
10662   }
10663 }
10664
10665 void FreeGameButtons()
10666 {
10667   int i;
10668
10669   for (i = 0; i < NUM_GAME_BUTTONS; i++)
10670     FreeGadget(game_gadget[i]);
10671 }
10672
10673 static void MapGameButtons()
10674 {
10675   int i;
10676
10677   for (i = 0; i < NUM_GAME_BUTTONS; i++)
10678     MapGadget(game_gadget[i]);
10679 }
10680
10681 void UnmapGameButtons()
10682 {
10683   int i;
10684
10685   for (i = 0; i < NUM_GAME_BUTTONS; i++)
10686     UnmapGadget(game_gadget[i]);
10687 }
10688
10689 static void HandleGameButtons(struct GadgetInfo *gi)
10690 {
10691   int id = gi->custom_id;
10692
10693   if (game_status != GAME_MODE_PLAYING)
10694     return;
10695
10696   switch (id)
10697   {
10698     case GAME_CTRL_ID_STOP:
10699       RequestQuitGame(TRUE);
10700       break;
10701
10702     case GAME_CTRL_ID_PAUSE:
10703       if (options.network)
10704       {
10705 #if defined(NETWORK_AVALIABLE)
10706         if (tape.pausing)
10707           SendToServer_ContinuePlaying();
10708         else
10709           SendToServer_PausePlaying();
10710 #endif
10711       }
10712       else
10713         TapeTogglePause(TAPE_TOGGLE_MANUAL);
10714       break;
10715
10716     case GAME_CTRL_ID_PLAY:
10717       if (tape.pausing)
10718       {
10719 #if defined(NETWORK_AVALIABLE)
10720         if (options.network)
10721           SendToServer_ContinuePlaying();
10722         else
10723 #endif
10724         {
10725           tape.pausing = FALSE;
10726           DrawVideoDisplay(VIDEO_STATE_PAUSE_OFF,0);
10727         }
10728       }
10729       break;
10730
10731     case SOUND_CTRL_ID_MUSIC:
10732       if (setup.sound_music)
10733       {
10734         setup.sound_music = FALSE;
10735         FadeMusic();
10736       }
10737       else if (audio.music_available)
10738       {
10739         setup.sound = setup.sound_music = TRUE;
10740
10741         SetAudioMode(setup.sound);
10742
10743         PlayLevelMusic();
10744       }
10745       break;
10746
10747     case SOUND_CTRL_ID_LOOPS:
10748       if (setup.sound_loops)
10749         setup.sound_loops = FALSE;
10750       else if (audio.loops_available)
10751       {
10752         setup.sound = setup.sound_loops = TRUE;
10753         SetAudioMode(setup.sound);
10754       }
10755       break;
10756
10757     case SOUND_CTRL_ID_SIMPLE:
10758       if (setup.sound_simple)
10759         setup.sound_simple = FALSE;
10760       else if (audio.sound_available)
10761       {
10762         setup.sound = setup.sound_simple = TRUE;
10763         SetAudioMode(setup.sound);
10764       }
10765       break;
10766
10767     default:
10768       break;
10769   }
10770 }