src/game.c

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