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