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 element;
1910
1911       if (!IN_LEV_FIELD(x, y) ||
1912           ((mode != EX_NORMAL || center_element == EL_AMOEBA_TO_DIAMOND) &&
1913            (x != ex || y != ey)))
1914         continue;
1915
1916       element = Feld[x][y];
1917
1918       if (IS_MOVING(x, y) || IS_BLOCKED(x, y))
1919       {
1920         element = MovingOrBlocked2Element(x, y);
1921
1922         if (!IS_EXPLOSION_PROOF(element))
1923           RemoveMovingField(x, y);
1924       }
1925
1926 #if 1
1927
1928 #if 1
1929       if (IS_EXPLOSION_PROOF(element))
1930         continue;
1931 #else
1932       /* indestructible elements can only explode in center (but not flames) */
1933       if ((IS_EXPLOSION_PROOF(element) && (x != ex || y != ey)) ||
1934           element == EL_FLAMES)
1935         continue;
1936 #endif
1937
1938 #else
1939       if ((IS_INDESTRUCTIBLE(element) &&
1940            (game.engine_version < VERSION_IDENT(2,2,0) ||
1941             (!IS_WALKABLE_OVER(element) && !IS_WALKABLE_UNDER(element)))) ||
1942           element == EL_FLAMES)
1943         continue;
1944 #endif
1945
1946       if (IS_PLAYER(x, y) && SHIELD_ON(PLAYERINFO(x, y)))
1947       {
1948         if (IS_ACTIVE_BOMB(element))
1949         {
1950           /* re-activate things under the bomb like gate or penguin */
1951           Feld[x][y] = (Store[x][y] ? Store[x][y] : EL_EMPTY);
1952           Store[x][y] = 0;
1953         }
1954
1955         continue;
1956       }
1957
1958       /* save walkable background elements while explosion on same tile */
1959 #if 1
1960       if (IS_INDESTRUCTIBLE(element))
1961         Back[x][y] = element;
1962 #else
1963       if (IS_INDESTRUCTIBLE(element) && IS_WALKABLE(element))
1964         Back[x][y] = element;
1965 #endif
1966
1967       /* ignite explodable elements reached by other explosion */
1968       if (element == EL_EXPLOSION)
1969         element = Store2[x][y];
1970
1971 #if 1
1972       if (AmoebaNr[x][y] &&
1973           (element == EL_AMOEBA_FULL ||
1974            element == EL_BD_AMOEBA ||
1975            element == EL_AMOEBA_GROWING))
1976       {
1977         AmoebaCnt[AmoebaNr[x][y]]--;
1978         AmoebaCnt2[AmoebaNr[x][y]]--;
1979       }
1980
1981       RemoveField(x, y);
1982 #endif
1983
1984       if (IS_PLAYER(ex, ey) && !PLAYER_PROTECTED(ex, ey))
1985       {
1986         switch(StorePlayer[ex][ey])
1987         {
1988           case EL_PLAYER_2:
1989             Store[x][y] = EL_EMERALD_RED;
1990             break;
1991           case EL_PLAYER_3:
1992             Store[x][y] = EL_EMERALD;
1993             break;
1994           case EL_PLAYER_4:
1995             Store[x][y] = EL_EMERALD_PURPLE;
1996             break;
1997           case EL_PLAYER_1:
1998           default:
1999             Store[x][y] = EL_EMERALD_YELLOW;
2000             break;
2001         }
2002
2003         if (game.emulation == EMU_SUPAPLEX)
2004           Store[x][y] = EL_EMPTY;
2005       }
2006       else if (center_element == EL_MOLE)
2007         Store[x][y] = EL_EMERALD_RED;
2008       else if (center_element == EL_PENGUIN)
2009         Store[x][y] = EL_EMERALD_PURPLE;
2010       else if (center_element == EL_BUG)
2011         Store[x][y] = ((x == ex && y == ey) ? EL_DIAMOND : EL_EMERALD);
2012       else if (center_element == EL_BD_BUTTERFLY)
2013         Store[x][y] = EL_BD_DIAMOND;
2014       else if (center_element == EL_SP_ELECTRON)
2015         Store[x][y] = EL_SP_INFOTRON;
2016       else if (center_element == EL_AMOEBA_TO_DIAMOND)
2017         Store[x][y] = level.amoeba_content;
2018       else if (center_element == EL_YAMYAM)
2019         Store[x][y] =
2020           level.yamyam_content[game.yamyam_content_nr][x - ex + 1][y - ey + 1];
2021       else if (IS_CUSTOM_ELEMENT(center_element))
2022         Store[x][y] =
2023           element_info[center_element].content[x - ex + 1][y - ey + 1];
2024       else if (element == EL_WALL_EMERALD)
2025         Store[x][y] = EL_EMERALD;
2026       else if (element == EL_WALL_DIAMOND)
2027         Store[x][y] = EL_DIAMOND;
2028       else if (element == EL_WALL_BD_DIAMOND)
2029         Store[x][y] = EL_BD_DIAMOND;
2030       else if (element == EL_WALL_EMERALD_YELLOW)
2031         Store[x][y] = EL_EMERALD_YELLOW;
2032       else if (element == EL_WALL_EMERALD_RED)
2033         Store[x][y] = EL_EMERALD_RED;
2034       else if (element == EL_WALL_EMERALD_PURPLE)
2035         Store[x][y] = EL_EMERALD_PURPLE;
2036       else if (element == EL_WALL_PEARL)
2037         Store[x][y] = EL_PEARL;
2038       else if (element == EL_WALL_CRYSTAL)
2039         Store[x][y] = EL_CRYSTAL;
2040       else
2041         Store[x][y] = EL_EMPTY;
2042
2043       if (x != ex || y != ey ||
2044           center_element == EL_AMOEBA_TO_DIAMOND || mode == EX_BORDER)
2045         Store2[x][y] = element;
2046
2047 #if 0
2048       if (AmoebaNr[x][y] &&
2049           (element == EL_AMOEBA_FULL ||
2050            element == EL_BD_AMOEBA ||
2051            element == EL_AMOEBA_GROWING))
2052       {
2053         AmoebaCnt[AmoebaNr[x][y]]--;
2054         AmoebaCnt2[AmoebaNr[x][y]]--;
2055       }
2056
2057 #if 1
2058       RemoveField(x, y);
2059 #else
2060       MovDir[x][y] = MovPos[x][y] = 0;
2061       AmoebaNr[x][y] = 0;
2062 #endif
2063 #endif
2064
2065       Feld[x][y] = EL_EXPLOSION;
2066 #if 1
2067       GfxElement[x][y] = center_element;
2068 #else
2069       GfxElement[x][y] = EL_UNDEFINED;
2070 #endif
2071
2072       ExplodePhase[x][y] = 1;
2073       Stop[x][y] = TRUE;
2074     }
2075
2076     if (center_element == EL_YAMYAM)
2077       game.yamyam_content_nr =
2078         (game.yamyam_content_nr + 1) % level.num_yamyam_contents;
2079
2080     return;
2081   }
2082
2083   if (Stop[ex][ey])
2084     return;
2085
2086   x = ex;
2087   y = ey;
2088
2089   ExplodePhase[x][y] = (phase < last_phase ? phase + 1 : 0);
2090
2091   if (phase == first_phase_after_start)
2092   {
2093     int element = Store2[x][y];
2094
2095     if (element == EL_BLACK_ORB)
2096     {
2097       Feld[x][y] = Store2[x][y];
2098       Store2[x][y] = 0;
2099       Bang(x, y);
2100     }
2101   }
2102   else if (phase == half_phase)
2103   {
2104     int element = Store2[x][y];
2105
2106     if (IS_PLAYER(x, y))
2107       KillHeroUnlessProtected(x, y);
2108     else if (CAN_EXPLODE_BY_FIRE(element))
2109     {
2110       Feld[x][y] = Store2[x][y];
2111       Store2[x][y] = 0;
2112       Bang(x, y);
2113     }
2114     else if (element == EL_AMOEBA_TO_DIAMOND)
2115       AmoebeUmwandeln(x, y);
2116   }
2117
2118   if (phase == last_phase)
2119   {
2120     int element;
2121
2122     element = Feld[x][y] = Store[x][y];
2123     Store[x][y] = Store2[x][y] = 0;
2124     GfxElement[x][y] = EL_UNDEFINED;
2125
2126     if (Back[x][y] && IS_INDESTRUCTIBLE(Back[x][y]))
2127       element = Feld[x][y] = Back[x][y];
2128     Back[x][y] = 0;
2129
2130     MovDir[x][y] = MovPos[x][y] = MovDelay[x][y] = ChangeDelay[x][y] = 0;
2131     InitField(x, y, FALSE);
2132     if (CAN_MOVE(element))
2133       InitMovDir(x, y);
2134     DrawLevelField(x, y);
2135
2136     if (IS_PLAYER(x, y) && !PLAYERINFO(x,y)->present)
2137       StorePlayer[x][y] = 0;
2138   }
2139   else if (phase >= delay && IN_SCR_FIELD(SCREENX(x), SCREENY(y)))
2140   {
2141 #if 1
2142     int graphic = el_act2img(GfxElement[x][y], ACTION_EXPLODING);
2143 #else
2144     int stored = Store[x][y];
2145     int graphic = (game.emulation != EMU_SUPAPLEX ? IMG_EXPLOSION :
2146                    stored == EL_SP_INFOTRON ? IMG_SP_EXPLOSION_INFOTRON :
2147                    IMG_SP_EXPLOSION);
2148 #endif
2149     int frame = getGraphicAnimationFrame(graphic, phase - delay);
2150
2151     if (phase == delay)
2152       DrawLevelFieldCrumbledSand(x, y);
2153
2154     if (IS_WALKABLE_OVER(Back[x][y]) && Back[x][y] != EL_EMPTY)
2155     {
2156       DrawLevelElement(x, y, Back[x][y]);
2157       DrawGraphicThruMask(SCREENX(x), SCREENY(y), graphic, frame);
2158     }
2159     else if (IS_WALKABLE_UNDER(Back[x][y]))
2160     {
2161       DrawGraphic(SCREENX(x), SCREENY(y), graphic, frame);
2162       DrawLevelElementThruMask(x, y, Back[x][y]);
2163     }
2164     else if (!IS_WALKABLE_INSIDE(Back[x][y]))
2165       DrawGraphic(SCREENX(x), SCREENY(y), graphic, frame);
2166   }
2167 }
2168
2169 void DynaExplode(int ex, int ey)
2170 {
2171   int i, j;
2172   int dynabomb_size = 1;
2173   boolean dynabomb_xl = FALSE;
2174   struct PlayerInfo *player;
2175   static int xy[4][2] =
2176   {
2177     { 0, -1 },
2178     { -1, 0 },
2179     { +1, 0 },
2180     { 0, +1 }
2181   };
2182
2183   if (IS_ACTIVE_BOMB(Feld[ex][ey]))
2184   {
2185     player = &stored_player[Feld[ex][ey] - EL_DYNABOMB_PLAYER_1_ACTIVE];
2186     dynabomb_size = player->dynabomb_size;
2187     dynabomb_xl = player->dynabomb_xl;
2188     player->dynabombs_left++;
2189   }
2190
2191   Explode(ex, ey, EX_PHASE_START, EX_CENTER);
2192
2193   for (i=0; i<4; i++)
2194   {
2195     for (j=1; j<=dynabomb_size; j++)
2196     {
2197       int x = ex + j * xy[i % 4][0];
2198       int y = ey + j * xy[i % 4][1];
2199       int element;
2200
2201       if (!IN_LEV_FIELD(x, y) || IS_INDESTRUCTIBLE(Feld[x][y]))
2202         break;
2203
2204       element = Feld[x][y];
2205
2206       /* do not restart explosions of fields with active bombs */
2207       if (element == EL_EXPLOSION && IS_ACTIVE_BOMB(Store2[x][y]))
2208         continue;
2209
2210       Explode(x, y, EX_PHASE_START, EX_BORDER);
2211
2212       if (element != EL_EMPTY &&
2213           element != EL_SAND &&
2214           element != EL_EXPLOSION &&
2215           !dynabomb_xl)
2216         break;
2217     }
2218   }
2219 }
2220
2221 void Bang(int x, int y)
2222 {
2223 #if 1
2224   int element = MovingOrBlocked2Element(x, y);
2225 #else
2226   int element = Feld[x][y];
2227 #endif
2228
2229   if (IS_PLAYER(x, y))
2230   {
2231     struct PlayerInfo *player = PLAYERINFO(x, y);
2232
2233     element = Feld[x][y] = (player->use_murphy_graphic ? EL_SP_MURPHY :
2234                             player->element_nr);
2235   }
2236
2237 #if 0
2238 #if 1
2239   PlaySoundLevelAction(x, y, ACTION_EXPLODING);
2240 #else
2241   if (game.emulation == EMU_SUPAPLEX)
2242     PlaySoundLevel(x, y, SND_SP_ELEMENT_EXPLODING);
2243   else
2244     PlaySoundLevel(x, y, SND_ELEMENT_EXPLODING);
2245 #endif
2246 #endif
2247
2248 #if 0
2249   if (IS_PLAYER(x, y))  /* remove objects that might cause smaller explosion */
2250     element = EL_EMPTY;
2251 #endif
2252
2253   switch(element)
2254   {
2255     case EL_BUG:
2256     case EL_SPACESHIP:
2257     case EL_BD_BUTTERFLY:
2258     case EL_BD_FIREFLY:
2259     case EL_YAMYAM:
2260     case EL_DARK_YAMYAM:
2261     case EL_ROBOT:
2262     case EL_PACMAN:
2263     case EL_MOLE:
2264       RaiseScoreElement(element);
2265       Explode(x, y, EX_PHASE_START, EX_NORMAL);
2266       break;
2267     case EL_DYNABOMB_PLAYER_1_ACTIVE:
2268     case EL_DYNABOMB_PLAYER_2_ACTIVE:
2269     case EL_DYNABOMB_PLAYER_3_ACTIVE:
2270     case EL_DYNABOMB_PLAYER_4_ACTIVE:
2271     case EL_DYNABOMB_INCREASE_NUMBER:
2272     case EL_DYNABOMB_INCREASE_SIZE:
2273     case EL_DYNABOMB_INCREASE_POWER:
2274       DynaExplode(x, y);
2275       break;
2276     case EL_PENGUIN:
2277     case EL_LAMP:
2278     case EL_LAMP_ACTIVE:
2279       if (IS_PLAYER(x, y))
2280         Explode(x, y, EX_PHASE_START, EX_NORMAL);
2281       else
2282         Explode(x, y, EX_PHASE_START, EX_CENTER);
2283       break;
2284     default:
2285       Explode(x, y, EX_PHASE_START, EX_NORMAL);
2286       break;
2287   }
2288
2289   CheckTriggeredElementChange(x, y, element, CE_OTHER_IS_EXPLODING);
2290 }
2291
2292 void SplashAcid(int x, int y)
2293 {
2294   int element = Feld[x][y];
2295
2296   if (element != EL_ACID_SPLASH_LEFT &&
2297       element != EL_ACID_SPLASH_RIGHT)
2298   {
2299     PlaySoundLevel(x, y, SND_ACID_SPLASHING);
2300
2301     if (IN_LEV_FIELD(x-1, y) && IS_FREE(x-1, y) &&
2302         (!IN_LEV_FIELD(x-1, y-1) ||
2303          !CAN_FALL(MovingOrBlocked2Element(x-1, y-1))))
2304       Feld[x-1][y] = EL_ACID_SPLASH_LEFT;
2305
2306     if (IN_LEV_FIELD(x+1, y) && IS_FREE(x+1, y) &&
2307         (!IN_LEV_FIELD(x+1, y-1) ||
2308          !CAN_FALL(MovingOrBlocked2Element(x+1, y-1))))
2309       Feld[x+1][y] = EL_ACID_SPLASH_RIGHT;
2310   }
2311 }
2312
2313 static void InitBeltMovement()
2314 {
2315   static int belt_base_element[4] =
2316   {
2317     EL_CONVEYOR_BELT_1_LEFT,
2318     EL_CONVEYOR_BELT_2_LEFT,
2319     EL_CONVEYOR_BELT_3_LEFT,
2320     EL_CONVEYOR_BELT_4_LEFT
2321   };
2322   static int belt_base_active_element[4] =
2323   {
2324     EL_CONVEYOR_BELT_1_LEFT_ACTIVE,
2325     EL_CONVEYOR_BELT_2_LEFT_ACTIVE,
2326     EL_CONVEYOR_BELT_3_LEFT_ACTIVE,
2327     EL_CONVEYOR_BELT_4_LEFT_ACTIVE
2328   };
2329
2330   int x, y, i, j;
2331
2332   /* set frame order for belt animation graphic according to belt direction */
2333   for (i=0; i<4; i++)
2334   {
2335     int belt_nr = i;
2336
2337     for (j=0; j<3; j++)
2338     {
2339       int element = belt_base_active_element[belt_nr] + j;
2340       int graphic = el2img(element);
2341
2342       if (game.belt_dir[i] == MV_LEFT)
2343         graphic_info[graphic].anim_mode &= ~ANIM_REVERSE;
2344       else
2345         graphic_info[graphic].anim_mode |=  ANIM_REVERSE;
2346     }
2347   }
2348
2349   for(y=0; y<lev_fieldy; y++)
2350   {
2351     for(x=0; x<lev_fieldx; x++)
2352     {
2353       int element = Feld[x][y];
2354
2355       for (i=0; i<4; i++)
2356       {
2357         if (IS_BELT(element) && game.belt_dir[i] != MV_NO_MOVING)
2358         {
2359           int e_belt_nr = getBeltNrFromBeltElement(element);
2360           int belt_nr = i;
2361
2362           if (e_belt_nr == belt_nr)
2363           {
2364             int belt_part = Feld[x][y] - belt_base_element[belt_nr];
2365
2366             Feld[x][y] = belt_base_active_element[belt_nr] + belt_part;
2367           }
2368         }
2369       }
2370     }
2371   }
2372 }
2373
2374 static void ToggleBeltSwitch(int x, int y)
2375 {
2376   static int belt_base_element[4] =
2377   {
2378     EL_CONVEYOR_BELT_1_LEFT,
2379     EL_CONVEYOR_BELT_2_LEFT,
2380     EL_CONVEYOR_BELT_3_LEFT,
2381     EL_CONVEYOR_BELT_4_LEFT
2382   };
2383   static int belt_base_active_element[4] =
2384   {
2385     EL_CONVEYOR_BELT_1_LEFT_ACTIVE,
2386     EL_CONVEYOR_BELT_2_LEFT_ACTIVE,
2387     EL_CONVEYOR_BELT_3_LEFT_ACTIVE,
2388     EL_CONVEYOR_BELT_4_LEFT_ACTIVE
2389   };
2390   static int belt_base_switch_element[4] =
2391   {
2392     EL_CONVEYOR_BELT_1_SWITCH_LEFT,
2393     EL_CONVEYOR_BELT_2_SWITCH_LEFT,
2394     EL_CONVEYOR_BELT_3_SWITCH_LEFT,
2395     EL_CONVEYOR_BELT_4_SWITCH_LEFT
2396   };
2397   static int belt_move_dir[4] =
2398   {
2399     MV_LEFT,
2400     MV_NO_MOVING,
2401     MV_RIGHT,
2402     MV_NO_MOVING,
2403   };
2404
2405   int element = Feld[x][y];
2406   int belt_nr = getBeltNrFromBeltSwitchElement(element);
2407   int belt_dir_nr = (game.belt_dir_nr[belt_nr] + 1) % 4;
2408   int belt_dir = belt_move_dir[belt_dir_nr];
2409   int xx, yy, i;
2410
2411   if (!IS_BELT_SWITCH(element))
2412     return;
2413
2414   game.belt_dir_nr[belt_nr] = belt_dir_nr;
2415   game.belt_dir[belt_nr] = belt_dir;
2416
2417   if (belt_dir_nr == 3)
2418     belt_dir_nr = 1;
2419
2420   /* set frame order for belt animation graphic according to belt direction */
2421   for (i=0; i<3; i++)
2422   {
2423     int element = belt_base_active_element[belt_nr] + i;
2424     int graphic = el2img(element);
2425
2426     if (belt_dir == MV_LEFT)
2427       graphic_info[graphic].anim_mode &= ~ANIM_REVERSE;
2428     else
2429       graphic_info[graphic].anim_mode |=  ANIM_REVERSE;
2430   }
2431
2432   for (yy=0; yy<lev_fieldy; yy++)
2433   {
2434     for (xx=0; xx<lev_fieldx; xx++)
2435     {
2436       int element = Feld[xx][yy];
2437
2438       if (IS_BELT_SWITCH(element))
2439       {
2440         int e_belt_nr = getBeltNrFromBeltSwitchElement(element);
2441
2442         if (e_belt_nr == belt_nr)
2443         {
2444           Feld[xx][yy] = belt_base_switch_element[belt_nr] + belt_dir_nr;
2445           DrawLevelField(xx, yy);
2446         }
2447       }
2448       else if (IS_BELT(element) && belt_dir != MV_NO_MOVING)
2449       {
2450         int e_belt_nr = getBeltNrFromBeltElement(element);
2451
2452         if (e_belt_nr == belt_nr)
2453         {
2454           int belt_part = Feld[xx][yy] - belt_base_element[belt_nr];
2455
2456           Feld[xx][yy] = belt_base_active_element[belt_nr] + belt_part;
2457           DrawLevelField(xx, yy);
2458         }
2459       }
2460       else if (IS_BELT_ACTIVE(element) && belt_dir == MV_NO_MOVING)
2461       {
2462         int e_belt_nr = getBeltNrFromBeltActiveElement(element);
2463
2464         if (e_belt_nr == belt_nr)
2465         {
2466           int belt_part = Feld[xx][yy] - belt_base_active_element[belt_nr];
2467
2468           Feld[xx][yy] = belt_base_element[belt_nr] + belt_part;
2469           DrawLevelField(xx, yy);
2470         }
2471       }
2472     }
2473   }
2474 }
2475
2476 static void ToggleSwitchgateSwitch(int x, int y)
2477 {
2478   int xx, yy;
2479
2480   game.switchgate_pos = !game.switchgate_pos;
2481
2482   for (yy=0; yy<lev_fieldy; yy++)
2483   {
2484     for (xx=0; xx<lev_fieldx; xx++)
2485     {
2486       int element = Feld[xx][yy];
2487
2488       if (element == EL_SWITCHGATE_SWITCH_UP ||
2489           element == EL_SWITCHGATE_SWITCH_DOWN)
2490       {
2491         Feld[xx][yy] = EL_SWITCHGATE_SWITCH_UP + game.switchgate_pos;
2492         DrawLevelField(xx, yy);
2493       }
2494       else if (element == EL_SWITCHGATE_OPEN ||
2495                element == EL_SWITCHGATE_OPENING)
2496       {
2497         Feld[xx][yy] = EL_SWITCHGATE_CLOSING;
2498 #if 1
2499         PlaySoundLevelAction(xx, yy, ACTION_CLOSING);
2500 #else
2501         PlaySoundLevel(xx, yy, SND_SWITCHGATE_CLOSING);
2502 #endif
2503       }
2504       else if (element == EL_SWITCHGATE_CLOSED ||
2505                element == EL_SWITCHGATE_CLOSING)
2506       {
2507         Feld[xx][yy] = EL_SWITCHGATE_OPENING;
2508 #if 1
2509         PlaySoundLevelAction(xx, yy, ACTION_OPENING);
2510 #else
2511         PlaySoundLevel(xx, yy, SND_SWITCHGATE_OPENING);
2512 #endif
2513       }
2514     }
2515   }
2516 }
2517
2518 static int getInvisibleActiveFromInvisibleElement(int element)
2519 {
2520   return (element == EL_INVISIBLE_STEELWALL ? EL_INVISIBLE_STEELWALL_ACTIVE :
2521           element == EL_INVISIBLE_WALL      ? EL_INVISIBLE_WALL_ACTIVE :
2522           EL_INVISIBLE_SAND_ACTIVE);
2523 }
2524
2525 static int getInvisibleFromInvisibleActiveElement(int element)
2526 {
2527   return (element == EL_INVISIBLE_STEELWALL_ACTIVE ? EL_INVISIBLE_STEELWALL :
2528           element == EL_INVISIBLE_WALL_ACTIVE      ? EL_INVISIBLE_WALL :
2529           EL_INVISIBLE_SAND);
2530 }
2531
2532 static void RedrawAllLightSwitchesAndInvisibleElements()
2533 {
2534   int x, y;
2535
2536   for (y=0; y<lev_fieldy; y++)
2537   {
2538     for (x=0; x<lev_fieldx; x++)
2539     {
2540       int element = Feld[x][y];
2541
2542       if (element == EL_LIGHT_SWITCH &&
2543           game.light_time_left > 0)
2544       {
2545         Feld[x][y] = EL_LIGHT_SWITCH_ACTIVE;
2546         DrawLevelField(x, y);
2547       }
2548       else if (element == EL_LIGHT_SWITCH_ACTIVE &&
2549                game.light_time_left == 0)
2550       {
2551         Feld[x][y] = EL_LIGHT_SWITCH;
2552         DrawLevelField(x, y);
2553       }
2554       else if (element == EL_INVISIBLE_STEELWALL ||
2555                element == EL_INVISIBLE_WALL ||
2556                element == EL_INVISIBLE_SAND)
2557       {
2558         if (game.light_time_left > 0)
2559           Feld[x][y] = getInvisibleActiveFromInvisibleElement(element);
2560
2561         DrawLevelField(x, y);
2562       }
2563       else if (element == EL_INVISIBLE_STEELWALL_ACTIVE ||
2564                element == EL_INVISIBLE_WALL_ACTIVE ||
2565                element == EL_INVISIBLE_SAND_ACTIVE)
2566       {
2567         if (game.light_time_left == 0)
2568           Feld[x][y] = getInvisibleFromInvisibleActiveElement(element);
2569
2570         DrawLevelField(x, y);
2571       }
2572     }
2573   }
2574 }
2575
2576 static void ToggleLightSwitch(int x, int y)
2577 {
2578   int element = Feld[x][y];
2579
2580   game.light_time_left =
2581     (element == EL_LIGHT_SWITCH ?
2582      level.time_light * FRAMES_PER_SECOND : 0);
2583
2584   RedrawAllLightSwitchesAndInvisibleElements();
2585 }
2586
2587 static void ActivateTimegateSwitch(int x, int y)
2588 {
2589   int xx, yy;
2590
2591   game.timegate_time_left = level.time_timegate * FRAMES_PER_SECOND;
2592
2593   for (yy=0; yy<lev_fieldy; yy++)
2594   {
2595     for (xx=0; xx<lev_fieldx; xx++)
2596     {
2597       int element = Feld[xx][yy];
2598
2599       if (element == EL_TIMEGATE_CLOSED ||
2600           element == EL_TIMEGATE_CLOSING)
2601       {
2602         Feld[xx][yy] = EL_TIMEGATE_OPENING;
2603         PlaySoundLevel(xx, yy, SND_TIMEGATE_OPENING);
2604       }
2605
2606       /*
2607       else if (element == EL_TIMEGATE_SWITCH_ACTIVE)
2608       {
2609         Feld[xx][yy] = EL_TIMEGATE_SWITCH;
2610         DrawLevelField(xx, yy);
2611       }
2612       */
2613
2614     }
2615   }
2616
2617   Feld[x][y] = EL_TIMEGATE_SWITCH_ACTIVE;
2618 }
2619
2620 inline static int getElementMoveStepsize(int x, int y)
2621 {
2622   int element = Feld[x][y];
2623   int direction = MovDir[x][y];
2624   int dx = (direction == MV_LEFT ? -1 : direction == MV_RIGHT ? +1 : 0);
2625   int dy = (direction == MV_UP   ? -1 : direction == MV_DOWN  ? +1 : 0);
2626   int horiz_move = (dx != 0);
2627   int sign = (horiz_move ? dx : dy);
2628   int step = sign * element_info[element].move_stepsize;
2629
2630   /* special values for move stepsize for spring and things on conveyor belt */
2631   if (horiz_move)
2632   {
2633     if (CAN_FALL(element) &&
2634         y < lev_fieldy - 1 && IS_BELT_ACTIVE(Feld[x][y + 1]))
2635       step = sign * MOVE_STEPSIZE_NORMAL / 2;
2636     else if (element == EL_SPRING)
2637       step = sign * MOVE_STEPSIZE_NORMAL * 2;
2638   }
2639
2640   return step;
2641 }
2642
2643 void Impact(int x, int y)
2644 {
2645   boolean lastline = (y == lev_fieldy-1);
2646   boolean object_hit = FALSE;
2647   boolean impact = (lastline || object_hit);
2648   int element = Feld[x][y];
2649   int smashed = EL_UNDEFINED;
2650
2651   if (!lastline)        /* check if element below was hit */
2652   {
2653     if (Feld[x][y + 1] == EL_PLAYER_IS_LEAVING)
2654       return;
2655
2656     object_hit = (!IS_FREE(x, y + 1) && (!IS_MOVING(x, y + 1) ||
2657                                          MovDir[x][y + 1] != MV_DOWN ||
2658                                          MovPos[x][y + 1] <= TILEY / 2));
2659
2660     /* do not smash moving elements that left the smashed field in time */
2661     if (game.engine_version >= RELEASE_IDENT(2,2,0,7) && IS_MOVING(x, y + 1) &&
2662         ABS(MovPos[x][y + 1] + getElementMoveStepsize(x, y + 1)) >= TILEX)
2663       object_hit = FALSE;
2664
2665     if (object_hit)
2666       smashed = MovingOrBlocked2Element(x, y + 1);
2667
2668     impact = (lastline || object_hit);
2669   }
2670
2671   if (!lastline && smashed == EL_ACID)  /* element falls into acid */
2672   {
2673     SplashAcid(x, y);
2674     return;
2675   }
2676
2677   if (impact)
2678   {
2679     ResetGfxAnimation(x, y);
2680     DrawLevelField(x, y);
2681   }
2682
2683   if (impact && CAN_EXPLODE_IMPACT(element))
2684   {
2685     Bang(x, y);
2686     return;
2687   }
2688   else if (impact && element == EL_PEARL)
2689   {
2690     Feld[x][y] = EL_PEARL_BREAKING;
2691     PlaySoundLevel(x, y, SND_PEARL_BREAKING);
2692     return;
2693   }
2694 #if 1
2695   else if (impact && CheckElementChange(x, y, element, ACTION_IMPACT))
2696   {
2697     PlaySoundLevelElementAction(x, y, element, ACTION_IMPACT);
2698
2699     return;
2700   }
2701 #else
2702   else if (impact && CAN_CHANGE(element) &&
2703            HAS_CHANGE_EVENT(element, CE_IMPACT))
2704   {
2705     PlaySoundLevelElementAction(x, y, element, ACTION_IMPACT);
2706
2707     ChangeElementNow(x, y, element);
2708
2709     return;
2710   }
2711 #endif
2712
2713   if (impact && element == EL_AMOEBA_DROP)
2714   {
2715     if (object_hit && IS_PLAYER(x, y + 1))
2716       KillHeroUnlessProtected(x, y + 1);
2717     else if (object_hit && smashed == EL_PENGUIN)
2718       Bang(x, y + 1);
2719     else
2720     {
2721       Feld[x][y] = EL_AMOEBA_GROWING;
2722       Store[x][y] = EL_AMOEBA_WET;
2723
2724       ResetRandomAnimationValue(x, y);
2725     }
2726     return;
2727   }
2728
2729   if (object_hit)               /* check which object was hit */
2730   {
2731     if (CAN_PASS_MAGIC_WALL(element) &&
2732         (smashed == EL_MAGIC_WALL ||
2733          smashed == EL_BD_MAGIC_WALL))
2734     {
2735       int xx, yy;
2736       int activated_magic_wall =
2737         (smashed == EL_MAGIC_WALL ? EL_MAGIC_WALL_ACTIVE :
2738          EL_BD_MAGIC_WALL_ACTIVE);
2739
2740       /* activate magic wall / mill */
2741       for (yy=0; yy<lev_fieldy; yy++)
2742         for (xx=0; xx<lev_fieldx; xx++)
2743           if (Feld[xx][yy] == smashed)
2744             Feld[xx][yy] = activated_magic_wall;
2745
2746       game.magic_wall_time_left = level.time_magic_wall * FRAMES_PER_SECOND;
2747       game.magic_wall_active = TRUE;
2748
2749       PlaySoundLevel(x, y, (smashed == EL_MAGIC_WALL ?
2750                             SND_MAGIC_WALL_ACTIVATING :
2751                             SND_BD_MAGIC_WALL_ACTIVATING));
2752     }
2753
2754     if (IS_PLAYER(x, y + 1))
2755     {
2756       if (CAN_SMASH_PLAYER(element))
2757       {
2758         KillHeroUnlessProtected(x, y + 1);
2759         return;
2760       }
2761     }
2762     else if (smashed == EL_PENGUIN)
2763     {
2764       if (CAN_SMASH_PLAYER(element))
2765       {
2766         Bang(x, y + 1);
2767         return;
2768       }
2769     }
2770     else if (element == EL_BD_DIAMOND)
2771     {
2772       if (IS_CLASSIC_ENEMY(smashed) && IS_BD_ELEMENT(smashed))
2773       {
2774         Bang(x, y + 1);
2775         return;
2776       }
2777     }
2778     else if ((element == EL_SP_INFOTRON ||
2779               element == EL_SP_ZONK) &&
2780              (smashed == EL_SP_SNIKSNAK ||
2781               smashed == EL_SP_ELECTRON ||
2782               smashed == EL_SP_DISK_ORANGE))
2783     {
2784       Bang(x, y + 1);
2785       return;
2786     }
2787 #if 0
2788     else if (CAN_SMASH_ENEMIES(element) && IS_CLASSIC_ENEMY(smashed))
2789     {
2790       Bang(x, y + 1);
2791       return;
2792     }
2793 #endif
2794     else if (CAN_SMASH_EVERYTHING(element))
2795     {
2796       if (IS_CLASSIC_ENEMY(smashed) ||
2797           CAN_EXPLODE_SMASHED(smashed))
2798       {
2799         Bang(x, y + 1);
2800         return;
2801       }
2802       else if (!IS_MOVING(x, y + 1) && !IS_BLOCKED(x, y + 1))
2803       {
2804         if (smashed == EL_LAMP ||
2805             smashed == EL_LAMP_ACTIVE)
2806         {
2807           Bang(x, y + 1);
2808           return;
2809         }
2810         else if (smashed == EL_NUT)
2811         {
2812           Feld[x][y + 1] = EL_NUT_BREAKING;
2813           PlaySoundLevel(x, y, SND_NUT_BREAKING);
2814           RaiseScoreElement(EL_NUT);
2815           return;
2816         }
2817         else if (smashed == EL_PEARL)
2818         {
2819           Feld[x][y + 1] = EL_PEARL_BREAKING;
2820           PlaySoundLevel(x, y, SND_PEARL_BREAKING);
2821           return;
2822         }
2823         else if (smashed == EL_DIAMOND)
2824         {
2825           Feld[x][y + 1] = EL_DIAMOND_BREAKING;
2826           PlaySoundLevel(x, y, SND_DIAMOND_BREAKING);
2827           return;
2828         }
2829         else if (IS_BELT_SWITCH(smashed))
2830         {
2831           ToggleBeltSwitch(x, y + 1);
2832         }
2833         else if (smashed == EL_SWITCHGATE_SWITCH_UP ||
2834                  smashed == EL_SWITCHGATE_SWITCH_DOWN)
2835         {
2836           ToggleSwitchgateSwitch(x, y + 1);
2837         }
2838         else if (smashed == EL_LIGHT_SWITCH ||
2839                  smashed == EL_LIGHT_SWITCH_ACTIVE)
2840         {
2841           ToggleLightSwitch(x, y + 1);
2842         }
2843 #if 1
2844         else
2845         {
2846           CheckElementChange(x, y + 1, smashed, CE_SMASHED);
2847         }
2848 #else
2849         else if (CAN_CHANGE(smashed) && HAS_CHANGE_EVENT(smashed, CE_SMASHED))
2850         {
2851           ChangeElementNow(x, y + 1, smashed);
2852         }
2853 #endif
2854       }
2855       else
2856       {
2857         CheckElementChange(x, y + 1, smashed, CE_SMASHED);
2858       }
2859     }
2860   }
2861
2862   /* play sound of magic wall / mill */
2863   if (!lastline &&
2864       (Feld[x][y + 1] == EL_MAGIC_WALL_ACTIVE ||
2865        Feld[x][y + 1] == EL_BD_MAGIC_WALL_ACTIVE))
2866   {
2867     if (Feld[x][y + 1] == EL_MAGIC_WALL_ACTIVE)
2868       PlaySoundLevel(x, y, SND_MAGIC_WALL_FILLING);
2869     else if (Feld[x][y + 1] == EL_BD_MAGIC_WALL_ACTIVE)
2870       PlaySoundLevel(x, y, SND_BD_MAGIC_WALL_FILLING);
2871
2872     return;
2873   }
2874
2875   /* play sound of object that hits the ground */
2876   if (lastline || object_hit)
2877     PlaySoundLevelElementAction(x, y, element, ACTION_IMPACT);
2878 }
2879
2880 void TurnRound(int x, int y)
2881 {
2882   static struct
2883   {
2884     int x, y;
2885   } move_xy[] =
2886   {
2887     {  0,  0 },
2888     { -1,  0 },
2889     { +1,  0 },
2890     {  0,  0 },
2891     {  0, -1 },
2892     {  0,  0 }, { 0, 0 }, { 0, 0 },
2893     {  0, +1 }
2894   };
2895   static struct
2896   {
2897     int left, right, back;
2898   } turn[] =
2899   {
2900     { 0,        0,              0        },
2901     { MV_DOWN,  MV_UP,          MV_RIGHT },
2902     { MV_UP,    MV_DOWN,        MV_LEFT  },
2903     { 0,        0,              0        },
2904     { MV_LEFT,  MV_RIGHT,       MV_DOWN  },
2905     { 0,        0,              0        },
2906     { 0,        0,              0        },
2907     { 0,        0,              0        },
2908     { MV_RIGHT, MV_LEFT,        MV_UP    }
2909   };
2910
2911   int element = Feld[x][y];
2912   int old_move_dir = MovDir[x][y];
2913   int left_dir  = turn[old_move_dir].left;
2914   int right_dir = turn[old_move_dir].right;
2915   int back_dir  = turn[old_move_dir].back;
2916
2917   int left_dx  = move_xy[left_dir].x,     left_dy  = move_xy[left_dir].y;
2918   int right_dx = move_xy[right_dir].x,    right_dy = move_xy[right_dir].y;
2919   int move_dx  = move_xy[old_move_dir].x, move_dy  = move_xy[old_move_dir].y;
2920   int back_dx  = move_xy[back_dir].x,     back_dy  = move_xy[back_dir].y;
2921
2922   int left_x  = x + left_dx,  left_y  = y + left_dy;
2923   int right_x = x + right_dx, right_y = y + right_dy;
2924   int move_x  = x + move_dx,  move_y  = y + move_dy;
2925
2926   int xx, yy;
2927
2928   if (element == EL_BUG || element == EL_BD_BUTTERFLY)
2929   {
2930     TestIfBadThingTouchesOtherBadThing(x, y);
2931
2932     if (ENEMY_CAN_ENTER_FIELD(right_x, right_y))
2933       MovDir[x][y] = right_dir;
2934     else if (!ENEMY_CAN_ENTER_FIELD(move_x, move_y))
2935       MovDir[x][y] = left_dir;
2936
2937     if (element == EL_BUG && MovDir[x][y] != old_move_dir)
2938       MovDelay[x][y] = 9;
2939     else if (element == EL_BD_BUTTERFLY)     /* && MovDir[x][y] == left_dir) */
2940       MovDelay[x][y] = 1;
2941   }
2942   else if (element == EL_SPACESHIP || element == EL_BD_FIREFLY ||
2943            element == EL_SP_SNIKSNAK || element == EL_SP_ELECTRON)
2944   {
2945     TestIfBadThingTouchesOtherBadThing(x, y);
2946
2947     if (ENEMY_CAN_ENTER_FIELD(left_x, left_y))
2948       MovDir[x][y] = left_dir;
2949     else if (!ENEMY_CAN_ENTER_FIELD(move_x, move_y))
2950       MovDir[x][y] = right_dir;
2951
2952     if ((element == EL_SPACESHIP ||
2953          element == EL_SP_SNIKSNAK ||
2954          element == EL_SP_ELECTRON)
2955         && MovDir[x][y] != old_move_dir)
2956       MovDelay[x][y] = 9;
2957     else if (element == EL_BD_FIREFLY)      /* && MovDir[x][y] == right_dir) */
2958       MovDelay[x][y] = 1;
2959   }
2960   else if (element == EL_YAMYAM)
2961   {
2962     boolean can_turn_left  = YAMYAM_CAN_ENTER_FIELD(left_x, left_y);
2963     boolean can_turn_right = YAMYAM_CAN_ENTER_FIELD(right_x, right_y);
2964
2965     if (can_turn_left && can_turn_right)
2966       MovDir[x][y] = (RND(3) ? (RND(2) ? left_dir : right_dir) : back_dir);
2967     else if (can_turn_left)
2968       MovDir[x][y] = (RND(2) ? left_dir : back_dir);
2969     else if (can_turn_right)
2970       MovDir[x][y] = (RND(2) ? right_dir : back_dir);
2971     else
2972       MovDir[x][y] = back_dir;
2973
2974     MovDelay[x][y] = 16 + 16 * RND(3);
2975   }
2976   else if (element == EL_DARK_YAMYAM)
2977   {
2978     boolean can_turn_left  = DARK_YAMYAM_CAN_ENTER_FIELD(left_x, left_y);
2979     boolean can_turn_right = DARK_YAMYAM_CAN_ENTER_FIELD(right_x, right_y);
2980
2981     if (can_turn_left && can_turn_right)
2982       MovDir[x][y] = (RND(3) ? (RND(2) ? left_dir : right_dir) : back_dir);
2983     else if (can_turn_left)
2984       MovDir[x][y] = (RND(2) ? left_dir : back_dir);
2985     else if (can_turn_right)
2986       MovDir[x][y] = (RND(2) ? right_dir : back_dir);
2987     else
2988       MovDir[x][y] = back_dir;
2989
2990     MovDelay[x][y] = 16 + 16 * RND(3);
2991   }
2992   else if (element == EL_PACMAN)
2993   {
2994     boolean can_turn_left  = PACMAN_CAN_ENTER_FIELD(left_x, left_y);
2995     boolean can_turn_right = PACMAN_CAN_ENTER_FIELD(right_x, right_y);
2996
2997     if (can_turn_left && can_turn_right)
2998       MovDir[x][y] = (RND(3) ? (RND(2) ? left_dir : right_dir) : back_dir);
2999     else if (can_turn_left)
3000       MovDir[x][y] = (RND(2) ? left_dir : back_dir);
3001     else if (can_turn_right)
3002       MovDir[x][y] = (RND(2) ? right_dir : back_dir);
3003     else
3004       MovDir[x][y] = back_dir;
3005
3006     MovDelay[x][y] = 6 + RND(40);
3007   }
3008   else if (element == EL_PIG)
3009   {
3010     boolean can_turn_left  = PIG_CAN_ENTER_FIELD(left_x, left_y);
3011     boolean can_turn_right = PIG_CAN_ENTER_FIELD(right_x, right_y);
3012     boolean can_move_on    = PIG_CAN_ENTER_FIELD(move_x, move_y);
3013     boolean should_turn_left, should_turn_right, should_move_on;
3014     int rnd_value = 24;
3015     int rnd = RND(rnd_value);
3016
3017     should_turn_left = (can_turn_left &&
3018                         (!can_move_on ||
3019                          IN_LEV_FIELD_AND_NOT_FREE(x + back_dx + left_dx,
3020                                                    y + back_dy + left_dy)));
3021     should_turn_right = (can_turn_right &&
3022                          (!can_move_on ||
3023                           IN_LEV_FIELD_AND_NOT_FREE(x + back_dx + right_dx,
3024                                                     y + back_dy + right_dy)));
3025     should_move_on = (can_move_on &&
3026                       (!can_turn_left ||
3027                        !can_turn_right ||
3028                        IN_LEV_FIELD_AND_NOT_FREE(x + move_dx + left_dx,
3029                                                  y + move_dy + left_dy) ||
3030                        IN_LEV_FIELD_AND_NOT_FREE(x + move_dx + right_dx,
3031                                                  y + move_dy + right_dy)));
3032
3033     if (should_turn_left || should_turn_right || should_move_on)
3034     {
3035       if (should_turn_left && should_turn_right && should_move_on)
3036         MovDir[x][y] = (rnd < rnd_value / 3     ? left_dir :
3037                         rnd < 2 * rnd_value / 3 ? right_dir :
3038                         old_move_dir);
3039       else if (should_turn_left && should_turn_right)
3040         MovDir[x][y] = (rnd < rnd_value / 2 ? left_dir : right_dir);
3041       else if (should_turn_left && should_move_on)
3042         MovDir[x][y] = (rnd < rnd_value / 2 ? left_dir : old_move_dir);
3043       else if (should_turn_right && should_move_on)
3044         MovDir[x][y] = (rnd < rnd_value / 2 ? right_dir : old_move_dir);
3045       else if (should_turn_left)
3046         MovDir[x][y] = left_dir;
3047       else if (should_turn_right)
3048         MovDir[x][y] = right_dir;
3049       else if (should_move_on)
3050         MovDir[x][y] = old_move_dir;
3051     }
3052     else if (can_move_on && rnd > rnd_value / 8)
3053       MovDir[x][y] = old_move_dir;
3054     else if (can_turn_left && can_turn_right)
3055       MovDir[x][y] = (rnd < rnd_value / 2 ? left_dir : right_dir);
3056     else if (can_turn_left && rnd > rnd_value / 8)
3057       MovDir[x][y] = left_dir;
3058     else if (can_turn_right && rnd > rnd_value/8)
3059       MovDir[x][y] = right_dir;
3060     else
3061       MovDir[x][y] = back_dir;
3062
3063     xx = x + move_xy[MovDir[x][y]].x;
3064     yy = y + move_xy[MovDir[x][y]].y;
3065
3066     if (!IS_FREE(xx, yy) && !IS_FOOD_PIG(Feld[xx][yy]))
3067       MovDir[x][y] = old_move_dir;
3068
3069     MovDelay[x][y] = 0;
3070   }
3071   else if (element == EL_DRAGON)
3072   {
3073     boolean can_turn_left  = IN_LEV_FIELD_AND_IS_FREE(left_x, left_y);
3074     boolean can_turn_right = IN_LEV_FIELD_AND_IS_FREE(right_x, right_y);
3075     boolean can_move_on    = IN_LEV_FIELD_AND_IS_FREE(move_x, move_y);
3076     int rnd_value = 24;
3077     int rnd = RND(rnd_value);
3078
3079     if (can_move_on && rnd > rnd_value / 8)
3080       MovDir[x][y] = old_move_dir;
3081     else if (can_turn_left && can_turn_right)
3082       MovDir[x][y] = (rnd < rnd_value / 2 ? left_dir : right_dir);
3083     else if (can_turn_left && rnd > rnd_value / 8)
3084       MovDir[x][y] = left_dir;
3085     else if (can_turn_right && rnd > rnd_value / 8)
3086       MovDir[x][y] = right_dir;
3087     else
3088       MovDir[x][y] = back_dir;
3089
3090     xx = x + move_xy[MovDir[x][y]].x;
3091     yy = y + move_xy[MovDir[x][y]].y;
3092
3093     if (!IS_FREE(xx, yy))
3094       MovDir[x][y] = old_move_dir;
3095
3096     MovDelay[x][y] = 0;
3097   }
3098   else if (element == EL_MOLE)
3099   {
3100     boolean can_move_on =
3101       (MOLE_CAN_ENTER_FIELD(move_x, move_y,
3102                             IS_AMOEBOID(Feld[move_x][move_y]) ||
3103                             Feld[move_x][move_y] == EL_AMOEBA_SHRINKING));
3104     if (!can_move_on)
3105     {
3106       boolean can_turn_left =
3107         (MOLE_CAN_ENTER_FIELD(left_x, left_y,
3108                               IS_AMOEBOID(Feld[left_x][left_y])));
3109
3110       boolean can_turn_right =
3111         (MOLE_CAN_ENTER_FIELD(right_x, right_y,
3112                               IS_AMOEBOID(Feld[right_x][right_y])));
3113
3114       if (can_turn_left && can_turn_right)
3115         MovDir[x][y] = (RND(2) ? left_dir : right_dir);
3116       else if (can_turn_left)
3117         MovDir[x][y] = left_dir;
3118       else
3119         MovDir[x][y] = right_dir;
3120     }
3121
3122     if (MovDir[x][y] != old_move_dir)
3123       MovDelay[x][y] = 9;
3124   }
3125   else if (element == EL_BALLOON)
3126   {
3127     MovDir[x][y] = game.balloon_dir;
3128     MovDelay[x][y] = 0;
3129   }
3130   else if (element == EL_SPRING)
3131   {
3132     if (MovDir[x][y] & MV_HORIZONTAL &&
3133         (!IN_LEV_FIELD_AND_IS_FREE(move_x, move_y) ||
3134          IN_LEV_FIELD_AND_IS_FREE(x, y + 1)))
3135       MovDir[x][y] = MV_NO_MOVING;
3136
3137     MovDelay[x][y] = 0;
3138   }
3139   else if (element == EL_ROBOT ||
3140            element == EL_SATELLITE ||
3141            element == EL_PENGUIN)
3142   {
3143     int attr_x = -1, attr_y = -1;
3144
3145     if (AllPlayersGone)
3146     {
3147       attr_x = ExitX;
3148       attr_y = ExitY;
3149     }
3150     else
3151     {
3152       int i;
3153
3154       for (i=0; i<MAX_PLAYERS; i++)
3155       {
3156         struct PlayerInfo *player = &stored_player[i];
3157         int jx = player->jx, jy = player->jy;
3158
3159         if (!player->active)
3160           continue;
3161
3162         if (attr_x == -1 ||
3163             ABS(jx - x) + ABS(jy - y) < ABS(attr_x - x) + ABS(attr_y - y))
3164         {
3165           attr_x = jx;
3166           attr_y = jy;
3167         }
3168       }
3169     }
3170
3171     if (element == EL_ROBOT && ZX >= 0 && ZY >= 0)
3172     {
3173       attr_x = ZX;
3174       attr_y = ZY;
3175     }
3176
3177     if (element == EL_PENGUIN)
3178     {
3179       int i;
3180       static int xy[4][2] =
3181       {
3182         { 0, -1 },
3183         { -1, 0 },
3184         { +1, 0 },
3185         { 0, +1 }
3186       };
3187
3188       for (i=0; i<4; i++)
3189       {
3190         int ex = x + xy[i % 4][0];
3191         int ey = y + xy[i % 4][1];
3192
3193         if (IN_LEV_FIELD(ex, ey) && Feld[ex][ey] == EL_EXIT_OPEN)
3194         {
3195           attr_x = ex;
3196           attr_y = ey;
3197           break;
3198         }
3199       }
3200     }
3201
3202     MovDir[x][y] = MV_NO_MOVING;
3203     if (attr_x < x)
3204       MovDir[x][y] |= (AllPlayersGone ? MV_RIGHT : MV_LEFT);
3205     else if (attr_x > x)
3206       MovDir[x][y] |= (AllPlayersGone ? MV_LEFT : MV_RIGHT);
3207     if (attr_y < y)
3208       MovDir[x][y] |= (AllPlayersGone ? MV_DOWN : MV_UP);
3209     else if (attr_y > y)
3210       MovDir[x][y] |= (AllPlayersGone ? MV_UP : MV_DOWN);
3211
3212     if (element == EL_ROBOT)
3213     {
3214       int newx, newy;
3215
3216       if (MovDir[x][y] & MV_HORIZONTAL && MovDir[x][y] & MV_VERTICAL)
3217         MovDir[x][y] &= (RND(2) ? MV_HORIZONTAL : MV_VERTICAL);
3218       Moving2Blocked(x, y, &newx, &newy);
3219
3220       if (IN_LEV_FIELD(newx, newy) && IS_FREE_OR_PLAYER(newx, newy))
3221         MovDelay[x][y] = 8 + 8 * !RND(3);
3222       else
3223         MovDelay[x][y] = 16;
3224     }
3225     else if (element == EL_PENGUIN)
3226     {
3227       int newx, newy;
3228
3229       MovDelay[x][y] = 1;
3230
3231       if (MovDir[x][y] & MV_HORIZONTAL && MovDir[x][y] & MV_VERTICAL)
3232       {
3233         boolean first_horiz = RND(2);
3234         int new_move_dir = MovDir[x][y];
3235
3236         MovDir[x][y] =
3237           new_move_dir & (first_horiz ? MV_HORIZONTAL : MV_VERTICAL);
3238         Moving2Blocked(x, y, &newx, &newy);
3239
3240         if (PENGUIN_CAN_ENTER_FIELD(newx, newy))
3241           return;
3242
3243         MovDir[x][y] =
3244           new_move_dir & (!first_horiz ? MV_HORIZONTAL : MV_VERTICAL);
3245         Moving2Blocked(x, y, &newx, &newy);
3246
3247         if (PENGUIN_CAN_ENTER_FIELD(newx, newy))
3248           return;
3249
3250         MovDir[x][y] = old_move_dir;
3251         return;
3252       }
3253     }
3254     else        /* (element == EL_SATELLITE) */
3255     {
3256       int newx, newy;
3257
3258       MovDelay[x][y] = 1;
3259
3260       if (MovDir[x][y] & MV_HORIZONTAL && MovDir[x][y] & MV_VERTICAL)
3261       {
3262         boolean first_horiz = RND(2);
3263         int new_move_dir = MovDir[x][y];
3264
3265         MovDir[x][y] =
3266           new_move_dir & (first_horiz ? MV_HORIZONTAL : MV_VERTICAL);
3267         Moving2Blocked(x, y, &newx, &newy);
3268
3269         if (ELEMENT_CAN_ENTER_FIELD_OR_ACID_2(newx, newy))
3270           return;
3271
3272         MovDir[x][y] =
3273           new_move_dir & (!first_horiz ? MV_HORIZONTAL : MV_VERTICAL);
3274         Moving2Blocked(x, y, &newx, &newy);
3275
3276         if (ELEMENT_CAN_ENTER_FIELD_OR_ACID_2(newx, newy))
3277           return;
3278
3279         MovDir[x][y] = old_move_dir;
3280         return;
3281       }
3282     }
3283   }
3284   else if (element_info[element].move_pattern == MV_ALL_DIRECTIONS ||
3285            element_info[element].move_pattern == MV_TURNING_LEFT ||
3286            element_info[element].move_pattern == MV_TURNING_RIGHT)
3287   {
3288     boolean can_turn_left  = ELEMENT_CAN_ENTER_FIELD(element, left_x, left_y);
3289     boolean can_turn_right = ELEMENT_CAN_ENTER_FIELD(element, right_x,right_y);
3290
3291     if (element_info[element].move_pattern == MV_TURNING_LEFT)
3292       MovDir[x][y] = left_dir;
3293     else if (element_info[element].move_pattern == MV_TURNING_RIGHT)
3294       MovDir[x][y] = right_dir;
3295     else if (can_turn_left && can_turn_right)
3296       MovDir[x][y] = (RND(3) ? (RND(2) ? left_dir : right_dir) : back_dir);
3297     else if (can_turn_left)
3298       MovDir[x][y] = (RND(2) ? left_dir : back_dir);
3299     else if (can_turn_right)
3300       MovDir[x][y] = (RND(2) ? right_dir : back_dir);
3301     else
3302       MovDir[x][y] = back_dir;
3303
3304     MovDelay[x][y] = GET_NEW_MOVE_DELAY(element);
3305   }
3306   else if (element_info[element].move_pattern == MV_HORIZONTAL ||
3307            element_info[element].move_pattern == MV_VERTICAL)
3308   {
3309     if (element_info[element].move_pattern & old_move_dir)
3310       MovDir[x][y] = back_dir;
3311     else if (element_info[element].move_pattern == MV_HORIZONTAL)
3312       MovDir[x][y] = (RND(2) ? MV_LEFT : MV_RIGHT);
3313     else if (element_info[element].move_pattern == MV_VERTICAL)
3314       MovDir[x][y] = (RND(2) ? MV_UP : MV_DOWN);
3315
3316     MovDelay[x][y] = GET_NEW_MOVE_DELAY(element);
3317   }
3318   else if (element_info[element].move_pattern & MV_ANY_DIRECTION)
3319   {
3320     MovDir[x][y] = element_info[element].move_pattern;
3321     MovDelay[x][y] = GET_NEW_MOVE_DELAY(element);
3322   }
3323   else if (element_info[element].move_pattern == MV_ALONG_LEFT_SIDE)
3324   {
3325     if (ELEMENT_CAN_ENTER_FIELD(element, left_x, left_y))
3326       MovDir[x][y] = left_dir;
3327     else if (!ELEMENT_CAN_ENTER_FIELD(element, move_x, move_y))
3328       MovDir[x][y] = right_dir;
3329
3330     if (MovDir[x][y] != old_move_dir)
3331       MovDelay[x][y] = GET_NEW_MOVE_DELAY(element);
3332   }
3333   else if (element_info[element].move_pattern == MV_ALONG_RIGHT_SIDE)
3334   {
3335     if (ELEMENT_CAN_ENTER_FIELD(element, right_x, right_y))
3336       MovDir[x][y] = right_dir;
3337     else if (!ELEMENT_CAN_ENTER_FIELD(element, move_x, move_y))
3338       MovDir[x][y] = left_dir;
3339
3340     if (MovDir[x][y] != old_move_dir)
3341       MovDelay[x][y] = GET_NEW_MOVE_DELAY(element);
3342   }
3343   else if (element_info[element].move_pattern == MV_TOWARDS_PLAYER ||
3344            element_info[element].move_pattern == MV_AWAY_FROM_PLAYER)
3345   {
3346     int attr_x = -1, attr_y = -1;
3347     int newx, newy;
3348     boolean move_away =
3349       (element_info[element].move_pattern == MV_AWAY_FROM_PLAYER);
3350
3351     if (AllPlayersGone)
3352     {
3353       attr_x = ExitX;
3354       attr_y = ExitY;
3355     }
3356     else
3357     {
3358       int i;
3359
3360       for (i=0; i<MAX_PLAYERS; i++)
3361       {
3362         struct PlayerInfo *player = &stored_player[i];
3363         int jx = player->jx, jy = player->jy;
3364
3365         if (!player->active)
3366           continue;
3367
3368         if (attr_x == -1 ||
3369             ABS(jx - x) + ABS(jy - y) < ABS(attr_x - x) + ABS(attr_y - y))
3370         {
3371           attr_x = jx;
3372           attr_y = jy;
3373         }
3374       }
3375     }
3376
3377     MovDir[x][y] = MV_NO_MOVING;
3378     if (attr_x < x)
3379       MovDir[x][y] |= (move_away ? MV_RIGHT : MV_LEFT);
3380     else if (attr_x > x)
3381       MovDir[x][y] |= (move_away ? MV_LEFT : MV_RIGHT);
3382     if (attr_y < y)
3383       MovDir[x][y] |= (move_away ? MV_DOWN : MV_UP);
3384     else if (attr_y > y)
3385       MovDir[x][y] |= (move_away ? MV_UP : MV_DOWN);
3386
3387     MovDelay[x][y] = GET_NEW_MOVE_DELAY(element);
3388
3389     if (MovDir[x][y] & MV_HORIZONTAL && MovDir[x][y] & MV_VERTICAL)
3390     {
3391       boolean first_horiz = RND(2);
3392       int new_move_dir = MovDir[x][y];
3393
3394       MovDir[x][y] =
3395         new_move_dir & (first_horiz ? MV_HORIZONTAL : MV_VERTICAL);
3396       Moving2Blocked(x, y, &newx, &newy);
3397
3398       if (ELEMENT_CAN_ENTER_FIELD_OR_ACID(element, newx, newy))
3399         return;
3400
3401       MovDir[x][y] =
3402         new_move_dir & (!first_horiz ? MV_HORIZONTAL : MV_VERTICAL);
3403       Moving2Blocked(x, y, &newx, &newy);
3404
3405       if (ELEMENT_CAN_ENTER_FIELD_OR_ACID(element, newx, newy))
3406         return;
3407
3408       MovDir[x][y] = old_move_dir;
3409     }
3410   }
3411 }
3412
3413 static boolean JustBeingPushed(int x, int y)
3414 {
3415   int i;
3416
3417   for (i=0; i<MAX_PLAYERS; i++)
3418   {
3419     struct PlayerInfo *player = &stored_player[i];
3420
3421     if (player->active && player->Pushing && player->MovPos)
3422     {
3423       int next_jx = player->jx + (player->jx - player->last_jx);
3424       int next_jy = player->jy + (player->jy - player->last_jy);
3425
3426       if (x == next_jx && y == next_jy)
3427         return TRUE;
3428     }
3429   }
3430
3431   return FALSE;
3432 }
3433
3434 void StartMoving(int x, int y)
3435 {
3436   boolean use_spring_bug = (game.engine_version < VERSION_IDENT(2,2,0));
3437   boolean started_moving = FALSE;       /* some elements can fall _and_ move */
3438   int element = Feld[x][y];
3439
3440   if (Stop[x][y])
3441     return;
3442
3443   /* !!! this should be handled more generic (not only for more) !!! */
3444   if (element != EL_MOLE && GfxAction[x][y] != ACTION_DIGGING)
3445     GfxAction[x][y] = ACTION_DEFAULT;
3446
3447   if (CAN_FALL(element) && y < lev_fieldy - 1)
3448   {
3449     if ((x>0 && IS_PLAYER(x-1, y)) || (x<lev_fieldx-1 && IS_PLAYER(x+1, y)))
3450       if (JustBeingPushed(x, y))
3451         return;
3452
3453     if (element == EL_QUICKSAND_FULL)
3454     {
3455       if (IS_FREE(x, y + 1))
3456       {
3457         InitMovingField(x, y, MV_DOWN);
3458         started_moving = TRUE;
3459
3460         Feld[x][y] = EL_QUICKSAND_EMPTYING;
3461         Store[x][y] = EL_ROCK;
3462 #if 1
3463         PlaySoundLevelAction(x, y, ACTION_EMPTYING);
3464 #else
3465         PlaySoundLevel(x, y, SND_QUICKSAND_EMPTYING);
3466 #endif
3467       }
3468       else if (Feld[x][y + 1] == EL_QUICKSAND_EMPTY)
3469       {
3470         if (!MovDelay[x][y])
3471           MovDelay[x][y] = TILEY + 1;
3472
3473         if (MovDelay[x][y])
3474         {
3475           MovDelay[x][y]--;
3476           if (MovDelay[x][y])
3477             return;
3478         }
3479
3480         Feld[x][y] = EL_QUICKSAND_EMPTY;
3481         Feld[x][y + 1] = EL_QUICKSAND_FULL;
3482         Store[x][y + 1] = Store[x][y];
3483         Store[x][y] = 0;
3484 #if 1
3485         PlaySoundLevelAction(x, y, ACTION_FILLING);
3486 #else
3487         PlaySoundLevel(x, y, SND_QUICKSAND_FILLING);
3488 #endif
3489       }
3490     }
3491     else if ((element == EL_ROCK || element == EL_BD_ROCK) &&
3492              Feld[x][y + 1] == EL_QUICKSAND_EMPTY)
3493     {
3494       InitMovingField(x, y, MV_DOWN);
3495       started_moving = TRUE;
3496
3497       Feld[x][y] = EL_QUICKSAND_FILLING;
3498       Store[x][y] = element;
3499 #if 1
3500       PlaySoundLevelAction(x, y, ACTION_FILLING);
3501 #else
3502       PlaySoundLevel(x, y, SND_QUICKSAND_FILLING);
3503 #endif
3504     }
3505     else if (element == EL_MAGIC_WALL_FULL)
3506     {
3507       if (IS_FREE(x, y + 1))
3508       {
3509         InitMovingField(x, y, MV_DOWN);
3510         started_moving = TRUE;
3511
3512         Feld[x][y] = EL_MAGIC_WALL_EMPTYING;
3513         Store[x][y] = EL_CHANGED(Store[x][y]);
3514       }
3515       else if (Feld[x][y + 1] == EL_MAGIC_WALL_ACTIVE)
3516       {
3517         if (!MovDelay[x][y])
3518           MovDelay[x][y] = TILEY/4 + 1;
3519
3520         if (MovDelay[x][y])
3521         {
3522           MovDelay[x][y]--;
3523           if (MovDelay[x][y])
3524             return;
3525         }
3526
3527         Feld[x][y] = EL_MAGIC_WALL_ACTIVE;
3528         Feld[x][y + 1] = EL_MAGIC_WALL_FULL;
3529         Store[x][y + 1] = EL_CHANGED(Store[x][y]);
3530         Store[x][y] = 0;
3531       }
3532     }
3533     else if (element == EL_BD_MAGIC_WALL_FULL)
3534     {
3535       if (IS_FREE(x, y + 1))
3536       {
3537         InitMovingField(x, y, MV_DOWN);
3538         started_moving = TRUE;
3539
3540         Feld[x][y] = EL_BD_MAGIC_WALL_EMPTYING;
3541         Store[x][y] = EL_CHANGED2(Store[x][y]);
3542       }
3543       else if (Feld[x][y + 1] == EL_BD_MAGIC_WALL_ACTIVE)
3544       {
3545         if (!MovDelay[x][y])
3546           MovDelay[x][y] = TILEY/4 + 1;
3547
3548         if (MovDelay[x][y])
3549         {
3550           MovDelay[x][y]--;
3551           if (MovDelay[x][y])
3552             return;
3553         }
3554
3555         Feld[x][y] = EL_BD_MAGIC_WALL_ACTIVE;
3556         Feld[x][y + 1] = EL_BD_MAGIC_WALL_FULL;
3557         Store[x][y + 1] = EL_CHANGED2(Store[x][y]);
3558         Store[x][y] = 0;
3559       }
3560     }
3561     else if (CAN_PASS_MAGIC_WALL(element) &&
3562              (Feld[x][y + 1] == EL_MAGIC_WALL_ACTIVE ||
3563               Feld[x][y + 1] == EL_BD_MAGIC_WALL_ACTIVE))
3564     {
3565       InitMovingField(x, y, MV_DOWN);
3566       started_moving = TRUE;
3567
3568       Feld[x][y] =
3569         (Feld[x][y + 1] == EL_MAGIC_WALL_ACTIVE ? EL_MAGIC_WALL_FILLING :
3570          EL_BD_MAGIC_WALL_FILLING);
3571       Store[x][y] = element;
3572     }
3573 #if 0
3574     else if (CAN_SMASH(element) && Feld[x][y + 1] == EL_ACID)
3575 #else
3576     else if (CAN_FALL(element) && Feld[x][y + 1] == EL_ACID)
3577 #endif
3578     {
3579       SplashAcid(x, y);
3580
3581       InitMovingField(x, y, MV_DOWN);
3582       started_moving = TRUE;
3583
3584       Store[x][y] = EL_ACID;
3585 #if 0
3586       /* !!! TEST !!! better use "_FALLING" etc. !!! */
3587       GfxAction[x][y + 1] = ACTION_ACTIVE;
3588 #endif
3589     }
3590 #if 1
3591 #if 1
3592     else if (game.engine_version < RELEASE_IDENT(2,2,0,7) &&
3593              CAN_SMASH(element) && Feld[x][y + 1] == EL_BLOCKED &&
3594              JustStopped[x][y] && !Pushed[x][y + 1])
3595 #else
3596     else if (CAN_SMASH(element) && Feld[x][y + 1] == EL_BLOCKED &&
3597              JustStopped[x][y])
3598 #endif
3599     {
3600       /* calling "Impact()" here is not only completely unneccessary
3601          (because it already gets called from "ContinueMoving()" in
3602          all relevant situations), but also completely bullshit, because
3603          "JustStopped" also indicates a finished *horizontal* movement;
3604          we must keep this trash for backwards compatibility with older
3605          tapes */
3606
3607       Impact(x, y);
3608     }
3609 #endif
3610     else if (IS_FREE(x, y + 1) && element == EL_SPRING && use_spring_bug)
3611     {
3612       if (MovDir[x][y] == MV_NO_MOVING)
3613       {
3614         InitMovingField(x, y, MV_DOWN);
3615         started_moving = TRUE;
3616       }
3617     }
3618     else if (IS_FREE(x, y + 1) || Feld[x][y + 1] == EL_DIAMOND_BREAKING)
3619     {
3620       if (JustStopped[x][y])    /* prevent animation from being restarted */
3621         MovDir[x][y] = MV_DOWN;
3622
3623       InitMovingField(x, y, MV_DOWN);
3624       started_moving = TRUE;
3625     }
3626     else if (element == EL_AMOEBA_DROP)
3627     {
3628       Feld[x][y] = EL_AMOEBA_GROWING;
3629       Store[x][y] = EL_AMOEBA_WET;
3630     }
3631     /* Store[x][y + 1] must be zero, because:
3632        (EL_QUICKSAND_FULL -> EL_ROCK): Store[x][y + 1] == EL_QUICKSAND_EMPTY
3633     */
3634 #if 0
3635 #if OLD_GAME_BEHAVIOUR
3636     else if (IS_SLIPPERY(Feld[x][y + 1]) && !Store[x][y + 1])
3637 #else
3638     else if (IS_SLIPPERY(Feld[x][y + 1]) && !Store[x][y + 1] &&
3639              !IS_FALLING(x, y + 1) && !JustStopped[x][y + 1] &&
3640              element != EL_DX_SUPABOMB)
3641 #endif
3642 #else
3643     else if (((IS_SLIPPERY(Feld[x][y + 1]) && !IS_PLAYER(x, y + 1)) ||
3644               (IS_EM_SLIPPERY_WALL(Feld[x][y + 1]) && IS_GEM(element))) &&
3645              !IS_FALLING(x, y + 1) && !JustStopped[x][y + 1] &&
3646              element != EL_DX_SUPABOMB && element != EL_SP_DISK_ORANGE)
3647 #endif
3648     {
3649       boolean can_fall_left  = (x > 0 && IS_FREE(x - 1, y) &&
3650                                 (IS_FREE(x - 1, y + 1) ||
3651                                  Feld[x - 1][y + 1] == EL_ACID));
3652       boolean can_fall_right = (x < lev_fieldx - 1 && IS_FREE(x + 1, y) &&
3653                                 (IS_FREE(x + 1, y + 1) ||
3654                                  Feld[x + 1][y + 1] == EL_ACID));
3655       boolean can_fall_any  = (can_fall_left || can_fall_right);
3656       boolean can_fall_both = (can_fall_left && can_fall_right);
3657
3658       if (can_fall_any && IS_CUSTOM_ELEMENT(Feld[x][y + 1]))
3659       {
3660         int slippery_type = element_info[Feld[x][y + 1]].slippery_type;
3661
3662         if (slippery_type == SLIPPERY_ONLY_LEFT)
3663           can_fall_right = FALSE;
3664         else if (slippery_type == SLIPPERY_ONLY_RIGHT)
3665           can_fall_left = FALSE;
3666         else if (slippery_type == SLIPPERY_ANY_LEFT_RIGHT && can_fall_both)
3667           can_fall_right = FALSE;
3668         else if (slippery_type == SLIPPERY_ANY_RIGHT_LEFT && can_fall_both)
3669           can_fall_left = FALSE;
3670
3671         can_fall_any  = (can_fall_left || can_fall_right);
3672         can_fall_both = (can_fall_left && can_fall_right);
3673       }
3674
3675       if (can_fall_any)
3676       {
3677         if (can_fall_both &&
3678             (game.emulation != EMU_BOULDERDASH &&
3679              element != EL_BD_ROCK && element != EL_BD_DIAMOND))
3680           can_fall_left = !(can_fall_right = RND(2));
3681
3682         InitMovingField(x, y, can_fall_left ? MV_LEFT : MV_RIGHT);
3683         started_moving = TRUE;
3684       }
3685     }
3686     else if (IS_BELT_ACTIVE(Feld[x][y + 1]))
3687     {
3688       boolean left_is_free  = (x > 0 && IS_FREE(x - 1, y));
3689       boolean right_is_free = (x < lev_fieldx - 1 && IS_FREE(x + 1, y));
3690       int belt_nr = getBeltNrFromBeltActiveElement(Feld[x][y + 1]);
3691       int belt_dir = game.belt_dir[belt_nr];
3692
3693       if ((belt_dir == MV_LEFT  && left_is_free) ||
3694           (belt_dir == MV_RIGHT && right_is_free))
3695       {
3696         InitMovingField(x, y, belt_dir);
3697         started_moving = TRUE;
3698
3699         GfxAction[x][y] = ACTION_DEFAULT;
3700       }
3701     }
3702   }
3703
3704   /* not "else if" because of elements that can fall and move (EL_SPRING) */
3705   if (CAN_MOVE(element) && !started_moving)
3706   {
3707     int newx, newy;
3708
3709     if ((element == EL_SATELLITE ||
3710          element == EL_BALLOON ||
3711          element == EL_SPRING)
3712         && JustBeingPushed(x, y))
3713       return;
3714
3715 #if 0
3716 #if 0
3717     if (element == EL_SPRING && MovDir[x][y] == MV_DOWN)
3718       Feld[x][y + 1] = EL_EMPTY;        /* was set to EL_BLOCKED above */
3719 #else
3720     if (element == EL_SPRING && MovDir[x][y] != MV_NO_MOVING)
3721     {
3722       Moving2Blocked(x, y, &newx, &newy);
3723       if (Feld[newx][newy] == EL_BLOCKED)
3724         Feld[newx][newy] = EL_EMPTY;    /* was set to EL_BLOCKED above */
3725     }
3726 #endif
3727 #endif
3728
3729     if (!MovDelay[x][y])        /* start new movement phase */
3730     {
3731       /* all objects that can change their move direction after each step
3732          (YAMYAM, DARK_YAMYAM and PACMAN go straight until they hit a wall */
3733
3734       if (element != EL_YAMYAM &&
3735           element != EL_DARK_YAMYAM &&
3736           element != EL_PACMAN &&
3737           !(element_info[element].move_pattern & MV_ANY_DIRECTION) &&
3738           element_info[element].move_pattern != MV_TURNING_LEFT &&
3739           element_info[element].move_pattern != MV_TURNING_RIGHT)
3740       {
3741         TurnRound(x, y);
3742
3743         if (MovDelay[x][y] && (element == EL_BUG ||
3744                                element == EL_SPACESHIP ||
3745                                element == EL_SP_SNIKSNAK ||
3746                                element == EL_SP_ELECTRON ||
3747                                element == EL_MOLE))
3748           DrawLevelField(x, y);
3749       }
3750     }
3751
3752     if (MovDelay[x][y])         /* wait some time before next movement */
3753     {
3754       MovDelay[x][y]--;
3755
3756 #if 0
3757       if (element == EL_YAMYAM)
3758       {
3759         printf("::: %d\n",
3760                el_act_dir2img(EL_YAMYAM, ACTION_WAITING, MV_LEFT));
3761         DrawLevelElementAnimation(x, y, element);
3762       }
3763 #endif
3764
3765       if (MovDelay[x][y])       /* element still has to wait some time */
3766       {
3767 #if 0
3768         /* !!! PLACE THIS SOMEWHERE AFTER "TurnRound()" !!! */
3769         ResetGfxAnimation(x, y);
3770 #endif
3771         GfxAction[x][y] = ACTION_WAITING;
3772       }
3773
3774       if (element == EL_ROBOT ||
3775 #if 0
3776           element == EL_PACMAN ||
3777 #endif
3778           element == EL_YAMYAM ||
3779           element == EL_DARK_YAMYAM)
3780       {
3781 #if 0
3782         DrawLevelElementAnimation(x, y, element);
3783 #else
3784         DrawLevelElementAnimationIfNeeded(x, y, element);
3785 #endif
3786         PlaySoundLevelAction(x, y, ACTION_WAITING);
3787       }
3788       else if (element == EL_SP_ELECTRON)
3789         DrawLevelElementAnimationIfNeeded(x, y, element);
3790       else if (element == EL_DRAGON)
3791       {
3792         int i;
3793         int dir = MovDir[x][y];
3794         int dx = (dir == MV_LEFT ? -1 : dir == MV_RIGHT ? +1 : 0);
3795         int dy = (dir == MV_UP   ? -1 : dir == MV_DOWN  ? +1 : 0);
3796         int graphic = (dir == MV_LEFT   ? IMG_FLAMES_1_LEFT :
3797                        dir == MV_RIGHT  ? IMG_FLAMES_1_RIGHT :
3798                        dir == MV_UP     ? IMG_FLAMES_1_UP :
3799                        dir == MV_DOWN   ? IMG_FLAMES_1_DOWN : IMG_EMPTY);
3800         int frame = getGraphicAnimationFrame(graphic, -1);
3801
3802         for (i=1; i<=3; i++)
3803         {
3804           int xx = x + i*dx, yy = y + i*dy;
3805           int sx = SCREENX(xx), sy = SCREENY(yy);
3806           int flame_graphic = graphic + (i - 1);
3807
3808           if (!IN_LEV_FIELD(xx, yy) || IS_DRAGONFIRE_PROOF(Feld[xx][yy]))
3809             break;
3810
3811           if (MovDelay[x][y])
3812           {
3813             int flamed = MovingOrBlocked2Element(xx, yy);
3814
3815             if (IS_CLASSIC_ENEMY(flamed) || CAN_EXPLODE_BY_FIRE(flamed))
3816               Bang(xx, yy);
3817             else
3818               RemoveMovingField(xx, yy);
3819
3820             Feld[xx][yy] = EL_FLAMES;
3821             if (IN_SCR_FIELD(sx, sy))
3822               DrawGraphic(sx, sy, flame_graphic, frame);
3823           }
3824           else
3825           {
3826             if (Feld[xx][yy] == EL_FLAMES)
3827               Feld[xx][yy] = EL_EMPTY;
3828             DrawLevelField(xx, yy);
3829           }
3830         }
3831       }
3832
3833       if (MovDelay[x][y])       /* element still has to wait some time */
3834       {
3835         PlaySoundLevelAction(x, y, ACTION_WAITING);
3836
3837         return;
3838       }
3839
3840       GfxAction[x][y] = ACTION_MOVING;
3841     }
3842
3843     /* now make next step */
3844
3845     Moving2Blocked(x, y, &newx, &newy); /* get next screen position */
3846
3847     if (DONT_COLLIDE_WITH(element) && IS_PLAYER(newx, newy) &&
3848         !PLAYER_PROTECTED(newx, newy))
3849     {
3850 #if 1
3851       TestIfBadThingRunsIntoHero(x, y, MovDir[x][y]);
3852       return;
3853 #else
3854       /* player killed by element which is deadly when colliding with */
3855       MovDir[x][y] = 0;
3856       KillHero(PLAYERINFO(newx, newy));
3857       return;
3858 #endif
3859
3860     }
3861     else if ((element == EL_PENGUIN ||
3862               element == EL_ROBOT ||
3863               element == EL_SATELLITE ||
3864               element == EL_BALLOON ||
3865               IS_CUSTOM_ELEMENT(element)) &&
3866              IN_LEV_FIELD(newx, newy) &&
3867              MovDir[x][y] == MV_DOWN && Feld[newx][newy] == EL_ACID)
3868     {
3869       SplashAcid(x, y);
3870       Store[x][y] = EL_ACID;
3871     }
3872     else if (element == EL_PENGUIN && IN_LEV_FIELD(newx, newy))
3873     {
3874       if (Feld[newx][newy] == EL_EXIT_OPEN)
3875       {
3876         Feld[x][y] = EL_EMPTY;
3877         DrawLevelField(x, y);
3878
3879         PlaySoundLevel(newx, newy, SND_PENGUIN_PASSING);
3880         if (IN_SCR_FIELD(SCREENX(newx), SCREENY(newy)))
3881           DrawGraphicThruMask(SCREENX(newx),SCREENY(newy), el2img(element), 0);
3882
3883         local_player->friends_still_needed--;
3884         if (!local_player->friends_still_needed &&
3885             !local_player->GameOver && AllPlayersGone)
3886           local_player->LevelSolved = local_player->GameOver = TRUE;
3887
3888         return;
3889       }
3890       else if (IS_FOOD_PENGUIN(Feld[newx][newy]))
3891       {
3892         if (DigField(local_player, newx, newy, 0, 0, DF_DIG) == MF_MOVING)
3893           DrawLevelField(newx, newy);
3894         else
3895           MovDir[x][y] = MV_NO_MOVING;
3896       }
3897       else if (!IS_FREE(newx, newy))
3898       {
3899         GfxAction[x][y] = ACTION_WAITING;
3900
3901         if (IS_PLAYER(x, y))
3902           DrawPlayerField(x, y);
3903         else
3904           DrawLevelField(x, y);
3905         return;
3906       }
3907     }
3908     else if (element == EL_PIG && IN_LEV_FIELD(newx, newy))
3909     {
3910       if (IS_FOOD_PIG(Feld[newx][newy]))
3911       {
3912         if (IS_MOVING(newx, newy))
3913           RemoveMovingField(newx, newy);
3914         else
3915         {
3916           Feld[newx][newy] = EL_EMPTY;
3917           DrawLevelField(newx, newy);
3918         }
3919
3920         PlaySoundLevel(x, y, SND_PIG_DIGGING);
3921       }
3922       else if (!IS_FREE(newx, newy))
3923       {
3924         if (IS_PLAYER(x, y))
3925           DrawPlayerField(x, y);
3926         else
3927           DrawLevelField(x, y);
3928         return;
3929       }
3930     }
3931     else if (element == EL_DRAGON && IN_LEV_FIELD(newx, newy))
3932     {
3933       if (!IS_FREE(newx, newy))
3934       {
3935         if (IS_PLAYER(x, y))
3936           DrawPlayerField(x, y);
3937         else
3938           DrawLevelField(x, y);
3939         return;
3940       }
3941       else
3942       {
3943         boolean wanna_flame = !RND(10);
3944         int dx = newx - x, dy = newy - y;
3945         int newx1 = newx+1*dx, newy1 = newy+1*dy;
3946         int newx2 = newx+2*dx, newy2 = newy+2*dy;
3947         int element1 = (IN_LEV_FIELD(newx1, newy1) ?
3948                         MovingOrBlocked2Element(newx1, newy1) : EL_STEELWALL);
3949         int element2 = (IN_LEV_FIELD(newx2, newy2) ?
3950                         MovingOrBlocked2Element(newx2, newy2) : EL_STEELWALL);
3951
3952         if ((wanna_flame ||
3953              IS_CLASSIC_ENEMY(element1) ||
3954              IS_CLASSIC_ENEMY(element2)) &&
3955             element1 != EL_DRAGON && element2 != EL_DRAGON &&
3956             element1 != EL_FLAMES && element2 != EL_FLAMES)
3957         {
3958           if (IS_PLAYER(x, y))
3959             DrawPlayerField(x, y);
3960           else
3961             DrawLevelField(x, y);
3962
3963           PlaySoundLevel(x, y, SND_DRAGON_ATTACKING);
3964
3965           MovDelay[x][y] = 50;
3966           Feld[newx][newy] = EL_FLAMES;
3967           if (IN_LEV_FIELD(newx1, newy1) && Feld[newx1][newy1] == EL_EMPTY)
3968             Feld[newx1][newy1] = EL_FLAMES;
3969           if (IN_LEV_FIELD(newx2, newy2) && Feld[newx2][newy2] == EL_EMPTY)
3970             Feld[newx2][newy2] = EL_FLAMES;
3971           return;
3972         }
3973       }
3974     }
3975     else if (element == EL_YAMYAM && IN_LEV_FIELD(newx, newy) &&
3976              Feld[newx][newy] == EL_DIAMOND)
3977     {
3978       if (IS_MOVING(newx, newy))
3979         RemoveMovingField(newx, newy);
3980       else
3981       {
3982         Feld[newx][newy] = EL_EMPTY;
3983         DrawLevelField(newx, newy);
3984       }
3985
3986       PlaySoundLevel(x, y, SND_YAMYAM_DIGGING);
3987     }
3988     else if (element == EL_DARK_YAMYAM && IN_LEV_FIELD(newx, newy) &&
3989              IS_FOOD_DARK_YAMYAM(Feld[newx][newy]))
3990     {
3991       if (AmoebaNr[newx][newy])
3992       {
3993         AmoebaCnt2[AmoebaNr[newx][newy]]--;
3994         if (Feld[newx][newy] == EL_AMOEBA_FULL ||
3995             Feld[newx][newy] == EL_BD_AMOEBA)
3996           AmoebaCnt[AmoebaNr[newx][newy]]--;
3997       }
3998
3999       if (IS_MOVING(newx, newy))
4000         RemoveMovingField(newx, newy);
4001       else
4002       {
4003         Feld[newx][newy] = EL_EMPTY;
4004         DrawLevelField(newx, newy);
4005       }
4006
4007       PlaySoundLevel(x, y, SND_DARK_YAMYAM_DIGGING);
4008     }
4009     else if ((element == EL_PACMAN || element == EL_MOLE)
4010              && IN_LEV_FIELD(newx, newy) && IS_AMOEBOID(Feld[newx][newy]))
4011     {
4012       if (AmoebaNr[newx][newy])
4013       {
4014         AmoebaCnt2[AmoebaNr[newx][newy]]--;
4015         if (Feld[newx][newy] == EL_AMOEBA_FULL ||
4016             Feld[newx][newy] == EL_BD_AMOEBA)
4017           AmoebaCnt[AmoebaNr[newx][newy]]--;
4018       }
4019
4020       if (element == EL_MOLE)
4021       {
4022         Feld[newx][newy] = EL_AMOEBA_SHRINKING;
4023         PlaySoundLevel(x, y, SND_MOLE_DIGGING);
4024
4025         ResetGfxAnimation(x, y);
4026         GfxAction[x][y] = ACTION_DIGGING;
4027         DrawLevelField(x, y);
4028
4029         MovDelay[newx][newy] = 0;       /* start amoeba shrinking delay */
4030         return;                         /* wait for shrinking amoeba */
4031       }
4032       else      /* element == EL_PACMAN */
4033       {
4034         Feld[newx][newy] = EL_EMPTY;
4035         DrawLevelField(newx, newy);
4036         PlaySoundLevel(x, y, SND_PACMAN_DIGGING);
4037       }
4038     }
4039     else if (element == EL_MOLE && IN_LEV_FIELD(newx, newy) &&
4040              (Feld[newx][newy] == EL_AMOEBA_SHRINKING ||
4041               (Feld[newx][newy] == EL_EMPTY && Stop[newx][newy])))
4042     {
4043       /* wait for shrinking amoeba to completely disappear */
4044       return;
4045     }
4046     else if (!IN_LEV_FIELD(newx, newy) || !IS_FREE(newx, newy))
4047     {
4048       /* object was running against a wall */
4049
4050       TurnRound(x, y);
4051
4052 #if 1
4053       DrawLevelElementAnimation(x, y, element);
4054 #else
4055       if (element == EL_BUG ||
4056           element == EL_SPACESHIP ||
4057           element == EL_SP_SNIKSNAK)
4058         DrawLevelField(x, y);
4059       else if (element == EL_MOLE)
4060         DrawLevelField(x, y);
4061       else if (element == EL_BD_BUTTERFLY ||
4062                element == EL_BD_FIREFLY)
4063         DrawLevelElementAnimationIfNeeded(x, y, element);
4064       else if (element == EL_SATELLITE)
4065         DrawLevelElementAnimationIfNeeded(x, y, element);
4066       else if (element == EL_SP_ELECTRON)
4067         DrawLevelElementAnimationIfNeeded(x, y, element);
4068 #endif
4069
4070       if (DONT_TOUCH(element))
4071         TestIfBadThingTouchesHero(x, y);
4072
4073 #if 0
4074       PlaySoundLevelAction(x, y, ACTION_WAITING);
4075 #endif
4076
4077       return;
4078     }
4079
4080     InitMovingField(x, y, MovDir[x][y]);
4081
4082     PlaySoundLevelAction(x, y, ACTION_MOVING);
4083   }
4084
4085   if (MovDir[x][y])
4086     ContinueMoving(x, y);
4087 }
4088
4089 void ContinueMoving(int x, int y)
4090 {
4091   int element = Feld[x][y];
4092   int direction = MovDir[x][y];
4093   int dx = (direction == MV_LEFT ? -1 : direction == MV_RIGHT ? +1 : 0);
4094   int dy = (direction == MV_UP   ? -1 : direction == MV_DOWN  ? +1 : 0);
4095   int newx = x + dx, newy = y + dy;
4096   int nextx = newx + dx, nexty = newy + dy;
4097   boolean pushed = Pushed[x][y];
4098
4099   MovPos[x][y] += getElementMoveStepsize(x, y);
4100
4101   if (pushed)           /* special case: moving object pushed by player */
4102     MovPos[x][y] = SIGN(MovPos[x][y]) * (TILEX - ABS(PLAYERINFO(x,y)->MovPos));
4103
4104   if (ABS(MovPos[x][y]) >= TILEX)       /* object reached its destination */
4105   {
4106     Feld[x][y] = EL_EMPTY;
4107     Feld[newx][newy] = element;
4108     MovPos[x][y] = 0;   /* force "not moving" for "crumbled sand" */
4109
4110     if (element == EL_MOLE)
4111     {
4112       Feld[x][y] = EL_SAND;
4113
4114       DrawLevelFieldCrumbledSandNeighbours(x, y);
4115     }
4116     else if (element == EL_QUICKSAND_FILLING)
4117     {
4118       element = Feld[newx][newy] = get_next_element(element);
4119       Store[newx][newy] = Store[x][y];
4120     }
4121     else if (element == EL_QUICKSAND_EMPTYING)
4122     {
4123       Feld[x][y] = get_next_element(element);
4124       element = Feld[newx][newy] = Store[x][y];
4125     }
4126     else if (element == EL_MAGIC_WALL_FILLING)
4127     {
4128       element = Feld[newx][newy] = get_next_element(element);
4129       if (!game.magic_wall_active)
4130         element = Feld[newx][newy] = EL_MAGIC_WALL_DEAD;
4131       Store[newx][newy] = Store[x][y];
4132     }
4133     else if (element == EL_MAGIC_WALL_EMPTYING)
4134     {
4135       Feld[x][y] = get_next_element(element);
4136       if (!game.magic_wall_active)
4137         Feld[x][y] = EL_MAGIC_WALL_DEAD;
4138       element = Feld[newx][newy] = Store[x][y];
4139     }
4140     else if (element == EL_BD_MAGIC_WALL_FILLING)
4141     {
4142       element = Feld[newx][newy] = get_next_element(element);
4143       if (!game.magic_wall_active)
4144         element = Feld[newx][newy] = EL_BD_MAGIC_WALL_DEAD;
4145       Store[newx][newy] = Store[x][y];
4146     }
4147     else if (element == EL_BD_MAGIC_WALL_EMPTYING)
4148     {
4149       Feld[x][y] = get_next_element(element);
4150       if (!game.magic_wall_active)
4151         Feld[x][y] = EL_BD_MAGIC_WALL_DEAD;
4152       element = Feld[newx][newy] = Store[x][y];
4153     }
4154     else if (element == EL_AMOEBA_DROPPING)
4155     {
4156       Feld[x][y] = get_next_element(element);
4157       element = Feld[newx][newy] = Store[x][y];
4158     }
4159     else if (element == EL_SOKOBAN_OBJECT)
4160     {
4161       if (Back[x][y])
4162         Feld[x][y] = Back[x][y];
4163
4164       if (Back[newx][newy])
4165         Feld[newx][newy] = EL_SOKOBAN_FIELD_FULL;
4166
4167       Back[x][y] = Back[newx][newy] = 0;
4168     }
4169     else if (Store[x][y] == EL_ACID)
4170     {
4171       element = Feld[newx][newy] = EL_ACID;
4172     }
4173
4174     Store[x][y] = 0;
4175     MovPos[x][y] = MovDir[x][y] = MovDelay[x][y] = 0;
4176     MovDelay[newx][newy] = 0;
4177
4178     /* copy element change control values to new field */
4179     ChangeDelay[newx][newy] = ChangeDelay[x][y];
4180
4181     /* copy animation control values to new field */
4182     GfxFrame[newx][newy]  = GfxFrame[x][y];
4183     GfxAction[newx][newy] = GfxAction[x][y];    /* keep action one frame */
4184     GfxRandom[newx][newy] = GfxRandom[x][y];    /* keep same random value */
4185
4186     Pushed[x][y] = Pushed[newx][newy] = FALSE;
4187
4188     ResetGfxAnimation(x, y);    /* reset animation values for old field */
4189
4190 #if 0
4191     /* 2.1.1 (does not work correctly for spring) */
4192     if (!CAN_MOVE(element))
4193       MovDir[newx][newy] = 0;
4194 #else
4195
4196 #if 0
4197     /* (does not work for falling objects that slide horizontally) */
4198     if (CAN_FALL(element) && MovDir[newx][newy] == MV_DOWN)
4199       MovDir[newx][newy] = 0;
4200 #else
4201     /*
4202     if (!CAN_MOVE(element) ||
4203         (element == EL_SPRING && MovDir[newx][newy] == MV_DOWN))
4204       MovDir[newx][newy] = 0;
4205     */
4206
4207     if (!CAN_MOVE(element) ||
4208         (CAN_FALL(element) && MovDir[newx][newy] == MV_DOWN))
4209       MovDir[newx][newy] = 0;
4210 #endif
4211 #endif
4212
4213     DrawLevelField(x, y);
4214     DrawLevelField(newx, newy);
4215
4216     Stop[newx][newy] = TRUE;    /* ignore this element until the next frame */
4217
4218     if (!pushed)        /* special case: moving object pushed by player */
4219       JustStopped[newx][newy] = 3;
4220
4221     if (DONT_TOUCH(element))    /* object may be nasty to player or others */
4222     {
4223       TestIfBadThingTouchesHero(newx, newy);
4224       TestIfBadThingTouchesFriend(newx, newy);
4225       TestIfBadThingTouchesOtherBadThing(newx, newy);
4226     }
4227     else if (element == EL_PENGUIN)
4228       TestIfFriendTouchesBadThing(newx, newy);
4229
4230     if (CAN_FALL(element) && direction == MV_DOWN &&
4231         (newy == lev_fieldy - 1 || !IS_FREE(x, newy + 1)))
4232       Impact(x, newy);
4233
4234     if (!IN_LEV_FIELD(nextx, nexty) || !IS_FREE(nextx, nexty))
4235       CheckElementChange(newx, newy, element, CE_COLLISION);
4236
4237     TestIfPlayerTouchesCustomElement(newx, newy);
4238     TestIfElementTouchesCustomElement(newx, newy);
4239   }
4240   else                          /* still moving on */
4241   {
4242     DrawLevelField(x, y);
4243   }
4244 }
4245
4246 int AmoebeNachbarNr(int ax, int ay)
4247 {
4248   int i;
4249   int element = Feld[ax][ay];
4250   int group_nr = 0;
4251   static int xy[4][2] =
4252   {
4253     { 0, -1 },
4254     { -1, 0 },
4255     { +1, 0 },
4256     { 0, +1 }
4257   };
4258
4259   for (i=0; i<4; i++)
4260   {
4261     int x = ax + xy[i][0];
4262     int y = ay + xy[i][1];
4263
4264     if (!IN_LEV_FIELD(x, y))
4265       continue;
4266
4267     if (Feld[x][y] == element && AmoebaNr[x][y] > 0)
4268       group_nr = AmoebaNr[x][y];
4269   }
4270
4271   return group_nr;
4272 }
4273
4274 void AmoebenVereinigen(int ax, int ay)
4275 {
4276   int i, x, y, xx, yy;
4277   int new_group_nr = AmoebaNr[ax][ay];
4278   static int xy[4][2] =
4279   {
4280     { 0, -1 },
4281     { -1, 0 },
4282     { +1, 0 },
4283     { 0, +1 }
4284   };
4285
4286   if (new_group_nr == 0)
4287     return;
4288
4289   for (i=0; i<4; i++)
4290   {
4291     x = ax + xy[i][0];
4292     y = ay + xy[i][1];
4293
4294     if (!IN_LEV_FIELD(x, y))
4295       continue;
4296
4297     if ((Feld[x][y] == EL_AMOEBA_FULL ||
4298          Feld[x][y] == EL_BD_AMOEBA ||
4299          Feld[x][y] == EL_AMOEBA_DEAD) &&
4300         AmoebaNr[x][y] != new_group_nr)
4301     {
4302       int old_group_nr = AmoebaNr[x][y];
4303
4304       if (old_group_nr == 0)
4305         return;
4306
4307       AmoebaCnt[new_group_nr] += AmoebaCnt[old_group_nr];
4308       AmoebaCnt[old_group_nr] = 0;
4309       AmoebaCnt2[new_group_nr] += AmoebaCnt2[old_group_nr];
4310       AmoebaCnt2[old_group_nr] = 0;
4311
4312       for (yy=0; yy<lev_fieldy; yy++)
4313       {
4314         for (xx=0; xx<lev_fieldx; xx++)
4315         {
4316           if (AmoebaNr[xx][yy] == old_group_nr)
4317             AmoebaNr[xx][yy] = new_group_nr;
4318         }
4319       }
4320     }
4321   }
4322 }
4323
4324 void AmoebeUmwandeln(int ax, int ay)
4325 {
4326   int i, x, y;
4327
4328   if (Feld[ax][ay] == EL_AMOEBA_DEAD)
4329   {
4330     int group_nr = AmoebaNr[ax][ay];
4331
4332 #ifdef DEBUG
4333     if (group_nr == 0)
4334     {
4335       printf("AmoebeUmwandeln(): ax = %d, ay = %d\n", ax, ay);
4336       printf("AmoebeUmwandeln(): This should never happen!\n");
4337       return;
4338     }
4339 #endif
4340
4341     for (y=0; y<lev_fieldy; y++)
4342     {
4343       for (x=0; x<lev_fieldx; x++)
4344       {
4345         if (Feld[x][y] == EL_AMOEBA_DEAD && AmoebaNr[x][y] == group_nr)
4346         {
4347           AmoebaNr[x][y] = 0;
4348           Feld[x][y] = EL_AMOEBA_TO_DIAMOND;
4349         }
4350       }
4351     }
4352     PlaySoundLevel(ax, ay, (IS_GEM(level.amoeba_content) ?
4353                             SND_AMOEBA_TURNING_TO_GEM :
4354                             SND_AMOEBA_TURNING_TO_ROCK));
4355     Bang(ax, ay);
4356   }
4357   else
4358   {
4359     static int xy[4][2] =
4360     {
4361       { 0, -1 },
4362       { -1, 0 },
4363       { +1, 0 },
4364       { 0, +1 }
4365     };
4366
4367     for (i=0; i<4; i++)
4368     {
4369       x = ax + xy[i][0];
4370       y = ay + xy[i][1];
4371
4372       if (!IN_LEV_FIELD(x, y))
4373         continue;
4374
4375       if (Feld[x][y] == EL_AMOEBA_TO_DIAMOND)
4376       {
4377         PlaySoundLevel(x, y, (IS_GEM(level.amoeba_content) ?
4378                               SND_AMOEBA_TURNING_TO_GEM :
4379                               SND_AMOEBA_TURNING_TO_ROCK));
4380         Bang(x, y);
4381       }
4382     }
4383   }
4384 }
4385
4386 void AmoebeUmwandelnBD(int ax, int ay, int new_element)
4387 {
4388   int x, y;
4389   int group_nr = AmoebaNr[ax][ay];
4390   boolean done = FALSE;
4391
4392 #ifdef DEBUG
4393   if (group_nr == 0)
4394   {
4395     printf("AmoebeUmwandelnBD(): ax = %d, ay = %d\n", ax, ay);
4396     printf("AmoebeUmwandelnBD(): This should never happen!\n");
4397     return;
4398   }
4399 #endif
4400
4401   for (y=0; y<lev_fieldy; y++)
4402   {
4403     for (x=0; x<lev_fieldx; x++)
4404     {
4405       if (AmoebaNr[x][y] == group_nr &&
4406           (Feld[x][y] == EL_AMOEBA_DEAD ||
4407            Feld[x][y] == EL_BD_AMOEBA ||
4408            Feld[x][y] == EL_AMOEBA_GROWING))
4409       {
4410         AmoebaNr[x][y] = 0;
4411         Feld[x][y] = new_element;
4412         InitField(x, y, FALSE);
4413         DrawLevelField(x, y);
4414         done = TRUE;
4415       }
4416     }
4417   }
4418
4419   if (done)
4420     PlaySoundLevel(ax, ay, (new_element == EL_BD_ROCK ?
4421                             SND_BD_AMOEBA_TURNING_TO_ROCK :
4422                             SND_BD_AMOEBA_TURNING_TO_GEM));
4423 }
4424
4425 void AmoebeWaechst(int x, int y)
4426 {
4427   static unsigned long sound_delay = 0;
4428   static unsigned long sound_delay_value = 0;
4429
4430   if (!MovDelay[x][y])          /* start new growing cycle */
4431   {
4432     MovDelay[x][y] = 7;
4433
4434     if (DelayReached(&sound_delay, sound_delay_value))
4435     {
4436 #if 1
4437       PlaySoundLevelElementAction(x, y, Store[x][y], ACTION_GROWING);
4438 #else
4439       if (Store[x][y] == EL_BD_AMOEBA)
4440         PlaySoundLevel(x, y, SND_BD_AMOEBA_GROWING);
4441       else
4442         PlaySoundLevel(x, y, SND_AMOEBA_GROWING);
4443 #endif
4444       sound_delay_value = 30;
4445     }
4446   }
4447
4448   if (MovDelay[x][y])           /* wait some time before growing bigger */
4449   {
4450     MovDelay[x][y]--;
4451     if (MovDelay[x][y]/2 && IN_SCR_FIELD(SCREENX(x), SCREENY(y)))
4452     {
4453       int frame = getGraphicAnimationFrame(IMG_AMOEBA_GROWING,
4454                                            6 - MovDelay[x][y]);
4455
4456       DrawGraphic(SCREENX(x), SCREENY(y), IMG_AMOEBA_GROWING, frame);
4457     }
4458
4459     if (!MovDelay[x][y])
4460     {
4461       Feld[x][y] = Store[x][y];
4462       Store[x][y] = 0;
4463       DrawLevelField(x, y);
4464     }
4465   }
4466 }
4467
4468 void AmoebaDisappearing(int x, int y)
4469 {
4470   static unsigned long sound_delay = 0;
4471   static unsigned long sound_delay_value = 0;
4472
4473   if (!MovDelay[x][y])          /* start new shrinking cycle */
4474   {
4475     MovDelay[x][y] = 7;
4476
4477     if (DelayReached(&sound_delay, sound_delay_value))
4478       sound_delay_value = 30;
4479   }
4480
4481   if (MovDelay[x][y])           /* wait some time before shrinking */
4482   {
4483     MovDelay[x][y]--;
4484     if (MovDelay[x][y]/2 && IN_SCR_FIELD(SCREENX(x), SCREENY(y)))
4485     {
4486       int frame = getGraphicAnimationFrame(IMG_AMOEBA_SHRINKING,
4487                                            6 - MovDelay[x][y]);
4488
4489       DrawGraphic(SCREENX(x), SCREENY(y), IMG_AMOEBA_SHRINKING, frame);
4490     }
4491
4492     if (!MovDelay[x][y])
4493     {
4494       Feld[x][y] = EL_EMPTY;
4495       DrawLevelField(x, y);
4496
4497       /* don't let mole enter this field in this cycle;
4498          (give priority to objects falling to this field from above) */
4499       Stop[x][y] = TRUE;
4500     }
4501   }
4502 }
4503
4504 void AmoebeAbleger(int ax, int ay)
4505 {
4506   int i;
4507   int element = Feld[ax][ay];
4508   int graphic = el2img(element);
4509   int newax = ax, neway = ay;
4510   static int xy[4][2] =
4511   {
4512     { 0, -1 },
4513     { -1, 0 },
4514     { +1, 0 },
4515     { 0, +1 }
4516   };
4517
4518   if (!level.amoeba_speed)
4519   {
4520     Feld[ax][ay] = EL_AMOEBA_DEAD;
4521     DrawLevelField(ax, ay);
4522     return;
4523   }
4524
4525   if (IS_ANIMATED(graphic))
4526     DrawLevelGraphicAnimationIfNeeded(ax, ay, graphic);
4527
4528   if (!MovDelay[ax][ay])        /* start making new amoeba field */
4529     MovDelay[ax][ay] = RND(FRAMES_PER_SECOND * 25 / (1 + level.amoeba_speed));
4530
4531   if (MovDelay[ax][ay])         /* wait some time before making new amoeba */
4532   {
4533     MovDelay[ax][ay]--;
4534     if (MovDelay[ax][ay])
4535       return;
4536   }
4537
4538   if (element == EL_AMOEBA_WET) /* object is an acid / amoeba drop */
4539   {
4540     int start = RND(4);
4541     int x = ax + xy[start][0];
4542     int y = ay + xy[start][1];
4543
4544     if (!IN_LEV_FIELD(x, y))
4545       return;
4546
4547     if (IS_FREE(x, y) ||
4548         Feld[x][y] == EL_SAND || Feld[x][y] == EL_QUICKSAND_EMPTY)
4549     {
4550       newax = x;
4551       neway = y;
4552     }
4553
4554     if (newax == ax && neway == ay)
4555       return;
4556   }
4557   else                          /* normal or "filled" (BD style) amoeba */
4558   {
4559     int start = RND(4);
4560     boolean waiting_for_player = FALSE;
4561
4562     for (i=0; i<4; i++)
4563     {
4564       int j = (start + i) % 4;
4565       int x = ax + xy[j][0];
4566       int y = ay + xy[j][1];
4567
4568       if (!IN_LEV_FIELD(x, y))
4569         continue;
4570
4571       if (IS_FREE(x, y) ||
4572           Feld[x][y] == EL_SAND || Feld[x][y] == EL_QUICKSAND_EMPTY)
4573       {
4574         newax = x;
4575         neway = y;
4576         break;
4577       }
4578       else if (IS_PLAYER(x, y))
4579         waiting_for_player = TRUE;
4580     }
4581
4582     if (newax == ax && neway == ay)             /* amoeba cannot grow */
4583     {
4584       if (i == 4 && (!waiting_for_player || game.emulation == EMU_BOULDERDASH))
4585       {
4586         Feld[ax][ay] = EL_AMOEBA_DEAD;
4587         DrawLevelField(ax, ay);
4588         AmoebaCnt[AmoebaNr[ax][ay]]--;
4589
4590         if (AmoebaCnt[AmoebaNr[ax][ay]] <= 0)   /* amoeba is completely dead */
4591         {
4592           if (element == EL_AMOEBA_FULL)
4593             AmoebeUmwandeln(ax, ay);
4594           else if (element == EL_BD_AMOEBA)
4595             AmoebeUmwandelnBD(ax, ay, level.amoeba_content);
4596         }
4597       }
4598       return;
4599     }
4600     else if (element == EL_AMOEBA_FULL || element == EL_BD_AMOEBA)
4601     {
4602       /* amoeba gets larger by growing in some direction */
4603
4604       int new_group_nr = AmoebaNr[ax][ay];
4605
4606 #ifdef DEBUG
4607   if (new_group_nr == 0)
4608   {
4609     printf("AmoebeAbleger(): newax = %d, neway = %d\n", newax, neway);
4610     printf("AmoebeAbleger(): This should never happen!\n");
4611     return;
4612   }
4613 #endif
4614
4615       AmoebaNr[newax][neway] = new_group_nr;
4616       AmoebaCnt[new_group_nr]++;
4617       AmoebaCnt2[new_group_nr]++;
4618
4619       /* if amoeba touches other amoeba(s) after growing, unify them */
4620       AmoebenVereinigen(newax, neway);
4621
4622       if (element == EL_BD_AMOEBA && AmoebaCnt2[new_group_nr] >= 200)
4623       {
4624         AmoebeUmwandelnBD(newax, neway, EL_BD_ROCK);
4625         return;
4626       }
4627     }
4628   }
4629
4630   if (element != EL_AMOEBA_WET || neway < ay || !IS_FREE(newax, neway) ||
4631       (neway == lev_fieldy - 1 && newax != ax))
4632   {
4633     Feld[newax][neway] = EL_AMOEBA_GROWING;     /* creation of new amoeba */
4634     Store[newax][neway] = element;
4635   }
4636   else if (neway == ay)
4637   {
4638     Feld[newax][neway] = EL_AMOEBA_DROP;        /* drop left/right of amoeba */
4639 #if 1
4640     PlaySoundLevelAction(newax, neway, ACTION_GROWING);
4641 #else
4642     PlaySoundLevel(newax, neway, SND_AMOEBA_GROWING);
4643 #endif
4644   }
4645   else
4646   {
4647     InitMovingField(ax, ay, MV_DOWN);           /* drop dripping from amoeba */
4648     Feld[ax][ay] = EL_AMOEBA_DROPPING;
4649     Store[ax][ay] = EL_AMOEBA_DROP;
4650     ContinueMoving(ax, ay);
4651     return;
4652   }
4653
4654   DrawLevelField(newax, neway);
4655 }
4656
4657 void Life(int ax, int ay)
4658 {
4659   int x1, y1, x2, y2;
4660   static int life[4] = { 2, 3, 3, 3 };  /* parameters for "game of life" */
4661   int life_time = 40;
4662   int element = Feld[ax][ay];
4663   int graphic = el2img(element);
4664   boolean changed = FALSE;
4665
4666   if (IS_ANIMATED(graphic))
4667     DrawLevelGraphicAnimationIfNeeded(ax, ay, graphic);
4668
4669   if (Stop[ax][ay])
4670     return;
4671
4672   if (!MovDelay[ax][ay])        /* start new "game of life" cycle */
4673     MovDelay[ax][ay] = life_time;
4674
4675   if (MovDelay[ax][ay])         /* wait some time before next cycle */
4676   {
4677     MovDelay[ax][ay]--;
4678     if (MovDelay[ax][ay])
4679       return;
4680   }
4681
4682   for (y1=-1; y1<2; y1++) for(x1=-1; x1<2; x1++)
4683   {
4684     int xx = ax+x1, yy = ay+y1;
4685     int nachbarn = 0;
4686
4687     if (!IN_LEV_FIELD(xx, yy))
4688       continue;
4689
4690     for (y2=-1; y2<2; y2++) for (x2=-1; x2<2; x2++)
4691     {
4692       int x = xx+x2, y = yy+y2;
4693
4694       if (!IN_LEV_FIELD(x, y) || (x == xx && y == yy))
4695         continue;
4696
4697       if (((Feld[x][y] == element ||
4698             (element == EL_GAME_OF_LIFE && IS_PLAYER(x, y))) &&
4699            !Stop[x][y]) ||
4700           (IS_FREE(x, y) && Stop[x][y]))
4701         nachbarn++;
4702     }
4703
4704     if (xx == ax && yy == ay)           /* field in the middle */
4705     {
4706       if (nachbarn < life[0] || nachbarn > life[1])
4707       {
4708         Feld[xx][yy] = EL_EMPTY;
4709         if (!Stop[xx][yy])
4710           DrawLevelField(xx, yy);
4711         Stop[xx][yy] = TRUE;
4712         changed = TRUE;
4713       }
4714     }
4715     else if (IS_FREE(xx, yy) || Feld[xx][yy] == EL_SAND)
4716     {                                   /* free border field */
4717       if (nachbarn >= life[2] && nachbarn <= life[3])
4718       {
4719         Feld[xx][yy] = element;
4720         MovDelay[xx][yy] = (element == EL_GAME_OF_LIFE ? 0 : life_time-1);
4721         if (!Stop[xx][yy])
4722           DrawLevelField(xx, yy);
4723         Stop[xx][yy] = TRUE;
4724         changed = TRUE;
4725       }
4726     }
4727   }
4728
4729   if (changed)
4730     PlaySoundLevel(ax, ay, element == EL_BIOMAZE ? SND_BIOMAZE_GROWING :
4731                    SND_GAME_OF_LIFE_GROWING);
4732 }
4733
4734 static void InitRobotWheel(int x, int y)
4735 {
4736   ChangeDelay[x][y] = level.time_wheel * FRAMES_PER_SECOND;
4737 }
4738
4739 static void RunRobotWheel(int x, int y)
4740 {
4741   PlaySoundLevel(x, y, SND_ROBOT_WHEEL_ACTIVE);
4742 }
4743
4744 static void StopRobotWheel(int x, int y)
4745 {
4746   if (ZX == x && ZY == y)
4747     ZX = ZY = -1;
4748 }
4749
4750 static void InitTimegateWheel(int x, int y)
4751 {
4752   ChangeDelay[x][y] = level.time_wheel * FRAMES_PER_SECOND;
4753 }
4754
4755 static void RunTimegateWheel(int x, int y)
4756 {
4757   PlaySoundLevel(x, y, SND_TIMEGATE_SWITCH_ACTIVE);
4758 }
4759
4760 void CheckExit(int x, int y)
4761 {
4762   if (local_player->gems_still_needed > 0 ||
4763       local_player->sokobanfields_still_needed > 0 ||
4764       local_player->lights_still_needed > 0)
4765   {
4766     int element = Feld[x][y];
4767     int graphic = el2img(element);
4768
4769     if (IS_ANIMATED(graphic))
4770       DrawLevelGraphicAnimationIfNeeded(x, y, graphic);
4771
4772     return;
4773   }
4774
4775   Feld[x][y] = EL_EXIT_OPENING;
4776
4777   PlaySoundLevelNearest(x, y, SND_CLASS_EXIT_OPENING);
4778 }
4779
4780 void CheckExitSP(int x, int y)
4781 {
4782   if (local_player->gems_still_needed > 0)
4783   {
4784     int element = Feld[x][y];
4785     int graphic = el2img(element);
4786
4787     if (IS_ANIMATED(graphic))
4788       DrawLevelGraphicAnimationIfNeeded(x, y, graphic);
4789
4790     return;
4791   }
4792
4793   Feld[x][y] = EL_SP_EXIT_OPEN;
4794
4795   PlaySoundLevelNearest(x, y, SND_CLASS_SP_EXIT_OPENING);
4796 }
4797
4798 static void CloseAllOpenTimegates()
4799 {
4800   int x, y;
4801
4802   for (y=0; y<lev_fieldy; y++)
4803   {
4804     for (x=0; x<lev_fieldx; x++)
4805     {
4806       int element = Feld[x][y];
4807
4808       if (element == EL_TIMEGATE_OPEN || element == EL_TIMEGATE_OPENING)
4809       {
4810         Feld[x][y] = EL_TIMEGATE_CLOSING;
4811 #if 1
4812         PlaySoundLevelAction(x, y, ACTION_CLOSING);
4813 #else
4814         PlaySoundLevel(x, y, SND_TIMEGATE_CLOSING);
4815 #endif
4816       }
4817     }
4818   }
4819 }
4820
4821 void EdelsteinFunkeln(int x, int y)
4822 {
4823   if (!IN_SCR_FIELD(SCREENX(x), SCREENY(y)) || IS_MOVING(x, y))
4824     return;
4825
4826   if (Feld[x][y] == EL_BD_DIAMOND)
4827     return;
4828
4829   if (MovDelay[x][y] == 0)      /* next animation frame */
4830     MovDelay[x][y] = 11 * !SimpleRND(500);
4831
4832   if (MovDelay[x][y] != 0)      /* wait some time before next frame */
4833   {
4834     MovDelay[x][y]--;
4835
4836     if (setup.direct_draw && MovDelay[x][y])
4837       SetDrawtoField(DRAW_BUFFERED);
4838
4839     DrawLevelElementAnimation(x, y, Feld[x][y]);
4840
4841     if (MovDelay[x][y] != 0)
4842     {
4843       int frame = getGraphicAnimationFrame(IMG_TWINKLE_WHITE,
4844                                            10 - MovDelay[x][y]);
4845
4846       DrawGraphicThruMask(SCREENX(x), SCREENY(y), IMG_TWINKLE_WHITE, frame);
4847
4848       if (setup.direct_draw)
4849       {
4850         int dest_x, dest_y;
4851
4852         dest_x = FX + SCREENX(x) * TILEX;
4853         dest_y = FY + SCREENY(y) * TILEY;
4854
4855         BlitBitmap(drawto_field, window,
4856                    dest_x, dest_y, TILEX, TILEY, dest_x, dest_y);
4857         SetDrawtoField(DRAW_DIRECT);
4858       }
4859     }
4860   }
4861 }
4862
4863 void MauerWaechst(int x, int y)
4864 {
4865   int delay = 6;
4866
4867   if (!MovDelay[x][y])          /* next animation frame */
4868     MovDelay[x][y] = 3 * delay;
4869
4870   if (MovDelay[x][y])           /* wait some time before next frame */
4871   {
4872     MovDelay[x][y]--;
4873
4874     if (IN_SCR_FIELD(SCREENX(x), SCREENY(y)))
4875     {
4876       int graphic = el_dir2img(Feld[x][y], MovDir[x][y]);
4877       int frame = getGraphicAnimationFrame(graphic, 17 - MovDelay[x][y]);
4878
4879       DrawGraphic(SCREENX(x), SCREENY(y), graphic, frame);
4880     }
4881
4882     if (!MovDelay[x][y])
4883     {
4884       if (MovDir[x][y] == MV_LEFT)
4885       {
4886         if (IN_LEV_FIELD(x - 1, y) && IS_WALL(Feld[x - 1][y]))
4887           DrawLevelField(x - 1, y);
4888       }
4889       else if (MovDir[x][y] == MV_RIGHT)
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_UP)
4895       {
4896         if (IN_LEV_FIELD(x, y - 1) && IS_WALL(Feld[x][y - 1]))
4897           DrawLevelField(x, y - 1);
4898       }
4899       else
4900       {
4901         if (IN_LEV_FIELD(x, y + 1) && IS_WALL(Feld[x][y + 1]))
4902           DrawLevelField(x, y + 1);
4903       }
4904
4905       Feld[x][y] = Store[x][y];
4906       Store[x][y] = 0;
4907       MovDir[x][y] = MV_NO_MOVING;
4908       DrawLevelField(x, y);
4909     }
4910   }
4911 }
4912
4913 void MauerAbleger(int ax, int ay)
4914 {
4915   int element = Feld[ax][ay];
4916   int graphic = el2img(element);
4917   boolean oben_frei = FALSE, unten_frei = FALSE;
4918   boolean links_frei = FALSE, rechts_frei = FALSE;
4919   boolean oben_massiv = FALSE, unten_massiv = FALSE;
4920   boolean links_massiv = FALSE, rechts_massiv = FALSE;
4921   boolean new_wall = FALSE;
4922
4923   if (IS_ANIMATED(graphic))
4924     DrawLevelGraphicAnimationIfNeeded(ax, ay, graphic);
4925
4926   if (!MovDelay[ax][ay])        /* start building new wall */
4927     MovDelay[ax][ay] = 6;
4928
4929   if (MovDelay[ax][ay])         /* wait some time before building new wall */
4930   {
4931     MovDelay[ax][ay]--;
4932     if (MovDelay[ax][ay])
4933       return;
4934   }
4935
4936   if (IN_LEV_FIELD(ax, ay-1) && IS_FREE(ax, ay-1))
4937     oben_frei = TRUE;
4938   if (IN_LEV_FIELD(ax, ay+1) && IS_FREE(ax, ay+1))
4939     unten_frei = TRUE;
4940   if (IN_LEV_FIELD(ax-1, ay) && IS_FREE(ax-1, ay))
4941     links_frei = TRUE;
4942   if (IN_LEV_FIELD(ax+1, ay) && IS_FREE(ax+1, ay))
4943     rechts_frei = TRUE;
4944
4945   if (element == EL_EXPANDABLE_WALL_VERTICAL ||
4946       element == EL_EXPANDABLE_WALL_ANY)
4947   {
4948     if (oben_frei)
4949     {
4950       Feld[ax][ay-1] = EL_EXPANDABLE_WALL_GROWING;
4951       Store[ax][ay-1] = element;
4952       MovDir[ax][ay-1] = MV_UP;
4953       if (IN_SCR_FIELD(SCREENX(ax), SCREENY(ay-1)))
4954         DrawGraphic(SCREENX(ax), SCREENY(ay - 1),
4955                     IMG_EXPANDABLE_WALL_GROWING_UP, 0);
4956       new_wall = TRUE;
4957     }
4958     if (unten_frei)
4959     {
4960       Feld[ax][ay+1] = EL_EXPANDABLE_WALL_GROWING;
4961       Store[ax][ay+1] = element;
4962       MovDir[ax][ay+1] = MV_DOWN;
4963       if (IN_SCR_FIELD(SCREENX(ax), SCREENY(ay+1)))
4964         DrawGraphic(SCREENX(ax), SCREENY(ay + 1),
4965                     IMG_EXPANDABLE_WALL_GROWING_DOWN, 0);
4966       new_wall = TRUE;
4967     }
4968   }
4969
4970   if (element == EL_EXPANDABLE_WALL_HORIZONTAL ||
4971       element == EL_EXPANDABLE_WALL_ANY ||
4972       element == EL_EXPANDABLE_WALL)
4973   {
4974     if (links_frei)
4975     {
4976       Feld[ax-1][ay] = EL_EXPANDABLE_WALL_GROWING;
4977       Store[ax-1][ay] = element;
4978       MovDir[ax-1][ay] = MV_LEFT;
4979       if (IN_SCR_FIELD(SCREENX(ax-1), SCREENY(ay)))
4980         DrawGraphic(SCREENX(ax - 1), SCREENY(ay),
4981                     IMG_EXPANDABLE_WALL_GROWING_LEFT, 0);
4982       new_wall = TRUE;
4983     }
4984
4985     if (rechts_frei)
4986     {
4987       Feld[ax+1][ay] = EL_EXPANDABLE_WALL_GROWING;
4988       Store[ax+1][ay] = element;
4989       MovDir[ax+1][ay] = MV_RIGHT;
4990       if (IN_SCR_FIELD(SCREENX(ax+1), SCREENY(ay)))
4991         DrawGraphic(SCREENX(ax + 1), SCREENY(ay),
4992                     IMG_EXPANDABLE_WALL_GROWING_RIGHT, 0);
4993       new_wall = TRUE;
4994     }
4995   }
4996
4997   if (element == EL_EXPANDABLE_WALL && (links_frei || rechts_frei))
4998     DrawLevelField(ax, ay);
4999
5000   if (!IN_LEV_FIELD(ax, ay-1) || IS_WALL(Feld[ax][ay-1]))
5001     oben_massiv = TRUE;
5002   if (!IN_LEV_FIELD(ax, ay+1) || IS_WALL(Feld[ax][ay+1]))
5003     unten_massiv = TRUE;
5004   if (!IN_LEV_FIELD(ax-1, ay) || IS_WALL(Feld[ax-1][ay]))
5005     links_massiv = TRUE;
5006   if (!IN_LEV_FIELD(ax+1, ay) || IS_WALL(Feld[ax+1][ay]))
5007     rechts_massiv = TRUE;
5008
5009   if (((oben_massiv && unten_massiv) ||
5010        element == EL_EXPANDABLE_WALL_HORIZONTAL ||
5011        element == EL_EXPANDABLE_WALL) &&
5012       ((links_massiv && rechts_massiv) ||
5013        element == EL_EXPANDABLE_WALL_VERTICAL))
5014     Feld[ax][ay] = EL_WALL;
5015
5016   if (new_wall)
5017 #if 1
5018     PlaySoundLevelAction(ax, ay, ACTION_GROWING);
5019 #else
5020     PlaySoundLevel(ax, ay, SND_EXPANDABLE_WALL_GROWING);
5021 #endif
5022 }
5023
5024 void CheckForDragon(int x, int y)
5025 {
5026   int i, j;
5027   boolean dragon_found = FALSE;
5028   static int xy[4][2] =
5029   {
5030     { 0, -1 },
5031     { -1, 0 },
5032     { +1, 0 },
5033     { 0, +1 }
5034   };
5035
5036   for (i=0; i<4; i++)
5037   {
5038     for (j=0; j<4; j++)
5039     {
5040       int xx = x + j*xy[i][0], yy = y + j*xy[i][1];
5041
5042       if (IN_LEV_FIELD(xx, yy) &&
5043           (Feld[xx][yy] == EL_FLAMES || Feld[xx][yy] == EL_DRAGON))
5044       {
5045         if (Feld[xx][yy] == EL_DRAGON)
5046           dragon_found = TRUE;
5047       }
5048       else
5049         break;
5050     }
5051   }
5052
5053   if (!dragon_found)
5054   {
5055     for (i=0; i<4; i++)
5056     {
5057       for (j=0; j<3; j++)
5058       {
5059         int xx = x + j*xy[i][0], yy = y + j*xy[i][1];
5060
5061         if (IN_LEV_FIELD(xx, yy) && Feld[xx][yy] == EL_FLAMES)
5062         {
5063           Feld[xx][yy] = EL_EMPTY;
5064           DrawLevelField(xx, yy);
5065         }
5066         else
5067           break;
5068       }
5069     }
5070   }
5071 }
5072
5073 static void InitBuggyBase(int x, int y)
5074 {
5075   int element = Feld[x][y];
5076   int activating_delay = FRAMES_PER_SECOND / 4;
5077
5078   ChangeDelay[x][y] =
5079     (element == EL_SP_BUGGY_BASE ?
5080      2 * FRAMES_PER_SECOND + RND(5 * FRAMES_PER_SECOND) - activating_delay :
5081      element == EL_SP_BUGGY_BASE_ACTIVATING ?
5082      activating_delay :
5083      element == EL_SP_BUGGY_BASE_ACTIVE ?
5084      1 * FRAMES_PER_SECOND + RND(1 * FRAMES_PER_SECOND) : 1);
5085 }
5086
5087 static void WarnBuggyBase(int x, int y)
5088 {
5089   int i;
5090   static int xy[4][2] =
5091   {
5092     { 0, -1 },
5093     { -1, 0 },
5094     { +1, 0 },
5095     { 0, +1 }
5096   };
5097
5098   for (i=0; i<4; i++)
5099   {
5100     int xx = x + xy[i][0], yy = y + xy[i][1];
5101
5102     if (IS_PLAYER(xx, yy))
5103     {
5104       PlaySoundLevel(x, y, SND_SP_BUGGY_BASE_ACTIVE);
5105
5106       break;
5107     }
5108   }
5109 }
5110
5111 static void InitTrap(int x, int y)
5112 {
5113   ChangeDelay[x][y] = 2 * FRAMES_PER_SECOND + RND(5 * FRAMES_PER_SECOND);
5114 }
5115
5116 static void ActivateTrap(int x, int y)
5117 {
5118   PlaySoundLevel(x, y, SND_TRAP_ACTIVATING);
5119 }
5120
5121 static void ChangeActiveTrap(int x, int y)
5122 {
5123   int graphic = IMG_TRAP_ACTIVE;
5124
5125   /* if new animation frame was drawn, correct crumbled sand border */
5126   if (IS_NEW_FRAME(GfxFrame[x][y], graphic))
5127     DrawLevelFieldCrumbledSand(x, y);
5128 }
5129
5130 static void ChangeElementNowExt(int x, int y, int target_element)
5131 {
5132   if (IS_PLAYER(x, y) && !IS_ACCESSIBLE(target_element))
5133   {
5134     Bang(x, y);
5135     return;
5136   }
5137
5138   RemoveField(x, y);
5139   Feld[x][y] = target_element;
5140
5141   ResetGfxAnimation(x, y);
5142   ResetRandomAnimationValue(x, y);
5143
5144   InitField(x, y, FALSE);
5145   if (CAN_MOVE(Feld[x][y]))
5146     InitMovDir(x, y);
5147
5148   DrawLevelField(x, y);
5149
5150   if (CAN_BE_CRUMBLED(Feld[x][y]))
5151     DrawLevelFieldCrumbledSandNeighbours(x, y);
5152
5153   TestIfBadThingTouchesHero(x, y);
5154   TestIfPlayerTouchesCustomElement(x, y);
5155   TestIfElementTouchesCustomElement(x, y);
5156 }
5157
5158 static void ChangeElementNow(int x, int y, int element)
5159 {
5160   struct ElementChangeInfo *change = &element_info[element].change;
5161
5162   /* prevent CheckTriggeredElementChange() from looping */
5163   Changing[x][y] = TRUE;
5164
5165   CheckTriggeredElementChange(x, y, Feld[x][y], CE_OTHER_IS_CHANGING);
5166
5167   Changing[x][y] = FALSE;
5168
5169   if (change->explode)
5170   {
5171     Bang(x, y);
5172     return;
5173   }
5174
5175   if (change->use_content)
5176   {
5177     boolean complete_change = TRUE;
5178     boolean can_change[3][3];
5179     int xx, yy;
5180
5181     for (yy = 0; yy < 3; yy++) for(xx = 0; xx < 3 ; xx++)
5182     {
5183       boolean half_destructible;
5184       int ex = x + xx - 1;
5185       int ey = y + yy - 1;
5186       int e;
5187
5188       can_change[xx][yy] = TRUE;
5189
5190       if (ex == x && ey == y)   /* do not check changing element itself */
5191         continue;
5192
5193       if (change->content[xx][yy] == EL_EMPTY_SPACE)
5194       {
5195         can_change[xx][yy] = FALSE;     /* do not change empty borders */
5196
5197         continue;
5198       }
5199
5200       if (!IN_LEV_FIELD(ex, ey))
5201       {
5202         can_change[xx][yy] = FALSE;
5203         complete_change = FALSE;
5204
5205         continue;
5206       }
5207
5208       e = Feld[ex][ey];
5209
5210       if (IS_MOVING(ex, ey) || IS_BLOCKED(ex, ey))
5211         e = MovingOrBlocked2Element(ex, ey);
5212
5213       half_destructible = (IS_FREE(ex, ey) || IS_DIGGABLE(e));
5214
5215       if ((change->power <= CP_NON_DESTRUCTIVE  && !IS_FREE(ex, ey)) ||
5216           (change->power <= CP_HALF_DESTRUCTIVE && !half_destructible) ||
5217           (change->power <= CP_FULL_DESTRUCTIVE && IS_INDESTRUCTIBLE(e)))
5218       {
5219         can_change[xx][yy] = FALSE;
5220         complete_change = FALSE;
5221       }
5222     }
5223
5224     if (!change->only_complete || complete_change)
5225     {
5226       if (change->only_complete && change->use_random_change &&
5227           RND(change->random) != 0)
5228         return;
5229
5230       for (yy = 0; yy < 3; yy++) for(xx = 0; xx < 3 ; xx++)
5231       {
5232         int ex = x + xx - 1;
5233         int ey = y + yy - 1;
5234
5235         if (can_change[xx][yy] && (!change->use_random_change ||
5236                                    RND(change->random) == 0))
5237         {
5238           if (IS_MOVING(ex, ey) || IS_BLOCKED(ex, ey))
5239             RemoveMovingField(ex, ey);
5240
5241           ChangeElementNowExt(ex, ey, change->content[xx][yy]);
5242
5243           /* for symmetry reasons, stop newly created border elements */
5244           if (ex != x || ey != y)
5245             Stop[ex][ey] = TRUE;
5246         }
5247       }
5248
5249       return;
5250     }
5251   }
5252
5253   ChangeElementNowExt(x, y, change->target_element);
5254 }
5255
5256 static void ChangeElement(int x, int y)
5257 {
5258 #if 1
5259   int element = MovingOrBlocked2Element(x, y);
5260 #else
5261   int element = Feld[x][y];
5262 #endif
5263   struct ElementChangeInfo *change = &element_info[element].change;
5264
5265   if (ChangeDelay[x][y] == 0)           /* initialize element change */
5266   {
5267 #if 1
5268     ChangeDelay[x][y] = (    change->delay_fixed  * change->delay_frames +
5269                          RND(change->delay_random * change->delay_frames)) + 1;
5270 #else
5271     ChangeDelay[x][y] = changing_element[element].change_delay + 1;
5272
5273     if (IS_CUSTOM_ELEMENT(element) && HAS_CHANGE_EVENT(element, CE_DELAY))
5274     {
5275       int max_random_delay = element_info[element].change.delay_random;
5276       int delay_frames = element_info[element].change.delay_frames;
5277
5278       ChangeDelay[x][y] += RND(max_random_delay * delay_frames);
5279     }
5280 #endif
5281
5282     ResetGfxAnimation(x, y);
5283     ResetRandomAnimationValue(x, y);
5284
5285 #if 1
5286     if (change->pre_change_function)
5287       change->pre_change_function(x, y);
5288 #else
5289     if (changing_element[element].pre_change_function)
5290       changing_element[element].pre_change_function(x, y);
5291 #endif
5292   }
5293
5294   ChangeDelay[x][y]--;
5295
5296   if (ChangeDelay[x][y] != 0)           /* continue element change */
5297   {
5298     int graphic = el_act_dir2img(element, GfxAction[x][y], MovDir[x][y]);
5299
5300     if (IS_ANIMATED(graphic))
5301       DrawLevelGraphicAnimationIfNeeded(x, y, graphic);
5302
5303 #if 1
5304     if (change->change_function)
5305       change->change_function(x, y);
5306 #else
5307     if (changing_element[element].change_function)
5308       changing_element[element].change_function(x, y);
5309 #endif
5310   }
5311   else                                  /* finish element change */
5312   {
5313 #if 0
5314     int next_element = changing_element[element].next_element;
5315 #endif
5316
5317     if (IS_MOVING(x, y))                /* never change a running system ;-) */
5318     {
5319       ChangeDelay[x][y] = 1;            /* try change after next move step */
5320
5321       return;
5322     }
5323
5324 #if 1
5325     ChangeElementNow(x, y, element);
5326
5327     if (change->post_change_function)
5328       change->post_change_function(x, y);
5329 #else
5330     if (next_element != EL_UNDEFINED)
5331       ChangeElementNow(x, y, next_element);
5332     else
5333       ChangeElementNow(x, y, element_info[element].change.target_element);
5334
5335     if (changing_element[element].post_change_function)
5336       changing_element[element].post_change_function(x, y);
5337 #endif
5338   }
5339 }
5340
5341 static boolean CheckTriggeredElementChange(int lx, int ly, int trigger_element,
5342                                            int trigger_event)
5343 {
5344   int i, x, y;
5345
5346   if (!(trigger_events[trigger_element] & CH_EVENT_BIT(trigger_event)))
5347     return FALSE;
5348
5349   for (i=0; i<MAX_NUM_ELEMENTS; i++)
5350   {
5351     if (!CAN_CHANGE(i) || !HAS_CHANGE_EVENT(i, trigger_event) ||
5352         element_info[i].change.trigger_element != trigger_element)
5353       continue;
5354
5355     for (y=0; y<lev_fieldy; y++) for (x=0; x<lev_fieldx; x++)
5356     {
5357       if (x == lx && y == ly)   /* do not change trigger element itself */
5358         continue;
5359
5360       if (Changing[x][y])       /* do not change just changing elements */
5361         continue;
5362
5363       if (Feld[x][y] == i)
5364       {
5365         ChangeDelay[x][y] = 1;
5366         ChangeElement(x, y);
5367       }
5368     }
5369   }
5370
5371   return TRUE;
5372 }
5373
5374 static boolean CheckElementChange(int x, int y, int element, int trigger_event)
5375 {
5376   if (!CAN_CHANGE(element) || !HAS_CHANGE_EVENT(element, trigger_event))
5377     return FALSE;
5378
5379   if (Feld[x][y] == EL_BLOCKED)
5380     Blocked2Moving(x, y, &x, &y);
5381
5382   ChangeDelay[x][y] = 1;
5383   ChangeElement(x, y);
5384
5385   return TRUE;
5386 }
5387
5388 static void PlayerActions(struct PlayerInfo *player, byte player_action)
5389 {
5390   static byte stored_player_action[MAX_PLAYERS];
5391   static int num_stored_actions = 0;
5392   boolean moved = FALSE, snapped = FALSE, bombed = FALSE;
5393   int left      = player_action & JOY_LEFT;
5394   int right     = player_action & JOY_RIGHT;
5395   int up        = player_action & JOY_UP;
5396   int down      = player_action & JOY_DOWN;
5397   int button1   = player_action & JOY_BUTTON_1;
5398   int button2   = player_action & JOY_BUTTON_2;
5399   int dx        = (left ? -1    : right ? 1     : 0);
5400   int dy        = (up   ? -1    : down  ? 1     : 0);
5401
5402   stored_player_action[player->index_nr] = 0;
5403   num_stored_actions++;
5404
5405   if (!player->active || tape.pausing)
5406     return;
5407
5408   if (player_action)
5409   {
5410     if (button1)
5411       snapped = SnapField(player, dx, dy);
5412     else
5413     {
5414       if (button2)
5415         bombed = PlaceBomb(player);
5416       moved = MoveFigure(player, dx, dy);
5417     }
5418
5419     if (tape.single_step && tape.recording && !tape.pausing)
5420     {
5421       if (button1 || (bombed && !moved))
5422       {
5423         TapeTogglePause(TAPE_TOGGLE_AUTOMATIC);
5424         SnapField(player, 0, 0);                /* stop snapping */
5425       }
5426     }
5427
5428     stored_player_action[player->index_nr] = player_action;
5429   }
5430   else
5431   {
5432     /* no actions for this player (no input at player's configured device) */
5433
5434     DigField(player, 0, 0, 0, 0, DF_NO_PUSH);
5435     SnapField(player, 0, 0);
5436     CheckGravityMovement(player);
5437
5438     if (player->MovPos == 0)
5439     {
5440 #if 0
5441       printf("Trying... Player frame reset\n");
5442 #endif
5443
5444       InitPlayerGfxAnimation(player, ACTION_DEFAULT, player->MovDir);
5445     }
5446
5447     if (player->MovPos == 0)    /* needed for tape.playing */
5448       player->is_moving = FALSE;
5449   }
5450
5451   if (tape.recording && num_stored_actions >= MAX_PLAYERS)
5452   {
5453     TapeRecordAction(stored_player_action);
5454     num_stored_actions = 0;
5455   }
5456 }
5457
5458 void GameActions()
5459 {
5460   static unsigned long action_delay = 0;
5461   unsigned long action_delay_value;
5462   int magic_wall_x = 0, magic_wall_y = 0;
5463   int i, x, y, element, graphic;
5464   byte *recorded_player_action;
5465   byte summarized_player_action = 0;
5466
5467   if (game_status != GAME_MODE_PLAYING)
5468     return;
5469
5470   action_delay_value =
5471     (tape.playing && tape.fast_forward ? FfwdFrameDelay : GameFrameDelay);
5472
5473   if (tape.playing && tape.index_search && !tape.pausing)
5474     action_delay_value = 0;
5475
5476   /* ---------- main game synchronization point ---------- */
5477
5478   WaitUntilDelayReached(&action_delay, action_delay_value);
5479
5480   if (network_playing && !network_player_action_received)
5481   {
5482     /*
5483 #ifdef DEBUG
5484     printf("DEBUG: try to get network player actions in time\n");
5485 #endif
5486     */
5487
5488 #if defined(PLATFORM_UNIX)
5489     /* last chance to get network player actions without main loop delay */
5490     HandleNetworking();
5491 #endif
5492
5493     if (game_status != GAME_MODE_PLAYING)
5494       return;
5495
5496     if (!network_player_action_received)
5497     {
5498       /*
5499 #ifdef DEBUG
5500       printf("DEBUG: failed to get network player actions in time\n");
5501 #endif
5502       */
5503       return;
5504     }
5505   }
5506
5507   if (tape.pausing)
5508     return;
5509
5510   recorded_player_action = (tape.playing ? TapePlayAction() : NULL);
5511
5512   for (i=0; i<MAX_PLAYERS; i++)
5513   {
5514     summarized_player_action |= stored_player[i].action;
5515
5516     if (!network_playing)
5517       stored_player[i].effective_action = stored_player[i].action;
5518   }
5519
5520 #if defined(PLATFORM_UNIX)
5521   if (network_playing)
5522     SendToServer_MovePlayer(summarized_player_action);
5523 #endif
5524
5525   if (!options.network && !setup.team_mode)
5526     local_player->effective_action = summarized_player_action;
5527
5528   for (i=0; i<MAX_PLAYERS; i++)
5529   {
5530     int actual_player_action = stored_player[i].effective_action;
5531
5532     if (stored_player[i].programmed_action)
5533       actual_player_action = stored_player[i].programmed_action;
5534
5535     if (recorded_player_action)
5536       actual_player_action = recorded_player_action[i];
5537
5538     PlayerActions(&stored_player[i], actual_player_action);
5539     ScrollFigure(&stored_player[i], SCROLL_GO_ON);
5540   }
5541
5542   network_player_action_received = FALSE;
5543
5544   ScrollScreen(NULL, SCROLL_GO_ON);
5545
5546 #if 0
5547   FrameCounter++;
5548   TimeFrames++;
5549
5550   for (i=0; i<MAX_PLAYERS; i++)
5551     stored_player[i].Frame++;
5552 #endif
5553
5554 #if 1
5555   if (game.engine_version < RELEASE_IDENT(2,2,0,7))
5556   {
5557     for (i=0; i<MAX_PLAYERS; i++)
5558     {
5559       struct PlayerInfo *player = &stored_player[i];
5560       int x = player->jx;
5561       int y = player->jy;
5562
5563       if (player->active && player->Pushing && player->is_moving &&
5564           IS_MOVING(x, y))
5565       {
5566         ContinueMoving(x, y);
5567
5568         /* continue moving after pushing (this is actually a bug) */
5569         if (!IS_MOVING(x, y))
5570         {
5571           Stop[x][y] = FALSE;
5572         }
5573       }
5574     }
5575   }
5576 #endif
5577
5578   for (y=0; y<lev_fieldy; y++) for (x=0; x<lev_fieldx; x++)
5579   {
5580     Stop[x][y] = FALSE;
5581     if (JustStopped[x][y] > 0)
5582       JustStopped[x][y]--;
5583
5584     GfxFrame[x][y]++;
5585
5586 #if DEBUG
5587     if (IS_BLOCKED(x, y))
5588     {
5589       int oldx, oldy;
5590
5591       Blocked2Moving(x, y, &oldx, &oldy);
5592       if (!IS_MOVING(oldx, oldy))
5593       {
5594         printf("GameActions(): (BLOCKED => MOVING) context corrupted!\n");
5595         printf("GameActions(): BLOCKED: x = %d, y = %d\n", x, y);
5596         printf("GameActions(): !MOVING: oldx = %d, oldy = %d\n", oldx, oldy);
5597         printf("GameActions(): This should never happen!\n");
5598       }
5599     }
5600 #endif
5601   }
5602
5603   for (y=0; y<lev_fieldy; y++) for (x=0; x<lev_fieldx; x++)
5604   {
5605     element = Feld[x][y];
5606 #if 1
5607     graphic = el_act_dir2img(element, GfxAction[x][y], MovDir[x][y]);
5608 #else
5609     graphic = el2img(element);
5610 #endif
5611
5612 #if 0
5613     if (element == -1)
5614     {
5615       printf("::: %d,%d: %d [%d]\n", x, y, element, FrameCounter);
5616
5617       element = graphic = 0;
5618     }
5619 #endif
5620
5621     if (graphic_info[graphic].anim_global_sync)
5622       GfxFrame[x][y] = FrameCounter;
5623
5624     if (ANIM_MODE(graphic) == ANIM_RANDOM &&
5625         IS_NEXT_FRAME(GfxFrame[x][y], graphic))
5626       ResetRandomAnimationValue(x, y);
5627
5628     SetRandomAnimationValue(x, y);
5629
5630 #if 1
5631     PlaySoundLevelActionIfLoop(x, y, GfxAction[x][y]);
5632 #endif
5633
5634     if (IS_INACTIVE(element))
5635     {
5636       if (IS_ANIMATED(graphic))
5637         DrawLevelGraphicAnimationIfNeeded(x, y, graphic);
5638
5639       continue;
5640     }
5641
5642 #if 1
5643     /* this may take place after moving, so 'element' may have changed */
5644     if (IS_CHANGING(x, y))
5645     {
5646       ChangeElement(x, y);
5647       element = Feld[x][y];
5648       graphic = el_act_dir2img(element, GfxAction[x][y], MovDir[x][y]);
5649     }
5650 #endif
5651
5652     if (!IS_MOVING(x, y) && (CAN_FALL(element) || CAN_MOVE(element)))
5653     {
5654       StartMoving(x, y);
5655
5656 #if 1
5657       graphic = el_act_dir2img(element, GfxAction[x][y], MovDir[x][y]);
5658 #if 0
5659       if (element == EL_MOLE)
5660         printf("::: %d, %d, %d [%d]\n",
5661                IS_ANIMATED(graphic), IS_MOVING(x, y), Stop[x][y],
5662                GfxAction[x][y]);
5663 #endif
5664 #if 0
5665       if (element == EL_YAMYAM)
5666         printf("::: %d, %d, %d\n",
5667                IS_ANIMATED(graphic), IS_MOVING(x, y), Stop[x][y]);
5668 #endif
5669 #endif
5670
5671       if (IS_ANIMATED(graphic) &&
5672           !IS_MOVING(x, y) &&
5673           !Stop[x][y])
5674       {
5675         DrawLevelGraphicAnimationIfNeeded(x, y, graphic);
5676
5677 #if 0
5678         if (element == EL_MOLE)
5679           printf("::: %d, %d\n", graphic, GfxFrame[x][y]);
5680 #endif
5681       }
5682
5683       if (IS_GEM(element) || element == EL_SP_INFOTRON)
5684         EdelsteinFunkeln(x, y);
5685     }
5686     else if ((element == EL_ACID ||
5687               element == EL_EXIT_OPEN ||
5688               element == EL_SP_EXIT_OPEN ||
5689               element == EL_SP_TERMINAL ||
5690               element == EL_SP_TERMINAL_ACTIVE ||
5691               element == EL_EXTRA_TIME ||
5692               element == EL_SHIELD_NORMAL ||
5693               element == EL_SHIELD_DEADLY) &&
5694              IS_ANIMATED(graphic))
5695       DrawLevelGraphicAnimationIfNeeded(x, y, graphic);
5696     else if (IS_MOVING(x, y))
5697       ContinueMoving(x, y);
5698     else if (IS_ACTIVE_BOMB(element))
5699       CheckDynamite(x, y);
5700 #if 0
5701     else if (element == EL_EXPLOSION && !game.explosions_delayed)
5702       Explode(x, y, ExplodePhase[x][y], EX_NORMAL);
5703 #endif
5704     else if (element == EL_AMOEBA_GROWING)
5705       AmoebeWaechst(x, y);
5706     else if (element == EL_AMOEBA_SHRINKING)
5707       AmoebaDisappearing(x, y);
5708
5709 #if !USE_NEW_AMOEBA_CODE
5710     else if (IS_AMOEBALIVE(element))
5711       AmoebeAbleger(x, y);
5712 #endif
5713
5714     else if (element == EL_GAME_OF_LIFE || element == EL_BIOMAZE)
5715       Life(x, y);
5716     else if (element == EL_EXIT_CLOSED)
5717       CheckExit(x, y);
5718     else if (element == EL_SP_EXIT_CLOSED)
5719       CheckExitSP(x, y);
5720     else if (element == EL_EXPANDABLE_WALL_GROWING)
5721       MauerWaechst(x, y);
5722     else if (element == EL_EXPANDABLE_WALL ||
5723              element == EL_EXPANDABLE_WALL_HORIZONTAL ||
5724              element == EL_EXPANDABLE_WALL_VERTICAL ||
5725              element == EL_EXPANDABLE_WALL_ANY)
5726       MauerAbleger(x, y);
5727     else if (element == EL_FLAMES)
5728       CheckForDragon(x, y);
5729 #if 0
5730     else if (IS_AUTO_CHANGING(element))
5731       ChangeElement(x, y);
5732 #endif
5733     else if (element == EL_EXPLOSION)
5734       ; /* drawing of correct explosion animation is handled separately */
5735     else if (IS_ANIMATED(graphic) && !IS_CHANGING(x, y))
5736       DrawLevelGraphicAnimationIfNeeded(x, y, graphic);
5737
5738 #if 0
5739     /* this may take place after moving, so 'element' may have changed */
5740     if (IS_AUTO_CHANGING(Feld[x][y]))
5741       ChangeElement(x, y);
5742 #endif
5743
5744     if (IS_BELT_ACTIVE(element))
5745       PlaySoundLevelAction(x, y, ACTION_ACTIVE);
5746
5747     if (game.magic_wall_active)
5748     {
5749       int jx = local_player->jx, jy = local_player->jy;
5750
5751       /* play the element sound at the position nearest to the player */
5752       if ((element == EL_MAGIC_WALL_FULL ||
5753            element == EL_MAGIC_WALL_ACTIVE ||
5754            element == EL_MAGIC_WALL_EMPTYING ||
5755            element == EL_BD_MAGIC_WALL_FULL ||
5756            element == EL_BD_MAGIC_WALL_ACTIVE ||
5757            element == EL_BD_MAGIC_WALL_EMPTYING) &&
5758           ABS(x-jx) + ABS(y-jy) < ABS(magic_wall_x-jx) + ABS(magic_wall_y-jy))
5759       {
5760         magic_wall_x = x;
5761         magic_wall_y = y;
5762       }
5763     }
5764   }
5765
5766 #if USE_NEW_AMOEBA_CODE
5767   /* new experimental amoeba growth stuff */
5768 #if 1
5769   if (!(FrameCounter % 8))
5770 #endif
5771   {
5772     static unsigned long random = 1684108901;
5773
5774     for (i = 0; i < level.amoeba_speed * 28 / 8; i++)
5775     {
5776 #if 0
5777       x = (random >> 10) % lev_fieldx;
5778       y = (random >> 20) % lev_fieldy;
5779 #else
5780       x = RND(lev_fieldx);
5781       y = RND(lev_fieldy);
5782 #endif
5783       element = Feld[x][y];
5784
5785       if (!IS_PLAYER(x,y) &&
5786           (element == EL_EMPTY ||
5787            element == EL_SAND ||
5788            element == EL_QUICKSAND_EMPTY ||
5789            element == EL_ACID_SPLASH_LEFT ||
5790            element == EL_ACID_SPLASH_RIGHT))
5791       {
5792         if ((IN_LEV_FIELD(x, y-1) && Feld[x][y-1] == EL_AMOEBA_WET) ||
5793             (IN_LEV_FIELD(x-1, y) && Feld[x-1][y] == EL_AMOEBA_WET) ||
5794             (IN_LEV_FIELD(x+1, y) && Feld[x+1][y] == EL_AMOEBA_WET) ||
5795             (IN_LEV_FIELD(x, y+1) && Feld[x][y+1] == EL_AMOEBA_WET))
5796           Feld[x][y] = EL_AMOEBA_DROP;
5797       }
5798
5799       random = random * 129 + 1;
5800     }
5801   }
5802 #endif
5803
5804 #if 0
5805   if (game.explosions_delayed)
5806 #endif
5807   {
5808     game.explosions_delayed = FALSE;
5809
5810     for (y=0; y<lev_fieldy; y++) for (x=0; x<lev_fieldx; x++)
5811     {
5812       element = Feld[x][y];
5813
5814       if (ExplodeField[x][y])
5815         Explode(x, y, EX_PHASE_START, ExplodeField[x][y]);
5816       else if (element == EL_EXPLOSION)
5817         Explode(x, y, ExplodePhase[x][y], EX_NORMAL);
5818
5819       ExplodeField[x][y] = EX_NO_EXPLOSION;
5820     }
5821
5822     game.explosions_delayed = TRUE;
5823   }
5824
5825   if (game.magic_wall_active)
5826   {
5827     if (!(game.magic_wall_time_left % 4))
5828     {
5829       int element = Feld[magic_wall_x][magic_wall_y];
5830
5831       if (element == EL_BD_MAGIC_WALL_FULL ||
5832           element == EL_BD_MAGIC_WALL_ACTIVE ||
5833           element == EL_BD_MAGIC_WALL_EMPTYING)
5834         PlaySoundLevel(magic_wall_x, magic_wall_y, SND_BD_MAGIC_WALL_ACTIVE);
5835       else
5836         PlaySoundLevel(magic_wall_x, magic_wall_y, SND_MAGIC_WALL_ACTIVE);
5837     }
5838
5839     if (game.magic_wall_time_left > 0)
5840     {
5841       game.magic_wall_time_left--;
5842       if (!game.magic_wall_time_left)
5843       {
5844         for (y=0; y<lev_fieldy; y++) for (x=0; x<lev_fieldx; x++)
5845         {
5846           element = Feld[x][y];
5847
5848           if (element == EL_MAGIC_WALL_ACTIVE ||
5849               element == EL_MAGIC_WALL_FULL)
5850           {
5851             Feld[x][y] = EL_MAGIC_WALL_DEAD;
5852             DrawLevelField(x, y);
5853           }
5854           else if (element == EL_BD_MAGIC_WALL_ACTIVE ||
5855                    element == EL_BD_MAGIC_WALL_FULL)
5856           {
5857             Feld[x][y] = EL_BD_MAGIC_WALL_DEAD;
5858             DrawLevelField(x, y);
5859           }
5860         }
5861
5862         game.magic_wall_active = FALSE;
5863       }
5864     }
5865   }
5866
5867   if (game.light_time_left > 0)
5868   {
5869     game.light_time_left--;
5870
5871     if (game.light_time_left == 0)
5872       RedrawAllLightSwitchesAndInvisibleElements();
5873   }
5874
5875   if (game.timegate_time_left > 0)
5876   {
5877     game.timegate_time_left--;
5878
5879     if (game.timegate_time_left == 0)
5880       CloseAllOpenTimegates();
5881   }
5882
5883   for (i=0; i<MAX_PLAYERS; i++)
5884   {
5885     struct PlayerInfo *player = &stored_player[i];
5886
5887     if (SHIELD_ON(player))
5888     {
5889       if (player->shield_deadly_time_left)
5890         PlaySoundLevel(player->jx, player->jy, SND_SHIELD_DEADLY_ACTIVE);
5891       else if (player->shield_normal_time_left)
5892         PlaySoundLevel(player->jx, player->jy, SND_SHIELD_NORMAL_ACTIVE);
5893     }
5894   }
5895
5896   if (TimeFrames >= (1000 / GameFrameDelay))
5897   {
5898     TimeFrames = 0;
5899     TimePlayed++;
5900
5901     for (i=0; i<MAX_PLAYERS; i++)
5902     {
5903       struct PlayerInfo *player = &stored_player[i];
5904
5905       if (SHIELD_ON(player))
5906       {
5907         player->shield_normal_time_left--;
5908
5909         if (player->shield_deadly_time_left > 0)
5910           player->shield_deadly_time_left--;
5911       }
5912     }
5913
5914     if (tape.recording || tape.playing)
5915       DrawVideoDisplay(VIDEO_STATE_TIME_ON, TimePlayed);
5916
5917     if (TimeLeft > 0)
5918     {
5919       TimeLeft--;
5920
5921       if (TimeLeft <= 10 && setup.time_limit)
5922         PlaySoundStereo(SND_GAME_RUNNING_OUT_OF_TIME, SOUND_MIDDLE);
5923
5924       DrawText(DX_TIME, DY_TIME, int2str(TimeLeft, 3), FONT_TEXT_2);
5925
5926       if (!TimeLeft && setup.time_limit)
5927         for (i=0; i<MAX_PLAYERS; i++)
5928           KillHero(&stored_player[i]);
5929     }
5930     else if (level.time == 0 && !AllPlayersGone) /* level without time limit */
5931       DrawText(DX_TIME, DY_TIME, int2str(TimePlayed, 3), FONT_TEXT_2);
5932   }
5933
5934   DrawAllPlayers();
5935
5936   if (options.debug)                    /* calculate frames per second */
5937   {
5938     static unsigned long fps_counter = 0;
5939     static int fps_frames = 0;
5940     unsigned long fps_delay_ms = Counter() - fps_counter;
5941
5942     fps_frames++;
5943
5944     if (fps_delay_ms >= 500)    /* calculate fps every 0.5 seconds */
5945     {
5946       global.frames_per_second = 1000 * (float)fps_frames / fps_delay_ms;
5947
5948       fps_frames = 0;
5949       fps_counter = Counter();
5950     }
5951
5952     redraw_mask |= REDRAW_FPS;
5953   }
5954
5955 #if 0
5956   if (stored_player[0].jx != stored_player[0].last_jx ||
5957       stored_player[0].jy != stored_player[0].last_jy)
5958     printf("::: %d, %d, %d, %d, %d\n",
5959            stored_player[0].MovDir,
5960            stored_player[0].MovPos,
5961            stored_player[0].GfxPos,
5962            stored_player[0].Frame,
5963            stored_player[0].StepFrame);
5964 #endif
5965
5966 #if 1
5967   FrameCounter++;
5968   TimeFrames++;
5969
5970   for (i=0; i<MAX_PLAYERS; i++)
5971   {
5972     int move_frames =
5973       MOVE_DELAY_NORMAL_SPEED /  stored_player[i].move_delay_value;
5974
5975     stored_player[i].Frame += move_frames;
5976
5977     if (stored_player[i].MovPos != 0)
5978       stored_player[i].StepFrame += move_frames;
5979   }
5980 #endif
5981 }
5982
5983 static boolean AllPlayersInSight(struct PlayerInfo *player, int x, int y)
5984 {
5985   int min_x = x, min_y = y, max_x = x, max_y = y;
5986   int i;
5987
5988   for (i=0; i<MAX_PLAYERS; i++)
5989   {
5990     int jx = stored_player[i].jx, jy = stored_player[i].jy;
5991
5992     if (!stored_player[i].active || &stored_player[i] == player)
5993       continue;
5994
5995     min_x = MIN(min_x, jx);
5996     min_y = MIN(min_y, jy);
5997     max_x = MAX(max_x, jx);
5998     max_y = MAX(max_y, jy);
5999   }
6000
6001   return (max_x - min_x < SCR_FIELDX && max_y - min_y < SCR_FIELDY);
6002 }
6003
6004 static boolean AllPlayersInVisibleScreen()
6005 {
6006   int i;
6007
6008   for (i=0; i<MAX_PLAYERS; i++)
6009   {
6010     int jx = stored_player[i].jx, jy = stored_player[i].jy;
6011
6012     if (!stored_player[i].active)
6013       continue;
6014
6015     if (!IN_VIS_FIELD(SCREENX(jx), SCREENY(jy)))
6016       return FALSE;
6017   }
6018
6019   return TRUE;
6020 }
6021
6022 void ScrollLevel(int dx, int dy)
6023 {
6024   int softscroll_offset = (setup.soft_scrolling ? TILEX : 0);
6025   int x, y;
6026
6027   BlitBitmap(drawto_field, drawto_field,
6028              FX + TILEX*(dx == -1) - softscroll_offset,
6029              FY + TILEY*(dy == -1) - softscroll_offset,
6030              SXSIZE - TILEX*(dx!=0) + 2*softscroll_offset,
6031              SYSIZE - TILEY*(dy!=0) + 2*softscroll_offset,
6032              FX + TILEX*(dx == 1) - softscroll_offset,
6033              FY + TILEY*(dy == 1) - softscroll_offset);
6034
6035   if (dx)
6036   {
6037     x = (dx == 1 ? BX1 : BX2);
6038     for (y=BY1; y<=BY2; y++)
6039       DrawScreenField(x, y);
6040   }
6041
6042   if (dy)
6043   {
6044     y = (dy == 1 ? BY1 : BY2);
6045     for (x=BX1; x<=BX2; x++)
6046       DrawScreenField(x, y);
6047   }
6048
6049   redraw_mask |= REDRAW_FIELD;
6050 }
6051
6052 static void CheckGravityMovement(struct PlayerInfo *player)
6053 {
6054   if (level.gravity && !player->programmed_action)
6055   {
6056     int move_dir_vertical = player->action & (MV_UP | MV_DOWN);
6057     int move_dir_horizontal = player->action & (MV_LEFT | MV_RIGHT);
6058     int move_dir =
6059       (player->last_move_dir & (MV_LEFT | MV_RIGHT) ?
6060        (move_dir_vertical ? move_dir_vertical : move_dir_horizontal) :
6061        (move_dir_horizontal ? move_dir_horizontal : move_dir_vertical));
6062     int jx = player->jx, jy = player->jy;
6063     int dx = (move_dir & MV_LEFT ? -1 : move_dir & MV_RIGHT ? +1 : 0);
6064     int dy = (move_dir & MV_UP ? -1 : move_dir & MV_DOWN ? +1 : 0);
6065     int new_jx = jx + dx, new_jy = jy + dy;
6066     boolean field_under_player_is_free =
6067       (IN_LEV_FIELD(jx, jy + 1) && IS_FREE(jx, jy + 1));
6068     boolean player_is_moving_to_valid_field =
6069       (IN_LEV_FIELD(new_jx, new_jy) &&
6070        (Feld[new_jx][new_jy] == EL_SP_BASE ||
6071         Feld[new_jx][new_jy] == EL_SAND));
6072
6073     if (field_under_player_is_free &&
6074         !player_is_moving_to_valid_field &&
6075         !IS_WALKABLE_INSIDE(Feld[jx][jy]))
6076       player->programmed_action = MV_DOWN;
6077   }
6078 }
6079
6080 /*
6081   MoveFigureOneStep()
6082   -----------------------------------------------------------------------------
6083   dx, dy:               direction (non-diagonal) to try to move the player to
6084   real_dx, real_dy:     direction as read from input device (can be diagonal)
6085 */
6086
6087 boolean MoveFigureOneStep(struct PlayerInfo *player,
6088                           int dx, int dy, int real_dx, int real_dy)
6089 {
6090   int jx = player->jx, jy = player->jy;
6091   int new_jx = jx+dx, new_jy = jy+dy;
6092   int element;
6093   int can_move;
6094
6095   if (!player->active || (!dx && !dy))
6096     return MF_NO_ACTION;
6097
6098   player->MovDir = (dx < 0 ? MV_LEFT :
6099                     dx > 0 ? MV_RIGHT :
6100                     dy < 0 ? MV_UP :
6101                     dy > 0 ? MV_DOWN :  MV_NO_MOVING);
6102
6103   if (!IN_LEV_FIELD(new_jx, new_jy))
6104     return MF_NO_ACTION;
6105
6106   if (!options.network && !AllPlayersInSight(player, new_jx, new_jy))
6107     return MF_NO_ACTION;
6108
6109 #if 0
6110   element = MovingOrBlocked2Element(new_jx, new_jy);
6111 #else
6112   element = MovingOrBlocked2ElementIfNotLeaving(new_jx, new_jy);
6113 #endif
6114
6115   if (DONT_RUN_INTO(element))
6116   {
6117     if (element == EL_ACID && dx == 0 && dy == 1)
6118     {
6119       SplashAcid(jx, jy);
6120       Feld[jx][jy] = EL_PLAYER_1;
6121       InitMovingField(jx, jy, MV_DOWN);
6122       Store[jx][jy] = EL_ACID;
6123       ContinueMoving(jx, jy);
6124       BuryHero(player);
6125     }
6126     else
6127       TestIfHeroRunsIntoBadThing(jx, jy, player->MovDir);
6128
6129     return MF_MOVING;
6130   }
6131
6132   can_move = DigField(player, new_jx, new_jy, real_dx, real_dy, DF_DIG);
6133   if (can_move != MF_MOVING)
6134     return can_move;
6135
6136   StorePlayer[jx][jy] = 0;
6137   player->last_jx = jx;
6138   player->last_jy = jy;
6139   jx = player->jx = new_jx;
6140   jy = player->jy = new_jy;
6141   StorePlayer[jx][jy] = player->element_nr;
6142
6143   player->MovPos =
6144     (dx > 0 || dy > 0 ? -1 : 1) * (TILEX - TILEX / player->move_delay_value);
6145
6146   ScrollFigure(player, SCROLL_INIT);
6147
6148   return MF_MOVING;
6149 }
6150
6151 boolean MoveFigure(struct PlayerInfo *player, int dx, int dy)
6152 {
6153   int jx = player->jx, jy = player->jy;
6154   int old_jx = jx, old_jy = jy;
6155   int moved = MF_NO_ACTION;
6156
6157   if (!player->active || (!dx && !dy))
6158     return FALSE;
6159
6160 #if 0
6161   if (!FrameReached(&player->move_delay, player->move_delay_value) &&
6162       !tape.playing)
6163     return FALSE;
6164 #else
6165   if (!FrameReached(&player->move_delay, player->move_delay_value) &&
6166       !(tape.playing && tape.file_version < FILE_VERSION_2_0))
6167     return FALSE;
6168 #endif
6169
6170   /* remove the last programmed player action */
6171   player->programmed_action = 0;
6172
6173   if (player->MovPos)
6174   {
6175     /* should only happen if pre-1.2 tape recordings are played */
6176     /* this is only for backward compatibility */
6177
6178     int original_move_delay_value = player->move_delay_value;
6179
6180 #if DEBUG
6181     printf("THIS SHOULD ONLY HAPPEN WITH PRE-1.2 LEVEL TAPES. [%ld]\n",
6182            tape.counter);
6183 #endif
6184
6185     /* scroll remaining steps with finest movement resolution */
6186     player->move_delay_value = MOVE_DELAY_NORMAL_SPEED;
6187
6188     while (player->MovPos)
6189     {
6190       ScrollFigure(player, SCROLL_GO_ON);
6191       ScrollScreen(NULL, SCROLL_GO_ON);
6192       FrameCounter++;
6193       DrawAllPlayers();
6194       BackToFront();
6195     }
6196
6197     player->move_delay_value = original_move_delay_value;
6198   }
6199
6200   if (player->last_move_dir & (MV_LEFT | MV_RIGHT))
6201   {
6202     if (!(moved |= MoveFigureOneStep(player, 0, dy, dx, dy)))
6203       moved |= MoveFigureOneStep(player, dx, 0, dx, dy);
6204   }
6205   else
6206   {
6207     if (!(moved |= MoveFigureOneStep(player, dx, 0, dx, dy)))
6208       moved |= MoveFigureOneStep(player, 0, dy, dx, dy);
6209   }
6210
6211   jx = player->jx;
6212   jy = player->jy;
6213
6214   if (moved & MF_MOVING && !ScreenMovPos &&
6215       (player == local_player || !options.network))
6216   {
6217     int old_scroll_x = scroll_x, old_scroll_y = scroll_y;
6218     int offset = (setup.scroll_delay ? 3 : 0);
6219
6220     if (!IN_VIS_FIELD(SCREENX(jx), SCREENY(jy)))
6221     {
6222       /* actual player has left the screen -- scroll in that direction */
6223       if (jx != old_jx)         /* player has moved horizontally */
6224         scroll_x += (jx - old_jx);
6225       else                      /* player has moved vertically */
6226         scroll_y += (jy - old_jy);
6227     }
6228     else
6229     {
6230       if (jx != old_jx)         /* player has moved horizontally */
6231       {
6232         if ((player->MovDir == MV_LEFT && scroll_x > jx - MIDPOSX + offset) ||
6233             (player->MovDir == MV_RIGHT && scroll_x < jx - MIDPOSX - offset))
6234           scroll_x = jx-MIDPOSX + (scroll_x < jx-MIDPOSX ? -offset : +offset);
6235
6236         /* don't scroll over playfield boundaries */
6237         if (scroll_x < SBX_Left || scroll_x > SBX_Right)
6238           scroll_x = (scroll_x < SBX_Left ? SBX_Left : SBX_Right);
6239
6240         /* don't scroll more than one field at a time */
6241         scroll_x = old_scroll_x + SIGN(scroll_x - old_scroll_x);
6242
6243         /* don't scroll against the player's moving direction */
6244         if ((player->MovDir == MV_LEFT && scroll_x > old_scroll_x) ||
6245             (player->MovDir == MV_RIGHT && scroll_x < old_scroll_x))
6246           scroll_x = old_scroll_x;
6247       }
6248       else                      /* player has moved vertically */
6249       {
6250         if ((player->MovDir == MV_UP && scroll_y > jy - MIDPOSY + offset) ||
6251             (player->MovDir == MV_DOWN && scroll_y < jy - MIDPOSY - offset))
6252           scroll_y = jy-MIDPOSY + (scroll_y < jy-MIDPOSY ? -offset : +offset);
6253
6254         /* don't scroll over playfield boundaries */
6255         if (scroll_y < SBY_Upper || scroll_y > SBY_Lower)
6256           scroll_y = (scroll_y < SBY_Upper ? SBY_Upper : SBY_Lower);
6257
6258         /* don't scroll more than one field at a time */
6259         scroll_y = old_scroll_y + SIGN(scroll_y - old_scroll_y);
6260
6261         /* don't scroll against the player's moving direction */
6262         if ((player->MovDir == MV_UP && scroll_y > old_scroll_y) ||
6263             (player->MovDir == MV_DOWN && scroll_y < old_scroll_y))
6264           scroll_y = old_scroll_y;
6265       }
6266     }
6267
6268     if (scroll_x != old_scroll_x || scroll_y != old_scroll_y)
6269     {
6270       if (!options.network && !AllPlayersInVisibleScreen())
6271       {
6272         scroll_x = old_scroll_x;
6273         scroll_y = old_scroll_y;
6274       }
6275       else
6276       {
6277         ScrollScreen(player, SCROLL_INIT);
6278         ScrollLevel(old_scroll_x - scroll_x, old_scroll_y - scroll_y);
6279       }
6280     }
6281   }
6282
6283 #if 0
6284 #if 1
6285   InitPlayerGfxAnimation(player, ACTION_DEFAULT);
6286 #else
6287   if (!(moved & MF_MOVING) && !player->Pushing)
6288     player->Frame = 0;
6289 #endif
6290 #endif
6291
6292   player->StepFrame = 0;
6293
6294   if (moved & MF_MOVING)
6295   {
6296     if (old_jx != jx && old_jy == jy)
6297       player->MovDir = (old_jx < jx ? MV_RIGHT : MV_LEFT);
6298     else if (old_jx == jx && old_jy != jy)
6299       player->MovDir = (old_jy < jy ? MV_DOWN : MV_UP);
6300
6301     DrawLevelField(jx, jy);     /* for "crumbled sand" */
6302
6303     player->last_move_dir = player->MovDir;
6304     player->is_moving = TRUE;
6305   }
6306   else
6307   {
6308     CheckGravityMovement(player);
6309
6310     /*
6311     player->last_move_dir = MV_NO_MOVING;
6312     */
6313     player->is_moving = FALSE;
6314   }
6315
6316   TestIfHeroTouchesBadThing(jx, jy);
6317   TestIfPlayerTouchesCustomElement(jx, jy);
6318
6319   if (!player->active)
6320     RemoveHero(player);
6321
6322   return moved;
6323 }
6324
6325 void ScrollFigure(struct PlayerInfo *player, int mode)
6326 {
6327   int jx = player->jx, jy = player->jy;
6328   int last_jx = player->last_jx, last_jy = player->last_jy;
6329   int move_stepsize = TILEX / player->move_delay_value;
6330
6331   if (!player->active || !player->MovPos)
6332     return;
6333
6334   if (mode == SCROLL_INIT)
6335   {
6336     player->actual_frame_counter = FrameCounter;
6337     player->GfxPos = move_stepsize * (player->MovPos / move_stepsize);
6338
6339     if (Feld[last_jx][last_jy] == EL_EMPTY)
6340       Feld[last_jx][last_jy] = EL_PLAYER_IS_LEAVING;
6341
6342     DrawPlayer(player);
6343     return;
6344   }
6345   else if (!FrameReached(&player->actual_frame_counter, 1))
6346     return;
6347
6348   player->MovPos += (player->MovPos > 0 ? -1 : 1) * move_stepsize;
6349   player->GfxPos = move_stepsize * (player->MovPos / move_stepsize);
6350
6351   if (Feld[last_jx][last_jy] == EL_PLAYER_IS_LEAVING)
6352     Feld[last_jx][last_jy] = EL_EMPTY;
6353
6354   /* before DrawPlayer() to draw correct player graphic for this case */
6355   if (player->MovPos == 0)
6356     CheckGravityMovement(player);
6357
6358   DrawPlayer(player);
6359
6360   if (player->MovPos == 0)
6361   {
6362     if (IS_PASSABLE(Feld[last_jx][last_jy]))
6363     {
6364       /* continue with normal speed after quickly moving through gate */
6365       HALVE_PLAYER_SPEED(player);
6366
6367       /* be able to make the next move without delay */
6368       player->move_delay = 0;
6369     }
6370
6371     player->last_jx = jx;
6372     player->last_jy = jy;
6373
6374     if (Feld[jx][jy] == EL_EXIT_OPEN ||
6375         Feld[jx][jy] == EL_SP_EXIT_OPEN)
6376     {
6377       RemoveHero(player);
6378
6379       if (local_player->friends_still_needed == 0 ||
6380           Feld[jx][jy] == EL_SP_EXIT_OPEN)
6381         player->LevelSolved = player->GameOver = TRUE;
6382     }
6383
6384     if (tape.single_step && tape.recording && !tape.pausing &&
6385         !player->programmed_action)
6386       TapeTogglePause(TAPE_TOGGLE_AUTOMATIC);
6387   }
6388 }
6389
6390 void ScrollScreen(struct PlayerInfo *player, int mode)
6391 {
6392   static unsigned long screen_frame_counter = 0;
6393
6394   if (mode == SCROLL_INIT)
6395   {
6396     /* set scrolling step size according to actual player's moving speed */
6397     ScrollStepSize = TILEX / player->move_delay_value;
6398
6399     screen_frame_counter = FrameCounter;
6400     ScreenMovDir = player->MovDir;
6401     ScreenMovPos = player->MovPos;
6402     ScreenGfxPos = ScrollStepSize * (ScreenMovPos / ScrollStepSize);
6403     return;
6404   }
6405   else if (!FrameReached(&screen_frame_counter, 1))
6406     return;
6407
6408   if (ScreenMovPos)
6409   {
6410     ScreenMovPos += (ScreenMovPos > 0 ? -1 : 1) * ScrollStepSize;
6411     ScreenGfxPos = ScrollStepSize * (ScreenMovPos / ScrollStepSize);
6412     redraw_mask |= REDRAW_FIELD;
6413   }
6414   else
6415     ScreenMovDir = MV_NO_MOVING;
6416 }
6417
6418 void TestIfPlayerTouchesCustomElement(int x, int y)
6419 {
6420   static boolean check_changing = FALSE;
6421   static int xy[4][2] =
6422   {
6423     { 0, -1 },
6424     { -1, 0 },
6425     { +1, 0 },
6426     { 0, +1 }
6427   };
6428   boolean center_is_player = (IS_PLAYER(x, y));
6429   int i;
6430
6431   /* prevent TestIfPlayerTouchesCustomElement() from looping */
6432   if (check_changing)
6433     return;
6434
6435   check_changing = TRUE;
6436
6437   for (i=0; i<4; i++)
6438   {
6439     int xx = x + xy[i][0];
6440     int yy = y + xy[i][1];
6441
6442     if (!IN_LEV_FIELD(xx, yy))
6443       continue;
6444
6445     if (center_is_player)
6446     {
6447       CheckTriggeredElementChange(xx, yy, Feld[xx][yy], CE_OTHER_GETS_TOUCHED);
6448       CheckElementChange(xx, yy, Feld[xx][yy], CE_TOUCHED_BY_PLAYER);
6449     }
6450     else if (IS_PLAYER(xx, yy))
6451     {
6452       CheckTriggeredElementChange(x, y, Feld[x][y], CE_OTHER_GETS_TOUCHED);
6453       CheckElementChange(x, y, Feld[x][y], CE_TOUCHED_BY_PLAYER);
6454
6455       break;
6456     }
6457   }
6458
6459   check_changing = FALSE;
6460 }
6461
6462 void TestIfElementTouchesCustomElement(int x, int y)
6463 {
6464   static boolean check_changing = FALSE;
6465   static int xy[4][2] =
6466   {
6467     { 0, -1 },
6468     { -1, 0 },
6469     { +1, 0 },
6470     { 0, +1 }
6471   };
6472   boolean center_is_custom = (IS_CUSTOM_ELEMENT(Feld[x][y]));
6473   int i;
6474
6475   /* prevent TestIfElementTouchesCustomElement() from looping */
6476   if (check_changing)
6477     return;
6478
6479   check_changing = TRUE;
6480
6481   for (i=0; i<4; i++)
6482   {
6483     int xx = x + xy[i][0];
6484     int yy = y + xy[i][1];
6485
6486     if (!IN_LEV_FIELD(xx, yy))
6487       continue;
6488
6489     if (center_is_custom &&
6490         Feld[xx][yy] == element_info[Feld[x][y]].change.trigger_element)
6491     {
6492       CheckElementChange(x, y, Feld[x][y], CE_OTHER_IS_TOUCHING);
6493     }
6494
6495     if (IS_CUSTOM_ELEMENT(Feld[xx][yy]) &&
6496         Feld[x][y] == element_info[Feld[xx][yy]].change.trigger_element)
6497     {
6498       CheckElementChange(xx, yy, Feld[xx][yy], CE_OTHER_IS_TOUCHING);
6499     }
6500   }
6501
6502   check_changing = FALSE;
6503 }
6504
6505 void TestIfGoodThingHitsBadThing(int good_x, int good_y, int good_move_dir)
6506 {
6507   int i, kill_x = -1, kill_y = -1;
6508   static int test_xy[4][2] =
6509   {
6510     { 0, -1 },
6511     { -1, 0 },
6512     { +1, 0 },
6513     { 0, +1 }
6514   };
6515   static int test_dir[4] =
6516   {
6517     MV_UP,
6518     MV_LEFT,
6519     MV_RIGHT,
6520     MV_DOWN
6521   };
6522
6523   for (i=0; i<4; i++)
6524   {
6525     int test_x, test_y, test_move_dir, test_element;
6526
6527     test_x = good_x + test_xy[i][0];
6528     test_y = good_y + test_xy[i][1];
6529     if (!IN_LEV_FIELD(test_x, test_y))
6530       continue;
6531
6532     test_move_dir =
6533       (IS_MOVING(test_x, test_y) ? MovDir[test_x][test_y] : MV_NO_MOVING);
6534
6535 #if 0
6536     test_element = Feld[test_x][test_y];
6537 #else
6538     test_element = MovingOrBlocked2ElementIfNotLeaving(test_x, test_y);
6539 #endif
6540
6541     /* 1st case: good thing is moving towards DONT_RUN_INTO style bad thing;
6542        2nd case: DONT_TOUCH style bad thing does not move away from good thing
6543     */
6544     if ((DONT_RUN_INTO(test_element) && good_move_dir == test_dir[i]) ||
6545         (DONT_TOUCH(test_element)    && test_move_dir != test_dir[i]))
6546     {
6547       kill_x = test_x;
6548       kill_y = test_y;
6549       break;
6550     }
6551   }
6552
6553   if (kill_x != -1 || kill_y != -1)
6554   {
6555     if (IS_PLAYER(good_x, good_y))
6556     {
6557       struct PlayerInfo *player = PLAYERINFO(good_x, good_y);
6558
6559       if (player->shield_deadly_time_left > 0)
6560         Bang(kill_x, kill_y);
6561       else if (!PLAYER_PROTECTED(good_x, good_y))
6562         KillHero(player);
6563     }
6564     else
6565       Bang(good_x, good_y);
6566   }
6567 }
6568
6569 void TestIfBadThingHitsGoodThing(int bad_x, int bad_y, int bad_move_dir)
6570 {
6571   int i, kill_x = -1, kill_y = -1;
6572   int bad_element = Feld[bad_x][bad_y];
6573   static int test_xy[4][2] =
6574   {
6575     { 0, -1 },
6576     { -1, 0 },
6577     { +1, 0 },
6578     { 0, +1 }
6579   };
6580   static int test_dir[4] =
6581   {
6582     MV_UP,
6583     MV_LEFT,
6584     MV_RIGHT,
6585     MV_DOWN
6586   };
6587
6588   if (bad_element == EL_EXPLOSION)      /* skip just exploding bad things */
6589     return;
6590
6591   for (i=0; i<4; i++)
6592   {
6593     int test_x, test_y, test_move_dir, test_element;
6594
6595     test_x = bad_x + test_xy[i][0];
6596     test_y = bad_y + test_xy[i][1];
6597     if (!IN_LEV_FIELD(test_x, test_y))
6598       continue;
6599
6600     test_move_dir =
6601       (IS_MOVING(test_x, test_y) ? MovDir[test_x][test_y] : MV_NO_MOVING);
6602
6603     test_element = Feld[test_x][test_y];
6604
6605     /* 1st case: good thing is moving towards DONT_RUN_INTO style bad thing;
6606        2nd case: DONT_TOUCH style bad thing does not move away from good thing
6607     */
6608     if ((DONT_RUN_INTO(bad_element) &&  bad_move_dir == test_dir[i]) ||
6609         (DONT_TOUCH(bad_element)    && test_move_dir != test_dir[i]))
6610     {
6611       /* good thing is player or penguin that does not move away */
6612       if (IS_PLAYER(test_x, test_y))
6613       {
6614         struct PlayerInfo *player = PLAYERINFO(test_x, test_y);
6615
6616         if (bad_element == EL_ROBOT && player->is_moving)
6617           continue;     /* robot does not kill player if he is moving */
6618
6619         kill_x = test_x;
6620         kill_y = test_y;
6621         break;
6622       }
6623       else if (test_element == EL_PENGUIN)
6624       {
6625         kill_x = test_x;
6626         kill_y = test_y;
6627         break;
6628       }
6629     }
6630   }
6631
6632   if (kill_x != -1 || kill_y != -1)
6633   {
6634     if (IS_PLAYER(kill_x, kill_y))
6635     {
6636       struct PlayerInfo *player = PLAYERINFO(kill_x, kill_y);
6637
6638 #if 0
6639       int dir = player->MovDir;
6640       int newx = player->jx + (dir == MV_LEFT ? -1 : dir == MV_RIGHT ? +1 : 0);
6641       int newy = player->jy + (dir == MV_UP   ? -1 : dir == MV_DOWN  ? +1 : 0);
6642
6643       if (Feld[bad_x][bad_y] == EL_ROBOT && player->is_moving &&
6644           newx != bad_x && newy != bad_y)
6645         ;       /* robot does not kill player if he is moving */
6646       else
6647         printf("-> %d\n", player->MovDir);
6648
6649       if (Feld[bad_x][bad_y] == EL_ROBOT && player->is_moving &&
6650           newx != bad_x && newy != bad_y)
6651         ;       /* robot does not kill player if he is moving */
6652       else
6653         ;
6654 #endif
6655
6656       if (player->shield_deadly_time_left > 0)
6657         Bang(bad_x, bad_y);
6658       else if (!PLAYER_PROTECTED(kill_x, kill_y))
6659         KillHero(player);
6660     }
6661     else
6662       Bang(kill_x, kill_y);
6663   }
6664 }
6665
6666 void TestIfHeroTouchesBadThing(int x, int y)
6667 {
6668   TestIfGoodThingHitsBadThing(x, y, MV_NO_MOVING);
6669 }
6670
6671 void TestIfHeroRunsIntoBadThing(int x, int y, int move_dir)
6672 {
6673   TestIfGoodThingHitsBadThing(x, y, move_dir);
6674 }
6675
6676 void TestIfBadThingTouchesHero(int x, int y)
6677 {
6678   TestIfBadThingHitsGoodThing(x, y, MV_NO_MOVING);
6679 }
6680
6681 void TestIfBadThingRunsIntoHero(int x, int y, int move_dir)
6682 {
6683   TestIfBadThingHitsGoodThing(x, y, move_dir);
6684 }
6685
6686 void TestIfFriendTouchesBadThing(int x, int y)
6687 {
6688   TestIfGoodThingHitsBadThing(x, y, MV_NO_MOVING);
6689 }
6690
6691 void TestIfBadThingTouchesFriend(int x, int y)
6692 {
6693   TestIfBadThingHitsGoodThing(x, y, MV_NO_MOVING);
6694 }
6695
6696 void TestIfBadThingTouchesOtherBadThing(int bad_x, int bad_y)
6697 {
6698   int i, kill_x = bad_x, kill_y = bad_y;
6699   static int xy[4][2] =
6700   {
6701     { 0, -1 },
6702     { -1, 0 },
6703     { +1, 0 },
6704     { 0, +1 }
6705   };
6706
6707   for (i=0; i<4; i++)
6708   {
6709     int x, y, element;
6710
6711     x = bad_x + xy[i][0];
6712     y = bad_y + xy[i][1];
6713     if (!IN_LEV_FIELD(x, y))
6714       continue;
6715
6716     element = Feld[x][y];
6717     if (IS_AMOEBOID(element) || element == EL_GAME_OF_LIFE ||
6718         element == EL_AMOEBA_GROWING || element == EL_AMOEBA_DROP)
6719     {
6720       kill_x = x;
6721       kill_y = y;
6722       break;
6723     }
6724   }
6725
6726   if (kill_x != bad_x || kill_y != bad_y)
6727     Bang(bad_x, bad_y);
6728 }
6729
6730 void KillHero(struct PlayerInfo *player)
6731 {
6732   int jx = player->jx, jy = player->jy;
6733
6734   if (!player->active)
6735     return;
6736
6737   /* remove accessible field at the player's position */
6738   Feld[jx][jy] = EL_EMPTY;
6739
6740   /* deactivate shield (else Bang()/Explode() would not work right) */
6741   player->shield_normal_time_left = 0;
6742   player->shield_deadly_time_left = 0;
6743
6744   Bang(jx, jy);
6745   BuryHero(player);
6746 }
6747
6748 static void KillHeroUnlessProtected(int x, int y)
6749 {
6750   if (!PLAYER_PROTECTED(x, y))
6751     KillHero(PLAYERINFO(x, y));
6752 }
6753
6754 void BuryHero(struct PlayerInfo *player)
6755 {
6756   int jx = player->jx, jy = player->jy;
6757
6758   if (!player->active)
6759     return;
6760
6761 #if 1
6762   PlaySoundLevelElementAction(jx, jy, player->element_nr, ACTION_DYING);
6763 #else
6764   PlaySoundLevel(jx, jy, SND_CLASS_PLAYER_DYING);
6765 #endif
6766   PlaySoundLevel(jx, jy, SND_GAME_LOSING);
6767
6768   player->GameOver = TRUE;
6769   RemoveHero(player);
6770 }
6771
6772 void RemoveHero(struct PlayerInfo *player)
6773 {
6774   int jx = player->jx, jy = player->jy;
6775   int i, found = FALSE;
6776
6777   player->present = FALSE;
6778   player->active = FALSE;
6779
6780   if (!ExplodeField[jx][jy])
6781     StorePlayer[jx][jy] = 0;
6782
6783   for (i=0; i<MAX_PLAYERS; i++)
6784     if (stored_player[i].active)
6785       found = TRUE;
6786
6787   if (!found)
6788     AllPlayersGone = TRUE;
6789
6790   ExitX = ZX = jx;
6791   ExitY = ZY = jy;
6792 }
6793
6794 /*
6795   =============================================================================
6796   checkDiagonalPushing()
6797   -----------------------------------------------------------------------------
6798   check if diagonal input device direction results in pushing of object
6799   (by checking if the alternative direction is walkable, diggable, ...)
6800   =============================================================================
6801 */
6802
6803 static boolean checkDiagonalPushing(struct PlayerInfo *player,
6804                                     int x, int y, int real_dx, int real_dy)
6805 {
6806   int jx, jy, dx, dy, xx, yy;
6807
6808   if (real_dx == 0 || real_dy == 0)     /* no diagonal direction => push */
6809     return TRUE;
6810
6811   /* diagonal direction: check alternative direction */
6812   jx = player->jx;
6813   jy = player->jy;
6814   dx = x - jx;
6815   dy = y - jy;
6816   xx = jx + (dx == 0 ? real_dx : 0);
6817   yy = jy + (dy == 0 ? real_dy : 0);
6818
6819   return (!IN_LEV_FIELD(xx, yy) || IS_SOLID_FOR_PUSHING(Feld[xx][yy]));
6820 }
6821
6822 /*
6823   =============================================================================
6824   DigField()
6825   -----------------------------------------------------------------------------
6826   x, y:                 field next to player (non-diagonal) to try to dig to
6827   real_dx, real_dy:     direction as read from input device (can be diagonal)
6828   =============================================================================
6829 */
6830
6831 int DigField(struct PlayerInfo *player,
6832              int x, int y, int real_dx, int real_dy, int mode)
6833 {
6834   boolean use_spring_bug = (game.engine_version < VERSION_IDENT(2,2,0));
6835   int jx = player->jx, jy = player->jy;
6836   int dx = x - jx, dy = y - jy;
6837   int nextx = x + dx, nexty = y + dy;
6838   int move_direction = (dx == -1 ? MV_LEFT :
6839                         dx == +1 ? MV_RIGHT :
6840                         dy == -1 ? MV_UP :
6841                         dy == +1 ? MV_DOWN : MV_NO_MOVING);
6842   int element;
6843
6844   if (player->MovPos == 0)
6845   {
6846     player->is_digging = FALSE;
6847     player->is_collecting = FALSE;
6848   }
6849
6850   if (player->MovPos == 0)      /* last pushing move finished */
6851     player->Pushing = FALSE;
6852
6853   if (mode == DF_NO_PUSH)       /* player just stopped pushing */
6854   {
6855     player->Switching = FALSE;
6856     player->push_delay = 0;
6857
6858     return MF_NO_ACTION;
6859   }
6860
6861   if (IS_MOVING(x, y) || IS_PLAYER(x, y))
6862     return MF_NO_ACTION;
6863
6864 #if 0
6865   if (IS_TUBE(Feld[jx][jy]) || IS_TUBE(Back[jx][jy]))
6866 #else
6867   if (IS_TUBE(Feld[jx][jy]) ||
6868       (IS_TUBE(Back[jx][jy]) && game.engine_version >= VERSION_IDENT(2,2,0)))
6869 #endif
6870   {
6871     int i = 0;
6872     int tube_element = (IS_TUBE(Feld[jx][jy]) ? Feld[jx][jy] : Back[jx][jy]);
6873     int tube_leave_directions[][2] =
6874     {
6875       { EL_TUBE_ANY,                    MV_LEFT | MV_RIGHT | MV_UP | MV_DOWN },
6876       { EL_TUBE_VERTICAL,                                    MV_UP | MV_DOWN },
6877       { EL_TUBE_HORIZONTAL,             MV_LEFT | MV_RIGHT                   },
6878       { EL_TUBE_VERTICAL_LEFT,          MV_LEFT |            MV_UP | MV_DOWN },
6879       { EL_TUBE_VERTICAL_RIGHT,                   MV_RIGHT | MV_UP | MV_DOWN },
6880       { EL_TUBE_HORIZONTAL_UP,          MV_LEFT | MV_RIGHT | MV_UP           },
6881       { EL_TUBE_HORIZONTAL_DOWN,        MV_LEFT | MV_RIGHT |         MV_DOWN },
6882       { EL_TUBE_LEFT_UP,                MV_LEFT |            MV_UP           },
6883       { EL_TUBE_LEFT_DOWN,              MV_LEFT |                    MV_DOWN },
6884       { EL_TUBE_RIGHT_UP,                         MV_RIGHT | MV_UP           },
6885       { EL_TUBE_RIGHT_DOWN,                       MV_RIGHT |         MV_DOWN },
6886       { -1,                             MV_LEFT | MV_RIGHT | MV_UP | MV_DOWN }
6887     };
6888
6889     while (tube_leave_directions[i][0] != tube_element)
6890     {
6891       i++;
6892       if (tube_leave_directions[i][0] == -1)    /* should not happen */
6893         break;
6894     }
6895
6896     if (!(tube_leave_directions[i][1] & move_direction))
6897       return MF_NO_ACTION;      /* tube has no opening in this direction */
6898   }
6899
6900   element = Feld[x][y];
6901
6902   if (mode == DF_SNAP && !IS_SNAPPABLE(element) &&
6903       game.engine_version >= VERSION_IDENT(2,2,0))
6904     return MF_NO_ACTION;
6905
6906   switch (element)
6907   {
6908     case EL_ROBOT_WHEEL:
6909       Feld[x][y] = EL_ROBOT_WHEEL_ACTIVE;
6910       ZX = x;
6911       ZY = y;
6912       DrawLevelField(x, y);
6913       PlaySoundLevel(x, y, SND_ROBOT_WHEEL_ACTIVATING);
6914       return MF_ACTION;
6915       break;
6916
6917     case EL_SP_TERMINAL:
6918       {
6919         int xx, yy;
6920
6921         PlaySoundLevel(x, y, SND_SP_TERMINAL_ACTIVATING);
6922
6923         for (yy=0; yy<lev_fieldy; yy++)
6924         {
6925           for (xx=0; xx<lev_fieldx; xx++)
6926           {
6927             if (Feld[xx][yy] == EL_SP_DISK_YELLOW)
6928               Bang(xx, yy);
6929             else if (Feld[xx][yy] == EL_SP_TERMINAL)
6930               Feld[xx][yy] = EL_SP_TERMINAL_ACTIVE;
6931           }
6932         }
6933
6934         return MF_ACTION;
6935       }
6936       break;
6937
6938     case EL_CONVEYOR_BELT_1_SWITCH_LEFT:
6939     case EL_CONVEYOR_BELT_1_SWITCH_MIDDLE:
6940     case EL_CONVEYOR_BELT_1_SWITCH_RIGHT:
6941     case EL_CONVEYOR_BELT_2_SWITCH_LEFT:
6942     case EL_CONVEYOR_BELT_2_SWITCH_MIDDLE:
6943     case EL_CONVEYOR_BELT_2_SWITCH_RIGHT:
6944     case EL_CONVEYOR_BELT_3_SWITCH_LEFT:
6945     case EL_CONVEYOR_BELT_3_SWITCH_MIDDLE:
6946     case EL_CONVEYOR_BELT_3_SWITCH_RIGHT:
6947     case EL_CONVEYOR_BELT_4_SWITCH_LEFT:
6948     case EL_CONVEYOR_BELT_4_SWITCH_MIDDLE:
6949     case EL_CONVEYOR_BELT_4_SWITCH_RIGHT:
6950       if (!player->Switching)
6951       {
6952         player->Switching = TRUE;
6953         ToggleBeltSwitch(x, y);
6954         PlaySoundLevel(x, y, SND_CLASS_CONVEYOR_BELT_SWITCH_ACTIVATING);
6955       }
6956       return MF_ACTION;
6957       break;
6958
6959     case EL_SWITCHGATE_SWITCH_UP:
6960     case EL_SWITCHGATE_SWITCH_DOWN:
6961       if (!player->Switching)
6962       {
6963         player->Switching = TRUE;
6964         ToggleSwitchgateSwitch(x, y);
6965         PlaySoundLevel(x, y, SND_CLASS_SWITCHGATE_SWITCH_ACTIVATING);
6966       }
6967       return MF_ACTION;
6968       break;
6969
6970     case EL_LIGHT_SWITCH:
6971     case EL_LIGHT_SWITCH_ACTIVE:
6972       if (!player->Switching)
6973       {
6974         player->Switching = TRUE;
6975         ToggleLightSwitch(x, y);
6976         PlaySoundLevel(x, y, element == EL_LIGHT_SWITCH ?
6977                        SND_LIGHT_SWITCH_ACTIVATING :
6978                        SND_LIGHT_SWITCH_DEACTIVATING);
6979       }
6980       return MF_ACTION;
6981       break;
6982
6983     case EL_TIMEGATE_SWITCH:
6984       ActivateTimegateSwitch(x, y);
6985       PlaySoundLevel(x, y, SND_TIMEGATE_SWITCH_ACTIVATING);
6986
6987       return MF_ACTION;
6988       break;
6989
6990     case EL_BALLOON_SWITCH_LEFT:
6991     case EL_BALLOON_SWITCH_RIGHT:
6992     case EL_BALLOON_SWITCH_UP:
6993     case EL_BALLOON_SWITCH_DOWN:
6994     case EL_BALLOON_SWITCH_ANY:
6995       if (element == EL_BALLOON_SWITCH_ANY)
6996         game.balloon_dir = move_direction;
6997       else
6998         game.balloon_dir = (element == EL_BALLOON_SWITCH_LEFT  ? MV_LEFT :
6999                             element == EL_BALLOON_SWITCH_RIGHT ? MV_RIGHT :
7000                             element == EL_BALLOON_SWITCH_UP    ? MV_UP :
7001                             element == EL_BALLOON_SWITCH_DOWN  ? MV_DOWN :
7002                             MV_NO_MOVING);
7003       PlaySoundLevel(x, y, SND_CLASS_BALLOON_SWITCH_ACTIVATING);
7004
7005       return MF_ACTION;
7006       break;
7007
7008     case EL_SP_PORT_LEFT:
7009     case EL_SP_PORT_RIGHT:
7010     case EL_SP_PORT_UP:
7011     case EL_SP_PORT_DOWN:
7012     case EL_SP_PORT_HORIZONTAL:
7013     case EL_SP_PORT_VERTICAL:
7014     case EL_SP_PORT_ANY:
7015     case EL_SP_GRAVITY_PORT_LEFT:
7016     case EL_SP_GRAVITY_PORT_RIGHT:
7017     case EL_SP_GRAVITY_PORT_UP:
7018     case EL_SP_GRAVITY_PORT_DOWN:
7019       if ((dx == -1 &&
7020            element != EL_SP_PORT_LEFT &&
7021            element != EL_SP_GRAVITY_PORT_LEFT &&
7022            element != EL_SP_PORT_HORIZONTAL &&
7023            element != EL_SP_PORT_ANY) ||
7024           (dx == +1 &&
7025            element != EL_SP_PORT_RIGHT &&
7026            element != EL_SP_GRAVITY_PORT_RIGHT &&
7027            element != EL_SP_PORT_HORIZONTAL &&
7028            element != EL_SP_PORT_ANY) ||
7029           (dy == -1 &&
7030            element != EL_SP_PORT_UP &&
7031            element != EL_SP_GRAVITY_PORT_UP &&
7032            element != EL_SP_PORT_VERTICAL &&
7033            element != EL_SP_PORT_ANY) ||
7034           (dy == +1 &&
7035            element != EL_SP_PORT_DOWN &&
7036            element != EL_SP_GRAVITY_PORT_DOWN &&
7037            element != EL_SP_PORT_VERTICAL &&
7038            element != EL_SP_PORT_ANY) ||
7039           !IN_LEV_FIELD(nextx, nexty) ||
7040           !IS_FREE(nextx, nexty))
7041         return MF_NO_ACTION;
7042
7043       /* automatically move to the next field with double speed */
7044       player->programmed_action = move_direction;
7045       DOUBLE_PLAYER_SPEED(player);
7046
7047       PlaySoundLevel(x, y, SND_CLASS_SP_PORT_PASSING);
7048       break;
7049
7050     case EL_TUBE_ANY:
7051     case EL_TUBE_VERTICAL:
7052     case EL_TUBE_HORIZONTAL:
7053     case EL_TUBE_VERTICAL_LEFT:
7054     case EL_TUBE_VERTICAL_RIGHT:
7055     case EL_TUBE_HORIZONTAL_UP:
7056     case EL_TUBE_HORIZONTAL_DOWN:
7057     case EL_TUBE_LEFT_UP:
7058     case EL_TUBE_LEFT_DOWN:
7059     case EL_TUBE_RIGHT_UP:
7060     case EL_TUBE_RIGHT_DOWN:
7061       {
7062         int i = 0;
7063         int tube_enter_directions[][2] =
7064         {
7065           { EL_TUBE_ANY,                MV_LEFT | MV_RIGHT | MV_UP | MV_DOWN },
7066           { EL_TUBE_VERTICAL,                                MV_UP | MV_DOWN },
7067           { EL_TUBE_HORIZONTAL,         MV_LEFT | MV_RIGHT                   },
7068           { EL_TUBE_VERTICAL_LEFT,                MV_RIGHT | MV_UP | MV_DOWN },
7069           { EL_TUBE_VERTICAL_RIGHT,     MV_LEFT            | MV_UP | MV_DOWN },
7070           { EL_TUBE_HORIZONTAL_UP,      MV_LEFT | MV_RIGHT |         MV_DOWN },
7071           { EL_TUBE_HORIZONTAL_DOWN,    MV_LEFT | MV_RIGHT | MV_UP           },
7072           { EL_TUBE_LEFT_UP,                      MV_RIGHT |         MV_DOWN },
7073           { EL_TUBE_LEFT_DOWN,                    MV_RIGHT | MV_UP           },
7074           { EL_TUBE_RIGHT_UP,           MV_LEFT |                    MV_DOWN },
7075           { EL_TUBE_RIGHT_DOWN,         MV_LEFT |            MV_UP           },
7076           { -1,                         MV_NO_MOVING                         }
7077         };
7078
7079         while (tube_enter_directions[i][0] != element)
7080         {
7081           i++;
7082           if (tube_enter_directions[i][0] == -1)        /* should not happen */
7083             break;
7084         }
7085
7086         if (!(tube_enter_directions[i][1] & move_direction))
7087           return MF_NO_ACTION;  /* tube has no opening in this direction */
7088
7089         PlaySoundLevel(x, y, SND_CLASS_TUBE_WALKING);
7090       }
7091       break;
7092
7093     case EL_LAMP:
7094       Feld[x][y] = EL_LAMP_ACTIVE;
7095       local_player->lights_still_needed--;
7096       DrawLevelField(x, y);
7097       PlaySoundLevel(x, y, SND_LAMP_ACTIVATING);
7098       return MF_ACTION;
7099       break;
7100
7101     case EL_TIME_ORB_FULL:
7102       Feld[x][y] = EL_TIME_ORB_EMPTY;
7103       TimeLeft += 10;
7104       DrawText(DX_TIME, DY_TIME, int2str(TimeLeft, 3), FONT_TEXT_2);
7105       DrawLevelField(x, y);
7106       PlaySoundStereo(SND_TIME_ORB_FULL_COLLECTING, SOUND_MIDDLE);
7107       return MF_ACTION;
7108       break;
7109
7110     default:
7111
7112       if (IS_WALKABLE(element))
7113       {
7114         int sound_action = ACTION_WALKING;
7115
7116         if (element >= EL_GATE_1 && element <= EL_GATE_4)
7117         {
7118           if (!player->key[element - EL_GATE_1])
7119             return MF_NO_ACTION;
7120         }
7121         else if (element >= EL_GATE_1_GRAY && element <= EL_GATE_4_GRAY)
7122         {
7123           if (!player->key[element - EL_GATE_1_GRAY])
7124             return MF_NO_ACTION;
7125         }
7126         else if (element == EL_EXIT_OPEN || element == EL_SP_EXIT_OPEN)
7127         {
7128           sound_action = ACTION_PASSING;        /* player is passing exit */
7129         }
7130         else if (element == EL_EMPTY)
7131         {
7132           sound_action = ACTION_MOVING;         /* nothing to walk on */
7133         }
7134
7135         /* play sound from background or player, whatever is available */
7136         if (element_info[element].sound[sound_action] != SND_UNDEFINED)
7137           PlaySoundLevelElementAction(x, y, element, sound_action);
7138         else
7139           PlaySoundLevelElementAction(x, y, player->element_nr, sound_action);
7140
7141         break;
7142       }
7143       else if (IS_PASSABLE(element))
7144       {
7145         if (!IN_LEV_FIELD(nextx, nexty) || !IS_FREE(nextx, nexty))
7146           return MF_NO_ACTION;
7147
7148         if (element >= EL_EM_GATE_1 && element <= EL_EM_GATE_4)
7149         {
7150           if (!player->key[element - EL_EM_GATE_1])
7151             return MF_NO_ACTION;
7152         }
7153         else if (element >= EL_EM_GATE_1_GRAY && element <= EL_EM_GATE_4_GRAY)
7154         {
7155           if (!player->key[element - EL_EM_GATE_1_GRAY])
7156             return MF_NO_ACTION;
7157         }
7158
7159         /* automatically move to the next field with double speed */
7160         player->programmed_action = move_direction;
7161         DOUBLE_PLAYER_SPEED(player);
7162
7163         PlaySoundLevelAction(x, y, ACTION_PASSING);
7164
7165         break;
7166       }
7167       else if (IS_DIGGABLE(element))
7168       {
7169         RemoveField(x, y);
7170
7171         if (mode != DF_SNAP)
7172         {
7173           GfxElement[x][y] =
7174             (CAN_BE_CRUMBLED(element) ? EL_SAND : GFX_ELEMENT(element));
7175           player->is_digging = TRUE;
7176         }
7177
7178         PlaySoundLevelElementAction(x, y, element, ACTION_DIGGING);
7179
7180         break;
7181       }
7182       else if (IS_COLLECTIBLE(element))
7183       {
7184         RemoveField(x, y);
7185
7186         if (mode != DF_SNAP)
7187         {
7188           GfxElement[x][y] = element;
7189           player->is_collecting = TRUE;
7190         }
7191
7192         if (element == EL_SPEED_PILL)
7193           player->move_delay_value = MOVE_DELAY_HIGH_SPEED;
7194         else if (element == EL_EXTRA_TIME && level.time > 0)
7195         {
7196           TimeLeft += 10;
7197           DrawText(DX_TIME, DY_TIME, int2str(TimeLeft, 3), FONT_TEXT_2);
7198         }
7199         else if (element == EL_SHIELD_NORMAL || element == EL_SHIELD_DEADLY)
7200         {
7201           player->shield_normal_time_left += 10;
7202           if (element == EL_SHIELD_DEADLY)
7203             player->shield_deadly_time_left += 10;
7204         }
7205         else if (element == EL_DYNAMITE || element == EL_SP_DISK_RED)
7206         {
7207           player->dynamite++;
7208           player->use_disk_red_graphic = (element == EL_SP_DISK_RED);
7209
7210           DrawText(DX_DYNAMITE, DY_DYNAMITE,
7211                    int2str(local_player->dynamite, 3), FONT_TEXT_2);
7212         }
7213         else if (element == EL_DYNABOMB_INCREASE_NUMBER)
7214         {
7215           player->dynabomb_count++;
7216           player->dynabombs_left++;
7217         }
7218         else if (element == EL_DYNABOMB_INCREASE_SIZE)
7219         {
7220           player->dynabomb_size++;
7221         }
7222         else if (element == EL_DYNABOMB_INCREASE_POWER)
7223         {
7224           player->dynabomb_xl = TRUE;
7225         }
7226         else if ((element >= EL_KEY_1 && element <= EL_KEY_4) ||
7227                  (element >= EL_EM_KEY_1 && element <= EL_EM_KEY_4))
7228         {
7229           int key_nr = (element >= EL_KEY_1 && element <= EL_KEY_4 ?
7230                         element - EL_KEY_1 : element - EL_EM_KEY_1);
7231
7232           player->key[key_nr] = TRUE;
7233
7234           DrawMiniGraphicExt(drawto, DX_KEYS + key_nr * MINI_TILEX, DY_KEYS,
7235                              el2edimg(EL_KEY_1 + key_nr));
7236           redraw_mask |= REDRAW_DOOR_1;
7237         }
7238         else if (element_info[element].gem_count > 0)
7239         {
7240           local_player->gems_still_needed -=
7241             element_info[element].gem_count;
7242           if (local_player->gems_still_needed < 0)
7243             local_player->gems_still_needed = 0;
7244
7245           DrawText(DX_EMERALDS, DY_EMERALDS,
7246                    int2str(local_player->gems_still_needed, 3), FONT_TEXT_2);
7247         }
7248
7249         RaiseScoreElement(element);
7250         PlaySoundLevelElementAction(x, y, element, ACTION_COLLECTING);
7251
7252         CheckTriggeredElementChange(x, y, element, CE_OTHER_GETS_COLLECTED);
7253
7254         break;
7255       }
7256       else if (IS_PUSHABLE(element))
7257       {
7258         if (mode == DF_SNAP && element != EL_BD_ROCK)
7259           return MF_NO_ACTION;
7260
7261         if (CAN_FALL(element) && dy)
7262           return MF_NO_ACTION;
7263
7264         if (CAN_FALL(element) && IN_LEV_FIELD(x, y + 1) && IS_FREE(x, y + 1) &&
7265             !(element == EL_SPRING && use_spring_bug))
7266           return MF_NO_ACTION;
7267
7268         if (element == EL_SPRING && MovDir[x][y] != MV_NO_MOVING)
7269           return MF_NO_ACTION;
7270
7271         if (!player->Pushing &&
7272             game.engine_version >= RELEASE_IDENT(2,2,0,7))
7273           player->push_delay_value = GET_NEW_PUSH_DELAY(element);
7274
7275         player->Pushing = TRUE;
7276
7277         if (!(IN_LEV_FIELD(nextx, nexty) &&
7278               (IS_FREE(nextx, nexty) ||
7279                (Feld[nextx][nexty] == EL_SOKOBAN_FIELD_EMPTY &&
7280                 IS_SB_ELEMENT(element)))))
7281           return MF_NO_ACTION;
7282
7283         if (!checkDiagonalPushing(player, x, y, real_dx, real_dy))
7284           return MF_NO_ACTION;
7285
7286         if (player->push_delay == 0)    /* new pushing; restart delay */
7287           player->push_delay = FrameCounter;
7288
7289         if (!FrameReached(&player->push_delay, player->push_delay_value) &&
7290             !(tape.playing && tape.file_version < FILE_VERSION_2_0) &&
7291             element != EL_SPRING && element != EL_BALLOON)
7292           return MF_NO_ACTION;
7293
7294         if (IS_SB_ELEMENT(element))
7295         {
7296           if (element == EL_SOKOBAN_FIELD_FULL)
7297           {
7298             Back[x][y] = EL_SOKOBAN_FIELD_EMPTY;
7299             local_player->sokobanfields_still_needed++;
7300           }
7301
7302           if (Feld[nextx][nexty] == EL_SOKOBAN_FIELD_EMPTY)
7303           {
7304             Back[nextx][nexty] = EL_SOKOBAN_FIELD_EMPTY;
7305             local_player->sokobanfields_still_needed--;
7306           }
7307
7308           Feld[x][y] = EL_SOKOBAN_OBJECT;
7309
7310           if (Back[x][y] == Back[nextx][nexty])
7311             PlaySoundLevelAction(x, y, ACTION_PUSHING);
7312           else if (Back[x][y] != 0)
7313             PlaySoundLevelElementAction(x, y, EL_SOKOBAN_FIELD_FULL,
7314                                         ACTION_EMPTYING);
7315           else
7316             PlaySoundLevelElementAction(nextx, nexty, EL_SOKOBAN_FIELD_EMPTY,
7317                                         ACTION_FILLING);
7318
7319           if (local_player->sokobanfields_still_needed == 0 &&
7320               game.emulation == EMU_SOKOBAN)
7321           {
7322             player->LevelSolved = player->GameOver = TRUE;
7323             PlaySoundLevel(x, y, SND_GAME_SOKOBAN_SOLVING);
7324           }
7325         }
7326         else
7327           PlaySoundLevelElementAction(x, y, element, ACTION_PUSHING);
7328
7329         InitMovingField(x, y, move_direction);
7330
7331         if (mode == DF_SNAP)
7332           ContinueMoving(x, y);
7333         else
7334           MovPos[x][y] = (dx != 0 ? dx : dy);
7335
7336         Pushed[x][y] = TRUE;
7337         Pushed[nextx][nexty] = TRUE;
7338
7339         if (game.engine_version < RELEASE_IDENT(2,2,0,7))
7340           player->push_delay_value = GET_NEW_PUSH_DELAY(element);
7341
7342         CheckTriggeredElementChange(x, y, element, CE_OTHER_GETS_PUSHED);
7343         CheckElementChange(x, y, element, CE_PUSHED_BY_PLAYER);
7344
7345         break;
7346       }
7347       else
7348       {
7349         CheckTriggeredElementChange(x, y, element, CE_OTHER_GETS_PRESSED);
7350         CheckElementChange(x, y, element, CE_PRESSED_BY_PLAYER);
7351       }
7352
7353       return MF_NO_ACTION;
7354   }
7355
7356   player->push_delay = 0;
7357
7358   if (Feld[x][y] != element)            /* really digged/collected something */
7359     player->is_collecting = !player->is_digging;
7360
7361   return MF_MOVING;
7362 }
7363
7364 boolean SnapField(struct PlayerInfo *player, int dx, int dy)
7365 {
7366   int jx = player->jx, jy = player->jy;
7367   int x = jx + dx, y = jy + dy;
7368   int snap_direction = (dx == -1 ? MV_LEFT :
7369                         dx == +1 ? MV_RIGHT :
7370                         dy == -1 ? MV_UP :
7371                         dy == +1 ? MV_DOWN : MV_NO_MOVING);
7372
7373   if (player->MovPos && game.engine_version >= VERSION_IDENT(2,2,0))
7374     return FALSE;
7375
7376   if (!player->active || !IN_LEV_FIELD(x, y))
7377     return FALSE;
7378
7379   if (dx && dy)
7380     return FALSE;
7381
7382   if (!dx && !dy)
7383   {
7384     if (player->MovPos == 0)
7385       player->Pushing = FALSE;
7386
7387     player->snapped = FALSE;
7388
7389     if (player->MovPos == 0)
7390     {
7391       player->is_digging = FALSE;
7392       player->is_collecting = FALSE;
7393     }
7394
7395     return FALSE;
7396   }
7397
7398   if (player->snapped)
7399     return FALSE;
7400
7401   player->MovDir = snap_direction;
7402
7403   if (DigField(player, x, y, 0, 0, DF_SNAP) == MF_NO_ACTION)
7404     return FALSE;
7405
7406   player->snapped = TRUE;
7407   player->is_digging = FALSE;
7408   player->is_collecting = FALSE;
7409
7410   DrawLevelField(x, y);
7411   BackToFront();
7412
7413   return TRUE;
7414 }
7415
7416 boolean PlaceBomb(struct PlayerInfo *player)
7417 {
7418   int jx = player->jx, jy = player->jy;
7419   int element;
7420
7421   if (!player->active || player->MovPos)
7422     return FALSE;
7423
7424   element = Feld[jx][jy];
7425
7426   if ((player->dynamite == 0 && player->dynabombs_left == 0) ||
7427       IS_ACTIVE_BOMB(element) || element == EL_EXPLOSION)
7428     return FALSE;
7429
7430 #if 0
7431   if (element != EL_EMPTY)
7432     return FALSE;
7433 #endif
7434
7435   if (element != EL_EMPTY)
7436   {
7437 #if 0
7438     Store[jx][jy] = element;
7439 #else
7440     Back[jx][jy] = element;
7441 #endif
7442   }
7443
7444   MovDelay[jx][jy] = 96;
7445
7446   ResetGfxAnimation(jx, jy);
7447   ResetRandomAnimationValue(jx, jy);
7448
7449   if (player->dynamite)
7450   {
7451     Feld[jx][jy] = (player->use_disk_red_graphic ? EL_SP_DISK_RED_ACTIVE :
7452                     EL_DYNAMITE_ACTIVE);
7453     player->dynamite--;
7454
7455     DrawText(DX_DYNAMITE, DY_DYNAMITE, int2str(local_player->dynamite, 3),
7456              FONT_TEXT_2);
7457     if (IN_SCR_FIELD(SCREENX(jx), SCREENY(jy)))
7458     {
7459 #if 1
7460       DrawGraphicThruMask(SCREENX(jx), SCREENY(jy), el2img(Feld[jx][jy]), 0);
7461 #else
7462       if (game.emulation == EMU_SUPAPLEX)
7463         DrawGraphic(SCREENX(jx), SCREENY(jy), IMG_SP_DISK_RED, 0);
7464       else
7465         DrawGraphicThruMask(SCREENX(jx), SCREENY(jy), IMG_DYNAMITE_ACTIVE, 0);
7466 #endif
7467     }
7468
7469     PlaySoundLevelAction(jx, jy, ACTION_DROPPING);
7470   }
7471   else
7472   {
7473     Feld[jx][jy] =
7474       EL_DYNABOMB_PLAYER_1_ACTIVE + (player->element_nr - EL_PLAYER_1);
7475     player->dynabombs_left--;
7476
7477     if (IN_SCR_FIELD(SCREENX(jx), SCREENY(jy)))
7478       DrawGraphicThruMask(SCREENX(jx), SCREENY(jy), el2img(Feld[jx][jy]), 0);
7479
7480     PlaySoundLevelAction(jx, jy, ACTION_DROPPING);
7481   }
7482
7483   return TRUE;
7484 }
7485
7486 /* ------------------------------------------------------------------------- */
7487 /* game sound playing functions                                              */
7488 /* ------------------------------------------------------------------------- */
7489
7490 static int *loop_sound_frame = NULL;
7491 static int *loop_sound_volume = NULL;
7492
7493 void InitPlaySoundLevel()
7494 {
7495   int num_sounds = getSoundListSize();
7496
7497   if (loop_sound_frame != NULL)
7498     free(loop_sound_frame);
7499
7500   if (loop_sound_volume != NULL)
7501     free(loop_sound_volume);
7502
7503   loop_sound_frame = checked_calloc(num_sounds * sizeof(int));
7504   loop_sound_volume = checked_calloc(num_sounds * sizeof(int));
7505 }
7506
7507 static void PlaySoundLevel(int x, int y, int nr)
7508 {
7509   int sx = SCREENX(x), sy = SCREENY(y);
7510   int volume, stereo_position;
7511   int max_distance = 8;
7512   int type = (IS_LOOP_SOUND(nr) ? SND_CTRL_PLAY_LOOP : SND_CTRL_PLAY_SOUND);
7513
7514   if ((!setup.sound_simple && !IS_LOOP_SOUND(nr)) ||
7515       (!setup.sound_loops && IS_LOOP_SOUND(nr)))
7516     return;
7517
7518   if (!IN_LEV_FIELD(x, y) ||
7519       sx < -max_distance || sx >= SCR_FIELDX + max_distance ||
7520       sy < -max_distance || sy >= SCR_FIELDY + max_distance)
7521     return;
7522
7523   volume = SOUND_MAX_VOLUME;
7524
7525   if (!IN_SCR_FIELD(sx, sy))
7526   {
7527     int dx = ABS(sx - SCR_FIELDX / 2) - SCR_FIELDX / 2;
7528     int dy = ABS(sy - SCR_FIELDY / 2) - SCR_FIELDY / 2;
7529
7530     volume -= volume * (dx > dy ? dx : dy) / max_distance;
7531   }
7532
7533   stereo_position = (SOUND_MAX_LEFT +
7534                      (sx + max_distance) * SOUND_MAX_LEFT2RIGHT /
7535                      (SCR_FIELDX + 2 * max_distance));
7536
7537   if (IS_LOOP_SOUND(nr))
7538   {
7539     /* This assures that quieter loop sounds do not overwrite louder ones,
7540        while restarting sound volume comparison with each new game frame. */
7541
7542     if (loop_sound_volume[nr] > volume && loop_sound_frame[nr] == FrameCounter)
7543       return;
7544
7545     loop_sound_volume[nr] = volume;
7546     loop_sound_frame[nr] = FrameCounter;
7547   }
7548
7549   PlaySoundExt(nr, volume, stereo_position, type);
7550 }
7551
7552 static void PlaySoundLevelNearest(int x, int y, int sound_action)
7553 {
7554   PlaySoundLevel(x < LEVELX(BX1) ? LEVELX(BX1) :
7555                  x > LEVELX(BX2) ? LEVELX(BX2) : x,
7556                  y < LEVELY(BY1) ? LEVELY(BY1) :
7557                  y > LEVELY(BY2) ? LEVELY(BY2) : y,
7558                  sound_action);
7559 }
7560
7561 static void PlaySoundLevelAction(int x, int y, int action)
7562 {
7563   PlaySoundLevelElementAction(x, y, Feld[x][y], action);
7564 }
7565
7566 static void PlaySoundLevelElementAction(int x, int y, int element, int action)
7567 {
7568   int sound_effect = element_info[element].sound[action];
7569
7570   if (sound_effect != SND_UNDEFINED)
7571     PlaySoundLevel(x, y, sound_effect);
7572 }
7573
7574 static void PlaySoundLevelActionIfLoop(int x, int y, int action)
7575 {
7576   int sound_effect = element_info[Feld[x][y]].sound[action];
7577
7578   if (sound_effect != SND_UNDEFINED && IS_LOOP_SOUND(sound_effect))
7579     PlaySoundLevel(x, y, sound_effect);
7580 }
7581
7582 static void StopSoundLevelActionIfLoop(int x, int y, int action)
7583 {
7584   int sound_effect = element_info[Feld[x][y]].sound[action];
7585
7586   if (sound_effect != SND_UNDEFINED && IS_LOOP_SOUND(sound_effect))
7587     StopSoundExt(sound_effect, SND_CTRL_STOP_SOUND);
7588 }
7589
7590 void RaiseScore(int value)
7591 {
7592   local_player->score += value;
7593   DrawText(DX_SCORE, DY_SCORE, int2str(local_player->score, 5), FONT_TEXT_2);
7594 }
7595
7596 void RaiseScoreElement(int element)
7597 {
7598   switch(element)
7599   {
7600     case EL_EMERALD:
7601     case EL_BD_DIAMOND:
7602     case EL_EMERALD_YELLOW:
7603     case EL_EMERALD_RED:
7604     case EL_EMERALD_PURPLE:
7605     case EL_SP_INFOTRON:
7606       RaiseScore(level.score[SC_EMERALD]);
7607       break;
7608     case EL_DIAMOND:
7609       RaiseScore(level.score[SC_DIAMOND]);
7610       break;
7611     case EL_CRYSTAL:
7612       RaiseScore(level.score[SC_CRYSTAL]);
7613       break;
7614     case EL_PEARL:
7615       RaiseScore(level.score[SC_PEARL]);
7616       break;
7617     case EL_BUG:
7618     case EL_BD_BUTTERFLY:
7619     case EL_SP_ELECTRON:
7620       RaiseScore(level.score[SC_BUG]);
7621       break;
7622     case EL_SPACESHIP:
7623     case EL_BD_FIREFLY:
7624     case EL_SP_SNIKSNAK:
7625       RaiseScore(level.score[SC_SPACESHIP]);
7626       break;
7627     case EL_YAMYAM:
7628     case EL_DARK_YAMYAM:
7629       RaiseScore(level.score[SC_YAMYAM]);
7630       break;
7631     case EL_ROBOT:
7632       RaiseScore(level.score[SC_ROBOT]);
7633       break;
7634     case EL_PACMAN:
7635       RaiseScore(level.score[SC_PACMAN]);
7636       break;
7637     case EL_NUT:
7638       RaiseScore(level.score[SC_NUT]);
7639       break;
7640     case EL_DYNAMITE:
7641     case EL_SP_DISK_RED:
7642     case EL_DYNABOMB_INCREASE_NUMBER:
7643     case EL_DYNABOMB_INCREASE_SIZE:
7644     case EL_DYNABOMB_INCREASE_POWER:
7645       RaiseScore(level.score[SC_DYNAMITE]);
7646       break;
7647     case EL_SHIELD_NORMAL:
7648     case EL_SHIELD_DEADLY:
7649       RaiseScore(level.score[SC_SHIELD]);
7650       break;
7651     case EL_EXTRA_TIME:
7652       RaiseScore(level.score[SC_TIME_BONUS]);
7653       break;
7654     case EL_KEY_1:
7655     case EL_KEY_2:
7656     case EL_KEY_3:
7657     case EL_KEY_4:
7658       RaiseScore(level.score[SC_KEY]);
7659       break;
7660     default:
7661       RaiseScore(element_info[element].score);
7662       break;
7663   }
7664 }
7665
7666 void RequestQuitGame(boolean ask_if_really_quit)
7667 {
7668   if (AllPlayersGone ||
7669       !ask_if_really_quit ||
7670       level_editor_test_game ||
7671       Request("Do you really want to quit the game ?",
7672               REQ_ASK | REQ_STAY_CLOSED))
7673   {
7674 #if defined(PLATFORM_UNIX)
7675     if (options.network)
7676       SendToServer_StopPlaying();
7677     else
7678 #endif
7679     {
7680       game_status = GAME_MODE_MAIN;
7681       DrawMainMenu();
7682     }
7683   }
7684   else
7685   {
7686     OpenDoor(DOOR_OPEN_1 | DOOR_COPY_BACK);
7687   }
7688 }
7689
7690
7691 /* ---------- new game button stuff ---------------------------------------- */
7692
7693 /* graphic position values for game buttons */
7694 #define GAME_BUTTON_XSIZE       30
7695 #define GAME_BUTTON_YSIZE       30
7696 #define GAME_BUTTON_XPOS        5
7697 #define GAME_BUTTON_YPOS        215
7698 #define SOUND_BUTTON_XPOS       5
7699 #define SOUND_BUTTON_YPOS       (GAME_BUTTON_YPOS + GAME_BUTTON_YSIZE)
7700
7701 #define GAME_BUTTON_STOP_XPOS   (GAME_BUTTON_XPOS + 0 * GAME_BUTTON_XSIZE)
7702 #define GAME_BUTTON_PAUSE_XPOS  (GAME_BUTTON_XPOS + 1 * GAME_BUTTON_XSIZE)
7703 #define GAME_BUTTON_PLAY_XPOS   (GAME_BUTTON_XPOS + 2 * GAME_BUTTON_XSIZE)
7704 #define SOUND_BUTTON_MUSIC_XPOS (SOUND_BUTTON_XPOS + 0 * GAME_BUTTON_XSIZE)
7705 #define SOUND_BUTTON_LOOPS_XPOS (SOUND_BUTTON_XPOS + 1 * GAME_BUTTON_XSIZE)
7706 #define SOUND_BUTTON_SIMPLE_XPOS (SOUND_BUTTON_XPOS + 2 * GAME_BUTTON_XSIZE)
7707
7708 static struct
7709 {
7710   int x, y;
7711   int gadget_id;
7712   char *infotext;
7713 } gamebutton_info[NUM_GAME_BUTTONS] =
7714 {
7715   {
7716     GAME_BUTTON_STOP_XPOS,      GAME_BUTTON_YPOS,
7717     GAME_CTRL_ID_STOP,
7718     "stop game"
7719   },
7720   {
7721     GAME_BUTTON_PAUSE_XPOS,     GAME_BUTTON_YPOS,
7722     GAME_CTRL_ID_PAUSE,
7723     "pause game"
7724   },
7725   {
7726     GAME_BUTTON_PLAY_XPOS,      GAME_BUTTON_YPOS,
7727     GAME_CTRL_ID_PLAY,
7728     "play game"
7729   },
7730   {
7731     SOUND_BUTTON_MUSIC_XPOS,    SOUND_BUTTON_YPOS,
7732     SOUND_CTRL_ID_MUSIC,
7733     "background music on/off"
7734   },
7735   {
7736     SOUND_BUTTON_LOOPS_XPOS,    SOUND_BUTTON_YPOS,
7737     SOUND_CTRL_ID_LOOPS,
7738     "sound loops on/off"
7739   },
7740   {
7741     SOUND_BUTTON_SIMPLE_XPOS,   SOUND_BUTTON_YPOS,
7742     SOUND_CTRL_ID_SIMPLE,
7743     "normal sounds on/off"
7744   }
7745 };
7746
7747 void CreateGameButtons()
7748 {
7749   int i;
7750
7751   for (i=0; i<NUM_GAME_BUTTONS; i++)
7752   {
7753     Bitmap *gd_bitmap = graphic_info[IMG_GLOBAL_DOOR].bitmap;
7754     struct GadgetInfo *gi;
7755     int button_type;
7756     boolean checked;
7757     unsigned long event_mask;
7758     int gd_xoffset, gd_yoffset;
7759     int gd_x1, gd_x2, gd_y1, gd_y2;
7760     int id = i;
7761
7762     gd_xoffset = gamebutton_info[i].x;
7763     gd_yoffset = gamebutton_info[i].y;
7764     gd_x1 = DOOR_GFX_PAGEX4 + gd_xoffset;
7765     gd_x2 = DOOR_GFX_PAGEX3 + gd_xoffset;
7766
7767     if (id == GAME_CTRL_ID_STOP ||
7768         id == GAME_CTRL_ID_PAUSE ||
7769         id == GAME_CTRL_ID_PLAY)
7770     {
7771       button_type = GD_TYPE_NORMAL_BUTTON;
7772       checked = FALSE;
7773       event_mask = GD_EVENT_RELEASED;
7774       gd_y1  = DOOR_GFX_PAGEY1 + gd_yoffset - GAME_BUTTON_YSIZE;
7775       gd_y2  = DOOR_GFX_PAGEY1 + gd_yoffset - GAME_BUTTON_YSIZE;
7776     }
7777     else
7778     {
7779       button_type = GD_TYPE_CHECK_BUTTON;
7780       checked =
7781         ((id == SOUND_CTRL_ID_MUSIC && setup.sound_music) ||
7782          (id == SOUND_CTRL_ID_LOOPS && setup.sound_loops) ||
7783          (id == SOUND_CTRL_ID_SIMPLE && setup.sound_simple) ? TRUE : FALSE);
7784       event_mask = GD_EVENT_PRESSED;
7785       gd_y1  = DOOR_GFX_PAGEY1 + gd_yoffset;
7786       gd_y2  = DOOR_GFX_PAGEY1 + gd_yoffset - GAME_BUTTON_YSIZE;
7787     }
7788
7789     gi = CreateGadget(GDI_CUSTOM_ID, id,
7790                       GDI_INFO_TEXT, gamebutton_info[i].infotext,
7791                       GDI_X, DX + gd_xoffset,
7792                       GDI_Y, DY + gd_yoffset,
7793                       GDI_WIDTH, GAME_BUTTON_XSIZE,
7794                       GDI_HEIGHT, GAME_BUTTON_YSIZE,
7795                       GDI_TYPE, button_type,
7796                       GDI_STATE, GD_BUTTON_UNPRESSED,
7797                       GDI_CHECKED, checked,
7798                       GDI_DESIGN_UNPRESSED, gd_bitmap, gd_x1, gd_y1,
7799                       GDI_DESIGN_PRESSED, gd_bitmap, gd_x2, gd_y1,
7800                       GDI_ALT_DESIGN_UNPRESSED, gd_bitmap, gd_x1, gd_y2,
7801                       GDI_ALT_DESIGN_PRESSED, gd_bitmap, gd_x2, gd_y2,
7802                       GDI_EVENT_MASK, event_mask,
7803                       GDI_CALLBACK_ACTION, HandleGameButtons,
7804                       GDI_END);
7805
7806     if (gi == NULL)
7807       Error(ERR_EXIT, "cannot create gadget");
7808
7809     game_gadget[id] = gi;
7810   }
7811 }
7812
7813 void FreeGameButtons()
7814 {
7815   int i;
7816
7817   for (i=0; i<NUM_GAME_BUTTONS; i++)
7818     FreeGadget(game_gadget[i]);
7819 }
7820
7821 static void MapGameButtons()
7822 {
7823   int i;
7824
7825   for (i=0; i<NUM_GAME_BUTTONS; i++)
7826     MapGadget(game_gadget[i]);
7827 }
7828
7829 void UnmapGameButtons()
7830 {
7831   int i;
7832
7833   for (i=0; i<NUM_GAME_BUTTONS; i++)
7834     UnmapGadget(game_gadget[i]);
7835 }
7836
7837 static void HandleGameButtons(struct GadgetInfo *gi)
7838 {
7839   int id = gi->custom_id;
7840
7841   if (game_status != GAME_MODE_PLAYING)
7842     return;
7843
7844   switch (id)
7845   {
7846     case GAME_CTRL_ID_STOP:
7847       RequestQuitGame(TRUE);
7848       break;
7849
7850     case GAME_CTRL_ID_PAUSE:
7851       if (options.network)
7852       {
7853 #if defined(PLATFORM_UNIX)
7854         if (tape.pausing)
7855           SendToServer_ContinuePlaying();
7856         else
7857           SendToServer_PausePlaying();
7858 #endif
7859       }
7860       else
7861         TapeTogglePause(TAPE_TOGGLE_MANUAL);
7862       break;
7863
7864     case GAME_CTRL_ID_PLAY:
7865       if (tape.pausing)
7866       {
7867 #if defined(PLATFORM_UNIX)
7868         if (options.network)
7869           SendToServer_ContinuePlaying();
7870         else
7871 #endif
7872         {
7873           tape.pausing = FALSE;
7874           DrawVideoDisplay(VIDEO_STATE_PAUSE_OFF,0);
7875         }
7876       }
7877       break;
7878
7879     case SOUND_CTRL_ID_MUSIC:
7880       if (setup.sound_music)
7881       {
7882         setup.sound_music = FALSE;
7883         FadeMusic();
7884       }
7885       else if (audio.music_available)
7886       {
7887         setup.sound = setup.sound_music = TRUE;
7888         PlayMusic(level_nr);
7889       }
7890       break;
7891
7892     case SOUND_CTRL_ID_LOOPS:
7893       if (setup.sound_loops)
7894         setup.sound_loops = FALSE;
7895       else if (audio.loops_available)
7896         setup.sound = setup.sound_loops = TRUE;
7897       break;
7898
7899     case SOUND_CTRL_ID_SIMPLE:
7900       if (setup.sound_simple)
7901         setup.sound_simple = FALSE;
7902       else if (audio.sound_available)
7903         setup.sound = setup.sound_simple = TRUE;
7904       break;
7905
7906     default:
7907       break;
7908   }
7909 }