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   int action_arg_player_bits =
6600     (action_arg == CA_ARG_PLAYER_ANY ? PLAYER_BITS_ANY :
6601      action_arg >= CA_ARG_PLAYER_1 &&
6602      action_arg <= CA_ARG_PLAYER_4 ? action_arg - CA_ARG_PLAYER :
6603      action_arg >= CA_ARG_1 &&
6604      action_arg <= CA_ARG_PLAYER_4 ? (1 << (action_arg - CA_ARG_1)) :
6605      action_arg_element >= EL_PLAYER_1 &&
6606      action_arg_element <= EL_PLAYER_4 ?
6607      (1 << (action_arg_element - EL_PLAYER_1)) :
6608      PLAYER_BITS_ANY);
6609
6610   int trigger_player_bits =
6611     (change->actual_trigger_player >= EL_PLAYER_1 &&
6612      change->actual_trigger_player <= EL_PLAYER_4 ?
6613      (1 << (change->actual_trigger_player - EL_PLAYER_1)) :
6614      PLAYER_BITS_ANY);
6615
6616   /* ---------- execute action  ---------- */
6617
6618   switch(action_type)
6619   {
6620     case CA_NO_ACTION:
6621     {
6622       return;
6623     }
6624
6625     case CA_EXIT_PLAYER:
6626     {
6627       for (i = 0; i < MAX_PLAYERS; i++)
6628         if (action_arg_player_bits & (1 << i))
6629           stored_player[i].LevelSolved = stored_player[i].GameOver = TRUE;
6630
6631       break;
6632     }
6633
6634     case CA_KILL_PLAYER:
6635     {
6636       for (i = 0; i < MAX_PLAYERS; i++)
6637         if (action_arg_player_bits & (1 << i))
6638           KillPlayer(&stored_player[i]);
6639
6640       break;
6641     }
6642
6643     case CA_RESTART_LEVEL:
6644     {
6645       game.restart_level = TRUE;
6646
6647       break;
6648     }
6649
6650     case CA_SHOW_ENVELOPE:
6651     {
6652       int element = getSpecialActionElement(action_arg_element,
6653                                             action_arg_number, EL_ENVELOPE_1);
6654
6655       if (IS_ENVELOPE(element))
6656         local_player->show_envelope = element;
6657
6658       break;
6659     }
6660
6661     case CA_ADD_KEY:
6662     {
6663       int element = getSpecialActionElement(action_arg_element,
6664                                             action_arg_number, EL_KEY_1);
6665
6666       if (IS_KEY(element))
6667       {
6668         for (i = 0; i < MAX_PLAYERS; i++)
6669         {
6670           if (trigger_player_bits & (1 << i))
6671           {
6672             stored_player[i].key[KEY_NR(element)] = TRUE;
6673
6674             DrawGameValue_Keys(stored_player[i].key);
6675
6676             redraw_mask |= REDRAW_DOOR_1;
6677           }
6678         }
6679       }
6680
6681       break;
6682     }
6683
6684     case CA_DEL_KEY:
6685     {
6686       int element = getSpecialActionElement(action_arg_element,
6687                                             action_arg_number, EL_KEY_1);
6688
6689       if (IS_KEY(element))
6690       {
6691         for (i = 0; i < MAX_PLAYERS; i++)
6692         {
6693           if (trigger_player_bits & (1 << i))
6694           {
6695             stored_player[i].key[KEY_NR(element)] = FALSE;
6696
6697             DrawGameValue_Keys(stored_player[i].key);
6698
6699             redraw_mask |= REDRAW_DOOR_1;
6700           }
6701         }
6702       }
6703
6704       break;
6705     }
6706
6707     case CA_SET_PLAYER_SPEED:
6708     {
6709       for (i = 0; i < MAX_PLAYERS; i++)
6710       {
6711         if (trigger_player_bits & (1 << i))
6712         {
6713           int move_stepsize = TILEX / stored_player[i].move_delay_value;
6714
6715           if (action_mode == CA_MODE_ADD || action_mode == CA_MODE_SUBTRACT)
6716           {
6717             /* translate "+" and "-" to "*" and "/" with powers of two */
6718             action_arg_number = 1 << action_arg_number;
6719             action_mode = (action_mode == CA_MODE_ADD ? CA_MODE_MULTIPLY :
6720                            CA_MODE_DIVIDE);
6721           }
6722
6723           move_stepsize =
6724             getModifiedActionNumber(move_stepsize,
6725                                     action_mode,
6726                                     action_arg_number,
6727                                     action_arg_number_min,
6728                                     action_arg_number_max);
6729
6730           /* make sure that value is power of 2 */
6731           move_stepsize = (1 << log_2(move_stepsize));
6732
6733           /* do no immediately change -- the player might just be moving */
6734           stored_player[i].move_delay_value_next = TILEX / move_stepsize;
6735
6736 #if 0
6737           printf("::: move_delay_value == %d [%d]\n",
6738                  stored_player[i].move_delay_value_next, action_arg_number);
6739 #endif
6740         }
6741       }
6742
6743       break;
6744     }
6745
6746     case CA_SET_GEMS:
6747     {
6748       local_player->gems_still_needed = action_arg_number_new;
6749
6750       DrawGameValue_Emeralds(local_player->gems_still_needed);
6751
6752       break;
6753     }
6754
6755     case CA_SET_TIME:
6756     {
6757       if (level.time > 0)       /* only modify limited time value */
6758       {
6759         TimeLeft = action_arg_number_new;
6760
6761         DrawGameValue_Time(TimeLeft);
6762
6763         if (!TimeLeft && setup.time_limit)
6764           for (i = 0; i < MAX_PLAYERS; i++)
6765             KillPlayer(&stored_player[i]);
6766       }
6767
6768       break;
6769     }
6770
6771     case CA_SET_SCORE:
6772     {
6773       local_player->score = action_arg_number_new;
6774
6775       DrawGameValue_Score(local_player->score);
6776
6777       break;
6778     }
6779
6780     case CA_SET_CE_SCORE:
6781     {
6782       ei->collect_score = action_arg_number_new;
6783
6784       break;
6785     }
6786
6787     case CA_SET_CE_COUNT:
6788     {
6789 #if USE_NEW_COLLECT_COUNT
6790       int count_last = Count[x][y];
6791
6792       Count[x][y] = action_arg_number_new;
6793
6794 #if 0
6795       printf("::: Count == %d\n", Count[x][y]);
6796 #endif
6797
6798       if (Count[x][y] == 0 && count_last > 0)
6799       {
6800 #if 0
6801         printf("::: CE_COUNT_AT_ZERO\n");
6802 #endif
6803
6804         CheckElementChange(x, y, element, EL_UNDEFINED, CE_COUNT_AT_ZERO);
6805         CheckTriggeredElementChange(element, CE_COUNT_AT_ZERO_OF_X);
6806       }
6807 #endif
6808
6809       break;
6810     }
6811
6812     case CA_SET_DYNABOMB_NUMBER:
6813     {
6814       printf("::: CA_SET_DYNABOMB_NUMBER -- not yet implemented\n");
6815
6816       break;
6817     }
6818
6819     case CA_SET_DYNABOMB_SIZE:
6820     {
6821       printf("::: CA_SET_DYNABOMB_SIZE -- not yet implemented\n");
6822
6823       break;
6824     }
6825
6826     case CA_SET_DYNABOMB_POWER:
6827     {
6828       printf("::: CA_SET_DYNABOMB_POWER -- not yet implemented\n");
6829
6830       break;
6831     }
6832
6833     case CA_TOGGLE_PLAYER_GRAVITY:
6834     {
6835       game.gravity = !game.gravity;
6836
6837       break;
6838     }
6839
6840     case CA_ENABLE_PLAYER_GRAVITY:
6841     {
6842       game.gravity = TRUE;
6843
6844       break;
6845     }
6846
6847     case CA_DISABLE_PLAYER_GRAVITY:
6848     {
6849       game.gravity = FALSE;
6850
6851       break;
6852     }
6853
6854     default:
6855       break;
6856   }
6857 }
6858
6859 static void ChangeElementNowExt(struct ElementChangeInfo *change,
6860                                 int x, int y, int target_element)
6861 {
6862   int previous_move_direction = MovDir[x][y];
6863   boolean add_player = (ELEM_IS_PLAYER(target_element) &&
6864                         IS_WALKABLE(Feld[x][y]));
6865
6866   /* check if element under player changes from accessible to unaccessible
6867      (needed for special case of dropping element which then changes) */
6868   if (IS_PLAYER(x, y) && !PLAYER_EXPLOSION_PROTECTED(x, y) &&
6869       IS_ACCESSIBLE(Feld[x][y]) && !IS_ACCESSIBLE(target_element))
6870   {
6871     Bang(x, y);
6872     return;
6873   }
6874
6875   if (!add_player)
6876   {
6877     if (IS_MOVING(x, y) || IS_BLOCKED(x, y))
6878       RemoveMovingField(x, y);
6879     else
6880       RemoveField(x, y);
6881
6882     Feld[x][y] = target_element;
6883
6884     ResetGfxAnimation(x, y);
6885     ResetRandomAnimationValue(x, y);
6886
6887     if (element_info[Feld[x][y]].move_direction_initial == MV_START_PREVIOUS)
6888       MovDir[x][y] = previous_move_direction;
6889
6890     InitField_WithBug1(x, y, FALSE);
6891
6892     DrawLevelField(x, y);
6893
6894     if (GFX_CRUMBLED(Feld[x][y]))
6895       DrawLevelFieldCrumbledSandNeighbours(x, y);
6896   }
6897
6898   /* "Changed[][]" not set yet to allow "entered by player" change one time */
6899   if (ELEM_IS_PLAYER(target_element))
6900     RelocatePlayer(x, y, target_element);
6901
6902 #if 1
6903   Changed[x][y] = TRUE;         /* ignore all further changes in this frame */
6904 #else
6905   Changed[x][y] |= ChangeEvent[x][y];   /* ignore same changes in this frame */
6906 #endif
6907
6908   TestIfBadThingTouchesPlayer(x, y);
6909   TestIfPlayerTouchesCustomElement(x, y);
6910   TestIfElementTouchesCustomElement(x, y);
6911 }
6912
6913 static boolean ChangeElementNow(int x, int y, int element, int page)
6914 {
6915   struct ElementChangeInfo *change = &element_info[element].change_page[page];
6916   int target_element;
6917   int old_element = Feld[x][y];
6918
6919   /* always use default change event to prevent running into a loop */
6920   if (ChangeEvent[x][y] == -1)
6921     ChangeEvent[x][y] = CE_DELAY;
6922
6923   if (ChangeEvent[x][y] == CE_DELAY)
6924   {
6925     /* reset actual trigger element, trigger player and action element */
6926     change->actual_trigger_element = EL_EMPTY;
6927     change->actual_trigger_player = EL_PLAYER_1;
6928   }
6929
6930 #if 1
6931   /* do not change any elements that have already changed in this frame */
6932   if (Changed[x][y])
6933     return FALSE;
6934 #else
6935   /* do not change already changed elements with same change event */
6936   if (Changed[x][y] & ChangeEvent[x][y])
6937     return FALSE;
6938 #endif
6939
6940 #if 1
6941   Changed[x][y] = TRUE;         /* ignore all further changes in this frame */
6942 #else
6943   Changed[x][y] |= ChangeEvent[x][y];   /* ignore same changes in this frame */
6944 #endif
6945
6946   if (change->explode)
6947   {
6948     Bang(x, y);
6949
6950     return TRUE;
6951   }
6952
6953   if (change->use_target_content)
6954   {
6955     boolean complete_replace = TRUE;
6956     boolean can_replace[3][3];
6957     int xx, yy;
6958
6959     for (yy = 0; yy < 3; yy++) for (xx = 0; xx < 3 ; xx++)
6960     {
6961       boolean is_empty;
6962       boolean is_walkable;
6963       boolean is_diggable;
6964       boolean is_collectible;
6965       boolean is_removable;
6966       boolean is_destructible;
6967       int ex = x + xx - 1;
6968       int ey = y + yy - 1;
6969       int content_element = change->target_content.e[xx][yy];
6970       int e;
6971
6972       can_replace[xx][yy] = TRUE;
6973
6974       if (ex == x && ey == y)   /* do not check changing element itself */
6975         continue;
6976
6977       if (content_element == EL_EMPTY_SPACE)
6978       {
6979         can_replace[xx][yy] = FALSE;    /* do not replace border with space */
6980
6981         continue;
6982       }
6983
6984       if (!IN_LEV_FIELD(ex, ey))
6985       {
6986         can_replace[xx][yy] = FALSE;
6987         complete_replace = FALSE;
6988
6989         continue;
6990       }
6991
6992       e = Feld[ex][ey];
6993
6994       if (IS_MOVING(ex, ey) || IS_BLOCKED(ex, ey))
6995         e = MovingOrBlocked2Element(ex, ey);
6996
6997       is_empty = (IS_FREE(ex, ey) ||
6998                   (IS_FREE_OR_PLAYER(ex, ey) && IS_WALKABLE(content_element)));
6999
7000       is_walkable     = (is_empty || IS_WALKABLE(e));
7001       is_diggable     = (is_empty || IS_DIGGABLE(e));
7002       is_collectible  = (is_empty || IS_COLLECTIBLE(e));
7003       is_destructible = (is_empty || !IS_INDESTRUCTIBLE(e));
7004       is_removable    = (is_diggable || is_collectible);
7005
7006       can_replace[xx][yy] =
7007         (((change->replace_when == CP_WHEN_EMPTY        && is_empty) ||
7008           (change->replace_when == CP_WHEN_WALKABLE     && is_walkable) ||
7009           (change->replace_when == CP_WHEN_DIGGABLE     && is_diggable) ||
7010           (change->replace_when == CP_WHEN_COLLECTIBLE  && is_collectible) ||
7011           (change->replace_when == CP_WHEN_REMOVABLE    && is_removable) ||
7012           (change->replace_when == CP_WHEN_DESTRUCTIBLE && is_destructible)) &&
7013          !(IS_PLAYER(ex, ey) && ELEM_IS_PLAYER(content_element)));
7014
7015       if (!can_replace[xx][yy])
7016         complete_replace = FALSE;
7017     }
7018
7019     if (!change->only_if_complete || complete_replace)
7020     {
7021       boolean something_has_changed = FALSE;
7022
7023       if (change->only_if_complete && change->use_random_replace &&
7024           RND(100) < change->random_percentage)
7025         return FALSE;
7026
7027       for (yy = 0; yy < 3; yy++) for (xx = 0; xx < 3 ; xx++)
7028       {
7029         int ex = x + xx - 1;
7030         int ey = y + yy - 1;
7031         int content_element;
7032
7033         if (can_replace[xx][yy] && (!change->use_random_replace ||
7034                                     RND(100) < change->random_percentage))
7035         {
7036           if (IS_MOVING(ex, ey) || IS_BLOCKED(ex, ey))
7037             RemoveMovingField(ex, ey);
7038
7039           ChangeEvent[ex][ey] = ChangeEvent[x][y];
7040
7041           content_element = change->target_content.e[xx][yy];
7042           target_element = GET_TARGET_ELEMENT(content_element, change);
7043
7044           ChangeElementNowExt(change, ex, ey, target_element);
7045
7046           something_has_changed = TRUE;
7047
7048           /* for symmetry reasons, freeze newly created border elements */
7049           if (ex != x || ey != y)
7050             Stop[ex][ey] = TRUE;        /* no more moving in this frame */
7051         }
7052       }
7053
7054       if (something_has_changed)
7055       {
7056         PlayLevelSoundElementAction(x, y, element, ACTION_CHANGING);
7057         PlayLevelSoundElementAction(x, y, element, ACTION_PAGE_1 + page);
7058       }
7059     }
7060   }
7061   else
7062   {
7063     target_element = GET_TARGET_ELEMENT(change->target_element, change);
7064
7065     ChangeElementNowExt(change, x, y, target_element);
7066
7067     PlayLevelSoundElementAction(x, y, element, ACTION_CHANGING);
7068     PlayLevelSoundElementAction(x, y, element, ACTION_PAGE_1 + page);
7069   }
7070
7071   /* this uses direct change before indirect change */
7072   CheckTriggeredElementChangeByPage(old_element, CE_CHANGE_OF_X, page);
7073
7074   return TRUE;
7075 }
7076
7077 #if USE_NEW_DELAYED_ACTION
7078
7079 static void ChangeElement(int x, int y, int page)
7080 {
7081   int element = MovingOrBlocked2Element(x, y);
7082   struct ElementInfo *ei = &element_info[element];
7083   struct ElementChangeInfo *change = &ei->change_page[page];
7084
7085 #ifdef DEBUG
7086   if (!CAN_CHANGE_OR_HAS_ACTION(element) &&
7087       !CAN_CHANGE_OR_HAS_ACTION(Back[x][y]))
7088   {
7089     printf("\n\n");
7090     printf("ChangeElement(): %d,%d: element = %d ('%s')\n",
7091            x, y, element, element_info[element].token_name);
7092     printf("ChangeElement(): This should never happen!\n");
7093     printf("\n\n");
7094   }
7095 #endif
7096
7097   /* this can happen with classic bombs on walkable, changing elements */
7098   if (!CAN_CHANGE_OR_HAS_ACTION(element))
7099   {
7100 #if 0
7101     if (!CAN_CHANGE(Back[x][y]))        /* prevent permanent repetition */
7102       ChangeDelay[x][y] = 0;
7103 #endif
7104
7105     return;
7106   }
7107
7108   if (ChangeDelay[x][y] == 0)           /* initialize element change */
7109   {
7110     ChangeDelay[x][y] = GET_CHANGE_DELAY(change) + 1;
7111
7112     if (change->can_change)
7113     {
7114       ResetGfxAnimation(x, y);
7115       ResetRandomAnimationValue(x, y);
7116
7117       if (change->pre_change_function)
7118         change->pre_change_function(x, y);
7119     }
7120   }
7121
7122   ChangeDelay[x][y]--;
7123
7124   if (ChangeDelay[x][y] != 0)           /* continue element change */
7125   {
7126     if (change->can_change)
7127     {
7128       int graphic = el_act_dir2img(element, GfxAction[x][y], GfxDir[x][y]);
7129
7130       if (IS_ANIMATED(graphic))
7131         DrawLevelGraphicAnimationIfNeeded(x, y, graphic);
7132
7133       if (change->change_function)
7134         change->change_function(x, y);
7135     }
7136   }
7137   else                                  /* finish element change */
7138   {
7139     if (ChangePage[x][y] != -1)         /* remember page from delayed change */
7140     {
7141       page = ChangePage[x][y];
7142       ChangePage[x][y] = -1;
7143
7144       change = &ei->change_page[page];
7145     }
7146
7147     if (IS_MOVING(x, y))                /* never change a running system ;-) */
7148     {
7149       ChangeDelay[x][y] = 1;            /* try change after next move step */
7150       ChangePage[x][y] = page;          /* remember page to use for change */
7151
7152       return;
7153     }
7154
7155     if (change->can_change)
7156     {
7157       if (ChangeElementNow(x, y, element, page))
7158       {
7159         if (change->post_change_function)
7160           change->post_change_function(x, y);
7161       }
7162     }
7163
7164     if (change->has_action)
7165       ExecuteCustomElementAction(x, y, element, page);
7166   }
7167 }
7168
7169 #else
7170
7171 static void ChangeElement(int x, int y, int page)
7172 {
7173   int element = MovingOrBlocked2Element(x, y);
7174   struct ElementInfo *ei = &element_info[element];
7175   struct ElementChangeInfo *change = &ei->change_page[page];
7176
7177 #ifdef DEBUG
7178   if (!CAN_CHANGE(element) && !CAN_CHANGE(Back[x][y]))
7179   {
7180     printf("\n\n");
7181     printf("ChangeElement(): %d,%d: element = %d ('%s')\n",
7182            x, y, element, element_info[element].token_name);
7183     printf("ChangeElement(): This should never happen!\n");
7184     printf("\n\n");
7185   }
7186 #endif
7187
7188   /* this can happen with classic bombs on walkable, changing elements */
7189   if (!CAN_CHANGE(element))
7190   {
7191 #if 0
7192     if (!CAN_CHANGE(Back[x][y]))        /* prevent permanent repetition */
7193       ChangeDelay[x][y] = 0;
7194 #endif
7195
7196     return;
7197   }
7198
7199   if (ChangeDelay[x][y] == 0)           /* initialize element change */
7200   {
7201     ChangeDelay[x][y] = GET_CHANGE_DELAY(change) + 1;
7202
7203     ResetGfxAnimation(x, y);
7204     ResetRandomAnimationValue(x, y);
7205
7206     if (change->pre_change_function)
7207       change->pre_change_function(x, y);
7208   }
7209
7210   ChangeDelay[x][y]--;
7211
7212   if (ChangeDelay[x][y] != 0)           /* continue element change */
7213   {
7214     int graphic = el_act_dir2img(element, GfxAction[x][y], GfxDir[x][y]);
7215
7216     if (IS_ANIMATED(graphic))
7217       DrawLevelGraphicAnimationIfNeeded(x, y, graphic);
7218
7219     if (change->change_function)
7220       change->change_function(x, y);
7221   }
7222   else                                  /* finish element change */
7223   {
7224     if (ChangePage[x][y] != -1)         /* remember page from delayed change */
7225     {
7226       page = ChangePage[x][y];
7227       ChangePage[x][y] = -1;
7228
7229       change = &ei->change_page[page];
7230     }
7231
7232     if (IS_MOVING(x, y))                /* never change a running system ;-) */
7233     {
7234       ChangeDelay[x][y] = 1;            /* try change after next move step */
7235       ChangePage[x][y] = page;          /* remember page to use for change */
7236
7237       return;
7238     }
7239
7240     if (ChangeElementNow(x, y, element, page))
7241     {
7242       if (change->post_change_function)
7243         change->post_change_function(x, y);
7244     }
7245   }
7246 }
7247
7248 #endif
7249
7250 static boolean CheckTriggeredElementChangeExt(int trigger_element,
7251                                               int trigger_event,
7252                                               int trigger_player,
7253                                               int trigger_side,
7254                                               int trigger_page)
7255 {
7256   boolean change_done_any = FALSE;
7257   int trigger_page_bits = (trigger_page < 0 ? CH_PAGE_ANY : 1 << trigger_page);
7258   int i;
7259
7260   if (!(trigger_events[trigger_element][trigger_event]))
7261     return FALSE;
7262
7263   for (i = 0; i < NUM_CUSTOM_ELEMENTS; i++)
7264   {
7265     int element = EL_CUSTOM_START + i;
7266     boolean change_done = FALSE;
7267     int p;
7268
7269     if (!CAN_CHANGE_OR_HAS_ACTION(element) ||
7270         !HAS_ANY_CHANGE_EVENT(element, trigger_event))
7271       continue;
7272
7273     for (p = 0; p < element_info[element].num_change_pages; p++)
7274     {
7275       struct ElementChangeInfo *change = &element_info[element].change_page[p];
7276
7277       if (change->can_change_or_has_action &&
7278           change->has_event[trigger_event] &&
7279           change->trigger_side & trigger_side &&
7280           change->trigger_player & trigger_player &&
7281           change->trigger_page & trigger_page_bits &&
7282           IS_EQUAL_OR_IN_GROUP(trigger_element, change->trigger_element))
7283       {
7284         change->actual_trigger_element = trigger_element;
7285         change->actual_trigger_player = EL_PLAYER_1 + log_2(trigger_player);
7286
7287         if ((change->can_change && !change_done) || change->has_action)
7288         {
7289           int x, y;
7290
7291           for (y = 0; y < lev_fieldy; y++) for (x = 0; x < lev_fieldx; x++)
7292           {
7293             if (Feld[x][y] == element)
7294             {
7295               if (change->can_change && !change_done)
7296               {
7297                 ChangeDelay[x][y] = 1;
7298                 ChangeEvent[x][y] = trigger_event;
7299                 ChangeElement(x, y, p);
7300               }
7301 #if USE_NEW_DELAYED_ACTION
7302               else if (change->has_action)
7303               {
7304                 ExecuteCustomElementAction(x, y, element, p);
7305                 PlayLevelSoundElementAction(x, y, element, ACTION_PAGE_1 + p);
7306               }
7307 #else
7308               if (change->has_action)
7309               {
7310                 ExecuteCustomElementAction(x, y, element, p);
7311                 PlayLevelSoundElementAction(x, y, element, ACTION_PAGE_1 + p);
7312               }
7313 #endif
7314             }
7315           }
7316
7317           if (change->can_change)
7318           {
7319             change_done = TRUE;
7320             change_done_any = TRUE;
7321           }
7322         }
7323       }
7324     }
7325   }
7326
7327   return change_done_any;
7328 }
7329
7330 static boolean CheckElementChangeExt(int x, int y,
7331                                      int element,
7332                                      int trigger_element,
7333                                      int trigger_event,
7334                                      int trigger_player,
7335                                      int trigger_side)
7336 {
7337   boolean change_done = FALSE;
7338   int p;
7339
7340   if (!CAN_CHANGE_OR_HAS_ACTION(element) ||
7341       !HAS_ANY_CHANGE_EVENT(element, trigger_event))
7342     return FALSE;
7343
7344   if (Feld[x][y] == EL_BLOCKED)
7345   {
7346     Blocked2Moving(x, y, &x, &y);
7347     element = Feld[x][y];
7348   }
7349
7350   if (Feld[x][y] != element)    /* check if element has already changed */
7351     return FALSE;
7352
7353   for (p = 0; p < element_info[element].num_change_pages; p++)
7354   {
7355     struct ElementChangeInfo *change = &element_info[element].change_page[p];
7356
7357     boolean check_trigger_element =
7358       (trigger_event == CE_TOUCHING_X ||
7359        trigger_event == CE_HITTING_X ||
7360        trigger_event == CE_HIT_BY_X);
7361
7362     if (change->can_change_or_has_action &&
7363         change->has_event[trigger_event] &&
7364         change->trigger_side & trigger_side &&
7365         change->trigger_player & trigger_player &&
7366         (!check_trigger_element ||
7367          IS_EQUAL_OR_IN_GROUP(trigger_element, change->trigger_element)))
7368     {
7369       change->actual_trigger_element = trigger_element;
7370       change->actual_trigger_player = EL_PLAYER_1 + log_2(trigger_player);
7371
7372       if (change->can_change && !change_done)
7373       {
7374         ChangeDelay[x][y] = 1;
7375         ChangeEvent[x][y] = trigger_event;
7376         ChangeElement(x, y, p);
7377
7378         change_done = TRUE;
7379       }
7380 #if USE_NEW_DELAYED_ACTION
7381       else if (change->has_action)
7382       {
7383         ExecuteCustomElementAction(x, y, element, p);
7384         PlayLevelSoundElementAction(x, y, element, ACTION_PAGE_1 + p);
7385       }
7386 #else
7387       if (change->has_action)
7388       {
7389         ExecuteCustomElementAction(x, y, element, p);
7390         PlayLevelSoundElementAction(x, y, element, ACTION_PAGE_1 + p);
7391       }
7392 #endif
7393     }
7394   }
7395
7396   return change_done;
7397 }
7398
7399 static void PlayPlayerSound(struct PlayerInfo *player)
7400 {
7401   int jx = player->jx, jy = player->jy;
7402   int element = player->element_nr;
7403   int last_action = player->last_action_waiting;
7404   int action = player->action_waiting;
7405
7406   if (player->is_waiting)
7407   {
7408     if (action != last_action)
7409       PlayLevelSoundElementAction(jx, jy, element, action);
7410     else
7411       PlayLevelSoundElementActionIfLoop(jx, jy, element, action);
7412   }
7413   else
7414   {
7415     if (action != last_action)
7416       StopSound(element_info[element].sound[last_action]);
7417
7418     if (last_action == ACTION_SLEEPING)
7419       PlayLevelSoundElementAction(jx, jy, element, ACTION_AWAKENING);
7420   }
7421 }
7422
7423 static void PlayAllPlayersSound()
7424 {
7425   int i;
7426
7427   for (i = 0; i < MAX_PLAYERS; i++)
7428     if (stored_player[i].active)
7429       PlayPlayerSound(&stored_player[i]);
7430 }
7431
7432 static void SetPlayerWaiting(struct PlayerInfo *player, boolean is_waiting)
7433 {
7434   boolean last_waiting = player->is_waiting;
7435   int move_dir = player->MovDir;
7436
7437   player->last_action_waiting = player->action_waiting;
7438
7439   if (is_waiting)
7440   {
7441     if (!last_waiting)          /* not waiting -> waiting */
7442     {
7443       player->is_waiting = TRUE;
7444
7445       player->frame_counter_bored =
7446         FrameCounter +
7447         game.player_boring_delay_fixed +
7448         SimpleRND(game.player_boring_delay_random);
7449       player->frame_counter_sleeping =
7450         FrameCounter +
7451         game.player_sleeping_delay_fixed +
7452         SimpleRND(game.player_sleeping_delay_random);
7453
7454       InitPlayerGfxAnimation(player, ACTION_WAITING, player->MovDir);
7455     }
7456
7457     if (game.player_sleeping_delay_fixed +
7458         game.player_sleeping_delay_random > 0 &&
7459         player->anim_delay_counter == 0 &&
7460         player->post_delay_counter == 0 &&
7461         FrameCounter >= player->frame_counter_sleeping)
7462       player->is_sleeping = TRUE;
7463     else if (game.player_boring_delay_fixed +
7464              game.player_boring_delay_random > 0 &&
7465              FrameCounter >= player->frame_counter_bored)
7466       player->is_bored = TRUE;
7467
7468     player->action_waiting = (player->is_sleeping ? ACTION_SLEEPING :
7469                               player->is_bored ? ACTION_BORING :
7470                               ACTION_WAITING);
7471
7472     if (player->is_sleeping)
7473     {
7474       if (player->num_special_action_sleeping > 0)
7475       {
7476         if (player->anim_delay_counter == 0 && player->post_delay_counter == 0)
7477         {
7478           int last_special_action = player->special_action_sleeping;
7479           int num_special_action = player->num_special_action_sleeping;
7480           int special_action =
7481             (last_special_action == ACTION_DEFAULT ? ACTION_SLEEPING_1 :
7482              last_special_action == ACTION_SLEEPING ? ACTION_SLEEPING :
7483              last_special_action < ACTION_SLEEPING_1 + num_special_action - 1 ?
7484              last_special_action + 1 : ACTION_SLEEPING);
7485           int special_graphic =
7486             el_act_dir2img(player->element_nr, special_action, move_dir);
7487
7488           player->anim_delay_counter =
7489             graphic_info[special_graphic].anim_delay_fixed +
7490             SimpleRND(graphic_info[special_graphic].anim_delay_random);
7491           player->post_delay_counter =
7492             graphic_info[special_graphic].post_delay_fixed +
7493             SimpleRND(graphic_info[special_graphic].post_delay_random);
7494
7495           player->special_action_sleeping = special_action;
7496         }
7497
7498         if (player->anim_delay_counter > 0)
7499         {
7500           player->action_waiting = player->special_action_sleeping;
7501           player->anim_delay_counter--;
7502         }
7503         else if (player->post_delay_counter > 0)
7504         {
7505           player->post_delay_counter--;
7506         }
7507       }
7508     }
7509     else if (player->is_bored)
7510     {
7511       if (player->num_special_action_bored > 0)
7512       {
7513         if (player->anim_delay_counter == 0 && player->post_delay_counter == 0)
7514         {
7515           int special_action =
7516             ACTION_BORING_1 + SimpleRND(player->num_special_action_bored);
7517           int special_graphic =
7518             el_act_dir2img(player->element_nr, special_action, move_dir);
7519
7520           player->anim_delay_counter =
7521             graphic_info[special_graphic].anim_delay_fixed +
7522             SimpleRND(graphic_info[special_graphic].anim_delay_random);
7523           player->post_delay_counter =
7524             graphic_info[special_graphic].post_delay_fixed +
7525             SimpleRND(graphic_info[special_graphic].post_delay_random);
7526
7527           player->special_action_bored = special_action;
7528         }
7529
7530         if (player->anim_delay_counter > 0)
7531         {
7532           player->action_waiting = player->special_action_bored;
7533           player->anim_delay_counter--;
7534         }
7535         else if (player->post_delay_counter > 0)
7536         {
7537           player->post_delay_counter--;
7538         }
7539       }
7540     }
7541   }
7542   else if (last_waiting)        /* waiting -> not waiting */
7543   {
7544     player->is_waiting = FALSE;
7545     player->is_bored = FALSE;
7546     player->is_sleeping = FALSE;
7547
7548     player->frame_counter_bored = -1;
7549     player->frame_counter_sleeping = -1;
7550
7551     player->anim_delay_counter = 0;
7552     player->post_delay_counter = 0;
7553
7554     player->action_waiting = ACTION_DEFAULT;
7555
7556     player->special_action_bored = ACTION_DEFAULT;
7557     player->special_action_sleeping = ACTION_DEFAULT;
7558   }
7559 }
7560
7561 static byte PlayerActions(struct PlayerInfo *player, byte player_action)
7562 {
7563   boolean moved = FALSE, snapped = FALSE, dropped = FALSE;
7564   int left      = player_action & JOY_LEFT;
7565   int right     = player_action & JOY_RIGHT;
7566   int up        = player_action & JOY_UP;
7567   int down      = player_action & JOY_DOWN;
7568   int button1   = player_action & JOY_BUTTON_1;
7569   int button2   = player_action & JOY_BUTTON_2;
7570   int dx        = (left ? -1    : right ? 1     : 0);
7571   int dy        = (up   ? -1    : down  ? 1     : 0);
7572
7573   if (!player->active || tape.pausing)
7574     return 0;
7575
7576   if (player_action)
7577   {
7578     if (button1)
7579       snapped = SnapField(player, dx, dy);
7580     else
7581     {
7582       if (button2)
7583         dropped = DropElement(player);
7584
7585       moved = MovePlayer(player, dx, dy);
7586     }
7587
7588     if (tape.single_step && tape.recording && !tape.pausing)
7589     {
7590       if (button1 || (dropped && !moved))
7591       {
7592         TapeTogglePause(TAPE_TOGGLE_AUTOMATIC);
7593         SnapField(player, 0, 0);                /* stop snapping */
7594       }
7595     }
7596
7597     SetPlayerWaiting(player, FALSE);
7598
7599     return player_action;
7600   }
7601   else
7602   {
7603     /* no actions for this player (no input at player's configured device) */
7604
7605     DigField(player, 0, 0, 0, 0, 0, 0, DF_NO_PUSH);
7606     SnapField(player, 0, 0);
7607     CheckGravityMovementWhenNotMoving(player);
7608
7609     if (player->MovPos == 0)
7610       SetPlayerWaiting(player, TRUE);
7611
7612     if (player->MovPos == 0)    /* needed for tape.playing */
7613       player->is_moving = FALSE;
7614
7615     player->is_dropping = FALSE;
7616
7617     return 0;
7618   }
7619 }
7620
7621 void AdvanceFrameAndPlayerCounters(int player_nr)
7622 {
7623   int i;
7624
7625   /* advance frame counters (global frame counter and time frame counter) */
7626   FrameCounter++;
7627   TimeFrames++;
7628
7629   /* advance player counters (counters for move delay, move animation etc.) */
7630   for (i = 0; i < MAX_PLAYERS; i++)
7631   {
7632     boolean advance_player_counters = (player_nr == -1 || player_nr == i);
7633     int move_delay_value = stored_player[i].move_delay_value;
7634     int move_frames = MOVE_DELAY_NORMAL_SPEED / move_delay_value;
7635
7636     if (!advance_player_counters)       /* not all players may be affected */
7637       continue;
7638
7639 #if USE_NEW_PLAYER_ANIM
7640     if (move_frames == 0)       /* less than one move per game frame */
7641     {
7642       int stepsize = TILEX / move_delay_value;
7643       int delay = move_delay_value / MOVE_DELAY_NORMAL_SPEED;
7644       int count = (stored_player[i].is_moving ?
7645                    ABS(stored_player[i].MovPos) / stepsize : FrameCounter);
7646
7647       if (count % delay == 0)
7648         move_frames = 1;
7649     }
7650 #endif
7651
7652     stored_player[i].Frame += move_frames;
7653
7654     if (stored_player[i].MovPos != 0)
7655       stored_player[i].StepFrame += move_frames;
7656
7657     if (stored_player[i].move_delay > 0)
7658       stored_player[i].move_delay--;
7659
7660     /* due to bugs in previous versions, counter must count up, not down */
7661     if (stored_player[i].push_delay != -1)
7662       stored_player[i].push_delay++;
7663
7664     if (stored_player[i].drop_delay > 0)
7665       stored_player[i].drop_delay--;
7666   }
7667 }
7668
7669 void GameActions()
7670 {
7671   static unsigned long game_frame_delay = 0;
7672   unsigned long game_frame_delay_value;
7673   int magic_wall_x = 0, magic_wall_y = 0;
7674   int i, x, y, element, graphic;
7675   byte *recorded_player_action;
7676   byte summarized_player_action = 0;
7677   byte tape_action[MAX_PLAYERS];
7678
7679   if (game_status != GAME_MODE_PLAYING)
7680     return;
7681
7682   game_frame_delay_value =
7683     (tape.playing && tape.fast_forward ? FfwdFrameDelay : GameFrameDelay);
7684
7685   if (tape.playing && tape.warp_forward && !tape.pausing)
7686     game_frame_delay_value = 0;
7687
7688   /* ---------- main game synchronization point ---------- */
7689
7690   WaitUntilDelayReached(&game_frame_delay, game_frame_delay_value);
7691
7692   if (network_playing && !network_player_action_received)
7693   {
7694     /* try to get network player actions in time */
7695
7696 #if defined(NETWORK_AVALIABLE)
7697     /* last chance to get network player actions without main loop delay */
7698     HandleNetworking();
7699 #endif
7700
7701     /* game was quit by network peer */
7702     if (game_status != GAME_MODE_PLAYING)
7703       return;
7704
7705     if (!network_player_action_received)
7706       return;           /* failed to get network player actions in time */
7707   }
7708
7709   if (tape.pausing)
7710     return;
7711
7712   recorded_player_action = (tape.playing ? TapePlayAction() : NULL);
7713
7714 #if 1
7715   /* !!! CHECK THIS (tape.pausing is always FALSE here!) !!! */
7716   if (recorded_player_action == NULL && tape.pausing)
7717     return;
7718 #endif
7719
7720   for (i = 0; i < MAX_PLAYERS; i++)
7721   {
7722     summarized_player_action |= stored_player[i].action;
7723
7724     if (!network_playing)
7725       stored_player[i].effective_action = stored_player[i].action;
7726   }
7727
7728 #if defined(NETWORK_AVALIABLE)
7729   if (network_playing)
7730     SendToServer_MovePlayer(summarized_player_action);
7731 #endif
7732
7733   if (!options.network && !setup.team_mode)
7734     local_player->effective_action = summarized_player_action;
7735
7736   if (recorded_player_action != NULL)
7737     for (i = 0; i < MAX_PLAYERS; i++)
7738       stored_player[i].effective_action = recorded_player_action[i];
7739
7740   for (i = 0; i < MAX_PLAYERS; i++)
7741   {
7742     tape_action[i] = stored_player[i].effective_action;
7743
7744     if (tape.recording && tape_action[i] && !tape.player_participates[i])
7745       tape.player_participates[i] = TRUE;    /* player just appeared from CE */
7746   }
7747
7748   /* only save actions from input devices, but not programmed actions */
7749   if (tape.recording)
7750     TapeRecordAction(tape_action);
7751
7752   for (i = 0; i < MAX_PLAYERS; i++)
7753   {
7754     int actual_player_action = stored_player[i].effective_action;
7755
7756 #if 1
7757     /* !!! THIS BREAKS THE FOLLOWING TAPES: !!!
7758        - rnd_equinox_tetrachloride 048
7759        - rnd_equinox_tetrachloride_ii 096
7760        - rnd_emanuel_schmieg 002
7761        - doctor_sloan_ww 001, 020
7762     */
7763     if (stored_player[i].MovPos == 0)
7764       CheckGravityMovement(&stored_player[i]);
7765 #endif
7766
7767     /* overwrite programmed action with tape action */
7768     if (stored_player[i].programmed_action)
7769       actual_player_action = stored_player[i].programmed_action;
7770
7771 #if 1
7772     PlayerActions(&stored_player[i], actual_player_action);
7773 #else
7774     tape_action[i] = PlayerActions(&stored_player[i], actual_player_action);
7775
7776     if (tape.recording && tape_action[i] && !tape.player_participates[i])
7777       tape.player_participates[i] = TRUE;    /* player just appeared from CE */
7778 #endif
7779
7780     ScrollPlayer(&stored_player[i], SCROLL_GO_ON);
7781   }
7782
7783   network_player_action_received = FALSE;
7784
7785   ScrollScreen(NULL, SCROLL_GO_ON);
7786
7787   /* for backwards compatibility, the following code emulates a fixed bug that
7788      occured when pushing elements (causing elements that just made their last
7789      pushing step to already (if possible) make their first falling step in the
7790      same game frame, which is bad); this code is also needed to use the famous
7791      "spring push bug" which is used in older levels and might be wanted to be
7792      used also in newer levels, but in this case the buggy pushing code is only
7793      affecting the "spring" element and no other elements */
7794
7795   if (game.engine_version < VERSION_IDENT(2,2,0,7) || level.use_spring_bug)
7796   {
7797     for (i = 0; i < MAX_PLAYERS; i++)
7798     {
7799       struct PlayerInfo *player = &stored_player[i];
7800       int x = player->jx;
7801       int y = player->jy;
7802
7803       if (player->active && player->is_pushing && player->is_moving &&
7804           IS_MOVING(x, y) &&
7805           (game.engine_version < VERSION_IDENT(2,2,0,7) ||
7806            Feld[x][y] == EL_SPRING))
7807       {
7808         ContinueMoving(x, y);
7809
7810         /* continue moving after pushing (this is actually a bug) */
7811         if (!IS_MOVING(x, y))
7812         {
7813           Stop[x][y] = FALSE;
7814         }
7815       }
7816     }
7817   }
7818
7819   for (y = 0; y < lev_fieldy; y++) for (x = 0; x < lev_fieldx; x++)
7820   {
7821     Changed[x][y] = FALSE;
7822     ChangeEvent[x][y] = -1;
7823
7824     /* this must be handled before main playfield loop */
7825     if (Feld[x][y] == EL_PLAYER_IS_LEAVING)
7826     {
7827       MovDelay[x][y]--;
7828       if (MovDelay[x][y] <= 0)
7829         RemoveField(x, y);
7830     }
7831
7832 #if DEBUG
7833     if (ChangePage[x][y] != -1 && ChangeDelay[x][y] != 1)
7834     {
7835       printf("GameActions(): x = %d, y = %d: ChangePage != -1\n", x, y);
7836       printf("GameActions(): This should never happen!\n");
7837
7838       ChangePage[x][y] = -1;
7839     }
7840 #endif
7841
7842     Stop[x][y] = FALSE;
7843     if (WasJustMoving[x][y] > 0)
7844       WasJustMoving[x][y]--;
7845     if (WasJustFalling[x][y] > 0)
7846       WasJustFalling[x][y]--;
7847     if (CheckCollision[x][y] > 0)
7848       CheckCollision[x][y]--;
7849
7850     GfxFrame[x][y]++;
7851
7852     /* reset finished pushing action (not done in ContinueMoving() to allow
7853        continous pushing animation for elements with zero push delay) */
7854     if (GfxAction[x][y] == ACTION_PUSHING && !IS_MOVING(x, y))
7855     {
7856       ResetGfxAnimation(x, y);
7857       DrawLevelField(x, y);
7858     }
7859
7860 #if DEBUG
7861     if (IS_BLOCKED(x, y))
7862     {
7863       int oldx, oldy;
7864
7865       Blocked2Moving(x, y, &oldx, &oldy);
7866       if (!IS_MOVING(oldx, oldy))
7867       {
7868         printf("GameActions(): (BLOCKED => MOVING) context corrupted!\n");
7869         printf("GameActions(): BLOCKED: x = %d, y = %d\n", x, y);
7870         printf("GameActions(): !MOVING: oldx = %d, oldy = %d\n", oldx, oldy);
7871         printf("GameActions(): This should never happen!\n");
7872       }
7873     }
7874 #endif
7875   }
7876
7877   for (y = 0; y < lev_fieldy; y++) for (x = 0; x < lev_fieldx; x++)
7878   {
7879     element = Feld[x][y];
7880     graphic = el_act_dir2img(element, GfxAction[x][y], GfxDir[x][y]);
7881
7882     if (graphic_info[graphic].anim_global_sync)
7883       GfxFrame[x][y] = FrameCounter;
7884
7885     if (ANIM_MODE(graphic) == ANIM_RANDOM &&
7886         IS_NEXT_FRAME(GfxFrame[x][y], graphic))
7887       ResetRandomAnimationValue(x, y);
7888
7889     SetRandomAnimationValue(x, y);
7890
7891     PlayLevelSoundActionIfLoop(x, y, GfxAction[x][y]);
7892
7893     if (IS_INACTIVE(element))
7894     {
7895       if (IS_ANIMATED(graphic))
7896         DrawLevelGraphicAnimationIfNeeded(x, y, graphic);
7897
7898       continue;
7899     }
7900
7901     /* this may take place after moving, so 'element' may have changed */
7902     if (IS_CHANGING(x, y) &&
7903         (game.engine_version < VERSION_IDENT(3,0,7,1) || !Stop[x][y]))
7904     {
7905       int page = element_info[element].event_page_nr[CE_DELAY];
7906 #if 0
7907       ChangeElement(x, y, ChangePage[x][y] != -1 ? ChangePage[x][y] : page);
7908 #else
7909
7910 #if 0
7911       printf("::: ChangeDelay == %d\n", ChangeDelay[x][y]);
7912 #endif
7913
7914 #if 1
7915       ChangeElement(x, y, page);
7916 #else
7917       if (CAN_CHANGE(element))
7918         ChangeElement(x, y, page);
7919
7920       if (HAS_ACTION(element))
7921         ExecuteCustomElementAction(x, y, element, page);
7922 #endif
7923
7924 #endif
7925
7926       element = Feld[x][y];
7927       graphic = el_act_dir2img(element, GfxAction[x][y], GfxDir[x][y]);
7928     }
7929
7930     if (!IS_MOVING(x, y) && (CAN_FALL(element) || CAN_MOVE(element)))
7931     {
7932       StartMoving(x, y);
7933
7934       element = Feld[x][y];
7935       graphic = el_act_dir2img(element, GfxAction[x][y], GfxDir[x][y]);
7936
7937       if (IS_ANIMATED(graphic) &&
7938           !IS_MOVING(x, y) &&
7939           !Stop[x][y])
7940         DrawLevelGraphicAnimationIfNeeded(x, y, graphic);
7941
7942       if (IS_GEM(element) || element == EL_SP_INFOTRON)
7943         EdelsteinFunkeln(x, y);
7944     }
7945     else if ((element == EL_ACID ||
7946               element == EL_EXIT_OPEN ||
7947               element == EL_SP_EXIT_OPEN ||
7948               element == EL_SP_TERMINAL ||
7949               element == EL_SP_TERMINAL_ACTIVE ||
7950               element == EL_EXTRA_TIME ||
7951               element == EL_SHIELD_NORMAL ||
7952               element == EL_SHIELD_DEADLY) &&
7953              IS_ANIMATED(graphic))
7954       DrawLevelGraphicAnimationIfNeeded(x, y, graphic);
7955     else if (IS_MOVING(x, y))
7956       ContinueMoving(x, y);
7957     else if (IS_ACTIVE_BOMB(element))
7958       CheckDynamite(x, y);
7959     else if (element == EL_AMOEBA_GROWING)
7960       AmoebeWaechst(x, y);
7961     else if (element == EL_AMOEBA_SHRINKING)
7962       AmoebaDisappearing(x, y);
7963
7964 #if !USE_NEW_AMOEBA_CODE
7965     else if (IS_AMOEBALIVE(element))
7966       AmoebeAbleger(x, y);
7967 #endif
7968
7969     else if (element == EL_GAME_OF_LIFE || element == EL_BIOMAZE)
7970       Life(x, y);
7971     else if (element == EL_EXIT_CLOSED)
7972       CheckExit(x, y);
7973     else if (element == EL_SP_EXIT_CLOSED)
7974       CheckExitSP(x, y);
7975     else if (element == EL_EXPANDABLE_WALL_GROWING)
7976       MauerWaechst(x, y);
7977     else if (element == EL_EXPANDABLE_WALL ||
7978              element == EL_EXPANDABLE_WALL_HORIZONTAL ||
7979              element == EL_EXPANDABLE_WALL_VERTICAL ||
7980              element == EL_EXPANDABLE_WALL_ANY)
7981       MauerAbleger(x, y);
7982     else if (element == EL_FLAMES)
7983       CheckForDragon(x, y);
7984     else if (element == EL_EXPLOSION)
7985       ; /* drawing of correct explosion animation is handled separately */
7986     else if (IS_ANIMATED(graphic) && !IS_CHANGING(x, y))
7987       DrawLevelGraphicAnimationIfNeeded(x, y, graphic);
7988
7989     if (IS_BELT_ACTIVE(element))
7990       PlayLevelSoundAction(x, y, ACTION_ACTIVE);
7991
7992     if (game.magic_wall_active)
7993     {
7994       int jx = local_player->jx, jy = local_player->jy;
7995
7996       /* play the element sound at the position nearest to the player */
7997       if ((element == EL_MAGIC_WALL_FULL ||
7998            element == EL_MAGIC_WALL_ACTIVE ||
7999            element == EL_MAGIC_WALL_EMPTYING ||
8000            element == EL_BD_MAGIC_WALL_FULL ||
8001            element == EL_BD_MAGIC_WALL_ACTIVE ||
8002            element == EL_BD_MAGIC_WALL_EMPTYING) &&
8003           ABS(x-jx) + ABS(y-jy) < ABS(magic_wall_x-jx) + ABS(magic_wall_y-jy))
8004       {
8005         magic_wall_x = x;
8006         magic_wall_y = y;
8007       }
8008     }
8009   }
8010
8011 #if USE_NEW_AMOEBA_CODE
8012   /* new experimental amoeba growth stuff */
8013   if (!(FrameCounter % 8))
8014   {
8015     static unsigned long random = 1684108901;
8016
8017     for (i = 0; i < level.amoeba_speed * 28 / 8; i++)
8018     {
8019       x = RND(lev_fieldx);
8020       y = RND(lev_fieldy);
8021       element = Feld[x][y];
8022
8023       if (!IS_PLAYER(x,y) &&
8024           (element == EL_EMPTY ||
8025            CAN_GROW_INTO(element) ||
8026            element == EL_QUICKSAND_EMPTY ||
8027            element == EL_ACID_SPLASH_LEFT ||
8028            element == EL_ACID_SPLASH_RIGHT))
8029       {
8030         if ((IN_LEV_FIELD(x, y-1) && Feld[x][y-1] == EL_AMOEBA_WET) ||
8031             (IN_LEV_FIELD(x-1, y) && Feld[x-1][y] == EL_AMOEBA_WET) ||
8032             (IN_LEV_FIELD(x+1, y) && Feld[x+1][y] == EL_AMOEBA_WET) ||
8033             (IN_LEV_FIELD(x, y+1) && Feld[x][y+1] == EL_AMOEBA_WET))
8034           Feld[x][y] = EL_AMOEBA_DROP;
8035       }
8036
8037       random = random * 129 + 1;
8038     }
8039   }
8040 #endif
8041
8042 #if 0
8043   if (game.explosions_delayed)
8044 #endif
8045   {
8046     game.explosions_delayed = FALSE;
8047
8048     for (y = 0; y < lev_fieldy; y++) for (x = 0; x < lev_fieldx; x++)
8049     {
8050       element = Feld[x][y];
8051
8052       if (ExplodeField[x][y])
8053         Explode(x, y, EX_PHASE_START, ExplodeField[x][y]);
8054       else if (element == EL_EXPLOSION)
8055         Explode(x, y, ExplodePhase[x][y], EX_TYPE_NORMAL);
8056
8057       ExplodeField[x][y] = EX_TYPE_NONE;
8058     }
8059
8060     game.explosions_delayed = TRUE;
8061   }
8062
8063   if (game.magic_wall_active)
8064   {
8065     if (!(game.magic_wall_time_left % 4))
8066     {
8067       int element = Feld[magic_wall_x][magic_wall_y];
8068
8069       if (element == EL_BD_MAGIC_WALL_FULL ||
8070           element == EL_BD_MAGIC_WALL_ACTIVE ||
8071           element == EL_BD_MAGIC_WALL_EMPTYING)
8072         PlayLevelSound(magic_wall_x, magic_wall_y, SND_BD_MAGIC_WALL_ACTIVE);
8073       else
8074         PlayLevelSound(magic_wall_x, magic_wall_y, SND_MAGIC_WALL_ACTIVE);
8075     }
8076
8077     if (game.magic_wall_time_left > 0)
8078     {
8079       game.magic_wall_time_left--;
8080       if (!game.magic_wall_time_left)
8081       {
8082         for (y = 0; y < lev_fieldy; y++) for (x = 0; x < lev_fieldx; x++)
8083         {
8084           element = Feld[x][y];
8085
8086           if (element == EL_MAGIC_WALL_ACTIVE ||
8087               element == EL_MAGIC_WALL_FULL)
8088           {
8089             Feld[x][y] = EL_MAGIC_WALL_DEAD;
8090             DrawLevelField(x, y);
8091           }
8092           else if (element == EL_BD_MAGIC_WALL_ACTIVE ||
8093                    element == EL_BD_MAGIC_WALL_FULL)
8094           {
8095             Feld[x][y] = EL_BD_MAGIC_WALL_DEAD;
8096             DrawLevelField(x, y);
8097           }
8098         }
8099
8100         game.magic_wall_active = FALSE;
8101       }
8102     }
8103   }
8104
8105   if (game.light_time_left > 0)
8106   {
8107     game.light_time_left--;
8108
8109     if (game.light_time_left == 0)
8110       RedrawAllLightSwitchesAndInvisibleElements();
8111   }
8112
8113   if (game.timegate_time_left > 0)
8114   {
8115     game.timegate_time_left--;
8116
8117     if (game.timegate_time_left == 0)
8118       CloseAllOpenTimegates();
8119   }
8120
8121   for (i = 0; i < MAX_PLAYERS; i++)
8122   {
8123     struct PlayerInfo *player = &stored_player[i];
8124
8125     if (SHIELD_ON(player))
8126     {
8127       if (player->shield_deadly_time_left)
8128         PlayLevelSound(player->jx, player->jy, SND_SHIELD_DEADLY_ACTIVE);
8129       else if (player->shield_normal_time_left)
8130         PlayLevelSound(player->jx, player->jy, SND_SHIELD_NORMAL_ACTIVE);
8131     }
8132   }
8133
8134   if (TimeFrames >= FRAMES_PER_SECOND)
8135   {
8136     TimeFrames = 0;
8137     TapeTime++;
8138
8139     for (i = 0; i < MAX_PLAYERS; i++)
8140     {
8141       struct PlayerInfo *player = &stored_player[i];
8142
8143       if (SHIELD_ON(player))
8144       {
8145         player->shield_normal_time_left--;
8146
8147         if (player->shield_deadly_time_left > 0)
8148           player->shield_deadly_time_left--;
8149       }
8150     }
8151
8152     if (!level.use_step_counter)
8153     {
8154       TimePlayed++;
8155
8156       if (TimeLeft > 0)
8157       {
8158         TimeLeft--;
8159
8160         if (TimeLeft <= 10 && setup.time_limit)
8161           PlaySoundStereo(SND_GAME_RUNNING_OUT_OF_TIME, SOUND_MIDDLE);
8162
8163         DrawGameValue_Time(TimeLeft);
8164
8165         if (!TimeLeft && setup.time_limit)
8166           for (i = 0; i < MAX_PLAYERS; i++)
8167             KillPlayer(&stored_player[i]);
8168       }
8169       else if (level.time == 0 && !AllPlayersGone) /* level w/o time limit */
8170         DrawGameValue_Time(TimePlayed);
8171     }
8172
8173     if (tape.recording || tape.playing)
8174       DrawVideoDisplay(VIDEO_STATE_TIME_ON, TapeTime);
8175   }
8176
8177   DrawAllPlayers();
8178   PlayAllPlayersSound();
8179
8180   if (options.debug)                    /* calculate frames per second */
8181   {
8182     static unsigned long fps_counter = 0;
8183     static int fps_frames = 0;
8184     unsigned long fps_delay_ms = Counter() - fps_counter;
8185
8186     fps_frames++;
8187
8188     if (fps_delay_ms >= 500)    /* calculate fps every 0.5 seconds */
8189     {
8190       global.frames_per_second = 1000 * (float)fps_frames / fps_delay_ms;
8191
8192       fps_frames = 0;
8193       fps_counter = Counter();
8194     }
8195
8196     redraw_mask |= REDRAW_FPS;
8197   }
8198
8199   AdvanceFrameAndPlayerCounters(-1);    /* advance counters for all players */
8200
8201   if (local_player->show_envelope != 0 && local_player->MovPos == 0)
8202   {
8203     ShowEnvelope(local_player->show_envelope - EL_ENVELOPE_1);
8204
8205     local_player->show_envelope = 0;
8206   }
8207
8208   /* use random number generator in every frame to make it less predictable */
8209   if (game.engine_version >= VERSION_IDENT(3,1,1,0))
8210     RND(1);
8211 }
8212
8213 static boolean AllPlayersInSight(struct PlayerInfo *player, int x, int y)
8214 {
8215   int min_x = x, min_y = y, max_x = x, max_y = y;
8216   int i;
8217
8218   for (i = 0; i < MAX_PLAYERS; i++)
8219   {
8220     int jx = stored_player[i].jx, jy = stored_player[i].jy;
8221
8222     if (!stored_player[i].active || &stored_player[i] == player)
8223       continue;
8224
8225     min_x = MIN(min_x, jx);
8226     min_y = MIN(min_y, jy);
8227     max_x = MAX(max_x, jx);
8228     max_y = MAX(max_y, jy);
8229   }
8230
8231   return (max_x - min_x < SCR_FIELDX && max_y - min_y < SCR_FIELDY);
8232 }
8233
8234 static boolean AllPlayersInVisibleScreen()
8235 {
8236   int i;
8237
8238   for (i = 0; i < MAX_PLAYERS; i++)
8239   {
8240     int jx = stored_player[i].jx, jy = stored_player[i].jy;
8241
8242     if (!stored_player[i].active)
8243       continue;
8244
8245     if (!IN_VIS_FIELD(SCREENX(jx), SCREENY(jy)))
8246       return FALSE;
8247   }
8248
8249   return TRUE;
8250 }
8251
8252 void ScrollLevel(int dx, int dy)
8253 {
8254   int softscroll_offset = (setup.soft_scrolling ? TILEX : 0);
8255   int x, y;
8256
8257   BlitBitmap(drawto_field, drawto_field,
8258              FX + TILEX * (dx == -1) - softscroll_offset,
8259              FY + TILEY * (dy == -1) - softscroll_offset,
8260              SXSIZE - TILEX * (dx!=0) + 2 * softscroll_offset,
8261              SYSIZE - TILEY * (dy!=0) + 2 * softscroll_offset,
8262              FX + TILEX * (dx == 1) - softscroll_offset,
8263              FY + TILEY * (dy == 1) - softscroll_offset);
8264
8265   if (dx)
8266   {
8267     x = (dx == 1 ? BX1 : BX2);
8268     for (y = BY1; y <= BY2; y++)
8269       DrawScreenField(x, y);
8270   }
8271
8272   if (dy)
8273   {
8274     y = (dy == 1 ? BY1 : BY2);
8275     for (x = BX1; x <= BX2; x++)
8276       DrawScreenField(x, y);
8277   }
8278
8279   redraw_mask |= REDRAW_FIELD;
8280 }
8281
8282 static boolean canFallDown(struct PlayerInfo *player)
8283 {
8284   int jx = player->jx, jy = player->jy;
8285
8286   return (IN_LEV_FIELD(jx, jy + 1) &&
8287           (IS_FREE(jx, jy + 1) ||
8288            (Feld[jx][jy + 1] == EL_ACID && player->can_fall_into_acid)) &&
8289           IS_WALKABLE_FROM(Feld[jx][jy], MV_DOWN) &&
8290           !IS_WALKABLE_INSIDE(Feld[jx][jy]));
8291 }
8292
8293 static boolean canPassField(int x, int y, int move_dir)
8294 {
8295   int opposite_dir = MV_DIR_OPPOSITE(move_dir);
8296   int dx = (move_dir & MV_LEFT ? -1 : move_dir & MV_RIGHT ? +1 : 0);
8297   int dy = (move_dir & MV_UP   ? -1 : move_dir & MV_DOWN  ? +1 : 0);
8298   int nextx = x + dx;
8299   int nexty = y + dy;
8300   int element = Feld[x][y];
8301
8302   return (IS_PASSABLE_FROM(element, opposite_dir) &&
8303           !CAN_MOVE(element) &&
8304           IN_LEV_FIELD(nextx, nexty) && !IS_PLAYER(nextx, nexty) &&
8305           IS_WALKABLE_FROM(Feld[nextx][nexty], move_dir) &&
8306           (level.can_pass_to_walkable || IS_FREE(nextx, nexty)));
8307 }
8308
8309 static boolean canMoveToValidFieldWithGravity(int x, int y, int move_dir)
8310 {
8311   int opposite_dir = MV_DIR_OPPOSITE(move_dir);
8312   int dx = (move_dir & MV_LEFT ? -1 : move_dir & MV_RIGHT ? +1 : 0);
8313   int dy = (move_dir & MV_UP   ? -1 : move_dir & MV_DOWN  ? +1 : 0);
8314   int newx = x + dx;
8315   int newy = y + dy;
8316
8317   return (IN_LEV_FIELD(newx, newy) && !IS_FREE_OR_PLAYER(newx, newy) &&
8318           IS_GRAVITY_REACHABLE(Feld[newx][newy]) &&
8319           (IS_DIGGABLE(Feld[newx][newy]) ||
8320            IS_WALKABLE_FROM(Feld[newx][newy], opposite_dir) ||
8321            canPassField(newx, newy, move_dir)));
8322 }
8323
8324 static void CheckGravityMovement(struct PlayerInfo *player)
8325 {
8326   if (game.gravity && !player->programmed_action)
8327   {
8328     int move_dir_horizontal = player->effective_action & MV_HORIZONTAL;
8329     int move_dir_vertical   = player->effective_action & MV_VERTICAL;
8330     boolean player_is_snapping = player->effective_action & JOY_BUTTON_1;
8331     int jx = player->jx, jy = player->jy;
8332     boolean player_is_moving_to_valid_field =
8333       (!player_is_snapping &&
8334        (canMoveToValidFieldWithGravity(jx, jy, move_dir_horizontal) ||
8335         canMoveToValidFieldWithGravity(jx, jy, move_dir_vertical)));
8336     boolean player_can_fall_down = canFallDown(player);
8337
8338     if (player_can_fall_down &&
8339         !player_is_moving_to_valid_field)
8340       player->programmed_action = MV_DOWN;
8341   }
8342 }
8343
8344 static void CheckGravityMovementWhenNotMoving(struct PlayerInfo *player)
8345 {
8346   return CheckGravityMovement(player);
8347
8348   if (game.gravity && !player->programmed_action)
8349   {
8350     int jx = player->jx, jy = player->jy;
8351     boolean field_under_player_is_free =
8352       (IN_LEV_FIELD(jx, jy + 1) && IS_FREE(jx, jy + 1));
8353     boolean player_is_standing_on_valid_field =
8354       (IS_WALKABLE_INSIDE(Feld[jx][jy]) ||
8355        (IS_WALKABLE(Feld[jx][jy]) &&
8356         !(element_info[Feld[jx][jy]].access_direction & MV_DOWN)));
8357
8358     if (field_under_player_is_free && !player_is_standing_on_valid_field)
8359       player->programmed_action = MV_DOWN;
8360   }
8361 }
8362
8363 /*
8364   MovePlayerOneStep()
8365   -----------------------------------------------------------------------------
8366   dx, dy:               direction (non-diagonal) to try to move the player to
8367   real_dx, real_dy:     direction as read from input device (can be diagonal)
8368 */
8369
8370 boolean MovePlayerOneStep(struct PlayerInfo *player,
8371                           int dx, int dy, int real_dx, int real_dy)
8372 {
8373   int jx = player->jx, jy = player->jy;
8374   int new_jx = jx + dx, new_jy = jy + dy;
8375   int element;
8376   int can_move;
8377
8378   if (!player->active || (!dx && !dy))
8379     return MF_NO_ACTION;
8380
8381   player->MovDir = (dx < 0 ? MV_LEFT :
8382                     dx > 0 ? MV_RIGHT :
8383                     dy < 0 ? MV_UP :
8384                     dy > 0 ? MV_DOWN :  MV_NO_MOVING);
8385
8386   if (!IN_LEV_FIELD(new_jx, new_jy))
8387     return MF_NO_ACTION;
8388
8389   if (!options.network && !AllPlayersInSight(player, new_jx, new_jy))
8390     return MF_NO_ACTION;
8391
8392   element = MovingOrBlocked2ElementIfNotLeaving(new_jx, new_jy);
8393
8394   if (DONT_RUN_INTO(element))
8395   {
8396     if (element == EL_ACID && dx == 0 && dy == 1)
8397     {
8398       SplashAcid(new_jx, new_jy);
8399       Feld[jx][jy] = EL_PLAYER_1;
8400       InitMovingField(jx, jy, MV_DOWN);
8401       Store[jx][jy] = EL_ACID;
8402       ContinueMoving(jx, jy);
8403       BuryPlayer(player);
8404     }
8405     else
8406       TestIfPlayerRunsIntoBadThing(jx, jy, player->MovDir);
8407
8408     return MF_MOVING;
8409   }
8410
8411   can_move = DigField(player, jx, jy, new_jx, new_jy, real_dx,real_dy, DF_DIG);
8412   if (can_move != MF_MOVING)
8413     return can_move;
8414
8415   /* check if DigField() has caused relocation of the player */
8416   if (player->jx != jx || player->jy != jy)
8417     return MF_NO_ACTION;        /* <-- !!! CHECK THIS [-> MF_ACTION ?] !!! */
8418
8419   StorePlayer[jx][jy] = 0;
8420   player->last_jx = jx;
8421   player->last_jy = jy;
8422   player->jx = new_jx;
8423   player->jy = new_jy;
8424   StorePlayer[new_jx][new_jy] = player->element_nr;
8425
8426   if (player->move_delay_value_next != -1)
8427   {
8428     player->move_delay_value = player->move_delay_value_next;
8429     player->move_delay_value_next = -1;
8430   }
8431
8432   player->MovPos =
8433     (dx > 0 || dy > 0 ? -1 : 1) * (TILEX - TILEX / player->move_delay_value);
8434
8435   player->step_counter++;
8436
8437   PlayerVisit[jx][jy] = FrameCounter;
8438
8439   ScrollPlayer(player, SCROLL_INIT);
8440
8441   return MF_MOVING;
8442 }
8443
8444 boolean MovePlayer(struct PlayerInfo *player, int dx, int dy)
8445 {
8446   int jx = player->jx, jy = player->jy;
8447   int old_jx = jx, old_jy = jy;
8448   int moved = MF_NO_ACTION;
8449
8450   if (!player->active)
8451     return FALSE;
8452
8453   if (!dx && !dy)
8454   {
8455     if (player->MovPos == 0)
8456     {
8457       player->is_moving = FALSE;
8458       player->is_digging = FALSE;
8459       player->is_collecting = FALSE;
8460       player->is_snapping = FALSE;
8461       player->is_pushing = FALSE;
8462     }
8463
8464     return FALSE;
8465   }
8466
8467   if (player->move_delay > 0)
8468     return FALSE;
8469
8470   player->move_delay = -1;              /* set to "uninitialized" value */
8471
8472   /* store if player is automatically moved to next field */
8473   player->is_auto_moving = (player->programmed_action != MV_NO_MOVING);
8474
8475   /* remove the last programmed player action */
8476   player->programmed_action = 0;
8477
8478   if (player->MovPos)
8479   {
8480     /* should only happen if pre-1.2 tape recordings are played */
8481     /* this is only for backward compatibility */
8482
8483     int original_move_delay_value = player->move_delay_value;
8484
8485 #if DEBUG
8486     printf("THIS SHOULD ONLY HAPPEN WITH PRE-1.2 LEVEL TAPES. [%ld]\n",
8487            tape.counter);
8488 #endif
8489
8490     /* scroll remaining steps with finest movement resolution */
8491     player->move_delay_value = MOVE_DELAY_NORMAL_SPEED;
8492
8493     while (player->MovPos)
8494     {
8495       ScrollPlayer(player, SCROLL_GO_ON);
8496       ScrollScreen(NULL, SCROLL_GO_ON);
8497
8498       AdvanceFrameAndPlayerCounters(player->index_nr);
8499
8500       DrawAllPlayers();
8501       BackToFront();
8502     }
8503
8504     player->move_delay_value = original_move_delay_value;
8505   }
8506
8507   if (player->last_move_dir & MV_HORIZONTAL)
8508   {
8509     if (!(moved |= MovePlayerOneStep(player, 0, dy, dx, dy)))
8510       moved |= MovePlayerOneStep(player, dx, 0, dx, dy);
8511   }
8512   else
8513   {
8514     if (!(moved |= MovePlayerOneStep(player, dx, 0, dx, dy)))
8515       moved |= MovePlayerOneStep(player, 0, dy, dx, dy);
8516   }
8517
8518   jx = player->jx;
8519   jy = player->jy;
8520
8521   if (moved & MF_MOVING && !ScreenMovPos &&
8522       (player == local_player || !options.network))
8523   {
8524     int old_scroll_x = scroll_x, old_scroll_y = scroll_y;
8525     int offset = (setup.scroll_delay ? 3 : 0);
8526
8527     if (!IN_VIS_FIELD(SCREENX(jx), SCREENY(jy)))
8528     {
8529       /* actual player has left the screen -- scroll in that direction */
8530       if (jx != old_jx)         /* player has moved horizontally */
8531         scroll_x += (jx - old_jx);
8532       else                      /* player has moved vertically */
8533         scroll_y += (jy - old_jy);
8534     }
8535     else
8536     {
8537       if (jx != old_jx)         /* player has moved horizontally */
8538       {
8539         if ((player->MovDir == MV_LEFT  && scroll_x > jx - MIDPOSX + offset) ||
8540             (player->MovDir == MV_RIGHT && scroll_x < jx - MIDPOSX - offset))
8541           scroll_x = jx-MIDPOSX + (scroll_x < jx-MIDPOSX ? -offset : +offset);
8542
8543         /* don't scroll over playfield boundaries */
8544         if (scroll_x < SBX_Left || scroll_x > SBX_Right)
8545           scroll_x = (scroll_x < SBX_Left ? SBX_Left : SBX_Right);
8546
8547         /* don't scroll more than one field at a time */
8548         scroll_x = old_scroll_x + SIGN(scroll_x - old_scroll_x);
8549
8550         /* don't scroll against the player's moving direction */
8551         if ((player->MovDir == MV_LEFT  && scroll_x > old_scroll_x) ||
8552             (player->MovDir == MV_RIGHT && scroll_x < old_scroll_x))
8553           scroll_x = old_scroll_x;
8554       }
8555       else                      /* player has moved vertically */
8556       {
8557         if ((player->MovDir == MV_UP   && scroll_y > jy - MIDPOSY + offset) ||
8558             (player->MovDir == MV_DOWN && scroll_y < jy - MIDPOSY - offset))
8559           scroll_y = jy-MIDPOSY + (scroll_y < jy-MIDPOSY ? -offset : +offset);
8560
8561         /* don't scroll over playfield boundaries */
8562         if (scroll_y < SBY_Upper || scroll_y > SBY_Lower)
8563           scroll_y = (scroll_y < SBY_Upper ? SBY_Upper : SBY_Lower);
8564
8565         /* don't scroll more than one field at a time */
8566         scroll_y = old_scroll_y + SIGN(scroll_y - old_scroll_y);
8567
8568         /* don't scroll against the player's moving direction */
8569         if ((player->MovDir == MV_UP   && scroll_y > old_scroll_y) ||
8570             (player->MovDir == MV_DOWN && scroll_y < old_scroll_y))
8571           scroll_y = old_scroll_y;
8572       }
8573     }
8574
8575     if (scroll_x != old_scroll_x || scroll_y != old_scroll_y)
8576     {
8577       if (!options.network && !AllPlayersInVisibleScreen())
8578       {
8579         scroll_x = old_scroll_x;
8580         scroll_y = old_scroll_y;
8581       }
8582       else
8583       {
8584         ScrollScreen(player, SCROLL_INIT);
8585         ScrollLevel(old_scroll_x - scroll_x, old_scroll_y - scroll_y);
8586       }
8587     }
8588   }
8589
8590   player->StepFrame = 0;
8591
8592   if (moved & MF_MOVING)
8593   {
8594     if (old_jx != jx && old_jy == jy)
8595       player->MovDir = (old_jx < jx ? MV_RIGHT : MV_LEFT);
8596     else if (old_jx == jx && old_jy != jy)
8597       player->MovDir = (old_jy < jy ? MV_DOWN : MV_UP);
8598
8599     DrawLevelField(jx, jy);     /* for "crumbled sand" */
8600
8601     player->last_move_dir = player->MovDir;
8602     player->is_moving = TRUE;
8603     player->is_snapping = FALSE;
8604     player->is_switching = FALSE;
8605     player->is_dropping = FALSE;
8606   }
8607   else
8608   {
8609     CheckGravityMovementWhenNotMoving(player);
8610
8611     player->is_moving = FALSE;
8612
8613     /* at this point, the player is allowed to move, but cannot move right now
8614        (e.g. because of something blocking the way) -- ensure that the player
8615        is also allowed to move in the next frame (in old versions before 3.1.1,
8616        the player was forced to wait again for eight frames before next try) */
8617
8618     if (game.engine_version >= VERSION_IDENT(3,1,1,0))
8619       player->move_delay = 0;   /* allow direct movement in the next frame */
8620   }
8621
8622   if (player->move_delay == -1)         /* not yet initialized by DigField() */
8623     player->move_delay = player->move_delay_value;
8624
8625   if (game.engine_version < VERSION_IDENT(3,0,7,0))
8626   {
8627     TestIfPlayerTouchesBadThing(jx, jy);
8628     TestIfPlayerTouchesCustomElement(jx, jy);
8629   }
8630
8631   if (!player->active)
8632     RemovePlayer(player);
8633
8634   return moved;
8635 }
8636
8637 void ScrollPlayer(struct PlayerInfo *player, int mode)
8638 {
8639   int jx = player->jx, jy = player->jy;
8640   int last_jx = player->last_jx, last_jy = player->last_jy;
8641   int move_stepsize = TILEX / player->move_delay_value;
8642
8643 #if USE_NEW_PLAYER_SPEED
8644   if (!player->active)
8645     return;
8646
8647   if (player->MovPos == 0 && mode == SCROLL_GO_ON)      /* player not moving */
8648     return;
8649 #else
8650   if (!player->active || player->MovPos == 0)
8651     return;
8652 #endif
8653
8654   if (mode == SCROLL_INIT)
8655   {
8656     player->actual_frame_counter = FrameCounter;
8657     player->GfxPos = move_stepsize * (player->MovPos / move_stepsize);
8658
8659     if ((player->block_last_field || player->block_delay_adjustment > 0) &&
8660         Feld[last_jx][last_jy] == EL_EMPTY)
8661     {
8662       int last_field_block_delay = 0;   /* start with no blocking at all */
8663       int block_delay_adjustment = player->block_delay_adjustment;
8664
8665       /* if player blocks last field, add delay for exactly one move */
8666       if (player->block_last_field)
8667       {
8668         last_field_block_delay += player->move_delay_value;
8669
8670         /* when blocking enabled, prevent moving up despite gravity */
8671         if (game.gravity && player->MovDir == MV_UP)
8672           block_delay_adjustment = -1;
8673       }
8674
8675       /* add block delay adjustment (also possible when not blocking) */
8676       last_field_block_delay += block_delay_adjustment;
8677
8678       Feld[last_jx][last_jy] = EL_PLAYER_IS_LEAVING;
8679       MovDelay[last_jx][last_jy] = last_field_block_delay + 1;
8680     }
8681
8682 #if USE_NEW_PLAYER_SPEED
8683     if (player->MovPos != 0)    /* player has not yet reached destination */
8684       return;
8685 #else
8686     return;
8687 #endif
8688   }
8689   else if (!FrameReached(&player->actual_frame_counter, 1))
8690     return;
8691
8692 #if 0
8693   printf("::: player->MovPos: %d -> %d\n",
8694          player->MovPos,
8695          player->MovPos + (player->MovPos > 0 ? -1 : 1) * move_stepsize);
8696 #endif
8697
8698 #if USE_NEW_PLAYER_SPEED
8699   if (player->MovPos != 0)
8700   {
8701     player->MovPos += (player->MovPos > 0 ? -1 : 1) * move_stepsize;
8702     player->GfxPos = move_stepsize * (player->MovPos / move_stepsize);
8703
8704     /* before DrawPlayer() to draw correct player graphic for this case */
8705     if (player->MovPos == 0)
8706       CheckGravityMovement(player);
8707   }
8708 #else
8709   player->MovPos += (player->MovPos > 0 ? -1 : 1) * move_stepsize;
8710   player->GfxPos = move_stepsize * (player->MovPos / move_stepsize);
8711
8712   /* before DrawPlayer() to draw correct player graphic for this case */
8713   if (player->MovPos == 0)
8714     CheckGravityMovement(player);
8715 #endif
8716
8717   if (player->MovPos == 0)      /* player reached destination field */
8718   {
8719 #if 0
8720     printf("::: player reached destination field\n");
8721 #endif
8722
8723     if (player->move_delay_reset_counter > 0)
8724     {
8725       player->move_delay_reset_counter--;
8726
8727       if (player->move_delay_reset_counter == 0)
8728       {
8729         /* continue with normal speed after quickly moving through gate */
8730         HALVE_PLAYER_SPEED(player);
8731
8732         /* be able to make the next move without delay */
8733         player->move_delay = 0;
8734       }
8735     }
8736
8737     player->last_jx = jx;
8738     player->last_jy = jy;
8739
8740     if (Feld[jx][jy] == EL_EXIT_OPEN ||
8741         Feld[jx][jy] == EL_SP_EXIT_OPEN ||
8742         Feld[jx][jy] == EL_SP_EXIT_OPENING)     /* <-- special case */
8743     {
8744       DrawPlayer(player);       /* needed here only to cleanup last field */
8745       RemovePlayer(player);
8746
8747       if (local_player->friends_still_needed == 0 ||
8748           IS_SP_ELEMENT(Feld[jx][jy]))
8749         player->LevelSolved = player->GameOver = TRUE;
8750     }
8751
8752     /* this breaks one level: "machine", level 000 */
8753     {
8754       int move_direction = player->MovDir;
8755       int enter_side = MV_DIR_OPPOSITE(move_direction);
8756       int leave_side = move_direction;
8757       int old_jx = last_jx;
8758       int old_jy = last_jy;
8759       int old_element = Feld[old_jx][old_jy];
8760       int new_element = Feld[jx][jy];
8761
8762       if (IS_CUSTOM_ELEMENT(old_element))
8763         CheckElementChangeByPlayer(old_jx, old_jy, old_element,
8764                                    CE_LEFT_BY_PLAYER,
8765                                    player->index_bit, leave_side);
8766
8767       CheckTriggeredElementChangeByPlayer(old_element, CE_PLAYER_LEAVES_X,
8768                                           player->index_bit, leave_side);
8769
8770       if (IS_CUSTOM_ELEMENT(new_element))
8771         CheckElementChangeByPlayer(jx, jy, new_element, CE_ENTERED_BY_PLAYER,
8772                                    player->index_bit, enter_side);
8773
8774       CheckTriggeredElementChangeByPlayer(new_element, CE_PLAYER_ENTERS_X,
8775                                           player->index_bit, enter_side);
8776     }
8777
8778     if (game.engine_version >= VERSION_IDENT(3,0,7,0))
8779     {
8780       TestIfPlayerTouchesBadThing(jx, jy);
8781       TestIfPlayerTouchesCustomElement(jx, jy);
8782
8783       /* needed because pushed element has not yet reached its destination,
8784          so it would trigger a change event at its previous field location */
8785       if (!player->is_pushing)
8786         TestIfElementTouchesCustomElement(jx, jy);      /* for empty space */
8787
8788       if (!player->active)
8789         RemovePlayer(player);
8790     }
8791
8792     if (level.use_step_counter)
8793     {
8794       int i;
8795
8796       TimePlayed++;
8797
8798       if (TimeLeft > 0)
8799       {
8800         TimeLeft--;
8801
8802         if (TimeLeft <= 10 && setup.time_limit)
8803           PlaySoundStereo(SND_GAME_RUNNING_OUT_OF_TIME, SOUND_MIDDLE);
8804
8805         DrawGameValue_Time(TimeLeft);
8806
8807         if (!TimeLeft && setup.time_limit)
8808           for (i = 0; i < MAX_PLAYERS; i++)
8809             KillPlayer(&stored_player[i]);
8810       }
8811       else if (level.time == 0 && !AllPlayersGone) /* level w/o time limit */
8812         DrawGameValue_Time(TimePlayed);
8813     }
8814
8815     if (tape.single_step && tape.recording && !tape.pausing &&
8816         !player->programmed_action)
8817       TapeTogglePause(TAPE_TOGGLE_AUTOMATIC);
8818   }
8819 }
8820
8821 void ScrollScreen(struct PlayerInfo *player, int mode)
8822 {
8823   static unsigned long screen_frame_counter = 0;
8824
8825   if (mode == SCROLL_INIT)
8826   {
8827     /* set scrolling step size according to actual player's moving speed */
8828     ScrollStepSize = TILEX / player->move_delay_value;
8829
8830     screen_frame_counter = FrameCounter;
8831     ScreenMovDir = player->MovDir;
8832     ScreenMovPos = player->MovPos;
8833     ScreenGfxPos = ScrollStepSize * (ScreenMovPos / ScrollStepSize);
8834     return;
8835   }
8836   else if (!FrameReached(&screen_frame_counter, 1))
8837     return;
8838
8839   if (ScreenMovPos)
8840   {
8841     ScreenMovPos += (ScreenMovPos > 0 ? -1 : 1) * ScrollStepSize;
8842     ScreenGfxPos = ScrollStepSize * (ScreenMovPos / ScrollStepSize);
8843     redraw_mask |= REDRAW_FIELD;
8844   }
8845   else
8846     ScreenMovDir = MV_NO_MOVING;
8847 }
8848
8849 void TestIfPlayerTouchesCustomElement(int x, int y)
8850 {
8851   static int xy[4][2] =
8852   {
8853     { 0, -1 },
8854     { -1, 0 },
8855     { +1, 0 },
8856     { 0, +1 }
8857   };
8858   static int trigger_sides[4][2] =
8859   {
8860     /* center side       border side */
8861     { CH_SIDE_TOP,      CH_SIDE_BOTTOM  },      /* check top    */
8862     { CH_SIDE_LEFT,     CH_SIDE_RIGHT   },      /* check left   */
8863     { CH_SIDE_RIGHT,    CH_SIDE_LEFT    },      /* check right  */
8864     { CH_SIDE_BOTTOM,   CH_SIDE_TOP     }       /* check bottom */
8865   };
8866   static int touch_dir[4] =
8867   {
8868     MV_LEFT | MV_RIGHT,
8869     MV_UP   | MV_DOWN,
8870     MV_UP   | MV_DOWN,
8871     MV_LEFT | MV_RIGHT
8872   };
8873   int center_element = Feld[x][y];      /* should always be non-moving! */
8874   int i;
8875
8876   for (i = 0; i < NUM_DIRECTIONS; i++)
8877   {
8878     int xx = x + xy[i][0];
8879     int yy = y + xy[i][1];
8880     int center_side = trigger_sides[i][0];
8881     int border_side = trigger_sides[i][1];
8882     int border_element;
8883
8884     if (!IN_LEV_FIELD(xx, yy))
8885       continue;
8886
8887     if (IS_PLAYER(x, y))
8888     {
8889       struct PlayerInfo *player = PLAYERINFO(x, y);
8890
8891       if (game.engine_version < VERSION_IDENT(3,0,7,0))
8892         border_element = Feld[xx][yy];          /* may be moving! */
8893       else if (!IS_MOVING(xx, yy) && !IS_BLOCKED(xx, yy))
8894         border_element = Feld[xx][yy];
8895       else if (MovDir[xx][yy] & touch_dir[i])   /* elements are touching */
8896         border_element = MovingOrBlocked2Element(xx, yy);
8897       else
8898         continue;               /* center and border element do not touch */
8899
8900       CheckElementChangeByPlayer(xx, yy, border_element, CE_TOUCHED_BY_PLAYER,
8901                                  player->index_bit, border_side);
8902       CheckTriggeredElementChangeByPlayer(border_element, CE_PLAYER_TOUCHES_X,
8903                                           player->index_bit, border_side);
8904     }
8905     else if (IS_PLAYER(xx, yy))
8906     {
8907       struct PlayerInfo *player = PLAYERINFO(xx, yy);
8908
8909       if (game.engine_version >= VERSION_IDENT(3,0,7,0))
8910       {
8911         if (player->MovPos != 0 && !(player->MovDir & touch_dir[i]))
8912           continue;             /* center and border element do not touch */
8913       }
8914
8915       CheckElementChangeByPlayer(x, y, center_element, CE_TOUCHED_BY_PLAYER,
8916                                  player->index_bit, center_side);
8917       CheckTriggeredElementChangeByPlayer(center_element, CE_PLAYER_TOUCHES_X,
8918                                           player->index_bit, center_side);
8919       break;
8920     }
8921   }
8922 }
8923
8924 void TestIfElementTouchesCustomElement(int x, int y)
8925 {
8926   static int xy[4][2] =
8927   {
8928     { 0, -1 },
8929     { -1, 0 },
8930     { +1, 0 },
8931     { 0, +1 }
8932   };
8933   static int trigger_sides[4][2] =
8934   {
8935     /* center side      border side */
8936     { CH_SIDE_TOP,      CH_SIDE_BOTTOM  },      /* check top    */
8937     { CH_SIDE_LEFT,     CH_SIDE_RIGHT   },      /* check left   */
8938     { CH_SIDE_RIGHT,    CH_SIDE_LEFT    },      /* check right  */
8939     { CH_SIDE_BOTTOM,   CH_SIDE_TOP     }       /* check bottom */
8940   };
8941   static int touch_dir[4] =
8942   {
8943     MV_LEFT | MV_RIGHT,
8944     MV_UP   | MV_DOWN,
8945     MV_UP   | MV_DOWN,
8946     MV_LEFT | MV_RIGHT
8947   };
8948   boolean change_center_element = FALSE;
8949   int center_element = Feld[x][y];      /* should always be non-moving! */
8950   int i;
8951
8952   for (i = 0; i < NUM_DIRECTIONS; i++)
8953   {
8954     int xx = x + xy[i][0];
8955     int yy = y + xy[i][1];
8956     int center_side = trigger_sides[i][0];
8957     int border_side = trigger_sides[i][1];
8958     int border_element;
8959
8960     if (!IN_LEV_FIELD(xx, yy))
8961       continue;
8962
8963     if (game.engine_version < VERSION_IDENT(3,0,7,0))
8964       border_element = Feld[xx][yy];    /* may be moving! */
8965     else if (!IS_MOVING(xx, yy) && !IS_BLOCKED(xx, yy))
8966       border_element = Feld[xx][yy];
8967     else if (MovDir[xx][yy] & touch_dir[i])     /* elements are touching */
8968       border_element = MovingOrBlocked2Element(xx, yy);
8969     else
8970       continue;                 /* center and border element do not touch */
8971
8972     /* check for change of center element (but change it only once) */
8973     if (!change_center_element)
8974       change_center_element =
8975         CheckElementChangeBySide(x, y, center_element, border_element,
8976                                  CE_TOUCHING_X, border_side);
8977
8978     /* check for change of border element */
8979     CheckElementChangeBySide(xx, yy, border_element, center_element,
8980                              CE_TOUCHING_X, center_side);
8981   }
8982 }
8983
8984 void TestIfElementHitsCustomElement(int x, int y, int direction)
8985 {
8986   int dx = (direction == MV_LEFT ? -1 : direction == MV_RIGHT ? +1 : 0);
8987   int dy = (direction == MV_UP   ? -1 : direction == MV_DOWN  ? +1 : 0);
8988   int hitx = x + dx, hity = y + dy;
8989   int hitting_element = Feld[x][y];
8990   int touched_element;
8991
8992   if (IN_LEV_FIELD(hitx, hity) && IS_FREE(hitx, hity))
8993     return;
8994
8995   touched_element = (IN_LEV_FIELD(hitx, hity) ?
8996                      MovingOrBlocked2Element(hitx, hity) : EL_STEELWALL);
8997
8998   if (IN_LEV_FIELD(hitx, hity))
8999   {
9000     int opposite_direction = MV_DIR_OPPOSITE(direction);
9001     int hitting_side = direction;
9002     int touched_side = opposite_direction;
9003     boolean object_hit = (!IS_MOVING(hitx, hity) ||
9004                           MovDir[hitx][hity] != direction ||
9005                           ABS(MovPos[hitx][hity]) <= TILEY / 2);
9006
9007     object_hit = TRUE;
9008
9009     if (object_hit)
9010     {
9011       CheckElementChangeBySide(x, y, hitting_element, touched_element,
9012                                CE_HITTING_X, touched_side);
9013
9014       CheckElementChangeBySide(hitx, hity, touched_element,
9015                                hitting_element, CE_HIT_BY_X, hitting_side);
9016
9017       CheckElementChangeBySide(hitx, hity, touched_element, hitting_element,
9018                                CE_HIT_BY_SOMETHING, opposite_direction);
9019     }
9020   }
9021
9022   /* "hitting something" is also true when hitting the playfield border */
9023   CheckElementChangeBySide(x, y, hitting_element, touched_element,
9024                            CE_HITTING_SOMETHING, direction);
9025 }
9026
9027 #if 0
9028 void TestIfElementSmashesCustomElement(int x, int y, int direction)
9029 {
9030   int dx = (direction == MV_LEFT ? -1 : direction == MV_RIGHT ? +1 : 0);
9031   int dy = (direction == MV_UP   ? -1 : direction == MV_DOWN  ? +1 : 0);
9032   int hitx = x + dx, hity = y + dy;
9033   int hitting_element = Feld[x][y];
9034   int touched_element;
9035 #if 0
9036   boolean object_hit = (IN_LEV_FIELD(hitx, hity) &&
9037                         !IS_FREE(hitx, hity) &&
9038                         (!IS_MOVING(hitx, hity) ||
9039                          MovDir[hitx][hity] != direction ||
9040                          ABS(MovPos[hitx][hity]) <= TILEY / 2));
9041 #endif
9042
9043   if (IN_LEV_FIELD(hitx, hity) && IS_FREE(hitx, hity))
9044     return;
9045
9046 #if 0
9047   if (IN_LEV_FIELD(hitx, hity) && !object_hit)
9048     return;
9049 #endif
9050
9051   touched_element = (IN_LEV_FIELD(hitx, hity) ?
9052                      MovingOrBlocked2Element(hitx, hity) : EL_STEELWALL);
9053
9054   CheckElementChangeBySide(x, y, hitting_element, touched_element,
9055                            EP_CAN_SMASH_EVERYTHING, direction);
9056
9057   if (IN_LEV_FIELD(hitx, hity))
9058   {
9059     int opposite_direction = MV_DIR_OPPOSITE(direction);
9060     int hitting_side = direction;
9061     int touched_side = opposite_direction;
9062 #if 0
9063     int touched_element = MovingOrBlocked2Element(hitx, hity);
9064 #endif
9065 #if 1
9066     boolean object_hit = (!IS_MOVING(hitx, hity) ||
9067                           MovDir[hitx][hity] != direction ||
9068                           ABS(MovPos[hitx][hity]) <= TILEY / 2);
9069
9070     object_hit = TRUE;
9071 #endif
9072
9073     if (object_hit)
9074     {
9075       int i;
9076
9077       CheckElementChangeBySide(hitx, hity, touched_element, hitting_element,
9078                                CE_SMASHED_BY_SOMETHING, opposite_direction);
9079
9080       CheckElementChangeBySide(x, y, hitting_element, touched_element,
9081                                CE_OTHER_IS_SMASHING, touched_side);
9082
9083       CheckElementChangeBySide(hitx, hity, touched_element, hitting_element,
9084                                CE_OTHER_GETS_SMASHED, hitting_side);
9085     }
9086   }
9087 }
9088 #endif
9089
9090 void TestIfGoodThingHitsBadThing(int good_x, int good_y, int good_move_dir)
9091 {
9092   int i, kill_x = -1, kill_y = -1;
9093   int bad_element = -1;
9094   static int test_xy[4][2] =
9095   {
9096     { 0, -1 },
9097     { -1, 0 },
9098     { +1, 0 },
9099     { 0, +1 }
9100   };
9101   static int test_dir[4] =
9102   {
9103     MV_UP,
9104     MV_LEFT,
9105     MV_RIGHT,
9106     MV_DOWN
9107   };
9108
9109   for (i = 0; i < NUM_DIRECTIONS; i++)
9110   {
9111     int test_x, test_y, test_move_dir, test_element;
9112
9113     test_x = good_x + test_xy[i][0];
9114     test_y = good_y + test_xy[i][1];
9115
9116     if (!IN_LEV_FIELD(test_x, test_y))
9117       continue;
9118
9119     test_move_dir =
9120       (IS_MOVING(test_x, test_y) ? MovDir[test_x][test_y] : MV_NO_MOVING);
9121
9122     test_element = MovingOrBlocked2ElementIfNotLeaving(test_x, test_y);
9123
9124     /* 1st case: good thing is moving towards DONT_RUN_INTO style bad thing;
9125        2nd case: DONT_TOUCH style bad thing does not move away from good thing
9126     */
9127     if ((DONT_RUN_INTO(test_element) && good_move_dir == test_dir[i]) ||
9128         (DONT_TOUCH(test_element)    && test_move_dir != test_dir[i]))
9129     {
9130       kill_x = test_x;
9131       kill_y = test_y;
9132       bad_element = test_element;
9133
9134       break;
9135     }
9136   }
9137
9138   if (kill_x != -1 || kill_y != -1)
9139   {
9140     if (IS_PLAYER(good_x, good_y))
9141     {
9142       struct PlayerInfo *player = PLAYERINFO(good_x, good_y);
9143
9144       if (player->shield_deadly_time_left > 0 &&
9145           !IS_INDESTRUCTIBLE(bad_element))
9146         Bang(kill_x, kill_y);
9147       else if (!PLAYER_ENEMY_PROTECTED(good_x, good_y))
9148         KillPlayer(player);
9149     }
9150     else
9151       Bang(good_x, good_y);
9152   }
9153 }
9154
9155 void TestIfBadThingHitsGoodThing(int bad_x, int bad_y, int bad_move_dir)
9156 {
9157   int i, kill_x = -1, kill_y = -1;
9158   int bad_element = Feld[bad_x][bad_y];
9159   static int test_xy[4][2] =
9160   {
9161     { 0, -1 },
9162     { -1, 0 },
9163     { +1, 0 },
9164     { 0, +1 }
9165   };
9166   static int touch_dir[4] =
9167   {
9168     MV_LEFT | MV_RIGHT,
9169     MV_UP   | MV_DOWN,
9170     MV_UP   | MV_DOWN,
9171     MV_LEFT | MV_RIGHT
9172   };
9173   static int test_dir[4] =
9174   {
9175     MV_UP,
9176     MV_LEFT,
9177     MV_RIGHT,
9178     MV_DOWN
9179   };
9180
9181   if (bad_element == EL_EXPLOSION)      /* skip just exploding bad things */
9182     return;
9183
9184   for (i = 0; i < NUM_DIRECTIONS; i++)
9185   {
9186     int test_x, test_y, test_move_dir, test_element;
9187
9188     test_x = bad_x + test_xy[i][0];
9189     test_y = bad_y + test_xy[i][1];
9190     if (!IN_LEV_FIELD(test_x, test_y))
9191       continue;
9192
9193     test_move_dir =
9194       (IS_MOVING(test_x, test_y) ? MovDir[test_x][test_y] : MV_NO_MOVING);
9195
9196     test_element = Feld[test_x][test_y];
9197
9198     /* 1st case: good thing is moving towards DONT_RUN_INTO style bad thing;
9199        2nd case: DONT_TOUCH style bad thing does not move away from good thing
9200     */
9201     if ((DONT_RUN_INTO(bad_element) &&  bad_move_dir == test_dir[i]) ||
9202         (DONT_TOUCH(bad_element)    && test_move_dir != test_dir[i]))
9203     {
9204       /* good thing is player or penguin that does not move away */
9205       if (IS_PLAYER(test_x, test_y))
9206       {
9207         struct PlayerInfo *player = PLAYERINFO(test_x, test_y);
9208
9209         if (bad_element == EL_ROBOT && player->is_moving)
9210           continue;     /* robot does not kill player if he is moving */
9211
9212         if (game.engine_version >= VERSION_IDENT(3,0,7,0))
9213         {
9214           if (player->MovPos != 0 && !(player->MovDir & touch_dir[i]))
9215             continue;           /* center and border element do not touch */
9216         }
9217
9218         kill_x = test_x;
9219         kill_y = test_y;
9220         break;
9221       }
9222       else if (test_element == EL_PENGUIN)
9223       {
9224         kill_x = test_x;
9225         kill_y = test_y;
9226         break;
9227       }
9228     }
9229   }
9230
9231   if (kill_x != -1 || kill_y != -1)
9232   {
9233     if (IS_PLAYER(kill_x, kill_y))
9234     {
9235       struct PlayerInfo *player = PLAYERINFO(kill_x, kill_y);
9236
9237       if (player->shield_deadly_time_left > 0 &&
9238           !IS_INDESTRUCTIBLE(bad_element))
9239         Bang(bad_x, bad_y);
9240       else if (!PLAYER_ENEMY_PROTECTED(kill_x, kill_y))
9241         KillPlayer(player);
9242     }
9243     else
9244       Bang(kill_x, kill_y);
9245   }
9246 }
9247
9248 void TestIfPlayerTouchesBadThing(int x, int y)
9249 {
9250   TestIfGoodThingHitsBadThing(x, y, MV_NO_MOVING);
9251 }
9252
9253 void TestIfPlayerRunsIntoBadThing(int x, int y, int move_dir)
9254 {
9255   TestIfGoodThingHitsBadThing(x, y, move_dir);
9256 }
9257
9258 void TestIfBadThingTouchesPlayer(int x, int y)
9259 {
9260   TestIfBadThingHitsGoodThing(x, y, MV_NO_MOVING);
9261 }
9262
9263 void TestIfBadThingRunsIntoPlayer(int x, int y, int move_dir)
9264 {
9265   TestIfBadThingHitsGoodThing(x, y, move_dir);
9266 }
9267
9268 void TestIfFriendTouchesBadThing(int x, int y)
9269 {
9270   TestIfGoodThingHitsBadThing(x, y, MV_NO_MOVING);
9271 }
9272
9273 void TestIfBadThingTouchesFriend(int x, int y)
9274 {
9275   TestIfBadThingHitsGoodThing(x, y, MV_NO_MOVING);
9276 }
9277
9278 void TestIfBadThingTouchesOtherBadThing(int bad_x, int bad_y)
9279 {
9280   int i, kill_x = bad_x, kill_y = bad_y;
9281   static int xy[4][2] =
9282   {
9283     { 0, -1 },
9284     { -1, 0 },
9285     { +1, 0 },
9286     { 0, +1 }
9287   };
9288
9289   for (i = 0; i < NUM_DIRECTIONS; i++)
9290   {
9291     int x, y, element;
9292
9293     x = bad_x + xy[i][0];
9294     y = bad_y + xy[i][1];
9295     if (!IN_LEV_FIELD(x, y))
9296       continue;
9297
9298     element = Feld[x][y];
9299     if (IS_AMOEBOID(element) || element == EL_GAME_OF_LIFE ||
9300         element == EL_AMOEBA_GROWING || element == EL_AMOEBA_DROP)
9301     {
9302       kill_x = x;
9303       kill_y = y;
9304       break;
9305     }
9306   }
9307
9308   if (kill_x != bad_x || kill_y != bad_y)
9309     Bang(bad_x, bad_y);
9310 }
9311
9312 void KillPlayer(struct PlayerInfo *player)
9313 {
9314   int jx = player->jx, jy = player->jy;
9315
9316   if (!player->active)
9317     return;
9318
9319   /* remove accessible field at the player's position */
9320   Feld[jx][jy] = EL_EMPTY;
9321
9322   /* deactivate shield (else Bang()/Explode() would not work right) */
9323   player->shield_normal_time_left = 0;
9324   player->shield_deadly_time_left = 0;
9325
9326   Bang(jx, jy);
9327   BuryPlayer(player);
9328 }
9329
9330 static void KillPlayerUnlessEnemyProtected(int x, int y)
9331 {
9332   if (!PLAYER_ENEMY_PROTECTED(x, y))
9333     KillPlayer(PLAYERINFO(x, y));
9334 }
9335
9336 static void KillPlayerUnlessExplosionProtected(int x, int y)
9337 {
9338   if (!PLAYER_EXPLOSION_PROTECTED(x, y))
9339     KillPlayer(PLAYERINFO(x, y));
9340 }
9341
9342 void BuryPlayer(struct PlayerInfo *player)
9343 {
9344   int jx = player->jx, jy = player->jy;
9345
9346   if (!player->active)
9347     return;
9348
9349   PlayLevelSoundElementAction(jx, jy, player->element_nr, ACTION_DYING);
9350   PlayLevelSound(jx, jy, SND_GAME_LOSING);
9351
9352   player->GameOver = TRUE;
9353   RemovePlayer(player);
9354 }
9355
9356 void RemovePlayer(struct PlayerInfo *player)
9357 {
9358   int jx = player->jx, jy = player->jy;
9359   int i, found = FALSE;
9360
9361   player->present = FALSE;
9362   player->active = FALSE;
9363
9364   if (!ExplodeField[jx][jy])
9365     StorePlayer[jx][jy] = 0;
9366
9367   if (player->is_moving)
9368     DrawLevelField(player->last_jx, player->last_jy);
9369
9370   for (i = 0; i < MAX_PLAYERS; i++)
9371     if (stored_player[i].active)
9372       found = TRUE;
9373
9374   if (!found)
9375     AllPlayersGone = TRUE;
9376
9377   ExitX = ZX = jx;
9378   ExitY = ZY = jy;
9379 }
9380
9381 /*
9382   =============================================================================
9383   checkDiagonalPushing()
9384   -----------------------------------------------------------------------------
9385   check if diagonal input device direction results in pushing of object
9386   (by checking if the alternative direction is walkable, diggable, ...)
9387   =============================================================================
9388 */
9389
9390 static boolean checkDiagonalPushing(struct PlayerInfo *player,
9391                                     int x, int y, int real_dx, int real_dy)
9392 {
9393   int jx, jy, dx, dy, xx, yy;
9394
9395   if (real_dx == 0 || real_dy == 0)     /* no diagonal direction => push */
9396     return TRUE;
9397
9398   /* diagonal direction: check alternative direction */
9399   jx = player->jx;
9400   jy = player->jy;
9401   dx = x - jx;
9402   dy = y - jy;
9403   xx = jx + (dx == 0 ? real_dx : 0);
9404   yy = jy + (dy == 0 ? real_dy : 0);
9405
9406   return (!IN_LEV_FIELD(xx, yy) || IS_SOLID_FOR_PUSHING(Feld[xx][yy]));
9407 }
9408
9409 /*
9410   =============================================================================
9411   DigField()
9412   -----------------------------------------------------------------------------
9413   x, y:                 field next to player (non-diagonal) to try to dig to
9414   real_dx, real_dy:     direction as read from input device (can be diagonal)
9415   =============================================================================
9416 */
9417
9418 int DigField(struct PlayerInfo *player,
9419              int oldx, int oldy, int x, int y,
9420              int real_dx, int real_dy, int mode)
9421 {
9422   boolean is_player = (IS_PLAYER(oldx, oldy) || mode != DF_DIG);
9423   boolean player_was_pushing = player->is_pushing;
9424   int jx = oldx, jy = oldy;
9425   int dx = x - jx, dy = y - jy;
9426   int nextx = x + dx, nexty = y + dy;
9427   int move_direction = (dx == -1 ? MV_LEFT :
9428                         dx == +1 ? MV_RIGHT :
9429                         dy == -1 ? MV_UP :
9430                         dy == +1 ? MV_DOWN : MV_NO_MOVING);
9431   int opposite_direction = MV_DIR_OPPOSITE(move_direction);
9432   int dig_side = MV_DIR_OPPOSITE(move_direction);
9433   int old_element = Feld[jx][jy];
9434   int element;
9435   int collect_count;
9436
9437   if (is_player)                /* function can also be called by EL_PENGUIN */
9438   {
9439     if (player->MovPos == 0)
9440     {
9441       player->is_digging = FALSE;
9442       player->is_collecting = FALSE;
9443     }
9444
9445     if (player->MovPos == 0)    /* last pushing move finished */
9446       player->is_pushing = FALSE;
9447
9448     if (mode == DF_NO_PUSH)     /* player just stopped pushing */
9449     {
9450       player->is_switching = FALSE;
9451       player->push_delay = -1;
9452
9453       return MF_NO_ACTION;
9454     }
9455   }
9456
9457   if (IS_MOVING(x, y) || IS_PLAYER(x, y))
9458     return MF_NO_ACTION;
9459
9460   if (IS_TUBE(Back[jx][jy]) && game.engine_version >= VERSION_IDENT(2,2,0,0))
9461     old_element = Back[jx][jy];
9462
9463   /* in case of element dropped at player position, check background */
9464   else if (Back[jx][jy] != EL_EMPTY &&
9465            game.engine_version >= VERSION_IDENT(2,2,0,0))
9466     old_element = Back[jx][jy];
9467
9468   if (IS_WALKABLE(old_element) && !ACCESS_FROM(old_element, move_direction))
9469     return MF_NO_ACTION;        /* field has no opening in this direction */
9470
9471   if (IS_PASSABLE(old_element) && !ACCESS_FROM(old_element,opposite_direction))
9472     return MF_NO_ACTION;        /* field has no opening in this direction */
9473
9474   element = Feld[x][y];
9475 #if USE_NEW_COLLECT_COUNT
9476   collect_count = Count[x][y];
9477 #else
9478   collect_count = element_info[element].collect_count_initial;
9479 #endif
9480
9481 #if 0
9482   if (element != EL_BLOCKED &&
9483       Count[x][y] != element_info[element].collect_count_initial)
9484     printf("::: %d: %d != %d\n",
9485            element,
9486            Count[x][y],
9487            element_info[element].collect_count_initial);
9488 #endif
9489
9490   if (!is_player && !IS_COLLECTIBLE(element))   /* penguin cannot collect it */
9491     return MF_NO_ACTION;
9492
9493   if (mode == DF_SNAP && !IS_SNAPPABLE(element) &&
9494       game.engine_version >= VERSION_IDENT(2,2,0,0))
9495     return MF_NO_ACTION;
9496
9497   if (game.gravity && is_player && !player->is_auto_moving &&
9498       canFallDown(player) && move_direction != MV_DOWN &&
9499       !canMoveToValidFieldWithGravity(jx, jy, move_direction))
9500     return MF_NO_ACTION;        /* player cannot walk here due to gravity */
9501
9502   if (IS_WALKABLE(element) && ACCESS_FROM(element, opposite_direction))
9503   {
9504     int sound_element = SND_ELEMENT(element);
9505     int sound_action = ACTION_WALKING;
9506
9507     if (IS_RND_GATE(element))
9508     {
9509       if (!player->key[RND_GATE_NR(element)])
9510         return MF_NO_ACTION;
9511     }
9512     else if (IS_RND_GATE_GRAY(element))
9513     {
9514       if (!player->key[RND_GATE_GRAY_NR(element)])
9515         return MF_NO_ACTION;
9516     }
9517     else if (element == EL_EXIT_OPEN ||
9518              element == EL_SP_EXIT_OPEN ||
9519              element == EL_SP_EXIT_OPENING)
9520     {
9521       sound_action = ACTION_PASSING;    /* player is passing exit */
9522     }
9523     else if (element == EL_EMPTY)
9524     {
9525       sound_action = ACTION_MOVING;             /* nothing to walk on */
9526     }
9527
9528     /* play sound from background or player, whatever is available */
9529     if (element_info[sound_element].sound[sound_action] != SND_UNDEFINED)
9530       PlayLevelSoundElementAction(x, y, sound_element, sound_action);
9531     else
9532       PlayLevelSoundElementAction(x, y, player->element_nr, sound_action);
9533   }
9534   else if (IS_PASSABLE(element) && canPassField(x, y, move_direction))
9535   {
9536     if (!ACCESS_FROM(element, opposite_direction))
9537       return MF_NO_ACTION;      /* field not accessible from this direction */
9538
9539     if (CAN_MOVE(element))      /* only fixed elements can be passed! */
9540       return MF_NO_ACTION;
9541
9542     if (IS_EM_GATE(element))
9543     {
9544       if (!player->key[EM_GATE_NR(element)])
9545         return MF_NO_ACTION;
9546     }
9547     else if (IS_EM_GATE_GRAY(element))
9548     {
9549       if (!player->key[EM_GATE_GRAY_NR(element)])
9550         return MF_NO_ACTION;
9551     }
9552     else if (IS_SP_PORT(element))
9553     {
9554       if (element == EL_SP_GRAVITY_PORT_LEFT ||
9555           element == EL_SP_GRAVITY_PORT_RIGHT ||
9556           element == EL_SP_GRAVITY_PORT_UP ||
9557           element == EL_SP_GRAVITY_PORT_DOWN)
9558         game.gravity = !game.gravity;
9559       else if (element == EL_SP_GRAVITY_ON_PORT_LEFT ||
9560                element == EL_SP_GRAVITY_ON_PORT_RIGHT ||
9561                element == EL_SP_GRAVITY_ON_PORT_UP ||
9562                element == EL_SP_GRAVITY_ON_PORT_DOWN)
9563         game.gravity = TRUE;
9564       else if (element == EL_SP_GRAVITY_OFF_PORT_LEFT ||
9565                element == EL_SP_GRAVITY_OFF_PORT_RIGHT ||
9566                element == EL_SP_GRAVITY_OFF_PORT_UP ||
9567                element == EL_SP_GRAVITY_OFF_PORT_DOWN)
9568         game.gravity = FALSE;
9569     }
9570
9571     /* automatically move to the next field with double speed */
9572     player->programmed_action = move_direction;
9573
9574     if (player->move_delay_reset_counter == 0)
9575     {
9576       player->move_delay_reset_counter = 2;     /* two double speed steps */
9577
9578       DOUBLE_PLAYER_SPEED(player);
9579     }
9580
9581     PlayLevelSoundAction(x, y, ACTION_PASSING);
9582   }
9583   else if (IS_DIGGABLE(element))
9584   {
9585     RemoveField(x, y);
9586
9587     if (mode != DF_SNAP)
9588     {
9589       GfxElement[x][y] = GFX_ELEMENT(element);
9590       player->is_digging = TRUE;
9591     }
9592
9593     PlayLevelSoundElementAction(x, y, element, ACTION_DIGGING);
9594
9595     CheckTriggeredElementChangeByPlayer(element, CE_PLAYER_DIGS_X,
9596                                         player->index_bit, dig_side);
9597
9598     if (mode == DF_SNAP)
9599       TestIfElementTouchesCustomElement(x, y);  /* for empty space */
9600   }
9601   else if (IS_COLLECTIBLE(element))
9602   {
9603     RemoveField(x, y);
9604
9605     if (is_player && mode != DF_SNAP)
9606     {
9607       GfxElement[x][y] = element;
9608       player->is_collecting = TRUE;
9609     }
9610
9611     if (element == EL_SPEED_PILL)
9612     {
9613       player->move_delay_value = MOVE_DELAY_HIGH_SPEED;
9614     }
9615     else if (element == EL_EXTRA_TIME && level.time > 0)
9616     {
9617       TimeLeft += 10;
9618       DrawGameValue_Time(TimeLeft);
9619     }
9620     else if (element == EL_SHIELD_NORMAL || element == EL_SHIELD_DEADLY)
9621     {
9622       player->shield_normal_time_left += 10;
9623       if (element == EL_SHIELD_DEADLY)
9624         player->shield_deadly_time_left += 10;
9625     }
9626     else if (element == EL_DYNAMITE || element == EL_SP_DISK_RED)
9627     {
9628       if (player->inventory_size < MAX_INVENTORY_SIZE)
9629         player->inventory_element[player->inventory_size++] = element;
9630
9631       DrawGameValue_Dynamite(local_player->inventory_size);
9632     }
9633     else if (element == EL_DYNABOMB_INCREASE_NUMBER)
9634     {
9635       player->dynabomb_count++;
9636       player->dynabombs_left++;
9637     }
9638     else if (element == EL_DYNABOMB_INCREASE_SIZE)
9639     {
9640       player->dynabomb_size++;
9641     }
9642     else if (element == EL_DYNABOMB_INCREASE_POWER)
9643     {
9644       player->dynabomb_xl = TRUE;
9645     }
9646     else if (IS_KEY(element))
9647     {
9648       player->key[KEY_NR(element)] = TRUE;
9649
9650       DrawGameValue_Keys(player->key);
9651
9652       redraw_mask |= REDRAW_DOOR_1;
9653     }
9654     else if (IS_ENVELOPE(element))
9655     {
9656       player->show_envelope = element;
9657     }
9658     else if (IS_DROPPABLE(element) ||
9659              IS_THROWABLE(element))     /* can be collected and dropped */
9660     {
9661       int i;
9662
9663       if (collect_count == 0)
9664         player->inventory_infinite_element = element;
9665       else
9666         for (i = 0; i < collect_count; i++)
9667           if (player->inventory_size < MAX_INVENTORY_SIZE)
9668             player->inventory_element[player->inventory_size++] = element;
9669
9670       DrawGameValue_Dynamite(local_player->inventory_size);
9671     }
9672     else if (collect_count > 0)
9673     {
9674       local_player->gems_still_needed -= collect_count;
9675       if (local_player->gems_still_needed < 0)
9676         local_player->gems_still_needed = 0;
9677
9678       DrawGameValue_Emeralds(local_player->gems_still_needed);
9679     }
9680
9681     RaiseScoreElement(element);
9682     PlayLevelSoundElementAction(x, y, element, ACTION_COLLECTING);
9683
9684     if (is_player)
9685       CheckTriggeredElementChangeByPlayer(element, CE_PLAYER_COLLECTS_X,
9686                                           player->index_bit, dig_side);
9687
9688     if (mode == DF_SNAP)
9689       TestIfElementTouchesCustomElement(x, y);  /* for empty space */
9690   }
9691   else if (IS_PUSHABLE(element))
9692   {
9693     if (mode == DF_SNAP && element != EL_BD_ROCK)
9694       return MF_NO_ACTION;
9695
9696     if (CAN_FALL(element) && dy)
9697       return MF_NO_ACTION;
9698
9699     if (CAN_FALL(element) && IN_LEV_FIELD(x, y + 1) && IS_FREE(x, y + 1) &&
9700         !(element == EL_SPRING && level.use_spring_bug))
9701       return MF_NO_ACTION;
9702
9703     if (CAN_MOVE(element) && GET_MAX_MOVE_DELAY(element) == 0 &&
9704         ((move_direction & MV_VERTICAL &&
9705           ((element_info[element].move_pattern & MV_LEFT &&
9706             IN_LEV_FIELD(x - 1, y) && IS_FREE(x - 1, y)) ||
9707            (element_info[element].move_pattern & MV_RIGHT &&
9708             IN_LEV_FIELD(x + 1, y) && IS_FREE(x + 1, y)))) ||
9709          (move_direction & MV_HORIZONTAL &&
9710           ((element_info[element].move_pattern & MV_UP &&
9711             IN_LEV_FIELD(x, y - 1) && IS_FREE(x, y - 1)) ||
9712            (element_info[element].move_pattern & MV_DOWN &&
9713             IN_LEV_FIELD(x, y + 1) && IS_FREE(x, y + 1))))))
9714       return MF_NO_ACTION;
9715
9716     /* do not push elements already moving away faster than player */
9717     if (CAN_MOVE(element) && MovDir[x][y] == move_direction &&
9718         ABS(getElementMoveStepsize(x, y)) > MOVE_STEPSIZE_NORMAL)
9719       return MF_NO_ACTION;
9720
9721     if (game.engine_version >= VERSION_IDENT(3,1,0,0))
9722     {
9723       if (player->push_delay_value == -1 || !player_was_pushing)
9724         player->push_delay_value = GET_NEW_PUSH_DELAY(element);
9725     }
9726     else if (game.engine_version >= VERSION_IDENT(3,0,7,1))
9727     {
9728       if (player->push_delay_value == -1)
9729         player->push_delay_value = GET_NEW_PUSH_DELAY(element);
9730     }
9731     else if (game.engine_version >= VERSION_IDENT(2,2,0,7))
9732     {
9733       if (!player->is_pushing)
9734         player->push_delay_value = GET_NEW_PUSH_DELAY(element);
9735     }
9736
9737     player->is_pushing = TRUE;
9738
9739     if (!(IN_LEV_FIELD(nextx, nexty) &&
9740           (IS_FREE(nextx, nexty) ||
9741            (Feld[nextx][nexty] == EL_SOKOBAN_FIELD_EMPTY &&
9742             IS_SB_ELEMENT(element)))))
9743       return MF_NO_ACTION;
9744
9745     if (!checkDiagonalPushing(player, x, y, real_dx, real_dy))
9746       return MF_NO_ACTION;
9747
9748     if (player->push_delay == -1)       /* new pushing; restart delay */
9749       player->push_delay = 0;
9750
9751     if (player->push_delay < player->push_delay_value &&
9752         !(tape.playing && tape.file_version < FILE_VERSION_2_0) &&
9753         element != EL_SPRING && element != EL_BALLOON)
9754     {
9755       /* make sure that there is no move delay before next try to push */
9756       if (game.engine_version >= VERSION_IDENT(3,0,7,1))
9757         player->move_delay = 0;
9758
9759       return MF_NO_ACTION;
9760     }
9761
9762     if (IS_SB_ELEMENT(element))
9763     {
9764       if (element == EL_SOKOBAN_FIELD_FULL)
9765       {
9766         Back[x][y] = EL_SOKOBAN_FIELD_EMPTY;
9767         local_player->sokobanfields_still_needed++;
9768       }
9769
9770       if (Feld[nextx][nexty] == EL_SOKOBAN_FIELD_EMPTY)
9771       {
9772         Back[nextx][nexty] = EL_SOKOBAN_FIELD_EMPTY;
9773         local_player->sokobanfields_still_needed--;
9774       }
9775
9776       Feld[x][y] = EL_SOKOBAN_OBJECT;
9777
9778       if (Back[x][y] == Back[nextx][nexty])
9779         PlayLevelSoundAction(x, y, ACTION_PUSHING);
9780       else if (Back[x][y] != 0)
9781         PlayLevelSoundElementAction(x, y, EL_SOKOBAN_FIELD_FULL,
9782                                     ACTION_EMPTYING);
9783       else
9784         PlayLevelSoundElementAction(nextx, nexty, EL_SOKOBAN_FIELD_EMPTY,
9785                                     ACTION_FILLING);
9786
9787       if (local_player->sokobanfields_still_needed == 0 &&
9788           game.emulation == EMU_SOKOBAN)
9789       {
9790         player->LevelSolved = player->GameOver = TRUE;
9791         PlayLevelSound(x, y, SND_GAME_SOKOBAN_SOLVING);
9792       }
9793     }
9794     else
9795       PlayLevelSoundElementAction(x, y, element, ACTION_PUSHING);
9796
9797     InitMovingField(x, y, move_direction);
9798     GfxAction[x][y] = ACTION_PUSHING;
9799
9800     if (mode == DF_SNAP)
9801       ContinueMoving(x, y);
9802     else
9803       MovPos[x][y] = (dx != 0 ? dx : dy);
9804
9805     Pushed[x][y] = TRUE;
9806     Pushed[nextx][nexty] = TRUE;
9807
9808     if (game.engine_version < VERSION_IDENT(2,2,0,7))
9809       player->push_delay_value = GET_NEW_PUSH_DELAY(element);
9810     else
9811       player->push_delay_value = -1;    /* get new value later */
9812
9813     /* check for element change _after_ element has been pushed */
9814     if (game.use_change_when_pushing_bug)
9815     {
9816       CheckElementChangeByPlayer(x, y, element, CE_PUSHED_BY_PLAYER,
9817                                  player->index_bit, dig_side);
9818       CheckTriggeredElementChangeByPlayer(element, CE_PLAYER_PUSHES_X,
9819                                           player->index_bit, dig_side);
9820     }
9821   }
9822   else if (IS_SWITCHABLE(element))
9823   {
9824     if (PLAYER_SWITCHING(player, x, y))
9825     {
9826       CheckTriggeredElementChangeByPlayer(element, CE_PLAYER_PRESSES_X,
9827                                           player->index_bit, dig_side);
9828
9829       return MF_ACTION;
9830     }
9831
9832     player->is_switching = TRUE;
9833     player->switch_x = x;
9834     player->switch_y = y;
9835
9836     PlayLevelSoundElementAction(x, y, element, ACTION_ACTIVATING);
9837
9838     if (element == EL_ROBOT_WHEEL)
9839     {
9840       Feld[x][y] = EL_ROBOT_WHEEL_ACTIVE;
9841       ZX = x;
9842       ZY = y;
9843
9844       DrawLevelField(x, y);
9845     }
9846     else if (element == EL_SP_TERMINAL)
9847     {
9848       int xx, yy;
9849
9850       for (yy = 0; yy < lev_fieldy; yy++) for (xx=0; xx < lev_fieldx; xx++)
9851       {
9852         if (Feld[xx][yy] == EL_SP_DISK_YELLOW)
9853           Bang(xx, yy);
9854         else if (Feld[xx][yy] == EL_SP_TERMINAL)
9855           Feld[xx][yy] = EL_SP_TERMINAL_ACTIVE;
9856       }
9857     }
9858     else if (IS_BELT_SWITCH(element))
9859     {
9860       ToggleBeltSwitch(x, y);
9861     }
9862     else if (element == EL_SWITCHGATE_SWITCH_UP ||
9863              element == EL_SWITCHGATE_SWITCH_DOWN)
9864     {
9865       ToggleSwitchgateSwitch(x, y);
9866     }
9867     else if (element == EL_LIGHT_SWITCH ||
9868              element == EL_LIGHT_SWITCH_ACTIVE)
9869     {
9870       ToggleLightSwitch(x, y);
9871     }
9872     else if (element == EL_TIMEGATE_SWITCH)
9873     {
9874       ActivateTimegateSwitch(x, y);
9875     }
9876     else if (element == EL_BALLOON_SWITCH_LEFT ||
9877              element == EL_BALLOON_SWITCH_RIGHT ||
9878              element == EL_BALLOON_SWITCH_UP ||
9879              element == EL_BALLOON_SWITCH_DOWN ||
9880              element == EL_BALLOON_SWITCH_ANY)
9881     {
9882       if (element == EL_BALLOON_SWITCH_ANY)
9883         game.balloon_dir = move_direction;
9884       else
9885         game.balloon_dir = (element == EL_BALLOON_SWITCH_LEFT  ? MV_LEFT :
9886                             element == EL_BALLOON_SWITCH_RIGHT ? MV_RIGHT :
9887                             element == EL_BALLOON_SWITCH_UP    ? MV_UP :
9888                             element == EL_BALLOON_SWITCH_DOWN  ? MV_DOWN :
9889                             MV_NO_MOVING);
9890     }
9891     else if (element == EL_LAMP)
9892     {
9893       Feld[x][y] = EL_LAMP_ACTIVE;
9894       local_player->lights_still_needed--;
9895
9896       ResetGfxAnimation(x, y);
9897       DrawLevelField(x, y);
9898     }
9899     else if (element == EL_TIME_ORB_FULL)
9900     {
9901       Feld[x][y] = EL_TIME_ORB_EMPTY;
9902       TimeLeft += 10;
9903       DrawGameValue_Time(TimeLeft);
9904
9905       ResetGfxAnimation(x, y);
9906       DrawLevelField(x, y);
9907     }
9908
9909     CheckTriggeredElementChangeByPlayer(element, CE_SWITCH_OF_X,
9910                                         player->index_bit, dig_side);
9911
9912     CheckTriggeredElementChangeByPlayer(element, CE_PLAYER_PRESSES_X,
9913                                         player->index_bit, dig_side);
9914
9915     return MF_ACTION;
9916   }
9917   else
9918   {
9919     if (!PLAYER_SWITCHING(player, x, y))
9920     {
9921       player->is_switching = TRUE;
9922       player->switch_x = x;
9923       player->switch_y = y;
9924
9925       CheckElementChangeByPlayer(x, y, element, CE_SWITCHED,
9926                                  player->index_bit, dig_side);
9927       CheckTriggeredElementChangeByPlayer(element, CE_SWITCH_OF_X,
9928                                           player->index_bit, dig_side);
9929     }
9930
9931     CheckElementChangeByPlayer(x, y, element, CE_PRESSED_BY_PLAYER,
9932                                player->index_bit, dig_side);
9933     CheckTriggeredElementChangeByPlayer(element, CE_PLAYER_PRESSES_X,
9934                                         player->index_bit, dig_side);
9935
9936     return MF_NO_ACTION;
9937   }
9938
9939   player->push_delay = -1;
9940
9941   if (is_player)                /* function can also be called by EL_PENGUIN */
9942   {
9943     if (Feld[x][y] != element)          /* really digged/collected something */
9944       player->is_collecting = !player->is_digging;
9945   }
9946
9947   return MF_MOVING;
9948 }
9949
9950 boolean SnapField(struct PlayerInfo *player, int dx, int dy)
9951 {
9952   int jx = player->jx, jy = player->jy;
9953   int x = jx + dx, y = jy + dy;
9954   int snap_direction = (dx == -1 ? MV_LEFT :
9955                         dx == +1 ? MV_RIGHT :
9956                         dy == -1 ? MV_UP :
9957                         dy == +1 ? MV_DOWN : MV_NO_MOVING);
9958
9959   if (player->MovPos != 0 && game.engine_version >= VERSION_IDENT(2,2,0,0))
9960     return FALSE;
9961
9962   if (!player->active || !IN_LEV_FIELD(x, y))
9963     return FALSE;
9964
9965   if (dx && dy)
9966     return FALSE;
9967
9968   if (!dx && !dy)
9969   {
9970     if (player->MovPos == 0)
9971       player->is_pushing = FALSE;
9972
9973     player->is_snapping = FALSE;
9974
9975     if (player->MovPos == 0)
9976     {
9977       player->is_moving = FALSE;
9978       player->is_digging = FALSE;
9979       player->is_collecting = FALSE;
9980     }
9981
9982     return FALSE;
9983   }
9984
9985   if (player->is_snapping)
9986     return FALSE;
9987
9988   player->MovDir = snap_direction;
9989
9990   if (player->MovPos == 0)
9991   {
9992     player->is_moving = FALSE;
9993     player->is_digging = FALSE;
9994     player->is_collecting = FALSE;
9995   }
9996
9997   player->is_dropping = FALSE;
9998
9999   if (DigField(player, jx, jy, x, y, 0, 0, DF_SNAP) == MF_NO_ACTION)
10000     return FALSE;
10001
10002   player->is_snapping = TRUE;
10003
10004   if (player->MovPos == 0)
10005   {
10006     player->is_moving = FALSE;
10007     player->is_digging = FALSE;
10008     player->is_collecting = FALSE;
10009   }
10010
10011   if (player->MovPos != 0)      /* prevent graphic bugs in versions < 2.2.0 */
10012     DrawLevelField(player->last_jx, player->last_jy);
10013
10014   DrawLevelField(x, y);
10015
10016   return TRUE;
10017 }
10018
10019 boolean DropElement(struct PlayerInfo *player)
10020 {
10021   int old_element, new_element;
10022   int dropx = player->jx, dropy = player->jy;
10023   int drop_direction = player->MovDir;
10024   int drop_side = drop_direction;
10025   int drop_element = (player->inventory_size > 0 ?
10026                       player->inventory_element[player->inventory_size - 1] :
10027                       player->inventory_infinite_element != EL_UNDEFINED ?
10028                       player->inventory_infinite_element :
10029                       player->dynabombs_left > 0 ?
10030                       EL_DYNABOMB_PLAYER_1_ACTIVE + player->index_nr :
10031                       EL_UNDEFINED);
10032
10033   /* do not drop an element on top of another element; when holding drop key
10034      pressed without moving, dropped element must move away before the next
10035      element can be dropped (this is especially important if the next element
10036      is dynamite, which can be placed on background for historical reasons) */
10037   if (PLAYER_DROPPING(player, dropx, dropy) && Feld[dropx][dropy] != EL_EMPTY)
10038     return MF_ACTION;
10039
10040   if (IS_THROWABLE(drop_element))
10041   {
10042     dropx += GET_DX_FROM_DIR(drop_direction);
10043     dropy += GET_DY_FROM_DIR(drop_direction);
10044
10045     if (!IN_LEV_FIELD(dropx, dropy))
10046       return FALSE;
10047   }
10048
10049   old_element = Feld[dropx][dropy];     /* old element at dropping position */
10050   new_element = drop_element;           /* default: no change when dropping */
10051
10052   /* check if player is active, not moving and ready to drop */
10053   if (!player->active || player->MovPos || player->drop_delay > 0)
10054     return FALSE;
10055
10056   /* check if player has anything that can be dropped */
10057   if (new_element == EL_UNDEFINED)
10058     return FALSE;
10059
10060   /* check if anything can be dropped at the current position */
10061   if (IS_ACTIVE_BOMB(old_element) || old_element == EL_EXPLOSION)
10062     return FALSE;
10063
10064   /* collected custom elements can only be dropped on empty fields */
10065   if (IS_CUSTOM_ELEMENT(new_element) && old_element != EL_EMPTY)
10066     return FALSE;
10067
10068   if (old_element != EL_EMPTY)
10069     Back[dropx][dropy] = old_element;   /* store old element on this field */
10070
10071   ResetGfxAnimation(dropx, dropy);
10072   ResetRandomAnimationValue(dropx, dropy);
10073
10074   if (player->inventory_size > 0 ||
10075       player->inventory_infinite_element != EL_UNDEFINED)
10076   {
10077     if (player->inventory_size > 0)
10078     {
10079       player->inventory_size--;
10080
10081       DrawGameValue_Dynamite(local_player->inventory_size);
10082
10083       if (new_element == EL_DYNAMITE)
10084         new_element = EL_DYNAMITE_ACTIVE;
10085       else if (new_element == EL_SP_DISK_RED)
10086         new_element = EL_SP_DISK_RED_ACTIVE;
10087     }
10088
10089     Feld[dropx][dropy] = new_element;
10090
10091     if (IN_SCR_FIELD(SCREENX(dropx), SCREENY(dropy)))
10092       DrawGraphicThruMask(SCREENX(dropx), SCREENY(dropy),
10093                           el2img(Feld[dropx][dropy]), 0);
10094
10095     PlayLevelSoundAction(dropx, dropy, ACTION_DROPPING);
10096
10097     /* needed if previous element just changed to "empty" in the last frame */
10098     Changed[dropx][dropy] = FALSE;              /* allow another change */
10099
10100     CheckElementChangeByPlayer(dropx, dropy, new_element, CE_DROPPED_BY_PLAYER,
10101                                player->index_bit, drop_side);
10102     CheckTriggeredElementChangeByPlayer(new_element, CE_PLAYER_DROPS_X,
10103                                         player->index_bit, drop_side);
10104
10105     TestIfElementTouchesCustomElement(dropx, dropy);
10106   }
10107   else          /* player is dropping a dyna bomb */
10108   {
10109     player->dynabombs_left--;
10110
10111     Feld[dropx][dropy] = new_element;
10112
10113     if (IN_SCR_FIELD(SCREENX(dropx), SCREENY(dropy)))
10114       DrawGraphicThruMask(SCREENX(dropx), SCREENY(dropy),
10115                           el2img(Feld[dropx][dropy]), 0);
10116
10117     PlayLevelSoundAction(dropx, dropy, ACTION_DROPPING);
10118   }
10119
10120   if (Feld[dropx][dropy] == new_element) /* uninitialized unless CE change */
10121     InitField_WithBug1(dropx, dropy, FALSE);
10122
10123   new_element = Feld[dropx][dropy];     /* element might have changed */
10124
10125   if (IS_CUSTOM_ELEMENT(new_element) && CAN_MOVE(new_element) &&
10126       element_info[new_element].move_pattern == MV_WHEN_DROPPED)
10127   {
10128     int move_direction, nextx, nexty;
10129
10130     if (element_info[new_element].move_direction_initial == MV_START_AUTOMATIC)
10131       MovDir[dropx][dropy] = drop_direction;
10132
10133     move_direction = MovDir[dropx][dropy];
10134     nextx = dropx + GET_DX_FROM_DIR(move_direction);
10135     nexty = dropy + GET_DY_FROM_DIR(move_direction);
10136
10137     Changed[dropx][dropy] = FALSE;              /* allow another change */
10138     CheckCollision[dropx][dropy] = 2;
10139   }
10140
10141   player->drop_delay = GET_NEW_DROP_DELAY(drop_element);
10142   player->is_dropping = TRUE;
10143
10144   player->drop_x = dropx;
10145   player->drop_y = dropy;
10146
10147   return TRUE;
10148 }
10149
10150 /* ------------------------------------------------------------------------- */
10151 /* game sound playing functions                                              */
10152 /* ------------------------------------------------------------------------- */
10153
10154 static int *loop_sound_frame = NULL;
10155 static int *loop_sound_volume = NULL;
10156
10157 void InitPlayLevelSound()
10158 {
10159   int num_sounds = getSoundListSize();
10160
10161   checked_free(loop_sound_frame);
10162   checked_free(loop_sound_volume);
10163
10164   loop_sound_frame  = checked_calloc(num_sounds * sizeof(int));
10165   loop_sound_volume = checked_calloc(num_sounds * sizeof(int));
10166 }
10167
10168 static void PlayLevelSound(int x, int y, int nr)
10169 {
10170   int sx = SCREENX(x), sy = SCREENY(y);
10171   int volume, stereo_position;
10172   int max_distance = 8;
10173   int type = (IS_LOOP_SOUND(nr) ? SND_CTRL_PLAY_LOOP : SND_CTRL_PLAY_SOUND);
10174
10175   if ((!setup.sound_simple && !IS_LOOP_SOUND(nr)) ||
10176       (!setup.sound_loops && IS_LOOP_SOUND(nr)))
10177     return;
10178
10179   if (!IN_LEV_FIELD(x, y) ||
10180       sx < -max_distance || sx >= SCR_FIELDX + max_distance ||
10181       sy < -max_distance || sy >= SCR_FIELDY + max_distance)
10182     return;
10183
10184   volume = SOUND_MAX_VOLUME;
10185
10186   if (!IN_SCR_FIELD(sx, sy))
10187   {
10188     int dx = ABS(sx - SCR_FIELDX / 2) - SCR_FIELDX / 2;
10189     int dy = ABS(sy - SCR_FIELDY / 2) - SCR_FIELDY / 2;
10190
10191     volume -= volume * (dx > dy ? dx : dy) / max_distance;
10192   }
10193
10194   stereo_position = (SOUND_MAX_LEFT +
10195                      (sx + max_distance) * SOUND_MAX_LEFT2RIGHT /
10196                      (SCR_FIELDX + 2 * max_distance));
10197
10198   if (IS_LOOP_SOUND(nr))
10199   {
10200     /* This assures that quieter loop sounds do not overwrite louder ones,
10201        while restarting sound volume comparison with each new game frame. */
10202
10203     if (loop_sound_volume[nr] > volume && loop_sound_frame[nr] == FrameCounter)
10204       return;
10205
10206     loop_sound_volume[nr] = volume;
10207     loop_sound_frame[nr] = FrameCounter;
10208   }
10209
10210   PlaySoundExt(nr, volume, stereo_position, type);
10211 }
10212
10213 static void PlayLevelSoundNearest(int x, int y, int sound_action)
10214 {
10215   PlayLevelSound(x < LEVELX(BX1) ? LEVELX(BX1) :
10216                  x > LEVELX(BX2) ? LEVELX(BX2) : x,
10217                  y < LEVELY(BY1) ? LEVELY(BY1) :
10218                  y > LEVELY(BY2) ? LEVELY(BY2) : y,
10219                  sound_action);
10220 }
10221
10222 static void PlayLevelSoundAction(int x, int y, int action)
10223 {
10224   PlayLevelSoundElementAction(x, y, Feld[x][y], action);
10225 }
10226
10227 static void PlayLevelSoundElementAction(int x, int y, int element, int action)
10228 {
10229   int sound_effect = element_info[SND_ELEMENT(element)].sound[action];
10230
10231   if (sound_effect != SND_UNDEFINED)
10232     PlayLevelSound(x, y, sound_effect);
10233 }
10234
10235 static void PlayLevelSoundElementActionIfLoop(int x, int y, int element,
10236                                               int action)
10237 {
10238   int sound_effect = element_info[SND_ELEMENT(element)].sound[action];
10239
10240   if (sound_effect != SND_UNDEFINED && IS_LOOP_SOUND(sound_effect))
10241     PlayLevelSound(x, y, sound_effect);
10242 }
10243
10244 static void PlayLevelSoundActionIfLoop(int x, int y, int action)
10245 {
10246   int sound_effect = element_info[SND_ELEMENT(Feld[x][y])].sound[action];
10247
10248   if (sound_effect != SND_UNDEFINED && IS_LOOP_SOUND(sound_effect))
10249     PlayLevelSound(x, y, sound_effect);
10250 }
10251
10252 static void StopLevelSoundActionIfLoop(int x, int y, int action)
10253 {
10254   int sound_effect = element_info[SND_ELEMENT(Feld[x][y])].sound[action];
10255
10256   if (sound_effect != SND_UNDEFINED && IS_LOOP_SOUND(sound_effect))
10257     StopSound(sound_effect);
10258 }
10259
10260 static void PlayLevelMusic()
10261 {
10262   if (levelset.music[level_nr] != MUS_UNDEFINED)
10263     PlayMusic(levelset.music[level_nr]);        /* from config file */
10264   else
10265     PlayMusic(MAP_NOCONF_MUSIC(level_nr));      /* from music dir */
10266 }
10267
10268 void PlayLevelSound_EM(int x, int y, int element_em, int sample)
10269 {
10270   int element = (element_em > -1 ? map_element_EM_to_RND(element_em) : 0);
10271
10272   switch (sample)
10273   {
10274     case SAMPLE_blank:
10275       PlayLevelSoundElementAction(x, y, element, ACTION_WALKING);
10276       break;
10277
10278     case SAMPLE_roll:
10279       PlayLevelSoundElementAction(x, y, element, ACTION_PUSHING);
10280       break;
10281
10282     case SAMPLE_stone:
10283       PlayLevelSoundElementAction(x, y, element, ACTION_IMPACT);
10284       break;
10285
10286     case SAMPLE_nut:
10287       PlayLevelSoundElementAction(x, y, element, ACTION_IMPACT);
10288       break;
10289
10290     case SAMPLE_crack:
10291       PlayLevelSoundElementAction(x, y, element, ACTION_BREAKING);
10292       break;
10293
10294     case SAMPLE_bug:
10295       PlayLevelSoundElementAction(x, y, element, ACTION_MOVING);
10296       break;
10297
10298     case SAMPLE_tank:
10299       PlayLevelSoundElementAction(x, y, element, ACTION_MOVING);
10300       break;
10301
10302     case SAMPLE_android_clone:
10303       PlayLevelSoundElementAction(x, y, element, ACTION_DROPPING);
10304       break;
10305
10306     case SAMPLE_android_move:
10307       PlayLevelSoundElementAction(x, y, element, ACTION_MOVING);
10308       break;
10309
10310     case SAMPLE_spring:
10311       PlayLevelSoundElementAction(x, y, element, ACTION_IMPACT);
10312       break;
10313
10314     case SAMPLE_slurp:
10315       PlayLevelSoundElementAction(x, y, element, ACTION_SLURPED_BY_SPRING);
10316       break;
10317
10318     case SAMPLE_eater:
10319       PlayLevelSoundElementAction(x, y, element, ACTION_WAITING);
10320       break;
10321
10322     case SAMPLE_eater_eat:
10323       PlayLevelSoundElementAction(x, y, element, ACTION_DIGGING);
10324       break;
10325
10326     case SAMPLE_alien:
10327       PlayLevelSoundElementAction(x, y, element, ACTION_MOVING);
10328       break;
10329
10330     case SAMPLE_collect:
10331       PlayLevelSoundElementAction(x, y, element, ACTION_COLLECTING);
10332       break;
10333
10334     case SAMPLE_diamond:
10335       PlayLevelSoundElementAction(x, y, element, ACTION_IMPACT);
10336       break;
10337
10338     case SAMPLE_squash:
10339       /* !!! CHECK THIS !!! */
10340 #if 1
10341       PlayLevelSoundElementAction(x, y, element, ACTION_BREAKING);
10342 #else
10343       PlayLevelSoundElementAction(x, y, element, ACTION_SMASHED_BY_ROCK);
10344 #endif
10345       break;
10346
10347     case SAMPLE_wonderfall:
10348       PlayLevelSoundElementAction(x, y, element, ACTION_FILLING);
10349       break;
10350
10351     case SAMPLE_drip:
10352       PlayLevelSoundElementAction(x, y, element, ACTION_IMPACT);
10353       break;
10354
10355     case SAMPLE_push:
10356       PlayLevelSoundElementAction(x, y, element, ACTION_PUSHING);
10357       break;
10358
10359     case SAMPLE_dirt:
10360       PlayLevelSoundElementAction(x, y, element, ACTION_DIGGING);
10361       break;
10362
10363     case SAMPLE_acid:
10364       PlayLevelSoundElementAction(x, y, element, ACTION_SPLASHING);
10365       break;
10366
10367     case SAMPLE_ball:
10368       PlayLevelSoundElementAction(x, y, element, ACTION_DROPPING);
10369       break;
10370
10371     case SAMPLE_grow:
10372       PlayLevelSoundElementAction(x, y, element, ACTION_GROWING);
10373       break;
10374
10375     case SAMPLE_wonder:
10376       PlayLevelSoundElementAction(x, y, element, ACTION_ACTIVE);
10377       break;
10378
10379     case SAMPLE_door:
10380       PlayLevelSoundElementAction(x, y, element, ACTION_PASSING);
10381       break;
10382
10383     case SAMPLE_exit_open:
10384       PlayLevelSoundElementAction(x, y, element, ACTION_OPENING);
10385       break;
10386
10387     case SAMPLE_exit_leave:
10388       PlayLevelSoundElementAction(x, y, element, ACTION_PASSING);
10389       break;
10390
10391     case SAMPLE_dynamite:
10392       PlayLevelSoundElementAction(x, y, element, ACTION_DROPPING);
10393       break;
10394
10395     case SAMPLE_tick:
10396       PlayLevelSoundElementAction(x, y, element, ACTION_ACTIVE);
10397       break;
10398
10399     case SAMPLE_press:
10400       PlayLevelSoundElementAction(x, y, element, ACTION_ACTIVATING);
10401       break;
10402
10403     case SAMPLE_wheel:
10404       PlayLevelSoundElementAction(x, y, element, ACTION_ACTIVE);
10405       break;
10406
10407     case SAMPLE_boom:
10408       PlayLevelSoundElementAction(x, y, element, ACTION_EXPLODING);
10409       break;
10410
10411     case SAMPLE_die:
10412       PlayLevelSoundElementAction(x, y, element, ACTION_DYING);
10413       break;
10414
10415     case SAMPLE_time:
10416       PlaySoundStereo(SND_GAME_RUNNING_OUT_OF_TIME, SOUND_MIDDLE);
10417       break;
10418
10419     default:
10420       PlayLevelSoundElementAction(x, y, element, ACTION_DEFAULT);
10421       break;
10422   }
10423 }
10424
10425 void RaiseScore(int value)
10426 {
10427   local_player->score += value;
10428
10429   DrawGameValue_Score(local_player->score);
10430 }
10431
10432 void RaiseScoreElement(int element)
10433 {
10434   switch(element)
10435   {
10436     case EL_EMERALD:
10437     case EL_BD_DIAMOND:
10438     case EL_EMERALD_YELLOW:
10439     case EL_EMERALD_RED:
10440     case EL_EMERALD_PURPLE:
10441     case EL_SP_INFOTRON:
10442       RaiseScore(level.score[SC_EMERALD]);
10443       break;
10444     case EL_DIAMOND:
10445       RaiseScore(level.score[SC_DIAMOND]);
10446       break;
10447     case EL_CRYSTAL:
10448       RaiseScore(level.score[SC_CRYSTAL]);
10449       break;
10450     case EL_PEARL:
10451       RaiseScore(level.score[SC_PEARL]);
10452       break;
10453     case EL_BUG:
10454     case EL_BD_BUTTERFLY:
10455     case EL_SP_ELECTRON:
10456       RaiseScore(level.score[SC_BUG]);
10457       break;
10458     case EL_SPACESHIP:
10459     case EL_BD_FIREFLY:
10460     case EL_SP_SNIKSNAK:
10461       RaiseScore(level.score[SC_SPACESHIP]);
10462       break;
10463     case EL_YAMYAM:
10464     case EL_DARK_YAMYAM:
10465       RaiseScore(level.score[SC_YAMYAM]);
10466       break;
10467     case EL_ROBOT:
10468       RaiseScore(level.score[SC_ROBOT]);
10469       break;
10470     case EL_PACMAN:
10471       RaiseScore(level.score[SC_PACMAN]);
10472       break;
10473     case EL_NUT:
10474       RaiseScore(level.score[SC_NUT]);
10475       break;
10476     case EL_DYNAMITE:
10477     case EL_SP_DISK_RED:
10478     case EL_DYNABOMB_INCREASE_NUMBER:
10479     case EL_DYNABOMB_INCREASE_SIZE:
10480     case EL_DYNABOMB_INCREASE_POWER:
10481       RaiseScore(level.score[SC_DYNAMITE]);
10482       break;
10483     case EL_SHIELD_NORMAL:
10484     case EL_SHIELD_DEADLY:
10485       RaiseScore(level.score[SC_SHIELD]);
10486       break;
10487     case EL_EXTRA_TIME:
10488       RaiseScore(level.score[SC_TIME_BONUS]);
10489       break;
10490     case EL_KEY_1:
10491     case EL_KEY_2:
10492     case EL_KEY_3:
10493     case EL_KEY_4:
10494     case EL_EM_KEY_1:
10495     case EL_EM_KEY_2:
10496     case EL_EM_KEY_3:
10497     case EL_EM_KEY_4:
10498     case EL_EMC_KEY_5:
10499     case EL_EMC_KEY_6:
10500     case EL_EMC_KEY_7:
10501     case EL_EMC_KEY_8:
10502       RaiseScore(level.score[SC_KEY]);
10503       break;
10504     default:
10505       RaiseScore(element_info[element].collect_score);
10506       break;
10507   }
10508 }
10509
10510 void RequestQuitGame(boolean ask_if_really_quit)
10511 {
10512   if (AllPlayersGone ||
10513       !ask_if_really_quit ||
10514       level_editor_test_game ||
10515       Request("Do you really want to quit the game ?",
10516               REQ_ASK | REQ_STAY_CLOSED))
10517   {
10518 #if defined(NETWORK_AVALIABLE)
10519     if (options.network)
10520       SendToServer_StopPlaying();
10521     else
10522 #endif
10523     {
10524       game_status = GAME_MODE_MAIN;
10525       DrawMainMenu();
10526     }
10527   }
10528   else
10529   {
10530     if (tape.playing && tape.deactivate_display)
10531       TapeDeactivateDisplayOff(TRUE);
10532
10533     OpenDoor(DOOR_OPEN_1 | DOOR_COPY_BACK);
10534
10535     if (tape.playing && tape.deactivate_display)
10536       TapeDeactivateDisplayOn();
10537   }
10538 }
10539
10540
10541 /* ---------- new game button stuff ---------------------------------------- */
10542
10543 /* graphic position values for game buttons */
10544 #define GAME_BUTTON_XSIZE       30
10545 #define GAME_BUTTON_YSIZE       30
10546 #define GAME_BUTTON_XPOS        5
10547 #define GAME_BUTTON_YPOS        215
10548 #define SOUND_BUTTON_XPOS       5
10549 #define SOUND_BUTTON_YPOS       (GAME_BUTTON_YPOS + GAME_BUTTON_YSIZE)
10550
10551 #define GAME_BUTTON_STOP_XPOS   (GAME_BUTTON_XPOS + 0 * GAME_BUTTON_XSIZE)
10552 #define GAME_BUTTON_PAUSE_XPOS  (GAME_BUTTON_XPOS + 1 * GAME_BUTTON_XSIZE)
10553 #define GAME_BUTTON_PLAY_XPOS   (GAME_BUTTON_XPOS + 2 * GAME_BUTTON_XSIZE)
10554 #define SOUND_BUTTON_MUSIC_XPOS (SOUND_BUTTON_XPOS + 0 * GAME_BUTTON_XSIZE)
10555 #define SOUND_BUTTON_LOOPS_XPOS (SOUND_BUTTON_XPOS + 1 * GAME_BUTTON_XSIZE)
10556 #define SOUND_BUTTON_SIMPLE_XPOS (SOUND_BUTTON_XPOS + 2 * GAME_BUTTON_XSIZE)
10557
10558 static struct
10559 {
10560   int x, y;
10561   int gadget_id;
10562   char *infotext;
10563 } gamebutton_info[NUM_GAME_BUTTONS] =
10564 {
10565   {
10566     GAME_BUTTON_STOP_XPOS,      GAME_BUTTON_YPOS,
10567     GAME_CTRL_ID_STOP,
10568     "stop game"
10569   },
10570   {
10571     GAME_BUTTON_PAUSE_XPOS,     GAME_BUTTON_YPOS,
10572     GAME_CTRL_ID_PAUSE,
10573     "pause game"
10574   },
10575   {
10576     GAME_BUTTON_PLAY_XPOS,      GAME_BUTTON_YPOS,
10577     GAME_CTRL_ID_PLAY,
10578     "play game"
10579   },
10580   {
10581     SOUND_BUTTON_MUSIC_XPOS,    SOUND_BUTTON_YPOS,
10582     SOUND_CTRL_ID_MUSIC,
10583     "background music on/off"
10584   },
10585   {
10586     SOUND_BUTTON_LOOPS_XPOS,    SOUND_BUTTON_YPOS,
10587     SOUND_CTRL_ID_LOOPS,
10588     "sound loops on/off"
10589   },
10590   {
10591     SOUND_BUTTON_SIMPLE_XPOS,   SOUND_BUTTON_YPOS,
10592     SOUND_CTRL_ID_SIMPLE,
10593     "normal sounds on/off"
10594   }
10595 };
10596
10597 void CreateGameButtons()
10598 {
10599   int i;
10600
10601   for (i = 0; i < NUM_GAME_BUTTONS; i++)
10602   {
10603     Bitmap *gd_bitmap = graphic_info[IMG_GLOBAL_DOOR].bitmap;
10604     struct GadgetInfo *gi;
10605     int button_type;
10606     boolean checked;
10607     unsigned long event_mask;
10608     int gd_xoffset, gd_yoffset;
10609     int gd_x1, gd_x2, gd_y1, gd_y2;
10610     int id = i;
10611
10612     gd_xoffset = gamebutton_info[i].x;
10613     gd_yoffset = gamebutton_info[i].y;
10614     gd_x1 = DOOR_GFX_PAGEX4 + gd_xoffset;
10615     gd_x2 = DOOR_GFX_PAGEX3 + gd_xoffset;
10616
10617     if (id == GAME_CTRL_ID_STOP ||
10618         id == GAME_CTRL_ID_PAUSE ||
10619         id == GAME_CTRL_ID_PLAY)
10620     {
10621       button_type = GD_TYPE_NORMAL_BUTTON;
10622       checked = FALSE;
10623       event_mask = GD_EVENT_RELEASED;
10624       gd_y1  = DOOR_GFX_PAGEY1 + gd_yoffset - GAME_BUTTON_YSIZE;
10625       gd_y2  = DOOR_GFX_PAGEY1 + gd_yoffset - GAME_BUTTON_YSIZE;
10626     }
10627     else
10628     {
10629       button_type = GD_TYPE_CHECK_BUTTON;
10630       checked =
10631         ((id == SOUND_CTRL_ID_MUSIC && setup.sound_music) ||
10632          (id == SOUND_CTRL_ID_LOOPS && setup.sound_loops) ||
10633          (id == SOUND_CTRL_ID_SIMPLE && setup.sound_simple) ? TRUE : FALSE);
10634       event_mask = GD_EVENT_PRESSED;
10635       gd_y1  = DOOR_GFX_PAGEY1 + gd_yoffset;
10636       gd_y2  = DOOR_GFX_PAGEY1 + gd_yoffset - GAME_BUTTON_YSIZE;
10637     }
10638
10639     gi = CreateGadget(GDI_CUSTOM_ID, id,
10640                       GDI_INFO_TEXT, gamebutton_info[i].infotext,
10641                       GDI_X, DX + gd_xoffset,
10642                       GDI_Y, DY + gd_yoffset,
10643                       GDI_WIDTH, GAME_BUTTON_XSIZE,
10644                       GDI_HEIGHT, GAME_BUTTON_YSIZE,
10645                       GDI_TYPE, button_type,
10646                       GDI_STATE, GD_BUTTON_UNPRESSED,
10647                       GDI_CHECKED, checked,
10648                       GDI_DESIGN_UNPRESSED, gd_bitmap, gd_x1, gd_y1,
10649                       GDI_DESIGN_PRESSED, gd_bitmap, gd_x2, gd_y1,
10650                       GDI_ALT_DESIGN_UNPRESSED, gd_bitmap, gd_x1, gd_y2,
10651                       GDI_ALT_DESIGN_PRESSED, gd_bitmap, gd_x2, gd_y2,
10652                       GDI_EVENT_MASK, event_mask,
10653                       GDI_CALLBACK_ACTION, HandleGameButtons,
10654                       GDI_END);
10655
10656     if (gi == NULL)
10657       Error(ERR_EXIT, "cannot create gadget");
10658
10659     game_gadget[id] = gi;
10660   }
10661 }
10662
10663 void FreeGameButtons()
10664 {
10665   int i;
10666
10667   for (i = 0; i < NUM_GAME_BUTTONS; i++)
10668     FreeGadget(game_gadget[i]);
10669 }
10670
10671 static void MapGameButtons()
10672 {
10673   int i;
10674
10675   for (i = 0; i < NUM_GAME_BUTTONS; i++)
10676     MapGadget(game_gadget[i]);
10677 }
10678
10679 void UnmapGameButtons()
10680 {
10681   int i;
10682
10683   for (i = 0; i < NUM_GAME_BUTTONS; i++)
10684     UnmapGadget(game_gadget[i]);
10685 }
10686
10687 static void HandleGameButtons(struct GadgetInfo *gi)
10688 {
10689   int id = gi->custom_id;
10690
10691   if (game_status != GAME_MODE_PLAYING)
10692     return;
10693
10694   switch (id)
10695   {
10696     case GAME_CTRL_ID_STOP:
10697       RequestQuitGame(TRUE);
10698       break;
10699
10700     case GAME_CTRL_ID_PAUSE:
10701       if (options.network)
10702       {
10703 #if defined(NETWORK_AVALIABLE)
10704         if (tape.pausing)
10705           SendToServer_ContinuePlaying();
10706         else
10707           SendToServer_PausePlaying();
10708 #endif
10709       }
10710       else
10711         TapeTogglePause(TAPE_TOGGLE_MANUAL);
10712       break;
10713
10714     case GAME_CTRL_ID_PLAY:
10715       if (tape.pausing)
10716       {
10717 #if defined(NETWORK_AVALIABLE)
10718         if (options.network)
10719           SendToServer_ContinuePlaying();
10720         else
10721 #endif
10722         {
10723           tape.pausing = FALSE;
10724           DrawVideoDisplay(VIDEO_STATE_PAUSE_OFF,0);
10725         }
10726       }
10727       break;
10728
10729     case SOUND_CTRL_ID_MUSIC:
10730       if (setup.sound_music)
10731       {
10732         setup.sound_music = FALSE;
10733         FadeMusic();
10734       }
10735       else if (audio.music_available)
10736       {
10737         setup.sound = setup.sound_music = TRUE;
10738
10739         SetAudioMode(setup.sound);
10740
10741         PlayLevelMusic();
10742       }
10743       break;
10744
10745     case SOUND_CTRL_ID_LOOPS:
10746       if (setup.sound_loops)
10747         setup.sound_loops = FALSE;
10748       else if (audio.loops_available)
10749       {
10750         setup.sound = setup.sound_loops = TRUE;
10751         SetAudioMode(setup.sound);
10752       }
10753       break;
10754
10755     case SOUND_CTRL_ID_SIMPLE:
10756       if (setup.sound_simple)
10757         setup.sound_simple = FALSE;
10758       else if (audio.sound_available)
10759       {
10760         setup.sound = setup.sound_simple = TRUE;
10761         SetAudioMode(setup.sound);
10762       }
10763       break;
10764
10765     default:
10766       break;
10767   }
10768 }