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