src/game.c

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