src/game.c

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