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