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