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