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