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