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