src/game.c

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