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