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