src/game.c

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