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_NO_EXPLOSION         0
  47 #define EX_NORMAL               1
  48 #define EX_CENTER               2
  49 #define EX_BORDER               3
  50
  51 /* special positions in the game control window (relative to control window) */
  52 #define XX_LEVEL                37
  53 #define YY_LEVEL                20
  54 #define XX_EMERALDS             29
  55 #define YY_EMERALDS             54
  56 #define XX_DYNAMITE             29
  57 #define YY_DYNAMITE             89
  58 #define XX_KEYS                 18
  59 #define YY_KEYS                 123
  60 #define XX_SCORE                15
  61 #define YY_SCORE                159
  62 #define XX_TIME                 29
  63 #define YY_TIME                 194
  64
  65 /* special positions in the game control window (relative to main window) */
  66 #define DX_LEVEL                (DX + XX_LEVEL)
  67 #define DY_LEVEL                (DY + YY_LEVEL)
  68 #define DX_EMERALDS             (DX + XX_EMERALDS)
  69 #define DY_EMERALDS             (DY + YY_EMERALDS)
  70 #define DX_DYNAMITE             (DX + XX_DYNAMITE)
  71 #define DY_DYNAMITE             (DY + YY_DYNAMITE)
  72 #define DX_KEYS                 (DX + XX_KEYS)
  73 #define DY_KEYS                 (DY + YY_KEYS)
  74 #define DX_SCORE                (DX + XX_SCORE)
  75 #define DY_SCORE                (DY + YY_SCORE)
  76 #define DX_TIME                 (DX + XX_TIME)
  77 #define DY_TIME                 (DY + YY_TIME)
  78
  79 /* values for initial player move delay (initial delay counter value) */
  80 #define INITIAL_MOVE_DELAY_OFF  -1
  81 #define INITIAL_MOVE_DELAY_ON   0
  82
  83 /* values for player movement speed (which is in fact a delay value) */
  84 #define MOVE_DELAY_NORMAL_SPEED 8
  85 #define MOVE_DELAY_HIGH_SPEED   4
  86
  87 #define DOUBLE_MOVE_DELAY(x)    (x = (x <= MOVE_DELAY_HIGH_SPEED ? x * 2 : x))
  88 #define HALVE_MOVE_DELAY(x)     (x = (x >= MOVE_DELAY_HIGH_SPEED ? x / 2 : x))
  89 #define DOUBLE_PLAYER_SPEED(p)  (HALVE_MOVE_DELAY((p)->move_delay_value))
  90 #define HALVE_PLAYER_SPEED(p)   (DOUBLE_MOVE_DELAY((p)->move_delay_value))
  91
  92 /* values for other actions */
  93 #define MOVE_STEPSIZE_NORMAL    (TILEX / MOVE_DELAY_NORMAL_SPEED)
  94
  95 #define INIT_GFX_RANDOM()       (SimpleRND(1000000))
  96
  97 #define GET_NEW_PUSH_DELAY(e)   (   (element_info[e].push_delay_fixed) + \
  98                                  RND(element_info[e].push_delay_random))
  99 #define GET_NEW_MOVE_DELAY(e)   (   (element_info[e].move_delay_fixed) + \
 100                                  RND(element_info[e].move_delay_random))
 101
 102 #define ELEMENT_CAN_ENTER_FIELD_GENERIC(e, x, y, condition)             \
 103                 (IN_LEV_FIELD(x, y) && (IS_FREE(x, y) ||                \
 104                                         (condition) ||                  \
 105                                         (DONT_COLLIDE_WITH(e) &&        \
 106                                          IS_FREE_OR_PLAYER(x, y))))
 107
 108 #define ELEMENT_CAN_ENTER_FIELD_GENERIC_2(x, y, condition)              \
 109                 (IN_LEV_FIELD(x, y) && (IS_FREE(x, y) ||                \
 110                                         (condition)))
 111
 112 #define ELEMENT_CAN_ENTER_FIELD(e, x, y)                                \
 113         ELEMENT_CAN_ENTER_FIELD_GENERIC(e, x, y, 0)
 114
 115 #define ELEMENT_CAN_ENTER_FIELD_OR_ACID(e, x, y)                        \
 116         ELEMENT_CAN_ENTER_FIELD_GENERIC(e, x, y, (Feld[x][y] == EL_ACID))
 117
 118 #define ELEMENT_CAN_ENTER_FIELD_OR_ACID_2(x, y)                         \
 119         ELEMENT_CAN_ENTER_FIELD_GENERIC_2(x, y, (Feld[x][y] == EL_ACID))
 120
 121 #define ENEMY_CAN_ENTER_FIELD(x, y) (IN_LEV_FIELD(x, y) && IS_FREE(x, y))
 122
 123 #define YAMYAM_CAN_ENTER_FIELD(x, y)                                    \
 124                 (IN_LEV_FIELD(x, y) && (IS_FREE_OR_PLAYER(x, y) ||      \
 125                                         Feld[x][y] == EL_DIAMOND))
 126
 127 #define DARK_YAMYAM_CAN_ENTER_FIELD(x, y)                               \
 128                 (IN_LEV_FIELD(x, y) && (IS_FREE_OR_PLAYER(x, y) ||      \
 129                                         IS_FOOD_DARK_YAMYAM(Feld[x][y])))
 130
 131 #define PACMAN_CAN_ENTER_FIELD(x, y)                                    \
 132                 (IN_LEV_FIELD(x, y) && (IS_FREE_OR_PLAYER(x, y) ||      \
 133                                         IS_AMOEBOID(Feld[x][y])))
 134
 135 #define PIG_CAN_ENTER_FIELD(x, y)                                       \
 136                 (IN_LEV_FIELD(x, y) && (IS_FREE(x, y) ||                \
 137                                         IS_FOOD_PIG(Feld[x][y])))
 138
 139 #define PENGUIN_CAN_ENTER_FIELD(x, y)                                   \
 140                 (IN_LEV_FIELD(x, y) && (IS_FREE(x, y) ||                \
 141                                         IS_FOOD_PENGUIN(Feld[x][y]) ||  \
 142                                         Feld[x][y] == EL_EXIT_OPEN ||   \
 143                                         Feld[x][y] == EL_ACID))
 144
 145 #define MOLE_CAN_ENTER_FIELD(x, y, condition)                           \
 146                 (IN_LEV_FIELD(x, y) && (IS_FREE(x, y) || (condition)))
 147
 148 #define IN_LEV_FIELD_AND_IS_FREE(x, y)  (IN_LEV_FIELD(x, y) &&  IS_FREE(x, y))
 149 #define IN_LEV_FIELD_AND_NOT_FREE(x, y) (IN_LEV_FIELD(x, y) && !IS_FREE(x, y))
 150
 151 /* game button identifiers */
 152 #define GAME_CTRL_ID_STOP               0
 153 #define GAME_CTRL_ID_PAUSE              1
 154 #define GAME_CTRL_ID_PLAY               2
 155 #define SOUND_CTRL_ID_MUSIC             3
 156 #define SOUND_CTRL_ID_LOOPS             4
 157 #define SOUND_CTRL_ID_SIMPLE            5
 158
 159 #define NUM_GAME_BUTTONS                6
 160
 161
 162 /* forward declaration for internal use */
 163
 164 static boolean MovePlayerOneStep(struct PlayerInfo *, int, int, int, int);
 165 static boolean MovePlayer(struct PlayerInfo *, int, int);
 166 static void ScrollPlayer(struct PlayerInfo *, int);
 167 static void ScrollScreen(struct PlayerInfo *, int);
 168
 169 static void InitBeltMovement(void);
 170 static void CloseAllOpenTimegates(void);
 171 static void CheckGravityMovement(struct PlayerInfo *);
 172 static void KillHeroUnlessProtected(int, int);
 173
 174 static void TestIfPlayerTouchesCustomElement(int, int);
 175 static void TestIfElementTouchesCustomElement(int, int);
 176
 177 static void ChangeElement(int, int, int);
 178 static boolean CheckTriggeredElementSideChange(int, int, int, int, int);
 179 static boolean CheckTriggeredElementChange(int, int, int, int);
 180 static boolean CheckElementSideChange(int, int, int, int, int, int);
 181 static boolean CheckElementChange(int, int, int, int);
 182
 183 static void PlaySoundLevel(int, int, int);
 184 static void PlaySoundLevelNearest(int, int, int);
 185 static void PlaySoundLevelAction(int, int, int);
 186 static void PlaySoundLevelElementAction(int, int, int, int);
 187 static void PlaySoundLevelActionIfLoop(int, int, int);
 188 static void StopSoundLevelActionIfLoop(int, int, int);
 189
 190 static void MapGameButtons();
 191 static void HandleGameButtons(struct GadgetInfo *);
 192
 193 static struct GadgetInfo *game_gadget[NUM_GAME_BUTTONS];
 194
 195
 196 /* ------------------------------------------------------------------------- */
 197 /* definition of elements that automatically change to other elements after  */
 198 /* a specified time, eventually calling a function when changing             */
 199 /* ------------------------------------------------------------------------- */
 200
 201 /* forward declaration for changer functions */
 202 static void InitBuggyBase(int x, int y);
 203 static void WarnBuggyBase(int x, int y);
 204
 205 static void InitTrap(int x, int y);
 206 static void ActivateTrap(int x, int y);
 207 static void ChangeActiveTrap(int x, int y);
 208
 209 static void InitRobotWheel(int x, int y);
 210 static void RunRobotWheel(int x, int y);
 211 static void StopRobotWheel(int x, int y);
 212
 213 static void InitTimegateWheel(int x, int y);
 214 static void RunTimegateWheel(int x, int y);
 215
 216 struct ChangingElementInfo
 217 {
 218   int element;
 219   int target_element;
 220   int change_delay;
 221   void (*pre_change_function)(int x, int y);
 222   void (*change_function)(int x, int y);
 223   void (*post_change_function)(int x, int y);
 224 };
 225
 226 static struct ChangingElementInfo change_delay_list[] =
 227 {
 228   {
 229     EL_NUT_BREAKING,
 230     EL_EMERALD,
 231     6,
 232     NULL,
 233     NULL,
 234     NULL
 235   },
 236   {
 237     EL_PEARL_BREAKING,
 238     EL_EMPTY,
 239     8,
 240     NULL,
 241     NULL,
 242     NULL
 243   },
 244   {
 245     EL_EXIT_OPENING,
 246     EL_EXIT_OPEN,
 247     29,
 248     NULL,
 249     NULL,
 250     NULL
 251   },
 252   {
 253     EL_EXIT_CLOSING,
 254     EL_EXIT_CLOSED,
 255     29,
 256     NULL,
 257     NULL,
 258     NULL
 259   },
 260   {
 261     EL_SP_EXIT_OPENING,
 262     EL_SP_EXIT_OPEN,
 263     29,
 264     NULL,
 265     NULL,
 266     NULL
 267   },
 268   {
 269     EL_SP_EXIT_CLOSING,
 270     EL_SP_EXIT_CLOSED,
 271     29,
 272     NULL,
 273     NULL,
 274     NULL
 275   },
 276   {
 277     EL_SWITCHGATE_OPENING,
 278     EL_SWITCHGATE_OPEN,
 279     29,
 280     NULL,
 281     NULL,
 282     NULL
 283   },
 284   {
 285     EL_SWITCHGATE_CLOSING,
 286     EL_SWITCHGATE_CLOSED,
 287     29,
 288     NULL,
 289     NULL,
 290     NULL
 291   },
 292   {
 293     EL_TIMEGATE_OPENING,
 294     EL_TIMEGATE_OPEN,
 295     29,
 296     NULL,
 297     NULL,
 298     NULL
 299   },
 300   {
 301     EL_TIMEGATE_CLOSING,
 302     EL_TIMEGATE_CLOSED,
 303     29,
 304     NULL,
 305     NULL,
 306     NULL
 307   },
 308
 309   {
 310     EL_ACID_SPLASH_LEFT,
 311     EL_EMPTY,
 312     8,
 313     NULL,
 314     NULL,
 315     NULL
 316   },
 317   {
 318     EL_ACID_SPLASH_RIGHT,
 319     EL_EMPTY,
 320     8,
 321     NULL,
 322     NULL,
 323     NULL
 324   },
 325   {
 326     EL_SP_BUGGY_BASE,
 327     EL_SP_BUGGY_BASE_ACTIVATING,
 328     0,
 329     InitBuggyBase,
 330     NULL,
 331     NULL
 332   },
 333   {
 334     EL_SP_BUGGY_BASE_ACTIVATING,
 335     EL_SP_BUGGY_BASE_ACTIVE,
 336     0,
 337     InitBuggyBase,
 338     NULL,
 339     NULL
 340   },
 341   {
 342     EL_SP_BUGGY_BASE_ACTIVE,
 343     EL_SP_BUGGY_BASE,
 344     0,
 345     InitBuggyBase,
 346     WarnBuggyBase,
 347     NULL
 348   },
 349   {
 350     EL_TRAP,
 351     EL_TRAP_ACTIVE,
 352     0,
 353     InitTrap,
 354     NULL,
 355     ActivateTrap
 356   },
 357   {
 358     EL_TRAP_ACTIVE,
 359     EL_TRAP,
 360     31,
 361     NULL,
 362     ChangeActiveTrap,
 363     NULL
 364   },
 365   {
 366     EL_ROBOT_WHEEL_ACTIVE,
 367     EL_ROBOT_WHEEL,
 368     0,
 369     InitRobotWheel,
 370     RunRobotWheel,
 371     StopRobotWheel
 372   },
 373   {
 374     EL_TIMEGATE_SWITCH_ACTIVE,
 375     EL_TIMEGATE_SWITCH,
 376     0,
 377     InitTimegateWheel,
 378     RunTimegateWheel,
 379     NULL
 380   },
 381
 382   {
 383     EL_UNDEFINED,
 384     EL_UNDEFINED,
 385     -1,
 386     NULL,
 387     NULL,
 388     NULL
 389   }
 390 };
 391
 392 struct
 393 {
 394   int element;
 395   int push_delay_fixed, push_delay_random;
 396 }
 397 push_delay_list[] =
 398 {
 399   { EL_SPRING,                  0, 0 },
 400   { EL_BALLOON,                 0, 0 },
 401
 402   { EL_SOKOBAN_OBJECT,          2, 0 },
 403   { EL_SOKOBAN_FIELD_FULL,      2, 0 },
 404   { EL_SATELLITE,               2, 0 },
 405   { EL_SP_DISK_YELLOW,          2, 0 },
 406
 407   { EL_UNDEFINED,               0, 0 },
 408 };
 409
 410 struct
 411 {
 412   int element;
 413   int move_stepsize;
 414 }
 415 move_stepsize_list[] =
 416 {
 417   { EL_AMOEBA_DROP,             2 },
 418   { EL_AMOEBA_DROPPING,         2 },
 419   { EL_QUICKSAND_FILLING,       1 },
 420   { EL_QUICKSAND_EMPTYING,      1 },
 421   { EL_MAGIC_WALL_FILLING,      2 },
 422   { EL_BD_MAGIC_WALL_FILLING,   2 },
 423   { EL_MAGIC_WALL_EMPTYING,     2 },
 424   { EL_BD_MAGIC_WALL_EMPTYING,  2 },
 425
 426   { EL_UNDEFINED,               0 },
 427 };
 428
 429 struct
 430 {
 431   int element;
 432   int count;
 433 }
 434 collect_count_list[] =
 435 {
 436   { EL_EMERALD,                 1 },
 437   { EL_BD_DIAMOND,              1 },
 438   { EL_EMERALD_YELLOW,          1 },
 439   { EL_EMERALD_RED,             1 },
 440   { EL_EMERALD_PURPLE,          1 },
 441   { EL_DIAMOND,                 3 },
 442   { EL_SP_INFOTRON,             1 },
 443   { EL_PEARL,                   5 },
 444   { EL_CRYSTAL,                 8 },
 445
 446   { EL_UNDEFINED,               0 },
 447 };
 448
 449 static unsigned long trigger_events[MAX_NUM_ELEMENTS];
 450
 451 #define IS_AUTO_CHANGING(e)     (element_info[e].change_events & \
 452                                  CH_EVENT_BIT(CE_DELAY))
 453 #define IS_JUST_CHANGING(x, y)  (ChangeDelay[x][y] != 0)
 454 #define IS_CHANGING(x, y)       (IS_AUTO_CHANGING(Feld[x][y]) || \
 455                                  IS_JUST_CHANGING(x, y))
 456
 457 #define CE_PAGE(e, ce)          (element_info[e].event_page[ce])
 458
 459
 460 void GetPlayerConfig()
 461 {
 462   if (!audio.sound_available)
 463     setup.sound_simple = FALSE;
 464
 465   if (!audio.loops_available)
 466     setup.sound_loops = FALSE;
 467
 468   if (!audio.music_available)
 469     setup.sound_music = FALSE;
 470
 471   if (!video.fullscreen_available)
 472     setup.fullscreen = FALSE;
 473
 474   setup.sound = (setup.sound_simple || setup.sound_loops || setup.sound_music);
 475
 476   SetAudioMode(setup.sound);
 477   InitJoysticks();
 478 }
 479
 480 static int getBeltNrFromBeltElement(int element)
 481 {
 482   return (element < EL_CONVEYOR_BELT_2_LEFT ? 0 :
 483           element < EL_CONVEYOR_BELT_3_LEFT ? 1 :
 484           element < EL_CONVEYOR_BELT_4_LEFT ? 2 : 3);
 485 }
 486
 487 static int getBeltNrFromBeltActiveElement(int element)
 488 {
 489   return (element < EL_CONVEYOR_BELT_2_LEFT_ACTIVE ? 0 :
 490           element < EL_CONVEYOR_BELT_3_LEFT_ACTIVE ? 1 :
 491           element < EL_CONVEYOR_BELT_4_LEFT_ACTIVE ? 2 : 3);
 492 }
 493
 494 static int getBeltNrFromBeltSwitchElement(int element)
 495 {
 496   return (element < EL_CONVEYOR_BELT_2_SWITCH_LEFT ? 0 :
 497           element < EL_CONVEYOR_BELT_3_SWITCH_LEFT ? 1 :
 498           element < EL_CONVEYOR_BELT_4_SWITCH_LEFT ? 2 : 3);
 499 }
 500
 501 static int getBeltDirNrFromBeltSwitchElement(int element)
 502 {
 503   static int belt_base_element[4] =
 504   {
 505     EL_CONVEYOR_BELT_1_SWITCH_LEFT,
 506     EL_CONVEYOR_BELT_2_SWITCH_LEFT,
 507     EL_CONVEYOR_BELT_3_SWITCH_LEFT,
 508     EL_CONVEYOR_BELT_4_SWITCH_LEFT
 509   };
 510
 511   int belt_nr = getBeltNrFromBeltSwitchElement(element);
 512   int belt_dir_nr = element - belt_base_element[belt_nr];
 513
 514   return (belt_dir_nr % 3);
 515 }
 516
 517 static int getBeltDirFromBeltSwitchElement(int element)
 518 {
 519   static int belt_move_dir[3] =
 520   {
 521     MV_LEFT,
 522     MV_NO_MOVING,
 523     MV_RIGHT
 524   };
 525
 526   int belt_dir_nr = getBeltDirNrFromBeltSwitchElement(element);
 527
 528   return belt_move_dir[belt_dir_nr];
 529 }
 530
 531 static void InitPlayerField(int x, int y, int element, boolean init_game)
 532 {
 533   if (element == EL_SP_MURPHY)
 534   {
 535     if (init_game)
 536     {
 537       if (stored_player[0].present)
 538       {
 539         Feld[x][y] = EL_SP_MURPHY_CLONE;
 540
 541         return;
 542       }
 543       else
 544       {
 545         stored_player[0].use_murphy_graphic = TRUE;
 546       }
 547
 548       Feld[x][y] = EL_PLAYER_1;
 549     }
 550   }
 551
 552   if (init_game)
 553   {
 554     struct PlayerInfo *player = &stored_player[Feld[x][y] - EL_PLAYER_1];
 555     int jx = player->jx, jy = player->jy;
 556
 557     player->present = TRUE;
 558
 559     if (!options.network || player->connected)
 560     {
 561       player->active = TRUE;
 562
 563       /* remove potentially duplicate players */
 564       if (StorePlayer[jx][jy] == Feld[x][y])
 565         StorePlayer[jx][jy] = 0;
 566
 567       StorePlayer[x][y] = Feld[x][y];
 568
 569       if (options.debug)
 570       {
 571         printf("Player %d activated.\n", player->element_nr);
 572         printf("[Local player is %d and currently %s.]\n",
 573                local_player->element_nr,
 574                local_player->active ? "active" : "not active");
 575       }
 576     }
 577
 578     Feld[x][y] = EL_EMPTY;
 579     player->jx = player->last_jx = x;
 580     player->jy = player->last_jy = y;
 581   }
 582 }
 583
 584 static void InitField(int x, int y, boolean init_game)
 585 {
 586   int element = Feld[x][y];
 587
 588   switch (element)
 589   {
 590     case EL_SP_MURPHY:
 591     case EL_PLAYER_1:
 592     case EL_PLAYER_2:
 593     case EL_PLAYER_3:
 594     case EL_PLAYER_4:
 595       InitPlayerField(x, y, element, init_game);
 596       break;
 597
 598     case EL_STONEBLOCK:
 599       if (x < lev_fieldx-1 && Feld[x+1][y] == EL_ACID)
 600         Feld[x][y] = EL_ACID_POOL_TOPLEFT;
 601       else if (x > 0 && Feld[x-1][y] == EL_ACID)
 602         Feld[x][y] = EL_ACID_POOL_TOPRIGHT;
 603       else if (y > 0 && Feld[x][y-1] == EL_ACID_POOL_TOPLEFT)
 604         Feld[x][y] = EL_ACID_POOL_BOTTOMLEFT;
 605       else if (y > 0 && Feld[x][y-1] == EL_ACID)
 606         Feld[x][y] = EL_ACID_POOL_BOTTOM;
 607       else if (y > 0 && Feld[x][y-1] == EL_ACID_POOL_TOPRIGHT)
 608         Feld[x][y] = EL_ACID_POOL_BOTTOMRIGHT;
 609       break;
 610
 611     case EL_BUG_RIGHT:
 612     case EL_BUG_UP:
 613     case EL_BUG_LEFT:
 614     case EL_BUG_DOWN:
 615     case EL_BUG:
 616     case EL_SPACESHIP_RIGHT:
 617     case EL_SPACESHIP_UP:
 618     case EL_SPACESHIP_LEFT:
 619     case EL_SPACESHIP_DOWN:
 620     case EL_SPACESHIP:
 621     case EL_BD_BUTTERFLY_RIGHT:
 622     case EL_BD_BUTTERFLY_UP:
 623     case EL_BD_BUTTERFLY_LEFT:
 624     case EL_BD_BUTTERFLY_DOWN:
 625     case EL_BD_BUTTERFLY:
 626     case EL_BD_FIREFLY_RIGHT:
 627     case EL_BD_FIREFLY_UP:
 628     case EL_BD_FIREFLY_LEFT:
 629     case EL_BD_FIREFLY_DOWN:
 630     case EL_BD_FIREFLY:
 631     case EL_PACMAN_RIGHT:
 632     case EL_PACMAN_UP:
 633     case EL_PACMAN_LEFT:
 634     case EL_PACMAN_DOWN:
 635     case EL_YAMYAM:
 636     case EL_DARK_YAMYAM:
 637     case EL_ROBOT:
 638     case EL_PACMAN:
 639     case EL_SP_SNIKSNAK:
 640     case EL_SP_ELECTRON:
 641     case EL_MOLE_LEFT:
 642     case EL_MOLE_RIGHT:
 643     case EL_MOLE_UP:
 644     case EL_MOLE_DOWN:
 645     case EL_MOLE:
 646       InitMovDir(x, y);
 647       break;
 648
 649     case EL_AMOEBA_FULL:
 650     case EL_BD_AMOEBA:
 651       InitAmoebaNr(x, y);
 652       break;
 653
 654     case EL_AMOEBA_DROP:
 655       if (y == lev_fieldy - 1)
 656       {
 657         Feld[x][y] = EL_AMOEBA_GROWING;
 658         Store[x][y] = EL_AMOEBA_WET;
 659       }
 660       break;
 661
 662     case EL_DYNAMITE_ACTIVE:
 663       MovDelay[x][y] = 96;
 664       break;
 665
 666     case EL_LAMP:
 667       local_player->lights_still_needed++;
 668       break;
 669
 670     case EL_SOKOBAN_FIELD_EMPTY:
 671       local_player->sokobanfields_still_needed++;
 672       break;
 673
 674     case EL_PENGUIN:
 675       local_player->friends_still_needed++;
 676       break;
 677
 678     case EL_PIG:
 679     case EL_DRAGON:
 680       MovDir[x][y] = 1 << RND(4);
 681       break;
 682
 683 #if 0
 684     case EL_SP_EMPTY:
 685       Feld[x][y] = EL_EMPTY;
 686       break;
 687 #endif
 688
 689 #if 0
 690     case EL_EM_KEY_1_FILE:
 691       Feld[x][y] = EL_EM_KEY_1;
 692       break;
 693     case EL_EM_KEY_2_FILE:
 694       Feld[x][y] = EL_EM_KEY_2;
 695       break;
 696     case EL_EM_KEY_3_FILE:
 697       Feld[x][y] = EL_EM_KEY_3;
 698       break;
 699     case EL_EM_KEY_4_FILE:
 700       Feld[x][y] = EL_EM_KEY_4;
 701       break;
 702 #endif
 703
 704     case EL_CONVEYOR_BELT_1_SWITCH_LEFT:
 705     case EL_CONVEYOR_BELT_1_SWITCH_MIDDLE:
 706     case EL_CONVEYOR_BELT_1_SWITCH_RIGHT:
 707     case EL_CONVEYOR_BELT_2_SWITCH_LEFT:
 708     case EL_CONVEYOR_BELT_2_SWITCH_MIDDLE:
 709     case EL_CONVEYOR_BELT_2_SWITCH_RIGHT:
 710     case EL_CONVEYOR_BELT_3_SWITCH_LEFT:
 711     case EL_CONVEYOR_BELT_3_SWITCH_MIDDLE:
 712     case EL_CONVEYOR_BELT_3_SWITCH_RIGHT:
 713     case EL_CONVEYOR_BELT_4_SWITCH_LEFT:
 714     case EL_CONVEYOR_BELT_4_SWITCH_MIDDLE:
 715     case EL_CONVEYOR_BELT_4_SWITCH_RIGHT:
 716       if (init_game)
 717       {
 718         int belt_nr = getBeltNrFromBeltSwitchElement(Feld[x][y]);
 719         int belt_dir = getBeltDirFromBeltSwitchElement(Feld[x][y]);
 720         int belt_dir_nr = getBeltDirNrFromBeltSwitchElement(Feld[x][y]);
 721
 722         if (game.belt_dir_nr[belt_nr] == 3)     /* initial value */
 723         {
 724           game.belt_dir[belt_nr] = belt_dir;
 725           game.belt_dir_nr[belt_nr] = belt_dir_nr;
 726         }
 727         else    /* more than one switch -- set it like the first switch */
 728         {
 729           Feld[x][y] = Feld[x][y] - belt_dir_nr + game.belt_dir_nr[belt_nr];
 730         }
 731       }
 732       break;
 733
 734     case EL_SWITCHGATE_SWITCH_DOWN:     /* always start with same switch pos */
 735       if (init_game)
 736         Feld[x][y] = EL_SWITCHGATE_SWITCH_UP;
 737       break;
 738
 739     case EL_LIGHT_SWITCH_ACTIVE:
 740       if (init_game)
 741         game.light_time_left = level.time_light * FRAMES_PER_SECOND;
 742       break;
 743
 744     default:
 745       if (IS_CUSTOM_ELEMENT(element) && CAN_MOVE(element))
 746         InitMovDir(x, y);
 747       break;
 748   }
 749 }
 750
 751 void DrawGameDoorValues()
 752 {
 753   int i, j;
 754
 755   for (i=0; i<MAX_PLAYERS; i++)
 756     for (j=0; j<4; j++)
 757       if (stored_player[i].key[j])
 758         DrawMiniGraphicExt(drawto, DX_KEYS + j * MINI_TILEX, DY_KEYS,
 759                            el2edimg(EL_KEY_1 + j));
 760
 761   DrawText(DX + XX_EMERALDS, DY + YY_EMERALDS,
 762            int2str(local_player->gems_still_needed, 3), FONT_TEXT_2);
 763   DrawText(DX + XX_DYNAMITE, DY + YY_DYNAMITE,
 764            int2str(local_player->inventory_size, 3), FONT_TEXT_2);
 765   DrawText(DX + XX_SCORE, DY + YY_SCORE,
 766            int2str(local_player->score, 5), FONT_TEXT_2);
 767   DrawText(DX + XX_TIME, DY + YY_TIME,
 768            int2str(TimeLeft, 3), FONT_TEXT_2);
 769 }
 770
 771
 772 /*
 773   =============================================================================
 774   InitGameEngine()
 775   -----------------------------------------------------------------------------
 776   initialize game engine due to level / tape version number
 777   =============================================================================
 778 */
 779
 780 static void InitGameEngine()
 781 {
 782   int i, j, k;
 783
 784   /* set game engine from tape file when re-playing, else from level file */
 785   game.engine_version = (tape.playing ? tape.engine_version :
 786                          level.game_version);
 787
 788   /* dynamically adjust element properties according to game engine version */
 789   InitElementPropertiesEngine(game.engine_version);
 790
 791 #if 0
 792   printf("level %d: level version == %06d\n", level_nr, level.game_version);
 793   printf("          tape version == %06d [%s] [file: %06d]\n",
 794          tape.engine_version, (tape.playing ? "PLAYING" : "RECORDING"),
 795          tape.file_version);
 796   printf("       => game.engine_version == %06d\n", game.engine_version);
 797 #endif
 798
 799   /* ---------- initialize player's initial move delay --------------------- */
 800
 801   /* dynamically adjust player properties according to game engine version */
 802   game.initial_move_delay =
 803     (game.engine_version <= VERSION_IDENT(2,0,1) ? INITIAL_MOVE_DELAY_ON :
 804      INITIAL_MOVE_DELAY_OFF);
 805
 806   /* dynamically adjust player properties according to level information */
 807   game.initial_move_delay_value =
 808     (level.double_speed ? MOVE_DELAY_HIGH_SPEED : MOVE_DELAY_NORMAL_SPEED);
 809
 810   /* ---------- initialize changing elements ------------------------------- */
 811
 812   /* initialize changing elements information */
 813   for (i=0; i < MAX_NUM_ELEMENTS; i++)
 814   {
 815     struct ElementInfo *ei = &element_info[i];
 816
 817     /* this pointer might have been changed in the level editor */
 818     ei->change = &ei->change_page[0];
 819
 820     if (!IS_CUSTOM_ELEMENT(i))
 821     {
 822       ei->change->target_element = EL_EMPTY_SPACE;
 823       ei->change->delay_fixed = 0;
 824       ei->change->delay_random = 0;
 825       ei->change->delay_frames = 1;
 826     }
 827
 828     ei->change_events = CE_BITMASK_DEFAULT;
 829     for (j=0; j < NUM_CHANGE_EVENTS; j++)
 830     {
 831       ei->event_page_nr[j] = 0;
 832       ei->event_page[j] = &ei->change_page[0];
 833     }
 834   }
 835
 836   /* add changing elements from pre-defined list */
 837   for (i=0; change_delay_list[i].element != EL_UNDEFINED; i++)
 838   {
 839     struct ChangingElementInfo *ch_delay = &change_delay_list[i];
 840     struct ElementInfo *ei = &element_info[ch_delay->element];
 841
 842     ei->change->target_element       = ch_delay->target_element;
 843     ei->change->delay_fixed          = ch_delay->change_delay;
 844
 845     ei->change->pre_change_function  = ch_delay->pre_change_function;
 846     ei->change->change_function      = ch_delay->change_function;
 847     ei->change->post_change_function = ch_delay->post_change_function;
 848
 849     ei->change_events |= CH_EVENT_BIT(CE_DELAY);
 850   }
 851
 852 #if 1
 853   /* add change events from custom element configuration */
 854   for (i=0; i < NUM_CUSTOM_ELEMENTS; i++)
 855   {
 856     struct ElementInfo *ei = &element_info[EL_CUSTOM_START + i];
 857
 858     for (j=0; j < ei->num_change_pages; j++)
 859     {
 860       if (!ei->change_page[j].can_change)
 861         continue;
 862
 863       for (k=0; k < NUM_CHANGE_EVENTS; k++)
 864       {
 865         /* only add event page for the first page found with this event */
 866         if (ei->change_page[j].events & CH_EVENT_BIT(k) &&
 867             !(ei->change_events & CH_EVENT_BIT(k)))
 868         {
 869           ei->change_events |= CH_EVENT_BIT(k);
 870           ei->event_page_nr[k] = j;
 871           ei->event_page[k] = &ei->change_page[j];
 872         }
 873       }
 874     }
 875   }
 876
 877 #else
 878
 879   /* add change events from custom element configuration */
 880   for (i=0; i < NUM_CUSTOM_ELEMENTS; i++)
 881   {
 882     int element = EL_CUSTOM_START + i;
 883
 884     /* only add custom elements that change after fixed/random frame delay */
 885     if (CAN_CHANGE(element) && HAS_CHANGE_EVENT(element, CE_DELAY))
 886       element_info[element].change_events |= CH_EVENT_BIT(CE_DELAY);
 887   }
 888 #endif
 889
 890   /* ---------- initialize trigger events ---------------------------------- */
 891
 892   /* initialize trigger events information */
 893   for (i=0; i<MAX_NUM_ELEMENTS; i++)
 894     trigger_events[i] = EP_BITMASK_DEFAULT;
 895
 896 #if 1
 897   /* add trigger events from element change event properties */
 898   for (i=0; i<MAX_NUM_ELEMENTS; i++)
 899   {
 900     struct ElementInfo *ei = &element_info[i];
 901
 902     for (j=0; j < ei->num_change_pages; j++)
 903     {
 904       if (!ei->change_page[j].can_change)
 905         continue;
 906
 907       if (ei->change_page[j].events & CH_EVENT_BIT(CE_BY_OTHER_ACTION))
 908       {
 909         int trigger_element = ei->change_page[j].trigger_element;
 910
 911         trigger_events[trigger_element] |= ei->change_page[j].events;
 912       }
 913     }
 914   }
 915 #else
 916   /* add trigger events from element change event properties */
 917   for (i=0; i<MAX_NUM_ELEMENTS; i++)
 918     if (HAS_CHANGE_EVENT(i, CE_BY_OTHER_ACTION))
 919       trigger_events[element_info[i].change->trigger_element] |=
 920         element_info[i].change->events;
 921 #endif
 922
 923   /* ---------- initialize push delay -------------------------------------- */
 924
 925   /* initialize push delay values to default */
 926   for (i=0; i<MAX_NUM_ELEMENTS; i++)
 927   {
 928     if (!IS_CUSTOM_ELEMENT(i))
 929     {
 930       element_info[i].push_delay_fixed = 2;
 931       element_info[i].push_delay_random = 8;
 932     }
 933   }
 934
 935   /* set push delay value for certain elements from pre-defined list */
 936   for (i=0; push_delay_list[i].element != EL_UNDEFINED; i++)
 937   {
 938     int e = push_delay_list[i].element;
 939
 940     element_info[e].push_delay_fixed  = push_delay_list[i].push_delay_fixed;
 941     element_info[e].push_delay_random = push_delay_list[i].push_delay_random;
 942   }
 943
 944   /* ---------- initialize move stepsize ----------------------------------- */
 945
 946   /* initialize move stepsize values to default */
 947   for (i=0; i<MAX_NUM_ELEMENTS; i++)
 948     if (!IS_CUSTOM_ELEMENT(i))
 949       element_info[i].move_stepsize = MOVE_STEPSIZE_NORMAL;
 950
 951   /* set move stepsize value for certain elements from pre-defined list */
 952   for (i=0; move_stepsize_list[i].element != EL_UNDEFINED; i++)
 953   {
 954     int e = move_stepsize_list[i].element;
 955
 956     element_info[e].move_stepsize = move_stepsize_list[i].move_stepsize;
 957   }
 958
 959   /* ---------- initialize gem count --------------------------------------- */
 960
 961   /* initialize gem count values for each element */
 962   for (i=0; i<MAX_NUM_ELEMENTS; i++)
 963     if (!IS_CUSTOM_ELEMENT(i))
 964       element_info[i].collect_count = 0;
 965
 966   /* add gem count values for all elements from pre-defined list */
 967   for (i=0; collect_count_list[i].element != EL_UNDEFINED; i++)
 968     element_info[collect_count_list[i].element].collect_count =
 969       collect_count_list[i].count;
 970 }
 971
 972
 973 /*
 974   =============================================================================
 975   InitGame()
 976   -----------------------------------------------------------------------------
 977   initialize and start new game
 978   =============================================================================
 979 */
 980
 981 void InitGame()
 982 {
 983   boolean emulate_bd = TRUE;    /* unless non-BOULDERDASH elements found */
 984   boolean emulate_sb = TRUE;    /* unless non-SOKOBAN     elements found */
 985   boolean emulate_sp = TRUE;    /* unless non-SUPAPLEX    elements found */
 986   int i, j, x, y;
 987
 988   InitGameEngine();
 989
 990 #if 0
 991 #if DEBUG
 992 #if USE_NEW_AMOEBA_CODE
 993   printf("Using new amoeba code.\n");
 994 #else
 995   printf("Using old amoeba code.\n");
 996 #endif
 997 #endif
 998 #endif
 999
1000   /* don't play tapes over network */
1001   network_playing = (options.network && !tape.playing);
1002
1003   for (i=0; i<MAX_PLAYERS; i++)
1004   {
1005     struct PlayerInfo *player = &stored_player[i];
1006
1007     player->index_nr = i;
1008     player->element_nr = EL_PLAYER_1 + i;
1009
1010     player->present = FALSE;
1011     player->active = FALSE;
1012
1013     player->action = 0;
1014     player->effective_action = 0;
1015     player->programmed_action = 0;
1016
1017     player->score = 0;
1018     player->gems_still_needed = level.gems_needed;
1019     player->sokobanfields_still_needed = 0;
1020     player->lights_still_needed = 0;
1021     player->friends_still_needed = 0;
1022
1023     for (j=0; j<4; j++)
1024       player->key[j] = FALSE;
1025
1026     player->dynabomb_count = 0;
1027     player->dynabomb_size = 1;
1028     player->dynabombs_left = 0;
1029     player->dynabomb_xl = FALSE;
1030
1031     player->MovDir = MV_NO_MOVING;
1032     player->MovPos = 0;
1033     player->Pushing = FALSE;
1034     player->Switching = FALSE;
1035     player->GfxPos = 0;
1036     player->GfxDir = MV_NO_MOVING;
1037     player->GfxAction = ACTION_DEFAULT;
1038     player->Frame = 0;
1039     player->StepFrame = 0;
1040
1041     player->switch_x = -1;
1042     player->switch_y = -1;
1043
1044     player->use_murphy_graphic = FALSE;
1045     player->use_disk_red_graphic = FALSE;
1046
1047     player->actual_frame_counter = 0;
1048
1049     player->last_move_dir = MV_NO_MOVING;
1050
1051     player->is_moving = FALSE;
1052     player->is_waiting = FALSE;
1053     player->is_digging = FALSE;
1054     player->is_collecting = FALSE;
1055
1056     player->show_envelope = 0;
1057
1058     player->move_delay       = game.initial_move_delay;
1059     player->move_delay_value = game.initial_move_delay_value;
1060
1061     player->push_delay = 0;
1062     player->push_delay_value = 5;
1063
1064     player->snapped = FALSE;
1065
1066     player->last_jx = player->last_jy = 0;
1067     player->jx = player->jy = 0;
1068
1069     player->shield_normal_time_left = 0;
1070     player->shield_deadly_time_left = 0;
1071
1072     player->inventory_size = 0;
1073
1074     DigField(player, 0, 0, 0, 0, DF_NO_PUSH);
1075     SnapField(player, 0, 0);
1076
1077     player->LevelSolved = FALSE;
1078     player->GameOver = FALSE;
1079   }
1080
1081   network_player_action_received = FALSE;
1082
1083 #if defined(PLATFORM_UNIX)
1084   /* initial null action */
1085   if (network_playing)
1086     SendToServer_MovePlayer(MV_NO_MOVING);
1087 #endif
1088
1089   ZX = ZY = -1;
1090
1091   FrameCounter = 0;
1092   TimeFrames = 0;
1093   TimePlayed = 0;
1094   TimeLeft = level.time;
1095
1096   ScreenMovDir = MV_NO_MOVING;
1097   ScreenMovPos = 0;
1098   ScreenGfxPos = 0;
1099
1100   ScrollStepSize = 0;   /* will be correctly initialized by ScrollScreen() */
1101
1102   AllPlayersGone = FALSE;
1103
1104   game.yamyam_content_nr = 0;
1105   game.magic_wall_active = FALSE;
1106   game.magic_wall_time_left = 0;
1107   game.light_time_left = 0;
1108   game.timegate_time_left = 0;
1109   game.switchgate_pos = 0;
1110   game.balloon_dir = MV_NO_MOVING;
1111   game.gravity = level.initial_gravity;
1112   game.explosions_delayed = TRUE;
1113
1114   game.envelope_active = FALSE;
1115
1116   for (i=0; i<4; i++)
1117   {
1118     game.belt_dir[i] = MV_NO_MOVING;
1119     game.belt_dir_nr[i] = 3;            /* not moving, next moving left */
1120   }
1121
1122   for (i=0; i<MAX_NUM_AMOEBA; i++)
1123     AmoebaCnt[i] = AmoebaCnt2[i] = 0;
1124
1125   for (x=0; x<lev_fieldx; x++)
1126   {
1127     for (y=0; y<lev_fieldy; y++)
1128     {
1129       Feld[x][y] = level.field[x][y];
1130       MovPos[x][y] = MovDir[x][y] = MovDelay[x][y] = 0;
1131       ChangeDelay[x][y] = 0;
1132       ChangePage[x][y] = -1;
1133       Store[x][y] = Store2[x][y] = StorePlayer[x][y] = Back[x][y] = 0;
1134       AmoebaNr[x][y] = 0;
1135       JustStopped[x][y] = 0;
1136       Stop[x][y] = FALSE;
1137       Pushed[x][y] = FALSE;
1138
1139       Changed[x][y] = CE_BITMASK_DEFAULT;
1140       ChangeEvent[x][y] = CE_BITMASK_DEFAULT;
1141
1142       ExplodePhase[x][y] = 0;
1143       ExplodeField[x][y] = EX_NO_EXPLOSION;
1144
1145       GfxFrame[x][y] = 0;
1146       GfxAction[x][y] = ACTION_DEFAULT;
1147       GfxRandom[x][y] = INIT_GFX_RANDOM();
1148       GfxElement[x][y] = EL_UNDEFINED;
1149     }
1150   }
1151
1152   for(y=0; y<lev_fieldy; y++)
1153   {
1154     for(x=0; x<lev_fieldx; x++)
1155     {
1156       if (emulate_bd && !IS_BD_ELEMENT(Feld[x][y]))
1157         emulate_bd = FALSE;
1158       if (emulate_sb && !IS_SB_ELEMENT(Feld[x][y]))
1159         emulate_sb = FALSE;
1160       if (emulate_sp && !IS_SP_ELEMENT(Feld[x][y]))
1161         emulate_sp = FALSE;
1162
1163       InitField(x, y, TRUE);
1164     }
1165   }
1166
1167   InitBeltMovement();
1168
1169   game.emulation = (emulate_bd ? EMU_BOULDERDASH :
1170                     emulate_sb ? EMU_SOKOBAN :
1171                     emulate_sp ? EMU_SUPAPLEX : EMU_NONE);
1172
1173   /* correct non-moving belts to start moving left */
1174   for (i=0; i<4; i++)
1175     if (game.belt_dir[i] == MV_NO_MOVING)
1176       game.belt_dir_nr[i] = 3;          /* not moving, next moving left */
1177
1178   /* check if any connected player was not found in playfield */
1179   for (i=0; i<MAX_PLAYERS; i++)
1180   {
1181     struct PlayerInfo *player = &stored_player[i];
1182
1183     if (player->connected && !player->present)
1184     {
1185       for (j=0; j<MAX_PLAYERS; j++)
1186       {
1187         struct PlayerInfo *some_player = &stored_player[j];
1188         int jx = some_player->jx, jy = some_player->jy;
1189
1190         /* assign first free player found that is present in the playfield */
1191         if (some_player->present && !some_player->connected)
1192         {
1193           player->present = TRUE;
1194           player->active = TRUE;
1195           some_player->present = FALSE;
1196
1197           StorePlayer[jx][jy] = player->element_nr;
1198           player->jx = player->last_jx = jx;
1199           player->jy = player->last_jy = jy;
1200
1201           break;
1202         }
1203       }
1204     }
1205   }
1206
1207   if (tape.playing)
1208   {
1209     /* when playing a tape, eliminate all players who do not participate */
1210
1211     for (i=0; i<MAX_PLAYERS; i++)
1212     {
1213       if (stored_player[i].active && !tape.player_participates[i])
1214       {
1215         struct PlayerInfo *player = &stored_player[i];
1216         int jx = player->jx, jy = player->jy;
1217
1218         player->active = FALSE;
1219         StorePlayer[jx][jy] = 0;
1220         Feld[jx][jy] = EL_EMPTY;
1221       }
1222     }
1223   }
1224   else if (!options.network && !setup.team_mode)        /* && !tape.playing */
1225   {
1226     /* when in single player mode, eliminate all but the first active player */
1227
1228     for (i=0; i<MAX_PLAYERS; i++)
1229     {
1230       if (stored_player[i].active)
1231       {
1232         for (j=i+1; j<MAX_PLAYERS; j++)
1233         {
1234           if (stored_player[j].active)
1235           {
1236             struct PlayerInfo *player = &stored_player[j];
1237             int jx = player->jx, jy = player->jy;
1238
1239             player->active = FALSE;
1240             StorePlayer[jx][jy] = 0;
1241             Feld[jx][jy] = EL_EMPTY;
1242           }
1243         }
1244       }
1245     }
1246   }
1247
1248   /* when recording the game, store which players take part in the game */
1249   if (tape.recording)
1250   {
1251     for (i=0; i<MAX_PLAYERS; i++)
1252       if (stored_player[i].active)
1253         tape.player_participates[i] = TRUE;
1254   }
1255
1256   if (options.debug)
1257   {
1258     for (i=0; i<MAX_PLAYERS; i++)
1259     {
1260       struct PlayerInfo *player = &stored_player[i];
1261
1262       printf("Player %d: present == %d, connected == %d, active == %d.\n",
1263              i+1,
1264              player->present,
1265              player->connected,
1266              player->active);
1267       if (local_player == player)
1268         printf("Player  %d is local player.\n", i+1);
1269     }
1270   }
1271
1272   if (BorderElement == EL_EMPTY)
1273   {
1274     SBX_Left = 0;
1275     SBX_Right = lev_fieldx - SCR_FIELDX;
1276     SBY_Upper = 0;
1277     SBY_Lower = lev_fieldy - SCR_FIELDY;
1278   }
1279   else
1280   {
1281     SBX_Left = -1;
1282     SBX_Right = lev_fieldx - SCR_FIELDX + 1;
1283     SBY_Upper = -1;
1284     SBY_Lower = lev_fieldy - SCR_FIELDY + 1;
1285   }
1286
1287   if (lev_fieldx + (SBX_Left == -1 ? 2 : 0) <= SCR_FIELDX)
1288     SBX_Left = SBX_Right = -1 * (SCR_FIELDX - lev_fieldx) / 2;
1289
1290   if (lev_fieldy + (SBY_Upper == -1 ? 2 : 0) <= SCR_FIELDY)
1291     SBY_Upper = SBY_Lower = -1 * (SCR_FIELDY - lev_fieldy) / 2;
1292
1293   /* if local player not found, look for custom element that might create
1294      the player (make some assumptions about the right custom element) */
1295   if (!local_player->present)
1296   {
1297     int start_x = 0, start_y = 0;
1298     int found_rating = 0;
1299     int found_element = EL_UNDEFINED;
1300
1301     for(y=0; y < lev_fieldy; y++) for(x=0; x < lev_fieldx; x++)
1302     {
1303       int element = Feld[x][y];
1304       int content;
1305       int xx, yy;
1306       boolean is_player;
1307
1308       if (!IS_CUSTOM_ELEMENT(element))
1309         continue;
1310
1311       if (CAN_CHANGE(element))
1312       {
1313         for (i=0; i < element_info[element].num_change_pages; i++)
1314         {
1315           content = element_info[element].change_page[i].target_element;
1316           is_player = ELEM_IS_PLAYER(content);
1317
1318           if (is_player && (found_rating < 3 || element < found_element))
1319           {
1320             start_x = x;
1321             start_y = y;
1322
1323             found_rating = 3;
1324             found_element = element;
1325           }
1326         }
1327       }
1328
1329       for(yy=0; yy < 3; yy++) for(xx=0; xx < 3; xx++)
1330       {
1331         content = element_info[element].content[xx][yy];
1332         is_player = ELEM_IS_PLAYER(content);
1333
1334         if (is_player && (found_rating < 2 || element < found_element))
1335         {
1336           start_x = x + xx - 1;
1337           start_y = y + yy - 1;
1338
1339           found_rating = 2;
1340           found_element = element;
1341         }
1342
1343         if (!CAN_CHANGE(element))
1344           continue;
1345
1346         for (i=0; i < element_info[element].num_change_pages; i++)
1347         {
1348           content = element_info[element].change_page[i].content[xx][yy];
1349           is_player = ELEM_IS_PLAYER(content);
1350
1351           if (is_player && (found_rating < 1 || element < found_element))
1352           {
1353             start_x = x + xx - 1;
1354             start_y = y + yy - 1;
1355
1356             found_rating = 1;
1357             found_element = element;
1358           }
1359         }
1360       }
1361     }
1362
1363     scroll_x = (start_x < SBX_Left  + MIDPOSX ? SBX_Left :
1364                 start_x > SBX_Right + MIDPOSX ? SBX_Right :
1365                 start_x - MIDPOSX);
1366
1367     scroll_y = (start_y < SBY_Upper + MIDPOSY ? SBY_Upper :
1368                 start_y > SBY_Lower + MIDPOSY ? SBY_Lower :
1369                 start_y - MIDPOSY);
1370   }
1371   else
1372   {
1373 #if 1
1374     scroll_x = (local_player->jx < SBX_Left  + MIDPOSX ? SBX_Left :
1375                 local_player->jx > SBX_Right + MIDPOSX ? SBX_Right :
1376                 local_player->jx - MIDPOSX);
1377
1378     scroll_y = (local_player->jy < SBY_Upper + MIDPOSY ? SBY_Upper :
1379                 local_player->jy > SBY_Lower + MIDPOSY ? SBY_Lower :
1380                 local_player->jy - MIDPOSY);
1381 #else
1382     scroll_x = SBX_Left;
1383     scroll_y = SBY_Upper;
1384     if (local_player->jx >= SBX_Left + MIDPOSX)
1385       scroll_x = (local_player->jx <= SBX_Right + MIDPOSX ?
1386                   local_player->jx - MIDPOSX :
1387                   SBX_Right);
1388     if (local_player->jy >= SBY_Upper + MIDPOSY)
1389       scroll_y = (local_player->jy <= SBY_Lower + MIDPOSY ?
1390                   local_player->jy - MIDPOSY :
1391                   SBY_Lower);
1392 #endif
1393   }
1394
1395   CloseDoor(DOOR_CLOSE_1);
1396
1397   DrawLevel();
1398   DrawAllPlayers();
1399
1400   /* after drawing the level, correct some elements */
1401   if (game.timegate_time_left == 0)
1402     CloseAllOpenTimegates();
1403
1404   if (setup.soft_scrolling)
1405     BlitBitmap(fieldbuffer, backbuffer, FX, FY, SXSIZE, SYSIZE, SX, SY);
1406
1407   redraw_mask |= REDRAW_FROM_BACKBUFFER;
1408   FadeToFront();
1409
1410   /* copy default game door content to main double buffer */
1411   BlitBitmap(graphic_info[IMG_GLOBAL_DOOR].bitmap, drawto,
1412              DOOR_GFX_PAGEX5, DOOR_GFX_PAGEY1, DXSIZE, DYSIZE, DX, DY);
1413
1414   if (level_nr < 100)
1415     DrawText(DX + XX_LEVEL, DY + YY_LEVEL, int2str(level_nr, 2), FONT_TEXT_2);
1416   else
1417   {
1418     DrawTextExt(drawto, DX + XX_EMERALDS, DY + YY_EMERALDS,
1419                 int2str(level_nr, 3), FONT_LEVEL_NUMBER, BLIT_OPAQUE);
1420     BlitBitmap(drawto, drawto,
1421                DX + XX_EMERALDS, DY + YY_EMERALDS + 1,
1422                getFontWidth(FONT_LEVEL_NUMBER) * 3,
1423                getFontHeight(FONT_LEVEL_NUMBER) - 1,
1424                DX + XX_LEVEL - 1, DY + YY_LEVEL + 1);
1425   }
1426
1427   DrawGameDoorValues();
1428
1429   UnmapGameButtons();
1430   UnmapTapeButtons();
1431   game_gadget[SOUND_CTRL_ID_MUSIC]->checked = setup.sound_music;
1432   game_gadget[SOUND_CTRL_ID_LOOPS]->checked = setup.sound_loops;
1433   game_gadget[SOUND_CTRL_ID_SIMPLE]->checked = setup.sound_simple;
1434   MapGameButtons();
1435   MapTapeButtons();
1436
1437   /* copy actual game door content to door double buffer for OpenDoor() */
1438   BlitBitmap(drawto, bitmap_db_door,
1439              DX, DY, DXSIZE, DYSIZE, DOOR_GFX_PAGEX1, DOOR_GFX_PAGEY1);
1440
1441   OpenDoor(DOOR_OPEN_ALL);
1442
1443   PlaySoundStereo(SND_GAME_STARTING, SOUND_MIDDLE);
1444   if (setup.sound_music)
1445     PlayMusic(level_nr);
1446
1447   KeyboardAutoRepeatOffUnlessAutoplay();
1448
1449   if (options.debug)
1450   {
1451     for (i=0; i<4; i++)
1452       printf("Player %d %sactive.\n",
1453              i + 1, (stored_player[i].active ? "" : "not "));
1454   }
1455 }
1456
1457 void InitMovDir(int x, int y)
1458 {
1459   int i, element = Feld[x][y];
1460   static int xy[4][2] =
1461   {
1462     {  0, +1 },
1463     { +1,  0 },
1464     {  0, -1 },
1465     { -1,  0 }
1466   };
1467   static int direction[3][4] =
1468   {
1469     { MV_RIGHT, MV_UP,   MV_LEFT,  MV_DOWN },
1470     { MV_LEFT,  MV_DOWN, MV_RIGHT, MV_UP },
1471     { MV_LEFT,  MV_RIGHT, MV_UP, MV_DOWN }
1472   };
1473
1474   switch(element)
1475   {
1476     case EL_BUG_RIGHT:
1477     case EL_BUG_UP:
1478     case EL_BUG_LEFT:
1479     case EL_BUG_DOWN:
1480       Feld[x][y] = EL_BUG;
1481       MovDir[x][y] = direction[0][element - EL_BUG_RIGHT];
1482       break;
1483
1484     case EL_SPACESHIP_RIGHT:
1485     case EL_SPACESHIP_UP:
1486     case EL_SPACESHIP_LEFT:
1487     case EL_SPACESHIP_DOWN:
1488       Feld[x][y] = EL_SPACESHIP;
1489       MovDir[x][y] = direction[0][element - EL_SPACESHIP_RIGHT];
1490       break;
1491
1492     case EL_BD_BUTTERFLY_RIGHT:
1493     case EL_BD_BUTTERFLY_UP:
1494     case EL_BD_BUTTERFLY_LEFT:
1495     case EL_BD_BUTTERFLY_DOWN:
1496       Feld[x][y] = EL_BD_BUTTERFLY;
1497       MovDir[x][y] = direction[0][element - EL_BD_BUTTERFLY_RIGHT];
1498       break;
1499
1500     case EL_BD_FIREFLY_RIGHT:
1501     case EL_BD_FIREFLY_UP:
1502     case EL_BD_FIREFLY_LEFT:
1503     case EL_BD_FIREFLY_DOWN:
1504       Feld[x][y] = EL_BD_FIREFLY;
1505       MovDir[x][y] = direction[0][element - EL_BD_FIREFLY_RIGHT];
1506       break;
1507
1508     case EL_PACMAN_RIGHT:
1509     case EL_PACMAN_UP:
1510     case EL_PACMAN_LEFT:
1511     case EL_PACMAN_DOWN:
1512       Feld[x][y] = EL_PACMAN;
1513       MovDir[x][y] = direction[0][element - EL_PACMAN_RIGHT];
1514       break;
1515
1516     case EL_SP_SNIKSNAK:
1517       MovDir[x][y] = MV_UP;
1518       break;
1519
1520     case EL_SP_ELECTRON:
1521       MovDir[x][y] = MV_LEFT;
1522       break;
1523
1524     case EL_MOLE_LEFT:
1525     case EL_MOLE_RIGHT:
1526     case EL_MOLE_UP:
1527     case EL_MOLE_DOWN:
1528       Feld[x][y] = EL_MOLE;
1529       MovDir[x][y] = direction[2][element - EL_MOLE_LEFT];
1530       break;
1531
1532     default:
1533       if (IS_CUSTOM_ELEMENT(element))
1534       {
1535         if (element_info[element].move_direction_initial != MV_NO_MOVING)
1536           MovDir[x][y] = element_info[element].move_direction_initial;
1537         else if (element_info[element].move_pattern == MV_ALL_DIRECTIONS ||
1538                  element_info[element].move_pattern == MV_TURNING_LEFT ||
1539                  element_info[element].move_pattern == MV_TURNING_RIGHT)
1540           MovDir[x][y] = 1 << RND(4);
1541         else if (element_info[element].move_pattern == MV_HORIZONTAL)
1542           MovDir[x][y] = (RND(2) ? MV_LEFT : MV_RIGHT);
1543         else if (element_info[element].move_pattern == MV_VERTICAL)
1544           MovDir[x][y] = (RND(2) ? MV_UP : MV_DOWN);
1545         else if (element_info[element].move_pattern & MV_ANY_DIRECTION)
1546           MovDir[x][y] = element_info[element].move_pattern;
1547         else if (element_info[element].move_pattern == MV_ALONG_LEFT_SIDE ||
1548                  element_info[element].move_pattern == MV_ALONG_RIGHT_SIDE)
1549         {
1550           for (i=0; i<4; i++)
1551           {
1552             int x1 = x + xy[i][0];
1553             int y1 = y + xy[i][1];
1554
1555             if (!IN_LEV_FIELD(x1, y1) || !IS_FREE(x1, y1))
1556             {
1557               if (element_info[element].move_pattern == MV_ALONG_RIGHT_SIDE)
1558                 MovDir[x][y] = direction[0][i];
1559               else
1560                 MovDir[x][y] = direction[1][i];
1561
1562               break;
1563             }
1564           }
1565         }
1566       }
1567       else
1568       {
1569         MovDir[x][y] = 1 << RND(4);
1570
1571         if (element != EL_BUG &&
1572             element != EL_SPACESHIP &&
1573             element != EL_BD_BUTTERFLY &&
1574             element != EL_BD_FIREFLY)
1575           break;
1576
1577         for (i=0; i<4; i++)
1578         {
1579           int x1 = x + xy[i][0];
1580           int y1 = y + xy[i][1];
1581
1582           if (!IN_LEV_FIELD(x1, y1) || !IS_FREE(x1, y1))
1583           {
1584             if (element == EL_BUG || element == EL_BD_BUTTERFLY)
1585             {
1586               MovDir[x][y] = direction[0][i];
1587               break;
1588             }
1589             else if (element == EL_SPACESHIP || element == EL_BD_FIREFLY ||
1590                      element == EL_SP_SNIKSNAK || element == EL_SP_ELECTRON)
1591             {
1592               MovDir[x][y] = direction[1][i];
1593               break;
1594             }
1595           }
1596         }
1597       }
1598       break;
1599   }
1600 }
1601
1602 void InitAmoebaNr(int x, int y)
1603 {
1604   int i;
1605   int group_nr = AmoebeNachbarNr(x, y);
1606
1607   if (group_nr == 0)
1608   {
1609     for (i=1; i<MAX_NUM_AMOEBA; i++)
1610     {
1611       if (AmoebaCnt[i] == 0)
1612       {
1613         group_nr = i;
1614         break;
1615       }
1616     }
1617   }
1618
1619   AmoebaNr[x][y] = group_nr;
1620   AmoebaCnt[group_nr]++;
1621   AmoebaCnt2[group_nr]++;
1622 }
1623
1624 void GameWon()
1625 {
1626   int hi_pos;
1627   boolean raise_level = FALSE;
1628
1629   if (local_player->MovPos)
1630     return;
1631
1632 #if 1
1633   if (tape.auto_play)           /* tape might already be stopped here */
1634     tape.auto_play_level_solved = TRUE;
1635 #else
1636   if (tape.playing && tape.auto_play)
1637     tape.auto_play_level_solved = TRUE;
1638 #endif
1639
1640   local_player->LevelSolved = FALSE;
1641
1642   PlaySoundStereo(SND_GAME_WINNING, SOUND_MIDDLE);
1643
1644   if (TimeLeft)
1645   {
1646     if (!tape.playing && setup.sound_loops)
1647       PlaySoundExt(SND_GAME_LEVELTIME_BONUS, SOUND_MAX_VOLUME, SOUND_MIDDLE,
1648                    SND_CTRL_PLAY_LOOP);
1649
1650     while (TimeLeft > 0)
1651     {
1652       if (!tape.playing && !setup.sound_loops)
1653         PlaySoundStereo(SND_GAME_LEVELTIME_BONUS, SOUND_MIDDLE);
1654       if (TimeLeft > 0 && !(TimeLeft % 10))
1655         RaiseScore(level.score[SC_TIME_BONUS]);
1656       if (TimeLeft > 100 && !(TimeLeft % 10))
1657         TimeLeft -= 10;
1658       else
1659         TimeLeft--;
1660       DrawText(DX_TIME, DY_TIME, int2str(TimeLeft, 3), FONT_TEXT_2);
1661       BackToFront();
1662
1663       if (!tape.playing)
1664         Delay(10);
1665     }
1666
1667     if (!tape.playing && setup.sound_loops)
1668       StopSound(SND_GAME_LEVELTIME_BONUS);
1669   }
1670   else if (level.time == 0)             /* level without time limit */
1671   {
1672     if (!tape.playing && setup.sound_loops)
1673       PlaySoundExt(SND_GAME_LEVELTIME_BONUS, SOUND_MAX_VOLUME, SOUND_MIDDLE,
1674                    SND_CTRL_PLAY_LOOP);
1675
1676     while (TimePlayed < 999)
1677     {
1678       if (!tape.playing && !setup.sound_loops)
1679         PlaySoundStereo(SND_GAME_LEVELTIME_BONUS, SOUND_MIDDLE);
1680       if (TimePlayed < 999 && !(TimePlayed % 10))
1681         RaiseScore(level.score[SC_TIME_BONUS]);
1682       if (TimePlayed < 900 && !(TimePlayed % 10))
1683         TimePlayed += 10;
1684       else
1685         TimePlayed++;
1686       DrawText(DX_TIME, DY_TIME, int2str(TimePlayed, 3), FONT_TEXT_2);
1687       BackToFront();
1688
1689       if (!tape.playing)
1690         Delay(10);
1691     }
1692
1693     if (!tape.playing && setup.sound_loops)
1694       StopSound(SND_GAME_LEVELTIME_BONUS);
1695   }
1696
1697   /* close exit door after last player */
1698   if ((Feld[ExitX][ExitY] == EL_EXIT_OPEN ||
1699        Feld[ExitX][ExitY] == EL_SP_EXIT_OPEN) && AllPlayersGone)
1700   {
1701     int element = Feld[ExitX][ExitY];
1702
1703     Feld[ExitX][ExitY] = (element == EL_EXIT_OPEN ? EL_EXIT_CLOSING :
1704                           EL_SP_EXIT_CLOSING);
1705
1706     PlaySoundLevelElementAction(ExitX, ExitY, element, ACTION_CLOSING);
1707   }
1708
1709   /* Hero disappears */
1710   DrawLevelField(ExitX, ExitY);
1711   BackToFront();
1712
1713   if (tape.playing)
1714     return;
1715
1716   CloseDoor(DOOR_CLOSE_1);
1717
1718   if (tape.recording)
1719   {
1720     TapeStop();
1721     SaveTape(tape.level_nr);            /* Ask to save tape */
1722   }
1723
1724   if (level_nr == leveldir_current->handicap_level)
1725   {
1726     leveldir_current->handicap_level++;
1727     SaveLevelSetup_SeriesInfo();
1728   }
1729
1730   if (level_editor_test_game)
1731     local_player->score = -1;   /* no highscore when playing from editor */
1732   else if (level_nr < leveldir_current->last_level)
1733     raise_level = TRUE;         /* advance to next level */
1734
1735   if ((hi_pos = NewHiScore()) >= 0)
1736   {
1737     game_status = GAME_MODE_SCORES;
1738     DrawHallOfFame(hi_pos);
1739     if (raise_level)
1740     {
1741       level_nr++;
1742       TapeErase();
1743     }
1744   }
1745   else
1746   {
1747     game_status = GAME_MODE_MAIN;
1748     if (raise_level)
1749     {
1750       level_nr++;
1751       TapeErase();
1752     }
1753     DrawMainMenu();
1754   }
1755
1756   BackToFront();
1757 }
1758
1759 int NewHiScore()
1760 {
1761   int k, l;
1762   int position = -1;
1763
1764   LoadScore(level_nr);
1765
1766   if (strcmp(setup.player_name, EMPTY_PLAYER_NAME) == 0 ||
1767       local_player->score < highscore[MAX_SCORE_ENTRIES - 1].Score)
1768     return -1;
1769
1770   for (k=0; k<MAX_SCORE_ENTRIES; k++)
1771   {
1772     if (local_player->score > highscore[k].Score)
1773     {
1774       /* player has made it to the hall of fame */
1775
1776       if (k < MAX_SCORE_ENTRIES - 1)
1777       {
1778         int m = MAX_SCORE_ENTRIES - 1;
1779
1780 #ifdef ONE_PER_NAME
1781         for (l=k; l<MAX_SCORE_ENTRIES; l++)
1782           if (!strcmp(setup.player_name, highscore[l].Name))
1783             m = l;
1784         if (m == k)     /* player's new highscore overwrites his old one */
1785           goto put_into_list;
1786 #endif
1787
1788         for (l=m; l>k; l--)
1789         {
1790           strcpy(highscore[l].Name, highscore[l - 1].Name);
1791           highscore[l].Score = highscore[l - 1].Score;
1792         }
1793       }
1794
1795 #ifdef ONE_PER_NAME
1796       put_into_list:
1797 #endif
1798       strncpy(highscore[k].Name, setup.player_name, MAX_PLAYER_NAME_LEN);
1799       highscore[k].Name[MAX_PLAYER_NAME_LEN] = '\0';
1800       highscore[k].Score = local_player->score;
1801       position = k;
1802       break;
1803     }
1804
1805 #ifdef ONE_PER_NAME
1806     else if (!strncmp(setup.player_name, highscore[k].Name,
1807                       MAX_PLAYER_NAME_LEN))
1808       break;    /* player already there with a higher score */
1809 #endif
1810
1811   }
1812
1813   if (position >= 0)
1814     SaveScore(level_nr);
1815
1816   return position;
1817 }
1818
1819 void InitPlayerGfxAnimation(struct PlayerInfo *player, int action, int dir)
1820 {
1821   if (player->GfxAction != action || player->GfxDir != dir)
1822   {
1823 #if 0
1824     printf("Player frame reset! (%d => %d, %d => %d)\n",
1825            player->GfxAction, action, player->GfxDir, dir);
1826 #endif
1827
1828     player->GfxAction = action;
1829     player->GfxDir = dir;
1830     player->Frame = 0;
1831     player->StepFrame = 0;
1832   }
1833 }
1834
1835 static void ResetRandomAnimationValue(int x, int y)
1836 {
1837   GfxRandom[x][y] = INIT_GFX_RANDOM();
1838 }
1839
1840 static void ResetGfxAnimation(int x, int y)
1841 {
1842   GfxFrame[x][y] = 0;
1843   GfxAction[x][y] = ACTION_DEFAULT;
1844 }
1845
1846 void InitMovingField(int x, int y, int direction)
1847 {
1848   int element = Feld[x][y];
1849   int dx = (direction == MV_LEFT ? -1 : direction == MV_RIGHT ? +1 : 0);
1850   int dy = (direction == MV_UP   ? -1 : direction == MV_DOWN  ? +1 : 0);
1851   int newx = x + dx;
1852   int newy = y + dy;
1853
1854   if (!JustStopped[x][y] || direction != MovDir[x][y])
1855     ResetGfxAnimation(x, y);
1856
1857   MovDir[newx][newy] = MovDir[x][y] = direction;
1858
1859   if (Feld[newx][newy] == EL_EMPTY)
1860     Feld[newx][newy] = EL_BLOCKED;
1861
1862   if (direction == MV_DOWN && CAN_FALL(element))
1863     GfxAction[x][y] = ACTION_FALLING;
1864   else
1865     GfxAction[x][y] = ACTION_MOVING;
1866
1867   GfxFrame[newx][newy] = GfxFrame[x][y];
1868   GfxAction[newx][newy] = GfxAction[x][y];
1869   GfxRandom[newx][newy] = GfxRandom[x][y];
1870 }
1871
1872 void Moving2Blocked(int x, int y, int *goes_to_x, int *goes_to_y)
1873 {
1874   int direction = MovDir[x][y];
1875   int newx = x + (direction == MV_LEFT ? -1 : direction == MV_RIGHT ? +1 : 0);
1876   int newy = y + (direction == MV_UP   ? -1 : direction == MV_DOWN  ? +1 : 0);
1877
1878   *goes_to_x = newx;
1879   *goes_to_y = newy;
1880 }
1881
1882 void Blocked2Moving(int x, int y, int *comes_from_x, int *comes_from_y)
1883 {
1884   int oldx = x, oldy = y;
1885   int direction = MovDir[x][y];
1886
1887   if (direction == MV_LEFT)
1888     oldx++;
1889   else if (direction == MV_RIGHT)
1890     oldx--;
1891   else if (direction == MV_UP)
1892     oldy++;
1893   else if (direction == MV_DOWN)
1894     oldy--;
1895
1896   *comes_from_x = oldx;
1897   *comes_from_y = oldy;
1898 }
1899
1900 int MovingOrBlocked2Element(int x, int y)
1901 {
1902   int element = Feld[x][y];
1903
1904   if (element == EL_BLOCKED)
1905   {
1906     int oldx, oldy;
1907
1908     Blocked2Moving(x, y, &oldx, &oldy);
1909     return Feld[oldx][oldy];
1910   }
1911   else
1912     return element;
1913 }
1914
1915 static int MovingOrBlocked2ElementIfNotLeaving(int x, int y)
1916 {
1917   /* like MovingOrBlocked2Element(), but if element is moving
1918      and (x,y) is the field the moving element is just leaving,
1919      return EL_BLOCKED instead of the element value */
1920   int element = Feld[x][y];
1921
1922   if (IS_MOVING(x, y))
1923   {
1924     if (element == EL_BLOCKED)
1925     {
1926       int oldx, oldy;
1927
1928       Blocked2Moving(x, y, &oldx, &oldy);
1929       return Feld[oldx][oldy];
1930     }
1931     else
1932       return EL_BLOCKED;
1933   }
1934   else
1935     return element;
1936 }
1937
1938 static void RemoveField(int x, int y)
1939 {
1940   Feld[x][y] = EL_EMPTY;
1941
1942   MovPos[x][y] = 0;
1943   MovDir[x][y] = 0;
1944   MovDelay[x][y] = 0;
1945
1946   AmoebaNr[x][y] = 0;
1947   ChangeDelay[x][y] = 0;
1948   ChangePage[x][y] = -1;
1949   Pushed[x][y] = FALSE;
1950
1951   GfxElement[x][y] = EL_UNDEFINED;
1952   GfxAction[x][y] = ACTION_DEFAULT;
1953 }
1954
1955 void RemoveMovingField(int x, int y)
1956 {
1957   int oldx = x, oldy = y, newx = x, newy = y;
1958   int element = Feld[x][y];
1959   int next_element = EL_UNDEFINED;
1960
1961   if (element != EL_BLOCKED && !IS_MOVING(x, y))
1962     return;
1963
1964   if (IS_MOVING(x, y))
1965   {
1966     Moving2Blocked(x, y, &newx, &newy);
1967     if (Feld[newx][newy] != EL_BLOCKED)
1968       return;
1969   }
1970   else if (element == EL_BLOCKED)
1971   {
1972     Blocked2Moving(x, y, &oldx, &oldy);
1973     if (!IS_MOVING(oldx, oldy))
1974       return;
1975   }
1976
1977   if (element == EL_BLOCKED &&
1978       (Feld[oldx][oldy] == EL_QUICKSAND_EMPTYING ||
1979        Feld[oldx][oldy] == EL_MAGIC_WALL_EMPTYING ||
1980        Feld[oldx][oldy] == EL_BD_MAGIC_WALL_EMPTYING ||
1981        Feld[oldx][oldy] == EL_AMOEBA_DROPPING))
1982     next_element = get_next_element(Feld[oldx][oldy]);
1983
1984   RemoveField(oldx, oldy);
1985   RemoveField(newx, newy);
1986
1987   Store[oldx][oldy] = Store2[oldx][oldy] = 0;
1988
1989   if (next_element != EL_UNDEFINED)
1990     Feld[oldx][oldy] = next_element;
1991
1992   DrawLevelField(oldx, oldy);
1993   DrawLevelField(newx, newy);
1994 }
1995
1996 void DrawDynamite(int x, int y)
1997 {
1998   int sx = SCREENX(x), sy = SCREENY(y);
1999   int graphic = el2img(Feld[x][y]);
2000   int frame;
2001
2002   if (!IN_SCR_FIELD(sx, sy) || IS_PLAYER(x, y))
2003     return;
2004
2005   if (IS_WALKABLE_INSIDE(Back[x][y]))
2006     return;
2007
2008   if (Back[x][y])
2009     DrawGraphic(sx, sy, el2img(Back[x][y]), 0);
2010   else if (Store[x][y])
2011     DrawGraphic(sx, sy, el2img(Store[x][y]), 0);
2012
2013   frame = getGraphicAnimationFrame(graphic, GfxFrame[x][y]);
2014
2015 #if 1
2016   if (Back[x][y] || Store[x][y])
2017     DrawGraphicThruMask(sx, sy, graphic, frame);
2018   else
2019     DrawGraphic(sx, sy, graphic, frame);
2020 #else
2021   if (game.emulation == EMU_SUPAPLEX)
2022     DrawGraphic(sx, sy, IMG_SP_DISK_RED, frame);
2023   else if (Store[x][y])
2024     DrawGraphicThruMask(sx, sy, graphic, frame);
2025   else
2026     DrawGraphic(sx, sy, graphic, frame);
2027 #endif
2028 }
2029
2030 void CheckDynamite(int x, int y)
2031 {
2032   if (MovDelay[x][y] != 0)      /* dynamite is still waiting to explode */
2033   {
2034     MovDelay[x][y]--;
2035
2036     if (MovDelay[x][y] != 0)
2037     {
2038       DrawDynamite(x, y);
2039       PlaySoundLevelActionIfLoop(x, y, ACTION_ACTIVE);
2040
2041       return;
2042     }
2043   }
2044
2045 #if 1
2046   StopSoundLevelActionIfLoop(x, y, ACTION_ACTIVE);
2047 #else
2048   if (Feld[x][y] == EL_DYNAMITE_ACTIVE ||
2049       Feld[x][y] == EL_SP_DISK_RED_ACTIVE)
2050     StopSound(SND_DYNAMITE_ACTIVE);
2051   else
2052     StopSound(SND_DYNABOMB_ACTIVE);
2053 #endif
2054
2055   Bang(x, y);
2056 }
2057
2058 void RelocatePlayer(int x, int y, int element)
2059 {
2060   struct PlayerInfo *player = &stored_player[element - EL_PLAYER_1];
2061
2062 #if 1
2063   RemoveField(x, y);            /* temporarily remove newly placed player */
2064   DrawLevelField(x, y);
2065 #endif
2066
2067   if (player->present)
2068   {
2069     while (player->MovPos)
2070     {
2071       ScrollPlayer(player, SCROLL_GO_ON);
2072       ScrollScreen(NULL, SCROLL_GO_ON);
2073       FrameCounter++;
2074
2075       DrawPlayer(player);
2076
2077       BackToFront();
2078       Delay(GAME_FRAME_DELAY);
2079     }
2080
2081     DrawPlayer(player);         /* needed here only to cleanup last field */
2082     DrawLevelField(player->jx, player->jy);     /* remove player graphic */
2083
2084     player->is_moving = FALSE;
2085   }
2086
2087   Feld[x][y] = element;
2088   InitPlayerField(x, y, element, TRUE);
2089
2090   if (player == local_player)
2091   {
2092     int scroll_xx = -999, scroll_yy = -999;
2093
2094     while (scroll_xx != scroll_x || scroll_yy != scroll_y)
2095     {
2096       int dx = 0, dy = 0;
2097       int fx = FX, fy = FY;
2098
2099       scroll_xx = (local_player->jx < SBX_Left  + MIDPOSX ? SBX_Left :
2100                    local_player->jx > SBX_Right + MIDPOSX ? SBX_Right :
2101                    local_player->jx - MIDPOSX);
2102
2103       scroll_yy = (local_player->jy < SBY_Upper + MIDPOSY ? SBY_Upper :
2104                    local_player->jy > SBY_Lower + MIDPOSY ? SBY_Lower :
2105                    local_player->jy - MIDPOSY);
2106
2107       dx = (scroll_xx < scroll_x ? +1 : scroll_xx > scroll_x ? -1 : 0);
2108       dy = (scroll_yy < scroll_y ? +1 : scroll_yy > scroll_y ? -1 : 0);
2109
2110       scroll_x -= dx;
2111       scroll_y -= dy;
2112
2113       fx += dx * TILEX / 2;
2114       fy += dy * TILEY / 2;
2115
2116       ScrollLevel(dx, dy);
2117       DrawAllPlayers();
2118
2119       /* scroll in two steps of half tile size to make things smoother */
2120       BlitBitmap(drawto_field, window, fx, fy, SXSIZE, SYSIZE, SX, SY);
2121       FlushDisplay();
2122       Delay(GAME_FRAME_DELAY);
2123
2124       /* scroll second step to align at full tile size */
2125       BackToFront();
2126       Delay(GAME_FRAME_DELAY);
2127     }
2128   }
2129 }
2130
2131 void Explode(int ex, int ey, int phase, int mode)
2132 {
2133   int x, y;
2134   int num_phase = 9;
2135   int delay = (game.emulation == EMU_SUPAPLEX ? 3 : 2);
2136   int last_phase = num_phase * delay;
2137   int half_phase = (num_phase / 2) * delay;
2138   int first_phase_after_start = EX_PHASE_START + 1;
2139
2140   if (game.explosions_delayed)
2141   {
2142     ExplodeField[ex][ey] = mode;
2143     return;
2144   }
2145
2146   if (phase == EX_PHASE_START)          /* initialize 'Store[][]' field */
2147   {
2148     int center_element = Feld[ex][ey];
2149
2150 #if 0
2151     /* --- This is only really needed (and now handled) in "Impact()". --- */
2152     /* do not explode moving elements that left the explode field in time */
2153     if (game.engine_version >= RELEASE_IDENT(2,2,0,7) &&
2154         center_element == EL_EMPTY && (mode == EX_NORMAL || mode == EX_CENTER))
2155       return;
2156 #endif
2157
2158     if (mode == EX_NORMAL || mode == EX_CENTER)
2159       PlaySoundLevelAction(ex, ey, ACTION_EXPLODING);
2160
2161     /* remove things displayed in background while burning dynamite */
2162     if (Back[ex][ey] != EL_EMPTY && !IS_INDESTRUCTIBLE(Back[ex][ey]))
2163       Back[ex][ey] = 0;
2164
2165     if (IS_MOVING(ex, ey) || IS_BLOCKED(ex, ey))
2166     {
2167       /* put moving element to center field (and let it explode there) */
2168       center_element = MovingOrBlocked2Element(ex, ey);
2169       RemoveMovingField(ex, ey);
2170       Feld[ex][ey] = center_element;
2171     }
2172
2173     for (y = ey - 1; y <= ey + 1; y++) for(x = ex - 1; x <= ex + 1; x++)
2174     {
2175       int xx = x - ex + 1;
2176       int yy = y - ey + 1;
2177       int element;
2178
2179       if (!IN_LEV_FIELD(x, y) ||
2180           ((mode != EX_NORMAL || center_element == EL_AMOEBA_TO_DIAMOND) &&
2181            (x != ex || y != ey)))
2182         continue;
2183
2184       element = Feld[x][y];
2185
2186       if (IS_MOVING(x, y) || IS_BLOCKED(x, y))
2187       {
2188         element = MovingOrBlocked2Element(x, y);
2189
2190         if (!IS_EXPLOSION_PROOF(element))
2191           RemoveMovingField(x, y);
2192       }
2193
2194 #if 1
2195
2196 #if 0
2197       if (IS_EXPLOSION_PROOF(element))
2198         continue;
2199 #else
2200       /* indestructible elements can only explode in center (but not flames) */
2201       if ((IS_EXPLOSION_PROOF(element) && (x != ex || y != ey)) ||
2202           element == EL_FLAMES)
2203         continue;
2204 #endif
2205
2206 #else
2207       if ((IS_INDESTRUCTIBLE(element) &&
2208            (game.engine_version < VERSION_IDENT(2,2,0) ||
2209             (!IS_WALKABLE_OVER(element) && !IS_WALKABLE_UNDER(element)))) ||
2210           element == EL_FLAMES)
2211         continue;
2212 #endif
2213
2214       if (IS_PLAYER(x, y) && SHIELD_ON(PLAYERINFO(x, y)))
2215       {
2216         if (IS_ACTIVE_BOMB(element))
2217         {
2218           /* re-activate things under the bomb like gate or penguin */
2219           Feld[x][y] = (Store[x][y] ? Store[x][y] : EL_EMPTY);
2220           Store[x][y] = 0;
2221         }
2222
2223         continue;
2224       }
2225
2226       /* save walkable background elements while explosion on same tile */
2227 #if 0
2228       if (IS_INDESTRUCTIBLE(element))
2229         Back[x][y] = element;
2230 #else
2231       if (IS_WALKABLE(element) && IS_INDESTRUCTIBLE(element))
2232         Back[x][y] = element;
2233 #endif
2234
2235       /* ignite explodable elements reached by other explosion */
2236       if (element == EL_EXPLOSION)
2237         element = Store2[x][y];
2238
2239 #if 1
2240       if (AmoebaNr[x][y] &&
2241           (element == EL_AMOEBA_FULL ||
2242            element == EL_BD_AMOEBA ||
2243            element == EL_AMOEBA_GROWING))
2244       {
2245         AmoebaCnt[AmoebaNr[x][y]]--;
2246         AmoebaCnt2[AmoebaNr[x][y]]--;
2247       }
2248
2249       RemoveField(x, y);
2250 #endif
2251
2252       if (IS_PLAYER(ex, ey) && !PLAYER_PROTECTED(ex, ey))
2253       {
2254         switch(StorePlayer[ex][ey])
2255         {
2256           case EL_PLAYER_2:
2257             Store[x][y] = EL_EMERALD_RED;
2258             break;
2259           case EL_PLAYER_3:
2260             Store[x][y] = EL_EMERALD;
2261             break;
2262           case EL_PLAYER_4:
2263             Store[x][y] = EL_EMERALD_PURPLE;
2264             break;
2265           case EL_PLAYER_1:
2266           default:
2267             Store[x][y] = EL_EMERALD_YELLOW;
2268             break;
2269         }
2270
2271         if (game.emulation == EMU_SUPAPLEX)
2272           Store[x][y] = EL_EMPTY;
2273       }
2274       else if (center_element == EL_MOLE)
2275         Store[x][y] = EL_EMERALD_RED;
2276       else if (center_element == EL_PENGUIN)
2277         Store[x][y] = EL_EMERALD_PURPLE;
2278       else if (center_element == EL_BUG)
2279         Store[x][y] = ((x == ex && y == ey) ? EL_DIAMOND : EL_EMERALD);
2280       else if (center_element == EL_BD_BUTTERFLY)
2281         Store[x][y] = EL_BD_DIAMOND;
2282       else if (center_element == EL_SP_ELECTRON)
2283         Store[x][y] = EL_SP_INFOTRON;
2284       else if (center_element == EL_AMOEBA_TO_DIAMOND)
2285         Store[x][y] = level.amoeba_content;
2286       else if (center_element == EL_YAMYAM)
2287         Store[x][y] = level.yamyam_content[game.yamyam_content_nr][xx][yy];
2288       else if (IS_CUSTOM_ELEMENT(center_element) &&
2289                element_info[center_element].content[xx][yy] != EL_EMPTY)
2290         Store[x][y] = element_info[center_element].content[xx][yy];
2291       else if (element == EL_WALL_EMERALD)
2292         Store[x][y] = EL_EMERALD;
2293       else if (element == EL_WALL_DIAMOND)
2294         Store[x][y] = EL_DIAMOND;
2295       else if (element == EL_WALL_BD_DIAMOND)
2296         Store[x][y] = EL_BD_DIAMOND;
2297       else if (element == EL_WALL_EMERALD_YELLOW)
2298         Store[x][y] = EL_EMERALD_YELLOW;
2299       else if (element == EL_WALL_EMERALD_RED)
2300         Store[x][y] = EL_EMERALD_RED;
2301       else if (element == EL_WALL_EMERALD_PURPLE)
2302         Store[x][y] = EL_EMERALD_PURPLE;
2303       else if (element == EL_WALL_PEARL)
2304         Store[x][y] = EL_PEARL;
2305       else if (element == EL_WALL_CRYSTAL)
2306         Store[x][y] = EL_CRYSTAL;
2307       else if (IS_CUSTOM_ELEMENT(element) && !CAN_EXPLODE(element))
2308         Store[x][y] = element_info[element].content[1][1];
2309       else
2310         Store[x][y] = EL_EMPTY;
2311
2312       if (x != ex || y != ey ||
2313           center_element == EL_AMOEBA_TO_DIAMOND || mode == EX_BORDER)
2314         Store2[x][y] = element;
2315
2316 #if 0
2317       if (AmoebaNr[x][y] &&
2318           (element == EL_AMOEBA_FULL ||
2319            element == EL_BD_AMOEBA ||
2320            element == EL_AMOEBA_GROWING))
2321       {
2322         AmoebaCnt[AmoebaNr[x][y]]--;
2323         AmoebaCnt2[AmoebaNr[x][y]]--;
2324       }
2325
2326 #if 1
2327       RemoveField(x, y);
2328 #else
2329       MovDir[x][y] = MovPos[x][y] = 0;
2330       AmoebaNr[x][y] = 0;
2331 #endif
2332 #endif
2333
2334       Feld[x][y] = EL_EXPLOSION;
2335 #if 1
2336       GfxElement[x][y] = center_element;
2337 #else
2338       GfxElement[x][y] = EL_UNDEFINED;
2339 #endif
2340
2341       ExplodePhase[x][y] = 1;
2342       Stop[x][y] = TRUE;
2343     }
2344
2345     if (center_element == EL_YAMYAM)
2346       game.yamyam_content_nr =
2347         (game.yamyam_content_nr + 1) % level.num_yamyam_contents;
2348
2349     return;
2350   }
2351
2352   if (Stop[ex][ey])
2353     return;
2354
2355   x = ex;
2356   y = ey;
2357
2358   ExplodePhase[x][y] = (phase < last_phase ? phase + 1 : 0);
2359
2360 #ifdef DEBUG
2361
2362   /* activate this even in non-DEBUG version until cause for crash in
2363      getGraphicAnimationFrame() (see below) is found and eliminated */
2364 #endif
2365 #if 1
2366
2367   if (GfxElement[x][y] == EL_UNDEFINED)
2368   {
2369     printf("\n\n");
2370     printf("Explode(): x = %d, y = %d: GfxElement == EL_UNDEFINED\n", x, y);
2371     printf("Explode(): This should never happen!\n");
2372     printf("\n\n");
2373
2374     GfxElement[x][y] = EL_EMPTY;
2375   }
2376 #endif
2377
2378   if (phase == first_phase_after_start)
2379   {
2380     int element = Store2[x][y];
2381
2382     if (element == EL_BLACK_ORB)
2383     {
2384       Feld[x][y] = Store2[x][y];
2385       Store2[x][y] = 0;
2386       Bang(x, y);
2387     }
2388   }
2389   else if (phase == half_phase)
2390   {
2391     int element = Store2[x][y];
2392
2393     if (IS_PLAYER(x, y))
2394       KillHeroUnlessProtected(x, y);
2395     else if (CAN_EXPLODE_BY_FIRE(element))
2396     {
2397       Feld[x][y] = Store2[x][y];
2398       Store2[x][y] = 0;
2399       Bang(x, y);
2400     }
2401     else if (element == EL_AMOEBA_TO_DIAMOND)
2402       AmoebeUmwandeln(x, y);
2403   }
2404
2405   if (phase == last_phase)
2406   {
2407     int element;
2408
2409     element = Feld[x][y] = Store[x][y];
2410     Store[x][y] = Store2[x][y] = 0;
2411     GfxElement[x][y] = EL_UNDEFINED;
2412
2413     if (Back[x][y] && IS_INDESTRUCTIBLE(Back[x][y]))
2414       element = Feld[x][y] = Back[x][y];
2415     Back[x][y] = 0;
2416
2417     MovDir[x][y] = MovPos[x][y] = MovDelay[x][y] = 0;
2418     ChangeDelay[x][y] = 0;
2419     ChangePage[x][y] = -1;
2420
2421     InitField(x, y, FALSE);
2422     if (CAN_MOVE(element))
2423       InitMovDir(x, y);
2424     DrawLevelField(x, y);
2425
2426     TestIfElementTouchesCustomElement(x, y);
2427
2428     if (GFX_CRUMBLED(element))
2429       DrawLevelFieldCrumbledSandNeighbours(x, y);
2430
2431     if (IS_PLAYER(x, y) && !PLAYERINFO(x,y)->present)
2432       StorePlayer[x][y] = 0;
2433
2434     if (ELEM_IS_PLAYER(element))
2435       RelocatePlayer(x, y, element);
2436   }
2437   else if (phase >= delay && IN_SCR_FIELD(SCREENX(x), SCREENY(y)))
2438   {
2439 #if 1
2440     int graphic = el_act2img(GfxElement[x][y], ACTION_EXPLODING);
2441 #else
2442     int stored = Store[x][y];
2443     int graphic = (game.emulation != EMU_SUPAPLEX ? IMG_EXPLOSION :
2444                    stored == EL_SP_INFOTRON ? IMG_SP_EXPLOSION_INFOTRON :
2445                    IMG_SP_EXPLOSION);
2446 #endif
2447     int frame = getGraphicAnimationFrame(graphic, phase - delay);
2448
2449     if (phase == delay)
2450       DrawLevelFieldCrumbledSand(x, y);
2451
2452     if (IS_WALKABLE_OVER(Back[x][y]) && Back[x][y] != EL_EMPTY)
2453     {
2454       DrawLevelElement(x, y, Back[x][y]);
2455       DrawGraphicThruMask(SCREENX(x), SCREENY(y), graphic, frame);
2456     }
2457     else if (IS_WALKABLE_UNDER(Back[x][y]))
2458     {
2459       DrawGraphic(SCREENX(x), SCREENY(y), graphic, frame);
2460       DrawLevelElementThruMask(x, y, Back[x][y]);
2461     }
2462     else if (!IS_WALKABLE_INSIDE(Back[x][y]))
2463       DrawGraphic(SCREENX(x), SCREENY(y), graphic, frame);
2464   }
2465 }
2466
2467 void DynaExplode(int ex, int ey)
2468 {
2469   int i, j;
2470   int dynabomb_size = 1;
2471   boolean dynabomb_xl = FALSE;
2472   struct PlayerInfo *player;
2473   static int xy[4][2] =
2474   {
2475     { 0, -1 },
2476     { -1, 0 },
2477     { +1, 0 },
2478     { 0, +1 }
2479   };
2480
2481   if (IS_ACTIVE_BOMB(Feld[ex][ey]))
2482   {
2483     player = &stored_player[Feld[ex][ey] - EL_DYNABOMB_PLAYER_1_ACTIVE];
2484     dynabomb_size = player->dynabomb_size;
2485     dynabomb_xl = player->dynabomb_xl;
2486     player->dynabombs_left++;
2487   }
2488
2489   Explode(ex, ey, EX_PHASE_START, EX_CENTER);
2490
2491   for (i=0; i<4; i++)
2492   {
2493     for (j=1; j<=dynabomb_size; j++)
2494     {
2495       int x = ex + j * xy[i % 4][0];
2496       int y = ey + j * xy[i % 4][1];
2497       int element;
2498
2499       if (!IN_LEV_FIELD(x, y) || IS_INDESTRUCTIBLE(Feld[x][y]))
2500         break;
2501
2502       element = Feld[x][y];
2503
2504       /* do not restart explosions of fields with active bombs */
2505       if (element == EL_EXPLOSION && IS_ACTIVE_BOMB(Store2[x][y]))
2506         continue;
2507
2508       Explode(x, y, EX_PHASE_START, EX_BORDER);
2509
2510       /* !!! extend EL_SAND to anything diggable (but maybe not SP_BASE) !!! */
2511       if (element != EL_EMPTY &&
2512           element != EL_SAND &&
2513           element != EL_EXPLOSION &&
2514           !dynabomb_xl)
2515         break;
2516     }
2517   }
2518 }
2519
2520 void Bang(int x, int y)
2521 {
2522 #if 1
2523   int element = MovingOrBlocked2Element(x, y);
2524 #else
2525   int element = Feld[x][y];
2526 #endif
2527
2528 #if 1
2529   if (IS_PLAYER(x, y) && !PLAYER_PROTECTED(x, y))
2530 #else
2531   if (IS_PLAYER(x, y))
2532 #endif
2533   {
2534     struct PlayerInfo *player = PLAYERINFO(x, y);
2535
2536     element = Feld[x][y] = (player->use_murphy_graphic ? EL_SP_MURPHY :
2537                             player->element_nr);
2538   }
2539
2540 #if 0
2541 #if 1
2542   PlaySoundLevelAction(x, y, ACTION_EXPLODING);
2543 #else
2544   if (game.emulation == EMU_SUPAPLEX)
2545     PlaySoundLevel(x, y, SND_SP_ELEMENT_EXPLODING);
2546   else
2547     PlaySoundLevel(x, y, SND_ELEMENT_EXPLODING);
2548 #endif
2549 #endif
2550
2551 #if 0
2552   if (IS_PLAYER(x, y))  /* remove objects that might cause smaller explosion */
2553     element = EL_EMPTY;
2554 #endif
2555
2556   switch(element)
2557   {
2558     case EL_BUG:
2559     case EL_SPACESHIP:
2560     case EL_BD_BUTTERFLY:
2561     case EL_BD_FIREFLY:
2562     case EL_YAMYAM:
2563     case EL_DARK_YAMYAM:
2564     case EL_ROBOT:
2565     case EL_PACMAN:
2566     case EL_MOLE:
2567       RaiseScoreElement(element);
2568       Explode(x, y, EX_PHASE_START, EX_NORMAL);
2569       break;
2570     case EL_DYNABOMB_PLAYER_1_ACTIVE:
2571     case EL_DYNABOMB_PLAYER_2_ACTIVE:
2572     case EL_DYNABOMB_PLAYER_3_ACTIVE:
2573     case EL_DYNABOMB_PLAYER_4_ACTIVE:
2574     case EL_DYNABOMB_INCREASE_NUMBER:
2575     case EL_DYNABOMB_INCREASE_SIZE:
2576     case EL_DYNABOMB_INCREASE_POWER:
2577       DynaExplode(x, y);
2578       break;
2579     case EL_PENGUIN:
2580     case EL_LAMP:
2581     case EL_LAMP_ACTIVE:
2582       if (IS_PLAYER(x, y))
2583         Explode(x, y, EX_PHASE_START, EX_NORMAL);
2584       else
2585         Explode(x, y, EX_PHASE_START, EX_CENTER);
2586       break;
2587     default:
2588       if (CAN_EXPLODE_1X1(element))
2589         Explode(x, y, EX_PHASE_START, EX_CENTER);
2590       else
2591         Explode(x, y, EX_PHASE_START, EX_NORMAL);
2592       break;
2593   }
2594
2595   CheckTriggeredElementChange(x, y, element, CE_OTHER_IS_EXPLODING);
2596 }
2597
2598 void SplashAcid(int x, int y)
2599 {
2600   int element = Feld[x][y];
2601
2602   if (element != EL_ACID_SPLASH_LEFT &&
2603       element != EL_ACID_SPLASH_RIGHT)
2604   {
2605     PlaySoundLevel(x, y, SND_ACID_SPLASHING);
2606
2607     if (IN_LEV_FIELD(x-1, y) && IS_FREE(x-1, y) &&
2608         (!IN_LEV_FIELD(x-1, y-1) ||
2609          !CAN_FALL(MovingOrBlocked2Element(x-1, y-1))))
2610       Feld[x-1][y] = EL_ACID_SPLASH_LEFT;
2611
2612     if (IN_LEV_FIELD(x+1, y) && IS_FREE(x+1, y) &&
2613         (!IN_LEV_FIELD(x+1, y-1) ||
2614          !CAN_FALL(MovingOrBlocked2Element(x+1, y-1))))
2615       Feld[x+1][y] = EL_ACID_SPLASH_RIGHT;
2616   }
2617 }
2618
2619 static void InitBeltMovement()
2620 {
2621   static int belt_base_element[4] =
2622   {
2623     EL_CONVEYOR_BELT_1_LEFT,
2624     EL_CONVEYOR_BELT_2_LEFT,
2625     EL_CONVEYOR_BELT_3_LEFT,
2626     EL_CONVEYOR_BELT_4_LEFT
2627   };
2628   static int belt_base_active_element[4] =
2629   {
2630     EL_CONVEYOR_BELT_1_LEFT_ACTIVE,
2631     EL_CONVEYOR_BELT_2_LEFT_ACTIVE,
2632     EL_CONVEYOR_BELT_3_LEFT_ACTIVE,
2633     EL_CONVEYOR_BELT_4_LEFT_ACTIVE
2634   };
2635
2636   int x, y, i, j;
2637
2638   /* set frame order for belt animation graphic according to belt direction */
2639   for (i=0; i<4; i++)
2640   {
2641     int belt_nr = i;
2642
2643     for (j=0; j<3; j++)
2644     {
2645       int element = belt_base_active_element[belt_nr] + j;
2646       int graphic = el2img(element);
2647
2648       if (game.belt_dir[i] == MV_LEFT)
2649         graphic_info[graphic].anim_mode &= ~ANIM_REVERSE;
2650       else
2651         graphic_info[graphic].anim_mode |=  ANIM_REVERSE;
2652     }
2653   }
2654
2655   for(y=0; y<lev_fieldy; y++)
2656   {
2657     for(x=0; x<lev_fieldx; x++)
2658     {
2659       int element = Feld[x][y];
2660
2661       for (i=0; i<4; i++)
2662       {
2663         if (IS_BELT(element) && game.belt_dir[i] != MV_NO_MOVING)
2664         {
2665           int e_belt_nr = getBeltNrFromBeltElement(element);
2666           int belt_nr = i;
2667
2668           if (e_belt_nr == belt_nr)
2669           {
2670             int belt_part = Feld[x][y] - belt_base_element[belt_nr];
2671
2672             Feld[x][y] = belt_base_active_element[belt_nr] + belt_part;
2673           }
2674         }
2675       }
2676     }
2677   }
2678 }
2679
2680 static void ToggleBeltSwitch(int x, int y)
2681 {
2682   static int belt_base_element[4] =
2683   {
2684     EL_CONVEYOR_BELT_1_LEFT,
2685     EL_CONVEYOR_BELT_2_LEFT,
2686     EL_CONVEYOR_BELT_3_LEFT,
2687     EL_CONVEYOR_BELT_4_LEFT
2688   };
2689   static int belt_base_active_element[4] =
2690   {
2691     EL_CONVEYOR_BELT_1_LEFT_ACTIVE,
2692     EL_CONVEYOR_BELT_2_LEFT_ACTIVE,
2693     EL_CONVEYOR_BELT_3_LEFT_ACTIVE,
2694     EL_CONVEYOR_BELT_4_LEFT_ACTIVE
2695   };
2696   static int belt_base_switch_element[4] =
2697   {
2698     EL_CONVEYOR_BELT_1_SWITCH_LEFT,
2699     EL_CONVEYOR_BELT_2_SWITCH_LEFT,
2700     EL_CONVEYOR_BELT_3_SWITCH_LEFT,
2701     EL_CONVEYOR_BELT_4_SWITCH_LEFT
2702   };
2703   static int belt_move_dir[4] =
2704   {
2705     MV_LEFT,
2706     MV_NO_MOVING,
2707     MV_RIGHT,
2708     MV_NO_MOVING,
2709   };
2710
2711   int element = Feld[x][y];
2712   int belt_nr = getBeltNrFromBeltSwitchElement(element);
2713   int belt_dir_nr = (game.belt_dir_nr[belt_nr] + 1) % 4;
2714   int belt_dir = belt_move_dir[belt_dir_nr];
2715   int xx, yy, i;
2716
2717   if (!IS_BELT_SWITCH(element))
2718     return;
2719
2720   game.belt_dir_nr[belt_nr] = belt_dir_nr;
2721   game.belt_dir[belt_nr] = belt_dir;
2722
2723   if (belt_dir_nr == 3)
2724     belt_dir_nr = 1;
2725
2726   /* set frame order for belt animation graphic according to belt direction */
2727   for (i=0; i<3; i++)
2728   {
2729     int element = belt_base_active_element[belt_nr] + i;
2730     int graphic = el2img(element);
2731
2732     if (belt_dir == MV_LEFT)
2733       graphic_info[graphic].anim_mode &= ~ANIM_REVERSE;
2734     else
2735       graphic_info[graphic].anim_mode |=  ANIM_REVERSE;
2736   }
2737
2738   for (yy=0; yy<lev_fieldy; yy++)
2739   {
2740     for (xx=0; xx<lev_fieldx; xx++)
2741     {
2742       int element = Feld[xx][yy];
2743
2744       if (IS_BELT_SWITCH(element))
2745       {
2746         int e_belt_nr = getBeltNrFromBeltSwitchElement(element);
2747
2748         if (e_belt_nr == belt_nr)
2749         {
2750           Feld[xx][yy] = belt_base_switch_element[belt_nr] + belt_dir_nr;
2751           DrawLevelField(xx, yy);
2752         }
2753       }
2754       else if (IS_BELT(element) && belt_dir != MV_NO_MOVING)
2755       {
2756         int e_belt_nr = getBeltNrFromBeltElement(element);
2757
2758         if (e_belt_nr == belt_nr)
2759         {
2760           int belt_part = Feld[xx][yy] - belt_base_element[belt_nr];
2761
2762           Feld[xx][yy] = belt_base_active_element[belt_nr] + belt_part;
2763           DrawLevelField(xx, yy);
2764         }
2765       }
2766       else if (IS_BELT_ACTIVE(element) && belt_dir == MV_NO_MOVING)
2767       {
2768         int e_belt_nr = getBeltNrFromBeltActiveElement(element);
2769
2770         if (e_belt_nr == belt_nr)
2771         {
2772           int belt_part = Feld[xx][yy] - belt_base_active_element[belt_nr];
2773
2774           Feld[xx][yy] = belt_base_element[belt_nr] + belt_part;
2775           DrawLevelField(xx, yy);
2776         }
2777       }
2778     }
2779   }
2780 }
2781
2782 static void ToggleSwitchgateSwitch(int x, int y)
2783 {
2784   int xx, yy;
2785
2786   game.switchgate_pos = !game.switchgate_pos;
2787
2788   for (yy=0; yy<lev_fieldy; yy++)
2789   {
2790     for (xx=0; xx<lev_fieldx; xx++)
2791     {
2792       int element = Feld[xx][yy];
2793
2794       if (element == EL_SWITCHGATE_SWITCH_UP ||
2795           element == EL_SWITCHGATE_SWITCH_DOWN)
2796       {
2797         Feld[xx][yy] = EL_SWITCHGATE_SWITCH_UP + game.switchgate_pos;
2798         DrawLevelField(xx, yy);
2799       }
2800       else if (element == EL_SWITCHGATE_OPEN ||
2801                element == EL_SWITCHGATE_OPENING)
2802       {
2803         Feld[xx][yy] = EL_SWITCHGATE_CLOSING;
2804 #if 1
2805         PlaySoundLevelAction(xx, yy, ACTION_CLOSING);
2806 #else
2807         PlaySoundLevel(xx, yy, SND_SWITCHGATE_CLOSING);
2808 #endif
2809       }
2810       else if (element == EL_SWITCHGATE_CLOSED ||
2811                element == EL_SWITCHGATE_CLOSING)
2812       {
2813         Feld[xx][yy] = EL_SWITCHGATE_OPENING;
2814 #if 1
2815         PlaySoundLevelAction(xx, yy, ACTION_OPENING);
2816 #else
2817         PlaySoundLevel(xx, yy, SND_SWITCHGATE_OPENING);
2818 #endif
2819       }
2820     }
2821   }
2822 }
2823
2824 static int getInvisibleActiveFromInvisibleElement(int element)
2825 {
2826   return (element == EL_INVISIBLE_STEELWALL ? EL_INVISIBLE_STEELWALL_ACTIVE :
2827           element == EL_INVISIBLE_WALL      ? EL_INVISIBLE_WALL_ACTIVE :
2828           element == EL_INVISIBLE_SAND      ? EL_INVISIBLE_SAND_ACTIVE :
2829           element);
2830 }
2831
2832 static int getInvisibleFromInvisibleActiveElement(int element)
2833 {
2834   return (element == EL_INVISIBLE_STEELWALL_ACTIVE ? EL_INVISIBLE_STEELWALL :
2835           element == EL_INVISIBLE_WALL_ACTIVE      ? EL_INVISIBLE_WALL :
2836           element == EL_INVISIBLE_SAND_ACTIVE      ? EL_INVISIBLE_SAND :
2837           element);
2838 }
2839
2840 static void RedrawAllLightSwitchesAndInvisibleElements()
2841 {
2842   int x, y;
2843
2844   for (y=0; y<lev_fieldy; y++)
2845   {
2846     for (x=0; x<lev_fieldx; x++)
2847     {
2848       int element = Feld[x][y];
2849
2850       if (element == EL_LIGHT_SWITCH &&
2851           game.light_time_left > 0)
2852       {
2853         Feld[x][y] = EL_LIGHT_SWITCH_ACTIVE;
2854         DrawLevelField(x, y);
2855       }
2856       else if (element == EL_LIGHT_SWITCH_ACTIVE &&
2857                game.light_time_left == 0)
2858       {
2859         Feld[x][y] = EL_LIGHT_SWITCH;
2860         DrawLevelField(x, y);
2861       }
2862       else if (element == EL_INVISIBLE_STEELWALL ||
2863                element == EL_INVISIBLE_WALL ||
2864                element == EL_INVISIBLE_SAND)
2865       {
2866         if (game.light_time_left > 0)
2867           Feld[x][y] = getInvisibleActiveFromInvisibleElement(element);
2868
2869         DrawLevelField(x, y);
2870       }
2871       else if (element == EL_INVISIBLE_STEELWALL_ACTIVE ||
2872                element == EL_INVISIBLE_WALL_ACTIVE ||
2873                element == EL_INVISIBLE_SAND_ACTIVE)
2874       {
2875         if (game.light_time_left == 0)
2876           Feld[x][y] = getInvisibleFromInvisibleActiveElement(element);
2877
2878         DrawLevelField(x, y);
2879       }
2880     }
2881   }
2882 }
2883
2884 static void ToggleLightSwitch(int x, int y)
2885 {
2886   int element = Feld[x][y];
2887
2888   game.light_time_left =
2889     (element == EL_LIGHT_SWITCH ?
2890      level.time_light * FRAMES_PER_SECOND : 0);
2891
2892   RedrawAllLightSwitchesAndInvisibleElements();
2893 }
2894
2895 static void ActivateTimegateSwitch(int x, int y)
2896 {
2897   int xx, yy;
2898
2899   game.timegate_time_left = level.time_timegate * FRAMES_PER_SECOND;
2900
2901   for (yy=0; yy<lev_fieldy; yy++)
2902   {
2903     for (xx=0; xx<lev_fieldx; xx++)
2904     {
2905       int element = Feld[xx][yy];
2906
2907       if (element == EL_TIMEGATE_CLOSED ||
2908           element == EL_TIMEGATE_CLOSING)
2909       {
2910         Feld[xx][yy] = EL_TIMEGATE_OPENING;
2911         PlaySoundLevel(xx, yy, SND_TIMEGATE_OPENING);
2912       }
2913
2914       /*
2915       else if (element == EL_TIMEGATE_SWITCH_ACTIVE)
2916       {
2917         Feld[xx][yy] = EL_TIMEGATE_SWITCH;
2918         DrawLevelField(xx, yy);
2919       }
2920       */
2921
2922     }
2923   }
2924
2925   Feld[x][y] = EL_TIMEGATE_SWITCH_ACTIVE;
2926 }
2927
2928 inline static int getElementMoveStepsize(int x, int y)
2929 {
2930   int element = Feld[x][y];
2931   int direction = MovDir[x][y];
2932   int dx = (direction == MV_LEFT ? -1 : direction == MV_RIGHT ? +1 : 0);
2933   int dy = (direction == MV_UP   ? -1 : direction == MV_DOWN  ? +1 : 0);
2934   int horiz_move = (dx != 0);
2935   int sign = (horiz_move ? dx : dy);
2936   int step = sign * element_info[element].move_stepsize;
2937
2938   /* special values for move stepsize for spring and things on conveyor belt */
2939   if (horiz_move)
2940   {
2941     if (CAN_FALL(element) &&
2942         y < lev_fieldy - 1 && IS_BELT_ACTIVE(Feld[x][y + 1]))
2943       step = sign * MOVE_STEPSIZE_NORMAL / 2;
2944     else if (element == EL_SPRING)
2945       step = sign * MOVE_STEPSIZE_NORMAL * 2;
2946   }
2947
2948   return step;
2949 }
2950
2951 void Impact(int x, int y)
2952 {
2953   boolean lastline = (y == lev_fieldy-1);
2954   boolean object_hit = FALSE;
2955   boolean impact = (lastline || object_hit);
2956   int element = Feld[x][y];
2957   int smashed = EL_UNDEFINED;
2958
2959   if (!lastline)        /* check if element below was hit */
2960   {
2961     if (Feld[x][y + 1] == EL_PLAYER_IS_LEAVING)
2962       return;
2963
2964     object_hit = (!IS_FREE(x, y + 1) && (!IS_MOVING(x, y + 1) ||
2965                                          MovDir[x][y + 1] != MV_DOWN ||
2966                                          MovPos[x][y + 1] <= TILEY / 2));
2967
2968     /* do not smash moving elements that left the smashed field in time */
2969     if (game.engine_version >= RELEASE_IDENT(2,2,0,7) && IS_MOVING(x, y + 1) &&
2970         ABS(MovPos[x][y + 1] + getElementMoveStepsize(x, y + 1)) >= TILEX)
2971       object_hit = FALSE;
2972
2973     if (object_hit)
2974       smashed = MovingOrBlocked2Element(x, y + 1);
2975
2976     impact = (lastline || object_hit);
2977   }
2978
2979   if (!lastline && smashed == EL_ACID)  /* element falls into acid */
2980   {
2981     SplashAcid(x, y);
2982     return;
2983   }
2984
2985   /* only reset graphic animation if graphic really changes after impact */
2986   if (impact &&
2987       el_act_dir2img(element, GfxAction[x][y], MV_DOWN) != el2img(element))
2988   {
2989     ResetGfxAnimation(x, y);
2990     DrawLevelField(x, y);
2991   }
2992
2993   if (impact && CAN_EXPLODE_IMPACT(element))
2994   {
2995     Bang(x, y);
2996     return;
2997   }
2998   else if (impact && element == EL_PEARL)
2999   {
3000     Feld[x][y] = EL_PEARL_BREAKING;
3001     PlaySoundLevel(x, y, SND_PEARL_BREAKING);
3002     return;
3003   }
3004   else if (impact && CheckElementChange(x, y, element, CE_IMPACT))
3005   {
3006     PlaySoundLevelElementAction(x, y, element, ACTION_IMPACT);
3007
3008     return;
3009   }
3010
3011   if (impact && element == EL_AMOEBA_DROP)
3012   {
3013     if (object_hit && IS_PLAYER(x, y + 1))
3014       KillHeroUnlessProtected(x, y + 1);
3015     else if (object_hit && smashed == EL_PENGUIN)
3016       Bang(x, y + 1);
3017     else
3018     {
3019       Feld[x][y] = EL_AMOEBA_GROWING;
3020       Store[x][y] = EL_AMOEBA_WET;
3021
3022       ResetRandomAnimationValue(x, y);
3023     }
3024     return;
3025   }
3026
3027   if (object_hit)               /* check which object was hit */
3028   {
3029     if (CAN_PASS_MAGIC_WALL(element) &&
3030         (smashed == EL_MAGIC_WALL ||
3031          smashed == EL_BD_MAGIC_WALL))
3032     {
3033       int xx, yy;
3034       int activated_magic_wall =
3035         (smashed == EL_MAGIC_WALL ? EL_MAGIC_WALL_ACTIVE :
3036          EL_BD_MAGIC_WALL_ACTIVE);
3037
3038       /* activate magic wall / mill */
3039       for (yy=0; yy<lev_fieldy; yy++)
3040         for (xx=0; xx<lev_fieldx; xx++)
3041           if (Feld[xx][yy] == smashed)
3042             Feld[xx][yy] = activated_magic_wall;
3043
3044       game.magic_wall_time_left = level.time_magic_wall * FRAMES_PER_SECOND;
3045       game.magic_wall_active = TRUE;
3046
3047       PlaySoundLevel(x, y, (smashed == EL_MAGIC_WALL ?
3048                             SND_MAGIC_WALL_ACTIVATING :
3049                             SND_BD_MAGIC_WALL_ACTIVATING));
3050     }
3051
3052     if (IS_PLAYER(x, y + 1))
3053     {
3054       if (CAN_SMASH_PLAYER(element))
3055       {
3056         KillHeroUnlessProtected(x, y + 1);
3057         return;
3058       }
3059     }
3060     else if (smashed == EL_PENGUIN)
3061     {
3062       if (CAN_SMASH_PLAYER(element))
3063       {
3064         Bang(x, y + 1);
3065         return;
3066       }
3067     }
3068     else if (element == EL_BD_DIAMOND)
3069     {
3070       if (IS_CLASSIC_ENEMY(smashed) && IS_BD_ELEMENT(smashed))
3071       {
3072         Bang(x, y + 1);
3073         return;
3074       }
3075     }
3076     else if ((element == EL_SP_INFOTRON ||
3077               element == EL_SP_ZONK) &&
3078              (smashed == EL_SP_SNIKSNAK ||
3079               smashed == EL_SP_ELECTRON ||
3080               smashed == EL_SP_DISK_ORANGE))
3081     {
3082       Bang(x, y + 1);
3083       return;
3084     }
3085 #if 0
3086     else if (CAN_SMASH_ENEMIES(element) && IS_CLASSIC_ENEMY(smashed))
3087     {
3088       Bang(x, y + 1);
3089       return;
3090     }
3091 #endif
3092     else if (CAN_SMASH_EVERYTHING(element))
3093     {
3094       if (IS_CLASSIC_ENEMY(smashed) ||
3095           CAN_EXPLODE_SMASHED(smashed))
3096       {
3097         Bang(x, y + 1);
3098         return;
3099       }
3100       else if (!IS_MOVING(x, y + 1) && !IS_BLOCKED(x, y + 1))
3101       {
3102         if (smashed == EL_LAMP ||
3103             smashed == EL_LAMP_ACTIVE)
3104         {
3105           Bang(x, y + 1);
3106           return;
3107         }
3108         else if (smashed == EL_NUT)
3109         {
3110           Feld[x][y + 1] = EL_NUT_BREAKING;
3111           PlaySoundLevel(x, y, SND_NUT_BREAKING);
3112           RaiseScoreElement(EL_NUT);
3113           return;
3114         }
3115         else if (smashed == EL_PEARL)
3116         {
3117           Feld[x][y + 1] = EL_PEARL_BREAKING;
3118           PlaySoundLevel(x, y, SND_PEARL_BREAKING);
3119           return;
3120         }
3121         else if (smashed == EL_DIAMOND)
3122         {
3123           Feld[x][y + 1] = EL_DIAMOND_BREAKING;
3124           PlaySoundLevel(x, y, SND_DIAMOND_BREAKING);
3125           return;
3126         }
3127         else if (IS_BELT_SWITCH(smashed))
3128         {
3129           ToggleBeltSwitch(x, y + 1);
3130         }
3131         else if (smashed == EL_SWITCHGATE_SWITCH_UP ||
3132                  smashed == EL_SWITCHGATE_SWITCH_DOWN)
3133         {
3134           ToggleSwitchgateSwitch(x, y + 1);
3135         }
3136         else if (smashed == EL_LIGHT_SWITCH ||
3137                  smashed == EL_LIGHT_SWITCH_ACTIVE)
3138         {
3139           ToggleLightSwitch(x, y + 1);
3140         }
3141         else
3142         {
3143           CheckElementChange(x, y + 1, smashed, CE_SMASHED);
3144
3145           CheckTriggeredElementSideChange(x, y + 1, smashed, CH_SIDE_TOP,
3146                                           CE_OTHER_IS_SWITCHING);
3147           CheckElementSideChange(x, y + 1, smashed, CH_SIDE_TOP,
3148                                  CE_SWITCHED, -1);
3149         }
3150       }
3151       else
3152       {
3153         CheckElementChange(x, y + 1, smashed, CE_SMASHED);
3154       }
3155     }
3156   }
3157
3158   /* play sound of magic wall / mill */
3159   if (!lastline &&
3160       (Feld[x][y + 1] == EL_MAGIC_WALL_ACTIVE ||
3161        Feld[x][y + 1] == EL_BD_MAGIC_WALL_ACTIVE))
3162   {
3163     if (Feld[x][y + 1] == EL_MAGIC_WALL_ACTIVE)
3164       PlaySoundLevel(x, y, SND_MAGIC_WALL_FILLING);
3165     else if (Feld[x][y + 1] == EL_BD_MAGIC_WALL_ACTIVE)
3166       PlaySoundLevel(x, y, SND_BD_MAGIC_WALL_FILLING);
3167
3168     return;
3169   }
3170
3171   /* play sound of object that hits the ground */
3172   if (lastline || object_hit)
3173     PlaySoundLevelElementAction(x, y, element, ACTION_IMPACT);
3174 }
3175
3176 void TurnRound(int x, int y)
3177 {
3178   static struct
3179   {
3180     int x, y;
3181   } move_xy[] =
3182   {
3183     {  0,  0 },
3184     { -1,  0 },
3185     { +1,  0 },
3186     {  0,  0 },
3187     {  0, -1 },
3188     {  0,  0 }, { 0, 0 }, { 0, 0 },
3189     {  0, +1 }
3190   };
3191   static struct
3192   {
3193     int left, right, back;
3194   } turn[] =
3195   {
3196     { 0,        0,              0        },
3197     { MV_DOWN,  MV_UP,          MV_RIGHT },
3198     { MV_UP,    MV_DOWN,        MV_LEFT  },
3199     { 0,        0,              0        },
3200     { MV_LEFT,  MV_RIGHT,       MV_DOWN  },
3201     { 0,        0,              0        },
3202     { 0,        0,              0        },
3203     { 0,        0,              0        },
3204     { MV_RIGHT, MV_LEFT,        MV_UP    }
3205   };
3206
3207   int element = Feld[x][y];
3208   int old_move_dir = MovDir[x][y];
3209   int left_dir  = turn[old_move_dir].left;
3210   int right_dir = turn[old_move_dir].right;
3211   int back_dir  = turn[old_move_dir].back;
3212
3213   int left_dx  = move_xy[left_dir].x,     left_dy  = move_xy[left_dir].y;
3214   int right_dx = move_xy[right_dir].x,    right_dy = move_xy[right_dir].y;
3215   int move_dx  = move_xy[old_move_dir].x, move_dy  = move_xy[old_move_dir].y;
3216   int back_dx  = move_xy[back_dir].x,     back_dy  = move_xy[back_dir].y;
3217
3218   int left_x  = x + left_dx,  left_y  = y + left_dy;
3219   int right_x = x + right_dx, right_y = y + right_dy;
3220   int move_x  = x + move_dx,  move_y  = y + move_dy;
3221
3222   int xx, yy;
3223
3224   if (element == EL_BUG || element == EL_BD_BUTTERFLY)
3225   {
3226     TestIfBadThingTouchesOtherBadThing(x, y);
3227
3228     if (ENEMY_CAN_ENTER_FIELD(right_x, right_y))
3229       MovDir[x][y] = right_dir;
3230     else if (!ENEMY_CAN_ENTER_FIELD(move_x, move_y))
3231       MovDir[x][y] = left_dir;
3232
3233     if (element == EL_BUG && MovDir[x][y] != old_move_dir)
3234       MovDelay[x][y] = 9;
3235     else if (element == EL_BD_BUTTERFLY)     /* && MovDir[x][y] == left_dir) */
3236       MovDelay[x][y] = 1;
3237   }
3238   else if (element == EL_SPACESHIP || element == EL_BD_FIREFLY ||
3239            element == EL_SP_SNIKSNAK || element == EL_SP_ELECTRON)
3240   {
3241     TestIfBadThingTouchesOtherBadThing(x, y);
3242
3243     if (ENEMY_CAN_ENTER_FIELD(left_x, left_y))
3244       MovDir[x][y] = left_dir;
3245     else if (!ENEMY_CAN_ENTER_FIELD(move_x, move_y))
3246       MovDir[x][y] = right_dir;
3247
3248     if ((element == EL_SPACESHIP ||
3249          element == EL_SP_SNIKSNAK ||
3250          element == EL_SP_ELECTRON)
3251         && MovDir[x][y] != old_move_dir)
3252       MovDelay[x][y] = 9;
3253     else if (element == EL_BD_FIREFLY)      /* && MovDir[x][y] == right_dir) */
3254       MovDelay[x][y] = 1;
3255   }
3256   else if (element == EL_YAMYAM)
3257   {
3258     boolean can_turn_left  = YAMYAM_CAN_ENTER_FIELD(left_x, left_y);
3259     boolean can_turn_right = YAMYAM_CAN_ENTER_FIELD(right_x, right_y);
3260
3261     if (can_turn_left && can_turn_right)
3262       MovDir[x][y] = (RND(3) ? (RND(2) ? left_dir : right_dir) : back_dir);
3263     else if (can_turn_left)
3264       MovDir[x][y] = (RND(2) ? left_dir : back_dir);
3265     else if (can_turn_right)
3266       MovDir[x][y] = (RND(2) ? right_dir : back_dir);
3267     else
3268       MovDir[x][y] = back_dir;
3269
3270     MovDelay[x][y] = 16 + 16 * RND(3);
3271   }
3272   else if (element == EL_DARK_YAMYAM)
3273   {
3274     boolean can_turn_left  = DARK_YAMYAM_CAN_ENTER_FIELD(left_x, left_y);
3275     boolean can_turn_right = DARK_YAMYAM_CAN_ENTER_FIELD(right_x, right_y);
3276
3277     if (can_turn_left && can_turn_right)
3278       MovDir[x][y] = (RND(3) ? (RND(2) ? left_dir : right_dir) : back_dir);
3279     else if (can_turn_left)
3280       MovDir[x][y] = (RND(2) ? left_dir : back_dir);
3281     else if (can_turn_right)
3282       MovDir[x][y] = (RND(2) ? right_dir : back_dir);
3283     else
3284       MovDir[x][y] = back_dir;
3285
3286     MovDelay[x][y] = 16 + 16 * RND(3);
3287   }
3288   else if (element == EL_PACMAN)
3289   {
3290     boolean can_turn_left  = PACMAN_CAN_ENTER_FIELD(left_x, left_y);
3291     boolean can_turn_right = PACMAN_CAN_ENTER_FIELD(right_x, right_y);
3292
3293     if (can_turn_left && can_turn_right)
3294       MovDir[x][y] = (RND(3) ? (RND(2) ? left_dir : right_dir) : back_dir);
3295     else if (can_turn_left)
3296       MovDir[x][y] = (RND(2) ? left_dir : back_dir);
3297     else if (can_turn_right)
3298       MovDir[x][y] = (RND(2) ? right_dir : back_dir);
3299     else
3300       MovDir[x][y] = back_dir;
3301
3302     MovDelay[x][y] = 6 + RND(40);
3303   }
3304   else if (element == EL_PIG)
3305   {
3306     boolean can_turn_left  = PIG_CAN_ENTER_FIELD(left_x, left_y);
3307     boolean can_turn_right = PIG_CAN_ENTER_FIELD(right_x, right_y);
3308     boolean can_move_on    = PIG_CAN_ENTER_FIELD(move_x, move_y);
3309     boolean should_turn_left, should_turn_right, should_move_on;
3310     int rnd_value = 24;
3311     int rnd = RND(rnd_value);
3312
3313     should_turn_left = (can_turn_left &&
3314                         (!can_move_on ||
3315                          IN_LEV_FIELD_AND_NOT_FREE(x + back_dx + left_dx,
3316                                                    y + back_dy + left_dy)));
3317     should_turn_right = (can_turn_right &&
3318                          (!can_move_on ||
3319                           IN_LEV_FIELD_AND_NOT_FREE(x + back_dx + right_dx,
3320                                                     y + back_dy + right_dy)));
3321     should_move_on = (can_move_on &&
3322                       (!can_turn_left ||
3323                        !can_turn_right ||
3324                        IN_LEV_FIELD_AND_NOT_FREE(x + move_dx + left_dx,
3325                                                  y + move_dy + left_dy) ||
3326                        IN_LEV_FIELD_AND_NOT_FREE(x + move_dx + right_dx,
3327                                                  y + move_dy + right_dy)));
3328
3329     if (should_turn_left || should_turn_right || should_move_on)
3330     {
3331       if (should_turn_left && should_turn_right && should_move_on)
3332         MovDir[x][y] = (rnd < rnd_value / 3     ? left_dir :
3333                         rnd < 2 * rnd_value / 3 ? right_dir :
3334                         old_move_dir);
3335       else if (should_turn_left && should_turn_right)
3336         MovDir[x][y] = (rnd < rnd_value / 2 ? left_dir : right_dir);
3337       else if (should_turn_left && should_move_on)
3338         MovDir[x][y] = (rnd < rnd_value / 2 ? left_dir : old_move_dir);
3339       else if (should_turn_right && should_move_on)
3340         MovDir[x][y] = (rnd < rnd_value / 2 ? right_dir : old_move_dir);
3341       else if (should_turn_left)
3342         MovDir[x][y] = left_dir;
3343       else if (should_turn_right)
3344         MovDir[x][y] = right_dir;
3345       else if (should_move_on)
3346         MovDir[x][y] = old_move_dir;
3347     }
3348     else if (can_move_on && rnd > rnd_value / 8)
3349       MovDir[x][y] = old_move_dir;
3350     else if (can_turn_left && can_turn_right)
3351       MovDir[x][y] = (rnd < rnd_value / 2 ? left_dir : right_dir);
3352     else if (can_turn_left && rnd > rnd_value / 8)
3353       MovDir[x][y] = left_dir;
3354     else if (can_turn_right && rnd > rnd_value/8)
3355       MovDir[x][y] = right_dir;
3356     else
3357       MovDir[x][y] = back_dir;
3358
3359     xx = x + move_xy[MovDir[x][y]].x;
3360     yy = y + move_xy[MovDir[x][y]].y;
3361
3362     if (!IS_FREE(xx, yy) && !IS_FOOD_PIG(Feld[xx][yy]))
3363       MovDir[x][y] = old_move_dir;
3364
3365     MovDelay[x][y] = 0;
3366   }
3367   else if (element == EL_DRAGON)
3368   {
3369     boolean can_turn_left  = IN_LEV_FIELD_AND_IS_FREE(left_x, left_y);
3370     boolean can_turn_right = IN_LEV_FIELD_AND_IS_FREE(right_x, right_y);
3371     boolean can_move_on    = IN_LEV_FIELD_AND_IS_FREE(move_x, move_y);
3372     int rnd_value = 24;
3373     int rnd = RND(rnd_value);
3374
3375     if (can_move_on && rnd > rnd_value / 8)
3376       MovDir[x][y] = old_move_dir;
3377     else if (can_turn_left && can_turn_right)
3378       MovDir[x][y] = (rnd < rnd_value / 2 ? left_dir : right_dir);
3379     else if (can_turn_left && rnd > rnd_value / 8)
3380       MovDir[x][y] = left_dir;
3381     else if (can_turn_right && rnd > rnd_value / 8)
3382       MovDir[x][y] = right_dir;
3383     else
3384       MovDir[x][y] = back_dir;
3385
3386     xx = x + move_xy[MovDir[x][y]].x;
3387     yy = y + move_xy[MovDir[x][y]].y;
3388
3389     if (!IS_FREE(xx, yy))
3390       MovDir[x][y] = old_move_dir;
3391
3392     MovDelay[x][y] = 0;
3393   }
3394   else if (element == EL_MOLE)
3395   {
3396     boolean can_move_on =
3397       (MOLE_CAN_ENTER_FIELD(move_x, move_y,
3398                             IS_AMOEBOID(Feld[move_x][move_y]) ||
3399                             Feld[move_x][move_y] == EL_AMOEBA_SHRINKING));
3400     if (!can_move_on)
3401     {
3402       boolean can_turn_left =
3403         (MOLE_CAN_ENTER_FIELD(left_x, left_y,
3404                               IS_AMOEBOID(Feld[left_x][left_y])));
3405
3406       boolean can_turn_right =
3407         (MOLE_CAN_ENTER_FIELD(right_x, right_y,
3408                               IS_AMOEBOID(Feld[right_x][right_y])));
3409
3410       if (can_turn_left && can_turn_right)
3411         MovDir[x][y] = (RND(2) ? left_dir : right_dir);
3412       else if (can_turn_left)
3413         MovDir[x][y] = left_dir;
3414       else
3415         MovDir[x][y] = right_dir;
3416     }
3417
3418     if (MovDir[x][y] != old_move_dir)
3419       MovDelay[x][y] = 9;
3420   }
3421   else if (element == EL_BALLOON)
3422   {
3423     MovDir[x][y] = game.balloon_dir;
3424     MovDelay[x][y] = 0;
3425   }
3426   else if (element == EL_SPRING)
3427   {
3428     if (MovDir[x][y] & MV_HORIZONTAL &&
3429         (!IN_LEV_FIELD_AND_IS_FREE(move_x, move_y) ||
3430          IN_LEV_FIELD_AND_IS_FREE(x, y + 1)))
3431       MovDir[x][y] = MV_NO_MOVING;
3432
3433     MovDelay[x][y] = 0;
3434   }
3435   else if (element == EL_ROBOT ||
3436            element == EL_SATELLITE ||
3437            element == EL_PENGUIN)
3438   {
3439     int attr_x = -1, attr_y = -1;
3440
3441     if (AllPlayersGone)
3442     {
3443       attr_x = ExitX;
3444       attr_y = ExitY;
3445     }
3446     else
3447     {
3448       int i;
3449
3450       for (i=0; i<MAX_PLAYERS; i++)
3451       {
3452         struct PlayerInfo *player = &stored_player[i];
3453         int jx = player->jx, jy = player->jy;
3454
3455         if (!player->active)
3456           continue;
3457
3458         if (attr_x == -1 ||
3459             ABS(jx - x) + ABS(jy - y) < ABS(attr_x - x) + ABS(attr_y - y))
3460         {
3461           attr_x = jx;
3462           attr_y = jy;
3463         }
3464       }
3465     }
3466
3467     if (element == EL_ROBOT && ZX >= 0 && ZY >= 0)
3468     {
3469       attr_x = ZX;
3470       attr_y = ZY;
3471     }
3472
3473     if (element == EL_PENGUIN)
3474     {
3475       int i;
3476       static int xy[4][2] =
3477       {
3478         { 0, -1 },
3479         { -1, 0 },
3480         { +1, 0 },
3481         { 0, +1 }
3482       };
3483
3484       for (i=0; i<4; i++)
3485       {
3486         int ex = x + xy[i % 4][0];
3487         int ey = y + xy[i % 4][1];
3488
3489         if (IN_LEV_FIELD(ex, ey) && Feld[ex][ey] == EL_EXIT_OPEN)
3490         {
3491           attr_x = ex;
3492           attr_y = ey;
3493           break;
3494         }
3495       }
3496     }
3497
3498     MovDir[x][y] = MV_NO_MOVING;
3499     if (attr_x < x)
3500       MovDir[x][y] |= (AllPlayersGone ? MV_RIGHT : MV_LEFT);
3501     else if (attr_x > x)
3502       MovDir[x][y] |= (AllPlayersGone ? MV_LEFT : MV_RIGHT);
3503     if (attr_y < y)
3504       MovDir[x][y] |= (AllPlayersGone ? MV_DOWN : MV_UP);
3505     else if (attr_y > y)
3506       MovDir[x][y] |= (AllPlayersGone ? MV_UP : MV_DOWN);
3507
3508     if (element == EL_ROBOT)
3509     {
3510       int newx, newy;
3511
3512       if (MovDir[x][y] & MV_HORIZONTAL && MovDir[x][y] & MV_VERTICAL)
3513         MovDir[x][y] &= (RND(2) ? MV_HORIZONTAL : MV_VERTICAL);
3514       Moving2Blocked(x, y, &newx, &newy);
3515
3516       if (IN_LEV_FIELD(newx, newy) && IS_FREE_OR_PLAYER(newx, newy))
3517         MovDelay[x][y] = 8 + 8 * !RND(3);
3518       else
3519         MovDelay[x][y] = 16;
3520     }
3521     else if (element == EL_PENGUIN)
3522     {
3523       int newx, newy;
3524
3525       MovDelay[x][y] = 1;
3526
3527       if (MovDir[x][y] & MV_HORIZONTAL && MovDir[x][y] & MV_VERTICAL)
3528       {
3529         boolean first_horiz = RND(2);
3530         int new_move_dir = MovDir[x][y];
3531
3532         MovDir[x][y] =
3533           new_move_dir & (first_horiz ? MV_HORIZONTAL : MV_VERTICAL);
3534         Moving2Blocked(x, y, &newx, &newy);
3535
3536         if (PENGUIN_CAN_ENTER_FIELD(newx, newy))
3537           return;
3538
3539         MovDir[x][y] =
3540           new_move_dir & (!first_horiz ? MV_HORIZONTAL : MV_VERTICAL);
3541         Moving2Blocked(x, y, &newx, &newy);
3542
3543         if (PENGUIN_CAN_ENTER_FIELD(newx, newy))
3544           return;
3545
3546         MovDir[x][y] = old_move_dir;
3547         return;
3548       }
3549     }
3550     else        /* (element == EL_SATELLITE) */
3551     {
3552       int newx, newy;
3553
3554       MovDelay[x][y] = 1;
3555
3556       if (MovDir[x][y] & MV_HORIZONTAL && MovDir[x][y] & MV_VERTICAL)
3557       {
3558         boolean first_horiz = RND(2);
3559         int new_move_dir = MovDir[x][y];
3560
3561         MovDir[x][y] =
3562           new_move_dir & (first_horiz ? MV_HORIZONTAL : MV_VERTICAL);
3563         Moving2Blocked(x, y, &newx, &newy);
3564
3565         if (ELEMENT_CAN_ENTER_FIELD_OR_ACID_2(newx, newy))
3566           return;
3567
3568         MovDir[x][y] =
3569           new_move_dir & (!first_horiz ? MV_HORIZONTAL : MV_VERTICAL);
3570         Moving2Blocked(x, y, &newx, &newy);
3571
3572         if (ELEMENT_CAN_ENTER_FIELD_OR_ACID_2(newx, newy))
3573           return;
3574
3575         MovDir[x][y] = old_move_dir;
3576         return;
3577       }
3578     }
3579   }
3580   else if (element_info[element].move_pattern == MV_ALL_DIRECTIONS ||
3581            element_info[element].move_pattern == MV_TURNING_LEFT ||
3582            element_info[element].move_pattern == MV_TURNING_RIGHT)
3583   {
3584     boolean can_turn_left  = ELEMENT_CAN_ENTER_FIELD(element, left_x, left_y);
3585     boolean can_turn_right = ELEMENT_CAN_ENTER_FIELD(element, right_x,right_y);
3586
3587     if (element_info[element].move_pattern == MV_TURNING_LEFT)
3588       MovDir[x][y] = left_dir;
3589     else if (element_info[element].move_pattern == MV_TURNING_RIGHT)
3590       MovDir[x][y] = right_dir;
3591     else if (can_turn_left && can_turn_right)
3592       MovDir[x][y] = (RND(3) ? (RND(2) ? left_dir : right_dir) : back_dir);
3593     else if (can_turn_left)
3594       MovDir[x][y] = (RND(2) ? left_dir : back_dir);
3595     else if (can_turn_right)
3596       MovDir[x][y] = (RND(2) ? right_dir : back_dir);
3597     else
3598       MovDir[x][y] = back_dir;
3599
3600     MovDelay[x][y] = GET_NEW_MOVE_DELAY(element);
3601   }
3602   else if (element_info[element].move_pattern == MV_HORIZONTAL ||
3603            element_info[element].move_pattern == MV_VERTICAL)
3604   {
3605     if (element_info[element].move_pattern & old_move_dir)
3606       MovDir[x][y] = back_dir;
3607     else if (element_info[element].move_pattern == MV_HORIZONTAL)
3608       MovDir[x][y] = (RND(2) ? MV_LEFT : MV_RIGHT);
3609     else if (element_info[element].move_pattern == MV_VERTICAL)
3610       MovDir[x][y] = (RND(2) ? MV_UP : MV_DOWN);
3611
3612     MovDelay[x][y] = GET_NEW_MOVE_DELAY(element);
3613   }
3614   else if (element_info[element].move_pattern & MV_ANY_DIRECTION)
3615   {
3616     MovDir[x][y] = element_info[element].move_pattern;
3617     MovDelay[x][y] = GET_NEW_MOVE_DELAY(element);
3618   }
3619   else if (element_info[element].move_pattern == MV_ALONG_LEFT_SIDE)
3620   {
3621     if (ELEMENT_CAN_ENTER_FIELD(element, left_x, left_y))
3622       MovDir[x][y] = left_dir;
3623     else if (!ELEMENT_CAN_ENTER_FIELD(element, move_x, move_y))
3624       MovDir[x][y] = right_dir;
3625
3626     if (MovDir[x][y] != old_move_dir)
3627       MovDelay[x][y] = GET_NEW_MOVE_DELAY(element);
3628   }
3629   else if (element_info[element].move_pattern == MV_ALONG_RIGHT_SIDE)
3630   {
3631     if (ELEMENT_CAN_ENTER_FIELD(element, right_x, right_y))
3632       MovDir[x][y] = right_dir;
3633     else if (!ELEMENT_CAN_ENTER_FIELD(element, move_x, move_y))
3634       MovDir[x][y] = left_dir;
3635
3636     if (MovDir[x][y] != old_move_dir)
3637       MovDelay[x][y] = GET_NEW_MOVE_DELAY(element);
3638   }
3639   else if (element_info[element].move_pattern == MV_TOWARDS_PLAYER ||
3640            element_info[element].move_pattern == MV_AWAY_FROM_PLAYER)
3641   {
3642     int attr_x = -1, attr_y = -1;
3643     int newx, newy;
3644     boolean move_away =
3645       (element_info[element].move_pattern == MV_AWAY_FROM_PLAYER);
3646
3647     if (AllPlayersGone)
3648     {
3649       attr_x = ExitX;
3650       attr_y = ExitY;
3651     }
3652     else
3653     {
3654       int i;
3655
3656       for (i=0; i<MAX_PLAYERS; i++)
3657       {
3658         struct PlayerInfo *player = &stored_player[i];
3659         int jx = player->jx, jy = player->jy;
3660
3661         if (!player->active)
3662           continue;
3663
3664         if (attr_x == -1 ||
3665             ABS(jx - x) + ABS(jy - y) < ABS(attr_x - x) + ABS(attr_y - y))
3666         {
3667           attr_x = jx;
3668           attr_y = jy;
3669         }
3670       }
3671     }
3672
3673     MovDir[x][y] = MV_NO_MOVING;
3674     if (attr_x < x)
3675       MovDir[x][y] |= (move_away ? MV_RIGHT : MV_LEFT);
3676     else if (attr_x > x)
3677       MovDir[x][y] |= (move_away ? MV_LEFT : MV_RIGHT);
3678     if (attr_y < y)
3679       MovDir[x][y] |= (move_away ? MV_DOWN : MV_UP);
3680     else if (attr_y > y)
3681       MovDir[x][y] |= (move_away ? MV_UP : MV_DOWN);
3682
3683     MovDelay[x][y] = GET_NEW_MOVE_DELAY(element);
3684
3685     if (MovDir[x][y] & MV_HORIZONTAL && MovDir[x][y] & MV_VERTICAL)
3686     {
3687       boolean first_horiz = RND(2);
3688       int new_move_dir = MovDir[x][y];
3689
3690       MovDir[x][y] =
3691         new_move_dir & (first_horiz ? MV_HORIZONTAL : MV_VERTICAL);
3692       Moving2Blocked(x, y, &newx, &newy);
3693
3694       if (ELEMENT_CAN_ENTER_FIELD_OR_ACID(element, newx, newy))
3695         return;
3696
3697       MovDir[x][y] =
3698         new_move_dir & (!first_horiz ? MV_HORIZONTAL : MV_VERTICAL);
3699       Moving2Blocked(x, y, &newx, &newy);
3700
3701       if (ELEMENT_CAN_ENTER_FIELD_OR_ACID(element, newx, newy))
3702         return;
3703
3704       MovDir[x][y] = old_move_dir;
3705     }
3706   }
3707   else if (element_info[element].move_pattern == MV_WHEN_PUSHED)
3708   {
3709     if (!IN_LEV_FIELD_AND_IS_FREE(move_x, move_y))
3710       MovDir[x][y] = MV_NO_MOVING;
3711
3712     MovDelay[x][y] = 0;
3713   }
3714 }
3715
3716 static boolean JustBeingPushed(int x, int y)
3717 {
3718   int i;
3719
3720   for (i=0; i<MAX_PLAYERS; i++)
3721   {
3722     struct PlayerInfo *player = &stored_player[i];
3723
3724     if (player->active && player->Pushing && player->MovPos)
3725     {
3726       int next_jx = player->jx + (player->jx - player->last_jx);
3727       int next_jy = player->jy + (player->jy - player->last_jy);
3728
3729       if (x == next_jx && y == next_jy)
3730         return TRUE;
3731     }
3732   }
3733
3734   return FALSE;
3735 }
3736
3737 void StartMoving(int x, int y)
3738 {
3739   boolean use_spring_bug = (game.engine_version < VERSION_IDENT(2,2,0));
3740   boolean started_moving = FALSE;       /* some elements can fall _and_ move */
3741   int element = Feld[x][y];
3742
3743   if (Stop[x][y])
3744     return;
3745
3746   /* !!! this should be handled more generic (not only for mole) !!! */
3747   if (element != EL_MOLE && GfxAction[x][y] != ACTION_DIGGING)
3748     GfxAction[x][y] = ACTION_DEFAULT;
3749
3750   if (CAN_FALL(element) && y < lev_fieldy - 1)
3751   {
3752     if ((x > 0 && IS_PLAYER(x - 1, y)) ||
3753         (x < lev_fieldx-1 && IS_PLAYER(x + 1, y)))
3754       if (JustBeingPushed(x, y))
3755         return;
3756
3757     if (element == EL_QUICKSAND_FULL)
3758     {
3759       if (IS_FREE(x, y + 1))
3760       {
3761         InitMovingField(x, y, MV_DOWN);
3762         started_moving = TRUE;
3763
3764         Feld[x][y] = EL_QUICKSAND_EMPTYING;
3765         Store[x][y] = EL_ROCK;
3766 #if 1
3767         PlaySoundLevelAction(x, y, ACTION_EMPTYING);
3768 #else
3769         PlaySoundLevel(x, y, SND_QUICKSAND_EMPTYING);
3770 #endif
3771       }
3772       else if (Feld[x][y + 1] == EL_QUICKSAND_EMPTY)
3773       {
3774         if (!MovDelay[x][y])
3775           MovDelay[x][y] = TILEY + 1;
3776
3777         if (MovDelay[x][y])
3778         {
3779           MovDelay[x][y]--;
3780           if (MovDelay[x][y])
3781             return;
3782         }
3783
3784         Feld[x][y] = EL_QUICKSAND_EMPTY;
3785         Feld[x][y + 1] = EL_QUICKSAND_FULL;
3786         Store[x][y + 1] = Store[x][y];
3787         Store[x][y] = 0;
3788 #if 1
3789         PlaySoundLevelAction(x, y, ACTION_FILLING);
3790 #else
3791         PlaySoundLevel(x, y, SND_QUICKSAND_FILLING);
3792 #endif
3793       }
3794     }
3795     else if ((element == EL_ROCK || element == EL_BD_ROCK) &&
3796              Feld[x][y + 1] == EL_QUICKSAND_EMPTY)
3797     {
3798       InitMovingField(x, y, MV_DOWN);
3799       started_moving = TRUE;
3800
3801       Feld[x][y] = EL_QUICKSAND_FILLING;
3802       Store[x][y] = element;
3803 #if 1
3804       PlaySoundLevelAction(x, y, ACTION_FILLING);
3805 #else
3806       PlaySoundLevel(x, y, SND_QUICKSAND_FILLING);
3807 #endif
3808     }
3809     else if (element == EL_MAGIC_WALL_FULL)
3810     {
3811       if (IS_FREE(x, y + 1))
3812       {
3813         InitMovingField(x, y, MV_DOWN);
3814         started_moving = TRUE;
3815
3816         Feld[x][y] = EL_MAGIC_WALL_EMPTYING;
3817         Store[x][y] = EL_CHANGED(Store[x][y]);
3818       }
3819       else if (Feld[x][y + 1] == EL_MAGIC_WALL_ACTIVE)
3820       {
3821         if (!MovDelay[x][y])
3822           MovDelay[x][y] = TILEY/4 + 1;
3823
3824         if (MovDelay[x][y])
3825         {
3826           MovDelay[x][y]--;
3827           if (MovDelay[x][y])
3828             return;
3829         }
3830
3831         Feld[x][y] = EL_MAGIC_WALL_ACTIVE;
3832         Feld[x][y + 1] = EL_MAGIC_WALL_FULL;
3833         Store[x][y + 1] = EL_CHANGED(Store[x][y]);
3834         Store[x][y] = 0;
3835       }
3836     }
3837     else if (element == EL_BD_MAGIC_WALL_FULL)
3838     {
3839       if (IS_FREE(x, y + 1))
3840       {
3841         InitMovingField(x, y, MV_DOWN);
3842         started_moving = TRUE;
3843
3844         Feld[x][y] = EL_BD_MAGIC_WALL_EMPTYING;
3845         Store[x][y] = EL_CHANGED2(Store[x][y]);
3846       }
3847       else if (Feld[x][y + 1] == EL_BD_MAGIC_WALL_ACTIVE)
3848       {
3849         if (!MovDelay[x][y])
3850           MovDelay[x][y] = TILEY/4 + 1;
3851
3852         if (MovDelay[x][y])
3853         {
3854           MovDelay[x][y]--;
3855           if (MovDelay[x][y])
3856             return;
3857         }
3858
3859         Feld[x][y] = EL_BD_MAGIC_WALL_ACTIVE;
3860         Feld[x][y + 1] = EL_BD_MAGIC_WALL_FULL;
3861         Store[x][y + 1] = EL_CHANGED2(Store[x][y]);
3862         Store[x][y] = 0;
3863       }
3864     }
3865     else if (CAN_PASS_MAGIC_WALL(element) &&
3866              (Feld[x][y + 1] == EL_MAGIC_WALL_ACTIVE ||
3867               Feld[x][y + 1] == EL_BD_MAGIC_WALL_ACTIVE))
3868     {
3869       InitMovingField(x, y, MV_DOWN);
3870       started_moving = TRUE;
3871
3872       Feld[x][y] =
3873         (Feld[x][y + 1] == EL_MAGIC_WALL_ACTIVE ? EL_MAGIC_WALL_FILLING :
3874          EL_BD_MAGIC_WALL_FILLING);
3875       Store[x][y] = element;
3876     }
3877 #if 0
3878     else if (CAN_SMASH(element) && Feld[x][y + 1] == EL_ACID)
3879 #else
3880     else if (CAN_FALL(element) && Feld[x][y + 1] == EL_ACID)
3881 #endif
3882     {
3883       SplashAcid(x, y);
3884
3885       InitMovingField(x, y, MV_DOWN);
3886       started_moving = TRUE;
3887
3888       Store[x][y] = EL_ACID;
3889 #if 0
3890       /* !!! TEST !!! better use "_FALLING" etc. !!! */
3891       GfxAction[x][y + 1] = ACTION_ACTIVE;
3892 #endif
3893     }
3894 #if 1
3895
3896 #if 0
3897     /* TEST: bug where player gets not killed by falling rock ... */
3898     else if (CAN_SMASH(element) &&
3899              (Feld[x][y + 1] == EL_BLOCKED ||
3900               IS_PLAYER(x, y + 1)) &&
3901              JustStopped[x][y] && !Pushed[x][y + 1])
3902
3903 #else
3904 #if 1
3905     else if (game.engine_version < RELEASE_IDENT(2,2,0,7) &&
3906              CAN_SMASH(element) && Feld[x][y + 1] == EL_BLOCKED &&
3907              JustStopped[x][y] && !Pushed[x][y + 1])
3908 #else
3909     else if (CAN_SMASH(element) && Feld[x][y + 1] == EL_BLOCKED &&
3910              JustStopped[x][y])
3911 #endif
3912 #endif
3913
3914     {
3915       /* calling "Impact()" here is not only completely unneccessary
3916          (because it already gets called from "ContinueMoving()" in
3917          all relevant situations), but also completely bullshit, because
3918          "JustStopped" also indicates a finished *horizontal* movement;
3919          we must keep this trash for backwards compatibility with older
3920          tapes */
3921
3922       Impact(x, y);
3923     }
3924 #endif
3925     else if (IS_FREE(x, y + 1) && element == EL_SPRING && use_spring_bug)
3926     {
3927       if (MovDir[x][y] == MV_NO_MOVING)
3928       {
3929         InitMovingField(x, y, MV_DOWN);
3930         started_moving = TRUE;
3931       }
3932     }
3933     else if (IS_FREE(x, y + 1) || Feld[x][y + 1] == EL_DIAMOND_BREAKING)
3934     {
3935       if (JustStopped[x][y])    /* prevent animation from being restarted */
3936         MovDir[x][y] = MV_DOWN;
3937
3938       InitMovingField(x, y, MV_DOWN);
3939       started_moving = TRUE;
3940     }
3941     else if (element == EL_AMOEBA_DROP)
3942     {
3943       Feld[x][y] = EL_AMOEBA_GROWING;
3944       Store[x][y] = EL_AMOEBA_WET;
3945     }
3946     /* Store[x][y + 1] must be zero, because:
3947        (EL_QUICKSAND_FULL -> EL_ROCK): Store[x][y + 1] == EL_QUICKSAND_EMPTY
3948     */
3949 #if 0
3950 #if OLD_GAME_BEHAVIOUR
3951     else if (IS_SLIPPERY(Feld[x][y + 1]) && !Store[x][y + 1])
3952 #else
3953     else if (IS_SLIPPERY(Feld[x][y + 1]) && !Store[x][y + 1] &&
3954              !IS_FALLING(x, y + 1) && !JustStopped[x][y + 1] &&
3955              element != EL_DX_SUPABOMB)
3956 #endif
3957 #else
3958     else if (((IS_SLIPPERY(Feld[x][y + 1]) && !IS_PLAYER(x, y + 1)) ||
3959               (IS_EM_SLIPPERY_WALL(Feld[x][y + 1]) && IS_GEM(element))) &&
3960              !IS_FALLING(x, y + 1) && !JustStopped[x][y + 1] &&
3961              element != EL_DX_SUPABOMB && element != EL_SP_DISK_ORANGE)
3962 #endif
3963     {
3964       boolean can_fall_left  = (x > 0 && IS_FREE(x - 1, y) &&
3965                                 (IS_FREE(x - 1, y + 1) ||
3966                                  Feld[x - 1][y + 1] == EL_ACID));
3967       boolean can_fall_right = (x < lev_fieldx - 1 && IS_FREE(x + 1, y) &&
3968                                 (IS_FREE(x + 1, y + 1) ||
3969                                  Feld[x + 1][y + 1] == EL_ACID));
3970       boolean can_fall_any  = (can_fall_left || can_fall_right);
3971       boolean can_fall_both = (can_fall_left && can_fall_right);
3972
3973       if (can_fall_any && IS_CUSTOM_ELEMENT(Feld[x][y + 1]))
3974       {
3975         int slippery_type = element_info[Feld[x][y + 1]].slippery_type;
3976
3977         if (slippery_type == SLIPPERY_ONLY_LEFT)
3978           can_fall_right = FALSE;
3979         else if (slippery_type == SLIPPERY_ONLY_RIGHT)
3980           can_fall_left = FALSE;
3981         else if (slippery_type == SLIPPERY_ANY_LEFT_RIGHT && can_fall_both)
3982           can_fall_right = FALSE;
3983         else if (slippery_type == SLIPPERY_ANY_RIGHT_LEFT && can_fall_both)
3984           can_fall_left = FALSE;
3985
3986         can_fall_any  = (can_fall_left || can_fall_right);
3987         can_fall_both = (can_fall_left && can_fall_right);
3988       }
3989
3990       if (can_fall_any)
3991       {
3992         if (can_fall_both &&
3993             (game.emulation != EMU_BOULDERDASH &&
3994              element != EL_BD_ROCK && element != EL_BD_DIAMOND))
3995           can_fall_left = !(can_fall_right = RND(2));
3996
3997         InitMovingField(x, y, can_fall_left ? MV_LEFT : MV_RIGHT);
3998         started_moving = TRUE;
3999       }
4000     }
4001     else if (IS_BELT_ACTIVE(Feld[x][y + 1]))
4002     {
4003       boolean left_is_free  = (x > 0 && IS_FREE(x - 1, y));
4004       boolean right_is_free = (x < lev_fieldx - 1 && IS_FREE(x + 1, y));
4005       int belt_nr = getBeltNrFromBeltActiveElement(Feld[x][y + 1]);
4006       int belt_dir = game.belt_dir[belt_nr];
4007
4008       if ((belt_dir == MV_LEFT  && left_is_free) ||
4009           (belt_dir == MV_RIGHT && right_is_free))
4010       {
4011         InitMovingField(x, y, belt_dir);
4012         started_moving = TRUE;
4013
4014         GfxAction[x][y] = ACTION_DEFAULT;
4015       }
4016     }
4017   }
4018
4019   /* not "else if" because of elements that can fall and move (EL_SPRING) */
4020   if (CAN_MOVE(element) && !started_moving)
4021   {
4022     int newx, newy;
4023
4024 #if 1
4025     if (IS_PUSHABLE(element) && JustBeingPushed(x, y))
4026       return;
4027 #else
4028     if ((element == EL_SATELLITE ||
4029          element == EL_BALLOON ||
4030          element == EL_SPRING)
4031         && JustBeingPushed(x, y))
4032       return;
4033 #endif
4034
4035 #if 0
4036 #if 0
4037     if (element == EL_SPRING && MovDir[x][y] == MV_DOWN)
4038       Feld[x][y + 1] = EL_EMPTY;        /* was set to EL_BLOCKED above */
4039 #else
4040     if (element == EL_SPRING && MovDir[x][y] != MV_NO_MOVING)
4041     {
4042       Moving2Blocked(x, y, &newx, &newy);
4043       if (Feld[newx][newy] == EL_BLOCKED)
4044         Feld[newx][newy] = EL_EMPTY;    /* was set to EL_BLOCKED above */
4045     }
4046 #endif
4047 #endif
4048
4049     if (!MovDelay[x][y])        /* start new movement phase */
4050     {
4051       /* all objects that can change their move direction after each step
4052          (YAMYAM, DARK_YAMYAM and PACMAN go straight until they hit a wall */
4053
4054       if (element != EL_YAMYAM &&
4055           element != EL_DARK_YAMYAM &&
4056           element != EL_PACMAN &&
4057           !(element_info[element].move_pattern & MV_ANY_DIRECTION) &&
4058           element_info[element].move_pattern != MV_TURNING_LEFT &&
4059           element_info[element].move_pattern != MV_TURNING_RIGHT)
4060       {
4061         TurnRound(x, y);
4062
4063         if (MovDelay[x][y] && (element == EL_BUG ||
4064                                element == EL_SPACESHIP ||
4065                                element == EL_SP_SNIKSNAK ||
4066                                element == EL_SP_ELECTRON ||
4067                                element == EL_MOLE))
4068           DrawLevelField(x, y);
4069       }
4070     }
4071
4072     if (MovDelay[x][y])         /* wait some time before next movement */
4073     {
4074       MovDelay[x][y]--;
4075
4076 #if 0
4077       if (element == EL_YAMYAM)
4078       {
4079         printf("::: %d\n",
4080                el_act_dir2img(EL_YAMYAM, ACTION_WAITING, MV_LEFT));
4081         DrawLevelElementAnimation(x, y, element);
4082       }
4083 #endif
4084
4085       if (MovDelay[x][y])       /* element still has to wait some time */
4086       {
4087 #if 0
4088         /* !!! PLACE THIS SOMEWHERE AFTER "TurnRound()" !!! */
4089         ResetGfxAnimation(x, y);
4090 #endif
4091         GfxAction[x][y] = ACTION_WAITING;
4092       }
4093
4094       if (element == EL_ROBOT ||
4095 #if 0
4096           element == EL_PACMAN ||
4097 #endif
4098           element == EL_YAMYAM ||
4099           element == EL_DARK_YAMYAM)
4100       {
4101 #if 0
4102         DrawLevelElementAnimation(x, y, element);
4103 #else
4104         DrawLevelElementAnimationIfNeeded(x, y, element);
4105 #endif
4106         PlaySoundLevelAction(x, y, ACTION_WAITING);
4107       }
4108       else if (element == EL_SP_ELECTRON)
4109         DrawLevelElementAnimationIfNeeded(x, y, element);
4110       else if (element == EL_DRAGON)
4111       {
4112         int i;
4113         int dir = MovDir[x][y];
4114         int dx = (dir == MV_LEFT ? -1 : dir == MV_RIGHT ? +1 : 0);
4115         int dy = (dir == MV_UP   ? -1 : dir == MV_DOWN  ? +1 : 0);
4116         int graphic = (dir == MV_LEFT   ? IMG_FLAMES_1_LEFT :
4117                        dir == MV_RIGHT  ? IMG_FLAMES_1_RIGHT :
4118                        dir == MV_UP     ? IMG_FLAMES_1_UP :
4119                        dir == MV_DOWN   ? IMG_FLAMES_1_DOWN : IMG_EMPTY);
4120         int frame = getGraphicAnimationFrame(graphic, -1);
4121
4122         for (i=1; i<=3; i++)
4123         {
4124           int xx = x + i*dx, yy = y + i*dy;
4125           int sx = SCREENX(xx), sy = SCREENY(yy);
4126           int flame_graphic = graphic + (i - 1);
4127
4128           if (!IN_LEV_FIELD(xx, yy) || IS_DRAGONFIRE_PROOF(Feld[xx][yy]))
4129             break;
4130
4131           if (MovDelay[x][y])
4132           {
4133             int flamed = MovingOrBlocked2Element(xx, yy);
4134
4135             if (IS_CLASSIC_ENEMY(flamed) || CAN_EXPLODE_BY_FIRE(flamed))
4136               Bang(xx, yy);
4137             else
4138               RemoveMovingField(xx, yy);
4139
4140             Feld[xx][yy] = EL_FLAMES;
4141             if (IN_SCR_FIELD(sx, sy))
4142               DrawGraphic(sx, sy, flame_graphic, frame);
4143           }
4144           else
4145           {
4146             if (Feld[xx][yy] == EL_FLAMES)
4147               Feld[xx][yy] = EL_EMPTY;
4148             DrawLevelField(xx, yy);
4149           }
4150         }
4151       }
4152
4153       if (MovDelay[x][y])       /* element still has to wait some time */
4154       {
4155         PlaySoundLevelAction(x, y, ACTION_WAITING);
4156
4157         return;
4158       }
4159
4160       /* special case of "moving" animation of waiting elements (FIX THIS !!!);
4161          for all other elements GfxAction will be set by InitMovingField() */
4162       if (element == EL_BD_BUTTERFLY || element == EL_BD_FIREFLY)
4163         GfxAction[x][y] = ACTION_MOVING;
4164     }
4165
4166     /* now make next step */
4167
4168     Moving2Blocked(x, y, &newx, &newy); /* get next screen position */
4169
4170     if (DONT_COLLIDE_WITH(element) &&
4171         IN_LEV_FIELD(newx, newy) && IS_PLAYER(newx, newy) &&
4172         !PLAYER_PROTECTED(newx, newy))
4173     {
4174 #if 1
4175       TestIfBadThingRunsIntoHero(x, y, MovDir[x][y]);
4176       return;
4177 #else
4178       /* player killed by element which is deadly when colliding with */
4179       MovDir[x][y] = 0;
4180       KillHero(PLAYERINFO(newx, newy));
4181       return;
4182 #endif
4183
4184     }
4185     else if ((element == EL_PENGUIN ||
4186               element == EL_ROBOT ||
4187               element == EL_SATELLITE ||
4188               element == EL_BALLOON ||
4189               IS_CUSTOM_ELEMENT(element)) &&
4190              IN_LEV_FIELD(newx, newy) &&
4191              MovDir[x][y] == MV_DOWN && Feld[newx][newy] == EL_ACID)
4192     {
4193       SplashAcid(x, y);
4194       Store[x][y] = EL_ACID;
4195     }
4196     else if (element == EL_PENGUIN && IN_LEV_FIELD(newx, newy))
4197     {
4198       if (Feld[newx][newy] == EL_EXIT_OPEN)
4199       {
4200         Feld[x][y] = EL_EMPTY;
4201         DrawLevelField(x, y);
4202
4203         PlaySoundLevel(newx, newy, SND_PENGUIN_PASSING);
4204         if (IN_SCR_FIELD(SCREENX(newx), SCREENY(newy)))
4205           DrawGraphicThruMask(SCREENX(newx),SCREENY(newy), el2img(element), 0);
4206
4207         local_player->friends_still_needed--;
4208         if (!local_player->friends_still_needed &&
4209             !local_player->GameOver && AllPlayersGone)
4210           local_player->LevelSolved = local_player->GameOver = TRUE;
4211
4212         return;
4213       }
4214       else if (IS_FOOD_PENGUIN(Feld[newx][newy]))
4215       {
4216         if (DigField(local_player, newx, newy, 0, 0, DF_DIG) == MF_MOVING)
4217           DrawLevelField(newx, newy);
4218         else
4219           MovDir[x][y] = MV_NO_MOVING;
4220       }
4221       else if (!IS_FREE(newx, newy))
4222       {
4223         GfxAction[x][y] = ACTION_WAITING;
4224
4225         if (IS_PLAYER(x, y))
4226           DrawPlayerField(x, y);
4227         else
4228           DrawLevelField(x, y);
4229         return;
4230       }
4231     }
4232     else if (element == EL_PIG && IN_LEV_FIELD(newx, newy))
4233     {
4234       if (IS_FOOD_PIG(Feld[newx][newy]))
4235       {
4236         if (IS_MOVING(newx, newy))
4237           RemoveMovingField(newx, newy);
4238         else
4239         {
4240           Feld[newx][newy] = EL_EMPTY;
4241           DrawLevelField(newx, newy);
4242         }
4243
4244         PlaySoundLevel(x, y, SND_PIG_DIGGING);
4245       }
4246       else if (!IS_FREE(newx, newy))
4247       {
4248         if (IS_PLAYER(x, y))
4249           DrawPlayerField(x, y);
4250         else
4251           DrawLevelField(x, y);
4252         return;
4253       }
4254     }
4255     else if (element == EL_DRAGON && IN_LEV_FIELD(newx, newy))
4256     {
4257       if (!IS_FREE(newx, newy))
4258       {
4259         if (IS_PLAYER(x, y))
4260           DrawPlayerField(x, y);
4261         else
4262           DrawLevelField(x, y);
4263         return;
4264       }
4265       else
4266       {
4267         boolean wanna_flame = !RND(10);
4268         int dx = newx - x, dy = newy - y;
4269         int newx1 = newx+1*dx, newy1 = newy+1*dy;
4270         int newx2 = newx+2*dx, newy2 = newy+2*dy;
4271         int element1 = (IN_LEV_FIELD(newx1, newy1) ?
4272                         MovingOrBlocked2Element(newx1, newy1) : EL_STEELWALL);
4273         int element2 = (IN_LEV_FIELD(newx2, newy2) ?
4274                         MovingOrBlocked2Element(newx2, newy2) : EL_STEELWALL);
4275
4276         if ((wanna_flame ||
4277              IS_CLASSIC_ENEMY(element1) ||
4278              IS_CLASSIC_ENEMY(element2)) &&
4279             element1 != EL_DRAGON && element2 != EL_DRAGON &&
4280             element1 != EL_FLAMES && element2 != EL_FLAMES)
4281         {
4282 #if 1
4283           ResetGfxAnimation(x, y);
4284           GfxAction[x][y] = ACTION_ATTACKING;
4285 #endif
4286
4287           if (IS_PLAYER(x, y))
4288             DrawPlayerField(x, y);
4289           else
4290             DrawLevelField(x, y);
4291
4292           PlaySoundLevel(x, y, SND_DRAGON_ATTACKING);
4293
4294           MovDelay[x][y] = 50;
4295           Feld[newx][newy] = EL_FLAMES;
4296           if (IN_LEV_FIELD(newx1, newy1) && Feld[newx1][newy1] == EL_EMPTY)
4297             Feld[newx1][newy1] = EL_FLAMES;
4298           if (IN_LEV_FIELD(newx2, newy2) && Feld[newx2][newy2] == EL_EMPTY)
4299             Feld[newx2][newy2] = EL_FLAMES;
4300
4301           return;
4302         }
4303       }
4304     }
4305     else if (element == EL_YAMYAM && IN_LEV_FIELD(newx, newy) &&
4306              Feld[newx][newy] == EL_DIAMOND)
4307     {
4308       if (IS_MOVING(newx, newy))
4309         RemoveMovingField(newx, newy);
4310       else
4311       {
4312         Feld[newx][newy] = EL_EMPTY;
4313         DrawLevelField(newx, newy);
4314       }
4315
4316       PlaySoundLevel(x, y, SND_YAMYAM_DIGGING);
4317     }
4318     else if (element == EL_DARK_YAMYAM && IN_LEV_FIELD(newx, newy) &&
4319              IS_FOOD_DARK_YAMYAM(Feld[newx][newy]))
4320     {
4321       if (AmoebaNr[newx][newy])
4322       {
4323         AmoebaCnt2[AmoebaNr[newx][newy]]--;
4324         if (Feld[newx][newy] == EL_AMOEBA_FULL ||
4325             Feld[newx][newy] == EL_BD_AMOEBA)
4326           AmoebaCnt[AmoebaNr[newx][newy]]--;
4327       }
4328
4329       if (IS_MOVING(newx, newy))
4330         RemoveMovingField(newx, newy);
4331       else
4332       {
4333         Feld[newx][newy] = EL_EMPTY;
4334         DrawLevelField(newx, newy);
4335       }
4336
4337       PlaySoundLevel(x, y, SND_DARK_YAMYAM_DIGGING);
4338     }
4339     else if ((element == EL_PACMAN || element == EL_MOLE)
4340              && IN_LEV_FIELD(newx, newy) && IS_AMOEBOID(Feld[newx][newy]))
4341     {
4342       if (AmoebaNr[newx][newy])
4343       {
4344         AmoebaCnt2[AmoebaNr[newx][newy]]--;
4345         if (Feld[newx][newy] == EL_AMOEBA_FULL ||
4346             Feld[newx][newy] == EL_BD_AMOEBA)
4347           AmoebaCnt[AmoebaNr[newx][newy]]--;
4348       }
4349
4350       if (element == EL_MOLE)
4351       {
4352         Feld[newx][newy] = EL_AMOEBA_SHRINKING;
4353         PlaySoundLevel(x, y, SND_MOLE_DIGGING);
4354
4355         ResetGfxAnimation(x, y);
4356         GfxAction[x][y] = ACTION_DIGGING;
4357         DrawLevelField(x, y);
4358
4359         MovDelay[newx][newy] = 0;       /* start amoeba shrinking delay */
4360         return;                         /* wait for shrinking amoeba */
4361       }
4362       else      /* element == EL_PACMAN */
4363       {
4364         Feld[newx][newy] = EL_EMPTY;
4365         DrawLevelField(newx, newy);
4366         PlaySoundLevel(x, y, SND_PACMAN_DIGGING);
4367       }
4368     }
4369     else if (element == EL_MOLE && IN_LEV_FIELD(newx, newy) &&
4370              (Feld[newx][newy] == EL_AMOEBA_SHRINKING ||
4371               (Feld[newx][newy] == EL_EMPTY && Stop[newx][newy])))
4372     {
4373       /* wait for shrinking amoeba to completely disappear */
4374       return;
4375     }
4376     else if (!IN_LEV_FIELD(newx, newy) || !IS_FREE(newx, newy))
4377     {
4378       /* object was running against a wall */
4379
4380       TurnRound(x, y);
4381
4382 #if 1
4383       if (GFX_ELEMENT(element) != EL_SAND)     /* !!! FIX THIS (crumble) !!! */
4384         DrawLevelElementAnimation(x, y, element);
4385 #else
4386       if (element == EL_BUG ||
4387           element == EL_SPACESHIP ||
4388           element == EL_SP_SNIKSNAK)
4389         DrawLevelField(x, y);
4390       else if (element == EL_MOLE)
4391         DrawLevelField(x, y);
4392       else if (element == EL_BD_BUTTERFLY ||
4393                element == EL_BD_FIREFLY)
4394         DrawLevelElementAnimationIfNeeded(x, y, element);
4395       else if (element == EL_SATELLITE)
4396         DrawLevelElementAnimationIfNeeded(x, y, element);
4397       else if (element == EL_SP_ELECTRON)
4398         DrawLevelElementAnimationIfNeeded(x, y, element);
4399 #endif
4400
4401       if (DONT_TOUCH(element))
4402         TestIfBadThingTouchesHero(x, y);
4403
4404 #if 0
4405       PlaySoundLevelAction(x, y, ACTION_WAITING);
4406 #endif
4407
4408       return;
4409     }
4410
4411     InitMovingField(x, y, MovDir[x][y]);
4412
4413     PlaySoundLevelAction(x, y, ACTION_MOVING);
4414   }
4415
4416   if (MovDir[x][y])
4417     ContinueMoving(x, y);
4418 }
4419
4420 void ContinueMoving(int x, int y)
4421 {
4422   int element = Feld[x][y];
4423   int direction = MovDir[x][y];
4424   int dx = (direction == MV_LEFT ? -1 : direction == MV_RIGHT ? +1 : 0);
4425   int dy = (direction == MV_UP   ? -1 : direction == MV_DOWN  ? +1 : 0);
4426   int newx = x + dx, newy = y + dy;
4427   int nextx = newx + dx, nexty = newy + dy;
4428   boolean pushed = Pushed[x][y];
4429
4430   MovPos[x][y] += getElementMoveStepsize(x, y);
4431
4432   if (pushed)           /* special case: moving object pushed by player */
4433     MovPos[x][y] = SIGN(MovPos[x][y]) * (TILEX - ABS(PLAYERINFO(x,y)->MovPos));
4434
4435   if (ABS(MovPos[x][y]) < TILEX)
4436   {
4437     DrawLevelField(x, y);
4438
4439     return;     /* element is still moving */
4440   }
4441
4442   /* element reached destination field */
4443
4444   Feld[x][y] = EL_EMPTY;
4445   Feld[newx][newy] = element;
4446   MovPos[x][y] = 0;     /* force "not moving" for "crumbled sand" */
4447
4448   if (element == EL_MOLE)
4449   {
4450     Feld[x][y] = EL_SAND;
4451
4452     DrawLevelFieldCrumbledSandNeighbours(x, y);
4453   }
4454   else if (element == EL_QUICKSAND_FILLING)
4455   {
4456     element = Feld[newx][newy] = get_next_element(element);
4457     Store[newx][newy] = Store[x][y];
4458   }
4459   else if (element == EL_QUICKSAND_EMPTYING)
4460   {
4461     Feld[x][y] = get_next_element(element);
4462     element = Feld[newx][newy] = Store[x][y];
4463   }
4464   else if (element == EL_MAGIC_WALL_FILLING)
4465   {
4466     element = Feld[newx][newy] = get_next_element(element);
4467     if (!game.magic_wall_active)
4468       element = Feld[newx][newy] = EL_MAGIC_WALL_DEAD;
4469     Store[newx][newy] = Store[x][y];
4470   }
4471   else if (element == EL_MAGIC_WALL_EMPTYING)
4472   {
4473     Feld[x][y] = get_next_element(element);
4474     if (!game.magic_wall_active)
4475       Feld[x][y] = EL_MAGIC_WALL_DEAD;
4476     element = Feld[newx][newy] = Store[x][y];
4477   }
4478   else if (element == EL_BD_MAGIC_WALL_FILLING)
4479   {
4480     element = Feld[newx][newy] = get_next_element(element);
4481     if (!game.magic_wall_active)
4482       element = Feld[newx][newy] = EL_BD_MAGIC_WALL_DEAD;
4483     Store[newx][newy] = Store[x][y];
4484   }
4485   else if (element == EL_BD_MAGIC_WALL_EMPTYING)
4486   {
4487     Feld[x][y] = get_next_element(element);
4488     if (!game.magic_wall_active)
4489       Feld[x][y] = EL_BD_MAGIC_WALL_DEAD;
4490     element = Feld[newx][newy] = Store[x][y];
4491   }
4492   else if (element == EL_AMOEBA_DROPPING)
4493   {
4494     Feld[x][y] = get_next_element(element);
4495     element = Feld[newx][newy] = Store[x][y];
4496   }
4497   else if (element == EL_SOKOBAN_OBJECT)
4498   {
4499     if (Back[x][y])
4500       Feld[x][y] = Back[x][y];
4501
4502     if (Back[newx][newy])
4503       Feld[newx][newy] = EL_SOKOBAN_FIELD_FULL;
4504
4505     Back[x][y] = Back[newx][newy] = 0;
4506   }
4507   else if (Store[x][y] == EL_ACID)
4508   {
4509     element = Feld[newx][newy] = EL_ACID;
4510   }
4511
4512   Store[x][y] = 0;
4513   MovPos[x][y] = MovDir[x][y] = MovDelay[x][y] = 0;
4514   MovDelay[newx][newy] = 0;
4515
4516   /* copy element change control values to new field */
4517   ChangeDelay[newx][newy] = ChangeDelay[x][y];
4518   ChangePage[newx][newy] = ChangePage[x][y];
4519   Changed[newx][newy] = Changed[x][y];
4520   ChangeEvent[newx][newy] = ChangeEvent[x][y];
4521
4522   ChangeDelay[x][y] = 0;
4523   ChangePage[x][y] = -1;
4524   Changed[x][y] = CE_BITMASK_DEFAULT;
4525   ChangeEvent[x][y] = CE_BITMASK_DEFAULT;
4526
4527   /* copy animation control values to new field */
4528   GfxFrame[newx][newy]  = GfxFrame[x][y];
4529   GfxAction[newx][newy] = GfxAction[x][y];      /* keep action one frame */
4530   GfxRandom[newx][newy] = GfxRandom[x][y];      /* keep same random value */
4531
4532   Pushed[x][y] = Pushed[newx][newy] = FALSE;
4533
4534   ResetGfxAnimation(x, y);      /* reset animation values for old field */
4535
4536 #if 0
4537   /* 2.1.1 (does not work correctly for spring) */
4538   if (!CAN_MOVE(element))
4539     MovDir[newx][newy] = 0;
4540 #else
4541
4542 #if 0
4543   /* (does not work for falling objects that slide horizontally) */
4544   if (CAN_FALL(element) && MovDir[newx][newy] == MV_DOWN)
4545     MovDir[newx][newy] = 0;
4546 #else
4547   /*
4548   if (!CAN_MOVE(element) ||
4549       (element == EL_SPRING && MovDir[newx][newy] == MV_DOWN))
4550     MovDir[newx][newy] = 0;
4551   */
4552
4553   if (!CAN_MOVE(element) ||
4554       (CAN_FALL(element) && MovDir[newx][newy] == MV_DOWN))
4555     MovDir[newx][newy] = 0;
4556 #endif
4557 #endif
4558
4559   DrawLevelField(x, y);
4560   DrawLevelField(newx, newy);
4561
4562   Stop[newx][newy] = TRUE;      /* ignore this element until the next frame */
4563
4564   /* prevent pushed element from moving on in pushed direction */
4565   if (pushed && CAN_MOVE(element) &&
4566       element_info[element].move_pattern & MV_ANY_DIRECTION &&
4567       !(element_info[element].move_pattern & MovDir[newx][newy]))
4568     TurnRound(newx, newy);
4569
4570   if (!pushed)  /* special case: moving object pushed by player */
4571     JustStopped[newx][newy] = 3;
4572
4573   if (DONT_TOUCH(element))      /* object may be nasty to player or others */
4574   {
4575     TestIfBadThingTouchesHero(newx, newy);
4576     TestIfBadThingTouchesFriend(newx, newy);
4577     TestIfBadThingTouchesOtherBadThing(newx, newy);
4578   }
4579   else if (element == EL_PENGUIN)
4580     TestIfFriendTouchesBadThing(newx, newy);
4581
4582   if (CAN_FALL(element) && direction == MV_DOWN &&
4583       (newy == lev_fieldy - 1 || !IS_FREE(x, newy + 1)))
4584     Impact(x, newy);
4585
4586 #if 1
4587   TestIfElementTouchesCustomElement(x, y);              /* for empty space */
4588 #endif
4589
4590 #if 0
4591   if (ChangePage[newx][newy] != -1)                     /* delayed change */
4592     ChangeElement(newx, newy, ChangePage[newx][newy]);
4593 #endif
4594
4595   if (!IN_LEV_FIELD(nextx, nexty) || !IS_FREE(nextx, nexty))
4596     CheckElementSideChange(newx, newy, Feld[newx][newy], direction,
4597                            CE_COLLISION, -1);
4598
4599   TestIfPlayerTouchesCustomElement(newx, newy);
4600   TestIfElementTouchesCustomElement(newx, newy);
4601 }
4602
4603 int AmoebeNachbarNr(int ax, int ay)
4604 {
4605   int i;
4606   int element = Feld[ax][ay];
4607   int group_nr = 0;
4608   static int xy[4][2] =
4609   {
4610     { 0, -1 },
4611     { -1, 0 },
4612     { +1, 0 },
4613     { 0, +1 }
4614   };
4615
4616   for (i=0; i<4; i++)
4617   {
4618     int x = ax + xy[i][0];
4619     int y = ay + xy[i][1];
4620
4621     if (!IN_LEV_FIELD(x, y))
4622       continue;
4623
4624     if (Feld[x][y] == element && AmoebaNr[x][y] > 0)
4625       group_nr = AmoebaNr[x][y];
4626   }
4627
4628   return group_nr;
4629 }
4630
4631 void AmoebenVereinigen(int ax, int ay)
4632 {
4633   int i, x, y, xx, yy;
4634   int new_group_nr = AmoebaNr[ax][ay];
4635   static int xy[4][2] =
4636   {
4637     { 0, -1 },
4638     { -1, 0 },
4639     { +1, 0 },
4640     { 0, +1 }
4641   };
4642
4643   if (new_group_nr == 0)
4644     return;
4645
4646   for (i=0; i<4; i++)
4647   {
4648     x = ax + xy[i][0];
4649     y = ay + xy[i][1];
4650
4651     if (!IN_LEV_FIELD(x, y))
4652       continue;
4653
4654     if ((Feld[x][y] == EL_AMOEBA_FULL ||
4655          Feld[x][y] == EL_BD_AMOEBA ||
4656          Feld[x][y] == EL_AMOEBA_DEAD) &&
4657         AmoebaNr[x][y] != new_group_nr)
4658     {
4659       int old_group_nr = AmoebaNr[x][y];
4660
4661       if (old_group_nr == 0)
4662         return;
4663
4664       AmoebaCnt[new_group_nr] += AmoebaCnt[old_group_nr];
4665       AmoebaCnt[old_group_nr] = 0;
4666       AmoebaCnt2[new_group_nr] += AmoebaCnt2[old_group_nr];
4667       AmoebaCnt2[old_group_nr] = 0;
4668
4669       for (yy=0; yy<lev_fieldy; yy++)
4670       {
4671         for (xx=0; xx<lev_fieldx; xx++)
4672         {
4673           if (AmoebaNr[xx][yy] == old_group_nr)
4674             AmoebaNr[xx][yy] = new_group_nr;
4675         }
4676       }
4677     }
4678   }
4679 }
4680
4681 void AmoebeUmwandeln(int ax, int ay)
4682 {
4683   int i, x, y;
4684
4685   if (Feld[ax][ay] == EL_AMOEBA_DEAD)
4686   {
4687     int group_nr = AmoebaNr[ax][ay];
4688
4689 #ifdef DEBUG
4690     if (group_nr == 0)
4691     {
4692       printf("AmoebeUmwandeln(): ax = %d, ay = %d\n", ax, ay);
4693       printf("AmoebeUmwandeln(): This should never happen!\n");
4694       return;
4695     }
4696 #endif
4697
4698     for (y=0; y<lev_fieldy; y++)
4699     {
4700       for (x=0; x<lev_fieldx; x++)
4701       {
4702         if (Feld[x][y] == EL_AMOEBA_DEAD && AmoebaNr[x][y] == group_nr)
4703         {
4704           AmoebaNr[x][y] = 0;
4705           Feld[x][y] = EL_AMOEBA_TO_DIAMOND;
4706         }
4707       }
4708     }
4709     PlaySoundLevel(ax, ay, (IS_GEM(level.amoeba_content) ?
4710                             SND_AMOEBA_TURNING_TO_GEM :
4711                             SND_AMOEBA_TURNING_TO_ROCK));
4712     Bang(ax, ay);
4713   }
4714   else
4715   {
4716     static int xy[4][2] =
4717     {
4718       { 0, -1 },
4719       { -1, 0 },
4720       { +1, 0 },
4721       { 0, +1 }
4722     };
4723
4724     for (i=0; i<4; i++)
4725     {
4726       x = ax + xy[i][0];
4727       y = ay + xy[i][1];
4728
4729       if (!IN_LEV_FIELD(x, y))
4730         continue;
4731
4732       if (Feld[x][y] == EL_AMOEBA_TO_DIAMOND)
4733       {
4734         PlaySoundLevel(x, y, (IS_GEM(level.amoeba_content) ?
4735                               SND_AMOEBA_TURNING_TO_GEM :
4736                               SND_AMOEBA_TURNING_TO_ROCK));
4737         Bang(x, y);
4738       }
4739     }
4740   }
4741 }
4742
4743 void AmoebeUmwandelnBD(int ax, int ay, int new_element)
4744 {
4745   int x, y;
4746   int group_nr = AmoebaNr[ax][ay];
4747   boolean done = FALSE;
4748
4749 #ifdef DEBUG
4750   if (group_nr == 0)
4751   {
4752     printf("AmoebeUmwandelnBD(): ax = %d, ay = %d\n", ax, ay);
4753     printf("AmoebeUmwandelnBD(): This should never happen!\n");
4754     return;
4755   }
4756 #endif
4757
4758   for (y=0; y<lev_fieldy; y++)
4759   {
4760     for (x=0; x<lev_fieldx; x++)
4761     {
4762       if (AmoebaNr[x][y] == group_nr &&
4763           (Feld[x][y] == EL_AMOEBA_DEAD ||
4764            Feld[x][y] == EL_BD_AMOEBA ||
4765            Feld[x][y] == EL_AMOEBA_GROWING))
4766       {
4767         AmoebaNr[x][y] = 0;
4768         Feld[x][y] = new_element;
4769         InitField(x, y, FALSE);
4770         DrawLevelField(x, y);
4771         done = TRUE;
4772       }
4773     }
4774   }
4775
4776   if (done)
4777     PlaySoundLevel(ax, ay, (new_element == EL_BD_ROCK ?
4778                             SND_BD_AMOEBA_TURNING_TO_ROCK :
4779                             SND_BD_AMOEBA_TURNING_TO_GEM));
4780 }
4781
4782 void AmoebeWaechst(int x, int y)
4783 {
4784   static unsigned long sound_delay = 0;
4785   static unsigned long sound_delay_value = 0;
4786
4787   if (!MovDelay[x][y])          /* start new growing cycle */
4788   {
4789     MovDelay[x][y] = 7;
4790
4791     if (DelayReached(&sound_delay, sound_delay_value))
4792     {
4793 #if 1
4794       PlaySoundLevelElementAction(x, y, Store[x][y], ACTION_GROWING);
4795 #else
4796       if (Store[x][y] == EL_BD_AMOEBA)
4797         PlaySoundLevel(x, y, SND_BD_AMOEBA_GROWING);
4798       else
4799         PlaySoundLevel(x, y, SND_AMOEBA_GROWING);
4800 #endif
4801       sound_delay_value = 30;
4802     }
4803   }
4804
4805   if (MovDelay[x][y])           /* wait some time before growing bigger */
4806   {
4807     MovDelay[x][y]--;
4808     if (MovDelay[x][y]/2 && IN_SCR_FIELD(SCREENX(x), SCREENY(y)))
4809     {
4810       int frame = getGraphicAnimationFrame(IMG_AMOEBA_GROWING,
4811                                            6 - MovDelay[x][y]);
4812
4813       DrawGraphic(SCREENX(x), SCREENY(y), IMG_AMOEBA_GROWING, frame);
4814     }
4815
4816     if (!MovDelay[x][y])
4817     {
4818       Feld[x][y] = Store[x][y];
4819       Store[x][y] = 0;
4820       DrawLevelField(x, y);
4821     }
4822   }
4823 }
4824
4825 void AmoebaDisappearing(int x, int y)
4826 {
4827   static unsigned long sound_delay = 0;
4828   static unsigned long sound_delay_value = 0;
4829
4830   if (!MovDelay[x][y])          /* start new shrinking cycle */
4831   {
4832     MovDelay[x][y] = 7;
4833
4834     if (DelayReached(&sound_delay, sound_delay_value))
4835       sound_delay_value = 30;
4836   }
4837
4838   if (MovDelay[x][y])           /* wait some time before shrinking */
4839   {
4840     MovDelay[x][y]--;
4841     if (MovDelay[x][y]/2 && IN_SCR_FIELD(SCREENX(x), SCREENY(y)))
4842     {
4843       int frame = getGraphicAnimationFrame(IMG_AMOEBA_SHRINKING,
4844                                            6 - MovDelay[x][y]);
4845
4846       DrawGraphic(SCREENX(x), SCREENY(y), IMG_AMOEBA_SHRINKING, frame);
4847     }
4848
4849     if (!MovDelay[x][y])
4850     {
4851       Feld[x][y] = EL_EMPTY;
4852       DrawLevelField(x, y);
4853
4854       /* don't let mole enter this field in this cycle;
4855          (give priority to objects falling to this field from above) */
4856       Stop[x][y] = TRUE;
4857     }
4858   }
4859 }
4860
4861 void AmoebeAbleger(int ax, int ay)
4862 {
4863   int i;
4864   int element = Feld[ax][ay];
4865   int graphic = el2img(element);
4866   int newax = ax, neway = ay;
4867   static int xy[4][2] =
4868   {
4869     { 0, -1 },
4870     { -1, 0 },
4871     { +1, 0 },
4872     { 0, +1 }
4873   };
4874
4875   if (!level.amoeba_speed)
4876   {
4877     Feld[ax][ay] = EL_AMOEBA_DEAD;
4878     DrawLevelField(ax, ay);
4879     return;
4880   }
4881
4882   if (IS_ANIMATED(graphic))
4883     DrawLevelGraphicAnimationIfNeeded(ax, ay, graphic);
4884
4885   if (!MovDelay[ax][ay])        /* start making new amoeba field */
4886     MovDelay[ax][ay] = RND(FRAMES_PER_SECOND * 25 / (1 + level.amoeba_speed));
4887
4888   if (MovDelay[ax][ay])         /* wait some time before making new amoeba */
4889   {
4890     MovDelay[ax][ay]--;
4891     if (MovDelay[ax][ay])
4892       return;
4893   }
4894
4895   if (element == EL_AMOEBA_WET) /* object is an acid / amoeba drop */
4896   {
4897     int start = RND(4);
4898     int x = ax + xy[start][0];
4899     int y = ay + xy[start][1];
4900
4901     if (!IN_LEV_FIELD(x, y))
4902       return;
4903
4904     /* !!! extend EL_SAND to anything diggable (but maybe not SP_BASE) !!! */
4905     if (IS_FREE(x, y) ||
4906         Feld[x][y] == EL_SAND || Feld[x][y] == EL_QUICKSAND_EMPTY)
4907     {
4908       newax = x;
4909       neway = y;
4910     }
4911
4912     if (newax == ax && neway == ay)
4913       return;
4914   }
4915   else                          /* normal or "filled" (BD style) amoeba */
4916   {
4917     int start = RND(4);
4918     boolean waiting_for_player = FALSE;
4919
4920     for (i=0; i<4; i++)
4921     {
4922       int j = (start + i) % 4;
4923       int x = ax + xy[j][0];
4924       int y = ay + xy[j][1];
4925
4926       if (!IN_LEV_FIELD(x, y))
4927         continue;
4928
4929       /* !!! extend EL_SAND to anything diggable (but maybe not SP_BASE) !!! */
4930       if (IS_FREE(x, y) ||
4931           Feld[x][y] == EL_SAND || Feld[x][y] == EL_QUICKSAND_EMPTY)
4932       {
4933         newax = x;
4934         neway = y;
4935         break;
4936       }
4937       else if (IS_PLAYER(x, y))
4938         waiting_for_player = TRUE;
4939     }
4940
4941     if (newax == ax && neway == ay)             /* amoeba cannot grow */
4942     {
4943       if (i == 4 && (!waiting_for_player || game.emulation == EMU_BOULDERDASH))
4944       {
4945         Feld[ax][ay] = EL_AMOEBA_DEAD;
4946         DrawLevelField(ax, ay);
4947         AmoebaCnt[AmoebaNr[ax][ay]]--;
4948
4949         if (AmoebaCnt[AmoebaNr[ax][ay]] <= 0)   /* amoeba is completely dead */
4950         {
4951           if (element == EL_AMOEBA_FULL)
4952             AmoebeUmwandeln(ax, ay);
4953           else if (element == EL_BD_AMOEBA)
4954             AmoebeUmwandelnBD(ax, ay, level.amoeba_content);
4955         }
4956       }
4957       return;
4958     }
4959     else if (element == EL_AMOEBA_FULL || element == EL_BD_AMOEBA)
4960     {
4961       /* amoeba gets larger by growing in some direction */
4962
4963       int new_group_nr = AmoebaNr[ax][ay];
4964
4965 #ifdef DEBUG
4966   if (new_group_nr == 0)
4967   {
4968     printf("AmoebeAbleger(): newax = %d, neway = %d\n", newax, neway);
4969     printf("AmoebeAbleger(): This should never happen!\n");
4970     return;
4971   }
4972 #endif
4973
4974       AmoebaNr[newax][neway] = new_group_nr;
4975       AmoebaCnt[new_group_nr]++;
4976       AmoebaCnt2[new_group_nr]++;
4977
4978       /* if amoeba touches other amoeba(s) after growing, unify them */
4979       AmoebenVereinigen(newax, neway);
4980
4981       if (element == EL_BD_AMOEBA && AmoebaCnt2[new_group_nr] >= 200)
4982       {
4983         AmoebeUmwandelnBD(newax, neway, EL_BD_ROCK);
4984         return;
4985       }
4986     }
4987   }
4988
4989   if (element != EL_AMOEBA_WET || neway < ay || !IS_FREE(newax, neway) ||
4990       (neway == lev_fieldy - 1 && newax != ax))
4991   {
4992     Feld[newax][neway] = EL_AMOEBA_GROWING;     /* creation of new amoeba */
4993     Store[newax][neway] = element;
4994   }
4995   else if (neway == ay)
4996   {
4997     Feld[newax][neway] = EL_AMOEBA_DROP;        /* drop left/right of amoeba */
4998 #if 1
4999     PlaySoundLevelAction(newax, neway, ACTION_GROWING);
5000 #else
5001     PlaySoundLevel(newax, neway, SND_AMOEBA_GROWING);
5002 #endif
5003   }
5004   else
5005   {
5006     InitMovingField(ax, ay, MV_DOWN);           /* drop dripping from amoeba */
5007     Feld[ax][ay] = EL_AMOEBA_DROPPING;
5008     Store[ax][ay] = EL_AMOEBA_DROP;
5009     ContinueMoving(ax, ay);
5010     return;
5011   }
5012
5013   DrawLevelField(newax, neway);
5014 }
5015
5016 void Life(int ax, int ay)
5017 {
5018   int x1, y1, x2, y2;
5019   static int life[4] = { 2, 3, 3, 3 };  /* parameters for "game of life" */
5020   int life_time = 40;
5021   int element = Feld[ax][ay];
5022   int graphic = el2img(element);
5023   boolean changed = FALSE;
5024
5025   if (IS_ANIMATED(graphic))
5026     DrawLevelGraphicAnimationIfNeeded(ax, ay, graphic);
5027
5028   if (Stop[ax][ay])
5029     return;
5030
5031   if (!MovDelay[ax][ay])        /* start new "game of life" cycle */
5032     MovDelay[ax][ay] = life_time;
5033
5034   if (MovDelay[ax][ay])         /* wait some time before next cycle */
5035   {
5036     MovDelay[ax][ay]--;
5037     if (MovDelay[ax][ay])
5038       return;
5039   }
5040
5041   for (y1=-1; y1<2; y1++) for(x1=-1; x1<2; x1++)
5042   {
5043     int xx = ax+x1, yy = ay+y1;
5044     int nachbarn = 0;
5045
5046     if (!IN_LEV_FIELD(xx, yy))
5047       continue;
5048
5049     for (y2=-1; y2<2; y2++) for (x2=-1; x2<2; x2++)
5050     {
5051       int x = xx+x2, y = yy+y2;
5052
5053       if (!IN_LEV_FIELD(x, y) || (x == xx && y == yy))
5054         continue;
5055
5056       if (((Feld[x][y] == element ||
5057             (element == EL_GAME_OF_LIFE && IS_PLAYER(x, y))) &&
5058            !Stop[x][y]) ||
5059           (IS_FREE(x, y) && Stop[x][y]))
5060         nachbarn++;
5061     }
5062
5063     if (xx == ax && yy == ay)           /* field in the middle */
5064     {
5065       if (nachbarn < life[0] || nachbarn > life[1])
5066       {
5067         Feld[xx][yy] = EL_EMPTY;
5068         if (!Stop[xx][yy])
5069           DrawLevelField(xx, yy);
5070         Stop[xx][yy] = TRUE;
5071         changed = TRUE;
5072       }
5073     }
5074     /* !!! extend EL_SAND to anything diggable (but maybe not SP_BASE) !!! */
5075     else if (IS_FREE(xx, yy) || Feld[xx][yy] == EL_SAND)
5076     {                                   /* free border field */
5077       if (nachbarn >= life[2] && nachbarn <= life[3])
5078       {
5079         Feld[xx][yy] = element;
5080         MovDelay[xx][yy] = (element == EL_GAME_OF_LIFE ? 0 : life_time-1);
5081         if (!Stop[xx][yy])
5082           DrawLevelField(xx, yy);
5083         Stop[xx][yy] = TRUE;
5084         changed = TRUE;
5085       }
5086     }
5087   }
5088
5089   if (changed)
5090     PlaySoundLevel(ax, ay, element == EL_BIOMAZE ? SND_BIOMAZE_GROWING :
5091                    SND_GAME_OF_LIFE_GROWING);
5092 }
5093
5094 static void InitRobotWheel(int x, int y)
5095 {
5096   ChangeDelay[x][y] = level.time_wheel * FRAMES_PER_SECOND;
5097 }
5098
5099 static void RunRobotWheel(int x, int y)
5100 {
5101   PlaySoundLevel(x, y, SND_ROBOT_WHEEL_ACTIVE);
5102 }
5103
5104 static void StopRobotWheel(int x, int y)
5105 {
5106   if (ZX == x && ZY == y)
5107     ZX = ZY = -1;
5108 }
5109
5110 static void InitTimegateWheel(int x, int y)
5111 {
5112   ChangeDelay[x][y] = level.time_wheel * FRAMES_PER_SECOND;
5113 }
5114
5115 static void RunTimegateWheel(int x, int y)
5116 {
5117   PlaySoundLevel(x, y, SND_TIMEGATE_SWITCH_ACTIVE);
5118 }
5119
5120 void CheckExit(int x, int y)
5121 {
5122   if (local_player->gems_still_needed > 0 ||
5123       local_player->sokobanfields_still_needed > 0 ||
5124       local_player->lights_still_needed > 0)
5125   {
5126     int element = Feld[x][y];
5127     int graphic = el2img(element);
5128
5129     if (IS_ANIMATED(graphic))
5130       DrawLevelGraphicAnimationIfNeeded(x, y, graphic);
5131
5132     return;
5133   }
5134
5135   if (AllPlayersGone)   /* do not re-open exit door closed after last player */
5136     return;
5137
5138   Feld[x][y] = EL_EXIT_OPENING;
5139
5140   PlaySoundLevelNearest(x, y, SND_CLASS_EXIT_OPENING);
5141 }
5142
5143 void CheckExitSP(int x, int y)
5144 {
5145   if (local_player->gems_still_needed > 0)
5146   {
5147     int element = Feld[x][y];
5148     int graphic = el2img(element);
5149
5150     if (IS_ANIMATED(graphic))
5151       DrawLevelGraphicAnimationIfNeeded(x, y, graphic);
5152
5153     return;
5154   }
5155
5156   if (AllPlayersGone)   /* do not re-open exit door closed after last player */
5157     return;
5158
5159   Feld[x][y] = EL_SP_EXIT_OPENING;
5160
5161   PlaySoundLevelNearest(x, y, SND_CLASS_SP_EXIT_OPENING);
5162 }
5163
5164 static void CloseAllOpenTimegates()
5165 {
5166   int x, y;
5167
5168   for (y=0; y<lev_fieldy; y++)
5169   {
5170     for (x=0; x<lev_fieldx; x++)
5171     {
5172       int element = Feld[x][y];
5173
5174       if (element == EL_TIMEGATE_OPEN || element == EL_TIMEGATE_OPENING)
5175       {
5176         Feld[x][y] = EL_TIMEGATE_CLOSING;
5177 #if 1
5178         PlaySoundLevelAction(x, y, ACTION_CLOSING);
5179 #else
5180         PlaySoundLevel(x, y, SND_TIMEGATE_CLOSING);
5181 #endif
5182       }
5183     }
5184   }
5185 }
5186
5187 void EdelsteinFunkeln(int x, int y)
5188 {
5189   if (!IN_SCR_FIELD(SCREENX(x), SCREENY(y)) || IS_MOVING(x, y))
5190     return;
5191
5192   if (Feld[x][y] == EL_BD_DIAMOND)
5193     return;
5194
5195   if (MovDelay[x][y] == 0)      /* next animation frame */
5196     MovDelay[x][y] = 11 * !SimpleRND(500);
5197
5198   if (MovDelay[x][y] != 0)      /* wait some time before next frame */
5199   {
5200     MovDelay[x][y]--;
5201
5202     if (setup.direct_draw && MovDelay[x][y])
5203       SetDrawtoField(DRAW_BUFFERED);
5204
5205     DrawLevelElementAnimation(x, y, Feld[x][y]);
5206
5207     if (MovDelay[x][y] != 0)
5208     {
5209       int frame = getGraphicAnimationFrame(IMG_TWINKLE_WHITE,
5210                                            10 - MovDelay[x][y]);
5211
5212       DrawGraphicThruMask(SCREENX(x), SCREENY(y), IMG_TWINKLE_WHITE, frame);
5213
5214       if (setup.direct_draw)
5215       {
5216         int dest_x, dest_y;
5217
5218         dest_x = FX + SCREENX(x) * TILEX;
5219         dest_y = FY + SCREENY(y) * TILEY;
5220
5221         BlitBitmap(drawto_field, window,
5222                    dest_x, dest_y, TILEX, TILEY, dest_x, dest_y);
5223         SetDrawtoField(DRAW_DIRECT);
5224       }
5225     }
5226   }
5227 }
5228
5229 void MauerWaechst(int x, int y)
5230 {
5231   int delay = 6;
5232
5233   if (!MovDelay[x][y])          /* next animation frame */
5234     MovDelay[x][y] = 3 * delay;
5235
5236   if (MovDelay[x][y])           /* wait some time before next frame */
5237   {
5238     MovDelay[x][y]--;
5239
5240     if (IN_SCR_FIELD(SCREENX(x), SCREENY(y)))
5241     {
5242       int graphic = el_dir2img(Feld[x][y], MovDir[x][y]);
5243       int frame = getGraphicAnimationFrame(graphic, 17 - MovDelay[x][y]);
5244
5245       DrawGraphic(SCREENX(x), SCREENY(y), graphic, frame);
5246     }
5247
5248     if (!MovDelay[x][y])
5249     {
5250       if (MovDir[x][y] == MV_LEFT)
5251       {
5252         if (IN_LEV_FIELD(x - 1, y) && IS_WALL(Feld[x - 1][y]))
5253           DrawLevelField(x - 1, y);
5254       }
5255       else if (MovDir[x][y] == MV_RIGHT)
5256       {
5257         if (IN_LEV_FIELD(x + 1, y) && IS_WALL(Feld[x + 1][y]))
5258           DrawLevelField(x + 1, y);
5259       }
5260       else if (MovDir[x][y] == MV_UP)
5261       {
5262         if (IN_LEV_FIELD(x, y - 1) && IS_WALL(Feld[x][y - 1]))
5263           DrawLevelField(x, y - 1);
5264       }
5265       else
5266       {
5267         if (IN_LEV_FIELD(x, y + 1) && IS_WALL(Feld[x][y + 1]))
5268           DrawLevelField(x, y + 1);
5269       }
5270
5271       Feld[x][y] = Store[x][y];
5272       Store[x][y] = 0;
5273       MovDir[x][y] = MV_NO_MOVING;
5274       DrawLevelField(x, y);
5275     }
5276   }
5277 }
5278
5279 void MauerAbleger(int ax, int ay)
5280 {
5281   int element = Feld[ax][ay];
5282   int graphic = el2img(element);
5283   boolean oben_frei = FALSE, unten_frei = FALSE;
5284   boolean links_frei = FALSE, rechts_frei = FALSE;
5285   boolean oben_massiv = FALSE, unten_massiv = FALSE;
5286   boolean links_massiv = FALSE, rechts_massiv = FALSE;
5287   boolean new_wall = FALSE;
5288
5289   if (IS_ANIMATED(graphic))
5290     DrawLevelGraphicAnimationIfNeeded(ax, ay, graphic);
5291
5292   if (!MovDelay[ax][ay])        /* start building new wall */
5293     MovDelay[ax][ay] = 6;
5294
5295   if (MovDelay[ax][ay])         /* wait some time before building new wall */
5296   {
5297     MovDelay[ax][ay]--;
5298     if (MovDelay[ax][ay])
5299       return;
5300   }
5301
5302   if (IN_LEV_FIELD(ax, ay-1) && IS_FREE(ax, ay-1))
5303     oben_frei = TRUE;
5304   if (IN_LEV_FIELD(ax, ay+1) && IS_FREE(ax, ay+1))
5305     unten_frei = TRUE;
5306   if (IN_LEV_FIELD(ax-1, ay) && IS_FREE(ax-1, ay))
5307     links_frei = TRUE;
5308   if (IN_LEV_FIELD(ax+1, ay) && IS_FREE(ax+1, ay))
5309     rechts_frei = TRUE;
5310
5311   if (element == EL_EXPANDABLE_WALL_VERTICAL ||
5312       element == EL_EXPANDABLE_WALL_ANY)
5313   {
5314     if (oben_frei)
5315     {
5316       Feld[ax][ay-1] = EL_EXPANDABLE_WALL_GROWING;
5317       Store[ax][ay-1] = element;
5318       MovDir[ax][ay-1] = MV_UP;
5319       if (IN_SCR_FIELD(SCREENX(ax), SCREENY(ay-1)))
5320         DrawGraphic(SCREENX(ax), SCREENY(ay - 1),
5321                     IMG_EXPANDABLE_WALL_GROWING_UP, 0);
5322       new_wall = TRUE;
5323     }
5324     if (unten_frei)
5325     {
5326       Feld[ax][ay+1] = EL_EXPANDABLE_WALL_GROWING;
5327       Store[ax][ay+1] = element;
5328       MovDir[ax][ay+1] = MV_DOWN;
5329       if (IN_SCR_FIELD(SCREENX(ax), SCREENY(ay+1)))
5330         DrawGraphic(SCREENX(ax), SCREENY(ay + 1),
5331                     IMG_EXPANDABLE_WALL_GROWING_DOWN, 0);
5332       new_wall = TRUE;
5333     }
5334   }
5335
5336   if (element == EL_EXPANDABLE_WALL_HORIZONTAL ||
5337       element == EL_EXPANDABLE_WALL_ANY ||
5338       element == EL_EXPANDABLE_WALL)
5339   {
5340     if (links_frei)
5341     {
5342       Feld[ax-1][ay] = EL_EXPANDABLE_WALL_GROWING;
5343       Store[ax-1][ay] = element;
5344       MovDir[ax-1][ay] = MV_LEFT;
5345       if (IN_SCR_FIELD(SCREENX(ax-1), SCREENY(ay)))
5346         DrawGraphic(SCREENX(ax - 1), SCREENY(ay),
5347                     IMG_EXPANDABLE_WALL_GROWING_LEFT, 0);
5348       new_wall = TRUE;
5349     }
5350
5351     if (rechts_frei)
5352     {
5353       Feld[ax+1][ay] = EL_EXPANDABLE_WALL_GROWING;
5354       Store[ax+1][ay] = element;
5355       MovDir[ax+1][ay] = MV_RIGHT;
5356       if (IN_SCR_FIELD(SCREENX(ax+1), SCREENY(ay)))
5357         DrawGraphic(SCREENX(ax + 1), SCREENY(ay),
5358                     IMG_EXPANDABLE_WALL_GROWING_RIGHT, 0);
5359       new_wall = TRUE;
5360     }
5361   }
5362
5363   if (element == EL_EXPANDABLE_WALL && (links_frei || rechts_frei))
5364     DrawLevelField(ax, ay);
5365
5366   if (!IN_LEV_FIELD(ax, ay-1) || IS_WALL(Feld[ax][ay-1]))
5367     oben_massiv = TRUE;
5368   if (!IN_LEV_FIELD(ax, ay+1) || IS_WALL(Feld[ax][ay+1]))
5369     unten_massiv = TRUE;
5370   if (!IN_LEV_FIELD(ax-1, ay) || IS_WALL(Feld[ax-1][ay]))
5371     links_massiv = TRUE;
5372   if (!IN_LEV_FIELD(ax+1, ay) || IS_WALL(Feld[ax+1][ay]))
5373     rechts_massiv = TRUE;
5374
5375   if (((oben_massiv && unten_massiv) ||
5376        element == EL_EXPANDABLE_WALL_HORIZONTAL ||
5377        element == EL_EXPANDABLE_WALL) &&
5378       ((links_massiv && rechts_massiv) ||
5379        element == EL_EXPANDABLE_WALL_VERTICAL))
5380     Feld[ax][ay] = EL_WALL;
5381
5382   if (new_wall)
5383 #if 1
5384     PlaySoundLevelAction(ax, ay, ACTION_GROWING);
5385 #else
5386     PlaySoundLevel(ax, ay, SND_EXPANDABLE_WALL_GROWING);
5387 #endif
5388 }
5389
5390 void CheckForDragon(int x, int y)
5391 {
5392   int i, j;
5393   boolean dragon_found = FALSE;
5394   static int xy[4][2] =
5395   {
5396     { 0, -1 },
5397     { -1, 0 },
5398     { +1, 0 },
5399     { 0, +1 }
5400   };
5401
5402   for (i=0; i<4; i++)
5403   {
5404     for (j=0; j<4; j++)
5405     {
5406       int xx = x + j*xy[i][0], yy = y + j*xy[i][1];
5407
5408       if (IN_LEV_FIELD(xx, yy) &&
5409           (Feld[xx][yy] == EL_FLAMES || Feld[xx][yy] == EL_DRAGON))
5410       {
5411         if (Feld[xx][yy] == EL_DRAGON)
5412           dragon_found = TRUE;
5413       }
5414       else
5415         break;
5416     }
5417   }
5418
5419   if (!dragon_found)
5420   {
5421     for (i=0; i<4; i++)
5422     {
5423       for (j=0; j<3; j++)
5424       {
5425         int xx = x + j*xy[i][0], yy = y + j*xy[i][1];
5426
5427         if (IN_LEV_FIELD(xx, yy) && Feld[xx][yy] == EL_FLAMES)
5428         {
5429           Feld[xx][yy] = EL_EMPTY;
5430           DrawLevelField(xx, yy);
5431         }
5432         else
5433           break;
5434       }
5435     }
5436   }
5437 }
5438
5439 static void InitBuggyBase(int x, int y)
5440 {
5441   int element = Feld[x][y];
5442   int activating_delay = FRAMES_PER_SECOND / 4;
5443
5444   ChangeDelay[x][y] =
5445     (element == EL_SP_BUGGY_BASE ?
5446      2 * FRAMES_PER_SECOND + RND(5 * FRAMES_PER_SECOND) - activating_delay :
5447      element == EL_SP_BUGGY_BASE_ACTIVATING ?
5448      activating_delay :
5449      element == EL_SP_BUGGY_BASE_ACTIVE ?
5450      1 * FRAMES_PER_SECOND + RND(1 * FRAMES_PER_SECOND) : 1);
5451 }
5452
5453 static void WarnBuggyBase(int x, int y)
5454 {
5455   int i;
5456   static int xy[4][2] =
5457   {
5458     { 0, -1 },
5459     { -1, 0 },
5460     { +1, 0 },
5461     { 0, +1 }
5462   };
5463
5464   for (i=0; i<4; i++)
5465   {
5466     int xx = x + xy[i][0], yy = y + xy[i][1];
5467
5468     if (IS_PLAYER(xx, yy))
5469     {
5470       PlaySoundLevel(x, y, SND_SP_BUGGY_BASE_ACTIVE);
5471
5472       break;
5473     }
5474   }
5475 }
5476
5477 static void InitTrap(int x, int y)
5478 {
5479   ChangeDelay[x][y] = 2 * FRAMES_PER_SECOND + RND(5 * FRAMES_PER_SECOND);
5480 }
5481
5482 static void ActivateTrap(int x, int y)
5483 {
5484   PlaySoundLevel(x, y, SND_TRAP_ACTIVATING);
5485 }
5486
5487 static void ChangeActiveTrap(int x, int y)
5488 {
5489   int graphic = IMG_TRAP_ACTIVE;
5490
5491   /* if new animation frame was drawn, correct crumbled sand border */
5492   if (IS_NEW_FRAME(GfxFrame[x][y], graphic))
5493     DrawLevelFieldCrumbledSand(x, y);
5494 }
5495
5496 static void ChangeElementNowExt(int x, int y, int target_element)
5497 {
5498   /* check if element under player changes from accessible to unaccessible
5499      (needed for special case of dropping element which then changes) */
5500   if (IS_PLAYER(x, y) && !PLAYER_PROTECTED(x, y) &&
5501       IS_ACCESSIBLE(Feld[x][y]) && !IS_ACCESSIBLE(target_element))
5502   {
5503     Bang(x, y);
5504     return;
5505   }
5506
5507   RemoveField(x, y);
5508   Feld[x][y] = target_element;
5509
5510   Changed[x][y] |= ChangeEvent[x][y];   /* ignore same changes in this frame */
5511
5512   ResetGfxAnimation(x, y);
5513   ResetRandomAnimationValue(x, y);
5514
5515   InitField(x, y, FALSE);
5516   if (CAN_MOVE(Feld[x][y]))
5517     InitMovDir(x, y);
5518
5519   DrawLevelField(x, y);
5520
5521   if (GFX_CRUMBLED(Feld[x][y]))
5522     DrawLevelFieldCrumbledSandNeighbours(x, y);
5523
5524   TestIfBadThingTouchesHero(x, y);
5525   TestIfPlayerTouchesCustomElement(x, y);
5526   TestIfElementTouchesCustomElement(x, y);
5527
5528   if (ELEM_IS_PLAYER(target_element))
5529     RelocatePlayer(x, y, target_element);
5530 }
5531
5532 static boolean ChangeElementNow(int x, int y, int element, int page)
5533 {
5534   struct ElementChangeInfo *change = &element_info[element].change_page[page];
5535
5536   /* always use default change event to prevent running into a loop */
5537   if (ChangeEvent[x][y] == CE_BITMASK_DEFAULT)
5538     ChangeEvent[x][y] = CH_EVENT_BIT(CE_DELAY);
5539
5540   /* do not change already changed elements with same change event */
5541 #if 0
5542   if (Changed[x][y] & ChangeEvent[x][y])
5543     return FALSE;
5544 #else
5545   if (Changed[x][y])
5546     return FALSE;
5547 #endif
5548
5549   Changed[x][y] |= ChangeEvent[x][y];   /* ignore same changes in this frame */
5550
5551   CheckTriggeredElementChange(x, y, Feld[x][y], CE_OTHER_IS_CHANGING);
5552
5553   if (change->explode)
5554   {
5555     Bang(x, y);
5556
5557     return TRUE;
5558   }
5559
5560   if (change->use_content)
5561   {
5562     boolean complete_change = TRUE;
5563     boolean can_change[3][3];
5564     int xx, yy;
5565
5566     for (yy = 0; yy < 3; yy++) for(xx = 0; xx < 3 ; xx++)
5567     {
5568       boolean half_destructible;
5569       int ex = x + xx - 1;
5570       int ey = y + yy - 1;
5571       int e;
5572
5573       can_change[xx][yy] = TRUE;
5574
5575       if (ex == x && ey == y)   /* do not check changing element itself */
5576         continue;
5577
5578       if (change->content[xx][yy] == EL_EMPTY_SPACE)
5579       {
5580         can_change[xx][yy] = FALSE;     /* do not change empty borders */
5581
5582         continue;
5583       }
5584
5585       if (!IN_LEV_FIELD(ex, ey))
5586       {
5587         can_change[xx][yy] = FALSE;
5588         complete_change = FALSE;
5589
5590         continue;
5591       }
5592
5593       e = Feld[ex][ey];
5594
5595       if (IS_MOVING(ex, ey) || IS_BLOCKED(ex, ey))
5596         e = MovingOrBlocked2Element(ex, ey);
5597
5598       half_destructible = (IS_FREE(ex, ey) || IS_DIGGABLE(e));
5599
5600       if ((change->power <= CP_NON_DESTRUCTIVE  && !IS_FREE(ex, ey)) ||
5601           (change->power <= CP_HALF_DESTRUCTIVE && !half_destructible) ||
5602           (change->power <= CP_FULL_DESTRUCTIVE && IS_INDESTRUCTIBLE(e)))
5603       {
5604         can_change[xx][yy] = FALSE;
5605         complete_change = FALSE;
5606       }
5607     }
5608
5609     if (!change->only_complete || complete_change)
5610     {
5611       boolean something_has_changed = FALSE;
5612
5613       if (change->only_complete && change->use_random_change &&
5614           RND(100) < change->random)
5615         return FALSE;
5616
5617       for (yy = 0; yy < 3; yy++) for(xx = 0; xx < 3 ; xx++)
5618       {
5619         int ex = x + xx - 1;
5620         int ey = y + yy - 1;
5621
5622         if (can_change[xx][yy] && (!change->use_random_change ||
5623                                    RND(100) < change->random))
5624         {
5625           if (IS_MOVING(ex, ey) || IS_BLOCKED(ex, ey))
5626             RemoveMovingField(ex, ey);
5627
5628           ChangeEvent[ex][ey] = ChangeEvent[x][y];
5629
5630           ChangeElementNowExt(ex, ey, change->content[xx][yy]);
5631
5632           something_has_changed = TRUE;
5633
5634           /* for symmetry reasons, freeze newly created border elements */
5635           if (ex != x || ey != y)
5636             Stop[ex][ey] = TRUE;        /* no more moving in this frame */
5637         }
5638       }
5639
5640       if (something_has_changed)
5641         PlaySoundLevelElementAction(x, y, element, ACTION_CHANGING);
5642     }
5643   }
5644   else
5645   {
5646     ChangeElementNowExt(x, y, change->target_element);
5647
5648     PlaySoundLevelElementAction(x, y, element, ACTION_CHANGING);
5649   }
5650
5651   return TRUE;
5652 }
5653
5654 static void ChangeElement(int x, int y, int page)
5655 {
5656   int element = MovingOrBlocked2Element(x, y);
5657   struct ElementInfo *ei = &element_info[element];
5658   struct ElementChangeInfo *change = &ei->change_page[page];
5659
5660 #if 0
5661 #ifdef DEBUG
5662   if (!CAN_CHANGE(element))
5663   {
5664     printf("\n\n");
5665     printf("ChangeElement(): %d,%d: element = %d ('%s')\n",
5666            x, y, element, element_info[element].token_name);
5667     printf("ChangeElement(): This should never happen!\n");
5668     printf("\n\n");
5669   }
5670 #endif
5671 #endif
5672
5673   if (ChangeDelay[x][y] == 0)           /* initialize element change */
5674   {
5675     ChangeDelay[x][y] = (    change->delay_fixed  * change->delay_frames +
5676                          RND(change->delay_random * change->delay_frames)) + 1;
5677
5678     ResetGfxAnimation(x, y);
5679     ResetRandomAnimationValue(x, y);
5680
5681     if (change->pre_change_function)
5682       change->pre_change_function(x, y);
5683   }
5684
5685   ChangeDelay[x][y]--;
5686
5687   if (ChangeDelay[x][y] != 0)           /* continue element change */
5688   {
5689     int graphic = el_act_dir2img(element, GfxAction[x][y], MovDir[x][y]);
5690
5691     if (IS_ANIMATED(graphic))
5692       DrawLevelGraphicAnimationIfNeeded(x, y, graphic);
5693
5694     if (change->change_function)
5695       change->change_function(x, y);
5696   }
5697   else                                  /* finish element change */
5698   {
5699     if (ChangePage[x][y] != -1)         /* remember page from delayed change */
5700     {
5701       page = ChangePage[x][y];
5702       ChangePage[x][y] = -1;
5703     }
5704
5705     if (IS_MOVING(x, y))                /* never change a running system ;-) */
5706     {
5707       ChangeDelay[x][y] = 1;            /* try change after next move step */
5708       ChangePage[x][y] = page;          /* remember page to use for change */
5709
5710       return;
5711     }
5712
5713     if (ChangeElementNow(x, y, element, page))
5714     {
5715       if (change->post_change_function)
5716         change->post_change_function(x, y);
5717     }
5718   }
5719 }
5720
5721 static boolean CheckTriggeredElementSideChange(int lx, int ly,
5722                                                int trigger_element,
5723                                                int trigger_side,
5724                                                int trigger_event)
5725 {
5726   int i, j, x, y;
5727
5728   if (!(trigger_events[trigger_element] & CH_EVENT_BIT(trigger_event)))
5729     return FALSE;
5730
5731   for (i=0; i < NUM_CUSTOM_ELEMENTS; i++)
5732   {
5733     int element = EL_CUSTOM_START + i;
5734
5735     boolean change_element = FALSE;
5736     int page = 0;
5737
5738     if (!CAN_CHANGE(element) || !HAS_ANY_CHANGE_EVENT(element, trigger_event))
5739       continue;
5740
5741     for (j=0; j < element_info[element].num_change_pages; j++)
5742     {
5743       struct ElementChangeInfo *change = &element_info[element].change_page[j];
5744
5745       if (change->can_change &&
5746           change->sides & trigger_side &&
5747           change->trigger_element == trigger_element)
5748       {
5749         change_element = TRUE;
5750         page = j;
5751
5752         break;
5753       }
5754     }
5755
5756     if (!change_element)
5757       continue;
5758
5759     for (y=0; y<lev_fieldy; y++) for (x=0; x<lev_fieldx; x++)
5760     {
5761 #if 0
5762       if (x == lx && y == ly)   /* do not change trigger element itself */
5763         continue;
5764 #endif
5765
5766       if (Feld[x][y] == element)
5767       {
5768         ChangeDelay[x][y] = 1;
5769         ChangeEvent[x][y] = CH_EVENT_BIT(trigger_event);
5770         ChangeElement(x, y, page);
5771       }
5772     }
5773   }
5774
5775   return TRUE;
5776 }
5777
5778 static boolean CheckTriggeredElementChange(int lx, int ly, int trigger_element,
5779                                            int trigger_event)
5780 {
5781   return CheckTriggeredElementSideChange(lx, ly, trigger_element, CH_SIDE_ANY,
5782                                          trigger_event);
5783 }
5784
5785 static boolean CheckElementSideChange(int x, int y, int element, int side,
5786                                       int trigger_event, int page)
5787 {
5788   if (!CAN_CHANGE(element) || !HAS_ANY_CHANGE_EVENT(element, trigger_event))
5789     return FALSE;
5790
5791   if (Feld[x][y] == EL_BLOCKED)
5792   {
5793     Blocked2Moving(x, y, &x, &y);
5794     element = Feld[x][y];
5795   }
5796
5797   if (page < 0)
5798     page = element_info[element].event_page_nr[trigger_event];
5799
5800   if (!(element_info[element].change_page[page].sides & side))
5801     return FALSE;
5802
5803   ChangeDelay[x][y] = 1;
5804   ChangeEvent[x][y] = CH_EVENT_BIT(trigger_event);
5805   ChangeElement(x, y, page);
5806
5807   return TRUE;
5808 }
5809
5810 static boolean CheckElementChange(int x, int y, int element, int trigger_event)
5811 {
5812   return CheckElementSideChange(x, y, element, CH_SIDE_ANY, trigger_event, -1);
5813 }
5814
5815 static void PlayerActions(struct PlayerInfo *player, byte player_action)
5816 {
5817   static byte stored_player_action[MAX_PLAYERS];
5818   static int num_stored_actions = 0;
5819   boolean moved = FALSE, snapped = FALSE, dropped = FALSE;
5820   int left      = player_action & JOY_LEFT;
5821   int right     = player_action & JOY_RIGHT;
5822   int up        = player_action & JOY_UP;
5823   int down      = player_action & JOY_DOWN;
5824   int button1   = player_action & JOY_BUTTON_1;
5825   int button2   = player_action & JOY_BUTTON_2;
5826   int dx        = (left ? -1    : right ? 1     : 0);
5827   int dy        = (up   ? -1    : down  ? 1     : 0);
5828
5829   stored_player_action[player->index_nr] = 0;
5830   num_stored_actions++;
5831
5832   if (!player->active || tape.pausing)
5833     return;
5834
5835   if (player_action)
5836   {
5837     if (button1)
5838       snapped = SnapField(player, dx, dy);
5839     else
5840     {
5841       if (button2)
5842         dropped = DropElement(player);
5843
5844       moved = MovePlayer(player, dx, dy);
5845     }
5846
5847     if (tape.single_step && tape.recording && !tape.pausing)
5848     {
5849       if (button1 || (dropped && !moved))
5850       {
5851         TapeTogglePause(TAPE_TOGGLE_AUTOMATIC);
5852         SnapField(player, 0, 0);                /* stop snapping */
5853       }
5854     }
5855
5856     stored_player_action[player->index_nr] = player_action;
5857   }
5858   else
5859   {
5860     /* no actions for this player (no input at player's configured device) */
5861
5862     DigField(player, 0, 0, 0, 0, DF_NO_PUSH);
5863     SnapField(player, 0, 0);
5864     CheckGravityMovement(player);
5865
5866     if (player->MovPos == 0)
5867       InitPlayerGfxAnimation(player, ACTION_DEFAULT, player->MovDir);
5868
5869     if (player->MovPos == 0)    /* needed for tape.playing */
5870       player->is_moving = FALSE;
5871   }
5872
5873   if (tape.recording && num_stored_actions >= MAX_PLAYERS)
5874   {
5875     TapeRecordAction(stored_player_action);
5876     num_stored_actions = 0;
5877   }
5878 }
5879
5880 void GameActions()
5881 {
5882   static unsigned long action_delay = 0;
5883   unsigned long action_delay_value;
5884   int magic_wall_x = 0, magic_wall_y = 0;
5885   int i, x, y, element, graphic;
5886   byte *recorded_player_action;
5887   byte summarized_player_action = 0;
5888
5889   if (game_status != GAME_MODE_PLAYING)
5890     return;
5891
5892   action_delay_value =
5893     (tape.playing && tape.fast_forward ? FfwdFrameDelay : GameFrameDelay);
5894
5895   if (tape.playing && tape.index_search && !tape.pausing)
5896     action_delay_value = 0;
5897
5898   /* ---------- main game synchronization point ---------- */
5899
5900   WaitUntilDelayReached(&action_delay, action_delay_value);
5901
5902   if (network_playing && !network_player_action_received)
5903   {
5904     /*
5905 #ifdef DEBUG
5906     printf("DEBUG: try to get network player actions in time\n");
5907 #endif
5908     */
5909
5910 #if defined(PLATFORM_UNIX)
5911     /* last chance to get network player actions without main loop delay */
5912     HandleNetworking();
5913 #endif
5914
5915     if (game_status != GAME_MODE_PLAYING)
5916       return;
5917
5918     if (!network_player_action_received)
5919     {
5920       /*
5921 #ifdef DEBUG
5922       printf("DEBUG: failed to get network player actions in time\n");
5923 #endif
5924       */
5925       return;
5926     }
5927   }
5928
5929   if (tape.pausing)
5930     return;
5931
5932   recorded_player_action = (tape.playing ? TapePlayAction() : NULL);
5933
5934   for (i=0; i<MAX_PLAYERS; i++)
5935   {
5936     summarized_player_action |= stored_player[i].action;
5937
5938     if (!network_playing)
5939       stored_player[i].effective_action = stored_player[i].action;
5940   }
5941
5942 #if defined(PLATFORM_UNIX)
5943   if (network_playing)
5944     SendToServer_MovePlayer(summarized_player_action);
5945 #endif
5946
5947   if (!options.network && !setup.team_mode)
5948     local_player->effective_action = summarized_player_action;
5949
5950   for (i=0; i<MAX_PLAYERS; i++)
5951   {
5952     int actual_player_action = stored_player[i].effective_action;
5953
5954     if (stored_player[i].programmed_action)
5955       actual_player_action = stored_player[i].programmed_action;
5956
5957     if (recorded_player_action)
5958       actual_player_action = recorded_player_action[i];
5959
5960     PlayerActions(&stored_player[i], actual_player_action);
5961     ScrollPlayer(&stored_player[i], SCROLL_GO_ON);
5962   }
5963
5964   network_player_action_received = FALSE;
5965
5966   ScrollScreen(NULL, SCROLL_GO_ON);
5967
5968 #if 0
5969   FrameCounter++;
5970   TimeFrames++;
5971
5972   for (i=0; i<MAX_PLAYERS; i++)
5973     stored_player[i].Frame++;
5974 #endif
5975
5976 #if 1
5977   if (game.engine_version < RELEASE_IDENT(2,2,0,7))
5978   {
5979     for (i=0; i<MAX_PLAYERS; i++)
5980     {
5981       struct PlayerInfo *player = &stored_player[i];
5982       int x = player->jx;
5983       int y = player->jy;
5984
5985       if (player->active && player->Pushing && player->is_moving &&
5986           IS_MOVING(x, y))
5987       {
5988         ContinueMoving(x, y);
5989
5990         /* continue moving after pushing (this is actually a bug) */
5991         if (!IS_MOVING(x, y))
5992         {
5993           Stop[x][y] = FALSE;
5994         }
5995       }
5996     }
5997   }
5998 #endif
5999
6000   for (y=0; y<lev_fieldy; y++) for (x=0; x<lev_fieldx; x++)
6001   {
6002     Changed[x][y] = CE_BITMASK_DEFAULT;
6003     ChangeEvent[x][y] = CE_BITMASK_DEFAULT;
6004
6005 #if DEBUG
6006     if (ChangePage[x][y] != -1 && ChangeDelay[x][y] != 1)
6007     {
6008       printf("GameActions(): x = %d, y = %d: ChangePage != -1\n", x, y);
6009       printf("GameActions(): This should never happen!\n");
6010
6011       ChangePage[x][y] = -1;
6012     }
6013 #endif
6014
6015     Stop[x][y] = FALSE;
6016     if (JustStopped[x][y] > 0)
6017       JustStopped[x][y]--;
6018
6019     GfxFrame[x][y]++;
6020
6021 #if 1
6022     /* reset finished pushing action (not done in ContinueMoving() to allow
6023        continous pushing animation for elements with zero push delay) */
6024     if (GfxAction[x][y] == ACTION_PUSHING && !IS_MOVING(x, y))
6025     {
6026       ResetGfxAnimation(x, y);
6027       DrawLevelField(x, y);
6028     }
6029 #endif
6030
6031 #if DEBUG
6032     if (IS_BLOCKED(x, y))
6033     {
6034       int oldx, oldy;
6035
6036       Blocked2Moving(x, y, &oldx, &oldy);
6037       if (!IS_MOVING(oldx, oldy))
6038       {
6039         printf("GameActions(): (BLOCKED => MOVING) context corrupted!\n");
6040         printf("GameActions(): BLOCKED: x = %d, y = %d\n", x, y);
6041         printf("GameActions(): !MOVING: oldx = %d, oldy = %d\n", oldx, oldy);
6042         printf("GameActions(): This should never happen!\n");
6043       }
6044     }
6045 #endif
6046   }
6047
6048   for (y=0; y<lev_fieldy; y++) for (x=0; x<lev_fieldx; x++)
6049   {
6050     element = Feld[x][y];
6051 #if 1
6052     graphic = el_act_dir2img(element, GfxAction[x][y], MovDir[x][y]);
6053 #else
6054     graphic = el2img(element);
6055 #endif
6056
6057 #if 0
6058     if (element == -1)
6059     {
6060       printf("::: %d,%d: %d [%d]\n", x, y, element, FrameCounter);
6061
6062       element = graphic = 0;
6063     }
6064 #endif
6065
6066     if (graphic_info[graphic].anim_global_sync)
6067       GfxFrame[x][y] = FrameCounter;
6068
6069     if (ANIM_MODE(graphic) == ANIM_RANDOM &&
6070         IS_NEXT_FRAME(GfxFrame[x][y], graphic))
6071       ResetRandomAnimationValue(x, y);
6072
6073     SetRandomAnimationValue(x, y);
6074
6075 #if 1
6076     PlaySoundLevelActionIfLoop(x, y, GfxAction[x][y]);
6077 #endif
6078
6079     if (IS_INACTIVE(element))
6080     {
6081       if (IS_ANIMATED(graphic))
6082         DrawLevelGraphicAnimationIfNeeded(x, y, graphic);
6083
6084       continue;
6085     }
6086
6087 #if 1
6088     /* this may take place after moving, so 'element' may have changed */
6089     if (IS_CHANGING(x, y))
6090     {
6091 #if 0
6092       ChangeElement(x, y, ChangePage[x][y] != -1 ? ChangePage[x][y] :
6093                     element_info[element].event_page_nr[CE_DELAY]);
6094 #else
6095       ChangeElement(x, y, element_info[element].event_page_nr[CE_DELAY]);
6096 #endif
6097
6098       element = Feld[x][y];
6099       graphic = el_act_dir2img(element, GfxAction[x][y], MovDir[x][y]);
6100     }
6101 #endif
6102
6103     if (!IS_MOVING(x, y) && (CAN_FALL(element) || CAN_MOVE(element)))
6104     {
6105       StartMoving(x, y);
6106
6107 #if 1
6108       graphic = el_act_dir2img(element, GfxAction[x][y], MovDir[x][y]);
6109 #if 0
6110       if (element == EL_MOLE)
6111         printf("::: %d, %d, %d [%d]\n",
6112                IS_ANIMATED(graphic), IS_MOVING(x, y), Stop[x][y],
6113                GfxAction[x][y]);
6114 #endif
6115 #if 0
6116       if (element == EL_YAMYAM)
6117         printf("::: %d, %d, %d\n",
6118                IS_ANIMATED(graphic), IS_MOVING(x, y), Stop[x][y]);
6119 #endif
6120 #endif
6121
6122       if (IS_ANIMATED(graphic) &&
6123           !IS_MOVING(x, y) &&
6124           !Stop[x][y])
6125       {
6126         DrawLevelGraphicAnimationIfNeeded(x, y, graphic);
6127
6128 #if 0
6129         if (element == EL_MOLE)
6130           printf("::: %d, %d\n", graphic, GfxFrame[x][y]);
6131 #endif
6132       }
6133
6134       if (IS_GEM(element) || element == EL_SP_INFOTRON)
6135         EdelsteinFunkeln(x, y);
6136     }
6137     else if ((element == EL_ACID ||
6138               element == EL_EXIT_OPEN ||
6139               element == EL_SP_EXIT_OPEN ||
6140               element == EL_SP_TERMINAL ||
6141               element == EL_SP_TERMINAL_ACTIVE ||
6142               element == EL_EXTRA_TIME ||
6143               element == EL_SHIELD_NORMAL ||
6144               element == EL_SHIELD_DEADLY) &&
6145              IS_ANIMATED(graphic))
6146       DrawLevelGraphicAnimationIfNeeded(x, y, graphic);
6147     else if (IS_MOVING(x, y))
6148       ContinueMoving(x, y);
6149     else if (IS_ACTIVE_BOMB(element))
6150       CheckDynamite(x, y);
6151 #if 0
6152     else if (element == EL_EXPLOSION && !game.explosions_delayed)
6153       Explode(x, y, ExplodePhase[x][y], EX_NORMAL);
6154 #endif
6155     else if (element == EL_AMOEBA_GROWING)
6156       AmoebeWaechst(x, y);
6157     else if (element == EL_AMOEBA_SHRINKING)
6158       AmoebaDisappearing(x, y);
6159
6160 #if !USE_NEW_AMOEBA_CODE
6161     else if (IS_AMOEBALIVE(element))
6162       AmoebeAbleger(x, y);
6163 #endif
6164
6165     else if (element == EL_GAME_OF_LIFE || element == EL_BIOMAZE)
6166       Life(x, y);
6167     else if (element == EL_EXIT_CLOSED)
6168       CheckExit(x, y);
6169     else if (element == EL_SP_EXIT_CLOSED)
6170       CheckExitSP(x, y);
6171     else if (element == EL_EXPANDABLE_WALL_GROWING)
6172       MauerWaechst(x, y);
6173     else if (element == EL_EXPANDABLE_WALL ||
6174              element == EL_EXPANDABLE_WALL_HORIZONTAL ||
6175              element == EL_EXPANDABLE_WALL_VERTICAL ||
6176              element == EL_EXPANDABLE_WALL_ANY)
6177       MauerAbleger(x, y);
6178     else if (element == EL_FLAMES)
6179       CheckForDragon(x, y);
6180 #if 0
6181     else if (IS_AUTO_CHANGING(element))
6182       ChangeElement(x, y);
6183 #endif
6184     else if (element == EL_EXPLOSION)
6185       ; /* drawing of correct explosion animation is handled separately */
6186     else if (IS_ANIMATED(graphic) && !IS_CHANGING(x, y))
6187       DrawLevelGraphicAnimationIfNeeded(x, y, graphic);
6188
6189 #if 0
6190     /* this may take place after moving, so 'element' may have changed */
6191     if (IS_AUTO_CHANGING(Feld[x][y]))
6192       ChangeElement(x, y);
6193 #endif
6194
6195     if (IS_BELT_ACTIVE(element))
6196       PlaySoundLevelAction(x, y, ACTION_ACTIVE);
6197
6198     if (game.magic_wall_active)
6199     {
6200       int jx = local_player->jx, jy = local_player->jy;
6201
6202       /* play the element sound at the position nearest to the player */
6203       if ((element == EL_MAGIC_WALL_FULL ||
6204            element == EL_MAGIC_WALL_ACTIVE ||
6205            element == EL_MAGIC_WALL_EMPTYING ||
6206            element == EL_BD_MAGIC_WALL_FULL ||
6207            element == EL_BD_MAGIC_WALL_ACTIVE ||
6208            element == EL_BD_MAGIC_WALL_EMPTYING) &&
6209           ABS(x-jx) + ABS(y-jy) < ABS(magic_wall_x-jx) + ABS(magic_wall_y-jy))
6210       {
6211         magic_wall_x = x;
6212         magic_wall_y = y;
6213       }
6214     }
6215   }
6216
6217 #if USE_NEW_AMOEBA_CODE
6218   /* new experimental amoeba growth stuff */
6219 #if 1
6220   if (!(FrameCounter % 8))
6221 #endif
6222   {
6223     static unsigned long random = 1684108901;
6224
6225     for (i = 0; i < level.amoeba_speed * 28 / 8; i++)
6226     {
6227 #if 0
6228       x = (random >> 10) % lev_fieldx;
6229       y = (random >> 20) % lev_fieldy;
6230 #else
6231       x = RND(lev_fieldx);
6232       y = RND(lev_fieldy);
6233 #endif
6234       element = Feld[x][y];
6235
6236       /* !!! extend EL_SAND to anything diggable (but maybe not SP_BASE) !!! */
6237       if (!IS_PLAYER(x,y) &&
6238           (element == EL_EMPTY ||
6239            element == EL_SAND ||
6240            element == EL_QUICKSAND_EMPTY ||
6241            element == EL_ACID_SPLASH_LEFT ||
6242            element == EL_ACID_SPLASH_RIGHT))
6243       {
6244         if ((IN_LEV_FIELD(x, y-1) && Feld[x][y-1] == EL_AMOEBA_WET) ||
6245             (IN_LEV_FIELD(x-1, y) && Feld[x-1][y] == EL_AMOEBA_WET) ||
6246             (IN_LEV_FIELD(x+1, y) && Feld[x+1][y] == EL_AMOEBA_WET) ||
6247             (IN_LEV_FIELD(x, y+1) && Feld[x][y+1] == EL_AMOEBA_WET))
6248           Feld[x][y] = EL_AMOEBA_DROP;
6249       }
6250
6251       random = random * 129 + 1;
6252     }
6253   }
6254 #endif
6255
6256 #if 0
6257   if (game.explosions_delayed)
6258 #endif
6259   {
6260     game.explosions_delayed = FALSE;
6261
6262     for (y=0; y<lev_fieldy; y++) for (x=0; x<lev_fieldx; x++)
6263     {
6264       element = Feld[x][y];
6265
6266       if (ExplodeField[x][y])
6267         Explode(x, y, EX_PHASE_START, ExplodeField[x][y]);
6268       else if (element == EL_EXPLOSION)
6269         Explode(x, y, ExplodePhase[x][y], EX_NORMAL);
6270
6271       ExplodeField[x][y] = EX_NO_EXPLOSION;
6272     }
6273
6274     game.explosions_delayed = TRUE;
6275   }
6276
6277   if (game.magic_wall_active)
6278   {
6279     if (!(game.magic_wall_time_left % 4))
6280     {
6281       int element = Feld[magic_wall_x][magic_wall_y];
6282
6283       if (element == EL_BD_MAGIC_WALL_FULL ||
6284           element == EL_BD_MAGIC_WALL_ACTIVE ||
6285           element == EL_BD_MAGIC_WALL_EMPTYING)
6286         PlaySoundLevel(magic_wall_x, magic_wall_y, SND_BD_MAGIC_WALL_ACTIVE);
6287       else
6288         PlaySoundLevel(magic_wall_x, magic_wall_y, SND_MAGIC_WALL_ACTIVE);
6289     }
6290
6291     if (game.magic_wall_time_left > 0)
6292     {
6293       game.magic_wall_time_left--;
6294       if (!game.magic_wall_time_left)
6295       {
6296         for (y=0; y<lev_fieldy; y++) for (x=0; x<lev_fieldx; x++)
6297         {
6298           element = Feld[x][y];
6299
6300           if (element == EL_MAGIC_WALL_ACTIVE ||
6301               element == EL_MAGIC_WALL_FULL)
6302           {
6303             Feld[x][y] = EL_MAGIC_WALL_DEAD;
6304             DrawLevelField(x, y);
6305           }
6306           else if (element == EL_BD_MAGIC_WALL_ACTIVE ||
6307                    element == EL_BD_MAGIC_WALL_FULL)
6308           {
6309             Feld[x][y] = EL_BD_MAGIC_WALL_DEAD;
6310             DrawLevelField(x, y);
6311           }
6312         }
6313
6314         game.magic_wall_active = FALSE;
6315       }
6316     }
6317   }
6318
6319   if (game.light_time_left > 0)
6320   {
6321     game.light_time_left--;
6322
6323     if (game.light_time_left == 0)
6324       RedrawAllLightSwitchesAndInvisibleElements();
6325   }
6326
6327   if (game.timegate_time_left > 0)
6328   {
6329     game.timegate_time_left--;
6330
6331     if (game.timegate_time_left == 0)
6332       CloseAllOpenTimegates();
6333   }
6334
6335   for (i=0; i<MAX_PLAYERS; i++)
6336   {
6337     struct PlayerInfo *player = &stored_player[i];
6338
6339     if (SHIELD_ON(player))
6340     {
6341       if (player->shield_deadly_time_left)
6342         PlaySoundLevel(player->jx, player->jy, SND_SHIELD_DEADLY_ACTIVE);
6343       else if (player->shield_normal_time_left)
6344         PlaySoundLevel(player->jx, player->jy, SND_SHIELD_NORMAL_ACTIVE);
6345     }
6346   }
6347
6348   if (TimeFrames >= FRAMES_PER_SECOND)
6349   {
6350     TimeFrames = 0;
6351     TimePlayed++;
6352
6353     for (i=0; i<MAX_PLAYERS; i++)
6354     {
6355       struct PlayerInfo *player = &stored_player[i];
6356
6357       if (SHIELD_ON(player))
6358       {
6359         player->shield_normal_time_left--;
6360
6361         if (player->shield_deadly_time_left > 0)
6362           player->shield_deadly_time_left--;
6363       }
6364     }
6365
6366     if (tape.recording || tape.playing)
6367       DrawVideoDisplay(VIDEO_STATE_TIME_ON, TimePlayed);
6368
6369     if (TimeLeft > 0)
6370     {
6371       TimeLeft--;
6372
6373       if (TimeLeft <= 10 && setup.time_limit)
6374         PlaySoundStereo(SND_GAME_RUNNING_OUT_OF_TIME, SOUND_MIDDLE);
6375
6376       DrawText(DX_TIME, DY_TIME, int2str(TimeLeft, 3), FONT_TEXT_2);
6377
6378       if (!TimeLeft && setup.time_limit)
6379         for (i=0; i<MAX_PLAYERS; i++)
6380           KillHero(&stored_player[i]);
6381     }
6382     else if (level.time == 0 && !AllPlayersGone) /* level without time limit */
6383       DrawText(DX_TIME, DY_TIME, int2str(TimePlayed, 3), FONT_TEXT_2);
6384   }
6385
6386   DrawAllPlayers();
6387
6388   if (options.debug)                    /* calculate frames per second */
6389   {
6390     static unsigned long fps_counter = 0;
6391     static int fps_frames = 0;
6392     unsigned long fps_delay_ms = Counter() - fps_counter;
6393
6394     fps_frames++;
6395
6396     if (fps_delay_ms >= 500)    /* calculate fps every 0.5 seconds */
6397     {
6398       global.frames_per_second = 1000 * (float)fps_frames / fps_delay_ms;
6399
6400       fps_frames = 0;
6401       fps_counter = Counter();
6402     }
6403
6404     redraw_mask |= REDRAW_FPS;
6405   }
6406
6407 #if 0
6408   if (stored_player[0].jx != stored_player[0].last_jx ||
6409       stored_player[0].jy != stored_player[0].last_jy)
6410     printf("::: %d, %d, %d, %d, %d\n",
6411            stored_player[0].MovDir,
6412            stored_player[0].MovPos,
6413            stored_player[0].GfxPos,
6414            stored_player[0].Frame,
6415            stored_player[0].StepFrame);
6416 #endif
6417
6418 #if 1
6419   FrameCounter++;
6420   TimeFrames++;
6421
6422   for (i=0; i<MAX_PLAYERS; i++)
6423   {
6424     int move_frames =
6425       MOVE_DELAY_NORMAL_SPEED /  stored_player[i].move_delay_value;
6426
6427     stored_player[i].Frame += move_frames;
6428
6429     if (stored_player[i].MovPos != 0)
6430       stored_player[i].StepFrame += move_frames;
6431   }
6432 #endif
6433
6434 #if 1
6435   if (local_player->show_envelope != 0 && local_player->MovPos == 0)
6436   {
6437     ShowEnvelope(local_player->show_envelope - EL_ENVELOPE_1);
6438
6439     local_player->show_envelope = 0;
6440   }
6441 #endif
6442 }
6443
6444 static boolean AllPlayersInSight(struct PlayerInfo *player, int x, int y)
6445 {
6446   int min_x = x, min_y = y, max_x = x, max_y = y;
6447   int i;
6448
6449   for (i=0; i<MAX_PLAYERS; i++)
6450   {
6451     int jx = stored_player[i].jx, jy = stored_player[i].jy;
6452
6453     if (!stored_player[i].active || &stored_player[i] == player)
6454       continue;
6455
6456     min_x = MIN(min_x, jx);
6457     min_y = MIN(min_y, jy);
6458     max_x = MAX(max_x, jx);
6459     max_y = MAX(max_y, jy);
6460   }
6461
6462   return (max_x - min_x < SCR_FIELDX && max_y - min_y < SCR_FIELDY);
6463 }
6464
6465 static boolean AllPlayersInVisibleScreen()
6466 {
6467   int i;
6468
6469   for (i=0; i<MAX_PLAYERS; i++)
6470   {
6471     int jx = stored_player[i].jx, jy = stored_player[i].jy;
6472
6473     if (!stored_player[i].active)
6474       continue;
6475
6476     if (!IN_VIS_FIELD(SCREENX(jx), SCREENY(jy)))
6477       return FALSE;
6478   }
6479
6480   return TRUE;
6481 }
6482
6483 void ScrollLevel(int dx, int dy)
6484 {
6485   int softscroll_offset = (setup.soft_scrolling ? TILEX : 0);
6486   int x, y;
6487
6488   BlitBitmap(drawto_field, drawto_field,
6489              FX + TILEX * (dx == -1) - softscroll_offset,
6490              FY + TILEY * (dy == -1) - softscroll_offset,
6491              SXSIZE - TILEX * (dx!=0) + 2 * softscroll_offset,
6492              SYSIZE - TILEY * (dy!=0) + 2 * softscroll_offset,
6493              FX + TILEX * (dx == 1) - softscroll_offset,
6494              FY + TILEY * (dy == 1) - softscroll_offset);
6495
6496   if (dx)
6497   {
6498     x = (dx == 1 ? BX1 : BX2);
6499     for (y=BY1; y <= BY2; y++)
6500       DrawScreenField(x, y);
6501   }
6502
6503   if (dy)
6504   {
6505     y = (dy == 1 ? BY1 : BY2);
6506     for (x=BX1; x <= BX2; x++)
6507       DrawScreenField(x, y);
6508   }
6509
6510   redraw_mask |= REDRAW_FIELD;
6511 }
6512
6513 static void CheckGravityMovement(struct PlayerInfo *player)
6514 {
6515   if (game.gravity && !player->programmed_action)
6516   {
6517     int move_dir_vertical = player->action & (MV_UP | MV_DOWN);
6518     int move_dir_horizontal = player->action & (MV_LEFT | MV_RIGHT);
6519     int move_dir =
6520       (player->last_move_dir & (MV_LEFT | MV_RIGHT) ?
6521        (move_dir_vertical ? move_dir_vertical : move_dir_horizontal) :
6522        (move_dir_horizontal ? move_dir_horizontal : move_dir_vertical));
6523     int jx = player->jx, jy = player->jy;
6524     int dx = (move_dir & MV_LEFT ? -1 : move_dir & MV_RIGHT ? +1 : 0);
6525     int dy = (move_dir & MV_UP ? -1 : move_dir & MV_DOWN ? +1 : 0);
6526     int new_jx = jx + dx, new_jy = jy + dy;
6527     boolean field_under_player_is_free =
6528       (IN_LEV_FIELD(jx, jy + 1) && IS_FREE(jx, jy + 1));
6529     boolean player_is_moving_to_valid_field =
6530       (IN_LEV_FIELD(new_jx, new_jy) &&
6531        (Feld[new_jx][new_jy] == EL_SP_BASE ||
6532         Feld[new_jx][new_jy] == EL_SAND));
6533     /* !!! extend EL_SAND to anything diggable !!! */
6534
6535     if (field_under_player_is_free &&
6536         !player_is_moving_to_valid_field &&
6537         !IS_WALKABLE_INSIDE(Feld[jx][jy]))
6538       player->programmed_action = MV_DOWN;
6539   }
6540 }
6541
6542 /*
6543   MovePlayerOneStep()
6544   -----------------------------------------------------------------------------
6545   dx, dy:               direction (non-diagonal) to try to move the player to
6546   real_dx, real_dy:     direction as read from input device (can be diagonal)
6547 */
6548
6549 boolean MovePlayerOneStep(struct PlayerInfo *player,
6550                           int dx, int dy, int real_dx, int real_dy)
6551 {
6552 #if 0
6553   static int change_sides[4][2] =
6554   {
6555     /* enter side        leave side */
6556     { CH_SIDE_RIGHT,    CH_SIDE_LEFT    },      /* moving left  */
6557     { CH_SIDE_LEFT,     CH_SIDE_RIGHT   },      /* moving right */
6558     { CH_SIDE_BOTTOM,   CH_SIDE_TOP     },      /* moving up    */
6559     { CH_SIDE_TOP,      CH_SIDE_BOTTOM  }       /* moving down  */
6560   };
6561   int move_direction = (dx == -1 ? MV_LEFT :
6562                         dx == +1 ? MV_RIGHT :
6563                         dy == -1 ? MV_UP :
6564                         dy == +1 ? MV_DOWN : MV_NO_MOVING);
6565   int enter_side = change_sides[MV_DIR_BIT(move_direction)][0];
6566   int leave_side = change_sides[MV_DIR_BIT(move_direction)][1];
6567 #endif
6568   int jx = player->jx, jy = player->jy;
6569   int new_jx = jx + dx, new_jy = jy + dy;
6570   int element;
6571   int can_move;
6572
6573   if (!player->active || (!dx && !dy))
6574     return MF_NO_ACTION;
6575
6576   player->MovDir = (dx < 0 ? MV_LEFT :
6577                     dx > 0 ? MV_RIGHT :
6578                     dy < 0 ? MV_UP :
6579                     dy > 0 ? MV_DOWN :  MV_NO_MOVING);
6580
6581   if (!IN_LEV_FIELD(new_jx, new_jy))
6582     return MF_NO_ACTION;
6583
6584   if (!options.network && !AllPlayersInSight(player, new_jx, new_jy))
6585     return MF_NO_ACTION;
6586
6587 #if 0
6588   element = MovingOrBlocked2Element(new_jx, new_jy);
6589 #else
6590   element = MovingOrBlocked2ElementIfNotLeaving(new_jx, new_jy);
6591 #endif
6592
6593   if (DONT_RUN_INTO(element))
6594   {
6595     if (element == EL_ACID && dx == 0 && dy == 1)
6596     {
6597       SplashAcid(jx, jy);
6598       Feld[jx][jy] = EL_PLAYER_1;
6599       InitMovingField(jx, jy, MV_DOWN);
6600       Store[jx][jy] = EL_ACID;
6601       ContinueMoving(jx, jy);
6602       BuryHero(player);
6603     }
6604     else
6605       TestIfHeroRunsIntoBadThing(jx, jy, player->MovDir);
6606
6607     return MF_MOVING;
6608   }
6609
6610   can_move = DigField(player, new_jx, new_jy, real_dx, real_dy, DF_DIG);
6611   if (can_move != MF_MOVING)
6612     return can_move;
6613
6614   /* check if DigField() has caused relocation of the player */
6615   if (player->jx != jx || player->jy != jy)
6616     return MF_NO_ACTION;
6617
6618   StorePlayer[jx][jy] = 0;
6619   player->last_jx = jx;
6620   player->last_jy = jy;
6621   player->jx = new_jx;
6622   player->jy = new_jy;
6623   StorePlayer[new_jx][new_jy] = player->element_nr;
6624
6625   player->MovPos =
6626     (dx > 0 || dy > 0 ? -1 : 1) * (TILEX - TILEX / player->move_delay_value);
6627
6628   ScrollPlayer(player, SCROLL_INIT);
6629
6630 #if 0
6631   if (IS_CUSTOM_ELEMENT(Feld[jx][jy]))
6632   {
6633     CheckTriggeredElementSideChange(jx, jy, Feld[jx][jy], leave_side,
6634                                     CE_OTHER_GETS_LEFT);
6635     CheckElementSideChange(jx, jy, Feld[jx][jy], leave_side,
6636                            CE_LEFT_BY_PLAYER, -1);
6637   }
6638
6639   if (IS_CUSTOM_ELEMENT(Feld[new_jx][new_jy]))
6640   {
6641     CheckTriggeredElementSideChange(new_jx, new_jy, Feld[new_jx][new_jy],
6642                                     enter_side, CE_OTHER_GETS_ENTERED);
6643     CheckElementSideChange(new_jx, new_jy, Feld[new_jx][new_jy], enter_side,
6644                            CE_ENTERED_BY_PLAYER, -1);
6645   }
6646 #endif
6647
6648   return MF_MOVING;
6649 }
6650
6651 boolean MovePlayer(struct PlayerInfo *player, int dx, int dy)
6652 {
6653   int jx = player->jx, jy = player->jy;
6654   int old_jx = jx, old_jy = jy;
6655   int moved = MF_NO_ACTION;
6656
6657   if (!player->active || (!dx && !dy))
6658     return FALSE;
6659
6660 #if 0
6661   if (!FrameReached(&player->move_delay, player->move_delay_value) &&
6662       !tape.playing)
6663     return FALSE;
6664 #else
6665   if (!FrameReached(&player->move_delay, player->move_delay_value) &&
6666       !(tape.playing && tape.file_version < FILE_VERSION_2_0))
6667     return FALSE;
6668 #endif
6669
6670   /* remove the last programmed player action */
6671   player->programmed_action = 0;
6672
6673   if (player->MovPos)
6674   {
6675     /* should only happen if pre-1.2 tape recordings are played */
6676     /* this is only for backward compatibility */
6677
6678     int original_move_delay_value = player->move_delay_value;
6679
6680 #if DEBUG
6681     printf("THIS SHOULD ONLY HAPPEN WITH PRE-1.2 LEVEL TAPES. [%ld]\n",
6682            tape.counter);
6683 #endif
6684
6685     /* scroll remaining steps with finest movement resolution */
6686     player->move_delay_value = MOVE_DELAY_NORMAL_SPEED;
6687
6688     while (player->MovPos)
6689     {
6690       ScrollPlayer(player, SCROLL_GO_ON);
6691       ScrollScreen(NULL, SCROLL_GO_ON);
6692       FrameCounter++;
6693       DrawAllPlayers();
6694       BackToFront();
6695     }
6696
6697     player->move_delay_value = original_move_delay_value;
6698   }
6699
6700   if (player->last_move_dir & (MV_LEFT | MV_RIGHT))
6701   {
6702     if (!(moved |= MovePlayerOneStep(player, 0, dy, dx, dy)))
6703       moved |= MovePlayerOneStep(player, dx, 0, dx, dy);
6704   }
6705   else
6706   {
6707     if (!(moved |= MovePlayerOneStep(player, dx, 0, dx, dy)))
6708       moved |= MovePlayerOneStep(player, 0, dy, dx, dy);
6709   }
6710
6711   jx = player->jx;
6712   jy = player->jy;
6713
6714   if (moved & MF_MOVING && !ScreenMovPos &&
6715       (player == local_player || !options.network))
6716   {
6717     int old_scroll_x = scroll_x, old_scroll_y = scroll_y;
6718     int offset = (setup.scroll_delay ? 3 : 0);
6719
6720     if (!IN_VIS_FIELD(SCREENX(jx), SCREENY(jy)))
6721     {
6722       /* actual player has left the screen -- scroll in that direction */
6723       if (jx != old_jx)         /* player has moved horizontally */
6724         scroll_x += (jx - old_jx);
6725       else                      /* player has moved vertically */
6726         scroll_y += (jy - old_jy);
6727     }
6728     else
6729     {
6730       if (jx != old_jx)         /* player has moved horizontally */
6731       {
6732         if ((player->MovDir == MV_LEFT && scroll_x > jx - MIDPOSX + offset) ||
6733             (player->MovDir == MV_RIGHT && scroll_x < jx - MIDPOSX - offset))
6734           scroll_x = jx-MIDPOSX + (scroll_x < jx-MIDPOSX ? -offset : +offset);
6735
6736         /* don't scroll over playfield boundaries */
6737         if (scroll_x < SBX_Left || scroll_x > SBX_Right)
6738           scroll_x = (scroll_x < SBX_Left ? SBX_Left : SBX_Right);
6739
6740         /* don't scroll more than one field at a time */
6741         scroll_x = old_scroll_x + SIGN(scroll_x - old_scroll_x);
6742
6743         /* don't scroll against the player's moving direction */
6744         if ((player->MovDir == MV_LEFT && scroll_x > old_scroll_x) ||
6745             (player->MovDir == MV_RIGHT && scroll_x < old_scroll_x))
6746           scroll_x = old_scroll_x;
6747       }
6748       else                      /* player has moved vertically */
6749       {
6750         if ((player->MovDir == MV_UP && scroll_y > jy - MIDPOSY + offset) ||
6751             (player->MovDir == MV_DOWN && scroll_y < jy - MIDPOSY - offset))
6752           scroll_y = jy-MIDPOSY + (scroll_y < jy-MIDPOSY ? -offset : +offset);
6753
6754         /* don't scroll over playfield boundaries */
6755         if (scroll_y < SBY_Upper || scroll_y > SBY_Lower)
6756           scroll_y = (scroll_y < SBY_Upper ? SBY_Upper : SBY_Lower);
6757
6758         /* don't scroll more than one field at a time */
6759         scroll_y = old_scroll_y + SIGN(scroll_y - old_scroll_y);
6760
6761         /* don't scroll against the player's moving direction */
6762         if ((player->MovDir == MV_UP && scroll_y > old_scroll_y) ||
6763             (player->MovDir == MV_DOWN && scroll_y < old_scroll_y))
6764           scroll_y = old_scroll_y;
6765       }
6766     }
6767
6768     if (scroll_x != old_scroll_x || scroll_y != old_scroll_y)
6769     {
6770       if (!options.network && !AllPlayersInVisibleScreen())
6771       {
6772         scroll_x = old_scroll_x;
6773         scroll_y = old_scroll_y;
6774       }
6775       else
6776       {
6777         ScrollScreen(player, SCROLL_INIT);
6778         ScrollLevel(old_scroll_x - scroll_x, old_scroll_y - scroll_y);
6779       }
6780     }
6781   }
6782
6783 #if 0
6784 #if 1
6785   InitPlayerGfxAnimation(player, ACTION_DEFAULT);
6786 #else
6787   if (!(moved & MF_MOVING) && !player->Pushing)
6788     player->Frame = 0;
6789 #endif
6790 #endif
6791
6792   player->StepFrame = 0;
6793
6794   if (moved & MF_MOVING)
6795   {
6796     if (old_jx != jx && old_jy == jy)
6797       player->MovDir = (old_jx < jx ? MV_RIGHT : MV_LEFT);
6798     else if (old_jx == jx && old_jy != jy)
6799       player->MovDir = (old_jy < jy ? MV_DOWN : MV_UP);
6800
6801     DrawLevelField(jx, jy);     /* for "crumbled sand" */
6802
6803     player->last_move_dir = player->MovDir;
6804     player->is_moving = TRUE;
6805 #if 1
6806     player->snapped = FALSE;
6807 #endif
6808
6809 #if 1
6810     player->Switching = FALSE;
6811 #endif
6812
6813
6814 #if 1
6815     {
6816       static int change_sides[4][2] =
6817       {
6818         /* enter side           leave side */
6819         { CH_SIDE_RIGHT,        CH_SIDE_LEFT    },      /* moving left  */
6820         { CH_SIDE_LEFT,         CH_SIDE_RIGHT   },      /* moving right */
6821         { CH_SIDE_BOTTOM,       CH_SIDE_TOP     },      /* moving up    */
6822         { CH_SIDE_TOP,          CH_SIDE_BOTTOM  }       /* moving down  */
6823       };
6824       int move_direction = player->MovDir;
6825       int enter_side = change_sides[MV_DIR_BIT(move_direction)][0];
6826       int leave_side = change_sides[MV_DIR_BIT(move_direction)][1];
6827
6828 #if 1
6829       if (IS_CUSTOM_ELEMENT(Feld[old_jx][old_jy]))
6830       {
6831         CheckTriggeredElementSideChange(old_jx, old_jy, Feld[old_jx][old_jy],
6832                                         leave_side, CE_OTHER_GETS_LEFT);
6833         CheckElementSideChange(old_jx, old_jy, Feld[old_jx][old_jy],
6834                                leave_side, CE_LEFT_BY_PLAYER, -1);
6835       }
6836
6837       if (IS_CUSTOM_ELEMENT(Feld[jx][jy]))
6838       {
6839         CheckTriggeredElementSideChange(jx, jy, Feld[jx][jy],
6840                                         enter_side, CE_OTHER_GETS_ENTERED);
6841         CheckElementSideChange(jx, jy, Feld[jx][jy],
6842                                enter_side, CE_ENTERED_BY_PLAYER, -1);
6843       }
6844 #endif
6845
6846     }
6847 #endif
6848
6849
6850   }
6851   else
6852   {
6853     CheckGravityMovement(player);
6854
6855     /*
6856     player->last_move_dir = MV_NO_MOVING;
6857     */
6858     player->is_moving = FALSE;
6859   }
6860
6861   if (game.engine_version < VERSION_IDENT(3,0,7))
6862   {
6863     TestIfHeroTouchesBadThing(jx, jy);
6864     TestIfPlayerTouchesCustomElement(jx, jy);
6865   }
6866
6867   if (!player->active)
6868     RemoveHero(player);
6869
6870   return moved;
6871 }
6872
6873 void ScrollPlayer(struct PlayerInfo *player, int mode)
6874 {
6875   int jx = player->jx, jy = player->jy;
6876   int last_jx = player->last_jx, last_jy = player->last_jy;
6877   int move_stepsize = TILEX / player->move_delay_value;
6878
6879   if (!player->active || !player->MovPos)
6880     return;
6881
6882   if (mode == SCROLL_INIT)
6883   {
6884     player->actual_frame_counter = FrameCounter;
6885     player->GfxPos = move_stepsize * (player->MovPos / move_stepsize);
6886
6887     if (Feld[last_jx][last_jy] == EL_EMPTY)
6888       Feld[last_jx][last_jy] = EL_PLAYER_IS_LEAVING;
6889
6890 #if 0
6891     DrawPlayer(player);
6892 #endif
6893     return;
6894   }
6895   else if (!FrameReached(&player->actual_frame_counter, 1))
6896     return;
6897
6898   player->MovPos += (player->MovPos > 0 ? -1 : 1) * move_stepsize;
6899   player->GfxPos = move_stepsize * (player->MovPos / move_stepsize);
6900
6901   if (Feld[last_jx][last_jy] == EL_PLAYER_IS_LEAVING)
6902     Feld[last_jx][last_jy] = EL_EMPTY;
6903
6904   /* before DrawPlayer() to draw correct player graphic for this case */
6905   if (player->MovPos == 0)
6906     CheckGravityMovement(player);
6907
6908 #if 0
6909   DrawPlayer(player);   /* needed here only to cleanup last field */
6910 #endif
6911
6912   if (player->MovPos == 0)      /* player reached destination field */
6913   {
6914     if (IS_PASSABLE(Feld[last_jx][last_jy]))
6915     {
6916       /* continue with normal speed after quickly moving through gate */
6917       HALVE_PLAYER_SPEED(player);
6918
6919       /* be able to make the next move without delay */
6920       player->move_delay = 0;
6921     }
6922
6923     player->last_jx = jx;
6924     player->last_jy = jy;
6925
6926     if (Feld[jx][jy] == EL_EXIT_OPEN ||
6927         Feld[jx][jy] == EL_SP_EXIT_OPEN ||
6928         Feld[jx][jy] == EL_SP_EXIT_OPENING)     /* <-- special case */
6929     {
6930       DrawPlayer(player);       /* needed here only to cleanup last field */
6931       RemoveHero(player);
6932
6933       if (local_player->friends_still_needed == 0 ||
6934           IS_SP_ELEMENT(Feld[jx][jy]))
6935         player->LevelSolved = player->GameOver = TRUE;
6936     }
6937
6938     if (game.engine_version >= VERSION_IDENT(3,0,7))
6939     {
6940       TestIfHeroTouchesBadThing(jx, jy);
6941       TestIfPlayerTouchesCustomElement(jx, jy);
6942
6943       if (!player->active)
6944         RemoveHero(player);
6945     }
6946
6947     if (tape.single_step && tape.recording && !tape.pausing &&
6948         !player->programmed_action)
6949       TapeTogglePause(TAPE_TOGGLE_AUTOMATIC);
6950   }
6951 }
6952
6953 void ScrollScreen(struct PlayerInfo *player, int mode)
6954 {
6955   static unsigned long screen_frame_counter = 0;
6956
6957   if (mode == SCROLL_INIT)
6958   {
6959     /* set scrolling step size according to actual player's moving speed */
6960     ScrollStepSize = TILEX / player->move_delay_value;
6961
6962     screen_frame_counter = FrameCounter;
6963     ScreenMovDir = player->MovDir;
6964     ScreenMovPos = player->MovPos;
6965     ScreenGfxPos = ScrollStepSize * (ScreenMovPos / ScrollStepSize);
6966     return;
6967   }
6968   else if (!FrameReached(&screen_frame_counter, 1))
6969     return;
6970
6971   if (ScreenMovPos)
6972   {
6973     ScreenMovPos += (ScreenMovPos > 0 ? -1 : 1) * ScrollStepSize;
6974     ScreenGfxPos = ScrollStepSize * (ScreenMovPos / ScrollStepSize);
6975     redraw_mask |= REDRAW_FIELD;
6976   }
6977   else
6978     ScreenMovDir = MV_NO_MOVING;
6979 }
6980
6981 void TestIfPlayerTouchesCustomElement(int x, int y)
6982 {
6983   static int xy[4][2] =
6984   {
6985     { 0, -1 },
6986     { -1, 0 },
6987     { +1, 0 },
6988     { 0, +1 }
6989   };
6990   static int change_sides[4][2] =
6991   {
6992     /* center side       border side */
6993     { CH_SIDE_TOP,      CH_SIDE_BOTTOM  },      /* check top    */
6994     { CH_SIDE_LEFT,     CH_SIDE_RIGHT   },      /* check left   */
6995     { CH_SIDE_RIGHT,    CH_SIDE_LEFT    },      /* check right  */
6996     { CH_SIDE_BOTTOM,   CH_SIDE_TOP     }       /* check bottom */
6997   };
6998   static int touch_dir[4] =
6999   {
7000     MV_LEFT | MV_RIGHT,
7001     MV_UP   | MV_DOWN,
7002     MV_UP   | MV_DOWN,
7003     MV_LEFT | MV_RIGHT
7004   };
7005   int center_element = Feld[x][y];      /* should always be non-moving! */
7006   int i;
7007
7008   for (i=0; i<4; i++)
7009   {
7010     int xx = x + xy[i][0];
7011     int yy = y + xy[i][1];
7012     int center_side = change_sides[i][0];
7013     int border_side = change_sides[i][1];
7014     int border_element;
7015
7016     if (!IN_LEV_FIELD(xx, yy))
7017       continue;
7018
7019     if (IS_PLAYER(x, y))
7020     {
7021       if (game.engine_version < VERSION_IDENT(3,0,7))
7022         border_element = Feld[xx][yy];          /* may be moving! */
7023       else if (!IS_MOVING(xx, yy) && !IS_BLOCKED(xx, yy))
7024         border_element = Feld[xx][yy];
7025       else if (MovDir[xx][yy] & touch_dir[i])   /* elements are touching */
7026         border_element = MovingOrBlocked2Element(xx, yy);
7027       else
7028         continue;               /* center and border element do not touch */
7029
7030       CheckTriggeredElementSideChange(xx, yy, border_element, border_side,
7031                                       CE_OTHER_GETS_TOUCHED);
7032       CheckElementSideChange(xx, yy, border_element, border_side,
7033                              CE_TOUCHED_BY_PLAYER, -1);
7034     }
7035     else if (IS_PLAYER(xx, yy))
7036     {
7037       if (game.engine_version >= VERSION_IDENT(3,0,7))
7038       {
7039         struct PlayerInfo *player = PLAYERINFO(xx, yy);
7040
7041         if (player->MovPos != 0 && !(player->MovDir & touch_dir[i]))
7042           continue;             /* center and border element do not touch */
7043       }
7044
7045       CheckTriggeredElementSideChange(x, y, center_element, center_side,
7046                                       CE_OTHER_GETS_TOUCHED);
7047       CheckElementSideChange(x, y, center_element, center_side,
7048                              CE_TOUCHED_BY_PLAYER, -1);
7049
7050       break;
7051     }
7052   }
7053 }
7054
7055 void TestIfElementTouchesCustomElement(int x, int y)
7056 {
7057   static int xy[4][2] =
7058   {
7059     { 0, -1 },
7060     { -1, 0 },
7061     { +1, 0 },
7062     { 0, +1 }
7063   };
7064   static int change_sides[4][2] =
7065   {
7066     /* center side       border side */
7067     { CH_SIDE_TOP,      CH_SIDE_BOTTOM  },      /* check top    */
7068     { CH_SIDE_LEFT,     CH_SIDE_RIGHT   },      /* check left   */
7069     { CH_SIDE_RIGHT,    CH_SIDE_LEFT    },      /* check right  */
7070     { CH_SIDE_BOTTOM,   CH_SIDE_TOP     }       /* check bottom */
7071   };
7072   static int touch_dir[4] =
7073   {
7074     MV_LEFT | MV_RIGHT,
7075     MV_UP   | MV_DOWN,
7076     MV_UP   | MV_DOWN,
7077     MV_LEFT | MV_RIGHT
7078   };
7079   boolean change_center_element = FALSE;
7080   int center_element_change_page = 0;
7081   int center_element = Feld[x][y];      /* should always be non-moving! */
7082   int i, j;
7083
7084   for (i=0; i<4; i++)
7085   {
7086     int xx = x + xy[i][0];
7087     int yy = y + xy[i][1];
7088     int center_side = change_sides[i][0];
7089     int border_side = change_sides[i][1];
7090     int border_element;
7091
7092     if (!IN_LEV_FIELD(xx, yy))
7093       continue;
7094
7095     if (game.engine_version < VERSION_IDENT(3,0,7))
7096       border_element = Feld[xx][yy];    /* may be moving! */
7097     else if (!IS_MOVING(xx, yy) && !IS_BLOCKED(xx, yy))
7098       border_element = Feld[xx][yy];
7099     else if (MovDir[xx][yy] & touch_dir[i])     /* elements are touching */
7100       border_element = MovingOrBlocked2Element(xx, yy);
7101     else
7102       continue;                 /* center and border element do not touch */
7103
7104     /* check for change of center element (but change it only once) */
7105     if (IS_CUSTOM_ELEMENT(center_element) &&
7106         HAS_ANY_CHANGE_EVENT(center_element, CE_OTHER_IS_TOUCHING) &&
7107         !change_center_element)
7108     {
7109       for (j=0; j < element_info[center_element].num_change_pages; j++)
7110       {
7111         struct ElementChangeInfo *change =
7112           &element_info[center_element].change_page[j];
7113
7114         if (change->can_change &&
7115             change->events & CH_EVENT_BIT(CE_OTHER_IS_TOUCHING) &&
7116             change->sides & border_side &&
7117             change->trigger_element == border_element)
7118         {
7119           change_center_element = TRUE;
7120           center_element_change_page = j;
7121
7122           break;
7123         }
7124       }
7125     }
7126
7127     /* check for change of border element */
7128     if (IS_CUSTOM_ELEMENT(border_element) &&
7129         HAS_ANY_CHANGE_EVENT(border_element, CE_OTHER_IS_TOUCHING))
7130     {
7131       for (j=0; j < element_info[border_element].num_change_pages; j++)
7132       {
7133         struct ElementChangeInfo *change =
7134           &element_info[border_element].change_page[j];
7135
7136         if (change->can_change &&
7137             change->events & CH_EVENT_BIT(CE_OTHER_IS_TOUCHING) &&
7138             change->sides & center_side &&
7139             change->trigger_element == center_element)
7140         {
7141           CheckElementSideChange(xx, yy, border_element, CH_SIDE_ANY,
7142                                  CE_OTHER_IS_TOUCHING, j);
7143           break;
7144         }
7145       }
7146     }
7147   }
7148
7149   if (change_center_element)
7150     CheckElementSideChange(x, y, center_element, CH_SIDE_ANY,
7151                            CE_OTHER_IS_TOUCHING, center_element_change_page);
7152 }
7153
7154 void TestIfGoodThingHitsBadThing(int good_x, int good_y, int good_move_dir)
7155 {
7156   int i, kill_x = -1, kill_y = -1;
7157   static int test_xy[4][2] =
7158   {
7159     { 0, -1 },
7160     { -1, 0 },
7161     { +1, 0 },
7162     { 0, +1 }
7163   };
7164   static int test_dir[4] =
7165   {
7166     MV_UP,
7167     MV_LEFT,
7168     MV_RIGHT,
7169     MV_DOWN
7170   };
7171
7172   for (i=0; i<4; i++)
7173   {
7174     int test_x, test_y, test_move_dir, test_element;
7175
7176     test_x = good_x + test_xy[i][0];
7177     test_y = good_y + test_xy[i][1];
7178     if (!IN_LEV_FIELD(test_x, test_y))
7179       continue;
7180
7181     test_move_dir =
7182       (IS_MOVING(test_x, test_y) ? MovDir[test_x][test_y] : MV_NO_MOVING);
7183
7184 #if 0
7185     test_element = Feld[test_x][test_y];
7186 #else
7187     test_element = MovingOrBlocked2ElementIfNotLeaving(test_x, test_y);
7188 #endif
7189
7190     /* 1st case: good thing is moving towards DONT_RUN_INTO style bad thing;
7191        2nd case: DONT_TOUCH style bad thing does not move away from good thing
7192     */
7193     if ((DONT_RUN_INTO(test_element) && good_move_dir == test_dir[i]) ||
7194         (DONT_TOUCH(test_element)    && test_move_dir != test_dir[i]))
7195     {
7196       kill_x = test_x;
7197       kill_y = test_y;
7198       break;
7199     }
7200   }
7201
7202   if (kill_x != -1 || kill_y != -1)
7203   {
7204     if (IS_PLAYER(good_x, good_y))
7205     {
7206       struct PlayerInfo *player = PLAYERINFO(good_x, good_y);
7207
7208       if (player->shield_deadly_time_left > 0)
7209         Bang(kill_x, kill_y);
7210       else if (!PLAYER_PROTECTED(good_x, good_y))
7211         KillHero(player);
7212     }
7213     else
7214       Bang(good_x, good_y);
7215   }
7216 }
7217
7218 void TestIfBadThingHitsGoodThing(int bad_x, int bad_y, int bad_move_dir)
7219 {
7220   int i, kill_x = -1, kill_y = -1;
7221   int bad_element = Feld[bad_x][bad_y];
7222   static int test_xy[4][2] =
7223   {
7224     { 0, -1 },
7225     { -1, 0 },
7226     { +1, 0 },
7227     { 0, +1 }
7228   };
7229   static int touch_dir[4] =
7230   {
7231     MV_LEFT | MV_RIGHT,
7232     MV_UP   | MV_DOWN,
7233     MV_UP   | MV_DOWN,
7234     MV_LEFT | MV_RIGHT
7235   };
7236   static int test_dir[4] =
7237   {
7238     MV_UP,
7239     MV_LEFT,
7240     MV_RIGHT,
7241     MV_DOWN
7242   };
7243
7244   if (bad_element == EL_EXPLOSION)      /* skip just exploding bad things */
7245     return;
7246
7247   for (i=0; i<4; i++)
7248   {
7249     int test_x, test_y, test_move_dir, test_element;
7250
7251     test_x = bad_x + test_xy[i][0];
7252     test_y = bad_y + test_xy[i][1];
7253     if (!IN_LEV_FIELD(test_x, test_y))
7254       continue;
7255
7256     test_move_dir =
7257       (IS_MOVING(test_x, test_y) ? MovDir[test_x][test_y] : MV_NO_MOVING);
7258
7259     test_element = Feld[test_x][test_y];
7260
7261     /* 1st case: good thing is moving towards DONT_RUN_INTO style bad thing;
7262        2nd case: DONT_TOUCH style bad thing does not move away from good thing
7263     */
7264     if ((DONT_RUN_INTO(bad_element) &&  bad_move_dir == test_dir[i]) ||
7265         (DONT_TOUCH(bad_element)    && test_move_dir != test_dir[i]))
7266     {
7267       /* good thing is player or penguin that does not move away */
7268       if (IS_PLAYER(test_x, test_y))
7269       {
7270         struct PlayerInfo *player = PLAYERINFO(test_x, test_y);
7271
7272         if (bad_element == EL_ROBOT && player->is_moving)
7273           continue;     /* robot does not kill player if he is moving */
7274
7275         if (game.engine_version >= VERSION_IDENT(3,0,7))
7276         {
7277           if (player->MovPos != 0 && !(player->MovDir & touch_dir[i]))
7278             continue;           /* center and border element do not touch */
7279         }
7280
7281         kill_x = test_x;
7282         kill_y = test_y;
7283         break;
7284       }
7285       else if (test_element == EL_PENGUIN)
7286       {
7287         kill_x = test_x;
7288         kill_y = test_y;
7289         break;
7290       }
7291     }
7292   }
7293
7294   if (kill_x != -1 || kill_y != -1)
7295   {
7296     if (IS_PLAYER(kill_x, kill_y))
7297     {
7298       struct PlayerInfo *player = PLAYERINFO(kill_x, kill_y);
7299
7300       if (player->shield_deadly_time_left > 0)
7301         Bang(bad_x, bad_y);
7302       else if (!PLAYER_PROTECTED(kill_x, kill_y))
7303         KillHero(player);
7304     }
7305     else
7306       Bang(kill_x, kill_y);
7307   }
7308 }
7309
7310 void TestIfHeroTouchesBadThing(int x, int y)
7311 {
7312   TestIfGoodThingHitsBadThing(x, y, MV_NO_MOVING);
7313 }
7314
7315 void TestIfHeroRunsIntoBadThing(int x, int y, int move_dir)
7316 {
7317   TestIfGoodThingHitsBadThing(x, y, move_dir);
7318 }
7319
7320 void TestIfBadThingTouchesHero(int x, int y)
7321 {
7322   TestIfBadThingHitsGoodThing(x, y, MV_NO_MOVING);
7323 }
7324
7325 void TestIfBadThingRunsIntoHero(int x, int y, int move_dir)
7326 {
7327   TestIfBadThingHitsGoodThing(x, y, move_dir);
7328 }
7329
7330 void TestIfFriendTouchesBadThing(int x, int y)
7331 {
7332   TestIfGoodThingHitsBadThing(x, y, MV_NO_MOVING);
7333 }
7334
7335 void TestIfBadThingTouchesFriend(int x, int y)
7336 {
7337   TestIfBadThingHitsGoodThing(x, y, MV_NO_MOVING);
7338 }
7339
7340 void TestIfBadThingTouchesOtherBadThing(int bad_x, int bad_y)
7341 {
7342   int i, kill_x = bad_x, kill_y = bad_y;
7343   static int xy[4][2] =
7344   {
7345     { 0, -1 },
7346     { -1, 0 },
7347     { +1, 0 },
7348     { 0, +1 }
7349   };
7350
7351   for (i=0; i<4; i++)
7352   {
7353     int x, y, element;
7354
7355     x = bad_x + xy[i][0];
7356     y = bad_y + xy[i][1];
7357     if (!IN_LEV_FIELD(x, y))
7358       continue;
7359
7360     element = Feld[x][y];
7361     if (IS_AMOEBOID(element) || element == EL_GAME_OF_LIFE ||
7362         element == EL_AMOEBA_GROWING || element == EL_AMOEBA_DROP)
7363     {
7364       kill_x = x;
7365       kill_y = y;
7366       break;
7367     }
7368   }
7369
7370   if (kill_x != bad_x || kill_y != bad_y)
7371     Bang(bad_x, bad_y);
7372 }
7373
7374 void KillHero(struct PlayerInfo *player)
7375 {
7376   int jx = player->jx, jy = player->jy;
7377
7378   if (!player->active)
7379     return;
7380
7381   /* remove accessible field at the player's position */
7382   Feld[jx][jy] = EL_EMPTY;
7383
7384   /* deactivate shield (else Bang()/Explode() would not work right) */
7385   player->shield_normal_time_left = 0;
7386   player->shield_deadly_time_left = 0;
7387
7388   Bang(jx, jy);
7389   BuryHero(player);
7390 }
7391
7392 static void KillHeroUnlessProtected(int x, int y)
7393 {
7394   if (!PLAYER_PROTECTED(x, y))
7395     KillHero(PLAYERINFO(x, y));
7396 }
7397
7398 void BuryHero(struct PlayerInfo *player)
7399 {
7400   int jx = player->jx, jy = player->jy;
7401
7402   if (!player->active)
7403     return;
7404
7405 #if 1
7406   PlaySoundLevelElementAction(jx, jy, player->element_nr, ACTION_DYING);
7407 #else
7408   PlaySoundLevel(jx, jy, SND_CLASS_PLAYER_DYING);
7409 #endif
7410   PlaySoundLevel(jx, jy, SND_GAME_LOSING);
7411
7412   player->GameOver = TRUE;
7413   RemoveHero(player);
7414 }
7415
7416 void RemoveHero(struct PlayerInfo *player)
7417 {
7418   int jx = player->jx, jy = player->jy;
7419   int i, found = FALSE;
7420
7421   player->present = FALSE;
7422   player->active = FALSE;
7423
7424   if (!ExplodeField[jx][jy])
7425     StorePlayer[jx][jy] = 0;
7426
7427   for (i=0; i<MAX_PLAYERS; i++)
7428     if (stored_player[i].active)
7429       found = TRUE;
7430
7431   if (!found)
7432     AllPlayersGone = TRUE;
7433
7434   ExitX = ZX = jx;
7435   ExitY = ZY = jy;
7436 }
7437
7438 /*
7439   =============================================================================
7440   checkDiagonalPushing()
7441   -----------------------------------------------------------------------------
7442   check if diagonal input device direction results in pushing of object
7443   (by checking if the alternative direction is walkable, diggable, ...)
7444   =============================================================================
7445 */
7446
7447 static boolean checkDiagonalPushing(struct PlayerInfo *player,
7448                                     int x, int y, int real_dx, int real_dy)
7449 {
7450   int jx, jy, dx, dy, xx, yy;
7451
7452   if (real_dx == 0 || real_dy == 0)     /* no diagonal direction => push */
7453     return TRUE;
7454
7455   /* diagonal direction: check alternative direction */
7456   jx = player->jx;
7457   jy = player->jy;
7458   dx = x - jx;
7459   dy = y - jy;
7460   xx = jx + (dx == 0 ? real_dx : 0);
7461   yy = jy + (dy == 0 ? real_dy : 0);
7462
7463   return (!IN_LEV_FIELD(xx, yy) || IS_SOLID_FOR_PUSHING(Feld[xx][yy]));
7464 }
7465
7466 /*
7467   =============================================================================
7468   DigField()
7469   -----------------------------------------------------------------------------
7470   x, y:                 field next to player (non-diagonal) to try to dig to
7471   real_dx, real_dy:     direction as read from input device (can be diagonal)
7472   =============================================================================
7473 */
7474
7475 int DigField(struct PlayerInfo *player,
7476              int x, int y, int real_dx, int real_dy, int mode)
7477 {
7478   static int change_sides[4] =
7479   {
7480     CH_SIDE_RIGHT,      /* moving left  */
7481     CH_SIDE_LEFT,       /* moving right */
7482     CH_SIDE_BOTTOM,     /* moving up    */
7483     CH_SIDE_TOP,        /* moving down  */
7484   };
7485   boolean use_spring_bug = (game.engine_version < VERSION_IDENT(2,2,0));
7486   int jx = player->jx, jy = player->jy;
7487   int dx = x - jx, dy = y - jy;
7488   int nextx = x + dx, nexty = y + dy;
7489   int move_direction = (dx == -1 ? MV_LEFT :
7490                         dx == +1 ? MV_RIGHT :
7491                         dy == -1 ? MV_UP :
7492                         dy == +1 ? MV_DOWN : MV_NO_MOVING);
7493   int dig_side = change_sides[MV_DIR_BIT(move_direction)];
7494   int element;
7495
7496   if (player->MovPos == 0)
7497   {
7498     player->is_digging = FALSE;
7499     player->is_collecting = FALSE;
7500   }
7501
7502   if (player->MovPos == 0)      /* last pushing move finished */
7503     player->Pushing = FALSE;
7504
7505   if (mode == DF_NO_PUSH)       /* player just stopped pushing */
7506   {
7507     player->Switching = FALSE;
7508     player->push_delay = 0;
7509
7510     return MF_NO_ACTION;
7511   }
7512
7513   if (IS_MOVING(x, y) || IS_PLAYER(x, y))
7514     return MF_NO_ACTION;
7515
7516 #if 0
7517   if (IS_TUBE(Feld[jx][jy]) || IS_TUBE(Back[jx][jy]))
7518 #else
7519   if (IS_TUBE(Feld[jx][jy]) ||
7520       (IS_TUBE(Back[jx][jy]) && game.engine_version >= VERSION_IDENT(2,2,0)))
7521 #endif
7522   {
7523     int i = 0;
7524     int tube_element = (IS_TUBE(Feld[jx][jy]) ? Feld[jx][jy] : Back[jx][jy]);
7525     int tube_leave_directions[][2] =
7526     {
7527       { EL_TUBE_ANY,                    MV_LEFT | MV_RIGHT | MV_UP | MV_DOWN },
7528       { EL_TUBE_VERTICAL,                                    MV_UP | MV_DOWN },
7529       { EL_TUBE_HORIZONTAL,             MV_LEFT | MV_RIGHT                   },
7530       { EL_TUBE_VERTICAL_LEFT,          MV_LEFT |            MV_UP | MV_DOWN },
7531       { EL_TUBE_VERTICAL_RIGHT,                   MV_RIGHT | MV_UP | MV_DOWN },
7532       { EL_TUBE_HORIZONTAL_UP,          MV_LEFT | MV_RIGHT | MV_UP           },
7533       { EL_TUBE_HORIZONTAL_DOWN,        MV_LEFT | MV_RIGHT |         MV_DOWN },
7534       { EL_TUBE_LEFT_UP,                MV_LEFT |            MV_UP           },
7535       { EL_TUBE_LEFT_DOWN,              MV_LEFT |                    MV_DOWN },
7536       { EL_TUBE_RIGHT_UP,                         MV_RIGHT | MV_UP           },
7537       { EL_TUBE_RIGHT_DOWN,                       MV_RIGHT |         MV_DOWN },
7538       { -1,                             MV_LEFT | MV_RIGHT | MV_UP | MV_DOWN }
7539     };
7540
7541     while (tube_leave_directions[i][0] != tube_element)
7542     {
7543       i++;
7544       if (tube_leave_directions[i][0] == -1)    /* should not happen */
7545         break;
7546     }
7547
7548     if (!(tube_leave_directions[i][1] & move_direction))
7549       return MF_NO_ACTION;      /* tube has no opening in this direction */
7550   }
7551
7552   element = Feld[x][y];
7553
7554   if (mode == DF_SNAP && !IS_SNAPPABLE(element) &&
7555       game.engine_version >= VERSION_IDENT(2,2,0))
7556     return MF_NO_ACTION;
7557
7558   switch (element)
7559   {
7560 #if 0
7561     case EL_ROBOT_WHEEL:
7562       Feld[x][y] = EL_ROBOT_WHEEL_ACTIVE;
7563       ZX = x;
7564       ZY = y;
7565       DrawLevelField(x, y);
7566       PlaySoundLevel(x, y, SND_ROBOT_WHEEL_ACTIVATING);
7567       return MF_ACTION;
7568       break;
7569 #endif
7570
7571 #if 0
7572     case EL_SP_TERMINAL:
7573       {
7574         int xx, yy;
7575
7576         PlaySoundLevel(x, y, SND_SP_TERMINAL_ACTIVATING);
7577
7578         for (yy=0; yy<lev_fieldy; yy++)
7579         {
7580           for (xx=0; xx<lev_fieldx; xx++)
7581           {
7582             if (Feld[xx][yy] == EL_SP_DISK_YELLOW)
7583               Bang(xx, yy);
7584             else if (Feld[xx][yy] == EL_SP_TERMINAL)
7585               Feld[xx][yy] = EL_SP_TERMINAL_ACTIVE;
7586           }
7587         }
7588
7589         return MF_ACTION;
7590       }
7591       break;
7592 #endif
7593
7594 #if 0
7595     case EL_CONVEYOR_BELT_1_SWITCH_LEFT:
7596     case EL_CONVEYOR_BELT_1_SWITCH_MIDDLE:
7597     case EL_CONVEYOR_BELT_1_SWITCH_RIGHT:
7598     case EL_CONVEYOR_BELT_2_SWITCH_LEFT:
7599     case EL_CONVEYOR_BELT_2_SWITCH_MIDDLE:
7600     case EL_CONVEYOR_BELT_2_SWITCH_RIGHT:
7601     case EL_CONVEYOR_BELT_3_SWITCH_LEFT:
7602     case EL_CONVEYOR_BELT_3_SWITCH_MIDDLE:
7603     case EL_CONVEYOR_BELT_3_SWITCH_RIGHT:
7604     case EL_CONVEYOR_BELT_4_SWITCH_LEFT:
7605     case EL_CONVEYOR_BELT_4_SWITCH_MIDDLE:
7606     case EL_CONVEYOR_BELT_4_SWITCH_RIGHT:
7607 #if 1
7608       if (!PLAYER_SWITCHING(player, x, y))
7609 #else
7610       if (!player->Switching)
7611 #endif
7612       {
7613         player->Switching = TRUE;
7614         player->switch_x = x;
7615         player->switch_y = y;
7616
7617         ToggleBeltSwitch(x, y);
7618         PlaySoundLevel(x, y, SND_CLASS_CONVEYOR_BELT_SWITCH_ACTIVATING);
7619       }
7620       return MF_ACTION;
7621       break;
7622 #endif
7623
7624 #if 0
7625     case EL_SWITCHGATE_SWITCH_UP:
7626     case EL_SWITCHGATE_SWITCH_DOWN:
7627 #if 1
7628       if (!PLAYER_SWITCHING(player, x, y))
7629 #else
7630       if (!player->Switching)
7631 #endif
7632       {
7633         player->Switching = TRUE;
7634         player->switch_x = x;
7635         player->switch_y = y;
7636
7637         ToggleSwitchgateSwitch(x, y);
7638         PlaySoundLevel(x, y, SND_CLASS_SWITCHGATE_SWITCH_ACTIVATING);
7639       }
7640       return MF_ACTION;
7641       break;
7642 #endif
7643
7644 #if 0
7645     case EL_LIGHT_SWITCH:
7646     case EL_LIGHT_SWITCH_ACTIVE:
7647 #if 1
7648       if (!PLAYER_SWITCHING(player, x, y))
7649 #else
7650       if (!player->Switching)
7651 #endif
7652       {
7653         player->Switching = TRUE;
7654         player->switch_x = x;
7655         player->switch_y = y;
7656
7657         ToggleLightSwitch(x, y);
7658         PlaySoundLevel(x, y, element == EL_LIGHT_SWITCH ?
7659                        SND_LIGHT_SWITCH_ACTIVATING :
7660                        SND_LIGHT_SWITCH_DEACTIVATING);
7661       }
7662       return MF_ACTION;
7663       break;
7664 #endif
7665
7666 #if 0
7667     case EL_TIMEGATE_SWITCH:
7668       ActivateTimegateSwitch(x, y);
7669       PlaySoundLevel(x, y, SND_TIMEGATE_SWITCH_ACTIVATING);
7670
7671       return MF_ACTION;
7672       break;
7673 #endif
7674
7675 #if 0
7676     case EL_BALLOON_SWITCH_LEFT:
7677     case EL_BALLOON_SWITCH_RIGHT:
7678     case EL_BALLOON_SWITCH_UP:
7679     case EL_BALLOON_SWITCH_DOWN:
7680     case EL_BALLOON_SWITCH_ANY:
7681       if (element == EL_BALLOON_SWITCH_ANY)
7682         game.balloon_dir = move_direction;
7683       else
7684         game.balloon_dir = (element == EL_BALLOON_SWITCH_LEFT  ? MV_LEFT :
7685                             element == EL_BALLOON_SWITCH_RIGHT ? MV_RIGHT :
7686                             element == EL_BALLOON_SWITCH_UP    ? MV_UP :
7687                             element == EL_BALLOON_SWITCH_DOWN  ? MV_DOWN :
7688                             MV_NO_MOVING);
7689       PlaySoundLevel(x, y, SND_CLASS_BALLOON_SWITCH_ACTIVATING);
7690
7691       return MF_ACTION;
7692       break;
7693 #endif
7694
7695     case EL_SP_PORT_LEFT:
7696     case EL_SP_PORT_RIGHT:
7697     case EL_SP_PORT_UP:
7698     case EL_SP_PORT_DOWN:
7699     case EL_SP_PORT_HORIZONTAL:
7700     case EL_SP_PORT_VERTICAL:
7701     case EL_SP_PORT_ANY:
7702     case EL_SP_GRAVITY_PORT_LEFT:
7703     case EL_SP_GRAVITY_PORT_RIGHT:
7704     case EL_SP_GRAVITY_PORT_UP:
7705     case EL_SP_GRAVITY_PORT_DOWN:
7706       if ((dx == -1 &&
7707            element != EL_SP_PORT_LEFT &&
7708            element != EL_SP_GRAVITY_PORT_LEFT &&
7709            element != EL_SP_PORT_HORIZONTAL &&
7710            element != EL_SP_PORT_ANY) ||
7711           (dx == +1 &&
7712            element != EL_SP_PORT_RIGHT &&
7713            element != EL_SP_GRAVITY_PORT_RIGHT &&
7714            element != EL_SP_PORT_HORIZONTAL &&
7715            element != EL_SP_PORT_ANY) ||
7716           (dy == -1 &&
7717            element != EL_SP_PORT_UP &&
7718            element != EL_SP_GRAVITY_PORT_UP &&
7719            element != EL_SP_PORT_VERTICAL &&
7720            element != EL_SP_PORT_ANY) ||
7721           (dy == +1 &&
7722            element != EL_SP_PORT_DOWN &&
7723            element != EL_SP_GRAVITY_PORT_DOWN &&
7724            element != EL_SP_PORT_VERTICAL &&
7725            element != EL_SP_PORT_ANY) ||
7726           !IN_LEV_FIELD(nextx, nexty) ||
7727           !IS_FREE(nextx, nexty))
7728         return MF_NO_ACTION;
7729
7730       if (element == EL_SP_GRAVITY_PORT_LEFT ||
7731           element == EL_SP_GRAVITY_PORT_RIGHT ||
7732           element == EL_SP_GRAVITY_PORT_UP ||
7733           element == EL_SP_GRAVITY_PORT_DOWN)
7734         game.gravity = !game.gravity;
7735
7736       /* automatically move to the next field with double speed */
7737       player->programmed_action = move_direction;
7738       DOUBLE_PLAYER_SPEED(player);
7739
7740       PlaySoundLevel(x, y, SND_CLASS_SP_PORT_PASSING);
7741       break;
7742
7743     case EL_TUBE_ANY:
7744     case EL_TUBE_VERTICAL:
7745     case EL_TUBE_HORIZONTAL:
7746     case EL_TUBE_VERTICAL_LEFT:
7747     case EL_TUBE_VERTICAL_RIGHT:
7748     case EL_TUBE_HORIZONTAL_UP:
7749     case EL_TUBE_HORIZONTAL_DOWN:
7750     case EL_TUBE_LEFT_UP:
7751     case EL_TUBE_LEFT_DOWN:
7752     case EL_TUBE_RIGHT_UP:
7753     case EL_TUBE_RIGHT_DOWN:
7754       {
7755         int i = 0;
7756         int tube_enter_directions[][2] =
7757         {
7758           { EL_TUBE_ANY,                MV_LEFT | MV_RIGHT | MV_UP | MV_DOWN },
7759           { EL_TUBE_VERTICAL,                                MV_UP | MV_DOWN },
7760           { EL_TUBE_HORIZONTAL,         MV_LEFT | MV_RIGHT                   },
7761           { EL_TUBE_VERTICAL_LEFT,                MV_RIGHT | MV_UP | MV_DOWN },
7762           { EL_TUBE_VERTICAL_RIGHT,     MV_LEFT            | MV_UP | MV_DOWN },
7763           { EL_TUBE_HORIZONTAL_UP,      MV_LEFT | MV_RIGHT |         MV_DOWN },
7764           { EL_TUBE_HORIZONTAL_DOWN,    MV_LEFT | MV_RIGHT | MV_UP           },
7765           { EL_TUBE_LEFT_UP,                      MV_RIGHT |         MV_DOWN },
7766           { EL_TUBE_LEFT_DOWN,                    MV_RIGHT | MV_UP           },
7767           { EL_TUBE_RIGHT_UP,           MV_LEFT |                    MV_DOWN },
7768           { EL_TUBE_RIGHT_DOWN,         MV_LEFT |            MV_UP           },
7769           { -1,                         MV_NO_MOVING                         }
7770         };
7771
7772         while (tube_enter_directions[i][0] != element)
7773         {
7774           i++;
7775           if (tube_enter_directions[i][0] == -1)        /* should not happen */
7776             break;
7777         }
7778
7779         if (!(tube_enter_directions[i][1] & move_direction))
7780           return MF_NO_ACTION;  /* tube has no opening in this direction */
7781
7782         PlaySoundLevel(x, y, SND_CLASS_TUBE_WALKING);
7783       }
7784       break;
7785
7786 #if 0
7787     case EL_LAMP:
7788       Feld[x][y] = EL_LAMP_ACTIVE;
7789       local_player->lights_still_needed--;
7790       DrawLevelField(x, y);
7791       PlaySoundLevel(x, y, SND_LAMP_ACTIVATING);
7792       return MF_ACTION;
7793       break;
7794 #endif
7795
7796 #if 0
7797     case EL_TIME_ORB_FULL:
7798       Feld[x][y] = EL_TIME_ORB_EMPTY;
7799       TimeLeft += 10;
7800       DrawText(DX_TIME, DY_TIME, int2str(TimeLeft, 3), FONT_TEXT_2);
7801       DrawLevelField(x, y);
7802       PlaySoundStereo(SND_TIME_ORB_FULL_COLLECTING, SOUND_MIDDLE);
7803       return MF_ACTION;
7804       break;
7805 #endif
7806
7807     default:
7808
7809       if (IS_WALKABLE(element))
7810       {
7811         int sound_action = ACTION_WALKING;
7812
7813         if (element >= EL_GATE_1 && element <= EL_GATE_4)
7814         {
7815           if (!player->key[element - EL_GATE_1])
7816             return MF_NO_ACTION;
7817         }
7818         else if (element >= EL_GATE_1_GRAY && element <= EL_GATE_4_GRAY)
7819         {
7820           if (!player->key[element - EL_GATE_1_GRAY])
7821             return MF_NO_ACTION;
7822         }
7823         else if (element == EL_EXIT_OPEN ||
7824                  element == EL_SP_EXIT_OPEN ||
7825                  element == EL_SP_EXIT_OPENING)
7826         {
7827           sound_action = ACTION_PASSING;        /* player is passing exit */
7828         }
7829         else if (element == EL_EMPTY)
7830         {
7831           sound_action = ACTION_MOVING;         /* nothing to walk on */
7832         }
7833
7834         /* play sound from background or player, whatever is available */
7835         if (element_info[element].sound[sound_action] != SND_UNDEFINED)
7836           PlaySoundLevelElementAction(x, y, element, sound_action);
7837         else
7838           PlaySoundLevelElementAction(x, y, player->element_nr, sound_action);
7839
7840         break;
7841       }
7842       else if (IS_PASSABLE(element))
7843       {
7844         if (!IN_LEV_FIELD(nextx, nexty) || !IS_FREE(nextx, nexty))
7845           return MF_NO_ACTION;
7846
7847 #if 1
7848         if (CAN_MOVE(element))  /* only fixed elements can be passed! */
7849           return MF_NO_ACTION;
7850 #endif
7851
7852         if (element >= EL_EM_GATE_1 && element <= EL_EM_GATE_4)
7853         {
7854           if (!player->key[element - EL_EM_GATE_1])
7855             return MF_NO_ACTION;
7856         }
7857         else if (element >= EL_EM_GATE_1_GRAY && element <= EL_EM_GATE_4_GRAY)
7858         {
7859           if (!player->key[element - EL_EM_GATE_1_GRAY])
7860             return MF_NO_ACTION;
7861         }
7862
7863         /* automatically move to the next field with double speed */
7864         player->programmed_action = move_direction;
7865         DOUBLE_PLAYER_SPEED(player);
7866
7867         PlaySoundLevelAction(x, y, ACTION_PASSING);
7868
7869         break;
7870       }
7871       else if (IS_DIGGABLE(element))
7872       {
7873         RemoveField(x, y);
7874
7875         if (mode != DF_SNAP)
7876         {
7877 #if 1
7878           GfxElement[x][y] = GFX_ELEMENT(element);
7879 #else
7880           GfxElement[x][y] =
7881             (GFX_CRUMBLED(element) ? EL_SAND : GFX_ELEMENT(element));
7882 #endif
7883           player->is_digging = TRUE;
7884         }
7885
7886         PlaySoundLevelElementAction(x, y, element, ACTION_DIGGING);
7887
7888         CheckTriggeredElementChange(x, y, element, CE_OTHER_GETS_DIGGED);
7889
7890         TestIfElementTouchesCustomElement(x, y);        /* for empty space */
7891
7892         break;
7893       }
7894       else if (IS_COLLECTIBLE(element))
7895       {
7896         RemoveField(x, y);
7897
7898         if (mode != DF_SNAP)
7899         {
7900           GfxElement[x][y] = element;
7901           player->is_collecting = TRUE;
7902         }
7903
7904         if (element == EL_SPEED_PILL)
7905           player->move_delay_value = MOVE_DELAY_HIGH_SPEED;
7906         else if (element == EL_EXTRA_TIME && level.time > 0)
7907         {
7908           TimeLeft += 10;
7909           DrawText(DX_TIME, DY_TIME, int2str(TimeLeft, 3), FONT_TEXT_2);
7910         }
7911         else if (element == EL_SHIELD_NORMAL || element == EL_SHIELD_DEADLY)
7912         {
7913           player->shield_normal_time_left += 10;
7914           if (element == EL_SHIELD_DEADLY)
7915             player->shield_deadly_time_left += 10;
7916         }
7917         else if (element == EL_DYNAMITE || element == EL_SP_DISK_RED)
7918         {
7919           if (player->inventory_size < MAX_INVENTORY_SIZE)
7920             player->inventory_element[player->inventory_size++] = element;
7921
7922           player->use_disk_red_graphic = (element == EL_SP_DISK_RED);
7923
7924           DrawText(DX_DYNAMITE, DY_DYNAMITE,
7925                    int2str(local_player->inventory_size, 3), FONT_TEXT_2);
7926         }
7927         else if (element == EL_DYNABOMB_INCREASE_NUMBER)
7928         {
7929           player->dynabomb_count++;
7930           player->dynabombs_left++;
7931         }
7932         else if (element == EL_DYNABOMB_INCREASE_SIZE)
7933         {
7934           player->dynabomb_size++;
7935         }
7936         else if (element == EL_DYNABOMB_INCREASE_POWER)
7937         {
7938           player->dynabomb_xl = TRUE;
7939         }
7940         else if ((element >= EL_KEY_1 && element <= EL_KEY_4) ||
7941                  (element >= EL_EM_KEY_1 && element <= EL_EM_KEY_4))
7942         {
7943           int key_nr = (element >= EL_KEY_1 && element <= EL_KEY_4 ?
7944                         element - EL_KEY_1 : element - EL_EM_KEY_1);
7945
7946           player->key[key_nr] = TRUE;
7947
7948           DrawMiniGraphicExt(drawto, DX_KEYS + key_nr * MINI_TILEX, DY_KEYS,
7949                              el2edimg(EL_KEY_1 + key_nr));
7950           redraw_mask |= REDRAW_DOOR_1;
7951         }
7952         else if (IS_ENVELOPE(element))
7953         {
7954 #if 1
7955           player->show_envelope = element;
7956 #else
7957           ShowEnvelope(element - EL_ENVELOPE_1);
7958 #endif
7959         }
7960         else if (IS_DROPPABLE(element)) /* can be collected and dropped */
7961         {
7962           int i;
7963
7964           for (i=0; i < element_info[element].collect_count; i++)
7965             if (player->inventory_size < MAX_INVENTORY_SIZE)
7966               player->inventory_element[player->inventory_size++] = element;
7967
7968           DrawText(DX_DYNAMITE, DY_DYNAMITE,
7969                    int2str(local_player->inventory_size, 3), FONT_TEXT_2);
7970         }
7971         else if (element_info[element].collect_count > 0)
7972         {
7973           local_player->gems_still_needed -=
7974             element_info[element].collect_count;
7975           if (local_player->gems_still_needed < 0)
7976             local_player->gems_still_needed = 0;
7977
7978           DrawText(DX_EMERALDS, DY_EMERALDS,
7979                    int2str(local_player->gems_still_needed, 3), FONT_TEXT_2);
7980         }
7981
7982         RaiseScoreElement(element);
7983         PlaySoundLevelElementAction(x, y, element, ACTION_COLLECTING);
7984
7985         CheckTriggeredElementChange(x, y, element, CE_OTHER_GETS_COLLECTED);
7986
7987         TestIfElementTouchesCustomElement(x, y);        /* for empty space */
7988
7989         break;
7990       }
7991       else if (IS_PUSHABLE(element))
7992       {
7993         if (mode == DF_SNAP && element != EL_BD_ROCK)
7994           return MF_NO_ACTION;
7995
7996         if (CAN_FALL(element) && dy)
7997           return MF_NO_ACTION;
7998
7999         if (CAN_FALL(element) && IN_LEV_FIELD(x, y + 1) && IS_FREE(x, y + 1) &&
8000             !(element == EL_SPRING && use_spring_bug))
8001           return MF_NO_ACTION;
8002
8003 #if 1
8004         /* do not push elements already moving away faster than player */
8005         if (CAN_MOVE(element) && MovDir[x][y] == move_direction &&
8006             ABS(getElementMoveStepsize(x, y)) > MOVE_STEPSIZE_NORMAL)
8007           return MF_NO_ACTION;
8008 #else
8009         if (element == EL_SPRING && MovDir[x][y] != MV_NO_MOVING)
8010           return MF_NO_ACTION;
8011 #endif
8012         if (!player->Pushing &&
8013             game.engine_version >= RELEASE_IDENT(2,2,0,7))
8014           player->push_delay_value = GET_NEW_PUSH_DELAY(element);
8015
8016         player->Pushing = TRUE;
8017
8018         if (!(IN_LEV_FIELD(nextx, nexty) &&
8019               (IS_FREE(nextx, nexty) ||
8020                (Feld[nextx][nexty] == EL_SOKOBAN_FIELD_EMPTY &&
8021                 IS_SB_ELEMENT(element)))))
8022           return MF_NO_ACTION;
8023
8024         if (!checkDiagonalPushing(player, x, y, real_dx, real_dy))
8025           return MF_NO_ACTION;
8026
8027         if (player->push_delay == 0)    /* new pushing; restart delay */
8028           player->push_delay = FrameCounter;
8029
8030         if (!FrameReached(&player->push_delay, player->push_delay_value) &&
8031             !(tape.playing && tape.file_version < FILE_VERSION_2_0) &&
8032             element != EL_SPRING && element != EL_BALLOON)
8033           return MF_NO_ACTION;
8034
8035         if (IS_SB_ELEMENT(element))
8036         {
8037           if (element == EL_SOKOBAN_FIELD_FULL)
8038           {
8039             Back[x][y] = EL_SOKOBAN_FIELD_EMPTY;
8040             local_player->sokobanfields_still_needed++;
8041           }
8042
8043           if (Feld[nextx][nexty] == EL_SOKOBAN_FIELD_EMPTY)
8044           {
8045             Back[nextx][nexty] = EL_SOKOBAN_FIELD_EMPTY;
8046             local_player->sokobanfields_still_needed--;
8047           }
8048
8049           Feld[x][y] = EL_SOKOBAN_OBJECT;
8050
8051           if (Back[x][y] == Back[nextx][nexty])
8052             PlaySoundLevelAction(x, y, ACTION_PUSHING);
8053           else if (Back[x][y] != 0)
8054             PlaySoundLevelElementAction(x, y, EL_SOKOBAN_FIELD_FULL,
8055                                         ACTION_EMPTYING);
8056           else
8057             PlaySoundLevelElementAction(nextx, nexty, EL_SOKOBAN_FIELD_EMPTY,
8058                                         ACTION_FILLING);
8059
8060           if (local_player->sokobanfields_still_needed == 0 &&
8061               game.emulation == EMU_SOKOBAN)
8062           {
8063             player->LevelSolved = player->GameOver = TRUE;
8064             PlaySoundLevel(x, y, SND_GAME_SOKOBAN_SOLVING);
8065           }
8066         }
8067         else
8068           PlaySoundLevelElementAction(x, y, element, ACTION_PUSHING);
8069
8070         InitMovingField(x, y, move_direction);
8071         GfxAction[x][y] = ACTION_PUSHING;
8072
8073         if (mode == DF_SNAP)
8074           ContinueMoving(x, y);
8075         else
8076           MovPos[x][y] = (dx != 0 ? dx : dy);
8077
8078         Pushed[x][y] = TRUE;
8079         Pushed[nextx][nexty] = TRUE;
8080
8081         if (game.engine_version < RELEASE_IDENT(2,2,0,7))
8082           player->push_delay_value = GET_NEW_PUSH_DELAY(element);
8083
8084 #if 1
8085         CheckTriggeredElementSideChange(x, y, element, dig_side,
8086                                         CE_OTHER_GETS_PUSHED);
8087         CheckElementSideChange(x, y, element, dig_side,
8088                                CE_PUSHED_BY_PLAYER, -1);
8089 #else
8090         CheckTriggeredElementChange(x, y, element, CE_OTHER_GETS_PUSHED);
8091         CheckElementChange(x, y, element, CE_PUSHED_BY_PLAYER);
8092 #endif
8093
8094         break;
8095       }
8096       else if (IS_SWITCHABLE(element))
8097       {
8098         if (PLAYER_SWITCHING(player, x, y))
8099           return MF_ACTION;
8100
8101 #if 1
8102         PlaySoundLevelElementAction(x, y, element, ACTION_ACTIVATING);
8103 #endif
8104
8105         if (element == EL_ROBOT_WHEEL)
8106         {
8107           Feld[x][y] = EL_ROBOT_WHEEL_ACTIVE;
8108           ZX = x;
8109           ZY = y;
8110
8111           DrawLevelField(x, y);
8112
8113 #if 0
8114           PlaySoundLevel(x, y, SND_ROBOT_WHEEL_ACTIVATING);
8115 #endif
8116         }
8117         else if (element == EL_SP_TERMINAL)
8118         {
8119           int xx, yy;
8120
8121 #if 0
8122           PlaySoundLevel(x, y, SND_SP_TERMINAL_ACTIVATING);
8123 #endif
8124
8125           for (yy=0; yy<lev_fieldy; yy++)
8126           {
8127             for (xx=0; xx<lev_fieldx; xx++)
8128             {
8129               if (Feld[xx][yy] == EL_SP_DISK_YELLOW)
8130                 Bang(xx, yy);
8131               else if (Feld[xx][yy] == EL_SP_TERMINAL)
8132                 Feld[xx][yy] = EL_SP_TERMINAL_ACTIVE;
8133             }
8134           }
8135         }
8136         else if (IS_BELT_SWITCH(element))
8137         {
8138 #if 0
8139           if (!PLAYER_SWITCHING(player, x, y))
8140 #endif
8141           {
8142             player->Switching = TRUE;
8143             player->switch_x = x;
8144             player->switch_y = y;
8145
8146             ToggleBeltSwitch(x, y);
8147
8148 #if 0
8149             PlaySoundLevel(x, y, SND_CLASS_CONVEYOR_BELT_SWITCH_ACTIVATING);
8150 #endif
8151           }
8152         }
8153         else if (element == EL_SWITCHGATE_SWITCH_UP ||
8154                  element == EL_SWITCHGATE_SWITCH_DOWN)
8155         {
8156 #if 0
8157           if (!PLAYER_SWITCHING(player, x, y))
8158 #endif
8159           {
8160             player->Switching = TRUE;
8161             player->switch_x = x;
8162             player->switch_y = y;
8163
8164             ToggleSwitchgateSwitch(x, y);
8165
8166 #if 0
8167             PlaySoundLevel(x, y, SND_CLASS_SWITCHGATE_SWITCH_ACTIVATING);
8168 #endif
8169           }
8170         }
8171         else if (element == EL_LIGHT_SWITCH ||
8172                  element == EL_LIGHT_SWITCH_ACTIVE)
8173         {
8174 #if 0
8175           if (!PLAYER_SWITCHING(player, x, y))
8176 #endif
8177           {
8178             player->Switching = TRUE;
8179             player->switch_x = x;
8180             player->switch_y = y;
8181
8182             ToggleLightSwitch(x, y);
8183
8184 #if 0
8185             PlaySoundLevel(x, y, element == EL_LIGHT_SWITCH ?
8186                            SND_LIGHT_SWITCH_ACTIVATING :
8187                            SND_LIGHT_SWITCH_DEACTIVATING);
8188 #endif
8189           }
8190         }
8191         else if (element == EL_TIMEGATE_SWITCH)
8192         {
8193           ActivateTimegateSwitch(x, y);
8194
8195 #if 0
8196           PlaySoundLevel(x, y, SND_TIMEGATE_SWITCH_ACTIVATING);
8197 #endif
8198         }
8199         else if (element == EL_BALLOON_SWITCH_LEFT ||
8200                  element == EL_BALLOON_SWITCH_RIGHT ||
8201                  element == EL_BALLOON_SWITCH_UP ||
8202                  element == EL_BALLOON_SWITCH_DOWN ||
8203                  element == EL_BALLOON_SWITCH_ANY)
8204         {
8205           if (element == EL_BALLOON_SWITCH_ANY)
8206             game.balloon_dir = move_direction;
8207           else
8208             game.balloon_dir = (element == EL_BALLOON_SWITCH_LEFT  ? MV_LEFT :
8209                                 element == EL_BALLOON_SWITCH_RIGHT ? MV_RIGHT :
8210                                 element == EL_BALLOON_SWITCH_UP    ? MV_UP :
8211                                 element == EL_BALLOON_SWITCH_DOWN  ? MV_DOWN :
8212                                 MV_NO_MOVING);
8213
8214 #if 0
8215           PlaySoundLevel(x, y, SND_CLASS_BALLOON_SWITCH_ACTIVATING);
8216 #endif
8217         }
8218         else if (element == EL_LAMP)
8219         {
8220           Feld[x][y] = EL_LAMP_ACTIVE;
8221           local_player->lights_still_needed--;
8222
8223           DrawLevelField(x, y);
8224
8225 #if 0
8226           PlaySoundLevel(x, y, SND_LAMP_ACTIVATING);
8227 #endif
8228         }
8229         else if (element == EL_TIME_ORB_FULL)
8230         {
8231           Feld[x][y] = EL_TIME_ORB_EMPTY;
8232           TimeLeft += 10;
8233           DrawText(DX_TIME, DY_TIME, int2str(TimeLeft, 3), FONT_TEXT_2);
8234
8235           DrawLevelField(x, y);
8236
8237 #if 0
8238           PlaySoundStereo(SND_TIME_ORB_FULL_COLLECTING, SOUND_MIDDLE);
8239 #endif
8240         }
8241
8242         return MF_ACTION;
8243       }
8244       else
8245       {
8246 #if 1
8247         if (!PLAYER_SWITCHING(player, x, y))
8248 #else
8249         if (!player->Switching)
8250 #endif
8251         {
8252           player->Switching = TRUE;
8253           player->switch_x = x;
8254           player->switch_y = y;
8255
8256           CheckTriggeredElementSideChange(x, y, element, dig_side,
8257                                           CE_OTHER_IS_SWITCHING);
8258           CheckElementSideChange(x, y, element, dig_side, CE_SWITCHED, -1);
8259         }
8260
8261         CheckTriggeredElementSideChange(x, y, element, dig_side,
8262                                         CE_OTHER_GETS_PRESSED);
8263         CheckElementSideChange(x, y, element, dig_side,
8264                                CE_PRESSED_BY_PLAYER, -1);
8265       }
8266
8267       return MF_NO_ACTION;
8268   }
8269
8270   player->push_delay = 0;
8271
8272   if (Feld[x][y] != element)            /* really digged/collected something */
8273     player->is_collecting = !player->is_digging;
8274
8275   return MF_MOVING;
8276 }
8277
8278 boolean SnapField(struct PlayerInfo *player, int dx, int dy)
8279 {
8280   int jx = player->jx, jy = player->jy;
8281   int x = jx + dx, y = jy + dy;
8282   int snap_direction = (dx == -1 ? MV_LEFT :
8283                         dx == +1 ? MV_RIGHT :
8284                         dy == -1 ? MV_UP :
8285                         dy == +1 ? MV_DOWN : MV_NO_MOVING);
8286
8287   if (player->MovPos && game.engine_version >= VERSION_IDENT(2,2,0))
8288     return FALSE;
8289
8290   if (!player->active || !IN_LEV_FIELD(x, y))
8291     return FALSE;
8292
8293   if (dx && dy)
8294     return FALSE;
8295
8296   if (!dx && !dy)
8297   {
8298     if (player->MovPos == 0)
8299       player->Pushing = FALSE;
8300
8301     player->snapped = FALSE;
8302
8303     if (player->MovPos == 0)
8304     {
8305       player->is_digging = FALSE;
8306       player->is_collecting = FALSE;
8307 #if 1
8308       player->is_moving = FALSE;
8309 #endif
8310     }
8311
8312 #if 0
8313     printf("::: trying to snap...\n");
8314 #endif
8315
8316     return FALSE;
8317   }
8318
8319   if (player->snapped)
8320     return FALSE;
8321
8322   player->MovDir = snap_direction;
8323
8324 #if 1
8325   player->is_digging = FALSE;
8326   player->is_collecting = FALSE;
8327 #if 1
8328   player->is_moving = FALSE;
8329 #endif
8330 #endif
8331
8332   if (DigField(player, x, y, 0, 0, DF_SNAP) == MF_NO_ACTION)
8333     return FALSE;
8334
8335   player->snapped = TRUE;
8336 #if 1
8337   player->is_digging = FALSE;
8338   player->is_collecting = FALSE;
8339 #if 1
8340   player->is_moving = FALSE;
8341 #endif
8342 #endif
8343
8344   DrawLevelField(x, y);
8345   BackToFront();
8346
8347   return TRUE;
8348 }
8349
8350 boolean DropElement(struct PlayerInfo *player)
8351 {
8352   int jx = player->jx, jy = player->jy;
8353   int old_element;
8354
8355   if (!player->active || player->MovPos)
8356     return FALSE;
8357
8358   old_element = Feld[jx][jy];
8359
8360   /* check if player has anything that can be dropped */
8361   if (player->inventory_size == 0 && player->dynabombs_left == 0)
8362     return FALSE;
8363
8364   /* check if anything can be dropped at the current position */
8365   if (IS_ACTIVE_BOMB(old_element) || old_element == EL_EXPLOSION)
8366     return FALSE;
8367
8368   /* collected custom elements can only be dropped on empty fields */
8369   if (player->inventory_size > 0 &&
8370       IS_CUSTOM_ELEMENT(player->inventory_element[player->inventory_size - 1])
8371       && old_element != EL_EMPTY)
8372     return FALSE;
8373
8374   if (old_element != EL_EMPTY)
8375     Back[jx][jy] = old_element;         /* store old element on this field */
8376
8377   MovDelay[jx][jy] = 96;
8378
8379   ResetGfxAnimation(jx, jy);
8380   ResetRandomAnimationValue(jx, jy);
8381
8382   if (player->inventory_size > 0)
8383   {
8384     int new_element = player->inventory_element[--player->inventory_size];
8385
8386 #if 1
8387     Feld[jx][jy] = (new_element == EL_DYNAMITE ? EL_DYNAMITE_ACTIVE :
8388                     new_element == EL_SP_DISK_RED ? EL_SP_DISK_RED_ACTIVE :
8389                     new_element);
8390 #else
8391     Feld[jx][jy] = (player->use_disk_red_graphic ? EL_SP_DISK_RED_ACTIVE :
8392                     EL_DYNAMITE_ACTIVE);
8393 #endif
8394
8395     DrawText(DX_DYNAMITE, DY_DYNAMITE,
8396              int2str(local_player->inventory_size, 3), FONT_TEXT_2);
8397
8398     if (IN_SCR_FIELD(SCREENX(jx), SCREENY(jy)))
8399       DrawGraphicThruMask(SCREENX(jx), SCREENY(jy), el2img(Feld[jx][jy]), 0);
8400
8401     PlaySoundLevelAction(jx, jy, ACTION_DROPPING);
8402
8403     CheckTriggeredElementChange(jx, jy, new_element, CE_OTHER_GETS_DROPPED);
8404     CheckElementChange(jx, jy, new_element, CE_DROPPED_BY_PLAYER);
8405
8406     TestIfElementTouchesCustomElement(jx, jy);
8407   }
8408   else          /* player is dropping a dyna bomb */
8409   {
8410     player->dynabombs_left--;
8411
8412     Feld[jx][jy] =
8413       EL_DYNABOMB_PLAYER_1_ACTIVE + (player->element_nr - EL_PLAYER_1);
8414
8415     if (IN_SCR_FIELD(SCREENX(jx), SCREENY(jy)))
8416       DrawGraphicThruMask(SCREENX(jx), SCREENY(jy), el2img(Feld[jx][jy]), 0);
8417
8418     PlaySoundLevelAction(jx, jy, ACTION_DROPPING);
8419   }
8420
8421   return TRUE;
8422 }
8423
8424 /* ------------------------------------------------------------------------- */
8425 /* game sound playing functions                                              */
8426 /* ------------------------------------------------------------------------- */
8427
8428 static int *loop_sound_frame = NULL;
8429 static int *loop_sound_volume = NULL;
8430
8431 void InitPlaySoundLevel()
8432 {
8433   int num_sounds = getSoundListSize();
8434
8435   if (loop_sound_frame != NULL)
8436     free(loop_sound_frame);
8437
8438   if (loop_sound_volume != NULL)
8439     free(loop_sound_volume);
8440
8441   loop_sound_frame = checked_calloc(num_sounds * sizeof(int));
8442   loop_sound_volume = checked_calloc(num_sounds * sizeof(int));
8443 }
8444
8445 static void PlaySoundLevel(int x, int y, int nr)
8446 {
8447   int sx = SCREENX(x), sy = SCREENY(y);
8448   int volume, stereo_position;
8449   int max_distance = 8;
8450   int type = (IS_LOOP_SOUND(nr) ? SND_CTRL_PLAY_LOOP : SND_CTRL_PLAY_SOUND);
8451
8452   if ((!setup.sound_simple && !IS_LOOP_SOUND(nr)) ||
8453       (!setup.sound_loops && IS_LOOP_SOUND(nr)))
8454     return;
8455
8456   if (!IN_LEV_FIELD(x, y) ||
8457       sx < -max_distance || sx >= SCR_FIELDX + max_distance ||
8458       sy < -max_distance || sy >= SCR_FIELDY + max_distance)
8459     return;
8460
8461   volume = SOUND_MAX_VOLUME;
8462
8463   if (!IN_SCR_FIELD(sx, sy))
8464   {
8465     int dx = ABS(sx - SCR_FIELDX / 2) - SCR_FIELDX / 2;
8466     int dy = ABS(sy - SCR_FIELDY / 2) - SCR_FIELDY / 2;
8467
8468     volume -= volume * (dx > dy ? dx : dy) / max_distance;
8469   }
8470
8471   stereo_position = (SOUND_MAX_LEFT +
8472                      (sx + max_distance) * SOUND_MAX_LEFT2RIGHT /
8473                      (SCR_FIELDX + 2 * max_distance));
8474
8475   if (IS_LOOP_SOUND(nr))
8476   {
8477     /* This assures that quieter loop sounds do not overwrite louder ones,
8478        while restarting sound volume comparison with each new game frame. */
8479
8480     if (loop_sound_volume[nr] > volume && loop_sound_frame[nr] == FrameCounter)
8481       return;
8482
8483     loop_sound_volume[nr] = volume;
8484     loop_sound_frame[nr] = FrameCounter;
8485   }
8486
8487   PlaySoundExt(nr, volume, stereo_position, type);
8488 }
8489
8490 static void PlaySoundLevelNearest(int x, int y, int sound_action)
8491 {
8492   PlaySoundLevel(x < LEVELX(BX1) ? LEVELX(BX1) :
8493                  x > LEVELX(BX2) ? LEVELX(BX2) : x,
8494                  y < LEVELY(BY1) ? LEVELY(BY1) :
8495                  y > LEVELY(BY2) ? LEVELY(BY2) : y,
8496                  sound_action);
8497 }
8498
8499 static void PlaySoundLevelAction(int x, int y, int action)
8500 {
8501   PlaySoundLevelElementAction(x, y, Feld[x][y], action);
8502 }
8503
8504 static void PlaySoundLevelElementAction(int x, int y, int element, int action)
8505 {
8506   int sound_effect = element_info[element].sound[action];
8507
8508   if (sound_effect != SND_UNDEFINED)
8509     PlaySoundLevel(x, y, sound_effect);
8510 }
8511
8512 static void PlaySoundLevelActionIfLoop(int x, int y, int action)
8513 {
8514   int sound_effect = element_info[Feld[x][y]].sound[action];
8515
8516   if (sound_effect != SND_UNDEFINED && IS_LOOP_SOUND(sound_effect))
8517     PlaySoundLevel(x, y, sound_effect);
8518 }
8519
8520 static void StopSoundLevelActionIfLoop(int x, int y, int action)
8521 {
8522   int sound_effect = element_info[Feld[x][y]].sound[action];
8523
8524   if (sound_effect != SND_UNDEFINED && IS_LOOP_SOUND(sound_effect))
8525     StopSoundExt(sound_effect, SND_CTRL_STOP_SOUND);
8526 }
8527
8528 void RaiseScore(int value)
8529 {
8530   local_player->score += value;
8531   DrawText(DX_SCORE, DY_SCORE, int2str(local_player->score, 5), FONT_TEXT_2);
8532 }
8533
8534 void RaiseScoreElement(int element)
8535 {
8536   switch(element)
8537   {
8538     case EL_EMERALD:
8539     case EL_BD_DIAMOND:
8540     case EL_EMERALD_YELLOW:
8541     case EL_EMERALD_RED:
8542     case EL_EMERALD_PURPLE:
8543     case EL_SP_INFOTRON:
8544       RaiseScore(level.score[SC_EMERALD]);
8545       break;
8546     case EL_DIAMOND:
8547       RaiseScore(level.score[SC_DIAMOND]);
8548       break;
8549     case EL_CRYSTAL:
8550       RaiseScore(level.score[SC_CRYSTAL]);
8551       break;
8552     case EL_PEARL:
8553       RaiseScore(level.score[SC_PEARL]);
8554       break;
8555     case EL_BUG:
8556     case EL_BD_BUTTERFLY:
8557     case EL_SP_ELECTRON:
8558       RaiseScore(level.score[SC_BUG]);
8559       break;
8560     case EL_SPACESHIP:
8561     case EL_BD_FIREFLY:
8562     case EL_SP_SNIKSNAK:
8563       RaiseScore(level.score[SC_SPACESHIP]);
8564       break;
8565     case EL_YAMYAM:
8566     case EL_DARK_YAMYAM:
8567       RaiseScore(level.score[SC_YAMYAM]);
8568       break;
8569     case EL_ROBOT:
8570       RaiseScore(level.score[SC_ROBOT]);
8571       break;
8572     case EL_PACMAN:
8573       RaiseScore(level.score[SC_PACMAN]);
8574       break;
8575     case EL_NUT:
8576       RaiseScore(level.score[SC_NUT]);
8577       break;
8578     case EL_DYNAMITE:
8579     case EL_SP_DISK_RED:
8580     case EL_DYNABOMB_INCREASE_NUMBER:
8581     case EL_DYNABOMB_INCREASE_SIZE:
8582     case EL_DYNABOMB_INCREASE_POWER:
8583       RaiseScore(level.score[SC_DYNAMITE]);
8584       break;
8585     case EL_SHIELD_NORMAL:
8586     case EL_SHIELD_DEADLY:
8587       RaiseScore(level.score[SC_SHIELD]);
8588       break;
8589     case EL_EXTRA_TIME:
8590       RaiseScore(level.score[SC_TIME_BONUS]);
8591       break;
8592     case EL_KEY_1:
8593     case EL_KEY_2:
8594     case EL_KEY_3:
8595     case EL_KEY_4:
8596       RaiseScore(level.score[SC_KEY]);
8597       break;
8598     default:
8599       RaiseScore(element_info[element].collect_score);
8600       break;
8601   }
8602 }
8603
8604 void RequestQuitGame(boolean ask_if_really_quit)
8605 {
8606   if (AllPlayersGone ||
8607       !ask_if_really_quit ||
8608       level_editor_test_game ||
8609       Request("Do you really want to quit the game ?",
8610               REQ_ASK | REQ_STAY_CLOSED))
8611   {
8612 #if defined(PLATFORM_UNIX)
8613     if (options.network)
8614       SendToServer_StopPlaying();
8615     else
8616 #endif
8617     {
8618       game_status = GAME_MODE_MAIN;
8619       DrawMainMenu();
8620     }
8621   }
8622   else
8623   {
8624     OpenDoor(DOOR_OPEN_1 | DOOR_COPY_BACK);
8625   }
8626 }
8627
8628
8629 /* ---------- new game button stuff ---------------------------------------- */
8630
8631 /* graphic position values for game buttons */
8632 #define GAME_BUTTON_XSIZE       30
8633 #define GAME_BUTTON_YSIZE       30
8634 #define GAME_BUTTON_XPOS        5
8635 #define GAME_BUTTON_YPOS        215
8636 #define SOUND_BUTTON_XPOS       5
8637 #define SOUND_BUTTON_YPOS       (GAME_BUTTON_YPOS + GAME_BUTTON_YSIZE)
8638
8639 #define GAME_BUTTON_STOP_XPOS   (GAME_BUTTON_XPOS + 0 * GAME_BUTTON_XSIZE)
8640 #define GAME_BUTTON_PAUSE_XPOS  (GAME_BUTTON_XPOS + 1 * GAME_BUTTON_XSIZE)
8641 #define GAME_BUTTON_PLAY_XPOS   (GAME_BUTTON_XPOS + 2 * GAME_BUTTON_XSIZE)
8642 #define SOUND_BUTTON_MUSIC_XPOS (SOUND_BUTTON_XPOS + 0 * GAME_BUTTON_XSIZE)
8643 #define SOUND_BUTTON_LOOPS_XPOS (SOUND_BUTTON_XPOS + 1 * GAME_BUTTON_XSIZE)
8644 #define SOUND_BUTTON_SIMPLE_XPOS (SOUND_BUTTON_XPOS + 2 * GAME_BUTTON_XSIZE)
8645
8646 static struct
8647 {
8648   int x, y;
8649   int gadget_id;
8650   char *infotext;
8651 } gamebutton_info[NUM_GAME_BUTTONS] =
8652 {
8653   {
8654     GAME_BUTTON_STOP_XPOS,      GAME_BUTTON_YPOS,
8655     GAME_CTRL_ID_STOP,
8656     "stop game"
8657   },
8658   {
8659     GAME_BUTTON_PAUSE_XPOS,     GAME_BUTTON_YPOS,
8660     GAME_CTRL_ID_PAUSE,
8661     "pause game"
8662   },
8663   {
8664     GAME_BUTTON_PLAY_XPOS,      GAME_BUTTON_YPOS,
8665     GAME_CTRL_ID_PLAY,
8666     "play game"
8667   },
8668   {
8669     SOUND_BUTTON_MUSIC_XPOS,    SOUND_BUTTON_YPOS,
8670     SOUND_CTRL_ID_MUSIC,
8671     "background music on/off"
8672   },
8673   {
8674     SOUND_BUTTON_LOOPS_XPOS,    SOUND_BUTTON_YPOS,
8675     SOUND_CTRL_ID_LOOPS,
8676     "sound loops on/off"
8677   },
8678   {
8679     SOUND_BUTTON_SIMPLE_XPOS,   SOUND_BUTTON_YPOS,
8680     SOUND_CTRL_ID_SIMPLE,
8681     "normal sounds on/off"
8682   }
8683 };
8684
8685 void CreateGameButtons()
8686 {
8687   int i;
8688
8689   for (i=0; i<NUM_GAME_BUTTONS; i++)
8690   {
8691     Bitmap *gd_bitmap = graphic_info[IMG_GLOBAL_DOOR].bitmap;
8692     struct GadgetInfo *gi;
8693     int button_type;
8694     boolean checked;
8695     unsigned long event_mask;
8696     int gd_xoffset, gd_yoffset;
8697     int gd_x1, gd_x2, gd_y1, gd_y2;
8698     int id = i;
8699
8700     gd_xoffset = gamebutton_info[i].x;
8701     gd_yoffset = gamebutton_info[i].y;
8702     gd_x1 = DOOR_GFX_PAGEX4 + gd_xoffset;
8703     gd_x2 = DOOR_GFX_PAGEX3 + gd_xoffset;
8704
8705     if (id == GAME_CTRL_ID_STOP ||
8706         id == GAME_CTRL_ID_PAUSE ||
8707         id == GAME_CTRL_ID_PLAY)
8708     {
8709       button_type = GD_TYPE_NORMAL_BUTTON;
8710       checked = FALSE;
8711       event_mask = GD_EVENT_RELEASED;
8712       gd_y1  = DOOR_GFX_PAGEY1 + gd_yoffset - GAME_BUTTON_YSIZE;
8713       gd_y2  = DOOR_GFX_PAGEY1 + gd_yoffset - GAME_BUTTON_YSIZE;
8714     }
8715     else
8716     {
8717       button_type = GD_TYPE_CHECK_BUTTON;
8718       checked =
8719         ((id == SOUND_CTRL_ID_MUSIC && setup.sound_music) ||
8720          (id == SOUND_CTRL_ID_LOOPS && setup.sound_loops) ||
8721          (id == SOUND_CTRL_ID_SIMPLE && setup.sound_simple) ? TRUE : FALSE);
8722       event_mask = GD_EVENT_PRESSED;
8723       gd_y1  = DOOR_GFX_PAGEY1 + gd_yoffset;
8724       gd_y2  = DOOR_GFX_PAGEY1 + gd_yoffset - GAME_BUTTON_YSIZE;
8725     }
8726
8727     gi = CreateGadget(GDI_CUSTOM_ID, id,
8728                       GDI_INFO_TEXT, gamebutton_info[i].infotext,
8729                       GDI_X, DX + gd_xoffset,
8730                       GDI_Y, DY + gd_yoffset,
8731                       GDI_WIDTH, GAME_BUTTON_XSIZE,
8732                       GDI_HEIGHT, GAME_BUTTON_YSIZE,
8733                       GDI_TYPE, button_type,
8734                       GDI_STATE, GD_BUTTON_UNPRESSED,
8735                       GDI_CHECKED, checked,
8736                       GDI_DESIGN_UNPRESSED, gd_bitmap, gd_x1, gd_y1,
8737                       GDI_DESIGN_PRESSED, gd_bitmap, gd_x2, gd_y1,
8738                       GDI_ALT_DESIGN_UNPRESSED, gd_bitmap, gd_x1, gd_y2,
8739                       GDI_ALT_DESIGN_PRESSED, gd_bitmap, gd_x2, gd_y2,
8740                       GDI_EVENT_MASK, event_mask,
8741                       GDI_CALLBACK_ACTION, HandleGameButtons,
8742                       GDI_END);
8743
8744     if (gi == NULL)
8745       Error(ERR_EXIT, "cannot create gadget");
8746
8747     game_gadget[id] = gi;
8748   }
8749 }
8750
8751 void FreeGameButtons()
8752 {
8753   int i;
8754
8755   for (i=0; i<NUM_GAME_BUTTONS; i++)
8756     FreeGadget(game_gadget[i]);
8757 }
8758
8759 static void MapGameButtons()
8760 {
8761   int i;
8762
8763   for (i=0; i<NUM_GAME_BUTTONS; i++)
8764     MapGadget(game_gadget[i]);
8765 }
8766
8767 void UnmapGameButtons()
8768 {
8769   int i;
8770
8771   for (i=0; i<NUM_GAME_BUTTONS; i++)
8772     UnmapGadget(game_gadget[i]);
8773 }
8774
8775 static void HandleGameButtons(struct GadgetInfo *gi)
8776 {
8777   int id = gi->custom_id;
8778
8779   if (game_status != GAME_MODE_PLAYING)
8780     return;
8781
8782   switch (id)
8783   {
8784     case GAME_CTRL_ID_STOP:
8785       RequestQuitGame(TRUE);
8786       break;
8787
8788     case GAME_CTRL_ID_PAUSE:
8789       if (options.network)
8790       {
8791 #if defined(PLATFORM_UNIX)
8792         if (tape.pausing)
8793           SendToServer_ContinuePlaying();
8794         else
8795           SendToServer_PausePlaying();
8796 #endif
8797       }
8798       else
8799         TapeTogglePause(TAPE_TOGGLE_MANUAL);
8800       break;
8801
8802     case GAME_CTRL_ID_PLAY:
8803       if (tape.pausing)
8804       {
8805 #if defined(PLATFORM_UNIX)
8806         if (options.network)
8807           SendToServer_ContinuePlaying();
8808         else
8809 #endif
8810         {
8811           tape.pausing = FALSE;
8812           DrawVideoDisplay(VIDEO_STATE_PAUSE_OFF,0);
8813         }
8814       }
8815       break;
8816
8817     case SOUND_CTRL_ID_MUSIC:
8818       if (setup.sound_music)
8819       {
8820         setup.sound_music = FALSE;
8821         FadeMusic();
8822       }
8823       else if (audio.music_available)
8824       {
8825         setup.sound = setup.sound_music = TRUE;
8826
8827         SetAudioMode(setup.sound);
8828         PlayMusic(level_nr);
8829       }
8830       break;
8831
8832     case SOUND_CTRL_ID_LOOPS:
8833       if (setup.sound_loops)
8834         setup.sound_loops = FALSE;
8835       else if (audio.loops_available)
8836       {
8837         setup.sound = setup.sound_loops = TRUE;
8838         SetAudioMode(setup.sound);
8839       }
8840       break;
8841
8842     case SOUND_CTRL_ID_SIMPLE:
8843       if (setup.sound_simple)
8844         setup.sound_simple = FALSE;
8845       else if (audio.sound_available)
8846       {
8847         setup.sound = setup.sound_simple = TRUE;
8848         SetAudioMode(setup.sound);
8849       }
8850       break;
8851
8852     default:
8853       break;
8854   }
8855 }