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