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