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;
5647
5648     if (!CAN_CHANGE(element) ||
5649         !HAS_ANY_CHANGE_EVENT(element, trigger_event))
5650       continue;
5651
5652     for (j=0; j < element_info[element].num_change_pages; j++)
5653     {
5654       struct ElementChangeInfo *change = &element_info[element].change_page[j];
5655
5656       if (change->sides & trigger_side &&
5657           change->trigger_element == trigger_element)
5658       {
5659         change_element = TRUE;
5660         page = j;
5661
5662         break;
5663       }
5664     }
5665
5666     if (!change_element)
5667       continue;
5668
5669     for (y=0; y<lev_fieldy; y++) for (x=0; x<lev_fieldx; x++)
5670     {
5671 #if 0
5672       if (x == lx && y == ly)   /* do not change trigger element itself */
5673         continue;
5674 #endif
5675
5676       if (Feld[x][y] == element)
5677       {
5678         ChangeDelay[x][y] = 1;
5679         ChangeEvent[x][y] = CH_EVENT_BIT(trigger_event);
5680         ChangeElement(x, y, page);
5681       }
5682     }
5683   }
5684
5685   return TRUE;
5686 }
5687
5688 static boolean CheckTriggeredElementChange(int lx, int ly, int trigger_element,
5689                                            int trigger_event)
5690 {
5691   return CheckTriggeredElementSideChange(lx, ly, trigger_element, CH_SIDE_ANY,
5692                                          trigger_event);
5693 }
5694
5695 static boolean CheckElementSideChange(int x, int y, int element, int side,
5696                                       int trigger_event, int page)
5697 {
5698   if (!CAN_CHANGE(element) || !HAS_ANY_CHANGE_EVENT(element, trigger_event))
5699     return FALSE;
5700
5701   if (Feld[x][y] == EL_BLOCKED)
5702   {
5703     Blocked2Moving(x, y, &x, &y);
5704     element = Feld[x][y];
5705   }
5706
5707   if (page < 0)
5708     page = element_info[element].event_page_nr[trigger_event];
5709
5710   if (!(element_info[element].change_page[page].sides & side))
5711     return FALSE;
5712
5713   ChangeDelay[x][y] = 1;
5714   ChangeEvent[x][y] = CH_EVENT_BIT(trigger_event);
5715   ChangeElement(x, y, page);
5716
5717   return TRUE;
5718 }
5719
5720 static boolean CheckElementChange(int x, int y, int element, int trigger_event)
5721 {
5722   return CheckElementSideChange(x, y, element, CH_SIDE_ANY, trigger_event, -1);
5723 }
5724
5725 static void PlayerActions(struct PlayerInfo *player, byte player_action)
5726 {
5727   static byte stored_player_action[MAX_PLAYERS];
5728   static int num_stored_actions = 0;
5729   boolean moved = FALSE, snapped = FALSE, dropped = FALSE;
5730   int left      = player_action & JOY_LEFT;
5731   int right     = player_action & JOY_RIGHT;
5732   int up        = player_action & JOY_UP;
5733   int down      = player_action & JOY_DOWN;
5734   int button1   = player_action & JOY_BUTTON_1;
5735   int button2   = player_action & JOY_BUTTON_2;
5736   int dx        = (left ? -1    : right ? 1     : 0);
5737   int dy        = (up   ? -1    : down  ? 1     : 0);
5738
5739   stored_player_action[player->index_nr] = 0;
5740   num_stored_actions++;
5741
5742   if (!player->active || tape.pausing)
5743     return;
5744
5745   if (player_action)
5746   {
5747     if (button1)
5748       snapped = SnapField(player, dx, dy);
5749     else
5750     {
5751       if (button2)
5752         dropped = DropElement(player);
5753
5754       moved = MoveFigure(player, dx, dy);
5755     }
5756
5757     if (tape.single_step && tape.recording && !tape.pausing)
5758     {
5759       if (button1 || (dropped && !moved))
5760       {
5761         TapeTogglePause(TAPE_TOGGLE_AUTOMATIC);
5762         SnapField(player, 0, 0);                /* stop snapping */
5763       }
5764     }
5765
5766     stored_player_action[player->index_nr] = player_action;
5767   }
5768   else
5769   {
5770     /* no actions for this player (no input at player's configured device) */
5771
5772     DigField(player, 0, 0, 0, 0, DF_NO_PUSH);
5773     SnapField(player, 0, 0);
5774     CheckGravityMovement(player);
5775
5776     if (player->MovPos == 0)
5777       InitPlayerGfxAnimation(player, ACTION_DEFAULT, player->MovDir);
5778
5779     if (player->MovPos == 0)    /* needed for tape.playing */
5780       player->is_moving = FALSE;
5781   }
5782
5783   if (tape.recording && num_stored_actions >= MAX_PLAYERS)
5784   {
5785     TapeRecordAction(stored_player_action);
5786     num_stored_actions = 0;
5787   }
5788 }
5789
5790 void GameActions()
5791 {
5792   static unsigned long action_delay = 0;
5793   unsigned long action_delay_value;
5794   int magic_wall_x = 0, magic_wall_y = 0;
5795   int i, x, y, element, graphic;
5796   byte *recorded_player_action;
5797   byte summarized_player_action = 0;
5798
5799   if (game_status != GAME_MODE_PLAYING)
5800     return;
5801
5802   action_delay_value =
5803     (tape.playing && tape.fast_forward ? FfwdFrameDelay : GameFrameDelay);
5804
5805   if (tape.playing && tape.index_search && !tape.pausing)
5806     action_delay_value = 0;
5807
5808   /* ---------- main game synchronization point ---------- */
5809
5810   WaitUntilDelayReached(&action_delay, action_delay_value);
5811
5812   if (network_playing && !network_player_action_received)
5813   {
5814     /*
5815 #ifdef DEBUG
5816     printf("DEBUG: try to get network player actions in time\n");
5817 #endif
5818     */
5819
5820 #if defined(PLATFORM_UNIX)
5821     /* last chance to get network player actions without main loop delay */
5822     HandleNetworking();
5823 #endif
5824
5825     if (game_status != GAME_MODE_PLAYING)
5826       return;
5827
5828     if (!network_player_action_received)
5829     {
5830       /*
5831 #ifdef DEBUG
5832       printf("DEBUG: failed to get network player actions in time\n");
5833 #endif
5834       */
5835       return;
5836     }
5837   }
5838
5839   if (tape.pausing)
5840     return;
5841
5842   recorded_player_action = (tape.playing ? TapePlayAction() : NULL);
5843
5844   for (i=0; i<MAX_PLAYERS; i++)
5845   {
5846     summarized_player_action |= stored_player[i].action;
5847
5848     if (!network_playing)
5849       stored_player[i].effective_action = stored_player[i].action;
5850   }
5851
5852 #if defined(PLATFORM_UNIX)
5853   if (network_playing)
5854     SendToServer_MovePlayer(summarized_player_action);
5855 #endif
5856
5857   if (!options.network && !setup.team_mode)
5858     local_player->effective_action = summarized_player_action;
5859
5860   for (i=0; i<MAX_PLAYERS; i++)
5861   {
5862     int actual_player_action = stored_player[i].effective_action;
5863
5864     if (stored_player[i].programmed_action)
5865       actual_player_action = stored_player[i].programmed_action;
5866
5867     if (recorded_player_action)
5868       actual_player_action = recorded_player_action[i];
5869
5870     PlayerActions(&stored_player[i], actual_player_action);
5871     ScrollFigure(&stored_player[i], SCROLL_GO_ON);
5872   }
5873
5874   network_player_action_received = FALSE;
5875
5876   ScrollScreen(NULL, SCROLL_GO_ON);
5877
5878 #if 0
5879   FrameCounter++;
5880   TimeFrames++;
5881
5882   for (i=0; i<MAX_PLAYERS; i++)
5883     stored_player[i].Frame++;
5884 #endif
5885
5886 #if 1
5887   if (game.engine_version < RELEASE_IDENT(2,2,0,7))
5888   {
5889     for (i=0; i<MAX_PLAYERS; i++)
5890     {
5891       struct PlayerInfo *player = &stored_player[i];
5892       int x = player->jx;
5893       int y = player->jy;
5894
5895       if (player->active && player->Pushing && player->is_moving &&
5896           IS_MOVING(x, y))
5897       {
5898         ContinueMoving(x, y);
5899
5900         /* continue moving after pushing (this is actually a bug) */
5901         if (!IS_MOVING(x, y))
5902         {
5903           Stop[x][y] = FALSE;
5904         }
5905       }
5906     }
5907   }
5908 #endif
5909
5910   for (y=0; y<lev_fieldy; y++) for (x=0; x<lev_fieldx; x++)
5911   {
5912     Changed[x][y] = CE_BITMASK_DEFAULT;
5913     ChangeEvent[x][y] = CE_BITMASK_DEFAULT;
5914
5915     Stop[x][y] = FALSE;
5916     if (JustStopped[x][y] > 0)
5917       JustStopped[x][y]--;
5918
5919     GfxFrame[x][y]++;
5920
5921 #if 1
5922     /* reset finished pushing action (not done in ContinueMoving() to allow
5923        continous pushing animation for elements with zero push delay) */
5924     if (GfxAction[x][y] == ACTION_PUSHING && !IS_MOVING(x, y))
5925     {
5926       ResetGfxAnimation(x, y);
5927       DrawLevelField(x, y);
5928     }
5929 #endif
5930
5931 #if DEBUG
5932     if (IS_BLOCKED(x, y))
5933     {
5934       int oldx, oldy;
5935
5936       Blocked2Moving(x, y, &oldx, &oldy);
5937       if (!IS_MOVING(oldx, oldy))
5938       {
5939         printf("GameActions(): (BLOCKED => MOVING) context corrupted!\n");
5940         printf("GameActions(): BLOCKED: x = %d, y = %d\n", x, y);
5941         printf("GameActions(): !MOVING: oldx = %d, oldy = %d\n", oldx, oldy);
5942         printf("GameActions(): This should never happen!\n");
5943       }
5944     }
5945 #endif
5946   }
5947
5948   for (y=0; y<lev_fieldy; y++) for (x=0; x<lev_fieldx; x++)
5949   {
5950     element = Feld[x][y];
5951 #if 1
5952     graphic = el_act_dir2img(element, GfxAction[x][y], MovDir[x][y]);
5953 #else
5954     graphic = el2img(element);
5955 #endif
5956
5957 #if 0
5958     if (element == -1)
5959     {
5960       printf("::: %d,%d: %d [%d]\n", x, y, element, FrameCounter);
5961
5962       element = graphic = 0;
5963     }
5964 #endif
5965
5966     if (graphic_info[graphic].anim_global_sync)
5967       GfxFrame[x][y] = FrameCounter;
5968
5969     if (ANIM_MODE(graphic) == ANIM_RANDOM &&
5970         IS_NEXT_FRAME(GfxFrame[x][y], graphic))
5971       ResetRandomAnimationValue(x, y);
5972
5973     SetRandomAnimationValue(x, y);
5974
5975 #if 1
5976     PlaySoundLevelActionIfLoop(x, y, GfxAction[x][y]);
5977 #endif
5978
5979     if (IS_INACTIVE(element))
5980     {
5981       if (IS_ANIMATED(graphic))
5982         DrawLevelGraphicAnimationIfNeeded(x, y, graphic);
5983
5984       continue;
5985     }
5986
5987 #if 1
5988     /* this may take place after moving, so 'element' may have changed */
5989     if (IS_CHANGING(x, y))
5990     {
5991       ChangeElement(x, y, element_info[element].event_page_nr[CE_DELAY]);
5992       element = Feld[x][y];
5993       graphic = el_act_dir2img(element, GfxAction[x][y], MovDir[x][y]);
5994     }
5995 #endif
5996
5997     if (!IS_MOVING(x, y) && (CAN_FALL(element) || CAN_MOVE(element)))
5998     {
5999       StartMoving(x, y);
6000
6001 #if 1
6002       graphic = el_act_dir2img(element, GfxAction[x][y], MovDir[x][y]);
6003 #if 0
6004       if (element == EL_MOLE)
6005         printf("::: %d, %d, %d [%d]\n",
6006                IS_ANIMATED(graphic), IS_MOVING(x, y), Stop[x][y],
6007                GfxAction[x][y]);
6008 #endif
6009 #if 0
6010       if (element == EL_YAMYAM)
6011         printf("::: %d, %d, %d\n",
6012                IS_ANIMATED(graphic), IS_MOVING(x, y), Stop[x][y]);
6013 #endif
6014 #endif
6015
6016       if (IS_ANIMATED(graphic) &&
6017           !IS_MOVING(x, y) &&
6018           !Stop[x][y])
6019       {
6020         DrawLevelGraphicAnimationIfNeeded(x, y, graphic);
6021
6022 #if 0
6023         if (element == EL_MOLE)
6024           printf("::: %d, %d\n", graphic, GfxFrame[x][y]);
6025 #endif
6026       }
6027
6028       if (IS_GEM(element) || element == EL_SP_INFOTRON)
6029         EdelsteinFunkeln(x, y);
6030     }
6031     else if ((element == EL_ACID ||
6032               element == EL_EXIT_OPEN ||
6033               element == EL_SP_EXIT_OPEN ||
6034               element == EL_SP_TERMINAL ||
6035               element == EL_SP_TERMINAL_ACTIVE ||
6036               element == EL_EXTRA_TIME ||
6037               element == EL_SHIELD_NORMAL ||
6038               element == EL_SHIELD_DEADLY) &&
6039              IS_ANIMATED(graphic))
6040       DrawLevelGraphicAnimationIfNeeded(x, y, graphic);
6041     else if (IS_MOVING(x, y))
6042       ContinueMoving(x, y);
6043     else if (IS_ACTIVE_BOMB(element))
6044       CheckDynamite(x, y);
6045 #if 0
6046     else if (element == EL_EXPLOSION && !game.explosions_delayed)
6047       Explode(x, y, ExplodePhase[x][y], EX_NORMAL);
6048 #endif
6049     else if (element == EL_AMOEBA_GROWING)
6050       AmoebeWaechst(x, y);
6051     else if (element == EL_AMOEBA_SHRINKING)
6052       AmoebaDisappearing(x, y);
6053
6054 #if !USE_NEW_AMOEBA_CODE
6055     else if (IS_AMOEBALIVE(element))
6056       AmoebeAbleger(x, y);
6057 #endif
6058
6059     else if (element == EL_GAME_OF_LIFE || element == EL_BIOMAZE)
6060       Life(x, y);
6061     else if (element == EL_EXIT_CLOSED)
6062       CheckExit(x, y);
6063     else if (element == EL_SP_EXIT_CLOSED)
6064       CheckExitSP(x, y);
6065     else if (element == EL_EXPANDABLE_WALL_GROWING)
6066       MauerWaechst(x, y);
6067     else if (element == EL_EXPANDABLE_WALL ||
6068              element == EL_EXPANDABLE_WALL_HORIZONTAL ||
6069              element == EL_EXPANDABLE_WALL_VERTICAL ||
6070              element == EL_EXPANDABLE_WALL_ANY)
6071       MauerAbleger(x, y);
6072     else if (element == EL_FLAMES)
6073       CheckForDragon(x, y);
6074 #if 0
6075     else if (IS_AUTO_CHANGING(element))
6076       ChangeElement(x, y);
6077 #endif
6078     else if (element == EL_EXPLOSION)
6079       ; /* drawing of correct explosion animation is handled separately */
6080     else if (IS_ANIMATED(graphic) && !IS_CHANGING(x, y))
6081       DrawLevelGraphicAnimationIfNeeded(x, y, graphic);
6082
6083 #if 0
6084     /* this may take place after moving, so 'element' may have changed */
6085     if (IS_AUTO_CHANGING(Feld[x][y]))
6086       ChangeElement(x, y);
6087 #endif
6088
6089     if (IS_BELT_ACTIVE(element))
6090       PlaySoundLevelAction(x, y, ACTION_ACTIVE);
6091
6092     if (game.magic_wall_active)
6093     {
6094       int jx = local_player->jx, jy = local_player->jy;
6095
6096       /* play the element sound at the position nearest to the player */
6097       if ((element == EL_MAGIC_WALL_FULL ||
6098            element == EL_MAGIC_WALL_ACTIVE ||
6099            element == EL_MAGIC_WALL_EMPTYING ||
6100            element == EL_BD_MAGIC_WALL_FULL ||
6101            element == EL_BD_MAGIC_WALL_ACTIVE ||
6102            element == EL_BD_MAGIC_WALL_EMPTYING) &&
6103           ABS(x-jx) + ABS(y-jy) < ABS(magic_wall_x-jx) + ABS(magic_wall_y-jy))
6104       {
6105         magic_wall_x = x;
6106         magic_wall_y = y;
6107       }
6108     }
6109   }
6110
6111 #if USE_NEW_AMOEBA_CODE
6112   /* new experimental amoeba growth stuff */
6113 #if 1
6114   if (!(FrameCounter % 8))
6115 #endif
6116   {
6117     static unsigned long random = 1684108901;
6118
6119     for (i = 0; i < level.amoeba_speed * 28 / 8; i++)
6120     {
6121 #if 0
6122       x = (random >> 10) % lev_fieldx;
6123       y = (random >> 20) % lev_fieldy;
6124 #else
6125       x = RND(lev_fieldx);
6126       y = RND(lev_fieldy);
6127 #endif
6128       element = Feld[x][y];
6129
6130       /* !!! extend EL_SAND to anything diggable (but maybe not SP_BASE) !!! */
6131       if (!IS_PLAYER(x,y) &&
6132           (element == EL_EMPTY ||
6133            element == EL_SAND ||
6134            element == EL_QUICKSAND_EMPTY ||
6135            element == EL_ACID_SPLASH_LEFT ||
6136            element == EL_ACID_SPLASH_RIGHT))
6137       {
6138         if ((IN_LEV_FIELD(x, y-1) && Feld[x][y-1] == EL_AMOEBA_WET) ||
6139             (IN_LEV_FIELD(x-1, y) && Feld[x-1][y] == EL_AMOEBA_WET) ||
6140             (IN_LEV_FIELD(x+1, y) && Feld[x+1][y] == EL_AMOEBA_WET) ||
6141             (IN_LEV_FIELD(x, y+1) && Feld[x][y+1] == EL_AMOEBA_WET))
6142           Feld[x][y] = EL_AMOEBA_DROP;
6143       }
6144
6145       random = random * 129 + 1;
6146     }
6147   }
6148 #endif
6149
6150 #if 0
6151   if (game.explosions_delayed)
6152 #endif
6153   {
6154     game.explosions_delayed = FALSE;
6155
6156     for (y=0; y<lev_fieldy; y++) for (x=0; x<lev_fieldx; x++)
6157     {
6158       element = Feld[x][y];
6159
6160       if (ExplodeField[x][y])
6161         Explode(x, y, EX_PHASE_START, ExplodeField[x][y]);
6162       else if (element == EL_EXPLOSION)
6163         Explode(x, y, ExplodePhase[x][y], EX_NORMAL);
6164
6165       ExplodeField[x][y] = EX_NO_EXPLOSION;
6166     }
6167
6168     game.explosions_delayed = TRUE;
6169   }
6170
6171   if (game.magic_wall_active)
6172   {
6173     if (!(game.magic_wall_time_left % 4))
6174     {
6175       int element = Feld[magic_wall_x][magic_wall_y];
6176
6177       if (element == EL_BD_MAGIC_WALL_FULL ||
6178           element == EL_BD_MAGIC_WALL_ACTIVE ||
6179           element == EL_BD_MAGIC_WALL_EMPTYING)
6180         PlaySoundLevel(magic_wall_x, magic_wall_y, SND_BD_MAGIC_WALL_ACTIVE);
6181       else
6182         PlaySoundLevel(magic_wall_x, magic_wall_y, SND_MAGIC_WALL_ACTIVE);
6183     }
6184
6185     if (game.magic_wall_time_left > 0)
6186     {
6187       game.magic_wall_time_left--;
6188       if (!game.magic_wall_time_left)
6189       {
6190         for (y=0; y<lev_fieldy; y++) for (x=0; x<lev_fieldx; x++)
6191         {
6192           element = Feld[x][y];
6193
6194           if (element == EL_MAGIC_WALL_ACTIVE ||
6195               element == EL_MAGIC_WALL_FULL)
6196           {
6197             Feld[x][y] = EL_MAGIC_WALL_DEAD;
6198             DrawLevelField(x, y);
6199           }
6200           else if (element == EL_BD_MAGIC_WALL_ACTIVE ||
6201                    element == EL_BD_MAGIC_WALL_FULL)
6202           {
6203             Feld[x][y] = EL_BD_MAGIC_WALL_DEAD;
6204             DrawLevelField(x, y);
6205           }
6206         }
6207
6208         game.magic_wall_active = FALSE;
6209       }
6210     }
6211   }
6212
6213   if (game.light_time_left > 0)
6214   {
6215     game.light_time_left--;
6216
6217     if (game.light_time_left == 0)
6218       RedrawAllLightSwitchesAndInvisibleElements();
6219   }
6220
6221   if (game.timegate_time_left > 0)
6222   {
6223     game.timegate_time_left--;
6224
6225     if (game.timegate_time_left == 0)
6226       CloseAllOpenTimegates();
6227   }
6228
6229   for (i=0; i<MAX_PLAYERS; i++)
6230   {
6231     struct PlayerInfo *player = &stored_player[i];
6232
6233     if (SHIELD_ON(player))
6234     {
6235       if (player->shield_deadly_time_left)
6236         PlaySoundLevel(player->jx, player->jy, SND_SHIELD_DEADLY_ACTIVE);
6237       else if (player->shield_normal_time_left)
6238         PlaySoundLevel(player->jx, player->jy, SND_SHIELD_NORMAL_ACTIVE);
6239     }
6240   }
6241
6242   if (TimeFrames >= (1000 / GameFrameDelay))
6243   {
6244     TimeFrames = 0;
6245     TimePlayed++;
6246
6247     for (i=0; i<MAX_PLAYERS; i++)
6248     {
6249       struct PlayerInfo *player = &stored_player[i];
6250
6251       if (SHIELD_ON(player))
6252       {
6253         player->shield_normal_time_left--;
6254
6255         if (player->shield_deadly_time_left > 0)
6256           player->shield_deadly_time_left--;
6257       }
6258     }
6259
6260     if (tape.recording || tape.playing)
6261       DrawVideoDisplay(VIDEO_STATE_TIME_ON, TimePlayed);
6262
6263     if (TimeLeft > 0)
6264     {
6265       TimeLeft--;
6266
6267       if (TimeLeft <= 10 && setup.time_limit)
6268         PlaySoundStereo(SND_GAME_RUNNING_OUT_OF_TIME, SOUND_MIDDLE);
6269
6270       DrawText(DX_TIME, DY_TIME, int2str(TimeLeft, 3), FONT_TEXT_2);
6271
6272       if (!TimeLeft && setup.time_limit)
6273         for (i=0; i<MAX_PLAYERS; i++)
6274           KillHero(&stored_player[i]);
6275     }
6276     else if (level.time == 0 && !AllPlayersGone) /* level without time limit */
6277       DrawText(DX_TIME, DY_TIME, int2str(TimePlayed, 3), FONT_TEXT_2);
6278   }
6279
6280   DrawAllPlayers();
6281
6282   if (options.debug)                    /* calculate frames per second */
6283   {
6284     static unsigned long fps_counter = 0;
6285     static int fps_frames = 0;
6286     unsigned long fps_delay_ms = Counter() - fps_counter;
6287
6288     fps_frames++;
6289
6290     if (fps_delay_ms >= 500)    /* calculate fps every 0.5 seconds */
6291     {
6292       global.frames_per_second = 1000 * (float)fps_frames / fps_delay_ms;
6293
6294       fps_frames = 0;
6295       fps_counter = Counter();
6296     }
6297
6298     redraw_mask |= REDRAW_FPS;
6299   }
6300
6301 #if 0
6302   if (stored_player[0].jx != stored_player[0].last_jx ||
6303       stored_player[0].jy != stored_player[0].last_jy)
6304     printf("::: %d, %d, %d, %d, %d\n",
6305            stored_player[0].MovDir,
6306            stored_player[0].MovPos,
6307            stored_player[0].GfxPos,
6308            stored_player[0].Frame,
6309            stored_player[0].StepFrame);
6310 #endif
6311
6312 #if 1
6313   FrameCounter++;
6314   TimeFrames++;
6315
6316   for (i=0; i<MAX_PLAYERS; i++)
6317   {
6318     int move_frames =
6319       MOVE_DELAY_NORMAL_SPEED /  stored_player[i].move_delay_value;
6320
6321     stored_player[i].Frame += move_frames;
6322
6323     if (stored_player[i].MovPos != 0)
6324       stored_player[i].StepFrame += move_frames;
6325   }
6326 #endif
6327
6328 #if 1
6329   if (local_player->show_envelope != 0 && local_player->MovPos == 0)
6330   {
6331     ShowEnvelope(local_player->show_envelope - EL_ENVELOPE_1);
6332
6333     local_player->show_envelope = 0;
6334   }
6335 #endif
6336 }
6337
6338 static boolean AllPlayersInSight(struct PlayerInfo *player, int x, int y)
6339 {
6340   int min_x = x, min_y = y, max_x = x, max_y = y;
6341   int i;
6342
6343   for (i=0; i<MAX_PLAYERS; i++)
6344   {
6345     int jx = stored_player[i].jx, jy = stored_player[i].jy;
6346
6347     if (!stored_player[i].active || &stored_player[i] == player)
6348       continue;
6349
6350     min_x = MIN(min_x, jx);
6351     min_y = MIN(min_y, jy);
6352     max_x = MAX(max_x, jx);
6353     max_y = MAX(max_y, jy);
6354   }
6355
6356   return (max_x - min_x < SCR_FIELDX && max_y - min_y < SCR_FIELDY);
6357 }
6358
6359 static boolean AllPlayersInVisibleScreen()
6360 {
6361   int i;
6362
6363   for (i=0; i<MAX_PLAYERS; i++)
6364   {
6365     int jx = stored_player[i].jx, jy = stored_player[i].jy;
6366
6367     if (!stored_player[i].active)
6368       continue;
6369
6370     if (!IN_VIS_FIELD(SCREENX(jx), SCREENY(jy)))
6371       return FALSE;
6372   }
6373
6374   return TRUE;
6375 }
6376
6377 void ScrollLevel(int dx, int dy)
6378 {
6379   int softscroll_offset = (setup.soft_scrolling ? TILEX : 0);
6380   int x, y;
6381
6382   BlitBitmap(drawto_field, drawto_field,
6383              FX + TILEX * (dx == -1) - softscroll_offset,
6384              FY + TILEY * (dy == -1) - softscroll_offset,
6385              SXSIZE - TILEX * (dx!=0) + 2 * softscroll_offset,
6386              SYSIZE - TILEY * (dy!=0) + 2 * softscroll_offset,
6387              FX + TILEX * (dx == 1) - softscroll_offset,
6388              FY + TILEY * (dy == 1) - softscroll_offset);
6389
6390   if (dx)
6391   {
6392     x = (dx == 1 ? BX1 : BX2);
6393     for (y=BY1; y <= BY2; y++)
6394       DrawScreenField(x, y);
6395   }
6396
6397   if (dy)
6398   {
6399     y = (dy == 1 ? BY1 : BY2);
6400     for (x=BX1; x <= BX2; x++)
6401       DrawScreenField(x, y);
6402   }
6403
6404   redraw_mask |= REDRAW_FIELD;
6405 }
6406
6407 static void CheckGravityMovement(struct PlayerInfo *player)
6408 {
6409   if (level.gravity && !player->programmed_action)
6410   {
6411     int move_dir_vertical = player->action & (MV_UP | MV_DOWN);
6412     int move_dir_horizontal = player->action & (MV_LEFT | MV_RIGHT);
6413     int move_dir =
6414       (player->last_move_dir & (MV_LEFT | MV_RIGHT) ?
6415        (move_dir_vertical ? move_dir_vertical : move_dir_horizontal) :
6416        (move_dir_horizontal ? move_dir_horizontal : move_dir_vertical));
6417     int jx = player->jx, jy = player->jy;
6418     int dx = (move_dir & MV_LEFT ? -1 : move_dir & MV_RIGHT ? +1 : 0);
6419     int dy = (move_dir & MV_UP ? -1 : move_dir & MV_DOWN ? +1 : 0);
6420     int new_jx = jx + dx, new_jy = jy + dy;
6421     boolean field_under_player_is_free =
6422       (IN_LEV_FIELD(jx, jy + 1) && IS_FREE(jx, jy + 1));
6423     boolean player_is_moving_to_valid_field =
6424       (IN_LEV_FIELD(new_jx, new_jy) &&
6425        (Feld[new_jx][new_jy] == EL_SP_BASE ||
6426         Feld[new_jx][new_jy] == EL_SAND));
6427     /* !!! extend EL_SAND to anything diggable !!! */
6428
6429     if (field_under_player_is_free &&
6430         !player_is_moving_to_valid_field &&
6431         !IS_WALKABLE_INSIDE(Feld[jx][jy]))
6432       player->programmed_action = MV_DOWN;
6433   }
6434 }
6435
6436 /*
6437   MoveFigureOneStep()
6438   -----------------------------------------------------------------------------
6439   dx, dy:               direction (non-diagonal) to try to move the player to
6440   real_dx, real_dy:     direction as read from input device (can be diagonal)
6441 */
6442
6443 boolean MoveFigureOneStep(struct PlayerInfo *player,
6444                           int dx, int dy, int real_dx, int real_dy)
6445 {
6446   static int change_sides[4][2] =
6447   {
6448     /* enter side        leave side */
6449     { CH_SIDE_RIGHT,    CH_SIDE_LEFT    },      /* moving left  */
6450     { CH_SIDE_LEFT,     CH_SIDE_RIGHT   },      /* moving right */
6451     { CH_SIDE_BOTTOM,   CH_SIDE_TOP     },      /* moving up    */
6452     { CH_SIDE_TOP,      CH_SIDE_BOTTOM  }       /* moving down  */
6453   };
6454   int move_direction = (dx == -1 ? MV_LEFT :
6455                         dx == +1 ? MV_RIGHT :
6456                         dy == -1 ? MV_UP :
6457                         dy == +1 ? MV_DOWN : MV_NO_MOVING);
6458   int enter_side = change_sides[MV_DIR_BIT(move_direction)][0];
6459   int leave_side = change_sides[MV_DIR_BIT(move_direction)][1];
6460   int jx = player->jx, jy = player->jy;
6461   int new_jx = jx + dx, new_jy = jy + dy;
6462   int element;
6463   int can_move;
6464
6465   if (!player->active || (!dx && !dy))
6466     return MF_NO_ACTION;
6467
6468   player->MovDir = (dx < 0 ? MV_LEFT :
6469                     dx > 0 ? MV_RIGHT :
6470                     dy < 0 ? MV_UP :
6471                     dy > 0 ? MV_DOWN :  MV_NO_MOVING);
6472
6473   if (!IN_LEV_FIELD(new_jx, new_jy))
6474     return MF_NO_ACTION;
6475
6476   if (!options.network && !AllPlayersInSight(player, new_jx, new_jy))
6477     return MF_NO_ACTION;
6478
6479 #if 0
6480   element = MovingOrBlocked2Element(new_jx, new_jy);
6481 #else
6482   element = MovingOrBlocked2ElementIfNotLeaving(new_jx, new_jy);
6483 #endif
6484
6485   if (DONT_RUN_INTO(element))
6486   {
6487     if (element == EL_ACID && dx == 0 && dy == 1)
6488     {
6489       SplashAcid(jx, jy);
6490       Feld[jx][jy] = EL_PLAYER_1;
6491       InitMovingField(jx, jy, MV_DOWN);
6492       Store[jx][jy] = EL_ACID;
6493       ContinueMoving(jx, jy);
6494       BuryHero(player);
6495     }
6496     else
6497       TestIfHeroRunsIntoBadThing(jx, jy, player->MovDir);
6498
6499     return MF_MOVING;
6500   }
6501
6502   can_move = DigField(player, new_jx, new_jy, real_dx, real_dy, DF_DIG);
6503   if (can_move != MF_MOVING)
6504     return can_move;
6505
6506   /* check if DigField() has caused relocation of the player */
6507   if (player->jx != jx || player->jy != jy)
6508     return MF_NO_ACTION;
6509
6510   StorePlayer[jx][jy] = 0;
6511   player->last_jx = jx;
6512   player->last_jy = jy;
6513   player->jx = new_jx;
6514   player->jy = new_jy;
6515   StorePlayer[new_jx][new_jy] = player->element_nr;
6516
6517   player->MovPos =
6518     (dx > 0 || dy > 0 ? -1 : 1) * (TILEX - TILEX / player->move_delay_value);
6519
6520   ScrollFigure(player, SCROLL_INIT);
6521
6522 #if 1
6523   if (IS_CUSTOM_ELEMENT(Feld[jx][jy]))
6524   {
6525     CheckTriggeredElementSideChange(jx, jy, Feld[jx][jy], leave_side,
6526                                     CE_OTHER_GETS_LEFT);
6527     CheckElementSideChange(jx, jy, Feld[jx][jy], leave_side,
6528                            CE_LEFT_BY_PLAYER, -1);
6529   }
6530
6531   if (IS_CUSTOM_ELEMENT(Feld[new_jx][new_jy]))
6532   {
6533     CheckTriggeredElementSideChange(new_jx, new_jy, Feld[new_jx][new_jy],
6534                                     enter_side, CE_OTHER_GETS_ENTERED);
6535     CheckElementSideChange(new_jx, new_jy, Feld[new_jx][new_jy], enter_side,
6536                            CE_ENTERED_BY_PLAYER, -1);
6537   }
6538 #endif
6539
6540   return MF_MOVING;
6541 }
6542
6543 boolean MoveFigure(struct PlayerInfo *player, int dx, int dy)
6544 {
6545   int jx = player->jx, jy = player->jy;
6546   int old_jx = jx, old_jy = jy;
6547   int moved = MF_NO_ACTION;
6548
6549   if (!player->active || (!dx && !dy))
6550     return FALSE;
6551
6552 #if 0
6553   if (!FrameReached(&player->move_delay, player->move_delay_value) &&
6554       !tape.playing)
6555     return FALSE;
6556 #else
6557   if (!FrameReached(&player->move_delay, player->move_delay_value) &&
6558       !(tape.playing && tape.file_version < FILE_VERSION_2_0))
6559     return FALSE;
6560 #endif
6561
6562   /* remove the last programmed player action */
6563   player->programmed_action = 0;
6564
6565   if (player->MovPos)
6566   {
6567     /* should only happen if pre-1.2 tape recordings are played */
6568     /* this is only for backward compatibility */
6569
6570     int original_move_delay_value = player->move_delay_value;
6571
6572 #if DEBUG
6573     printf("THIS SHOULD ONLY HAPPEN WITH PRE-1.2 LEVEL TAPES. [%ld]\n",
6574            tape.counter);
6575 #endif
6576
6577     /* scroll remaining steps with finest movement resolution */
6578     player->move_delay_value = MOVE_DELAY_NORMAL_SPEED;
6579
6580     while (player->MovPos)
6581     {
6582       ScrollFigure(player, SCROLL_GO_ON);
6583       ScrollScreen(NULL, SCROLL_GO_ON);
6584       FrameCounter++;
6585       DrawAllPlayers();
6586       BackToFront();
6587     }
6588
6589     player->move_delay_value = original_move_delay_value;
6590   }
6591
6592   if (player->last_move_dir & (MV_LEFT | MV_RIGHT))
6593   {
6594     if (!(moved |= MoveFigureOneStep(player, 0, dy, dx, dy)))
6595       moved |= MoveFigureOneStep(player, dx, 0, dx, dy);
6596   }
6597   else
6598   {
6599     if (!(moved |= MoveFigureOneStep(player, dx, 0, dx, dy)))
6600       moved |= MoveFigureOneStep(player, 0, dy, dx, dy);
6601   }
6602
6603   jx = player->jx;
6604   jy = player->jy;
6605
6606   if (moved & MF_MOVING && !ScreenMovPos &&
6607       (player == local_player || !options.network))
6608   {
6609     int old_scroll_x = scroll_x, old_scroll_y = scroll_y;
6610     int offset = (setup.scroll_delay ? 3 : 0);
6611
6612     if (!IN_VIS_FIELD(SCREENX(jx), SCREENY(jy)))
6613     {
6614       /* actual player has left the screen -- scroll in that direction */
6615       if (jx != old_jx)         /* player has moved horizontally */
6616         scroll_x += (jx - old_jx);
6617       else                      /* player has moved vertically */
6618         scroll_y += (jy - old_jy);
6619     }
6620     else
6621     {
6622       if (jx != old_jx)         /* player has moved horizontally */
6623       {
6624         if ((player->MovDir == MV_LEFT && scroll_x > jx - MIDPOSX + offset) ||
6625             (player->MovDir == MV_RIGHT && scroll_x < jx - MIDPOSX - offset))
6626           scroll_x = jx-MIDPOSX + (scroll_x < jx-MIDPOSX ? -offset : +offset);
6627
6628         /* don't scroll over playfield boundaries */
6629         if (scroll_x < SBX_Left || scroll_x > SBX_Right)
6630           scroll_x = (scroll_x < SBX_Left ? SBX_Left : SBX_Right);
6631
6632         /* don't scroll more than one field at a time */
6633         scroll_x = old_scroll_x + SIGN(scroll_x - old_scroll_x);
6634
6635         /* don't scroll against the player's moving direction */
6636         if ((player->MovDir == MV_LEFT && scroll_x > old_scroll_x) ||
6637             (player->MovDir == MV_RIGHT && scroll_x < old_scroll_x))
6638           scroll_x = old_scroll_x;
6639       }
6640       else                      /* player has moved vertically */
6641       {
6642         if ((player->MovDir == MV_UP && scroll_y > jy - MIDPOSY + offset) ||
6643             (player->MovDir == MV_DOWN && scroll_y < jy - MIDPOSY - offset))
6644           scroll_y = jy-MIDPOSY + (scroll_y < jy-MIDPOSY ? -offset : +offset);
6645
6646         /* don't scroll over playfield boundaries */
6647         if (scroll_y < SBY_Upper || scroll_y > SBY_Lower)
6648           scroll_y = (scroll_y < SBY_Upper ? SBY_Upper : SBY_Lower);
6649
6650         /* don't scroll more than one field at a time */
6651         scroll_y = old_scroll_y + SIGN(scroll_y - old_scroll_y);
6652
6653         /* don't scroll against the player's moving direction */
6654         if ((player->MovDir == MV_UP && scroll_y > old_scroll_y) ||
6655             (player->MovDir == MV_DOWN && scroll_y < old_scroll_y))
6656           scroll_y = old_scroll_y;
6657       }
6658     }
6659
6660     if (scroll_x != old_scroll_x || scroll_y != old_scroll_y)
6661     {
6662       if (!options.network && !AllPlayersInVisibleScreen())
6663       {
6664         scroll_x = old_scroll_x;
6665         scroll_y = old_scroll_y;
6666       }
6667       else
6668       {
6669         ScrollScreen(player, SCROLL_INIT);
6670         ScrollLevel(old_scroll_x - scroll_x, old_scroll_y - scroll_y);
6671       }
6672     }
6673   }
6674
6675 #if 0
6676 #if 1
6677   InitPlayerGfxAnimation(player, ACTION_DEFAULT);
6678 #else
6679   if (!(moved & MF_MOVING) && !player->Pushing)
6680     player->Frame = 0;
6681 #endif
6682 #endif
6683
6684   player->StepFrame = 0;
6685
6686   if (moved & MF_MOVING)
6687   {
6688     if (old_jx != jx && old_jy == jy)
6689       player->MovDir = (old_jx < jx ? MV_RIGHT : MV_LEFT);
6690     else if (old_jx == jx && old_jy != jy)
6691       player->MovDir = (old_jy < jy ? MV_DOWN : MV_UP);
6692
6693     DrawLevelField(jx, jy);     /* for "crumbled sand" */
6694
6695     player->last_move_dir = player->MovDir;
6696     player->is_moving = TRUE;
6697 #if 1
6698     player->snapped = FALSE;
6699 #endif
6700   }
6701   else
6702   {
6703     CheckGravityMovement(player);
6704
6705     /*
6706     player->last_move_dir = MV_NO_MOVING;
6707     */
6708     player->is_moving = FALSE;
6709   }
6710
6711   TestIfHeroTouchesBadThing(jx, jy);
6712   TestIfPlayerTouchesCustomElement(jx, jy);
6713
6714   if (!player->active)
6715     RemoveHero(player);
6716
6717   return moved;
6718 }
6719
6720 void ScrollFigure(struct PlayerInfo *player, int mode)
6721 {
6722   int jx = player->jx, jy = player->jy;
6723   int last_jx = player->last_jx, last_jy = player->last_jy;
6724   int move_stepsize = TILEX / player->move_delay_value;
6725
6726   if (!player->active || !player->MovPos)
6727     return;
6728
6729   if (mode == SCROLL_INIT)
6730   {
6731     player->actual_frame_counter = FrameCounter;
6732     player->GfxPos = move_stepsize * (player->MovPos / move_stepsize);
6733
6734     if (Feld[last_jx][last_jy] == EL_EMPTY)
6735       Feld[last_jx][last_jy] = EL_PLAYER_IS_LEAVING;
6736
6737 #if 0
6738     DrawPlayer(player);
6739 #endif
6740     return;
6741   }
6742   else if (!FrameReached(&player->actual_frame_counter, 1))
6743     return;
6744
6745   player->MovPos += (player->MovPos > 0 ? -1 : 1) * move_stepsize;
6746   player->GfxPos = move_stepsize * (player->MovPos / move_stepsize);
6747
6748   if (Feld[last_jx][last_jy] == EL_PLAYER_IS_LEAVING)
6749     Feld[last_jx][last_jy] = EL_EMPTY;
6750
6751   /* before DrawPlayer() to draw correct player graphic for this case */
6752   if (player->MovPos == 0)
6753     CheckGravityMovement(player);
6754
6755 #if 0
6756   DrawPlayer(player);   /* needed here only to cleanup last field */
6757 #endif
6758
6759   if (player->MovPos == 0)      /* player reached destination field */
6760   {
6761     if (IS_PASSABLE(Feld[last_jx][last_jy]))
6762     {
6763       /* continue with normal speed after quickly moving through gate */
6764       HALVE_PLAYER_SPEED(player);
6765
6766       /* be able to make the next move without delay */
6767       player->move_delay = 0;
6768     }
6769
6770     player->last_jx = jx;
6771     player->last_jy = jy;
6772
6773     if (Feld[jx][jy] == EL_EXIT_OPEN ||
6774         Feld[jx][jy] == EL_SP_EXIT_OPEN)
6775     {
6776       DrawPlayer(player);       /* needed here only to cleanup last field */
6777       RemoveHero(player);
6778
6779       if (local_player->friends_still_needed == 0 ||
6780           Feld[jx][jy] == EL_SP_EXIT_OPEN)
6781         player->LevelSolved = player->GameOver = TRUE;
6782     }
6783
6784     if (tape.single_step && tape.recording && !tape.pausing &&
6785         !player->programmed_action)
6786       TapeTogglePause(TAPE_TOGGLE_AUTOMATIC);
6787   }
6788 }
6789
6790 void ScrollScreen(struct PlayerInfo *player, int mode)
6791 {
6792   static unsigned long screen_frame_counter = 0;
6793
6794   if (mode == SCROLL_INIT)
6795   {
6796     /* set scrolling step size according to actual player's moving speed */
6797     ScrollStepSize = TILEX / player->move_delay_value;
6798
6799     screen_frame_counter = FrameCounter;
6800     ScreenMovDir = player->MovDir;
6801     ScreenMovPos = player->MovPos;
6802     ScreenGfxPos = ScrollStepSize * (ScreenMovPos / ScrollStepSize);
6803     return;
6804   }
6805   else if (!FrameReached(&screen_frame_counter, 1))
6806     return;
6807
6808   if (ScreenMovPos)
6809   {
6810     ScreenMovPos += (ScreenMovPos > 0 ? -1 : 1) * ScrollStepSize;
6811     ScreenGfxPos = ScrollStepSize * (ScreenMovPos / ScrollStepSize);
6812     redraw_mask |= REDRAW_FIELD;
6813   }
6814   else
6815     ScreenMovDir = MV_NO_MOVING;
6816 }
6817
6818 void TestIfPlayerTouchesCustomElement(int x, int y)
6819 {
6820 #if 0
6821   static boolean check_changing = FALSE;
6822 #endif
6823   static int xy[4][2] =
6824   {
6825     { 0, -1 },
6826     { -1, 0 },
6827     { +1, 0 },
6828     { 0, +1 }
6829   };
6830   static int change_sides[4][2] =
6831   {
6832     /* center side       border side */
6833     { CH_SIDE_TOP,      CH_SIDE_BOTTOM  },      /* check top    */
6834     { CH_SIDE_LEFT,     CH_SIDE_RIGHT   },      /* check left   */
6835     { CH_SIDE_RIGHT,    CH_SIDE_LEFT    },      /* check right  */
6836     { CH_SIDE_BOTTOM,   CH_SIDE_TOP     }       /* check bottom */
6837   };
6838   int i;
6839
6840 #if 0
6841   if (check_changing)   /* prevent this function from running into a loop */
6842     return;
6843
6844   check_changing = TRUE;
6845 #endif
6846
6847   for (i=0; i<4; i++)
6848   {
6849     int xx = x + xy[i][0];
6850     int yy = y + xy[i][1];
6851     int center_side = change_sides[i][0];
6852     int border_side = change_sides[i][1];
6853
6854     if (!IN_LEV_FIELD(xx, yy))
6855       continue;
6856
6857 #if 1
6858     if (IS_PLAYER(x, y))
6859     {
6860       CheckTriggeredElementSideChange(xx, yy, Feld[xx][yy], border_side,
6861                                       CE_OTHER_GETS_TOUCHED);
6862       CheckElementSideChange(xx, yy, Feld[xx][yy], border_side,
6863                              CE_TOUCHED_BY_PLAYER, -1);
6864     }
6865     else if (IS_PLAYER(xx, yy))
6866     {
6867       CheckTriggeredElementSideChange(x, y, Feld[x][y], center_side,
6868                                       CE_OTHER_GETS_TOUCHED);
6869       CheckElementSideChange(x, y, Feld[x][y], center_side,
6870                              CE_TOUCHED_BY_PLAYER, -1);
6871
6872       break;
6873     }
6874 #else
6875     if (IS_PLAYER(x, y))
6876     {
6877       CheckTriggeredElementChange(xx, yy, Feld[xx][yy], CE_OTHER_GETS_TOUCHED);
6878       CheckElementChange(xx, yy, Feld[xx][yy], CE_TOUCHED_BY_PLAYER);
6879     }
6880     else if (IS_PLAYER(xx, yy))
6881     {
6882       CheckTriggeredElementChange(x, y, Feld[x][y], CE_OTHER_GETS_TOUCHED);
6883       CheckElementChange(x, y, Feld[x][y], CE_TOUCHED_BY_PLAYER);
6884
6885       break;
6886     }
6887 #endif
6888   }
6889
6890 #if 0
6891   check_changing = FALSE;
6892 #endif
6893 }
6894
6895 void TestIfElementTouchesCustomElement(int x, int y)
6896 {
6897 #if 0
6898   static boolean check_changing = FALSE;
6899 #endif
6900   static int xy[4][2] =
6901   {
6902     { 0, -1 },
6903     { -1, 0 },
6904     { +1, 0 },
6905     { 0, +1 }
6906   };
6907   static int change_sides[4][2] =
6908   {
6909     /* center side       border side */
6910     { CH_SIDE_TOP,      CH_SIDE_BOTTOM  },      /* check top    */
6911     { CH_SIDE_LEFT,     CH_SIDE_RIGHT   },      /* check left   */
6912     { CH_SIDE_RIGHT,    CH_SIDE_LEFT    },      /* check right  */
6913     { CH_SIDE_BOTTOM,   CH_SIDE_TOP     }       /* check bottom */
6914   };
6915   boolean change_center_element = FALSE;
6916   int center_element_change_page = 0;
6917   int center_element = Feld[x][y];
6918   int i, j;
6919
6920 #if 0
6921   if (check_changing)   /* prevent this function from running into a loop */
6922     return;
6923
6924   check_changing = TRUE;
6925 #endif
6926
6927   for (i=0; i<4; i++)
6928   {
6929     int xx = x + xy[i][0];
6930     int yy = y + xy[i][1];
6931     int center_side = change_sides[i][0];
6932     int border_side = change_sides[i][1];
6933     int border_element;
6934
6935     if (!IN_LEV_FIELD(xx, yy))
6936       continue;
6937
6938     border_element = Feld[xx][yy];
6939
6940     /* check for change of center element (but change it only once) */
6941     if (IS_CUSTOM_ELEMENT(center_element) &&
6942         HAS_ANY_CHANGE_EVENT(center_element, CE_OTHER_IS_TOUCHING) &&
6943         !change_center_element)
6944     {
6945       for (j=0; j < element_info[center_element].num_change_pages; j++)
6946       {
6947         struct ElementChangeInfo *change =
6948           &element_info[center_element].change_page[j];
6949
6950         if (change->events & CH_EVENT_BIT(CE_OTHER_IS_TOUCHING) &&
6951             change->sides & border_side &&
6952             change->trigger_element == border_element)
6953         {
6954           change_center_element = TRUE;
6955           center_element_change_page = j;
6956
6957           break;
6958         }
6959       }
6960     }
6961
6962     /* check for change of border element */
6963     if (IS_CUSTOM_ELEMENT(border_element) &&
6964         HAS_ANY_CHANGE_EVENT(border_element, CE_OTHER_IS_TOUCHING))
6965     {
6966       for (j=0; j < element_info[border_element].num_change_pages; j++)
6967       {
6968         struct ElementChangeInfo *change =
6969           &element_info[border_element].change_page[j];
6970
6971         if (change->events & CH_EVENT_BIT(CE_OTHER_IS_TOUCHING) &&
6972             change->sides & center_side &&
6973             change->trigger_element == center_element)
6974         {
6975           CheckElementSideChange(xx, yy, border_element, CH_SIDE_ANY,
6976                                  CE_OTHER_IS_TOUCHING, j);
6977           break;
6978         }
6979       }
6980     }
6981   }
6982
6983   if (change_center_element)
6984     CheckElementSideChange(x, y, center_element, CH_SIDE_ANY,
6985                            CE_OTHER_IS_TOUCHING, center_element_change_page);
6986
6987 #if 0
6988   check_changing = FALSE;
6989 #endif
6990 }
6991
6992 void TestIfGoodThingHitsBadThing(int good_x, int good_y, int good_move_dir)
6993 {
6994   int i, kill_x = -1, kill_y = -1;
6995   static int test_xy[4][2] =
6996   {
6997     { 0, -1 },
6998     { -1, 0 },
6999     { +1, 0 },
7000     { 0, +1 }
7001   };
7002   static int test_dir[4] =
7003   {
7004     MV_UP,
7005     MV_LEFT,
7006     MV_RIGHT,
7007     MV_DOWN
7008   };
7009
7010   for (i=0; i<4; i++)
7011   {
7012     int test_x, test_y, test_move_dir, test_element;
7013
7014     test_x = good_x + test_xy[i][0];
7015     test_y = good_y + test_xy[i][1];
7016     if (!IN_LEV_FIELD(test_x, test_y))
7017       continue;
7018
7019     test_move_dir =
7020       (IS_MOVING(test_x, test_y) ? MovDir[test_x][test_y] : MV_NO_MOVING);
7021
7022 #if 0
7023     test_element = Feld[test_x][test_y];
7024 #else
7025     test_element = MovingOrBlocked2ElementIfNotLeaving(test_x, test_y);
7026 #endif
7027
7028     /* 1st case: good thing is moving towards DONT_RUN_INTO style bad thing;
7029        2nd case: DONT_TOUCH style bad thing does not move away from good thing
7030     */
7031     if ((DONT_RUN_INTO(test_element) && good_move_dir == test_dir[i]) ||
7032         (DONT_TOUCH(test_element)    && test_move_dir != test_dir[i]))
7033     {
7034       kill_x = test_x;
7035       kill_y = test_y;
7036       break;
7037     }
7038   }
7039
7040   if (kill_x != -1 || kill_y != -1)
7041   {
7042     if (IS_PLAYER(good_x, good_y))
7043     {
7044       struct PlayerInfo *player = PLAYERINFO(good_x, good_y);
7045
7046       if (player->shield_deadly_time_left > 0)
7047         Bang(kill_x, kill_y);
7048       else if (!PLAYER_PROTECTED(good_x, good_y))
7049         KillHero(player);
7050     }
7051     else
7052       Bang(good_x, good_y);
7053   }
7054 }
7055
7056 void TestIfBadThingHitsGoodThing(int bad_x, int bad_y, int bad_move_dir)
7057 {
7058   int i, kill_x = -1, kill_y = -1;
7059   int bad_element = Feld[bad_x][bad_y];
7060   static int test_xy[4][2] =
7061   {
7062     { 0, -1 },
7063     { -1, 0 },
7064     { +1, 0 },
7065     { 0, +1 }
7066   };
7067   static int test_dir[4] =
7068   {
7069     MV_UP,
7070     MV_LEFT,
7071     MV_RIGHT,
7072     MV_DOWN
7073   };
7074
7075   if (bad_element == EL_EXPLOSION)      /* skip just exploding bad things */
7076     return;
7077
7078   for (i=0; i<4; i++)
7079   {
7080     int test_x, test_y, test_move_dir, test_element;
7081
7082     test_x = bad_x + test_xy[i][0];
7083     test_y = bad_y + test_xy[i][1];
7084     if (!IN_LEV_FIELD(test_x, test_y))
7085       continue;
7086
7087     test_move_dir =
7088       (IS_MOVING(test_x, test_y) ? MovDir[test_x][test_y] : MV_NO_MOVING);
7089
7090     test_element = Feld[test_x][test_y];
7091
7092     /* 1st case: good thing is moving towards DONT_RUN_INTO style bad thing;
7093        2nd case: DONT_TOUCH style bad thing does not move away from good thing
7094     */
7095     if ((DONT_RUN_INTO(bad_element) &&  bad_move_dir == test_dir[i]) ||
7096         (DONT_TOUCH(bad_element)    && test_move_dir != test_dir[i]))
7097     {
7098       /* good thing is player or penguin that does not move away */
7099       if (IS_PLAYER(test_x, test_y))
7100       {
7101         struct PlayerInfo *player = PLAYERINFO(test_x, test_y);
7102
7103         if (bad_element == EL_ROBOT && player->is_moving)
7104           continue;     /* robot does not kill player if he is moving */
7105
7106         kill_x = test_x;
7107         kill_y = test_y;
7108         break;
7109       }
7110       else if (test_element == EL_PENGUIN)
7111       {
7112         kill_x = test_x;
7113         kill_y = test_y;
7114         break;
7115       }
7116     }
7117   }
7118
7119   if (kill_x != -1 || kill_y != -1)
7120   {
7121     if (IS_PLAYER(kill_x, kill_y))
7122     {
7123       struct PlayerInfo *player = PLAYERINFO(kill_x, kill_y);
7124
7125 #if 0
7126       int dir = player->MovDir;
7127       int newx = player->jx + (dir == MV_LEFT ? -1 : dir == MV_RIGHT ? +1 : 0);
7128       int newy = player->jy + (dir == MV_UP   ? -1 : dir == MV_DOWN  ? +1 : 0);
7129
7130       if (Feld[bad_x][bad_y] == EL_ROBOT && player->is_moving &&
7131           newx != bad_x && newy != bad_y)
7132         ;       /* robot does not kill player if he is moving */
7133       else
7134         printf("-> %d\n", player->MovDir);
7135
7136       if (Feld[bad_x][bad_y] == EL_ROBOT && player->is_moving &&
7137           newx != bad_x && newy != bad_y)
7138         ;       /* robot does not kill player if he is moving */
7139       else
7140         ;
7141 #endif
7142
7143       if (player->shield_deadly_time_left > 0)
7144         Bang(bad_x, bad_y);
7145       else if (!PLAYER_PROTECTED(kill_x, kill_y))
7146         KillHero(player);
7147     }
7148     else
7149       Bang(kill_x, kill_y);
7150   }
7151 }
7152
7153 void TestIfHeroTouchesBadThing(int x, int y)
7154 {
7155   TestIfGoodThingHitsBadThing(x, y, MV_NO_MOVING);
7156 }
7157
7158 void TestIfHeroRunsIntoBadThing(int x, int y, int move_dir)
7159 {
7160   TestIfGoodThingHitsBadThing(x, y, move_dir);
7161 }
7162
7163 void TestIfBadThingTouchesHero(int x, int y)
7164 {
7165   TestIfBadThingHitsGoodThing(x, y, MV_NO_MOVING);
7166 }
7167
7168 void TestIfBadThingRunsIntoHero(int x, int y, int move_dir)
7169 {
7170   TestIfBadThingHitsGoodThing(x, y, move_dir);
7171 }
7172
7173 void TestIfFriendTouchesBadThing(int x, int y)
7174 {
7175   TestIfGoodThingHitsBadThing(x, y, MV_NO_MOVING);
7176 }
7177
7178 void TestIfBadThingTouchesFriend(int x, int y)
7179 {
7180   TestIfBadThingHitsGoodThing(x, y, MV_NO_MOVING);
7181 }
7182
7183 void TestIfBadThingTouchesOtherBadThing(int bad_x, int bad_y)
7184 {
7185   int i, kill_x = bad_x, kill_y = bad_y;
7186   static int xy[4][2] =
7187   {
7188     { 0, -1 },
7189     { -1, 0 },
7190     { +1, 0 },
7191     { 0, +1 }
7192   };
7193
7194   for (i=0; i<4; i++)
7195   {
7196     int x, y, element;
7197
7198     x = bad_x + xy[i][0];
7199     y = bad_y + xy[i][1];
7200     if (!IN_LEV_FIELD(x, y))
7201       continue;
7202
7203     element = Feld[x][y];
7204     if (IS_AMOEBOID(element) || element == EL_GAME_OF_LIFE ||
7205         element == EL_AMOEBA_GROWING || element == EL_AMOEBA_DROP)
7206     {
7207       kill_x = x;
7208       kill_y = y;
7209       break;
7210     }
7211   }
7212
7213   if (kill_x != bad_x || kill_y != bad_y)
7214     Bang(bad_x, bad_y);
7215 }
7216
7217 void KillHero(struct PlayerInfo *player)
7218 {
7219   int jx = player->jx, jy = player->jy;
7220
7221   if (!player->active)
7222     return;
7223
7224   /* remove accessible field at the player's position */
7225   Feld[jx][jy] = EL_EMPTY;
7226
7227   /* deactivate shield (else Bang()/Explode() would not work right) */
7228   player->shield_normal_time_left = 0;
7229   player->shield_deadly_time_left = 0;
7230
7231   Bang(jx, jy);
7232   BuryHero(player);
7233 }
7234
7235 static void KillHeroUnlessProtected(int x, int y)
7236 {
7237   if (!PLAYER_PROTECTED(x, y))
7238     KillHero(PLAYERINFO(x, y));
7239 }
7240
7241 void BuryHero(struct PlayerInfo *player)
7242 {
7243   int jx = player->jx, jy = player->jy;
7244
7245   if (!player->active)
7246     return;
7247
7248 #if 1
7249   PlaySoundLevelElementAction(jx, jy, player->element_nr, ACTION_DYING);
7250 #else
7251   PlaySoundLevel(jx, jy, SND_CLASS_PLAYER_DYING);
7252 #endif
7253   PlaySoundLevel(jx, jy, SND_GAME_LOSING);
7254
7255   player->GameOver = TRUE;
7256   RemoveHero(player);
7257 }
7258
7259 void RemoveHero(struct PlayerInfo *player)
7260 {
7261   int jx = player->jx, jy = player->jy;
7262   int i, found = FALSE;
7263
7264   player->present = FALSE;
7265   player->active = FALSE;
7266
7267   if (!ExplodeField[jx][jy])
7268     StorePlayer[jx][jy] = 0;
7269
7270   for (i=0; i<MAX_PLAYERS; i++)
7271     if (stored_player[i].active)
7272       found = TRUE;
7273
7274   if (!found)
7275     AllPlayersGone = TRUE;
7276
7277   ExitX = ZX = jx;
7278   ExitY = ZY = jy;
7279 }
7280
7281 /*
7282   =============================================================================
7283   checkDiagonalPushing()
7284   -----------------------------------------------------------------------------
7285   check if diagonal input device direction results in pushing of object
7286   (by checking if the alternative direction is walkable, diggable, ...)
7287   =============================================================================
7288 */
7289
7290 static boolean checkDiagonalPushing(struct PlayerInfo *player,
7291                                     int x, int y, int real_dx, int real_dy)
7292 {
7293   int jx, jy, dx, dy, xx, yy;
7294
7295   if (real_dx == 0 || real_dy == 0)     /* no diagonal direction => push */
7296     return TRUE;
7297
7298   /* diagonal direction: check alternative direction */
7299   jx = player->jx;
7300   jy = player->jy;
7301   dx = x - jx;
7302   dy = y - jy;
7303   xx = jx + (dx == 0 ? real_dx : 0);
7304   yy = jy + (dy == 0 ? real_dy : 0);
7305
7306   return (!IN_LEV_FIELD(xx, yy) || IS_SOLID_FOR_PUSHING(Feld[xx][yy]));
7307 }
7308
7309 /*
7310   =============================================================================
7311   DigField()
7312   -----------------------------------------------------------------------------
7313   x, y:                 field next to player (non-diagonal) to try to dig to
7314   real_dx, real_dy:     direction as read from input device (can be diagonal)
7315   =============================================================================
7316 */
7317
7318 int DigField(struct PlayerInfo *player,
7319              int x, int y, int real_dx, int real_dy, int mode)
7320 {
7321   static int change_sides[4] =
7322   {
7323     CH_SIDE_RIGHT,      /* moving left  */
7324     CH_SIDE_LEFT,       /* moving right */
7325     CH_SIDE_BOTTOM,     /* moving up    */
7326     CH_SIDE_TOP,        /* moving down  */
7327   };
7328   boolean use_spring_bug = (game.engine_version < VERSION_IDENT(2,2,0));
7329   int jx = player->jx, jy = player->jy;
7330   int dx = x - jx, dy = y - jy;
7331   int nextx = x + dx, nexty = y + dy;
7332   int move_direction = (dx == -1 ? MV_LEFT :
7333                         dx == +1 ? MV_RIGHT :
7334                         dy == -1 ? MV_UP :
7335                         dy == +1 ? MV_DOWN : MV_NO_MOVING);
7336   int dig_side = change_sides[MV_DIR_BIT(move_direction)];
7337   int element;
7338
7339   if (player->MovPos == 0)
7340   {
7341     player->is_digging = FALSE;
7342     player->is_collecting = FALSE;
7343   }
7344
7345   if (player->MovPos == 0)      /* last pushing move finished */
7346     player->Pushing = FALSE;
7347
7348   if (mode == DF_NO_PUSH)       /* player just stopped pushing */
7349   {
7350     player->Switching = FALSE;
7351     player->push_delay = 0;
7352
7353     return MF_NO_ACTION;
7354   }
7355
7356   if (IS_MOVING(x, y) || IS_PLAYER(x, y))
7357     return MF_NO_ACTION;
7358
7359 #if 0
7360   if (IS_TUBE(Feld[jx][jy]) || IS_TUBE(Back[jx][jy]))
7361 #else
7362   if (IS_TUBE(Feld[jx][jy]) ||
7363       (IS_TUBE(Back[jx][jy]) && game.engine_version >= VERSION_IDENT(2,2,0)))
7364 #endif
7365   {
7366     int i = 0;
7367     int tube_element = (IS_TUBE(Feld[jx][jy]) ? Feld[jx][jy] : Back[jx][jy]);
7368     int tube_leave_directions[][2] =
7369     {
7370       { EL_TUBE_ANY,                    MV_LEFT | MV_RIGHT | MV_UP | MV_DOWN },
7371       { EL_TUBE_VERTICAL,                                    MV_UP | MV_DOWN },
7372       { EL_TUBE_HORIZONTAL,             MV_LEFT | MV_RIGHT                   },
7373       { EL_TUBE_VERTICAL_LEFT,          MV_LEFT |            MV_UP | MV_DOWN },
7374       { EL_TUBE_VERTICAL_RIGHT,                   MV_RIGHT | MV_UP | MV_DOWN },
7375       { EL_TUBE_HORIZONTAL_UP,          MV_LEFT | MV_RIGHT | MV_UP           },
7376       { EL_TUBE_HORIZONTAL_DOWN,        MV_LEFT | MV_RIGHT |         MV_DOWN },
7377       { EL_TUBE_LEFT_UP,                MV_LEFT |            MV_UP           },
7378       { EL_TUBE_LEFT_DOWN,              MV_LEFT |                    MV_DOWN },
7379       { EL_TUBE_RIGHT_UP,                         MV_RIGHT | MV_UP           },
7380       { EL_TUBE_RIGHT_DOWN,                       MV_RIGHT |         MV_DOWN },
7381       { -1,                             MV_LEFT | MV_RIGHT | MV_UP | MV_DOWN }
7382     };
7383
7384     while (tube_leave_directions[i][0] != tube_element)
7385     {
7386       i++;
7387       if (tube_leave_directions[i][0] == -1)    /* should not happen */
7388         break;
7389     }
7390
7391     if (!(tube_leave_directions[i][1] & move_direction))
7392       return MF_NO_ACTION;      /* tube has no opening in this direction */
7393   }
7394
7395   element = Feld[x][y];
7396
7397   if (mode == DF_SNAP && !IS_SNAPPABLE(element) &&
7398       game.engine_version >= VERSION_IDENT(2,2,0))
7399     return MF_NO_ACTION;
7400
7401   switch (element)
7402   {
7403     case EL_ROBOT_WHEEL:
7404       Feld[x][y] = EL_ROBOT_WHEEL_ACTIVE;
7405       ZX = x;
7406       ZY = y;
7407       DrawLevelField(x, y);
7408       PlaySoundLevel(x, y, SND_ROBOT_WHEEL_ACTIVATING);
7409       return MF_ACTION;
7410       break;
7411
7412     case EL_SP_TERMINAL:
7413       {
7414         int xx, yy;
7415
7416         PlaySoundLevel(x, y, SND_SP_TERMINAL_ACTIVATING);
7417
7418         for (yy=0; yy<lev_fieldy; yy++)
7419         {
7420           for (xx=0; xx<lev_fieldx; xx++)
7421           {
7422             if (Feld[xx][yy] == EL_SP_DISK_YELLOW)
7423               Bang(xx, yy);
7424             else if (Feld[xx][yy] == EL_SP_TERMINAL)
7425               Feld[xx][yy] = EL_SP_TERMINAL_ACTIVE;
7426           }
7427         }
7428
7429         return MF_ACTION;
7430       }
7431       break;
7432
7433     case EL_CONVEYOR_BELT_1_SWITCH_LEFT:
7434     case EL_CONVEYOR_BELT_1_SWITCH_MIDDLE:
7435     case EL_CONVEYOR_BELT_1_SWITCH_RIGHT:
7436     case EL_CONVEYOR_BELT_2_SWITCH_LEFT:
7437     case EL_CONVEYOR_BELT_2_SWITCH_MIDDLE:
7438     case EL_CONVEYOR_BELT_2_SWITCH_RIGHT:
7439     case EL_CONVEYOR_BELT_3_SWITCH_LEFT:
7440     case EL_CONVEYOR_BELT_3_SWITCH_MIDDLE:
7441     case EL_CONVEYOR_BELT_3_SWITCH_RIGHT:
7442     case EL_CONVEYOR_BELT_4_SWITCH_LEFT:
7443     case EL_CONVEYOR_BELT_4_SWITCH_MIDDLE:
7444     case EL_CONVEYOR_BELT_4_SWITCH_RIGHT:
7445       if (!player->Switching)
7446       {
7447         player->Switching = TRUE;
7448         ToggleBeltSwitch(x, y);
7449         PlaySoundLevel(x, y, SND_CLASS_CONVEYOR_BELT_SWITCH_ACTIVATING);
7450       }
7451       return MF_ACTION;
7452       break;
7453
7454     case EL_SWITCHGATE_SWITCH_UP:
7455     case EL_SWITCHGATE_SWITCH_DOWN:
7456       if (!player->Switching)
7457       {
7458         player->Switching = TRUE;
7459         ToggleSwitchgateSwitch(x, y);
7460         PlaySoundLevel(x, y, SND_CLASS_SWITCHGATE_SWITCH_ACTIVATING);
7461       }
7462       return MF_ACTION;
7463       break;
7464
7465     case EL_LIGHT_SWITCH:
7466     case EL_LIGHT_SWITCH_ACTIVE:
7467       if (!player->Switching)
7468       {
7469         player->Switching = TRUE;
7470         ToggleLightSwitch(x, y);
7471         PlaySoundLevel(x, y, element == EL_LIGHT_SWITCH ?
7472                        SND_LIGHT_SWITCH_ACTIVATING :
7473                        SND_LIGHT_SWITCH_DEACTIVATING);
7474       }
7475       return MF_ACTION;
7476       break;
7477
7478     case EL_TIMEGATE_SWITCH:
7479       ActivateTimegateSwitch(x, y);
7480       PlaySoundLevel(x, y, SND_TIMEGATE_SWITCH_ACTIVATING);
7481
7482       return MF_ACTION;
7483       break;
7484
7485     case EL_BALLOON_SWITCH_LEFT:
7486     case EL_BALLOON_SWITCH_RIGHT:
7487     case EL_BALLOON_SWITCH_UP:
7488     case EL_BALLOON_SWITCH_DOWN:
7489     case EL_BALLOON_SWITCH_ANY:
7490       if (element == EL_BALLOON_SWITCH_ANY)
7491         game.balloon_dir = move_direction;
7492       else
7493         game.balloon_dir = (element == EL_BALLOON_SWITCH_LEFT  ? MV_LEFT :
7494                             element == EL_BALLOON_SWITCH_RIGHT ? MV_RIGHT :
7495                             element == EL_BALLOON_SWITCH_UP    ? MV_UP :
7496                             element == EL_BALLOON_SWITCH_DOWN  ? MV_DOWN :
7497                             MV_NO_MOVING);
7498       PlaySoundLevel(x, y, SND_CLASS_BALLOON_SWITCH_ACTIVATING);
7499
7500       return MF_ACTION;
7501       break;
7502
7503     case EL_SP_PORT_LEFT:
7504     case EL_SP_PORT_RIGHT:
7505     case EL_SP_PORT_UP:
7506     case EL_SP_PORT_DOWN:
7507     case EL_SP_PORT_HORIZONTAL:
7508     case EL_SP_PORT_VERTICAL:
7509     case EL_SP_PORT_ANY:
7510     case EL_SP_GRAVITY_PORT_LEFT:
7511     case EL_SP_GRAVITY_PORT_RIGHT:
7512     case EL_SP_GRAVITY_PORT_UP:
7513     case EL_SP_GRAVITY_PORT_DOWN:
7514       if ((dx == -1 &&
7515            element != EL_SP_PORT_LEFT &&
7516            element != EL_SP_GRAVITY_PORT_LEFT &&
7517            element != EL_SP_PORT_HORIZONTAL &&
7518            element != EL_SP_PORT_ANY) ||
7519           (dx == +1 &&
7520            element != EL_SP_PORT_RIGHT &&
7521            element != EL_SP_GRAVITY_PORT_RIGHT &&
7522            element != EL_SP_PORT_HORIZONTAL &&
7523            element != EL_SP_PORT_ANY) ||
7524           (dy == -1 &&
7525            element != EL_SP_PORT_UP &&
7526            element != EL_SP_GRAVITY_PORT_UP &&
7527            element != EL_SP_PORT_VERTICAL &&
7528            element != EL_SP_PORT_ANY) ||
7529           (dy == +1 &&
7530            element != EL_SP_PORT_DOWN &&
7531            element != EL_SP_GRAVITY_PORT_DOWN &&
7532            element != EL_SP_PORT_VERTICAL &&
7533            element != EL_SP_PORT_ANY) ||
7534           !IN_LEV_FIELD(nextx, nexty) ||
7535           !IS_FREE(nextx, nexty))
7536         return MF_NO_ACTION;
7537
7538       if (element == EL_SP_GRAVITY_PORT_LEFT ||
7539           element == EL_SP_GRAVITY_PORT_RIGHT ||
7540           element == EL_SP_GRAVITY_PORT_UP ||
7541           element == EL_SP_GRAVITY_PORT_DOWN)
7542         level.gravity = !level.gravity;
7543
7544       /* automatically move to the next field with double speed */
7545       player->programmed_action = move_direction;
7546       DOUBLE_PLAYER_SPEED(player);
7547
7548       PlaySoundLevel(x, y, SND_CLASS_SP_PORT_PASSING);
7549       break;
7550
7551     case EL_TUBE_ANY:
7552     case EL_TUBE_VERTICAL:
7553     case EL_TUBE_HORIZONTAL:
7554     case EL_TUBE_VERTICAL_LEFT:
7555     case EL_TUBE_VERTICAL_RIGHT:
7556     case EL_TUBE_HORIZONTAL_UP:
7557     case EL_TUBE_HORIZONTAL_DOWN:
7558     case EL_TUBE_LEFT_UP:
7559     case EL_TUBE_LEFT_DOWN:
7560     case EL_TUBE_RIGHT_UP:
7561     case EL_TUBE_RIGHT_DOWN:
7562       {
7563         int i = 0;
7564         int tube_enter_directions[][2] =
7565         {
7566           { EL_TUBE_ANY,                MV_LEFT | MV_RIGHT | MV_UP | MV_DOWN },
7567           { EL_TUBE_VERTICAL,                                MV_UP | MV_DOWN },
7568           { EL_TUBE_HORIZONTAL,         MV_LEFT | MV_RIGHT                   },
7569           { EL_TUBE_VERTICAL_LEFT,                MV_RIGHT | MV_UP | MV_DOWN },
7570           { EL_TUBE_VERTICAL_RIGHT,     MV_LEFT            | MV_UP | MV_DOWN },
7571           { EL_TUBE_HORIZONTAL_UP,      MV_LEFT | MV_RIGHT |         MV_DOWN },
7572           { EL_TUBE_HORIZONTAL_DOWN,    MV_LEFT | MV_RIGHT | MV_UP           },
7573           { EL_TUBE_LEFT_UP,                      MV_RIGHT |         MV_DOWN },
7574           { EL_TUBE_LEFT_DOWN,                    MV_RIGHT | MV_UP           },
7575           { EL_TUBE_RIGHT_UP,           MV_LEFT |                    MV_DOWN },
7576           { EL_TUBE_RIGHT_DOWN,         MV_LEFT |            MV_UP           },
7577           { -1,                         MV_NO_MOVING                         }
7578         };
7579
7580         while (tube_enter_directions[i][0] != element)
7581         {
7582           i++;
7583           if (tube_enter_directions[i][0] == -1)        /* should not happen */
7584             break;
7585         }
7586
7587         if (!(tube_enter_directions[i][1] & move_direction))
7588           return MF_NO_ACTION;  /* tube has no opening in this direction */
7589
7590         PlaySoundLevel(x, y, SND_CLASS_TUBE_WALKING);
7591       }
7592       break;
7593
7594     case EL_LAMP:
7595       Feld[x][y] = EL_LAMP_ACTIVE;
7596       local_player->lights_still_needed--;
7597       DrawLevelField(x, y);
7598       PlaySoundLevel(x, y, SND_LAMP_ACTIVATING);
7599       return MF_ACTION;
7600       break;
7601
7602     case EL_TIME_ORB_FULL:
7603       Feld[x][y] = EL_TIME_ORB_EMPTY;
7604       TimeLeft += 10;
7605       DrawText(DX_TIME, DY_TIME, int2str(TimeLeft, 3), FONT_TEXT_2);
7606       DrawLevelField(x, y);
7607       PlaySoundStereo(SND_TIME_ORB_FULL_COLLECTING, SOUND_MIDDLE);
7608       return MF_ACTION;
7609       break;
7610
7611     default:
7612
7613       if (IS_WALKABLE(element))
7614       {
7615         int sound_action = ACTION_WALKING;
7616
7617         if (element >= EL_GATE_1 && element <= EL_GATE_4)
7618         {
7619           if (!player->key[element - EL_GATE_1])
7620             return MF_NO_ACTION;
7621         }
7622         else if (element >= EL_GATE_1_GRAY && element <= EL_GATE_4_GRAY)
7623         {
7624           if (!player->key[element - EL_GATE_1_GRAY])
7625             return MF_NO_ACTION;
7626         }
7627         else if (element == EL_EXIT_OPEN || element == EL_SP_EXIT_OPEN)
7628         {
7629           sound_action = ACTION_PASSING;        /* player is passing exit */
7630         }
7631         else if (element == EL_EMPTY)
7632         {
7633           sound_action = ACTION_MOVING;         /* nothing to walk on */
7634         }
7635
7636         /* play sound from background or player, whatever is available */
7637         if (element_info[element].sound[sound_action] != SND_UNDEFINED)
7638           PlaySoundLevelElementAction(x, y, element, sound_action);
7639         else
7640           PlaySoundLevelElementAction(x, y, player->element_nr, sound_action);
7641
7642         break;
7643       }
7644       else if (IS_PASSABLE(element))
7645       {
7646         if (!IN_LEV_FIELD(nextx, nexty) || !IS_FREE(nextx, nexty))
7647           return MF_NO_ACTION;
7648
7649         if (element >= EL_EM_GATE_1 && element <= EL_EM_GATE_4)
7650         {
7651           if (!player->key[element - EL_EM_GATE_1])
7652             return MF_NO_ACTION;
7653         }
7654         else if (element >= EL_EM_GATE_1_GRAY && element <= EL_EM_GATE_4_GRAY)
7655         {
7656           if (!player->key[element - EL_EM_GATE_1_GRAY])
7657             return MF_NO_ACTION;
7658         }
7659
7660         /* automatically move to the next field with double speed */
7661         player->programmed_action = move_direction;
7662         DOUBLE_PLAYER_SPEED(player);
7663
7664         PlaySoundLevelAction(x, y, ACTION_PASSING);
7665
7666         break;
7667       }
7668       else if (IS_DIGGABLE(element))
7669       {
7670         RemoveField(x, y);
7671
7672         if (mode != DF_SNAP)
7673         {
7674 #if 1
7675           GfxElement[x][y] = GFX_ELEMENT(element);
7676 #else
7677           GfxElement[x][y] =
7678             (GFX_CRUMBLED(element) ? EL_SAND : GFX_ELEMENT(element));
7679 #endif
7680           player->is_digging = TRUE;
7681         }
7682
7683         PlaySoundLevelElementAction(x, y, element, ACTION_DIGGING);
7684
7685         CheckTriggeredElementChange(x, y, element, CE_OTHER_GETS_DIGGED);
7686
7687         TestIfElementTouchesCustomElement(x, y);        /* for empty space */
7688
7689         break;
7690       }
7691       else if (IS_COLLECTIBLE(element))
7692       {
7693         RemoveField(x, y);
7694
7695         if (mode != DF_SNAP)
7696         {
7697           GfxElement[x][y] = element;
7698           player->is_collecting = TRUE;
7699         }
7700
7701         if (element == EL_SPEED_PILL)
7702           player->move_delay_value = MOVE_DELAY_HIGH_SPEED;
7703         else if (element == EL_EXTRA_TIME && level.time > 0)
7704         {
7705           TimeLeft += 10;
7706           DrawText(DX_TIME, DY_TIME, int2str(TimeLeft, 3), FONT_TEXT_2);
7707         }
7708         else if (element == EL_SHIELD_NORMAL || element == EL_SHIELD_DEADLY)
7709         {
7710           player->shield_normal_time_left += 10;
7711           if (element == EL_SHIELD_DEADLY)
7712             player->shield_deadly_time_left += 10;
7713         }
7714         else if (element == EL_DYNAMITE || element == EL_SP_DISK_RED)
7715         {
7716           if (player->inventory_size < MAX_INVENTORY_SIZE)
7717             player->inventory_element[player->inventory_size++] = element;
7718
7719           player->use_disk_red_graphic = (element == EL_SP_DISK_RED);
7720
7721           DrawText(DX_DYNAMITE, DY_DYNAMITE,
7722                    int2str(local_player->inventory_size, 3), FONT_TEXT_2);
7723         }
7724         else if (element == EL_DYNABOMB_INCREASE_NUMBER)
7725         {
7726           player->dynabomb_count++;
7727           player->dynabombs_left++;
7728         }
7729         else if (element == EL_DYNABOMB_INCREASE_SIZE)
7730         {
7731           player->dynabomb_size++;
7732         }
7733         else if (element == EL_DYNABOMB_INCREASE_POWER)
7734         {
7735           player->dynabomb_xl = TRUE;
7736         }
7737         else if ((element >= EL_KEY_1 && element <= EL_KEY_4) ||
7738                  (element >= EL_EM_KEY_1 && element <= EL_EM_KEY_4))
7739         {
7740           int key_nr = (element >= EL_KEY_1 && element <= EL_KEY_4 ?
7741                         element - EL_KEY_1 : element - EL_EM_KEY_1);
7742
7743           player->key[key_nr] = TRUE;
7744
7745           DrawMiniGraphicExt(drawto, DX_KEYS + key_nr * MINI_TILEX, DY_KEYS,
7746                              el2edimg(EL_KEY_1 + key_nr));
7747           redraw_mask |= REDRAW_DOOR_1;
7748         }
7749         else if (IS_ENVELOPE(element))
7750         {
7751 #if 1
7752           player->show_envelope = element;
7753 #else
7754           ShowEnvelope(element - EL_ENVELOPE_1);
7755 #endif
7756         }
7757         else if (IS_DROPPABLE(element)) /* can be collected and dropped */
7758         {
7759           int i;
7760
7761           for (i=0; i < element_info[element].collect_count; i++)
7762             if (player->inventory_size < MAX_INVENTORY_SIZE)
7763               player->inventory_element[player->inventory_size++] = element;
7764
7765           DrawText(DX_DYNAMITE, DY_DYNAMITE,
7766                    int2str(local_player->inventory_size, 3), FONT_TEXT_2);
7767         }
7768         else if (element_info[element].collect_count > 0)
7769         {
7770           local_player->gems_still_needed -=
7771             element_info[element].collect_count;
7772           if (local_player->gems_still_needed < 0)
7773             local_player->gems_still_needed = 0;
7774
7775           DrawText(DX_EMERALDS, DY_EMERALDS,
7776                    int2str(local_player->gems_still_needed, 3), FONT_TEXT_2);
7777         }
7778
7779         RaiseScoreElement(element);
7780         PlaySoundLevelElementAction(x, y, element, ACTION_COLLECTING);
7781
7782         CheckTriggeredElementChange(x, y, element, CE_OTHER_GETS_COLLECTED);
7783
7784         TestIfElementTouchesCustomElement(x, y);        /* for empty space */
7785
7786         break;
7787       }
7788       else if (IS_PUSHABLE(element))
7789       {
7790         if (mode == DF_SNAP && element != EL_BD_ROCK)
7791           return MF_NO_ACTION;
7792
7793         if (CAN_FALL(element) && dy)
7794           return MF_NO_ACTION;
7795
7796         if (CAN_FALL(element) && IN_LEV_FIELD(x, y + 1) && IS_FREE(x, y + 1) &&
7797             !(element == EL_SPRING && use_spring_bug))
7798           return MF_NO_ACTION;
7799
7800 #if 1
7801         /*
7802         printf("::: %d [%d,%d,%d => %d]\n", MovDir[x][y],
7803                CAN_MOVE(element), move_direction, getElementMoveStepsize(x, y),
7804                (CAN_MOVE(element) && MovDir[x][y] == move_direction &&
7805                 getElementMoveStepsize(x, y) > MOVE_STEPSIZE_NORMAL) );
7806         */
7807
7808         /* do not push elements already moving away faster than player */
7809         if (CAN_MOVE(element) && MovDir[x][y] == move_direction &&
7810             ABS(getElementMoveStepsize(x, y)) > MOVE_STEPSIZE_NORMAL)
7811           return MF_NO_ACTION;
7812 #else
7813         if (element == EL_SPRING && MovDir[x][y] != MV_NO_MOVING)
7814           return MF_NO_ACTION;
7815 #endif
7816         if (!player->Pushing &&
7817             game.engine_version >= RELEASE_IDENT(2,2,0,7))
7818           player->push_delay_value = GET_NEW_PUSH_DELAY(element);
7819
7820         player->Pushing = TRUE;
7821
7822         if (!(IN_LEV_FIELD(nextx, nexty) &&
7823               (IS_FREE(nextx, nexty) ||
7824                (Feld[nextx][nexty] == EL_SOKOBAN_FIELD_EMPTY &&
7825                 IS_SB_ELEMENT(element)))))
7826           return MF_NO_ACTION;
7827
7828         if (!checkDiagonalPushing(player, x, y, real_dx, real_dy))
7829           return MF_NO_ACTION;
7830
7831         if (player->push_delay == 0)    /* new pushing; restart delay */
7832           player->push_delay = FrameCounter;
7833
7834         if (!FrameReached(&player->push_delay, player->push_delay_value) &&
7835             !(tape.playing && tape.file_version < FILE_VERSION_2_0) &&
7836             element != EL_SPRING && element != EL_BALLOON)
7837           return MF_NO_ACTION;
7838
7839         if (IS_SB_ELEMENT(element))
7840         {
7841           if (element == EL_SOKOBAN_FIELD_FULL)
7842           {
7843             Back[x][y] = EL_SOKOBAN_FIELD_EMPTY;
7844             local_player->sokobanfields_still_needed++;
7845           }
7846
7847           if (Feld[nextx][nexty] == EL_SOKOBAN_FIELD_EMPTY)
7848           {
7849             Back[nextx][nexty] = EL_SOKOBAN_FIELD_EMPTY;
7850             local_player->sokobanfields_still_needed--;
7851           }
7852
7853           Feld[x][y] = EL_SOKOBAN_OBJECT;
7854
7855           if (Back[x][y] == Back[nextx][nexty])
7856             PlaySoundLevelAction(x, y, ACTION_PUSHING);
7857           else if (Back[x][y] != 0)
7858             PlaySoundLevelElementAction(x, y, EL_SOKOBAN_FIELD_FULL,
7859                                         ACTION_EMPTYING);
7860           else
7861             PlaySoundLevelElementAction(nextx, nexty, EL_SOKOBAN_FIELD_EMPTY,
7862                                         ACTION_FILLING);
7863
7864           if (local_player->sokobanfields_still_needed == 0 &&
7865               game.emulation == EMU_SOKOBAN)
7866           {
7867             player->LevelSolved = player->GameOver = TRUE;
7868             PlaySoundLevel(x, y, SND_GAME_SOKOBAN_SOLVING);
7869           }
7870         }
7871         else
7872           PlaySoundLevelElementAction(x, y, element, ACTION_PUSHING);
7873
7874         InitMovingField(x, y, move_direction);
7875         GfxAction[x][y] = ACTION_PUSHING;
7876
7877         if (mode == DF_SNAP)
7878           ContinueMoving(x, y);
7879         else
7880           MovPos[x][y] = (dx != 0 ? dx : dy);
7881
7882         Pushed[x][y] = TRUE;
7883         Pushed[nextx][nexty] = TRUE;
7884
7885         if (game.engine_version < RELEASE_IDENT(2,2,0,7))
7886           player->push_delay_value = GET_NEW_PUSH_DELAY(element);
7887
7888 #if 1
7889         CheckTriggeredElementSideChange(x, y, element, dig_side,
7890                                         CE_OTHER_GETS_PUSHED);
7891         CheckElementSideChange(x, y, element, dig_side,
7892                                CE_PUSHED_BY_PLAYER, -1);
7893 #else
7894         CheckTriggeredElementChange(x, y, element, CE_OTHER_GETS_PUSHED);
7895         CheckElementChange(x, y, element, CE_PUSHED_BY_PLAYER);
7896 #endif
7897
7898         break;
7899       }
7900       else
7901       {
7902 #if 1
7903         CheckTriggeredElementSideChange(x, y, element, dig_side,
7904                                     CE_OTHER_GETS_PRESSED);
7905         CheckElementSideChange(x, y, element, dig_side,
7906                                CE_PRESSED_BY_PLAYER, -1);
7907 #else
7908         CheckTriggeredElementChange(x, y, element, CE_OTHER_GETS_PRESSED);
7909         CheckElementChange(x, y, element, CE_PRESSED_BY_PLAYER);
7910 #endif
7911       }
7912
7913       return MF_NO_ACTION;
7914   }
7915
7916   player->push_delay = 0;
7917
7918   if (Feld[x][y] != element)            /* really digged/collected something */
7919     player->is_collecting = !player->is_digging;
7920
7921   return MF_MOVING;
7922 }
7923
7924 boolean SnapField(struct PlayerInfo *player, int dx, int dy)
7925 {
7926   int jx = player->jx, jy = player->jy;
7927   int x = jx + dx, y = jy + dy;
7928   int snap_direction = (dx == -1 ? MV_LEFT :
7929                         dx == +1 ? MV_RIGHT :
7930                         dy == -1 ? MV_UP :
7931                         dy == +1 ? MV_DOWN : MV_NO_MOVING);
7932
7933   if (player->MovPos && game.engine_version >= VERSION_IDENT(2,2,0))
7934     return FALSE;
7935
7936   if (!player->active || !IN_LEV_FIELD(x, y))
7937     return FALSE;
7938
7939   if (dx && dy)
7940     return FALSE;
7941
7942   if (!dx && !dy)
7943   {
7944     if (player->MovPos == 0)
7945       player->Pushing = FALSE;
7946
7947     player->snapped = FALSE;
7948
7949     if (player->MovPos == 0)
7950     {
7951       player->is_digging = FALSE;
7952       player->is_collecting = FALSE;
7953 #if 1
7954       player->is_moving = FALSE;
7955 #endif
7956     }
7957
7958 #if 0
7959     printf("::: trying to snap...\n");
7960 #endif
7961
7962     return FALSE;
7963   }
7964
7965   if (player->snapped)
7966     return FALSE;
7967
7968   player->MovDir = snap_direction;
7969
7970 #if 1
7971   player->is_digging = FALSE;
7972   player->is_collecting = FALSE;
7973 #if 1
7974   player->is_moving = FALSE;
7975 #endif
7976 #endif
7977
7978   if (DigField(player, x, y, 0, 0, DF_SNAP) == MF_NO_ACTION)
7979     return FALSE;
7980
7981   player->snapped = TRUE;
7982 #if 1
7983   player->is_digging = FALSE;
7984   player->is_collecting = FALSE;
7985 #if 1
7986   player->is_moving = FALSE;
7987 #endif
7988 #endif
7989
7990   DrawLevelField(x, y);
7991   BackToFront();
7992
7993   return TRUE;
7994 }
7995
7996 boolean DropElement(struct PlayerInfo *player)
7997 {
7998   int jx = player->jx, jy = player->jy;
7999   int old_element;
8000
8001   if (!player->active || player->MovPos)
8002     return FALSE;
8003
8004   old_element = Feld[jx][jy];
8005
8006   /* check if player has anything that can be dropped */
8007   if (player->inventory_size == 0 && player->dynabombs_left == 0)
8008     return FALSE;
8009
8010   /* check if anything can be dropped at the current position */
8011   if (IS_ACTIVE_BOMB(old_element) || old_element == EL_EXPLOSION)
8012     return FALSE;
8013
8014   /* collected custom elements can only be dropped on empty fields */
8015   if (player->inventory_size > 0 &&
8016       IS_CUSTOM_ELEMENT(player->inventory_element[player->inventory_size - 1])
8017       && old_element != EL_EMPTY)
8018     return FALSE;
8019
8020   if (old_element != EL_EMPTY)
8021     Back[jx][jy] = old_element;         /* store old element on this field */
8022
8023   MovDelay[jx][jy] = 96;
8024
8025   ResetGfxAnimation(jx, jy);
8026   ResetRandomAnimationValue(jx, jy);
8027
8028   if (player->inventory_size > 0)
8029   {
8030     int new_element = player->inventory_element[--player->inventory_size];
8031
8032 #if 1
8033     Feld[jx][jy] = (new_element == EL_DYNAMITE ? EL_DYNAMITE_ACTIVE :
8034                     new_element == EL_SP_DISK_RED ? EL_SP_DISK_RED_ACTIVE :
8035                     new_element);
8036 #else
8037     Feld[jx][jy] = (player->use_disk_red_graphic ? EL_SP_DISK_RED_ACTIVE :
8038                     EL_DYNAMITE_ACTIVE);
8039 #endif
8040
8041     DrawText(DX_DYNAMITE, DY_DYNAMITE,
8042              int2str(local_player->inventory_size, 3), FONT_TEXT_2);
8043
8044     if (IN_SCR_FIELD(SCREENX(jx), SCREENY(jy)))
8045       DrawGraphicThruMask(SCREENX(jx), SCREENY(jy), el2img(Feld[jx][jy]), 0);
8046
8047     PlaySoundLevelAction(jx, jy, ACTION_DROPPING);
8048
8049     CheckTriggeredElementChange(jx, jy, new_element, CE_OTHER_GETS_DROPPED);
8050     CheckElementChange(jx, jy, new_element, CE_DROPPED_BY_PLAYER);
8051
8052     TestIfElementTouchesCustomElement(jx, jy);
8053   }
8054   else          /* player is dropping a dyna bomb */
8055   {
8056     player->dynabombs_left--;
8057
8058     Feld[jx][jy] =
8059       EL_DYNABOMB_PLAYER_1_ACTIVE + (player->element_nr - EL_PLAYER_1);
8060
8061     if (IN_SCR_FIELD(SCREENX(jx), SCREENY(jy)))
8062       DrawGraphicThruMask(SCREENX(jx), SCREENY(jy), el2img(Feld[jx][jy]), 0);
8063
8064     PlaySoundLevelAction(jx, jy, ACTION_DROPPING);
8065   }
8066
8067   return TRUE;
8068 }
8069
8070 /* ------------------------------------------------------------------------- */
8071 /* game sound playing functions                                              */
8072 /* ------------------------------------------------------------------------- */
8073
8074 static int *loop_sound_frame = NULL;
8075 static int *loop_sound_volume = NULL;
8076
8077 void InitPlaySoundLevel()
8078 {
8079   int num_sounds = getSoundListSize();
8080
8081   if (loop_sound_frame != NULL)
8082     free(loop_sound_frame);
8083
8084   if (loop_sound_volume != NULL)
8085     free(loop_sound_volume);
8086
8087   loop_sound_frame = checked_calloc(num_sounds * sizeof(int));
8088   loop_sound_volume = checked_calloc(num_sounds * sizeof(int));
8089 }
8090
8091 static void PlaySoundLevel(int x, int y, int nr)
8092 {
8093   int sx = SCREENX(x), sy = SCREENY(y);
8094   int volume, stereo_position;
8095   int max_distance = 8;
8096   int type = (IS_LOOP_SOUND(nr) ? SND_CTRL_PLAY_LOOP : SND_CTRL_PLAY_SOUND);
8097
8098   if ((!setup.sound_simple && !IS_LOOP_SOUND(nr)) ||
8099       (!setup.sound_loops && IS_LOOP_SOUND(nr)))
8100     return;
8101
8102   if (!IN_LEV_FIELD(x, y) ||
8103       sx < -max_distance || sx >= SCR_FIELDX + max_distance ||
8104       sy < -max_distance || sy >= SCR_FIELDY + max_distance)
8105     return;
8106
8107   volume = SOUND_MAX_VOLUME;
8108
8109   if (!IN_SCR_FIELD(sx, sy))
8110   {
8111     int dx = ABS(sx - SCR_FIELDX / 2) - SCR_FIELDX / 2;
8112     int dy = ABS(sy - SCR_FIELDY / 2) - SCR_FIELDY / 2;
8113
8114     volume -= volume * (dx > dy ? dx : dy) / max_distance;
8115   }
8116
8117   stereo_position = (SOUND_MAX_LEFT +
8118                      (sx + max_distance) * SOUND_MAX_LEFT2RIGHT /
8119                      (SCR_FIELDX + 2 * max_distance));
8120
8121   if (IS_LOOP_SOUND(nr))
8122   {
8123     /* This assures that quieter loop sounds do not overwrite louder ones,
8124        while restarting sound volume comparison with each new game frame. */
8125
8126     if (loop_sound_volume[nr] > volume && loop_sound_frame[nr] == FrameCounter)
8127       return;
8128
8129     loop_sound_volume[nr] = volume;
8130     loop_sound_frame[nr] = FrameCounter;
8131   }
8132
8133   PlaySoundExt(nr, volume, stereo_position, type);
8134 }
8135
8136 static void PlaySoundLevelNearest(int x, int y, int sound_action)
8137 {
8138   PlaySoundLevel(x < LEVELX(BX1) ? LEVELX(BX1) :
8139                  x > LEVELX(BX2) ? LEVELX(BX2) : x,
8140                  y < LEVELY(BY1) ? LEVELY(BY1) :
8141                  y > LEVELY(BY2) ? LEVELY(BY2) : y,
8142                  sound_action);
8143 }
8144
8145 static void PlaySoundLevelAction(int x, int y, int action)
8146 {
8147   PlaySoundLevelElementAction(x, y, Feld[x][y], action);
8148 }
8149
8150 static void PlaySoundLevelElementAction(int x, int y, int element, int action)
8151 {
8152   int sound_effect = element_info[element].sound[action];
8153
8154   if (sound_effect != SND_UNDEFINED)
8155     PlaySoundLevel(x, y, sound_effect);
8156 }
8157
8158 static void PlaySoundLevelActionIfLoop(int x, int y, int action)
8159 {
8160   int sound_effect = element_info[Feld[x][y]].sound[action];
8161
8162   if (sound_effect != SND_UNDEFINED && IS_LOOP_SOUND(sound_effect))
8163     PlaySoundLevel(x, y, sound_effect);
8164 }
8165
8166 static void StopSoundLevelActionIfLoop(int x, int y, int action)
8167 {
8168   int sound_effect = element_info[Feld[x][y]].sound[action];
8169
8170   if (sound_effect != SND_UNDEFINED && IS_LOOP_SOUND(sound_effect))
8171     StopSoundExt(sound_effect, SND_CTRL_STOP_SOUND);
8172 }
8173
8174 void RaiseScore(int value)
8175 {
8176   local_player->score += value;
8177   DrawText(DX_SCORE, DY_SCORE, int2str(local_player->score, 5), FONT_TEXT_2);
8178 }
8179
8180 void RaiseScoreElement(int element)
8181 {
8182   switch(element)
8183   {
8184     case EL_EMERALD:
8185     case EL_BD_DIAMOND:
8186     case EL_EMERALD_YELLOW:
8187     case EL_EMERALD_RED:
8188     case EL_EMERALD_PURPLE:
8189     case EL_SP_INFOTRON:
8190       RaiseScore(level.score[SC_EMERALD]);
8191       break;
8192     case EL_DIAMOND:
8193       RaiseScore(level.score[SC_DIAMOND]);
8194       break;
8195     case EL_CRYSTAL:
8196       RaiseScore(level.score[SC_CRYSTAL]);
8197       break;
8198     case EL_PEARL:
8199       RaiseScore(level.score[SC_PEARL]);
8200       break;
8201     case EL_BUG:
8202     case EL_BD_BUTTERFLY:
8203     case EL_SP_ELECTRON:
8204       RaiseScore(level.score[SC_BUG]);
8205       break;
8206     case EL_SPACESHIP:
8207     case EL_BD_FIREFLY:
8208     case EL_SP_SNIKSNAK:
8209       RaiseScore(level.score[SC_SPACESHIP]);
8210       break;
8211     case EL_YAMYAM:
8212     case EL_DARK_YAMYAM:
8213       RaiseScore(level.score[SC_YAMYAM]);
8214       break;
8215     case EL_ROBOT:
8216       RaiseScore(level.score[SC_ROBOT]);
8217       break;
8218     case EL_PACMAN:
8219       RaiseScore(level.score[SC_PACMAN]);
8220       break;
8221     case EL_NUT:
8222       RaiseScore(level.score[SC_NUT]);
8223       break;
8224     case EL_DYNAMITE:
8225     case EL_SP_DISK_RED:
8226     case EL_DYNABOMB_INCREASE_NUMBER:
8227     case EL_DYNABOMB_INCREASE_SIZE:
8228     case EL_DYNABOMB_INCREASE_POWER:
8229       RaiseScore(level.score[SC_DYNAMITE]);
8230       break;
8231     case EL_SHIELD_NORMAL:
8232     case EL_SHIELD_DEADLY:
8233       RaiseScore(level.score[SC_SHIELD]);
8234       break;
8235     case EL_EXTRA_TIME:
8236       RaiseScore(level.score[SC_TIME_BONUS]);
8237       break;
8238     case EL_KEY_1:
8239     case EL_KEY_2:
8240     case EL_KEY_3:
8241     case EL_KEY_4:
8242       RaiseScore(level.score[SC_KEY]);
8243       break;
8244     default:
8245       RaiseScore(element_info[element].collect_score);
8246       break;
8247   }
8248 }
8249
8250 void RequestQuitGame(boolean ask_if_really_quit)
8251 {
8252   if (AllPlayersGone ||
8253       !ask_if_really_quit ||
8254       level_editor_test_game ||
8255       Request("Do you really want to quit the game ?",
8256               REQ_ASK | REQ_STAY_CLOSED))
8257   {
8258 #if defined(PLATFORM_UNIX)
8259     if (options.network)
8260       SendToServer_StopPlaying();
8261     else
8262 #endif
8263     {
8264       game_status = GAME_MODE_MAIN;
8265       DrawMainMenu();
8266     }
8267   }
8268   else
8269   {
8270     OpenDoor(DOOR_OPEN_1 | DOOR_COPY_BACK);
8271   }
8272 }
8273
8274
8275 /* ---------- new game button stuff ---------------------------------------- */
8276
8277 /* graphic position values for game buttons */
8278 #define GAME_BUTTON_XSIZE       30
8279 #define GAME_BUTTON_YSIZE       30
8280 #define GAME_BUTTON_XPOS        5
8281 #define GAME_BUTTON_YPOS        215
8282 #define SOUND_BUTTON_XPOS       5
8283 #define SOUND_BUTTON_YPOS       (GAME_BUTTON_YPOS + GAME_BUTTON_YSIZE)
8284
8285 #define GAME_BUTTON_STOP_XPOS   (GAME_BUTTON_XPOS + 0 * GAME_BUTTON_XSIZE)
8286 #define GAME_BUTTON_PAUSE_XPOS  (GAME_BUTTON_XPOS + 1 * GAME_BUTTON_XSIZE)
8287 #define GAME_BUTTON_PLAY_XPOS   (GAME_BUTTON_XPOS + 2 * GAME_BUTTON_XSIZE)
8288 #define SOUND_BUTTON_MUSIC_XPOS (SOUND_BUTTON_XPOS + 0 * GAME_BUTTON_XSIZE)
8289 #define SOUND_BUTTON_LOOPS_XPOS (SOUND_BUTTON_XPOS + 1 * GAME_BUTTON_XSIZE)
8290 #define SOUND_BUTTON_SIMPLE_XPOS (SOUND_BUTTON_XPOS + 2 * GAME_BUTTON_XSIZE)
8291
8292 static struct
8293 {
8294   int x, y;
8295   int gadget_id;
8296   char *infotext;
8297 } gamebutton_info[NUM_GAME_BUTTONS] =
8298 {
8299   {
8300     GAME_BUTTON_STOP_XPOS,      GAME_BUTTON_YPOS,
8301     GAME_CTRL_ID_STOP,
8302     "stop game"
8303   },
8304   {
8305     GAME_BUTTON_PAUSE_XPOS,     GAME_BUTTON_YPOS,
8306     GAME_CTRL_ID_PAUSE,
8307     "pause game"
8308   },
8309   {
8310     GAME_BUTTON_PLAY_XPOS,      GAME_BUTTON_YPOS,
8311     GAME_CTRL_ID_PLAY,
8312     "play game"
8313   },
8314   {
8315     SOUND_BUTTON_MUSIC_XPOS,    SOUND_BUTTON_YPOS,
8316     SOUND_CTRL_ID_MUSIC,
8317     "background music on/off"
8318   },
8319   {
8320     SOUND_BUTTON_LOOPS_XPOS,    SOUND_BUTTON_YPOS,
8321     SOUND_CTRL_ID_LOOPS,
8322     "sound loops on/off"
8323   },
8324   {
8325     SOUND_BUTTON_SIMPLE_XPOS,   SOUND_BUTTON_YPOS,
8326     SOUND_CTRL_ID_SIMPLE,
8327     "normal sounds on/off"
8328   }
8329 };
8330
8331 void CreateGameButtons()
8332 {
8333   int i;
8334
8335   for (i=0; i<NUM_GAME_BUTTONS; i++)
8336   {
8337     Bitmap *gd_bitmap = graphic_info[IMG_GLOBAL_DOOR].bitmap;
8338     struct GadgetInfo *gi;
8339     int button_type;
8340     boolean checked;
8341     unsigned long event_mask;
8342     int gd_xoffset, gd_yoffset;
8343     int gd_x1, gd_x2, gd_y1, gd_y2;
8344     int id = i;
8345
8346     gd_xoffset = gamebutton_info[i].x;
8347     gd_yoffset = gamebutton_info[i].y;
8348     gd_x1 = DOOR_GFX_PAGEX4 + gd_xoffset;
8349     gd_x2 = DOOR_GFX_PAGEX3 + gd_xoffset;
8350
8351     if (id == GAME_CTRL_ID_STOP ||
8352         id == GAME_CTRL_ID_PAUSE ||
8353         id == GAME_CTRL_ID_PLAY)
8354     {
8355       button_type = GD_TYPE_NORMAL_BUTTON;
8356       checked = FALSE;
8357       event_mask = GD_EVENT_RELEASED;
8358       gd_y1  = DOOR_GFX_PAGEY1 + gd_yoffset - GAME_BUTTON_YSIZE;
8359       gd_y2  = DOOR_GFX_PAGEY1 + gd_yoffset - GAME_BUTTON_YSIZE;
8360     }
8361     else
8362     {
8363       button_type = GD_TYPE_CHECK_BUTTON;
8364       checked =
8365         ((id == SOUND_CTRL_ID_MUSIC && setup.sound_music) ||
8366          (id == SOUND_CTRL_ID_LOOPS && setup.sound_loops) ||
8367          (id == SOUND_CTRL_ID_SIMPLE && setup.sound_simple) ? TRUE : FALSE);
8368       event_mask = GD_EVENT_PRESSED;
8369       gd_y1  = DOOR_GFX_PAGEY1 + gd_yoffset;
8370       gd_y2  = DOOR_GFX_PAGEY1 + gd_yoffset - GAME_BUTTON_YSIZE;
8371     }
8372
8373     gi = CreateGadget(GDI_CUSTOM_ID, id,
8374                       GDI_INFO_TEXT, gamebutton_info[i].infotext,
8375                       GDI_X, DX + gd_xoffset,
8376                       GDI_Y, DY + gd_yoffset,
8377                       GDI_WIDTH, GAME_BUTTON_XSIZE,
8378                       GDI_HEIGHT, GAME_BUTTON_YSIZE,
8379                       GDI_TYPE, button_type,
8380                       GDI_STATE, GD_BUTTON_UNPRESSED,
8381                       GDI_CHECKED, checked,
8382                       GDI_DESIGN_UNPRESSED, gd_bitmap, gd_x1, gd_y1,
8383                       GDI_DESIGN_PRESSED, gd_bitmap, gd_x2, gd_y1,
8384                       GDI_ALT_DESIGN_UNPRESSED, gd_bitmap, gd_x1, gd_y2,
8385                       GDI_ALT_DESIGN_PRESSED, gd_bitmap, gd_x2, gd_y2,
8386                       GDI_EVENT_MASK, event_mask,
8387                       GDI_CALLBACK_ACTION, HandleGameButtons,
8388                       GDI_END);
8389
8390     if (gi == NULL)
8391       Error(ERR_EXIT, "cannot create gadget");
8392
8393     game_gadget[id] = gi;
8394   }
8395 }
8396
8397 void FreeGameButtons()
8398 {
8399   int i;
8400
8401   for (i=0; i<NUM_GAME_BUTTONS; i++)
8402     FreeGadget(game_gadget[i]);
8403 }
8404
8405 static void MapGameButtons()
8406 {
8407   int i;
8408
8409   for (i=0; i<NUM_GAME_BUTTONS; i++)
8410     MapGadget(game_gadget[i]);
8411 }
8412
8413 void UnmapGameButtons()
8414 {
8415   int i;
8416
8417   for (i=0; i<NUM_GAME_BUTTONS; i++)
8418     UnmapGadget(game_gadget[i]);
8419 }
8420
8421 static void HandleGameButtons(struct GadgetInfo *gi)
8422 {
8423   int id = gi->custom_id;
8424
8425   if (game_status != GAME_MODE_PLAYING)
8426     return;
8427
8428   switch (id)
8429   {
8430     case GAME_CTRL_ID_STOP:
8431       RequestQuitGame(TRUE);
8432       break;
8433
8434     case GAME_CTRL_ID_PAUSE:
8435       if (options.network)
8436       {
8437 #if defined(PLATFORM_UNIX)
8438         if (tape.pausing)
8439           SendToServer_ContinuePlaying();
8440         else
8441           SendToServer_PausePlaying();
8442 #endif
8443       }
8444       else
8445         TapeTogglePause(TAPE_TOGGLE_MANUAL);
8446       break;
8447
8448     case GAME_CTRL_ID_PLAY:
8449       if (tape.pausing)
8450       {
8451 #if defined(PLATFORM_UNIX)
8452         if (options.network)
8453           SendToServer_ContinuePlaying();
8454         else
8455 #endif
8456         {
8457           tape.pausing = FALSE;
8458           DrawVideoDisplay(VIDEO_STATE_PAUSE_OFF,0);
8459         }
8460       }
8461       break;
8462
8463     case SOUND_CTRL_ID_MUSIC:
8464       if (setup.sound_music)
8465       {
8466         setup.sound_music = FALSE;
8467         FadeMusic();
8468       }
8469       else if (audio.music_available)
8470       {
8471         setup.sound = setup.sound_music = TRUE;
8472
8473         SetAudioMode(setup.sound);
8474         PlayMusic(level_nr);
8475       }
8476       break;
8477
8478     case SOUND_CTRL_ID_LOOPS:
8479       if (setup.sound_loops)
8480         setup.sound_loops = FALSE;
8481       else if (audio.loops_available)
8482       {
8483         setup.sound = setup.sound_loops = TRUE;
8484         SetAudioMode(setup.sound);
8485       }
8486       break;
8487
8488     case SOUND_CTRL_ID_SIMPLE:
8489       if (setup.sound_simple)
8490         setup.sound_simple = FALSE;
8491       else if (audio.sound_available)
8492       {
8493         setup.sound = setup.sound_simple = TRUE;
8494         SetAudioMode(setup.sound);
8495       }
8496       break;
8497
8498     default:
8499       break;
8500   }
8501 }