src/game.c

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