src/game.c

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