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 }
3653
3654 static boolean JustBeingPushed(int x, int y)
3655 {
3656   int i;
3657
3658   for (i=0; i<MAX_PLAYERS; i++)
3659   {
3660     struct PlayerInfo *player = &stored_player[i];
3661
3662     if (player->active && player->Pushing && player->MovPos)
3663     {
3664       int next_jx = player->jx + (player->jx - player->last_jx);
3665       int next_jy = player->jy + (player->jy - player->last_jy);
3666
3667       if (x == next_jx && y == next_jy)
3668         return TRUE;
3669     }
3670   }
3671
3672   return FALSE;
3673 }
3674
3675 void StartMoving(int x, int y)
3676 {
3677   boolean use_spring_bug = (game.engine_version < VERSION_IDENT(2,2,0));
3678   boolean started_moving = FALSE;       /* some elements can fall _and_ move */
3679   int element = Feld[x][y];
3680
3681   if (Stop[x][y])
3682     return;
3683
3684   /* !!! this should be handled more generic (not only for mole) !!! */
3685   if (element != EL_MOLE && GfxAction[x][y] != ACTION_DIGGING)
3686     GfxAction[x][y] = ACTION_DEFAULT;
3687
3688   if (CAN_FALL(element) && y < lev_fieldy - 1)
3689   {
3690     if ((x > 0 && IS_PLAYER(x - 1, y)) ||
3691         (x < lev_fieldx-1 && IS_PLAYER(x + 1, y)))
3692       if (JustBeingPushed(x, y))
3693         return;
3694
3695     if (element == EL_QUICKSAND_FULL)
3696     {
3697       if (IS_FREE(x, y + 1))
3698       {
3699         InitMovingField(x, y, MV_DOWN);
3700         started_moving = TRUE;
3701
3702         Feld[x][y] = EL_QUICKSAND_EMPTYING;
3703         Store[x][y] = EL_ROCK;
3704 #if 1
3705         PlaySoundLevelAction(x, y, ACTION_EMPTYING);
3706 #else
3707         PlaySoundLevel(x, y, SND_QUICKSAND_EMPTYING);
3708 #endif
3709       }
3710       else if (Feld[x][y + 1] == EL_QUICKSAND_EMPTY)
3711       {
3712         if (!MovDelay[x][y])
3713           MovDelay[x][y] = TILEY + 1;
3714
3715         if (MovDelay[x][y])
3716         {
3717           MovDelay[x][y]--;
3718           if (MovDelay[x][y])
3719             return;
3720         }
3721
3722         Feld[x][y] = EL_QUICKSAND_EMPTY;
3723         Feld[x][y + 1] = EL_QUICKSAND_FULL;
3724         Store[x][y + 1] = Store[x][y];
3725         Store[x][y] = 0;
3726 #if 1
3727         PlaySoundLevelAction(x, y, ACTION_FILLING);
3728 #else
3729         PlaySoundLevel(x, y, SND_QUICKSAND_FILLING);
3730 #endif
3731       }
3732     }
3733     else if ((element == EL_ROCK || element == EL_BD_ROCK) &&
3734              Feld[x][y + 1] == EL_QUICKSAND_EMPTY)
3735     {
3736       InitMovingField(x, y, MV_DOWN);
3737       started_moving = TRUE;
3738
3739       Feld[x][y] = EL_QUICKSAND_FILLING;
3740       Store[x][y] = element;
3741 #if 1
3742       PlaySoundLevelAction(x, y, ACTION_FILLING);
3743 #else
3744       PlaySoundLevel(x, y, SND_QUICKSAND_FILLING);
3745 #endif
3746     }
3747     else if (element == EL_MAGIC_WALL_FULL)
3748     {
3749       if (IS_FREE(x, y + 1))
3750       {
3751         InitMovingField(x, y, MV_DOWN);
3752         started_moving = TRUE;
3753
3754         Feld[x][y] = EL_MAGIC_WALL_EMPTYING;
3755         Store[x][y] = EL_CHANGED(Store[x][y]);
3756       }
3757       else if (Feld[x][y + 1] == EL_MAGIC_WALL_ACTIVE)
3758       {
3759         if (!MovDelay[x][y])
3760           MovDelay[x][y] = TILEY/4 + 1;
3761
3762         if (MovDelay[x][y])
3763         {
3764           MovDelay[x][y]--;
3765           if (MovDelay[x][y])
3766             return;
3767         }
3768
3769         Feld[x][y] = EL_MAGIC_WALL_ACTIVE;
3770         Feld[x][y + 1] = EL_MAGIC_WALL_FULL;
3771         Store[x][y + 1] = EL_CHANGED(Store[x][y]);
3772         Store[x][y] = 0;
3773       }
3774     }
3775     else if (element == EL_BD_MAGIC_WALL_FULL)
3776     {
3777       if (IS_FREE(x, y + 1))
3778       {
3779         InitMovingField(x, y, MV_DOWN);
3780         started_moving = TRUE;
3781
3782         Feld[x][y] = EL_BD_MAGIC_WALL_EMPTYING;
3783         Store[x][y] = EL_CHANGED2(Store[x][y]);
3784       }
3785       else if (Feld[x][y + 1] == EL_BD_MAGIC_WALL_ACTIVE)
3786       {
3787         if (!MovDelay[x][y])
3788           MovDelay[x][y] = TILEY/4 + 1;
3789
3790         if (MovDelay[x][y])
3791         {
3792           MovDelay[x][y]--;
3793           if (MovDelay[x][y])
3794             return;
3795         }
3796
3797         Feld[x][y] = EL_BD_MAGIC_WALL_ACTIVE;
3798         Feld[x][y + 1] = EL_BD_MAGIC_WALL_FULL;
3799         Store[x][y + 1] = EL_CHANGED2(Store[x][y]);
3800         Store[x][y] = 0;
3801       }
3802     }
3803     else if (CAN_PASS_MAGIC_WALL(element) &&
3804              (Feld[x][y + 1] == EL_MAGIC_WALL_ACTIVE ||
3805               Feld[x][y + 1] == EL_BD_MAGIC_WALL_ACTIVE))
3806     {
3807       InitMovingField(x, y, MV_DOWN);
3808       started_moving = TRUE;
3809
3810       Feld[x][y] =
3811         (Feld[x][y + 1] == EL_MAGIC_WALL_ACTIVE ? EL_MAGIC_WALL_FILLING :
3812          EL_BD_MAGIC_WALL_FILLING);
3813       Store[x][y] = element;
3814     }
3815 #if 0
3816     else if (CAN_SMASH(element) && Feld[x][y + 1] == EL_ACID)
3817 #else
3818     else if (CAN_FALL(element) && Feld[x][y + 1] == EL_ACID)
3819 #endif
3820     {
3821       SplashAcid(x, y);
3822
3823       InitMovingField(x, y, MV_DOWN);
3824       started_moving = TRUE;
3825
3826       Store[x][y] = EL_ACID;
3827 #if 0
3828       /* !!! TEST !!! better use "_FALLING" etc. !!! */
3829       GfxAction[x][y + 1] = ACTION_ACTIVE;
3830 #endif
3831     }
3832 #if 1
3833
3834 #if 0
3835     /* TEST: bug where player gets not killed by falling rock ... */
3836     else if (CAN_SMASH(element) &&
3837              (Feld[x][y + 1] == EL_BLOCKED ||
3838               IS_PLAYER(x, y + 1)) &&
3839              JustStopped[x][y] && !Pushed[x][y + 1])
3840
3841 #else
3842 #if 1
3843     else if (game.engine_version < RELEASE_IDENT(2,2,0,7) &&
3844              CAN_SMASH(element) && Feld[x][y + 1] == EL_BLOCKED &&
3845              JustStopped[x][y] && !Pushed[x][y + 1])
3846 #else
3847     else if (CAN_SMASH(element) && Feld[x][y + 1] == EL_BLOCKED &&
3848              JustStopped[x][y])
3849 #endif
3850 #endif
3851
3852     {
3853       /* calling "Impact()" here is not only completely unneccessary
3854          (because it already gets called from "ContinueMoving()" in
3855          all relevant situations), but also completely bullshit, because
3856          "JustStopped" also indicates a finished *horizontal* movement;
3857          we must keep this trash for backwards compatibility with older
3858          tapes */
3859
3860       Impact(x, y);
3861     }
3862 #endif
3863     else if (IS_FREE(x, y + 1) && element == EL_SPRING && use_spring_bug)
3864     {
3865       if (MovDir[x][y] == MV_NO_MOVING)
3866       {
3867         InitMovingField(x, y, MV_DOWN);
3868         started_moving = TRUE;
3869       }
3870     }
3871     else if (IS_FREE(x, y + 1) || Feld[x][y + 1] == EL_DIAMOND_BREAKING)
3872     {
3873       if (JustStopped[x][y])    /* prevent animation from being restarted */
3874         MovDir[x][y] = MV_DOWN;
3875
3876       InitMovingField(x, y, MV_DOWN);
3877       started_moving = TRUE;
3878     }
3879     else if (element == EL_AMOEBA_DROP)
3880     {
3881       Feld[x][y] = EL_AMOEBA_GROWING;
3882       Store[x][y] = EL_AMOEBA_WET;
3883     }
3884     /* Store[x][y + 1] must be zero, because:
3885        (EL_QUICKSAND_FULL -> EL_ROCK): Store[x][y + 1] == EL_QUICKSAND_EMPTY
3886     */
3887 #if 0
3888 #if OLD_GAME_BEHAVIOUR
3889     else if (IS_SLIPPERY(Feld[x][y + 1]) && !Store[x][y + 1])
3890 #else
3891     else if (IS_SLIPPERY(Feld[x][y + 1]) && !Store[x][y + 1] &&
3892              !IS_FALLING(x, y + 1) && !JustStopped[x][y + 1] &&
3893              element != EL_DX_SUPABOMB)
3894 #endif
3895 #else
3896     else if (((IS_SLIPPERY(Feld[x][y + 1]) && !IS_PLAYER(x, y + 1)) ||
3897               (IS_EM_SLIPPERY_WALL(Feld[x][y + 1]) && IS_GEM(element))) &&
3898              !IS_FALLING(x, y + 1) && !JustStopped[x][y + 1] &&
3899              element != EL_DX_SUPABOMB && element != EL_SP_DISK_ORANGE)
3900 #endif
3901     {
3902       boolean can_fall_left  = (x > 0 && IS_FREE(x - 1, y) &&
3903                                 (IS_FREE(x - 1, y + 1) ||
3904                                  Feld[x - 1][y + 1] == EL_ACID));
3905       boolean can_fall_right = (x < lev_fieldx - 1 && IS_FREE(x + 1, y) &&
3906                                 (IS_FREE(x + 1, y + 1) ||
3907                                  Feld[x + 1][y + 1] == EL_ACID));
3908       boolean can_fall_any  = (can_fall_left || can_fall_right);
3909       boolean can_fall_both = (can_fall_left && can_fall_right);
3910
3911       if (can_fall_any && IS_CUSTOM_ELEMENT(Feld[x][y + 1]))
3912       {
3913         int slippery_type = element_info[Feld[x][y + 1]].slippery_type;
3914
3915         if (slippery_type == SLIPPERY_ONLY_LEFT)
3916           can_fall_right = FALSE;
3917         else if (slippery_type == SLIPPERY_ONLY_RIGHT)
3918           can_fall_left = FALSE;
3919         else if (slippery_type == SLIPPERY_ANY_LEFT_RIGHT && can_fall_both)
3920           can_fall_right = FALSE;
3921         else if (slippery_type == SLIPPERY_ANY_RIGHT_LEFT && can_fall_both)
3922           can_fall_left = FALSE;
3923
3924         can_fall_any  = (can_fall_left || can_fall_right);
3925         can_fall_both = (can_fall_left && can_fall_right);
3926       }
3927
3928       if (can_fall_any)
3929       {
3930         if (can_fall_both &&
3931             (game.emulation != EMU_BOULDERDASH &&
3932              element != EL_BD_ROCK && element != EL_BD_DIAMOND))
3933           can_fall_left = !(can_fall_right = RND(2));
3934
3935         InitMovingField(x, y, can_fall_left ? MV_LEFT : MV_RIGHT);
3936         started_moving = TRUE;
3937       }
3938     }
3939     else if (IS_BELT_ACTIVE(Feld[x][y + 1]))
3940     {
3941       boolean left_is_free  = (x > 0 && IS_FREE(x - 1, y));
3942       boolean right_is_free = (x < lev_fieldx - 1 && IS_FREE(x + 1, y));
3943       int belt_nr = getBeltNrFromBeltActiveElement(Feld[x][y + 1]);
3944       int belt_dir = game.belt_dir[belt_nr];
3945
3946       if ((belt_dir == MV_LEFT  && left_is_free) ||
3947           (belt_dir == MV_RIGHT && right_is_free))
3948       {
3949         InitMovingField(x, y, belt_dir);
3950         started_moving = TRUE;
3951
3952         GfxAction[x][y] = ACTION_DEFAULT;
3953       }
3954     }
3955   }
3956
3957   /* not "else if" because of elements that can fall and move (EL_SPRING) */
3958   if (CAN_MOVE(element) && !started_moving)
3959   {
3960     int newx, newy;
3961
3962     if ((element == EL_SATELLITE ||
3963          element == EL_BALLOON ||
3964          element == EL_SPRING)
3965         && JustBeingPushed(x, y))
3966       return;
3967
3968 #if 0
3969 #if 0
3970     if (element == EL_SPRING && MovDir[x][y] == MV_DOWN)
3971       Feld[x][y + 1] = EL_EMPTY;        /* was set to EL_BLOCKED above */
3972 #else
3973     if (element == EL_SPRING && MovDir[x][y] != MV_NO_MOVING)
3974     {
3975       Moving2Blocked(x, y, &newx, &newy);
3976       if (Feld[newx][newy] == EL_BLOCKED)
3977         Feld[newx][newy] = EL_EMPTY;    /* was set to EL_BLOCKED above */
3978     }
3979 #endif
3980 #endif
3981
3982     if (!MovDelay[x][y])        /* start new movement phase */
3983     {
3984       /* all objects that can change their move direction after each step
3985          (YAMYAM, DARK_YAMYAM and PACMAN go straight until they hit a wall */
3986
3987       if (element != EL_YAMYAM &&
3988           element != EL_DARK_YAMYAM &&
3989           element != EL_PACMAN &&
3990           !(element_info[element].move_pattern & MV_ANY_DIRECTION) &&
3991           element_info[element].move_pattern != MV_TURNING_LEFT &&
3992           element_info[element].move_pattern != MV_TURNING_RIGHT)
3993       {
3994         TurnRound(x, y);
3995
3996         if (MovDelay[x][y] && (element == EL_BUG ||
3997                                element == EL_SPACESHIP ||
3998                                element == EL_SP_SNIKSNAK ||
3999                                element == EL_SP_ELECTRON ||
4000                                element == EL_MOLE))
4001           DrawLevelField(x, y);
4002       }
4003     }
4004
4005     if (MovDelay[x][y])         /* wait some time before next movement */
4006     {
4007       MovDelay[x][y]--;
4008
4009 #if 0
4010       if (element == EL_YAMYAM)
4011       {
4012         printf("::: %d\n",
4013                el_act_dir2img(EL_YAMYAM, ACTION_WAITING, MV_LEFT));
4014         DrawLevelElementAnimation(x, y, element);
4015       }
4016 #endif
4017
4018       if (MovDelay[x][y])       /* element still has to wait some time */
4019       {
4020 #if 0
4021         /* !!! PLACE THIS SOMEWHERE AFTER "TurnRound()" !!! */
4022         ResetGfxAnimation(x, y);
4023 #endif
4024         GfxAction[x][y] = ACTION_WAITING;
4025       }
4026
4027       if (element == EL_ROBOT ||
4028 #if 0
4029           element == EL_PACMAN ||
4030 #endif
4031           element == EL_YAMYAM ||
4032           element == EL_DARK_YAMYAM)
4033       {
4034 #if 0
4035         DrawLevelElementAnimation(x, y, element);
4036 #else
4037         DrawLevelElementAnimationIfNeeded(x, y, element);
4038 #endif
4039         PlaySoundLevelAction(x, y, ACTION_WAITING);
4040       }
4041       else if (element == EL_SP_ELECTRON)
4042         DrawLevelElementAnimationIfNeeded(x, y, element);
4043       else if (element == EL_DRAGON)
4044       {
4045         int i;
4046         int dir = MovDir[x][y];
4047         int dx = (dir == MV_LEFT ? -1 : dir == MV_RIGHT ? +1 : 0);
4048         int dy = (dir == MV_UP   ? -1 : dir == MV_DOWN  ? +1 : 0);
4049         int graphic = (dir == MV_LEFT   ? IMG_FLAMES_1_LEFT :
4050                        dir == MV_RIGHT  ? IMG_FLAMES_1_RIGHT :
4051                        dir == MV_UP     ? IMG_FLAMES_1_UP :
4052                        dir == MV_DOWN   ? IMG_FLAMES_1_DOWN : IMG_EMPTY);
4053         int frame = getGraphicAnimationFrame(graphic, -1);
4054
4055         for (i=1; i<=3; i++)
4056         {
4057           int xx = x + i*dx, yy = y + i*dy;
4058           int sx = SCREENX(xx), sy = SCREENY(yy);
4059           int flame_graphic = graphic + (i - 1);
4060
4061           if (!IN_LEV_FIELD(xx, yy) || IS_DRAGONFIRE_PROOF(Feld[xx][yy]))
4062             break;
4063
4064           if (MovDelay[x][y])
4065           {
4066             int flamed = MovingOrBlocked2Element(xx, yy);
4067
4068             if (IS_CLASSIC_ENEMY(flamed) || CAN_EXPLODE_BY_FIRE(flamed))
4069               Bang(xx, yy);
4070             else
4071               RemoveMovingField(xx, yy);
4072
4073             Feld[xx][yy] = EL_FLAMES;
4074             if (IN_SCR_FIELD(sx, sy))
4075               DrawGraphic(sx, sy, flame_graphic, frame);
4076           }
4077           else
4078           {
4079             if (Feld[xx][yy] == EL_FLAMES)
4080               Feld[xx][yy] = EL_EMPTY;
4081             DrawLevelField(xx, yy);
4082           }
4083         }
4084       }
4085
4086       if (MovDelay[x][y])       /* element still has to wait some time */
4087       {
4088         PlaySoundLevelAction(x, y, ACTION_WAITING);
4089
4090         return;
4091       }
4092
4093       /* special case of "moving" animation of waiting elements (FIX THIS !!!);
4094          for all other elements GfxAction will be set by InitMovingField() */
4095       if (element == EL_BD_BUTTERFLY || element == EL_BD_FIREFLY)
4096         GfxAction[x][y] = ACTION_MOVING;
4097     }
4098
4099     /* now make next step */
4100
4101     Moving2Blocked(x, y, &newx, &newy); /* get next screen position */
4102
4103     if (DONT_COLLIDE_WITH(element) &&
4104         IN_LEV_FIELD(newx, newy) && IS_PLAYER(newx, newy) &&
4105         !PLAYER_PROTECTED(newx, newy))
4106     {
4107 #if 1
4108       TestIfBadThingRunsIntoHero(x, y, MovDir[x][y]);
4109       return;
4110 #else
4111       /* player killed by element which is deadly when colliding with */
4112       MovDir[x][y] = 0;
4113       KillHero(PLAYERINFO(newx, newy));
4114       return;
4115 #endif
4116
4117     }
4118     else if ((element == EL_PENGUIN ||
4119               element == EL_ROBOT ||
4120               element == EL_SATELLITE ||
4121               element == EL_BALLOON ||
4122               IS_CUSTOM_ELEMENT(element)) &&
4123              IN_LEV_FIELD(newx, newy) &&
4124              MovDir[x][y] == MV_DOWN && Feld[newx][newy] == EL_ACID)
4125     {
4126       SplashAcid(x, y);
4127       Store[x][y] = EL_ACID;
4128     }
4129     else if (element == EL_PENGUIN && IN_LEV_FIELD(newx, newy))
4130     {
4131       if (Feld[newx][newy] == EL_EXIT_OPEN)
4132       {
4133         Feld[x][y] = EL_EMPTY;
4134         DrawLevelField(x, y);
4135
4136         PlaySoundLevel(newx, newy, SND_PENGUIN_PASSING);
4137         if (IN_SCR_FIELD(SCREENX(newx), SCREENY(newy)))
4138           DrawGraphicThruMask(SCREENX(newx),SCREENY(newy), el2img(element), 0);
4139
4140         local_player->friends_still_needed--;
4141         if (!local_player->friends_still_needed &&
4142             !local_player->GameOver && AllPlayersGone)
4143           local_player->LevelSolved = local_player->GameOver = TRUE;
4144
4145         return;
4146       }
4147       else if (IS_FOOD_PENGUIN(Feld[newx][newy]))
4148       {
4149         if (DigField(local_player, newx, newy, 0, 0, DF_DIG) == MF_MOVING)
4150           DrawLevelField(newx, newy);
4151         else
4152           MovDir[x][y] = MV_NO_MOVING;
4153       }
4154       else if (!IS_FREE(newx, newy))
4155       {
4156         GfxAction[x][y] = ACTION_WAITING;
4157
4158         if (IS_PLAYER(x, y))
4159           DrawPlayerField(x, y);
4160         else
4161           DrawLevelField(x, y);
4162         return;
4163       }
4164     }
4165     else if (element == EL_PIG && IN_LEV_FIELD(newx, newy))
4166     {
4167       if (IS_FOOD_PIG(Feld[newx][newy]))
4168       {
4169         if (IS_MOVING(newx, newy))
4170           RemoveMovingField(newx, newy);
4171         else
4172         {
4173           Feld[newx][newy] = EL_EMPTY;
4174           DrawLevelField(newx, newy);
4175         }
4176
4177         PlaySoundLevel(x, y, SND_PIG_DIGGING);
4178       }
4179       else if (!IS_FREE(newx, newy))
4180       {
4181         if (IS_PLAYER(x, y))
4182           DrawPlayerField(x, y);
4183         else
4184           DrawLevelField(x, y);
4185         return;
4186       }
4187     }
4188     else if (element == EL_DRAGON && IN_LEV_FIELD(newx, newy))
4189     {
4190       if (!IS_FREE(newx, newy))
4191       {
4192         if (IS_PLAYER(x, y))
4193           DrawPlayerField(x, y);
4194         else
4195           DrawLevelField(x, y);
4196         return;
4197       }
4198       else
4199       {
4200         boolean wanna_flame = !RND(10);
4201         int dx = newx - x, dy = newy - y;
4202         int newx1 = newx+1*dx, newy1 = newy+1*dy;
4203         int newx2 = newx+2*dx, newy2 = newy+2*dy;
4204         int element1 = (IN_LEV_FIELD(newx1, newy1) ?
4205                         MovingOrBlocked2Element(newx1, newy1) : EL_STEELWALL);
4206         int element2 = (IN_LEV_FIELD(newx2, newy2) ?
4207                         MovingOrBlocked2Element(newx2, newy2) : EL_STEELWALL);
4208
4209         if ((wanna_flame ||
4210              IS_CLASSIC_ENEMY(element1) ||
4211              IS_CLASSIC_ENEMY(element2)) &&
4212             element1 != EL_DRAGON && element2 != EL_DRAGON &&
4213             element1 != EL_FLAMES && element2 != EL_FLAMES)
4214         {
4215           if (IS_PLAYER(x, y))
4216             DrawPlayerField(x, y);
4217           else
4218             DrawLevelField(x, y);
4219
4220           PlaySoundLevel(x, y, SND_DRAGON_ATTACKING);
4221
4222           MovDelay[x][y] = 50;
4223           Feld[newx][newy] = EL_FLAMES;
4224           if (IN_LEV_FIELD(newx1, newy1) && Feld[newx1][newy1] == EL_EMPTY)
4225             Feld[newx1][newy1] = EL_FLAMES;
4226           if (IN_LEV_FIELD(newx2, newy2) && Feld[newx2][newy2] == EL_EMPTY)
4227             Feld[newx2][newy2] = EL_FLAMES;
4228           return;
4229         }
4230       }
4231     }
4232     else if (element == EL_YAMYAM && IN_LEV_FIELD(newx, newy) &&
4233              Feld[newx][newy] == EL_DIAMOND)
4234     {
4235       if (IS_MOVING(newx, newy))
4236         RemoveMovingField(newx, newy);
4237       else
4238       {
4239         Feld[newx][newy] = EL_EMPTY;
4240         DrawLevelField(newx, newy);
4241       }
4242
4243       PlaySoundLevel(x, y, SND_YAMYAM_DIGGING);
4244     }
4245     else if (element == EL_DARK_YAMYAM && IN_LEV_FIELD(newx, newy) &&
4246              IS_FOOD_DARK_YAMYAM(Feld[newx][newy]))
4247     {
4248       if (AmoebaNr[newx][newy])
4249       {
4250         AmoebaCnt2[AmoebaNr[newx][newy]]--;
4251         if (Feld[newx][newy] == EL_AMOEBA_FULL ||
4252             Feld[newx][newy] == EL_BD_AMOEBA)
4253           AmoebaCnt[AmoebaNr[newx][newy]]--;
4254       }
4255
4256       if (IS_MOVING(newx, newy))
4257         RemoveMovingField(newx, newy);
4258       else
4259       {
4260         Feld[newx][newy] = EL_EMPTY;
4261         DrawLevelField(newx, newy);
4262       }
4263
4264       PlaySoundLevel(x, y, SND_DARK_YAMYAM_DIGGING);
4265     }
4266     else if ((element == EL_PACMAN || element == EL_MOLE)
4267              && IN_LEV_FIELD(newx, newy) && IS_AMOEBOID(Feld[newx][newy]))
4268     {
4269       if (AmoebaNr[newx][newy])
4270       {
4271         AmoebaCnt2[AmoebaNr[newx][newy]]--;
4272         if (Feld[newx][newy] == EL_AMOEBA_FULL ||
4273             Feld[newx][newy] == EL_BD_AMOEBA)
4274           AmoebaCnt[AmoebaNr[newx][newy]]--;
4275       }
4276
4277       if (element == EL_MOLE)
4278       {
4279         Feld[newx][newy] = EL_AMOEBA_SHRINKING;
4280         PlaySoundLevel(x, y, SND_MOLE_DIGGING);
4281
4282         ResetGfxAnimation(x, y);
4283         GfxAction[x][y] = ACTION_DIGGING;
4284         DrawLevelField(x, y);
4285
4286         MovDelay[newx][newy] = 0;       /* start amoeba shrinking delay */
4287         return;                         /* wait for shrinking amoeba */
4288       }
4289       else      /* element == EL_PACMAN */
4290       {
4291         Feld[newx][newy] = EL_EMPTY;
4292         DrawLevelField(newx, newy);
4293         PlaySoundLevel(x, y, SND_PACMAN_DIGGING);
4294       }
4295     }
4296     else if (element == EL_MOLE && IN_LEV_FIELD(newx, newy) &&
4297              (Feld[newx][newy] == EL_AMOEBA_SHRINKING ||
4298               (Feld[newx][newy] == EL_EMPTY && Stop[newx][newy])))
4299     {
4300       /* wait for shrinking amoeba to completely disappear */
4301       return;
4302     }
4303     else if (!IN_LEV_FIELD(newx, newy) || !IS_FREE(newx, newy))
4304     {
4305       /* object was running against a wall */
4306
4307       TurnRound(x, y);
4308
4309 #if 1
4310       if (GFX_ELEMENT(element) != EL_SAND)     /* !!! FIX THIS (crumble) !!! */
4311         DrawLevelElementAnimation(x, y, element);
4312 #else
4313       if (element == EL_BUG ||
4314           element == EL_SPACESHIP ||
4315           element == EL_SP_SNIKSNAK)
4316         DrawLevelField(x, y);
4317       else if (element == EL_MOLE)
4318         DrawLevelField(x, y);
4319       else if (element == EL_BD_BUTTERFLY ||
4320                element == EL_BD_FIREFLY)
4321         DrawLevelElementAnimationIfNeeded(x, y, element);
4322       else if (element == EL_SATELLITE)
4323         DrawLevelElementAnimationIfNeeded(x, y, element);
4324       else if (element == EL_SP_ELECTRON)
4325         DrawLevelElementAnimationIfNeeded(x, y, element);
4326 #endif
4327
4328       if (DONT_TOUCH(element))
4329         TestIfBadThingTouchesHero(x, y);
4330
4331 #if 0
4332       PlaySoundLevelAction(x, y, ACTION_WAITING);
4333 #endif
4334
4335       return;
4336     }
4337
4338     InitMovingField(x, y, MovDir[x][y]);
4339
4340     PlaySoundLevelAction(x, y, ACTION_MOVING);
4341   }
4342
4343   if (MovDir[x][y])
4344     ContinueMoving(x, y);
4345 }
4346
4347 void ContinueMoving(int x, int y)
4348 {
4349   int element = Feld[x][y];
4350   int direction = MovDir[x][y];
4351   int dx = (direction == MV_LEFT ? -1 : direction == MV_RIGHT ? +1 : 0);
4352   int dy = (direction == MV_UP   ? -1 : direction == MV_DOWN  ? +1 : 0);
4353   int newx = x + dx, newy = y + dy;
4354   int nextx = newx + dx, nexty = newy + dy;
4355   boolean pushed = Pushed[x][y];
4356
4357   MovPos[x][y] += getElementMoveStepsize(x, y);
4358
4359   if (pushed)           /* special case: moving object pushed by player */
4360     MovPos[x][y] = SIGN(MovPos[x][y]) * (TILEX - ABS(PLAYERINFO(x,y)->MovPos));
4361
4362   if (ABS(MovPos[x][y]) >= TILEX)       /* object reached its destination */
4363   {
4364     Feld[x][y] = EL_EMPTY;
4365     Feld[newx][newy] = element;
4366     MovPos[x][y] = 0;   /* force "not moving" for "crumbled sand" */
4367
4368     if (element == EL_MOLE)
4369     {
4370       Feld[x][y] = EL_SAND;
4371
4372       DrawLevelFieldCrumbledSandNeighbours(x, y);
4373     }
4374     else if (element == EL_QUICKSAND_FILLING)
4375     {
4376       element = Feld[newx][newy] = get_next_element(element);
4377       Store[newx][newy] = Store[x][y];
4378     }
4379     else if (element == EL_QUICKSAND_EMPTYING)
4380     {
4381       Feld[x][y] = get_next_element(element);
4382       element = Feld[newx][newy] = Store[x][y];
4383     }
4384     else if (element == EL_MAGIC_WALL_FILLING)
4385     {
4386       element = Feld[newx][newy] = get_next_element(element);
4387       if (!game.magic_wall_active)
4388         element = Feld[newx][newy] = EL_MAGIC_WALL_DEAD;
4389       Store[newx][newy] = Store[x][y];
4390     }
4391     else if (element == EL_MAGIC_WALL_EMPTYING)
4392     {
4393       Feld[x][y] = get_next_element(element);
4394       if (!game.magic_wall_active)
4395         Feld[x][y] = EL_MAGIC_WALL_DEAD;
4396       element = Feld[newx][newy] = Store[x][y];
4397     }
4398     else if (element == EL_BD_MAGIC_WALL_FILLING)
4399     {
4400       element = Feld[newx][newy] = get_next_element(element);
4401       if (!game.magic_wall_active)
4402         element = Feld[newx][newy] = EL_BD_MAGIC_WALL_DEAD;
4403       Store[newx][newy] = Store[x][y];
4404     }
4405     else if (element == EL_BD_MAGIC_WALL_EMPTYING)
4406     {
4407       Feld[x][y] = get_next_element(element);
4408       if (!game.magic_wall_active)
4409         Feld[x][y] = EL_BD_MAGIC_WALL_DEAD;
4410       element = Feld[newx][newy] = Store[x][y];
4411     }
4412     else if (element == EL_AMOEBA_DROPPING)
4413     {
4414       Feld[x][y] = get_next_element(element);
4415       element = Feld[newx][newy] = Store[x][y];
4416     }
4417     else if (element == EL_SOKOBAN_OBJECT)
4418     {
4419       if (Back[x][y])
4420         Feld[x][y] = Back[x][y];
4421
4422       if (Back[newx][newy])
4423         Feld[newx][newy] = EL_SOKOBAN_FIELD_FULL;
4424
4425       Back[x][y] = Back[newx][newy] = 0;
4426     }
4427     else if (Store[x][y] == EL_ACID)
4428     {
4429       element = Feld[newx][newy] = EL_ACID;
4430     }
4431
4432     Store[x][y] = 0;
4433     MovPos[x][y] = MovDir[x][y] = MovDelay[x][y] = 0;
4434     MovDelay[newx][newy] = 0;
4435
4436     /* copy element change control values to new field */
4437     ChangeDelay[newx][newy] = ChangeDelay[x][y];
4438     Changed[newx][newy] = Changed[x][y];
4439     ChangeEvent[newx][newy] = ChangeEvent[x][y];
4440
4441     ChangeDelay[x][y] = 0;
4442     Changed[x][y] = CE_BITMASK_DEFAULT;
4443     ChangeEvent[x][y] = CE_BITMASK_DEFAULT;
4444
4445     /* copy animation control values to new field */
4446     GfxFrame[newx][newy]  = GfxFrame[x][y];
4447     GfxAction[newx][newy] = GfxAction[x][y];    /* keep action one frame */
4448     GfxRandom[newx][newy] = GfxRandom[x][y];    /* keep same random value */
4449
4450     Pushed[x][y] = Pushed[newx][newy] = FALSE;
4451
4452     ResetGfxAnimation(x, y);    /* reset animation values for old field */
4453
4454 #if 0
4455     /* 2.1.1 (does not work correctly for spring) */
4456     if (!CAN_MOVE(element))
4457       MovDir[newx][newy] = 0;
4458 #else
4459
4460 #if 0
4461     /* (does not work for falling objects that slide horizontally) */
4462     if (CAN_FALL(element) && MovDir[newx][newy] == MV_DOWN)
4463       MovDir[newx][newy] = 0;
4464 #else
4465     /*
4466     if (!CAN_MOVE(element) ||
4467         (element == EL_SPRING && MovDir[newx][newy] == MV_DOWN))
4468       MovDir[newx][newy] = 0;
4469     */
4470
4471     if (!CAN_MOVE(element) ||
4472         (CAN_FALL(element) && MovDir[newx][newy] == MV_DOWN))
4473       MovDir[newx][newy] = 0;
4474 #endif
4475 #endif
4476
4477     DrawLevelField(x, y);
4478     DrawLevelField(newx, newy);
4479
4480     Stop[newx][newy] = TRUE;    /* ignore this element until the next frame */
4481
4482     if (!pushed)        /* special case: moving object pushed by player */
4483       JustStopped[newx][newy] = 3;
4484
4485     if (DONT_TOUCH(element))    /* object may be nasty to player or others */
4486     {
4487       TestIfBadThingTouchesHero(newx, newy);
4488       TestIfBadThingTouchesFriend(newx, newy);
4489       TestIfBadThingTouchesOtherBadThing(newx, newy);
4490     }
4491     else if (element == EL_PENGUIN)
4492       TestIfFriendTouchesBadThing(newx, newy);
4493
4494     if (CAN_FALL(element) && direction == MV_DOWN &&
4495         (newy == lev_fieldy - 1 || !IS_FREE(x, newy + 1)))
4496       Impact(x, newy);
4497
4498     if (!IN_LEV_FIELD(nextx, nexty) || !IS_FREE(nextx, nexty))
4499       CheckElementChange(newx, newy, element, CE_COLLISION);
4500
4501 #if 1
4502     TestIfElementTouchesCustomElement(x, y);            /* for empty space */
4503 #endif
4504
4505     TestIfPlayerTouchesCustomElement(newx, newy);
4506     TestIfElementTouchesCustomElement(newx, newy);
4507   }
4508   else                          /* still moving on */
4509   {
4510     DrawLevelField(x, y);
4511   }
4512 }
4513
4514 int AmoebeNachbarNr(int ax, int ay)
4515 {
4516   int i;
4517   int element = Feld[ax][ay];
4518   int group_nr = 0;
4519   static int xy[4][2] =
4520   {
4521     { 0, -1 },
4522     { -1, 0 },
4523     { +1, 0 },
4524     { 0, +1 }
4525   };
4526
4527   for (i=0; i<4; i++)
4528   {
4529     int x = ax + xy[i][0];
4530     int y = ay + xy[i][1];
4531
4532     if (!IN_LEV_FIELD(x, y))
4533       continue;
4534
4535     if (Feld[x][y] == element && AmoebaNr[x][y] > 0)
4536       group_nr = AmoebaNr[x][y];
4537   }
4538
4539   return group_nr;
4540 }
4541
4542 void AmoebenVereinigen(int ax, int ay)
4543 {
4544   int i, x, y, xx, yy;
4545   int new_group_nr = AmoebaNr[ax][ay];
4546   static int xy[4][2] =
4547   {
4548     { 0, -1 },
4549     { -1, 0 },
4550     { +1, 0 },
4551     { 0, +1 }
4552   };
4553
4554   if (new_group_nr == 0)
4555     return;
4556
4557   for (i=0; i<4; i++)
4558   {
4559     x = ax + xy[i][0];
4560     y = ay + xy[i][1];
4561
4562     if (!IN_LEV_FIELD(x, y))
4563       continue;
4564
4565     if ((Feld[x][y] == EL_AMOEBA_FULL ||
4566          Feld[x][y] == EL_BD_AMOEBA ||
4567          Feld[x][y] == EL_AMOEBA_DEAD) &&
4568         AmoebaNr[x][y] != new_group_nr)
4569     {
4570       int old_group_nr = AmoebaNr[x][y];
4571
4572       if (old_group_nr == 0)
4573         return;
4574
4575       AmoebaCnt[new_group_nr] += AmoebaCnt[old_group_nr];
4576       AmoebaCnt[old_group_nr] = 0;
4577       AmoebaCnt2[new_group_nr] += AmoebaCnt2[old_group_nr];
4578       AmoebaCnt2[old_group_nr] = 0;
4579
4580       for (yy=0; yy<lev_fieldy; yy++)
4581       {
4582         for (xx=0; xx<lev_fieldx; xx++)
4583         {
4584           if (AmoebaNr[xx][yy] == old_group_nr)
4585             AmoebaNr[xx][yy] = new_group_nr;
4586         }
4587       }
4588     }
4589   }
4590 }
4591
4592 void AmoebeUmwandeln(int ax, int ay)
4593 {
4594   int i, x, y;
4595
4596   if (Feld[ax][ay] == EL_AMOEBA_DEAD)
4597   {
4598     int group_nr = AmoebaNr[ax][ay];
4599
4600 #ifdef DEBUG
4601     if (group_nr == 0)
4602     {
4603       printf("AmoebeUmwandeln(): ax = %d, ay = %d\n", ax, ay);
4604       printf("AmoebeUmwandeln(): This should never happen!\n");
4605       return;
4606     }
4607 #endif
4608
4609     for (y=0; y<lev_fieldy; y++)
4610     {
4611       for (x=0; x<lev_fieldx; x++)
4612       {
4613         if (Feld[x][y] == EL_AMOEBA_DEAD && AmoebaNr[x][y] == group_nr)
4614         {
4615           AmoebaNr[x][y] = 0;
4616           Feld[x][y] = EL_AMOEBA_TO_DIAMOND;
4617         }
4618       }
4619     }
4620     PlaySoundLevel(ax, ay, (IS_GEM(level.amoeba_content) ?
4621                             SND_AMOEBA_TURNING_TO_GEM :
4622                             SND_AMOEBA_TURNING_TO_ROCK));
4623     Bang(ax, ay);
4624   }
4625   else
4626   {
4627     static int xy[4][2] =
4628     {
4629       { 0, -1 },
4630       { -1, 0 },
4631       { +1, 0 },
4632       { 0, +1 }
4633     };
4634
4635     for (i=0; i<4; i++)
4636     {
4637       x = ax + xy[i][0];
4638       y = ay + xy[i][1];
4639
4640       if (!IN_LEV_FIELD(x, y))
4641         continue;
4642
4643       if (Feld[x][y] == EL_AMOEBA_TO_DIAMOND)
4644       {
4645         PlaySoundLevel(x, y, (IS_GEM(level.amoeba_content) ?
4646                               SND_AMOEBA_TURNING_TO_GEM :
4647                               SND_AMOEBA_TURNING_TO_ROCK));
4648         Bang(x, y);
4649       }
4650     }
4651   }
4652 }
4653
4654 void AmoebeUmwandelnBD(int ax, int ay, int new_element)
4655 {
4656   int x, y;
4657   int group_nr = AmoebaNr[ax][ay];
4658   boolean done = FALSE;
4659
4660 #ifdef DEBUG
4661   if (group_nr == 0)
4662   {
4663     printf("AmoebeUmwandelnBD(): ax = %d, ay = %d\n", ax, ay);
4664     printf("AmoebeUmwandelnBD(): This should never happen!\n");
4665     return;
4666   }
4667 #endif
4668
4669   for (y=0; y<lev_fieldy; y++)
4670   {
4671     for (x=0; x<lev_fieldx; x++)
4672     {
4673       if (AmoebaNr[x][y] == group_nr &&
4674           (Feld[x][y] == EL_AMOEBA_DEAD ||
4675            Feld[x][y] == EL_BD_AMOEBA ||
4676            Feld[x][y] == EL_AMOEBA_GROWING))
4677       {
4678         AmoebaNr[x][y] = 0;
4679         Feld[x][y] = new_element;
4680         InitField(x, y, FALSE);
4681         DrawLevelField(x, y);
4682         done = TRUE;
4683       }
4684     }
4685   }
4686
4687   if (done)
4688     PlaySoundLevel(ax, ay, (new_element == EL_BD_ROCK ?
4689                             SND_BD_AMOEBA_TURNING_TO_ROCK :
4690                             SND_BD_AMOEBA_TURNING_TO_GEM));
4691 }
4692
4693 void AmoebeWaechst(int x, int y)
4694 {
4695   static unsigned long sound_delay = 0;
4696   static unsigned long sound_delay_value = 0;
4697
4698   if (!MovDelay[x][y])          /* start new growing cycle */
4699   {
4700     MovDelay[x][y] = 7;
4701
4702     if (DelayReached(&sound_delay, sound_delay_value))
4703     {
4704 #if 1
4705       PlaySoundLevelElementAction(x, y, Store[x][y], ACTION_GROWING);
4706 #else
4707       if (Store[x][y] == EL_BD_AMOEBA)
4708         PlaySoundLevel(x, y, SND_BD_AMOEBA_GROWING);
4709       else
4710         PlaySoundLevel(x, y, SND_AMOEBA_GROWING);
4711 #endif
4712       sound_delay_value = 30;
4713     }
4714   }
4715
4716   if (MovDelay[x][y])           /* wait some time before growing bigger */
4717   {
4718     MovDelay[x][y]--;
4719     if (MovDelay[x][y]/2 && IN_SCR_FIELD(SCREENX(x), SCREENY(y)))
4720     {
4721       int frame = getGraphicAnimationFrame(IMG_AMOEBA_GROWING,
4722                                            6 - MovDelay[x][y]);
4723
4724       DrawGraphic(SCREENX(x), SCREENY(y), IMG_AMOEBA_GROWING, frame);
4725     }
4726
4727     if (!MovDelay[x][y])
4728     {
4729       Feld[x][y] = Store[x][y];
4730       Store[x][y] = 0;
4731       DrawLevelField(x, y);
4732     }
4733   }
4734 }
4735
4736 void AmoebaDisappearing(int x, int y)
4737 {
4738   static unsigned long sound_delay = 0;
4739   static unsigned long sound_delay_value = 0;
4740
4741   if (!MovDelay[x][y])          /* start new shrinking cycle */
4742   {
4743     MovDelay[x][y] = 7;
4744
4745     if (DelayReached(&sound_delay, sound_delay_value))
4746       sound_delay_value = 30;
4747   }
4748
4749   if (MovDelay[x][y])           /* wait some time before shrinking */
4750   {
4751     MovDelay[x][y]--;
4752     if (MovDelay[x][y]/2 && IN_SCR_FIELD(SCREENX(x), SCREENY(y)))
4753     {
4754       int frame = getGraphicAnimationFrame(IMG_AMOEBA_SHRINKING,
4755                                            6 - MovDelay[x][y]);
4756
4757       DrawGraphic(SCREENX(x), SCREENY(y), IMG_AMOEBA_SHRINKING, frame);
4758     }
4759
4760     if (!MovDelay[x][y])
4761     {
4762       Feld[x][y] = EL_EMPTY;
4763       DrawLevelField(x, y);
4764
4765       /* don't let mole enter this field in this cycle;
4766          (give priority to objects falling to this field from above) */
4767       Stop[x][y] = TRUE;
4768     }
4769   }
4770 }
4771
4772 void AmoebeAbleger(int ax, int ay)
4773 {
4774   int i;
4775   int element = Feld[ax][ay];
4776   int graphic = el2img(element);
4777   int newax = ax, neway = ay;
4778   static int xy[4][2] =
4779   {
4780     { 0, -1 },
4781     { -1, 0 },
4782     { +1, 0 },
4783     { 0, +1 }
4784   };
4785
4786   if (!level.amoeba_speed)
4787   {
4788     Feld[ax][ay] = EL_AMOEBA_DEAD;
4789     DrawLevelField(ax, ay);
4790     return;
4791   }
4792
4793   if (IS_ANIMATED(graphic))
4794     DrawLevelGraphicAnimationIfNeeded(ax, ay, graphic);
4795
4796   if (!MovDelay[ax][ay])        /* start making new amoeba field */
4797     MovDelay[ax][ay] = RND(FRAMES_PER_SECOND * 25 / (1 + level.amoeba_speed));
4798
4799   if (MovDelay[ax][ay])         /* wait some time before making new amoeba */
4800   {
4801     MovDelay[ax][ay]--;
4802     if (MovDelay[ax][ay])
4803       return;
4804   }
4805
4806   if (element == EL_AMOEBA_WET) /* object is an acid / amoeba drop */
4807   {
4808     int start = RND(4);
4809     int x = ax + xy[start][0];
4810     int y = ay + xy[start][1];
4811
4812     if (!IN_LEV_FIELD(x, y))
4813       return;
4814
4815     /* !!! extend EL_SAND to anything diggable (but maybe not SP_BASE) !!! */
4816     if (IS_FREE(x, y) ||
4817         Feld[x][y] == EL_SAND || Feld[x][y] == EL_QUICKSAND_EMPTY)
4818     {
4819       newax = x;
4820       neway = y;
4821     }
4822
4823     if (newax == ax && neway == ay)
4824       return;
4825   }
4826   else                          /* normal or "filled" (BD style) amoeba */
4827   {
4828     int start = RND(4);
4829     boolean waiting_for_player = FALSE;
4830
4831     for (i=0; i<4; i++)
4832     {
4833       int j = (start + i) % 4;
4834       int x = ax + xy[j][0];
4835       int y = ay + xy[j][1];
4836
4837       if (!IN_LEV_FIELD(x, y))
4838         continue;
4839
4840       /* !!! extend EL_SAND to anything diggable (but maybe not SP_BASE) !!! */
4841       if (IS_FREE(x, y) ||
4842           Feld[x][y] == EL_SAND || Feld[x][y] == EL_QUICKSAND_EMPTY)
4843       {
4844         newax = x;
4845         neway = y;
4846         break;
4847       }
4848       else if (IS_PLAYER(x, y))
4849         waiting_for_player = TRUE;
4850     }
4851
4852     if (newax == ax && neway == ay)             /* amoeba cannot grow */
4853     {
4854       if (i == 4 && (!waiting_for_player || game.emulation == EMU_BOULDERDASH))
4855       {
4856         Feld[ax][ay] = EL_AMOEBA_DEAD;
4857         DrawLevelField(ax, ay);
4858         AmoebaCnt[AmoebaNr[ax][ay]]--;
4859
4860         if (AmoebaCnt[AmoebaNr[ax][ay]] <= 0)   /* amoeba is completely dead */
4861         {
4862           if (element == EL_AMOEBA_FULL)
4863             AmoebeUmwandeln(ax, ay);
4864           else if (element == EL_BD_AMOEBA)
4865             AmoebeUmwandelnBD(ax, ay, level.amoeba_content);
4866         }
4867       }
4868       return;
4869     }
4870     else if (element == EL_AMOEBA_FULL || element == EL_BD_AMOEBA)
4871     {
4872       /* amoeba gets larger by growing in some direction */
4873
4874       int new_group_nr = AmoebaNr[ax][ay];
4875
4876 #ifdef DEBUG
4877   if (new_group_nr == 0)
4878   {
4879     printf("AmoebeAbleger(): newax = %d, neway = %d\n", newax, neway);
4880     printf("AmoebeAbleger(): This should never happen!\n");
4881     return;
4882   }
4883 #endif
4884
4885       AmoebaNr[newax][neway] = new_group_nr;
4886       AmoebaCnt[new_group_nr]++;
4887       AmoebaCnt2[new_group_nr]++;
4888
4889       /* if amoeba touches other amoeba(s) after growing, unify them */
4890       AmoebenVereinigen(newax, neway);
4891
4892       if (element == EL_BD_AMOEBA && AmoebaCnt2[new_group_nr] >= 200)
4893       {
4894         AmoebeUmwandelnBD(newax, neway, EL_BD_ROCK);
4895         return;
4896       }
4897     }
4898   }
4899
4900   if (element != EL_AMOEBA_WET || neway < ay || !IS_FREE(newax, neway) ||
4901       (neway == lev_fieldy - 1 && newax != ax))
4902   {
4903     Feld[newax][neway] = EL_AMOEBA_GROWING;     /* creation of new amoeba */
4904     Store[newax][neway] = element;
4905   }
4906   else if (neway == ay)
4907   {
4908     Feld[newax][neway] = EL_AMOEBA_DROP;        /* drop left/right of amoeba */
4909 #if 1
4910     PlaySoundLevelAction(newax, neway, ACTION_GROWING);
4911 #else
4912     PlaySoundLevel(newax, neway, SND_AMOEBA_GROWING);
4913 #endif
4914   }
4915   else
4916   {
4917     InitMovingField(ax, ay, MV_DOWN);           /* drop dripping from amoeba */
4918     Feld[ax][ay] = EL_AMOEBA_DROPPING;
4919     Store[ax][ay] = EL_AMOEBA_DROP;
4920     ContinueMoving(ax, ay);
4921     return;
4922   }
4923
4924   DrawLevelField(newax, neway);
4925 }
4926
4927 void Life(int ax, int ay)
4928 {
4929   int x1, y1, x2, y2;
4930   static int life[4] = { 2, 3, 3, 3 };  /* parameters for "game of life" */
4931   int life_time = 40;
4932   int element = Feld[ax][ay];
4933   int graphic = el2img(element);
4934   boolean changed = FALSE;
4935
4936   if (IS_ANIMATED(graphic))
4937     DrawLevelGraphicAnimationIfNeeded(ax, ay, graphic);
4938
4939   if (Stop[ax][ay])
4940     return;
4941
4942   if (!MovDelay[ax][ay])        /* start new "game of life" cycle */
4943     MovDelay[ax][ay] = life_time;
4944
4945   if (MovDelay[ax][ay])         /* wait some time before next cycle */
4946   {
4947     MovDelay[ax][ay]--;
4948     if (MovDelay[ax][ay])
4949       return;
4950   }
4951
4952   for (y1=-1; y1<2; y1++) for(x1=-1; x1<2; x1++)
4953   {
4954     int xx = ax+x1, yy = ay+y1;
4955     int nachbarn = 0;
4956
4957     if (!IN_LEV_FIELD(xx, yy))
4958       continue;
4959
4960     for (y2=-1; y2<2; y2++) for (x2=-1; x2<2; x2++)
4961     {
4962       int x = xx+x2, y = yy+y2;
4963
4964       if (!IN_LEV_FIELD(x, y) || (x == xx && y == yy))
4965         continue;
4966
4967       if (((Feld[x][y] == element ||
4968             (element == EL_GAME_OF_LIFE && IS_PLAYER(x, y))) &&
4969            !Stop[x][y]) ||
4970           (IS_FREE(x, y) && Stop[x][y]))
4971         nachbarn++;
4972     }
4973
4974     if (xx == ax && yy == ay)           /* field in the middle */
4975     {
4976       if (nachbarn < life[0] || nachbarn > life[1])
4977       {
4978         Feld[xx][yy] = EL_EMPTY;
4979         if (!Stop[xx][yy])
4980           DrawLevelField(xx, yy);
4981         Stop[xx][yy] = TRUE;
4982         changed = TRUE;
4983       }
4984     }
4985     /* !!! extend EL_SAND to anything diggable (but maybe not SP_BASE) !!! */
4986     else if (IS_FREE(xx, yy) || Feld[xx][yy] == EL_SAND)
4987     {                                   /* free border field */
4988       if (nachbarn >= life[2] && nachbarn <= life[3])
4989       {
4990         Feld[xx][yy] = element;
4991         MovDelay[xx][yy] = (element == EL_GAME_OF_LIFE ? 0 : life_time-1);
4992         if (!Stop[xx][yy])
4993           DrawLevelField(xx, yy);
4994         Stop[xx][yy] = TRUE;
4995         changed = TRUE;
4996       }
4997     }
4998   }
4999
5000   if (changed)
5001     PlaySoundLevel(ax, ay, element == EL_BIOMAZE ? SND_BIOMAZE_GROWING :
5002                    SND_GAME_OF_LIFE_GROWING);
5003 }
5004
5005 static void InitRobotWheel(int x, int y)
5006 {
5007   ChangeDelay[x][y] = level.time_wheel * FRAMES_PER_SECOND;
5008 }
5009
5010 static void RunRobotWheel(int x, int y)
5011 {
5012   PlaySoundLevel(x, y, SND_ROBOT_WHEEL_ACTIVE);
5013 }
5014
5015 static void StopRobotWheel(int x, int y)
5016 {
5017   if (ZX == x && ZY == y)
5018     ZX = ZY = -1;
5019 }
5020
5021 static void InitTimegateWheel(int x, int y)
5022 {
5023   ChangeDelay[x][y] = level.time_wheel * FRAMES_PER_SECOND;
5024 }
5025
5026 static void RunTimegateWheel(int x, int y)
5027 {
5028   PlaySoundLevel(x, y, SND_TIMEGATE_SWITCH_ACTIVE);
5029 }
5030
5031 void CheckExit(int x, int y)
5032 {
5033   if (local_player->gems_still_needed > 0 ||
5034       local_player->sokobanfields_still_needed > 0 ||
5035       local_player->lights_still_needed > 0)
5036   {
5037     int element = Feld[x][y];
5038     int graphic = el2img(element);
5039
5040     if (IS_ANIMATED(graphic))
5041       DrawLevelGraphicAnimationIfNeeded(x, y, graphic);
5042
5043     return;
5044   }
5045
5046   if (AllPlayersGone)   /* do not re-open exit door closed after last player */
5047     return;
5048
5049   Feld[x][y] = EL_EXIT_OPENING;
5050
5051   PlaySoundLevelNearest(x, y, SND_CLASS_EXIT_OPENING);
5052 }
5053
5054 void CheckExitSP(int x, int y)
5055 {
5056   if (local_player->gems_still_needed > 0)
5057   {
5058     int element = Feld[x][y];
5059     int graphic = el2img(element);
5060
5061     if (IS_ANIMATED(graphic))
5062       DrawLevelGraphicAnimationIfNeeded(x, y, graphic);
5063
5064     return;
5065   }
5066
5067   Feld[x][y] = EL_SP_EXIT_OPEN;
5068
5069   PlaySoundLevelNearest(x, y, SND_CLASS_SP_EXIT_OPENING);
5070 }
5071
5072 static void CloseAllOpenTimegates()
5073 {
5074   int x, y;
5075
5076   for (y=0; y<lev_fieldy; y++)
5077   {
5078     for (x=0; x<lev_fieldx; x++)
5079     {
5080       int element = Feld[x][y];
5081
5082       if (element == EL_TIMEGATE_OPEN || element == EL_TIMEGATE_OPENING)
5083       {
5084         Feld[x][y] = EL_TIMEGATE_CLOSING;
5085 #if 1
5086         PlaySoundLevelAction(x, y, ACTION_CLOSING);
5087 #else
5088         PlaySoundLevel(x, y, SND_TIMEGATE_CLOSING);
5089 #endif
5090       }
5091     }
5092   }
5093 }
5094
5095 void EdelsteinFunkeln(int x, int y)
5096 {
5097   if (!IN_SCR_FIELD(SCREENX(x), SCREENY(y)) || IS_MOVING(x, y))
5098     return;
5099
5100   if (Feld[x][y] == EL_BD_DIAMOND)
5101     return;
5102
5103   if (MovDelay[x][y] == 0)      /* next animation frame */
5104     MovDelay[x][y] = 11 * !SimpleRND(500);
5105
5106   if (MovDelay[x][y] != 0)      /* wait some time before next frame */
5107   {
5108     MovDelay[x][y]--;
5109
5110     if (setup.direct_draw && MovDelay[x][y])
5111       SetDrawtoField(DRAW_BUFFERED);
5112
5113     DrawLevelElementAnimation(x, y, Feld[x][y]);
5114
5115     if (MovDelay[x][y] != 0)
5116     {
5117       int frame = getGraphicAnimationFrame(IMG_TWINKLE_WHITE,
5118                                            10 - MovDelay[x][y]);
5119
5120       DrawGraphicThruMask(SCREENX(x), SCREENY(y), IMG_TWINKLE_WHITE, frame);
5121
5122       if (setup.direct_draw)
5123       {
5124         int dest_x, dest_y;
5125
5126         dest_x = FX + SCREENX(x) * TILEX;
5127         dest_y = FY + SCREENY(y) * TILEY;
5128
5129         BlitBitmap(drawto_field, window,
5130                    dest_x, dest_y, TILEX, TILEY, dest_x, dest_y);
5131         SetDrawtoField(DRAW_DIRECT);
5132       }
5133     }
5134   }
5135 }
5136
5137 void MauerWaechst(int x, int y)
5138 {
5139   int delay = 6;
5140
5141   if (!MovDelay[x][y])          /* next animation frame */
5142     MovDelay[x][y] = 3 * delay;
5143
5144   if (MovDelay[x][y])           /* wait some time before next frame */
5145   {
5146     MovDelay[x][y]--;
5147
5148     if (IN_SCR_FIELD(SCREENX(x), SCREENY(y)))
5149     {
5150       int graphic = el_dir2img(Feld[x][y], MovDir[x][y]);
5151       int frame = getGraphicAnimationFrame(graphic, 17 - MovDelay[x][y]);
5152
5153       DrawGraphic(SCREENX(x), SCREENY(y), graphic, frame);
5154     }
5155
5156     if (!MovDelay[x][y])
5157     {
5158       if (MovDir[x][y] == MV_LEFT)
5159       {
5160         if (IN_LEV_FIELD(x - 1, y) && IS_WALL(Feld[x - 1][y]))
5161           DrawLevelField(x - 1, y);
5162       }
5163       else if (MovDir[x][y] == MV_RIGHT)
5164       {
5165         if (IN_LEV_FIELD(x + 1, y) && IS_WALL(Feld[x + 1][y]))
5166           DrawLevelField(x + 1, y);
5167       }
5168       else if (MovDir[x][y] == MV_UP)
5169       {
5170         if (IN_LEV_FIELD(x, y - 1) && IS_WALL(Feld[x][y - 1]))
5171           DrawLevelField(x, y - 1);
5172       }
5173       else
5174       {
5175         if (IN_LEV_FIELD(x, y + 1) && IS_WALL(Feld[x][y + 1]))
5176           DrawLevelField(x, y + 1);
5177       }
5178
5179       Feld[x][y] = Store[x][y];
5180       Store[x][y] = 0;
5181       MovDir[x][y] = MV_NO_MOVING;
5182       DrawLevelField(x, y);
5183     }
5184   }
5185 }
5186
5187 void MauerAbleger(int ax, int ay)
5188 {
5189   int element = Feld[ax][ay];
5190   int graphic = el2img(element);
5191   boolean oben_frei = FALSE, unten_frei = FALSE;
5192   boolean links_frei = FALSE, rechts_frei = FALSE;
5193   boolean oben_massiv = FALSE, unten_massiv = FALSE;
5194   boolean links_massiv = FALSE, rechts_massiv = FALSE;
5195   boolean new_wall = FALSE;
5196
5197   if (IS_ANIMATED(graphic))
5198     DrawLevelGraphicAnimationIfNeeded(ax, ay, graphic);
5199
5200   if (!MovDelay[ax][ay])        /* start building new wall */
5201     MovDelay[ax][ay] = 6;
5202
5203   if (MovDelay[ax][ay])         /* wait some time before building new wall */
5204   {
5205     MovDelay[ax][ay]--;
5206     if (MovDelay[ax][ay])
5207       return;
5208   }
5209
5210   if (IN_LEV_FIELD(ax, ay-1) && IS_FREE(ax, ay-1))
5211     oben_frei = TRUE;
5212   if (IN_LEV_FIELD(ax, ay+1) && IS_FREE(ax, ay+1))
5213     unten_frei = TRUE;
5214   if (IN_LEV_FIELD(ax-1, ay) && IS_FREE(ax-1, ay))
5215     links_frei = TRUE;
5216   if (IN_LEV_FIELD(ax+1, ay) && IS_FREE(ax+1, ay))
5217     rechts_frei = TRUE;
5218
5219   if (element == EL_EXPANDABLE_WALL_VERTICAL ||
5220       element == EL_EXPANDABLE_WALL_ANY)
5221   {
5222     if (oben_frei)
5223     {
5224       Feld[ax][ay-1] = EL_EXPANDABLE_WALL_GROWING;
5225       Store[ax][ay-1] = element;
5226       MovDir[ax][ay-1] = MV_UP;
5227       if (IN_SCR_FIELD(SCREENX(ax), SCREENY(ay-1)))
5228         DrawGraphic(SCREENX(ax), SCREENY(ay - 1),
5229                     IMG_EXPANDABLE_WALL_GROWING_UP, 0);
5230       new_wall = TRUE;
5231     }
5232     if (unten_frei)
5233     {
5234       Feld[ax][ay+1] = EL_EXPANDABLE_WALL_GROWING;
5235       Store[ax][ay+1] = element;
5236       MovDir[ax][ay+1] = MV_DOWN;
5237       if (IN_SCR_FIELD(SCREENX(ax), SCREENY(ay+1)))
5238         DrawGraphic(SCREENX(ax), SCREENY(ay + 1),
5239                     IMG_EXPANDABLE_WALL_GROWING_DOWN, 0);
5240       new_wall = TRUE;
5241     }
5242   }
5243
5244   if (element == EL_EXPANDABLE_WALL_HORIZONTAL ||
5245       element == EL_EXPANDABLE_WALL_ANY ||
5246       element == EL_EXPANDABLE_WALL)
5247   {
5248     if (links_frei)
5249     {
5250       Feld[ax-1][ay] = EL_EXPANDABLE_WALL_GROWING;
5251       Store[ax-1][ay] = element;
5252       MovDir[ax-1][ay] = MV_LEFT;
5253       if (IN_SCR_FIELD(SCREENX(ax-1), SCREENY(ay)))
5254         DrawGraphic(SCREENX(ax - 1), SCREENY(ay),
5255                     IMG_EXPANDABLE_WALL_GROWING_LEFT, 0);
5256       new_wall = TRUE;
5257     }
5258
5259     if (rechts_frei)
5260     {
5261       Feld[ax+1][ay] = EL_EXPANDABLE_WALL_GROWING;
5262       Store[ax+1][ay] = element;
5263       MovDir[ax+1][ay] = MV_RIGHT;
5264       if (IN_SCR_FIELD(SCREENX(ax+1), SCREENY(ay)))
5265         DrawGraphic(SCREENX(ax + 1), SCREENY(ay),
5266                     IMG_EXPANDABLE_WALL_GROWING_RIGHT, 0);
5267       new_wall = TRUE;
5268     }
5269   }
5270
5271   if (element == EL_EXPANDABLE_WALL && (links_frei || rechts_frei))
5272     DrawLevelField(ax, ay);
5273
5274   if (!IN_LEV_FIELD(ax, ay-1) || IS_WALL(Feld[ax][ay-1]))
5275     oben_massiv = TRUE;
5276   if (!IN_LEV_FIELD(ax, ay+1) || IS_WALL(Feld[ax][ay+1]))
5277     unten_massiv = TRUE;
5278   if (!IN_LEV_FIELD(ax-1, ay) || IS_WALL(Feld[ax-1][ay]))
5279     links_massiv = TRUE;
5280   if (!IN_LEV_FIELD(ax+1, ay) || IS_WALL(Feld[ax+1][ay]))
5281     rechts_massiv = TRUE;
5282
5283   if (((oben_massiv && unten_massiv) ||
5284        element == EL_EXPANDABLE_WALL_HORIZONTAL ||
5285        element == EL_EXPANDABLE_WALL) &&
5286       ((links_massiv && rechts_massiv) ||
5287        element == EL_EXPANDABLE_WALL_VERTICAL))
5288     Feld[ax][ay] = EL_WALL;
5289
5290   if (new_wall)
5291 #if 1
5292     PlaySoundLevelAction(ax, ay, ACTION_GROWING);
5293 #else
5294     PlaySoundLevel(ax, ay, SND_EXPANDABLE_WALL_GROWING);
5295 #endif
5296 }
5297
5298 void CheckForDragon(int x, int y)
5299 {
5300   int i, j;
5301   boolean dragon_found = FALSE;
5302   static int xy[4][2] =
5303   {
5304     { 0, -1 },
5305     { -1, 0 },
5306     { +1, 0 },
5307     { 0, +1 }
5308   };
5309
5310   for (i=0; i<4; i++)
5311   {
5312     for (j=0; j<4; j++)
5313     {
5314       int xx = x + j*xy[i][0], yy = y + j*xy[i][1];
5315
5316       if (IN_LEV_FIELD(xx, yy) &&
5317           (Feld[xx][yy] == EL_FLAMES || Feld[xx][yy] == EL_DRAGON))
5318       {
5319         if (Feld[xx][yy] == EL_DRAGON)
5320           dragon_found = TRUE;
5321       }
5322       else
5323         break;
5324     }
5325   }
5326
5327   if (!dragon_found)
5328   {
5329     for (i=0; i<4; i++)
5330     {
5331       for (j=0; j<3; j++)
5332       {
5333         int xx = x + j*xy[i][0], yy = y + j*xy[i][1];
5334
5335         if (IN_LEV_FIELD(xx, yy) && Feld[xx][yy] == EL_FLAMES)
5336         {
5337           Feld[xx][yy] = EL_EMPTY;
5338           DrawLevelField(xx, yy);
5339         }
5340         else
5341           break;
5342       }
5343     }
5344   }
5345 }
5346
5347 static void InitBuggyBase(int x, int y)
5348 {
5349   int element = Feld[x][y];
5350   int activating_delay = FRAMES_PER_SECOND / 4;
5351
5352   ChangeDelay[x][y] =
5353     (element == EL_SP_BUGGY_BASE ?
5354      2 * FRAMES_PER_SECOND + RND(5 * FRAMES_PER_SECOND) - activating_delay :
5355      element == EL_SP_BUGGY_BASE_ACTIVATING ?
5356      activating_delay :
5357      element == EL_SP_BUGGY_BASE_ACTIVE ?
5358      1 * FRAMES_PER_SECOND + RND(1 * FRAMES_PER_SECOND) : 1);
5359 }
5360
5361 static void WarnBuggyBase(int x, int y)
5362 {
5363   int i;
5364   static int xy[4][2] =
5365   {
5366     { 0, -1 },
5367     { -1, 0 },
5368     { +1, 0 },
5369     { 0, +1 }
5370   };
5371
5372   for (i=0; i<4; i++)
5373   {
5374     int xx = x + xy[i][0], yy = y + xy[i][1];
5375
5376     if (IS_PLAYER(xx, yy))
5377     {
5378       PlaySoundLevel(x, y, SND_SP_BUGGY_BASE_ACTIVE);
5379
5380       break;
5381     }
5382   }
5383 }
5384
5385 static void InitTrap(int x, int y)
5386 {
5387   ChangeDelay[x][y] = 2 * FRAMES_PER_SECOND + RND(5 * FRAMES_PER_SECOND);
5388 }
5389
5390 static void ActivateTrap(int x, int y)
5391 {
5392   PlaySoundLevel(x, y, SND_TRAP_ACTIVATING);
5393 }
5394
5395 static void ChangeActiveTrap(int x, int y)
5396 {
5397   int graphic = IMG_TRAP_ACTIVE;
5398
5399   /* if new animation frame was drawn, correct crumbled sand border */
5400   if (IS_NEW_FRAME(GfxFrame[x][y], graphic))
5401     DrawLevelFieldCrumbledSand(x, y);
5402 }
5403
5404 static void ChangeElementNowExt(int x, int y, int target_element)
5405 {
5406   /* check if element under player changes from accessible to unaccessible
5407      (needed for special case of dropping element which then changes) */
5408   if (IS_PLAYER(x, y) && !PLAYER_PROTECTED(x, y) &&
5409       IS_ACCESSIBLE(Feld[x][y]) && !IS_ACCESSIBLE(target_element))
5410   {
5411     Bang(x, y);
5412     return;
5413   }
5414
5415   RemoveField(x, y);
5416   Feld[x][y] = target_element;
5417
5418   Changed[x][y] |= ChangeEvent[x][y];   /* ignore same changes in this frame */
5419
5420   ResetGfxAnimation(x, y);
5421   ResetRandomAnimationValue(x, y);
5422
5423   InitField(x, y, FALSE);
5424   if (CAN_MOVE(Feld[x][y]))
5425     InitMovDir(x, y);
5426
5427   DrawLevelField(x, y);
5428
5429   if (GFX_CRUMBLED(Feld[x][y]))
5430     DrawLevelFieldCrumbledSandNeighbours(x, y);
5431
5432   TestIfBadThingTouchesHero(x, y);
5433   TestIfPlayerTouchesCustomElement(x, y);
5434   TestIfElementTouchesCustomElement(x, y);
5435
5436   if (ELEM_IS_PLAYER(target_element))
5437     RelocatePlayer(x, y, target_element);
5438 }
5439
5440 static boolean ChangeElementNow(int x, int y, int element, int page)
5441 {
5442   struct ElementChangeInfo *change = &element_info[element].change_page[page];
5443
5444   /* always use default change event to prevent running into a loop */
5445   if (ChangeEvent[x][y] == CE_BITMASK_DEFAULT)
5446     ChangeEvent[x][y] = CH_EVENT_BIT(CE_DELAY);
5447
5448   /* do not change already changed elements with same change event */
5449 #if 0
5450   if (Changed[x][y] & ChangeEvent[x][y])
5451     return FALSE;
5452 #else
5453   if (Changed[x][y])
5454     return FALSE;
5455 #endif
5456
5457   Changed[x][y] |= ChangeEvent[x][y];   /* ignore same changes in this frame */
5458
5459   CheckTriggeredElementChange(x, y, Feld[x][y], CE_OTHER_IS_CHANGING);
5460
5461   if (change->explode)
5462   {
5463     Bang(x, y);
5464
5465     return TRUE;
5466   }
5467
5468   if (change->use_content)
5469   {
5470     boolean complete_change = TRUE;
5471     boolean can_change[3][3];
5472     int xx, yy;
5473
5474     for (yy = 0; yy < 3; yy++) for(xx = 0; xx < 3 ; xx++)
5475     {
5476       boolean half_destructible;
5477       int ex = x + xx - 1;
5478       int ey = y + yy - 1;
5479       int e;
5480
5481       can_change[xx][yy] = TRUE;
5482
5483       if (ex == x && ey == y)   /* do not check changing element itself */
5484         continue;
5485
5486       if (change->content[xx][yy] == EL_EMPTY_SPACE)
5487       {
5488         can_change[xx][yy] = FALSE;     /* do not change empty borders */
5489
5490         continue;
5491       }
5492
5493       if (!IN_LEV_FIELD(ex, ey))
5494       {
5495         can_change[xx][yy] = FALSE;
5496         complete_change = FALSE;
5497
5498         continue;
5499       }
5500
5501       e = Feld[ex][ey];
5502
5503       if (IS_MOVING(ex, ey) || IS_BLOCKED(ex, ey))
5504         e = MovingOrBlocked2Element(ex, ey);
5505
5506       half_destructible = (IS_FREE(ex, ey) || IS_DIGGABLE(e));
5507
5508       if ((change->power <= CP_NON_DESTRUCTIVE  && !IS_FREE(ex, ey)) ||
5509           (change->power <= CP_HALF_DESTRUCTIVE && !half_destructible) ||
5510           (change->power <= CP_FULL_DESTRUCTIVE && IS_INDESTRUCTIBLE(e)))
5511       {
5512         can_change[xx][yy] = FALSE;
5513         complete_change = FALSE;
5514       }
5515     }
5516
5517     if (!change->only_complete || complete_change)
5518     {
5519       boolean something_has_changed = FALSE;
5520
5521       if (change->only_complete && change->use_random_change &&
5522           RND(100) < change->random)
5523         return FALSE;
5524
5525       for (yy = 0; yy < 3; yy++) for(xx = 0; xx < 3 ; xx++)
5526       {
5527         int ex = x + xx - 1;
5528         int ey = y + yy - 1;
5529
5530         if (can_change[xx][yy] && (!change->use_random_change ||
5531                                    RND(100) < change->random))
5532         {
5533           if (IS_MOVING(ex, ey) || IS_BLOCKED(ex, ey))
5534             RemoveMovingField(ex, ey);
5535
5536           ChangeElementNowExt(ex, ey, change->content[xx][yy]);
5537
5538           something_has_changed = TRUE;
5539
5540           /* for symmetry reasons, freeze newly created border elements */
5541           if (ex != x || ey != y)
5542             Stop[ex][ey] = TRUE;        /* no more moving in this frame */
5543         }
5544       }
5545
5546       if (something_has_changed)
5547         PlaySoundLevelElementAction(x, y, element, ACTION_CHANGING);
5548     }
5549   }
5550   else
5551   {
5552     ChangeElementNowExt(x, y, change->target_element);
5553
5554     PlaySoundLevelElementAction(x, y, element, ACTION_CHANGING);
5555   }
5556
5557   return TRUE;
5558 }
5559
5560 static void ChangeElement(int x, int y, int page)
5561 {
5562   int element = MovingOrBlocked2Element(x, y);
5563   struct ElementChangeInfo *change = &element_info[element].change_page[page];
5564
5565 #if 0
5566 #ifdef DEBUG
5567   if (!CAN_CHANGE(element))
5568   {
5569     printf("\n\n");
5570     printf("ChangeElement(): %d,%d: element = %d ('%s')\n",
5571            x, y, element, element_info[element].token_name);
5572     printf("ChangeElement(): This should never happen!\n");
5573     printf("\n\n");
5574   }
5575 #endif
5576 #endif
5577
5578   if (ChangeDelay[x][y] == 0)           /* initialize element change */
5579   {
5580     ChangeDelay[x][y] = (    change->delay_fixed  * change->delay_frames +
5581                          RND(change->delay_random * change->delay_frames)) + 1;
5582
5583     ResetGfxAnimation(x, y);
5584     ResetRandomAnimationValue(x, y);
5585
5586     if (change->pre_change_function)
5587       change->pre_change_function(x, y);
5588   }
5589
5590   ChangeDelay[x][y]--;
5591
5592   if (ChangeDelay[x][y] != 0)           /* continue element change */
5593   {
5594     int graphic = el_act_dir2img(element, GfxAction[x][y], MovDir[x][y]);
5595
5596     if (IS_ANIMATED(graphic))
5597       DrawLevelGraphicAnimationIfNeeded(x, y, graphic);
5598
5599     if (change->change_function)
5600       change->change_function(x, y);
5601   }
5602   else                                  /* finish element change */
5603   {
5604     if (IS_MOVING(x, y))                /* never change a running system ;-) */
5605     {
5606       ChangeDelay[x][y] = 1;            /* try change after next move step */
5607
5608       return;
5609     }
5610
5611     if (ChangeElementNow(x, y, element, page))
5612     {
5613       if (change->post_change_function)
5614         change->post_change_function(x, y);
5615     }
5616   }
5617 }
5618
5619 static boolean CheckTriggeredElementSideChange(int lx, int ly,
5620                                                int trigger_element,
5621                                                int trigger_side,
5622                                                int trigger_event)
5623 {
5624   int i, j, x, y;
5625
5626   if (!(trigger_events[trigger_element] & CH_EVENT_BIT(trigger_event)))
5627     return FALSE;
5628
5629   for (i=0; i < NUM_CUSTOM_ELEMENTS; i++)
5630   {
5631     int element = EL_CUSTOM_START + i;
5632
5633     boolean change_element = FALSE;
5634     int page;
5635
5636     if (!CAN_CHANGE(element) ||
5637         !HAS_ANY_CHANGE_EVENT(element, trigger_event))
5638       continue;
5639
5640     for (j=0; j < element_info[element].num_change_pages; j++)
5641     {
5642       struct ElementChangeInfo *change = &element_info[element].change_page[j];
5643
5644       if (change->sides & trigger_side &&
5645           change->trigger_element == trigger_element)
5646       {
5647         change_element = TRUE;
5648         page = j;
5649
5650         break;
5651       }
5652     }
5653
5654     if (!change_element)
5655       continue;
5656
5657     for (y=0; y<lev_fieldy; y++) for (x=0; x<lev_fieldx; x++)
5658     {
5659 #if 0
5660       if (x == lx && y == ly)   /* do not change trigger element itself */
5661         continue;
5662 #endif
5663
5664       if (Feld[x][y] == element)
5665       {
5666         ChangeDelay[x][y] = 1;
5667         ChangeEvent[x][y] = CH_EVENT_BIT(trigger_event);
5668         ChangeElement(x, y, page);
5669       }
5670     }
5671   }
5672
5673   return TRUE;
5674 }
5675
5676 static boolean CheckTriggeredElementChange(int lx, int ly, int trigger_element,
5677                                            int trigger_event)
5678 {
5679   return CheckTriggeredElementSideChange(lx, ly, trigger_element, CH_SIDE_ANY,
5680                                          trigger_event);
5681 }
5682
5683 static boolean CheckElementSideChange(int x, int y, int element, int side,
5684                                       int trigger_event, int page)
5685 {
5686   if (!CAN_CHANGE(element) || !HAS_ANY_CHANGE_EVENT(element, trigger_event))
5687     return FALSE;
5688
5689   if (Feld[x][y] == EL_BLOCKED)
5690   {
5691     Blocked2Moving(x, y, &x, &y);
5692     element = Feld[x][y];
5693   }
5694
5695   if (page < 0)
5696     page = element_info[element].event_page_nr[trigger_event];
5697
5698   if (!(element_info[element].change_page[page].sides & side))
5699     return FALSE;
5700
5701   ChangeDelay[x][y] = 1;
5702   ChangeEvent[x][y] = CH_EVENT_BIT(trigger_event);
5703   ChangeElement(x, y, page);
5704
5705   return TRUE;
5706 }
5707
5708 static boolean CheckElementChange(int x, int y, int element, int trigger_event)
5709 {
5710   return CheckElementSideChange(x, y, element, CH_SIDE_ANY, trigger_event, -1);
5711 }
5712
5713 static void PlayerActions(struct PlayerInfo *player, byte player_action)
5714 {
5715   static byte stored_player_action[MAX_PLAYERS];
5716   static int num_stored_actions = 0;
5717   boolean moved = FALSE, snapped = FALSE, dropped = FALSE;
5718   int left      = player_action & JOY_LEFT;
5719   int right     = player_action & JOY_RIGHT;
5720   int up        = player_action & JOY_UP;
5721   int down      = player_action & JOY_DOWN;
5722   int button1   = player_action & JOY_BUTTON_1;
5723   int button2   = player_action & JOY_BUTTON_2;
5724   int dx        = (left ? -1    : right ? 1     : 0);
5725   int dy        = (up   ? -1    : down  ? 1     : 0);
5726
5727   stored_player_action[player->index_nr] = 0;
5728   num_stored_actions++;
5729
5730   if (!player->active || tape.pausing)
5731     return;
5732
5733   if (player_action)
5734   {
5735     if (button1)
5736       snapped = SnapField(player, dx, dy);
5737     else
5738     {
5739       if (button2)
5740         dropped = DropElement(player);
5741
5742       moved = MoveFigure(player, dx, dy);
5743     }
5744
5745     if (tape.single_step && tape.recording && !tape.pausing)
5746     {
5747       if (button1 || (dropped && !moved))
5748       {
5749         TapeTogglePause(TAPE_TOGGLE_AUTOMATIC);
5750         SnapField(player, 0, 0);                /* stop snapping */
5751       }
5752     }
5753
5754     stored_player_action[player->index_nr] = player_action;
5755   }
5756   else
5757   {
5758     /* no actions for this player (no input at player's configured device) */
5759
5760     DigField(player, 0, 0, 0, 0, DF_NO_PUSH);
5761     SnapField(player, 0, 0);
5762     CheckGravityMovement(player);
5763
5764     if (player->MovPos == 0)
5765       InitPlayerGfxAnimation(player, ACTION_DEFAULT, player->MovDir);
5766
5767     if (player->MovPos == 0)    /* needed for tape.playing */
5768       player->is_moving = FALSE;
5769   }
5770
5771   if (tape.recording && num_stored_actions >= MAX_PLAYERS)
5772   {
5773     TapeRecordAction(stored_player_action);
5774     num_stored_actions = 0;
5775   }
5776 }
5777
5778 void GameActions()
5779 {
5780   static unsigned long action_delay = 0;
5781   unsigned long action_delay_value;
5782   int magic_wall_x = 0, magic_wall_y = 0;
5783   int i, x, y, element, graphic;
5784   byte *recorded_player_action;
5785   byte summarized_player_action = 0;
5786
5787   if (game_status != GAME_MODE_PLAYING)
5788     return;
5789
5790   action_delay_value =
5791     (tape.playing && tape.fast_forward ? FfwdFrameDelay : GameFrameDelay);
5792
5793   if (tape.playing && tape.index_search && !tape.pausing)
5794     action_delay_value = 0;
5795
5796   /* ---------- main game synchronization point ---------- */
5797
5798   WaitUntilDelayReached(&action_delay, action_delay_value);
5799
5800   if (network_playing && !network_player_action_received)
5801   {
5802     /*
5803 #ifdef DEBUG
5804     printf("DEBUG: try to get network player actions in time\n");
5805 #endif
5806     */
5807
5808 #if defined(PLATFORM_UNIX)
5809     /* last chance to get network player actions without main loop delay */
5810     HandleNetworking();
5811 #endif
5812
5813     if (game_status != GAME_MODE_PLAYING)
5814       return;
5815
5816     if (!network_player_action_received)
5817     {
5818       /*
5819 #ifdef DEBUG
5820       printf("DEBUG: failed to get network player actions in time\n");
5821 #endif
5822       */
5823       return;
5824     }
5825   }
5826
5827   if (tape.pausing)
5828     return;
5829
5830   recorded_player_action = (tape.playing ? TapePlayAction() : NULL);
5831
5832   for (i=0; i<MAX_PLAYERS; i++)
5833   {
5834     summarized_player_action |= stored_player[i].action;
5835
5836     if (!network_playing)
5837       stored_player[i].effective_action = stored_player[i].action;
5838   }
5839
5840 #if defined(PLATFORM_UNIX)
5841   if (network_playing)
5842     SendToServer_MovePlayer(summarized_player_action);
5843 #endif
5844
5845   if (!options.network && !setup.team_mode)
5846     local_player->effective_action = summarized_player_action;
5847
5848   for (i=0; i<MAX_PLAYERS; i++)
5849   {
5850     int actual_player_action = stored_player[i].effective_action;
5851
5852     if (stored_player[i].programmed_action)
5853       actual_player_action = stored_player[i].programmed_action;
5854
5855     if (recorded_player_action)
5856       actual_player_action = recorded_player_action[i];
5857
5858     PlayerActions(&stored_player[i], actual_player_action);
5859     ScrollFigure(&stored_player[i], SCROLL_GO_ON);
5860   }
5861
5862   network_player_action_received = FALSE;
5863
5864   ScrollScreen(NULL, SCROLL_GO_ON);
5865
5866 #if 0
5867   FrameCounter++;
5868   TimeFrames++;
5869
5870   for (i=0; i<MAX_PLAYERS; i++)
5871     stored_player[i].Frame++;
5872 #endif
5873
5874 #if 1
5875   if (game.engine_version < RELEASE_IDENT(2,2,0,7))
5876   {
5877     for (i=0; i<MAX_PLAYERS; i++)
5878     {
5879       struct PlayerInfo *player = &stored_player[i];
5880       int x = player->jx;
5881       int y = player->jy;
5882
5883       if (player->active && player->Pushing && player->is_moving &&
5884           IS_MOVING(x, y))
5885       {
5886         ContinueMoving(x, y);
5887
5888         /* continue moving after pushing (this is actually a bug) */
5889         if (!IS_MOVING(x, y))
5890         {
5891           Stop[x][y] = FALSE;
5892         }
5893       }
5894     }
5895   }
5896 #endif
5897
5898   for (y=0; y<lev_fieldy; y++) for (x=0; x<lev_fieldx; x++)
5899   {
5900     Changed[x][y] = CE_BITMASK_DEFAULT;
5901     ChangeEvent[x][y] = CE_BITMASK_DEFAULT;
5902
5903     Stop[x][y] = FALSE;
5904     if (JustStopped[x][y] > 0)
5905       JustStopped[x][y]--;
5906
5907     GfxFrame[x][y]++;
5908
5909 #if 1
5910     /* reset finished pushing action (not done in ContinueMoving() to allow
5911        continous pushing animation for elements with zero push delay) */
5912     if (GfxAction[x][y] == ACTION_PUSHING && !IS_MOVING(x, y))
5913     {
5914       ResetGfxAnimation(x, y);
5915       DrawLevelField(x, y);
5916     }
5917 #endif
5918
5919 #if DEBUG
5920     if (IS_BLOCKED(x, y))
5921     {
5922       int oldx, oldy;
5923
5924       Blocked2Moving(x, y, &oldx, &oldy);
5925       if (!IS_MOVING(oldx, oldy))
5926       {
5927         printf("GameActions(): (BLOCKED => MOVING) context corrupted!\n");
5928         printf("GameActions(): BLOCKED: x = %d, y = %d\n", x, y);
5929         printf("GameActions(): !MOVING: oldx = %d, oldy = %d\n", oldx, oldy);
5930         printf("GameActions(): This should never happen!\n");
5931       }
5932     }
5933 #endif
5934   }
5935
5936   for (y=0; y<lev_fieldy; y++) for (x=0; x<lev_fieldx; x++)
5937   {
5938     element = Feld[x][y];
5939 #if 1
5940     graphic = el_act_dir2img(element, GfxAction[x][y], MovDir[x][y]);
5941 #else
5942     graphic = el2img(element);
5943 #endif
5944
5945 #if 0
5946     if (element == -1)
5947     {
5948       printf("::: %d,%d: %d [%d]\n", x, y, element, FrameCounter);
5949
5950       element = graphic = 0;
5951     }
5952 #endif
5953
5954     if (graphic_info[graphic].anim_global_sync)
5955       GfxFrame[x][y] = FrameCounter;
5956
5957     if (ANIM_MODE(graphic) == ANIM_RANDOM &&
5958         IS_NEXT_FRAME(GfxFrame[x][y], graphic))
5959       ResetRandomAnimationValue(x, y);
5960
5961     SetRandomAnimationValue(x, y);
5962
5963 #if 1
5964     PlaySoundLevelActionIfLoop(x, y, GfxAction[x][y]);
5965 #endif
5966
5967     if (IS_INACTIVE(element))
5968     {
5969       if (IS_ANIMATED(graphic))
5970         DrawLevelGraphicAnimationIfNeeded(x, y, graphic);
5971
5972       continue;
5973     }
5974
5975 #if 1
5976     /* this may take place after moving, so 'element' may have changed */
5977     if (IS_CHANGING(x, y))
5978     {
5979       ChangeElement(x, y, element_info[element].event_page_nr[CE_DELAY]);
5980       element = Feld[x][y];
5981       graphic = el_act_dir2img(element, GfxAction[x][y], MovDir[x][y]);
5982     }
5983 #endif
5984
5985     if (!IS_MOVING(x, y) && (CAN_FALL(element) || CAN_MOVE(element)))
5986     {
5987       StartMoving(x, y);
5988
5989 #if 1
5990       graphic = el_act_dir2img(element, GfxAction[x][y], MovDir[x][y]);
5991 #if 0
5992       if (element == EL_MOLE)
5993         printf("::: %d, %d, %d [%d]\n",
5994                IS_ANIMATED(graphic), IS_MOVING(x, y), Stop[x][y],
5995                GfxAction[x][y]);
5996 #endif
5997 #if 0
5998       if (element == EL_YAMYAM)
5999         printf("::: %d, %d, %d\n",
6000                IS_ANIMATED(graphic), IS_MOVING(x, y), Stop[x][y]);
6001 #endif
6002 #endif
6003
6004       if (IS_ANIMATED(graphic) &&
6005           !IS_MOVING(x, y) &&
6006           !Stop[x][y])
6007       {
6008         DrawLevelGraphicAnimationIfNeeded(x, y, graphic);
6009
6010 #if 0
6011         if (element == EL_MOLE)
6012           printf("::: %d, %d\n", graphic, GfxFrame[x][y]);
6013 #endif
6014       }
6015
6016       if (IS_GEM(element) || element == EL_SP_INFOTRON)
6017         EdelsteinFunkeln(x, y);
6018     }
6019     else if ((element == EL_ACID ||
6020               element == EL_EXIT_OPEN ||
6021               element == EL_SP_EXIT_OPEN ||
6022               element == EL_SP_TERMINAL ||
6023               element == EL_SP_TERMINAL_ACTIVE ||
6024               element == EL_EXTRA_TIME ||
6025               element == EL_SHIELD_NORMAL ||
6026               element == EL_SHIELD_DEADLY) &&
6027              IS_ANIMATED(graphic))
6028       DrawLevelGraphicAnimationIfNeeded(x, y, graphic);
6029     else if (IS_MOVING(x, y))
6030       ContinueMoving(x, y);
6031     else if (IS_ACTIVE_BOMB(element))
6032       CheckDynamite(x, y);
6033 #if 0
6034     else if (element == EL_EXPLOSION && !game.explosions_delayed)
6035       Explode(x, y, ExplodePhase[x][y], EX_NORMAL);
6036 #endif
6037     else if (element == EL_AMOEBA_GROWING)
6038       AmoebeWaechst(x, y);
6039     else if (element == EL_AMOEBA_SHRINKING)
6040       AmoebaDisappearing(x, y);
6041
6042 #if !USE_NEW_AMOEBA_CODE
6043     else if (IS_AMOEBALIVE(element))
6044       AmoebeAbleger(x, y);
6045 #endif
6046
6047     else if (element == EL_GAME_OF_LIFE || element == EL_BIOMAZE)
6048       Life(x, y);
6049     else if (element == EL_EXIT_CLOSED)
6050       CheckExit(x, y);
6051     else if (element == EL_SP_EXIT_CLOSED)
6052       CheckExitSP(x, y);
6053     else if (element == EL_EXPANDABLE_WALL_GROWING)
6054       MauerWaechst(x, y);
6055     else if (element == EL_EXPANDABLE_WALL ||
6056              element == EL_EXPANDABLE_WALL_HORIZONTAL ||
6057              element == EL_EXPANDABLE_WALL_VERTICAL ||
6058              element == EL_EXPANDABLE_WALL_ANY)
6059       MauerAbleger(x, y);
6060     else if (element == EL_FLAMES)
6061       CheckForDragon(x, y);
6062 #if 0
6063     else if (IS_AUTO_CHANGING(element))
6064       ChangeElement(x, y);
6065 #endif
6066     else if (element == EL_EXPLOSION)
6067       ; /* drawing of correct explosion animation is handled separately */
6068     else if (IS_ANIMATED(graphic) && !IS_CHANGING(x, y))
6069       DrawLevelGraphicAnimationIfNeeded(x, y, graphic);
6070
6071 #if 0
6072     /* this may take place after moving, so 'element' may have changed */
6073     if (IS_AUTO_CHANGING(Feld[x][y]))
6074       ChangeElement(x, y);
6075 #endif
6076
6077     if (IS_BELT_ACTIVE(element))
6078       PlaySoundLevelAction(x, y, ACTION_ACTIVE);
6079
6080     if (game.magic_wall_active)
6081     {
6082       int jx = local_player->jx, jy = local_player->jy;
6083
6084       /* play the element sound at the position nearest to the player */
6085       if ((element == EL_MAGIC_WALL_FULL ||
6086            element == EL_MAGIC_WALL_ACTIVE ||
6087            element == EL_MAGIC_WALL_EMPTYING ||
6088            element == EL_BD_MAGIC_WALL_FULL ||
6089            element == EL_BD_MAGIC_WALL_ACTIVE ||
6090            element == EL_BD_MAGIC_WALL_EMPTYING) &&
6091           ABS(x-jx) + ABS(y-jy) < ABS(magic_wall_x-jx) + ABS(magic_wall_y-jy))
6092       {
6093         magic_wall_x = x;
6094         magic_wall_y = y;
6095       }
6096     }
6097   }
6098
6099 #if USE_NEW_AMOEBA_CODE
6100   /* new experimental amoeba growth stuff */
6101 #if 1
6102   if (!(FrameCounter % 8))
6103 #endif
6104   {
6105     static unsigned long random = 1684108901;
6106
6107     for (i = 0; i < level.amoeba_speed * 28 / 8; i++)
6108     {
6109 #if 0
6110       x = (random >> 10) % lev_fieldx;
6111       y = (random >> 20) % lev_fieldy;
6112 #else
6113       x = RND(lev_fieldx);
6114       y = RND(lev_fieldy);
6115 #endif
6116       element = Feld[x][y];
6117
6118       /* !!! extend EL_SAND to anything diggable (but maybe not SP_BASE) !!! */
6119       if (!IS_PLAYER(x,y) &&
6120           (element == EL_EMPTY ||
6121            element == EL_SAND ||
6122            element == EL_QUICKSAND_EMPTY ||
6123            element == EL_ACID_SPLASH_LEFT ||
6124            element == EL_ACID_SPLASH_RIGHT))
6125       {
6126         if ((IN_LEV_FIELD(x, y-1) && Feld[x][y-1] == EL_AMOEBA_WET) ||
6127             (IN_LEV_FIELD(x-1, y) && Feld[x-1][y] == EL_AMOEBA_WET) ||
6128             (IN_LEV_FIELD(x+1, y) && Feld[x+1][y] == EL_AMOEBA_WET) ||
6129             (IN_LEV_FIELD(x, y+1) && Feld[x][y+1] == EL_AMOEBA_WET))
6130           Feld[x][y] = EL_AMOEBA_DROP;
6131       }
6132
6133       random = random * 129 + 1;
6134     }
6135   }
6136 #endif
6137
6138 #if 0
6139   if (game.explosions_delayed)
6140 #endif
6141   {
6142     game.explosions_delayed = FALSE;
6143
6144     for (y=0; y<lev_fieldy; y++) for (x=0; x<lev_fieldx; x++)
6145     {
6146       element = Feld[x][y];
6147
6148       if (ExplodeField[x][y])
6149         Explode(x, y, EX_PHASE_START, ExplodeField[x][y]);
6150       else if (element == EL_EXPLOSION)
6151         Explode(x, y, ExplodePhase[x][y], EX_NORMAL);
6152
6153       ExplodeField[x][y] = EX_NO_EXPLOSION;
6154     }
6155
6156     game.explosions_delayed = TRUE;
6157   }
6158
6159   if (game.magic_wall_active)
6160   {
6161     if (!(game.magic_wall_time_left % 4))
6162     {
6163       int element = Feld[magic_wall_x][magic_wall_y];
6164
6165       if (element == EL_BD_MAGIC_WALL_FULL ||
6166           element == EL_BD_MAGIC_WALL_ACTIVE ||
6167           element == EL_BD_MAGIC_WALL_EMPTYING)
6168         PlaySoundLevel(magic_wall_x, magic_wall_y, SND_BD_MAGIC_WALL_ACTIVE);
6169       else
6170         PlaySoundLevel(magic_wall_x, magic_wall_y, SND_MAGIC_WALL_ACTIVE);
6171     }
6172
6173     if (game.magic_wall_time_left > 0)
6174     {
6175       game.magic_wall_time_left--;
6176       if (!game.magic_wall_time_left)
6177       {
6178         for (y=0; y<lev_fieldy; y++) for (x=0; x<lev_fieldx; x++)
6179         {
6180           element = Feld[x][y];
6181
6182           if (element == EL_MAGIC_WALL_ACTIVE ||
6183               element == EL_MAGIC_WALL_FULL)
6184           {
6185             Feld[x][y] = EL_MAGIC_WALL_DEAD;
6186             DrawLevelField(x, y);
6187           }
6188           else if (element == EL_BD_MAGIC_WALL_ACTIVE ||
6189                    element == EL_BD_MAGIC_WALL_FULL)
6190           {
6191             Feld[x][y] = EL_BD_MAGIC_WALL_DEAD;
6192             DrawLevelField(x, y);
6193           }
6194         }
6195
6196         game.magic_wall_active = FALSE;
6197       }
6198     }
6199   }
6200
6201   if (game.light_time_left > 0)
6202   {
6203     game.light_time_left--;
6204
6205     if (game.light_time_left == 0)
6206       RedrawAllLightSwitchesAndInvisibleElements();
6207   }
6208
6209   if (game.timegate_time_left > 0)
6210   {
6211     game.timegate_time_left--;
6212
6213     if (game.timegate_time_left == 0)
6214       CloseAllOpenTimegates();
6215   }
6216
6217   for (i=0; i<MAX_PLAYERS; i++)
6218   {
6219     struct PlayerInfo *player = &stored_player[i];
6220
6221     if (SHIELD_ON(player))
6222     {
6223       if (player->shield_deadly_time_left)
6224         PlaySoundLevel(player->jx, player->jy, SND_SHIELD_DEADLY_ACTIVE);
6225       else if (player->shield_normal_time_left)
6226         PlaySoundLevel(player->jx, player->jy, SND_SHIELD_NORMAL_ACTIVE);
6227     }
6228   }
6229
6230   if (TimeFrames >= (1000 / GameFrameDelay))
6231   {
6232     TimeFrames = 0;
6233     TimePlayed++;
6234
6235     for (i=0; i<MAX_PLAYERS; i++)
6236     {
6237       struct PlayerInfo *player = &stored_player[i];
6238
6239       if (SHIELD_ON(player))
6240       {
6241         player->shield_normal_time_left--;
6242
6243         if (player->shield_deadly_time_left > 0)
6244           player->shield_deadly_time_left--;
6245       }
6246     }
6247
6248     if (tape.recording || tape.playing)
6249       DrawVideoDisplay(VIDEO_STATE_TIME_ON, TimePlayed);
6250
6251     if (TimeLeft > 0)
6252     {
6253       TimeLeft--;
6254
6255       if (TimeLeft <= 10 && setup.time_limit)
6256         PlaySoundStereo(SND_GAME_RUNNING_OUT_OF_TIME, SOUND_MIDDLE);
6257
6258       DrawText(DX_TIME, DY_TIME, int2str(TimeLeft, 3), FONT_TEXT_2);
6259
6260       if (!TimeLeft && setup.time_limit)
6261         for (i=0; i<MAX_PLAYERS; i++)
6262           KillHero(&stored_player[i]);
6263     }
6264     else if (level.time == 0 && !AllPlayersGone) /* level without time limit */
6265       DrawText(DX_TIME, DY_TIME, int2str(TimePlayed, 3), FONT_TEXT_2);
6266   }
6267
6268   DrawAllPlayers();
6269
6270   if (options.debug)                    /* calculate frames per second */
6271   {
6272     static unsigned long fps_counter = 0;
6273     static int fps_frames = 0;
6274     unsigned long fps_delay_ms = Counter() - fps_counter;
6275
6276     fps_frames++;
6277
6278     if (fps_delay_ms >= 500)    /* calculate fps every 0.5 seconds */
6279     {
6280       global.frames_per_second = 1000 * (float)fps_frames / fps_delay_ms;
6281
6282       fps_frames = 0;
6283       fps_counter = Counter();
6284     }
6285
6286     redraw_mask |= REDRAW_FPS;
6287   }
6288
6289 #if 0
6290   if (stored_player[0].jx != stored_player[0].last_jx ||
6291       stored_player[0].jy != stored_player[0].last_jy)
6292     printf("::: %d, %d, %d, %d, %d\n",
6293            stored_player[0].MovDir,
6294            stored_player[0].MovPos,
6295            stored_player[0].GfxPos,
6296            stored_player[0].Frame,
6297            stored_player[0].StepFrame);
6298 #endif
6299
6300 #if 1
6301   FrameCounter++;
6302   TimeFrames++;
6303
6304   for (i=0; i<MAX_PLAYERS; i++)
6305   {
6306     int move_frames =
6307       MOVE_DELAY_NORMAL_SPEED /  stored_player[i].move_delay_value;
6308
6309     stored_player[i].Frame += move_frames;
6310
6311     if (stored_player[i].MovPos != 0)
6312       stored_player[i].StepFrame += move_frames;
6313   }
6314 #endif
6315
6316 #if 1
6317   if (local_player->show_envelope != 0 && local_player->MovPos == 0)
6318   {
6319     ShowEnvelope(local_player->show_envelope - EL_ENVELOPE_1);
6320
6321     local_player->show_envelope = 0;
6322   }
6323 #endif
6324 }
6325
6326 static boolean AllPlayersInSight(struct PlayerInfo *player, int x, int y)
6327 {
6328   int min_x = x, min_y = y, max_x = x, max_y = y;
6329   int i;
6330
6331   for (i=0; i<MAX_PLAYERS; i++)
6332   {
6333     int jx = stored_player[i].jx, jy = stored_player[i].jy;
6334
6335     if (!stored_player[i].active || &stored_player[i] == player)
6336       continue;
6337
6338     min_x = MIN(min_x, jx);
6339     min_y = MIN(min_y, jy);
6340     max_x = MAX(max_x, jx);
6341     max_y = MAX(max_y, jy);
6342   }
6343
6344   return (max_x - min_x < SCR_FIELDX && max_y - min_y < SCR_FIELDY);
6345 }
6346
6347 static boolean AllPlayersInVisibleScreen()
6348 {
6349   int i;
6350
6351   for (i=0; i<MAX_PLAYERS; i++)
6352   {
6353     int jx = stored_player[i].jx, jy = stored_player[i].jy;
6354
6355     if (!stored_player[i].active)
6356       continue;
6357
6358     if (!IN_VIS_FIELD(SCREENX(jx), SCREENY(jy)))
6359       return FALSE;
6360   }
6361
6362   return TRUE;
6363 }
6364
6365 void ScrollLevel(int dx, int dy)
6366 {
6367   int softscroll_offset = (setup.soft_scrolling ? TILEX : 0);
6368   int x, y;
6369
6370   BlitBitmap(drawto_field, drawto_field,
6371              FX + TILEX * (dx == -1) - softscroll_offset,
6372              FY + TILEY * (dy == -1) - softscroll_offset,
6373              SXSIZE - TILEX * (dx!=0) + 2 * softscroll_offset,
6374              SYSIZE - TILEY * (dy!=0) + 2 * softscroll_offset,
6375              FX + TILEX * (dx == 1) - softscroll_offset,
6376              FY + TILEY * (dy == 1) - softscroll_offset);
6377
6378   if (dx)
6379   {
6380     x = (dx == 1 ? BX1 : BX2);
6381     for (y=BY1; y <= BY2; y++)
6382       DrawScreenField(x, y);
6383   }
6384
6385   if (dy)
6386   {
6387     y = (dy == 1 ? BY1 : BY2);
6388     for (x=BX1; x <= BX2; x++)
6389       DrawScreenField(x, y);
6390   }
6391
6392   redraw_mask |= REDRAW_FIELD;
6393 }
6394
6395 static void CheckGravityMovement(struct PlayerInfo *player)
6396 {
6397   if (level.gravity && !player->programmed_action)
6398   {
6399     int move_dir_vertical = player->action & (MV_UP | MV_DOWN);
6400     int move_dir_horizontal = player->action & (MV_LEFT | MV_RIGHT);
6401     int move_dir =
6402       (player->last_move_dir & (MV_LEFT | MV_RIGHT) ?
6403        (move_dir_vertical ? move_dir_vertical : move_dir_horizontal) :
6404        (move_dir_horizontal ? move_dir_horizontal : move_dir_vertical));
6405     int jx = player->jx, jy = player->jy;
6406     int dx = (move_dir & MV_LEFT ? -1 : move_dir & MV_RIGHT ? +1 : 0);
6407     int dy = (move_dir & MV_UP ? -1 : move_dir & MV_DOWN ? +1 : 0);
6408     int new_jx = jx + dx, new_jy = jy + dy;
6409     boolean field_under_player_is_free =
6410       (IN_LEV_FIELD(jx, jy + 1) && IS_FREE(jx, jy + 1));
6411     boolean player_is_moving_to_valid_field =
6412       (IN_LEV_FIELD(new_jx, new_jy) &&
6413        (Feld[new_jx][new_jy] == EL_SP_BASE ||
6414         Feld[new_jx][new_jy] == EL_SAND));
6415     /* !!! extend EL_SAND to anything diggable !!! */
6416
6417     if (field_under_player_is_free &&
6418         !player_is_moving_to_valid_field &&
6419         !IS_WALKABLE_INSIDE(Feld[jx][jy]))
6420       player->programmed_action = MV_DOWN;
6421   }
6422 }
6423
6424 /*
6425   MoveFigureOneStep()
6426   -----------------------------------------------------------------------------
6427   dx, dy:               direction (non-diagonal) to try to move the player to
6428   real_dx, real_dy:     direction as read from input device (can be diagonal)
6429 */
6430
6431 boolean MoveFigureOneStep(struct PlayerInfo *player,
6432                           int dx, int dy, int real_dx, int real_dy)
6433 {
6434   static int change_sides[4][2] =
6435   {
6436     /* enter side        leave side */
6437     { CH_SIDE_RIGHT,    CH_SIDE_LEFT    },      /* moving left  */
6438     { CH_SIDE_LEFT,     CH_SIDE_RIGHT   },      /* moving right */
6439     { CH_SIDE_BOTTOM,   CH_SIDE_TOP     },      /* moving up    */
6440     { CH_SIDE_TOP,      CH_SIDE_BOTTOM  }       /* moving down  */
6441   };
6442   int move_direction = (dx == -1 ? MV_LEFT :
6443                         dx == +1 ? MV_RIGHT :
6444                         dy == -1 ? MV_UP :
6445                         dy == +1 ? MV_DOWN : MV_NO_MOVING);
6446   int enter_side = change_sides[MV_DIR_BIT(move_direction)][0];
6447   int leave_side = change_sides[MV_DIR_BIT(move_direction)][1];
6448   int jx = player->jx, jy = player->jy;
6449   int new_jx = jx + dx, new_jy = jy + dy;
6450   int element;
6451   int can_move;
6452
6453   if (!player->active || (!dx && !dy))
6454     return MF_NO_ACTION;
6455
6456   player->MovDir = (dx < 0 ? MV_LEFT :
6457                     dx > 0 ? MV_RIGHT :
6458                     dy < 0 ? MV_UP :
6459                     dy > 0 ? MV_DOWN :  MV_NO_MOVING);
6460
6461   if (!IN_LEV_FIELD(new_jx, new_jy))
6462     return MF_NO_ACTION;
6463
6464   if (!options.network && !AllPlayersInSight(player, new_jx, new_jy))
6465     return MF_NO_ACTION;
6466
6467 #if 0
6468   element = MovingOrBlocked2Element(new_jx, new_jy);
6469 #else
6470   element = MovingOrBlocked2ElementIfNotLeaving(new_jx, new_jy);
6471 #endif
6472
6473   if (DONT_RUN_INTO(element))
6474   {
6475     if (element == EL_ACID && dx == 0 && dy == 1)
6476     {
6477       SplashAcid(jx, jy);
6478       Feld[jx][jy] = EL_PLAYER_1;
6479       InitMovingField(jx, jy, MV_DOWN);
6480       Store[jx][jy] = EL_ACID;
6481       ContinueMoving(jx, jy);
6482       BuryHero(player);
6483     }
6484     else
6485       TestIfHeroRunsIntoBadThing(jx, jy, player->MovDir);
6486
6487     return MF_MOVING;
6488   }
6489
6490   can_move = DigField(player, new_jx, new_jy, real_dx, real_dy, DF_DIG);
6491   if (can_move != MF_MOVING)
6492     return can_move;
6493
6494   /* check if DigField() has caused relocation of the player */
6495   if (player->jx != jx || player->jy != jy)
6496     return MF_NO_ACTION;
6497
6498   StorePlayer[jx][jy] = 0;
6499   player->last_jx = jx;
6500   player->last_jy = jy;
6501   player->jx = new_jx;
6502   player->jy = new_jy;
6503   StorePlayer[new_jx][new_jy] = player->element_nr;
6504
6505   player->MovPos =
6506     (dx > 0 || dy > 0 ? -1 : 1) * (TILEX - TILEX / player->move_delay_value);
6507
6508   ScrollFigure(player, SCROLL_INIT);
6509
6510 #if 1
6511   if (IS_CUSTOM_ELEMENT(Feld[jx][jy]))
6512   {
6513     CheckTriggeredElementSideChange(jx, jy, Feld[jx][jy], leave_side,
6514                                     CE_OTHER_GETS_LEFT);
6515     CheckElementSideChange(jx, jy, Feld[jx][jy], leave_side,
6516                            CE_LEFT_BY_PLAYER, -1);
6517   }
6518
6519   if (IS_CUSTOM_ELEMENT(Feld[new_jx][new_jy]))
6520   {
6521     CheckTriggeredElementSideChange(new_jx, new_jy, Feld[new_jx][new_jy],
6522                                     enter_side, CE_OTHER_GETS_ENTERED);
6523     CheckElementSideChange(new_jx, new_jy, Feld[new_jx][new_jy], enter_side,
6524                            CE_ENTERED_BY_PLAYER, -1);
6525   }
6526 #endif
6527
6528   return MF_MOVING;
6529 }
6530
6531 boolean MoveFigure(struct PlayerInfo *player, int dx, int dy)
6532 {
6533   int jx = player->jx, jy = player->jy;
6534   int old_jx = jx, old_jy = jy;
6535   int moved = MF_NO_ACTION;
6536
6537   if (!player->active || (!dx && !dy))
6538     return FALSE;
6539
6540 #if 0
6541   if (!FrameReached(&player->move_delay, player->move_delay_value) &&
6542       !tape.playing)
6543     return FALSE;
6544 #else
6545   if (!FrameReached(&player->move_delay, player->move_delay_value) &&
6546       !(tape.playing && tape.file_version < FILE_VERSION_2_0))
6547     return FALSE;
6548 #endif
6549
6550   /* remove the last programmed player action */
6551   player->programmed_action = 0;
6552
6553   if (player->MovPos)
6554   {
6555     /* should only happen if pre-1.2 tape recordings are played */
6556     /* this is only for backward compatibility */
6557
6558     int original_move_delay_value = player->move_delay_value;
6559
6560 #if DEBUG
6561     printf("THIS SHOULD ONLY HAPPEN WITH PRE-1.2 LEVEL TAPES. [%ld]\n",
6562            tape.counter);
6563 #endif
6564
6565     /* scroll remaining steps with finest movement resolution */
6566     player->move_delay_value = MOVE_DELAY_NORMAL_SPEED;
6567
6568     while (player->MovPos)
6569     {
6570       ScrollFigure(player, SCROLL_GO_ON);
6571       ScrollScreen(NULL, SCROLL_GO_ON);
6572       FrameCounter++;
6573       DrawAllPlayers();
6574       BackToFront();
6575     }
6576
6577     player->move_delay_value = original_move_delay_value;
6578   }
6579
6580   if (player->last_move_dir & (MV_LEFT | MV_RIGHT))
6581   {
6582     if (!(moved |= MoveFigureOneStep(player, 0, dy, dx, dy)))
6583       moved |= MoveFigureOneStep(player, dx, 0, dx, dy);
6584   }
6585   else
6586   {
6587     if (!(moved |= MoveFigureOneStep(player, dx, 0, dx, dy)))
6588       moved |= MoveFigureOneStep(player, 0, dy, dx, dy);
6589   }
6590
6591   jx = player->jx;
6592   jy = player->jy;
6593
6594   if (moved & MF_MOVING && !ScreenMovPos &&
6595       (player == local_player || !options.network))
6596   {
6597     int old_scroll_x = scroll_x, old_scroll_y = scroll_y;
6598     int offset = (setup.scroll_delay ? 3 : 0);
6599
6600     if (!IN_VIS_FIELD(SCREENX(jx), SCREENY(jy)))
6601     {
6602       /* actual player has left the screen -- scroll in that direction */
6603       if (jx != old_jx)         /* player has moved horizontally */
6604         scroll_x += (jx - old_jx);
6605       else                      /* player has moved vertically */
6606         scroll_y += (jy - old_jy);
6607     }
6608     else
6609     {
6610       if (jx != old_jx)         /* player has moved horizontally */
6611       {
6612         if ((player->MovDir == MV_LEFT && scroll_x > jx - MIDPOSX + offset) ||
6613             (player->MovDir == MV_RIGHT && scroll_x < jx - MIDPOSX - offset))
6614           scroll_x = jx-MIDPOSX + (scroll_x < jx-MIDPOSX ? -offset : +offset);
6615
6616         /* don't scroll over playfield boundaries */
6617         if (scroll_x < SBX_Left || scroll_x > SBX_Right)
6618           scroll_x = (scroll_x < SBX_Left ? SBX_Left : SBX_Right);
6619
6620         /* don't scroll more than one field at a time */
6621         scroll_x = old_scroll_x + SIGN(scroll_x - old_scroll_x);
6622
6623         /* don't scroll against the player's moving direction */
6624         if ((player->MovDir == MV_LEFT && scroll_x > old_scroll_x) ||
6625             (player->MovDir == MV_RIGHT && scroll_x < old_scroll_x))
6626           scroll_x = old_scroll_x;
6627       }
6628       else                      /* player has moved vertically */
6629       {
6630         if ((player->MovDir == MV_UP && scroll_y > jy - MIDPOSY + offset) ||
6631             (player->MovDir == MV_DOWN && scroll_y < jy - MIDPOSY - offset))
6632           scroll_y = jy-MIDPOSY + (scroll_y < jy-MIDPOSY ? -offset : +offset);
6633
6634         /* don't scroll over playfield boundaries */
6635         if (scroll_y < SBY_Upper || scroll_y > SBY_Lower)
6636           scroll_y = (scroll_y < SBY_Upper ? SBY_Upper : SBY_Lower);
6637
6638         /* don't scroll more than one field at a time */
6639         scroll_y = old_scroll_y + SIGN(scroll_y - old_scroll_y);
6640
6641         /* don't scroll against the player's moving direction */
6642         if ((player->MovDir == MV_UP && scroll_y > old_scroll_y) ||
6643             (player->MovDir == MV_DOWN && scroll_y < old_scroll_y))
6644           scroll_y = old_scroll_y;
6645       }
6646     }
6647
6648     if (scroll_x != old_scroll_x || scroll_y != old_scroll_y)
6649     {
6650       if (!options.network && !AllPlayersInVisibleScreen())
6651       {
6652         scroll_x = old_scroll_x;
6653         scroll_y = old_scroll_y;
6654       }
6655       else
6656       {
6657         ScrollScreen(player, SCROLL_INIT);
6658         ScrollLevel(old_scroll_x - scroll_x, old_scroll_y - scroll_y);
6659       }
6660     }
6661   }
6662
6663 #if 0
6664 #if 1
6665   InitPlayerGfxAnimation(player, ACTION_DEFAULT);
6666 #else
6667   if (!(moved & MF_MOVING) && !player->Pushing)
6668     player->Frame = 0;
6669 #endif
6670 #endif
6671
6672   player->StepFrame = 0;
6673
6674   if (moved & MF_MOVING)
6675   {
6676     if (old_jx != jx && old_jy == jy)
6677       player->MovDir = (old_jx < jx ? MV_RIGHT : MV_LEFT);
6678     else if (old_jx == jx && old_jy != jy)
6679       player->MovDir = (old_jy < jy ? MV_DOWN : MV_UP);
6680
6681     DrawLevelField(jx, jy);     /* for "crumbled sand" */
6682
6683     player->last_move_dir = player->MovDir;
6684     player->is_moving = TRUE;
6685 #if 1
6686     player->snapped = FALSE;
6687 #endif
6688   }
6689   else
6690   {
6691     CheckGravityMovement(player);
6692
6693     /*
6694     player->last_move_dir = MV_NO_MOVING;
6695     */
6696     player->is_moving = FALSE;
6697   }
6698
6699   TestIfHeroTouchesBadThing(jx, jy);
6700   TestIfPlayerTouchesCustomElement(jx, jy);
6701
6702   if (!player->active)
6703     RemoveHero(player);
6704
6705   return moved;
6706 }
6707
6708 void ScrollFigure(struct PlayerInfo *player, int mode)
6709 {
6710   int jx = player->jx, jy = player->jy;
6711   int last_jx = player->last_jx, last_jy = player->last_jy;
6712   int move_stepsize = TILEX / player->move_delay_value;
6713
6714   if (!player->active || !player->MovPos)
6715     return;
6716
6717   if (mode == SCROLL_INIT)
6718   {
6719     player->actual_frame_counter = FrameCounter;
6720     player->GfxPos = move_stepsize * (player->MovPos / move_stepsize);
6721
6722     if (Feld[last_jx][last_jy] == EL_EMPTY)
6723       Feld[last_jx][last_jy] = EL_PLAYER_IS_LEAVING;
6724
6725 #if 0
6726     DrawPlayer(player);
6727 #endif
6728     return;
6729   }
6730   else if (!FrameReached(&player->actual_frame_counter, 1))
6731     return;
6732
6733   player->MovPos += (player->MovPos > 0 ? -1 : 1) * move_stepsize;
6734   player->GfxPos = move_stepsize * (player->MovPos / move_stepsize);
6735
6736   if (Feld[last_jx][last_jy] == EL_PLAYER_IS_LEAVING)
6737     Feld[last_jx][last_jy] = EL_EMPTY;
6738
6739   /* before DrawPlayer() to draw correct player graphic for this case */
6740   if (player->MovPos == 0)
6741     CheckGravityMovement(player);
6742
6743 #if 0
6744   DrawPlayer(player);   /* needed here only to cleanup last field */
6745 #endif
6746
6747   if (player->MovPos == 0)      /* player reached destination field */
6748   {
6749     if (IS_PASSABLE(Feld[last_jx][last_jy]))
6750     {
6751       /* continue with normal speed after quickly moving through gate */
6752       HALVE_PLAYER_SPEED(player);
6753
6754       /* be able to make the next move without delay */
6755       player->move_delay = 0;
6756     }
6757
6758     player->last_jx = jx;
6759     player->last_jy = jy;
6760
6761     if (Feld[jx][jy] == EL_EXIT_OPEN ||
6762         Feld[jx][jy] == EL_SP_EXIT_OPEN)
6763     {
6764       DrawPlayer(player);       /* needed here only to cleanup last field */
6765       RemoveHero(player);
6766
6767       if (local_player->friends_still_needed == 0 ||
6768           Feld[jx][jy] == EL_SP_EXIT_OPEN)
6769         player->LevelSolved = player->GameOver = TRUE;
6770     }
6771
6772     if (tape.single_step && tape.recording && !tape.pausing &&
6773         !player->programmed_action)
6774       TapeTogglePause(TAPE_TOGGLE_AUTOMATIC);
6775   }
6776 }
6777
6778 void ScrollScreen(struct PlayerInfo *player, int mode)
6779 {
6780   static unsigned long screen_frame_counter = 0;
6781
6782   if (mode == SCROLL_INIT)
6783   {
6784     /* set scrolling step size according to actual player's moving speed */
6785     ScrollStepSize = TILEX / player->move_delay_value;
6786
6787     screen_frame_counter = FrameCounter;
6788     ScreenMovDir = player->MovDir;
6789     ScreenMovPos = player->MovPos;
6790     ScreenGfxPos = ScrollStepSize * (ScreenMovPos / ScrollStepSize);
6791     return;
6792   }
6793   else if (!FrameReached(&screen_frame_counter, 1))
6794     return;
6795
6796   if (ScreenMovPos)
6797   {
6798     ScreenMovPos += (ScreenMovPos > 0 ? -1 : 1) * ScrollStepSize;
6799     ScreenGfxPos = ScrollStepSize * (ScreenMovPos / ScrollStepSize);
6800     redraw_mask |= REDRAW_FIELD;
6801   }
6802   else
6803     ScreenMovDir = MV_NO_MOVING;
6804 }
6805
6806 void TestIfPlayerTouchesCustomElement(int x, int y)
6807 {
6808 #if 0
6809   static boolean check_changing = FALSE;
6810 #endif
6811   static int xy[4][2] =
6812   {
6813     { 0, -1 },
6814     { -1, 0 },
6815     { +1, 0 },
6816     { 0, +1 }
6817   };
6818   int i;
6819
6820 #if 0
6821   if (check_changing)   /* prevent this function from running into a loop */
6822     return;
6823
6824   check_changing = TRUE;
6825 #endif
6826
6827   for (i=0; i<4; i++)
6828   {
6829     int xx = x + xy[i][0];
6830     int yy = y + xy[i][1];
6831
6832     if (!IN_LEV_FIELD(xx, yy))
6833       continue;
6834
6835     if (IS_PLAYER(x, y))
6836     {
6837       CheckTriggeredElementChange(xx, yy, Feld[xx][yy], CE_OTHER_GETS_TOUCHED);
6838       CheckElementChange(xx, yy, Feld[xx][yy], CE_TOUCHED_BY_PLAYER);
6839     }
6840     else if (IS_PLAYER(xx, yy))
6841     {
6842       CheckTriggeredElementChange(x, y, Feld[x][y], CE_OTHER_GETS_TOUCHED);
6843       CheckElementChange(x, y, Feld[x][y], CE_TOUCHED_BY_PLAYER);
6844
6845       break;
6846     }
6847   }
6848
6849 #if 0
6850   check_changing = FALSE;
6851 #endif
6852 }
6853
6854 void TestIfElementTouchesCustomElement(int x, int y)
6855 {
6856 #if 0
6857   static boolean check_changing = FALSE;
6858 #endif
6859   static int xy[4][2] =
6860   {
6861     { 0, -1 },
6862     { -1, 0 },
6863     { +1, 0 },
6864     { 0, +1 }
6865   };
6866   static int change_sides[4][2] =
6867   {
6868     /* center side       border side */
6869     { CH_SIDE_TOP,      CH_SIDE_BOTTOM  },      /* check top    */
6870     { CH_SIDE_LEFT,     CH_SIDE_RIGHT   },      /* check left   */
6871     { CH_SIDE_RIGHT,    CH_SIDE_LEFT    },      /* check right  */
6872     { CH_SIDE_BOTTOM,   CH_SIDE_TOP     }       /* check bottom */
6873   };
6874   boolean change_center_element = FALSE;
6875   int center_element_change_page = 0;
6876   int center_element = Feld[x][y];
6877   int i, j;
6878
6879 #if 0
6880   if (check_changing)   /* prevent this function from running into a loop */
6881     return;
6882
6883   check_changing = TRUE;
6884 #endif
6885
6886   for (i=0; i<4; i++)
6887   {
6888     int xx = x + xy[i][0];
6889     int yy = y + xy[i][1];
6890     int center_side = change_sides[i][0];
6891     int border_side = change_sides[i][1];
6892     int border_element;
6893
6894     if (!IN_LEV_FIELD(xx, yy))
6895       continue;
6896
6897     border_element = Feld[xx][yy];
6898
6899     /* check for change of center element (but change it only once) */
6900     if (IS_CUSTOM_ELEMENT(center_element) &&
6901         HAS_ANY_CHANGE_EVENT(center_element, CE_OTHER_IS_TOUCHING) &&
6902         !change_center_element)
6903     {
6904       for (j=0; j < element_info[center_element].num_change_pages; j++)
6905       {
6906         struct ElementChangeInfo *change =
6907           &element_info[center_element].change_page[j];
6908
6909         if (change->events & CH_EVENT_BIT(CE_OTHER_IS_TOUCHING) &&
6910             change->sides & border_side &&
6911             change->trigger_element == border_element)
6912         {
6913           change_center_element = TRUE;
6914           center_element_change_page = j;
6915
6916           break;
6917         }
6918       }
6919     }
6920
6921     /* check for change of border element */
6922     if (IS_CUSTOM_ELEMENT(border_element) &&
6923         HAS_ANY_CHANGE_EVENT(border_element, CE_OTHER_IS_TOUCHING))
6924     {
6925       for (j=0; j < element_info[border_element].num_change_pages; j++)
6926       {
6927         struct ElementChangeInfo *change =
6928           &element_info[border_element].change_page[j];
6929
6930         if (change->events & CH_EVENT_BIT(CE_OTHER_IS_TOUCHING) &&
6931             change->sides & center_side &&
6932             change->trigger_element == center_element)
6933         {
6934           CheckElementSideChange(xx, yy, border_element, CH_SIDE_ANY,
6935                                  CE_OTHER_IS_TOUCHING, j);
6936           break;
6937         }
6938       }
6939     }
6940   }
6941
6942   if (change_center_element)
6943     CheckElementSideChange(x, y, center_element, CH_SIDE_ANY,
6944                            CE_OTHER_IS_TOUCHING, center_element_change_page);
6945
6946 #if 0
6947   check_changing = FALSE;
6948 #endif
6949 }
6950
6951 void TestIfGoodThingHitsBadThing(int good_x, int good_y, int good_move_dir)
6952 {
6953   int i, kill_x = -1, kill_y = -1;
6954   static int test_xy[4][2] =
6955   {
6956     { 0, -1 },
6957     { -1, 0 },
6958     { +1, 0 },
6959     { 0, +1 }
6960   };
6961   static int test_dir[4] =
6962   {
6963     MV_UP,
6964     MV_LEFT,
6965     MV_RIGHT,
6966     MV_DOWN
6967   };
6968
6969   for (i=0; i<4; i++)
6970   {
6971     int test_x, test_y, test_move_dir, test_element;
6972
6973     test_x = good_x + test_xy[i][0];
6974     test_y = good_y + test_xy[i][1];
6975     if (!IN_LEV_FIELD(test_x, test_y))
6976       continue;
6977
6978     test_move_dir =
6979       (IS_MOVING(test_x, test_y) ? MovDir[test_x][test_y] : MV_NO_MOVING);
6980
6981 #if 0
6982     test_element = Feld[test_x][test_y];
6983 #else
6984     test_element = MovingOrBlocked2ElementIfNotLeaving(test_x, test_y);
6985 #endif
6986
6987     /* 1st case: good thing is moving towards DONT_RUN_INTO style bad thing;
6988        2nd case: DONT_TOUCH style bad thing does not move away from good thing
6989     */
6990     if ((DONT_RUN_INTO(test_element) && good_move_dir == test_dir[i]) ||
6991         (DONT_TOUCH(test_element)    && test_move_dir != test_dir[i]))
6992     {
6993       kill_x = test_x;
6994       kill_y = test_y;
6995       break;
6996     }
6997   }
6998
6999   if (kill_x != -1 || kill_y != -1)
7000   {
7001     if (IS_PLAYER(good_x, good_y))
7002     {
7003       struct PlayerInfo *player = PLAYERINFO(good_x, good_y);
7004
7005       if (player->shield_deadly_time_left > 0)
7006         Bang(kill_x, kill_y);
7007       else if (!PLAYER_PROTECTED(good_x, good_y))
7008         KillHero(player);
7009     }
7010     else
7011       Bang(good_x, good_y);
7012   }
7013 }
7014
7015 void TestIfBadThingHitsGoodThing(int bad_x, int bad_y, int bad_move_dir)
7016 {
7017   int i, kill_x = -1, kill_y = -1;
7018   int bad_element = Feld[bad_x][bad_y];
7019   static int test_xy[4][2] =
7020   {
7021     { 0, -1 },
7022     { -1, 0 },
7023     { +1, 0 },
7024     { 0, +1 }
7025   };
7026   static int test_dir[4] =
7027   {
7028     MV_UP,
7029     MV_LEFT,
7030     MV_RIGHT,
7031     MV_DOWN
7032   };
7033
7034   if (bad_element == EL_EXPLOSION)      /* skip just exploding bad things */
7035     return;
7036
7037   for (i=0; i<4; i++)
7038   {
7039     int test_x, test_y, test_move_dir, test_element;
7040
7041     test_x = bad_x + test_xy[i][0];
7042     test_y = bad_y + test_xy[i][1];
7043     if (!IN_LEV_FIELD(test_x, test_y))
7044       continue;
7045
7046     test_move_dir =
7047       (IS_MOVING(test_x, test_y) ? MovDir[test_x][test_y] : MV_NO_MOVING);
7048
7049     test_element = Feld[test_x][test_y];
7050
7051     /* 1st case: good thing is moving towards DONT_RUN_INTO style bad thing;
7052        2nd case: DONT_TOUCH style bad thing does not move away from good thing
7053     */
7054     if ((DONT_RUN_INTO(bad_element) &&  bad_move_dir == test_dir[i]) ||
7055         (DONT_TOUCH(bad_element)    && test_move_dir != test_dir[i]))
7056     {
7057       /* good thing is player or penguin that does not move away */
7058       if (IS_PLAYER(test_x, test_y))
7059       {
7060         struct PlayerInfo *player = PLAYERINFO(test_x, test_y);
7061
7062         if (bad_element == EL_ROBOT && player->is_moving)
7063           continue;     /* robot does not kill player if he is moving */
7064
7065         kill_x = test_x;
7066         kill_y = test_y;
7067         break;
7068       }
7069       else if (test_element == EL_PENGUIN)
7070       {
7071         kill_x = test_x;
7072         kill_y = test_y;
7073         break;
7074       }
7075     }
7076   }
7077
7078   if (kill_x != -1 || kill_y != -1)
7079   {
7080     if (IS_PLAYER(kill_x, kill_y))
7081     {
7082       struct PlayerInfo *player = PLAYERINFO(kill_x, kill_y);
7083
7084 #if 0
7085       int dir = player->MovDir;
7086       int newx = player->jx + (dir == MV_LEFT ? -1 : dir == MV_RIGHT ? +1 : 0);
7087       int newy = player->jy + (dir == MV_UP   ? -1 : dir == MV_DOWN  ? +1 : 0);
7088
7089       if (Feld[bad_x][bad_y] == EL_ROBOT && player->is_moving &&
7090           newx != bad_x && newy != bad_y)
7091         ;       /* robot does not kill player if he is moving */
7092       else
7093         printf("-> %d\n", player->MovDir);
7094
7095       if (Feld[bad_x][bad_y] == EL_ROBOT && player->is_moving &&
7096           newx != bad_x && newy != bad_y)
7097         ;       /* robot does not kill player if he is moving */
7098       else
7099         ;
7100 #endif
7101
7102       if (player->shield_deadly_time_left > 0)
7103         Bang(bad_x, bad_y);
7104       else if (!PLAYER_PROTECTED(kill_x, kill_y))
7105         KillHero(player);
7106     }
7107     else
7108       Bang(kill_x, kill_y);
7109   }
7110 }
7111
7112 void TestIfHeroTouchesBadThing(int x, int y)
7113 {
7114   TestIfGoodThingHitsBadThing(x, y, MV_NO_MOVING);
7115 }
7116
7117 void TestIfHeroRunsIntoBadThing(int x, int y, int move_dir)
7118 {
7119   TestIfGoodThingHitsBadThing(x, y, move_dir);
7120 }
7121
7122 void TestIfBadThingTouchesHero(int x, int y)
7123 {
7124   TestIfBadThingHitsGoodThing(x, y, MV_NO_MOVING);
7125 }
7126
7127 void TestIfBadThingRunsIntoHero(int x, int y, int move_dir)
7128 {
7129   TestIfBadThingHitsGoodThing(x, y, move_dir);
7130 }
7131
7132 void TestIfFriendTouchesBadThing(int x, int y)
7133 {
7134   TestIfGoodThingHitsBadThing(x, y, MV_NO_MOVING);
7135 }
7136
7137 void TestIfBadThingTouchesFriend(int x, int y)
7138 {
7139   TestIfBadThingHitsGoodThing(x, y, MV_NO_MOVING);
7140 }
7141
7142 void TestIfBadThingTouchesOtherBadThing(int bad_x, int bad_y)
7143 {
7144   int i, kill_x = bad_x, kill_y = bad_y;
7145   static int xy[4][2] =
7146   {
7147     { 0, -1 },
7148     { -1, 0 },
7149     { +1, 0 },
7150     { 0, +1 }
7151   };
7152
7153   for (i=0; i<4; i++)
7154   {
7155     int x, y, element;
7156
7157     x = bad_x + xy[i][0];
7158     y = bad_y + xy[i][1];
7159     if (!IN_LEV_FIELD(x, y))
7160       continue;
7161
7162     element = Feld[x][y];
7163     if (IS_AMOEBOID(element) || element == EL_GAME_OF_LIFE ||
7164         element == EL_AMOEBA_GROWING || element == EL_AMOEBA_DROP)
7165     {
7166       kill_x = x;
7167       kill_y = y;
7168       break;
7169     }
7170   }
7171
7172   if (kill_x != bad_x || kill_y != bad_y)
7173     Bang(bad_x, bad_y);
7174 }
7175
7176 void KillHero(struct PlayerInfo *player)
7177 {
7178   int jx = player->jx, jy = player->jy;
7179
7180   if (!player->active)
7181     return;
7182
7183   /* remove accessible field at the player's position */
7184   Feld[jx][jy] = EL_EMPTY;
7185
7186   /* deactivate shield (else Bang()/Explode() would not work right) */
7187   player->shield_normal_time_left = 0;
7188   player->shield_deadly_time_left = 0;
7189
7190   Bang(jx, jy);
7191   BuryHero(player);
7192 }
7193
7194 static void KillHeroUnlessProtected(int x, int y)
7195 {
7196   if (!PLAYER_PROTECTED(x, y))
7197     KillHero(PLAYERINFO(x, y));
7198 }
7199
7200 void BuryHero(struct PlayerInfo *player)
7201 {
7202   int jx = player->jx, jy = player->jy;
7203
7204   if (!player->active)
7205     return;
7206
7207 #if 1
7208   PlaySoundLevelElementAction(jx, jy, player->element_nr, ACTION_DYING);
7209 #else
7210   PlaySoundLevel(jx, jy, SND_CLASS_PLAYER_DYING);
7211 #endif
7212   PlaySoundLevel(jx, jy, SND_GAME_LOSING);
7213
7214   player->GameOver = TRUE;
7215   RemoveHero(player);
7216 }
7217
7218 void RemoveHero(struct PlayerInfo *player)
7219 {
7220   int jx = player->jx, jy = player->jy;
7221   int i, found = FALSE;
7222
7223   player->present = FALSE;
7224   player->active = FALSE;
7225
7226   if (!ExplodeField[jx][jy])
7227     StorePlayer[jx][jy] = 0;
7228
7229   for (i=0; i<MAX_PLAYERS; i++)
7230     if (stored_player[i].active)
7231       found = TRUE;
7232
7233   if (!found)
7234     AllPlayersGone = TRUE;
7235
7236   ExitX = ZX = jx;
7237   ExitY = ZY = jy;
7238 }
7239
7240 /*
7241   =============================================================================
7242   checkDiagonalPushing()
7243   -----------------------------------------------------------------------------
7244   check if diagonal input device direction results in pushing of object
7245   (by checking if the alternative direction is walkable, diggable, ...)
7246   =============================================================================
7247 */
7248
7249 static boolean checkDiagonalPushing(struct PlayerInfo *player,
7250                                     int x, int y, int real_dx, int real_dy)
7251 {
7252   int jx, jy, dx, dy, xx, yy;
7253
7254   if (real_dx == 0 || real_dy == 0)     /* no diagonal direction => push */
7255     return TRUE;
7256
7257   /* diagonal direction: check alternative direction */
7258   jx = player->jx;
7259   jy = player->jy;
7260   dx = x - jx;
7261   dy = y - jy;
7262   xx = jx + (dx == 0 ? real_dx : 0);
7263   yy = jy + (dy == 0 ? real_dy : 0);
7264
7265   return (!IN_LEV_FIELD(xx, yy) || IS_SOLID_FOR_PUSHING(Feld[xx][yy]));
7266 }
7267
7268 /*
7269   =============================================================================
7270   DigField()
7271   -----------------------------------------------------------------------------
7272   x, y:                 field next to player (non-diagonal) to try to dig to
7273   real_dx, real_dy:     direction as read from input device (can be diagonal)
7274   =============================================================================
7275 */
7276
7277 int DigField(struct PlayerInfo *player,
7278              int x, int y, int real_dx, int real_dy, int mode)
7279 {
7280 #if 0
7281   static int change_sides[4][2] =
7282   {
7283     /* enter side        leave side */
7284     { CH_SIDE_RIGHT,    CH_SIDE_LEFT    },      /* moving left  */
7285     { CH_SIDE_LEFT,     CH_SIDE_RIGHT   },      /* moving right */
7286     { CH_SIDE_BOTTOM,   CH_SIDE_TOP     },      /* moving up    */
7287     { CH_SIDE_TOP,      CH_SIDE_BOTTOM  }       /* moving down  */
7288   };
7289 #endif
7290   boolean use_spring_bug = (game.engine_version < VERSION_IDENT(2,2,0));
7291   int jx = player->jx, jy = player->jy;
7292   int dx = x - jx, dy = y - jy;
7293   int nextx = x + dx, nexty = y + dy;
7294   int move_direction = (dx == -1 ? MV_LEFT :
7295                         dx == +1 ? MV_RIGHT :
7296                         dy == -1 ? MV_UP :
7297                         dy == +1 ? MV_DOWN : MV_NO_MOVING);
7298 #if 0
7299   int enter_side = change_sides[MV_DIR_BIT(move_direction)][0];
7300   int leave_side = change_sides[MV_DIR_BIT(move_direction)][1];
7301 #endif
7302   int element;
7303
7304   if (player->MovPos == 0)
7305   {
7306     player->is_digging = FALSE;
7307     player->is_collecting = FALSE;
7308   }
7309
7310   if (player->MovPos == 0)      /* last pushing move finished */
7311     player->Pushing = FALSE;
7312
7313   if (mode == DF_NO_PUSH)       /* player just stopped pushing */
7314   {
7315     player->Switching = FALSE;
7316     player->push_delay = 0;
7317
7318     return MF_NO_ACTION;
7319   }
7320
7321   if (IS_MOVING(x, y) || IS_PLAYER(x, y))
7322     return MF_NO_ACTION;
7323
7324 #if 0
7325   if (IS_TUBE(Feld[jx][jy]) || IS_TUBE(Back[jx][jy]))
7326 #else
7327   if (IS_TUBE(Feld[jx][jy]) ||
7328       (IS_TUBE(Back[jx][jy]) && game.engine_version >= VERSION_IDENT(2,2,0)))
7329 #endif
7330   {
7331     int i = 0;
7332     int tube_element = (IS_TUBE(Feld[jx][jy]) ? Feld[jx][jy] : Back[jx][jy]);
7333     int tube_leave_directions[][2] =
7334     {
7335       { EL_TUBE_ANY,                    MV_LEFT | MV_RIGHT | MV_UP | MV_DOWN },
7336       { EL_TUBE_VERTICAL,                                    MV_UP | MV_DOWN },
7337       { EL_TUBE_HORIZONTAL,             MV_LEFT | MV_RIGHT                   },
7338       { EL_TUBE_VERTICAL_LEFT,          MV_LEFT |            MV_UP | MV_DOWN },
7339       { EL_TUBE_VERTICAL_RIGHT,                   MV_RIGHT | MV_UP | MV_DOWN },
7340       { EL_TUBE_HORIZONTAL_UP,          MV_LEFT | MV_RIGHT | MV_UP           },
7341       { EL_TUBE_HORIZONTAL_DOWN,        MV_LEFT | MV_RIGHT |         MV_DOWN },
7342       { EL_TUBE_LEFT_UP,                MV_LEFT |            MV_UP           },
7343       { EL_TUBE_LEFT_DOWN,              MV_LEFT |                    MV_DOWN },
7344       { EL_TUBE_RIGHT_UP,                         MV_RIGHT | MV_UP           },
7345       { EL_TUBE_RIGHT_DOWN,                       MV_RIGHT |         MV_DOWN },
7346       { -1,                             MV_LEFT | MV_RIGHT | MV_UP | MV_DOWN }
7347     };
7348
7349     while (tube_leave_directions[i][0] != tube_element)
7350     {
7351       i++;
7352       if (tube_leave_directions[i][0] == -1)    /* should not happen */
7353         break;
7354     }
7355
7356     if (!(tube_leave_directions[i][1] & move_direction))
7357       return MF_NO_ACTION;      /* tube has no opening in this direction */
7358   }
7359
7360   element = Feld[x][y];
7361
7362   if (mode == DF_SNAP && !IS_SNAPPABLE(element) &&
7363       game.engine_version >= VERSION_IDENT(2,2,0))
7364     return MF_NO_ACTION;
7365
7366   switch (element)
7367   {
7368     case EL_ROBOT_WHEEL:
7369       Feld[x][y] = EL_ROBOT_WHEEL_ACTIVE;
7370       ZX = x;
7371       ZY = y;
7372       DrawLevelField(x, y);
7373       PlaySoundLevel(x, y, SND_ROBOT_WHEEL_ACTIVATING);
7374       return MF_ACTION;
7375       break;
7376
7377     case EL_SP_TERMINAL:
7378       {
7379         int xx, yy;
7380
7381         PlaySoundLevel(x, y, SND_SP_TERMINAL_ACTIVATING);
7382
7383         for (yy=0; yy<lev_fieldy; yy++)
7384         {
7385           for (xx=0; xx<lev_fieldx; xx++)
7386           {
7387             if (Feld[xx][yy] == EL_SP_DISK_YELLOW)
7388               Bang(xx, yy);
7389             else if (Feld[xx][yy] == EL_SP_TERMINAL)
7390               Feld[xx][yy] = EL_SP_TERMINAL_ACTIVE;
7391           }
7392         }
7393
7394         return MF_ACTION;
7395       }
7396       break;
7397
7398     case EL_CONVEYOR_BELT_1_SWITCH_LEFT:
7399     case EL_CONVEYOR_BELT_1_SWITCH_MIDDLE:
7400     case EL_CONVEYOR_BELT_1_SWITCH_RIGHT:
7401     case EL_CONVEYOR_BELT_2_SWITCH_LEFT:
7402     case EL_CONVEYOR_BELT_2_SWITCH_MIDDLE:
7403     case EL_CONVEYOR_BELT_2_SWITCH_RIGHT:
7404     case EL_CONVEYOR_BELT_3_SWITCH_LEFT:
7405     case EL_CONVEYOR_BELT_3_SWITCH_MIDDLE:
7406     case EL_CONVEYOR_BELT_3_SWITCH_RIGHT:
7407     case EL_CONVEYOR_BELT_4_SWITCH_LEFT:
7408     case EL_CONVEYOR_BELT_4_SWITCH_MIDDLE:
7409     case EL_CONVEYOR_BELT_4_SWITCH_RIGHT:
7410       if (!player->Switching)
7411       {
7412         player->Switching = TRUE;
7413         ToggleBeltSwitch(x, y);
7414         PlaySoundLevel(x, y, SND_CLASS_CONVEYOR_BELT_SWITCH_ACTIVATING);
7415       }
7416       return MF_ACTION;
7417       break;
7418
7419     case EL_SWITCHGATE_SWITCH_UP:
7420     case EL_SWITCHGATE_SWITCH_DOWN:
7421       if (!player->Switching)
7422       {
7423         player->Switching = TRUE;
7424         ToggleSwitchgateSwitch(x, y);
7425         PlaySoundLevel(x, y, SND_CLASS_SWITCHGATE_SWITCH_ACTIVATING);
7426       }
7427       return MF_ACTION;
7428       break;
7429
7430     case EL_LIGHT_SWITCH:
7431     case EL_LIGHT_SWITCH_ACTIVE:
7432       if (!player->Switching)
7433       {
7434         player->Switching = TRUE;
7435         ToggleLightSwitch(x, y);
7436         PlaySoundLevel(x, y, element == EL_LIGHT_SWITCH ?
7437                        SND_LIGHT_SWITCH_ACTIVATING :
7438                        SND_LIGHT_SWITCH_DEACTIVATING);
7439       }
7440       return MF_ACTION;
7441       break;
7442
7443     case EL_TIMEGATE_SWITCH:
7444       ActivateTimegateSwitch(x, y);
7445       PlaySoundLevel(x, y, SND_TIMEGATE_SWITCH_ACTIVATING);
7446
7447       return MF_ACTION;
7448       break;
7449
7450     case EL_BALLOON_SWITCH_LEFT:
7451     case EL_BALLOON_SWITCH_RIGHT:
7452     case EL_BALLOON_SWITCH_UP:
7453     case EL_BALLOON_SWITCH_DOWN:
7454     case EL_BALLOON_SWITCH_ANY:
7455       if (element == EL_BALLOON_SWITCH_ANY)
7456         game.balloon_dir = move_direction;
7457       else
7458         game.balloon_dir = (element == EL_BALLOON_SWITCH_LEFT  ? MV_LEFT :
7459                             element == EL_BALLOON_SWITCH_RIGHT ? MV_RIGHT :
7460                             element == EL_BALLOON_SWITCH_UP    ? MV_UP :
7461                             element == EL_BALLOON_SWITCH_DOWN  ? MV_DOWN :
7462                             MV_NO_MOVING);
7463       PlaySoundLevel(x, y, SND_CLASS_BALLOON_SWITCH_ACTIVATING);
7464
7465       return MF_ACTION;
7466       break;
7467
7468     case EL_SP_PORT_LEFT:
7469     case EL_SP_PORT_RIGHT:
7470     case EL_SP_PORT_UP:
7471     case EL_SP_PORT_DOWN:
7472     case EL_SP_PORT_HORIZONTAL:
7473     case EL_SP_PORT_VERTICAL:
7474     case EL_SP_PORT_ANY:
7475     case EL_SP_GRAVITY_PORT_LEFT:
7476     case EL_SP_GRAVITY_PORT_RIGHT:
7477     case EL_SP_GRAVITY_PORT_UP:
7478     case EL_SP_GRAVITY_PORT_DOWN:
7479       if ((dx == -1 &&
7480            element != EL_SP_PORT_LEFT &&
7481            element != EL_SP_GRAVITY_PORT_LEFT &&
7482            element != EL_SP_PORT_HORIZONTAL &&
7483            element != EL_SP_PORT_ANY) ||
7484           (dx == +1 &&
7485            element != EL_SP_PORT_RIGHT &&
7486            element != EL_SP_GRAVITY_PORT_RIGHT &&
7487            element != EL_SP_PORT_HORIZONTAL &&
7488            element != EL_SP_PORT_ANY) ||
7489           (dy == -1 &&
7490            element != EL_SP_PORT_UP &&
7491            element != EL_SP_GRAVITY_PORT_UP &&
7492            element != EL_SP_PORT_VERTICAL &&
7493            element != EL_SP_PORT_ANY) ||
7494           (dy == +1 &&
7495            element != EL_SP_PORT_DOWN &&
7496            element != EL_SP_GRAVITY_PORT_DOWN &&
7497            element != EL_SP_PORT_VERTICAL &&
7498            element != EL_SP_PORT_ANY) ||
7499           !IN_LEV_FIELD(nextx, nexty) ||
7500           !IS_FREE(nextx, nexty))
7501         return MF_NO_ACTION;
7502
7503       if (element == EL_SP_GRAVITY_PORT_LEFT ||
7504           element == EL_SP_GRAVITY_PORT_RIGHT ||
7505           element == EL_SP_GRAVITY_PORT_UP ||
7506           element == EL_SP_GRAVITY_PORT_DOWN)
7507         level.gravity = !level.gravity;
7508
7509       /* automatically move to the next field with double speed */
7510       player->programmed_action = move_direction;
7511       DOUBLE_PLAYER_SPEED(player);
7512
7513       PlaySoundLevel(x, y, SND_CLASS_SP_PORT_PASSING);
7514       break;
7515
7516     case EL_TUBE_ANY:
7517     case EL_TUBE_VERTICAL:
7518     case EL_TUBE_HORIZONTAL:
7519     case EL_TUBE_VERTICAL_LEFT:
7520     case EL_TUBE_VERTICAL_RIGHT:
7521     case EL_TUBE_HORIZONTAL_UP:
7522     case EL_TUBE_HORIZONTAL_DOWN:
7523     case EL_TUBE_LEFT_UP:
7524     case EL_TUBE_LEFT_DOWN:
7525     case EL_TUBE_RIGHT_UP:
7526     case EL_TUBE_RIGHT_DOWN:
7527       {
7528         int i = 0;
7529         int tube_enter_directions[][2] =
7530         {
7531           { EL_TUBE_ANY,                MV_LEFT | MV_RIGHT | MV_UP | MV_DOWN },
7532           { EL_TUBE_VERTICAL,                                MV_UP | MV_DOWN },
7533           { EL_TUBE_HORIZONTAL,         MV_LEFT | MV_RIGHT                   },
7534           { EL_TUBE_VERTICAL_LEFT,                MV_RIGHT | MV_UP | MV_DOWN },
7535           { EL_TUBE_VERTICAL_RIGHT,     MV_LEFT            | MV_UP | MV_DOWN },
7536           { EL_TUBE_HORIZONTAL_UP,      MV_LEFT | MV_RIGHT |         MV_DOWN },
7537           { EL_TUBE_HORIZONTAL_DOWN,    MV_LEFT | MV_RIGHT | MV_UP           },
7538           { EL_TUBE_LEFT_UP,                      MV_RIGHT |         MV_DOWN },
7539           { EL_TUBE_LEFT_DOWN,                    MV_RIGHT | MV_UP           },
7540           { EL_TUBE_RIGHT_UP,           MV_LEFT |                    MV_DOWN },
7541           { EL_TUBE_RIGHT_DOWN,         MV_LEFT |            MV_UP           },
7542           { -1,                         MV_NO_MOVING                         }
7543         };
7544
7545         while (tube_enter_directions[i][0] != element)
7546         {
7547           i++;
7548           if (tube_enter_directions[i][0] == -1)        /* should not happen */
7549             break;
7550         }
7551
7552         if (!(tube_enter_directions[i][1] & move_direction))
7553           return MF_NO_ACTION;  /* tube has no opening in this direction */
7554
7555         PlaySoundLevel(x, y, SND_CLASS_TUBE_WALKING);
7556       }
7557       break;
7558
7559     case EL_LAMP:
7560       Feld[x][y] = EL_LAMP_ACTIVE;
7561       local_player->lights_still_needed--;
7562       DrawLevelField(x, y);
7563       PlaySoundLevel(x, y, SND_LAMP_ACTIVATING);
7564       return MF_ACTION;
7565       break;
7566
7567     case EL_TIME_ORB_FULL:
7568       Feld[x][y] = EL_TIME_ORB_EMPTY;
7569       TimeLeft += 10;
7570       DrawText(DX_TIME, DY_TIME, int2str(TimeLeft, 3), FONT_TEXT_2);
7571       DrawLevelField(x, y);
7572       PlaySoundStereo(SND_TIME_ORB_FULL_COLLECTING, SOUND_MIDDLE);
7573       return MF_ACTION;
7574       break;
7575
7576     default:
7577
7578       if (IS_WALKABLE(element))
7579       {
7580         int sound_action = ACTION_WALKING;
7581
7582         if (element >= EL_GATE_1 && element <= EL_GATE_4)
7583         {
7584           if (!player->key[element - EL_GATE_1])
7585             return MF_NO_ACTION;
7586         }
7587         else if (element >= EL_GATE_1_GRAY && element <= EL_GATE_4_GRAY)
7588         {
7589           if (!player->key[element - EL_GATE_1_GRAY])
7590             return MF_NO_ACTION;
7591         }
7592         else if (element == EL_EXIT_OPEN || element == EL_SP_EXIT_OPEN)
7593         {
7594           sound_action = ACTION_PASSING;        /* player is passing exit */
7595         }
7596         else if (element == EL_EMPTY)
7597         {
7598           sound_action = ACTION_MOVING;         /* nothing to walk on */
7599         }
7600
7601         /* play sound from background or player, whatever is available */
7602         if (element_info[element].sound[sound_action] != SND_UNDEFINED)
7603           PlaySoundLevelElementAction(x, y, element, sound_action);
7604         else
7605           PlaySoundLevelElementAction(x, y, player->element_nr, sound_action);
7606
7607         break;
7608       }
7609       else if (IS_PASSABLE(element))
7610       {
7611         if (!IN_LEV_FIELD(nextx, nexty) || !IS_FREE(nextx, nexty))
7612           return MF_NO_ACTION;
7613
7614         if (element >= EL_EM_GATE_1 && element <= EL_EM_GATE_4)
7615         {
7616           if (!player->key[element - EL_EM_GATE_1])
7617             return MF_NO_ACTION;
7618         }
7619         else if (element >= EL_EM_GATE_1_GRAY && element <= EL_EM_GATE_4_GRAY)
7620         {
7621           if (!player->key[element - EL_EM_GATE_1_GRAY])
7622             return MF_NO_ACTION;
7623         }
7624
7625         /* automatically move to the next field with double speed */
7626         player->programmed_action = move_direction;
7627         DOUBLE_PLAYER_SPEED(player);
7628
7629         PlaySoundLevelAction(x, y, ACTION_PASSING);
7630
7631         break;
7632       }
7633       else if (IS_DIGGABLE(element))
7634       {
7635         RemoveField(x, y);
7636
7637         if (mode != DF_SNAP)
7638         {
7639 #if 1
7640           GfxElement[x][y] = GFX_ELEMENT(element);
7641 #else
7642           GfxElement[x][y] =
7643             (GFX_CRUMBLED(element) ? EL_SAND : GFX_ELEMENT(element));
7644 #endif
7645           player->is_digging = TRUE;
7646         }
7647
7648         PlaySoundLevelElementAction(x, y, element, ACTION_DIGGING);
7649
7650         CheckTriggeredElementChange(x, y, element, CE_OTHER_GETS_DIGGED);
7651
7652         TestIfElementTouchesCustomElement(x, y);        /* for empty space */
7653
7654         break;
7655       }
7656       else if (IS_COLLECTIBLE(element))
7657       {
7658         RemoveField(x, y);
7659
7660         if (mode != DF_SNAP)
7661         {
7662           GfxElement[x][y] = element;
7663           player->is_collecting = TRUE;
7664         }
7665
7666         if (element == EL_SPEED_PILL)
7667           player->move_delay_value = MOVE_DELAY_HIGH_SPEED;
7668         else if (element == EL_EXTRA_TIME && level.time > 0)
7669         {
7670           TimeLeft += 10;
7671           DrawText(DX_TIME, DY_TIME, int2str(TimeLeft, 3), FONT_TEXT_2);
7672         }
7673         else if (element == EL_SHIELD_NORMAL || element == EL_SHIELD_DEADLY)
7674         {
7675           player->shield_normal_time_left += 10;
7676           if (element == EL_SHIELD_DEADLY)
7677             player->shield_deadly_time_left += 10;
7678         }
7679         else if (element == EL_DYNAMITE || element == EL_SP_DISK_RED)
7680         {
7681           if (player->inventory_size < MAX_INVENTORY_SIZE)
7682             player->inventory_element[player->inventory_size++] = element;
7683
7684           player->use_disk_red_graphic = (element == EL_SP_DISK_RED);
7685
7686           DrawText(DX_DYNAMITE, DY_DYNAMITE,
7687                    int2str(local_player->inventory_size, 3), FONT_TEXT_2);
7688         }
7689         else if (element == EL_DYNABOMB_INCREASE_NUMBER)
7690         {
7691           player->dynabomb_count++;
7692           player->dynabombs_left++;
7693         }
7694         else if (element == EL_DYNABOMB_INCREASE_SIZE)
7695         {
7696           player->dynabomb_size++;
7697         }
7698         else if (element == EL_DYNABOMB_INCREASE_POWER)
7699         {
7700           player->dynabomb_xl = TRUE;
7701         }
7702         else if ((element >= EL_KEY_1 && element <= EL_KEY_4) ||
7703                  (element >= EL_EM_KEY_1 && element <= EL_EM_KEY_4))
7704         {
7705           int key_nr = (element >= EL_KEY_1 && element <= EL_KEY_4 ?
7706                         element - EL_KEY_1 : element - EL_EM_KEY_1);
7707
7708           player->key[key_nr] = TRUE;
7709
7710           DrawMiniGraphicExt(drawto, DX_KEYS + key_nr * MINI_TILEX, DY_KEYS,
7711                              el2edimg(EL_KEY_1 + key_nr));
7712           redraw_mask |= REDRAW_DOOR_1;
7713         }
7714         else if (IS_ENVELOPE(element))
7715         {
7716 #if 1
7717           player->show_envelope = element;
7718 #else
7719           ShowEnvelope(element - EL_ENVELOPE_1);
7720 #endif
7721         }
7722         else if (IS_DROPPABLE(element)) /* can be collected and dropped */
7723         {
7724           int i;
7725
7726           for (i=0; i < element_info[element].collect_count; i++)
7727             if (player->inventory_size < MAX_INVENTORY_SIZE)
7728               player->inventory_element[player->inventory_size++] = element;
7729
7730           DrawText(DX_DYNAMITE, DY_DYNAMITE,
7731                    int2str(local_player->inventory_size, 3), FONT_TEXT_2);
7732         }
7733         else if (element_info[element].collect_count > 0)
7734         {
7735           local_player->gems_still_needed -=
7736             element_info[element].collect_count;
7737           if (local_player->gems_still_needed < 0)
7738             local_player->gems_still_needed = 0;
7739
7740           DrawText(DX_EMERALDS, DY_EMERALDS,
7741                    int2str(local_player->gems_still_needed, 3), FONT_TEXT_2);
7742         }
7743
7744         RaiseScoreElement(element);
7745         PlaySoundLevelElementAction(x, y, element, ACTION_COLLECTING);
7746
7747         CheckTriggeredElementChange(x, y, element, CE_OTHER_GETS_COLLECTED);
7748
7749         TestIfElementTouchesCustomElement(x, y);        /* for empty space */
7750
7751         break;
7752       }
7753       else if (IS_PUSHABLE(element))
7754       {
7755         if (mode == DF_SNAP && element != EL_BD_ROCK)
7756           return MF_NO_ACTION;
7757
7758         if (CAN_FALL(element) && dy)
7759           return MF_NO_ACTION;
7760
7761         if (CAN_FALL(element) && IN_LEV_FIELD(x, y + 1) && IS_FREE(x, y + 1) &&
7762             !(element == EL_SPRING && use_spring_bug))
7763           return MF_NO_ACTION;
7764
7765         if (element == EL_SPRING && MovDir[x][y] != MV_NO_MOVING)
7766           return MF_NO_ACTION;
7767
7768         if (!player->Pushing &&
7769             game.engine_version >= RELEASE_IDENT(2,2,0,7))
7770           player->push_delay_value = GET_NEW_PUSH_DELAY(element);
7771
7772         player->Pushing = TRUE;
7773
7774         if (!(IN_LEV_FIELD(nextx, nexty) &&
7775               (IS_FREE(nextx, nexty) ||
7776                (Feld[nextx][nexty] == EL_SOKOBAN_FIELD_EMPTY &&
7777                 IS_SB_ELEMENT(element)))))
7778           return MF_NO_ACTION;
7779
7780         if (!checkDiagonalPushing(player, x, y, real_dx, real_dy))
7781           return MF_NO_ACTION;
7782
7783         if (player->push_delay == 0)    /* new pushing; restart delay */
7784           player->push_delay = FrameCounter;
7785
7786         if (!FrameReached(&player->push_delay, player->push_delay_value) &&
7787             !(tape.playing && tape.file_version < FILE_VERSION_2_0) &&
7788             element != EL_SPRING && element != EL_BALLOON)
7789           return MF_NO_ACTION;
7790
7791         if (IS_SB_ELEMENT(element))
7792         {
7793           if (element == EL_SOKOBAN_FIELD_FULL)
7794           {
7795             Back[x][y] = EL_SOKOBAN_FIELD_EMPTY;
7796             local_player->sokobanfields_still_needed++;
7797           }
7798
7799           if (Feld[nextx][nexty] == EL_SOKOBAN_FIELD_EMPTY)
7800           {
7801             Back[nextx][nexty] = EL_SOKOBAN_FIELD_EMPTY;
7802             local_player->sokobanfields_still_needed--;
7803           }
7804
7805           Feld[x][y] = EL_SOKOBAN_OBJECT;
7806
7807           if (Back[x][y] == Back[nextx][nexty])
7808             PlaySoundLevelAction(x, y, ACTION_PUSHING);
7809           else if (Back[x][y] != 0)
7810             PlaySoundLevelElementAction(x, y, EL_SOKOBAN_FIELD_FULL,
7811                                         ACTION_EMPTYING);
7812           else
7813             PlaySoundLevelElementAction(nextx, nexty, EL_SOKOBAN_FIELD_EMPTY,
7814                                         ACTION_FILLING);
7815
7816           if (local_player->sokobanfields_still_needed == 0 &&
7817               game.emulation == EMU_SOKOBAN)
7818           {
7819             player->LevelSolved = player->GameOver = TRUE;
7820             PlaySoundLevel(x, y, SND_GAME_SOKOBAN_SOLVING);
7821           }
7822         }
7823         else
7824           PlaySoundLevelElementAction(x, y, element, ACTION_PUSHING);
7825
7826         InitMovingField(x, y, move_direction);
7827         GfxAction[x][y] = ACTION_PUSHING;
7828
7829         if (mode == DF_SNAP)
7830           ContinueMoving(x, y);
7831         else
7832           MovPos[x][y] = (dx != 0 ? dx : dy);
7833
7834         Pushed[x][y] = TRUE;
7835         Pushed[nextx][nexty] = TRUE;
7836
7837         if (game.engine_version < RELEASE_IDENT(2,2,0,7))
7838           player->push_delay_value = GET_NEW_PUSH_DELAY(element);
7839
7840         CheckTriggeredElementChange(x, y, element, CE_OTHER_GETS_PUSHED);
7841         CheckElementChange(x, y, element, CE_PUSHED_BY_PLAYER);
7842
7843         break;
7844       }
7845       else
7846       {
7847         CheckTriggeredElementChange(x, y, element, CE_OTHER_GETS_PRESSED);
7848         CheckElementChange(x, y, element, CE_PRESSED_BY_PLAYER);
7849       }
7850
7851       return MF_NO_ACTION;
7852   }
7853
7854   player->push_delay = 0;
7855
7856   if (Feld[x][y] != element)            /* really digged/collected something */
7857     player->is_collecting = !player->is_digging;
7858
7859 #if 0
7860   if (IS_CUSTOM_ELEMENT(Feld[jx][jy]))
7861   {
7862     CheckTriggeredElementSideChange(jx, jy, Feld[jx][jy], leave_side,
7863                                     CE_OTHER_GETS_LEFT);
7864     CheckElementSideChange(jx, jy, Feld[jx][jy], leave_side,
7865                            CE_LEFT_BY_PLAYER, -1);
7866   }
7867
7868   if (IS_CUSTOM_ELEMENT(Feld[x][y]))
7869   {
7870     CheckTriggeredElementSideChange(x, y, Feld[x][y], enter_side,
7871                                     CE_OTHER_GETS_ENTERED);
7872     CheckElementSideChange(x, y, Feld[x][y], enter_side,
7873                            CE_ENTERED_BY_PLAYER, -1);
7874   }
7875 #endif
7876
7877   return MF_MOVING;
7878 }
7879
7880 boolean SnapField(struct PlayerInfo *player, int dx, int dy)
7881 {
7882   int jx = player->jx, jy = player->jy;
7883   int x = jx + dx, y = jy + dy;
7884   int snap_direction = (dx == -1 ? MV_LEFT :
7885                         dx == +1 ? MV_RIGHT :
7886                         dy == -1 ? MV_UP :
7887                         dy == +1 ? MV_DOWN : MV_NO_MOVING);
7888
7889   if (player->MovPos && game.engine_version >= VERSION_IDENT(2,2,0))
7890     return FALSE;
7891
7892   if (!player->active || !IN_LEV_FIELD(x, y))
7893     return FALSE;
7894
7895   if (dx && dy)
7896     return FALSE;
7897
7898   if (!dx && !dy)
7899   {
7900     if (player->MovPos == 0)
7901       player->Pushing = FALSE;
7902
7903     player->snapped = FALSE;
7904
7905     if (player->MovPos == 0)
7906     {
7907       player->is_digging = FALSE;
7908       player->is_collecting = FALSE;
7909 #if 1
7910       player->is_moving = FALSE;
7911 #endif
7912     }
7913
7914 #if 0
7915     printf("::: trying to snap...\n");
7916 #endif
7917
7918     return FALSE;
7919   }
7920
7921   if (player->snapped)
7922     return FALSE;
7923
7924   player->MovDir = snap_direction;
7925
7926 #if 1
7927   player->is_digging = FALSE;
7928   player->is_collecting = FALSE;
7929 #if 1
7930   player->is_moving = FALSE;
7931 #endif
7932 #endif
7933
7934   if (DigField(player, x, y, 0, 0, DF_SNAP) == MF_NO_ACTION)
7935     return FALSE;
7936
7937   player->snapped = TRUE;
7938 #if 1
7939   player->is_digging = FALSE;
7940   player->is_collecting = FALSE;
7941 #if 1
7942   player->is_moving = FALSE;
7943 #endif
7944 #endif
7945
7946   DrawLevelField(x, y);
7947   BackToFront();
7948
7949   return TRUE;
7950 }
7951
7952 boolean DropElement(struct PlayerInfo *player)
7953 {
7954   int jx = player->jx, jy = player->jy;
7955   int old_element;
7956
7957   if (!player->active || player->MovPos)
7958     return FALSE;
7959
7960   old_element = Feld[jx][jy];
7961
7962   /* check if player has anything that can be dropped */
7963   if (player->inventory_size == 0 && player->dynabombs_left == 0)
7964     return FALSE;
7965
7966   /* check if anything can be dropped at the current position */
7967   if (IS_ACTIVE_BOMB(old_element) || old_element == EL_EXPLOSION)
7968     return FALSE;
7969
7970   /* collected custom elements can only be dropped on empty fields */
7971   if (player->inventory_size > 0 &&
7972       IS_CUSTOM_ELEMENT(player->inventory_element[player->inventory_size - 1])
7973       && old_element != EL_EMPTY)
7974     return FALSE;
7975
7976   if (old_element != EL_EMPTY)
7977     Back[jx][jy] = old_element;         /* store old element on this field */
7978
7979   MovDelay[jx][jy] = 96;
7980
7981   ResetGfxAnimation(jx, jy);
7982   ResetRandomAnimationValue(jx, jy);
7983
7984   if (player->inventory_size > 0)
7985   {
7986     int new_element = player->inventory_element[--player->inventory_size];
7987
7988 #if 1
7989     Feld[jx][jy] = (new_element == EL_DYNAMITE ? EL_DYNAMITE_ACTIVE :
7990                     new_element == EL_SP_DISK_RED ? EL_SP_DISK_RED_ACTIVE :
7991                     new_element);
7992 #else
7993     Feld[jx][jy] = (player->use_disk_red_graphic ? EL_SP_DISK_RED_ACTIVE :
7994                     EL_DYNAMITE_ACTIVE);
7995 #endif
7996
7997     DrawText(DX_DYNAMITE, DY_DYNAMITE,
7998              int2str(local_player->inventory_size, 3), FONT_TEXT_2);
7999
8000     if (IN_SCR_FIELD(SCREENX(jx), SCREENY(jy)))
8001       DrawGraphicThruMask(SCREENX(jx), SCREENY(jy), el2img(Feld[jx][jy]), 0);
8002
8003     PlaySoundLevelAction(jx, jy, ACTION_DROPPING);
8004
8005     CheckTriggeredElementChange(jx, jy, new_element, CE_OTHER_GETS_DROPPED);
8006     CheckElementChange(jx, jy, new_element, CE_DROPPED_BY_PLAYER);
8007
8008     TestIfElementTouchesCustomElement(jx, jy);
8009   }
8010   else          /* player is dropping a dyna bomb */
8011   {
8012     player->dynabombs_left--;
8013
8014     Feld[jx][jy] =
8015       EL_DYNABOMB_PLAYER_1_ACTIVE + (player->element_nr - EL_PLAYER_1);
8016
8017     if (IN_SCR_FIELD(SCREENX(jx), SCREENY(jy)))
8018       DrawGraphicThruMask(SCREENX(jx), SCREENY(jy), el2img(Feld[jx][jy]), 0);
8019
8020     PlaySoundLevelAction(jx, jy, ACTION_DROPPING);
8021   }
8022
8023   return TRUE;
8024 }
8025
8026 /* ------------------------------------------------------------------------- */
8027 /* game sound playing functions                                              */
8028 /* ------------------------------------------------------------------------- */
8029
8030 static int *loop_sound_frame = NULL;
8031 static int *loop_sound_volume = NULL;
8032
8033 void InitPlaySoundLevel()
8034 {
8035   int num_sounds = getSoundListSize();
8036
8037   if (loop_sound_frame != NULL)
8038     free(loop_sound_frame);
8039
8040   if (loop_sound_volume != NULL)
8041     free(loop_sound_volume);
8042
8043   loop_sound_frame = checked_calloc(num_sounds * sizeof(int));
8044   loop_sound_volume = checked_calloc(num_sounds * sizeof(int));
8045 }
8046
8047 static void PlaySoundLevel(int x, int y, int nr)
8048 {
8049   int sx = SCREENX(x), sy = SCREENY(y);
8050   int volume, stereo_position;
8051   int max_distance = 8;
8052   int type = (IS_LOOP_SOUND(nr) ? SND_CTRL_PLAY_LOOP : SND_CTRL_PLAY_SOUND);
8053
8054   if ((!setup.sound_simple && !IS_LOOP_SOUND(nr)) ||
8055       (!setup.sound_loops && IS_LOOP_SOUND(nr)))
8056     return;
8057
8058   if (!IN_LEV_FIELD(x, y) ||
8059       sx < -max_distance || sx >= SCR_FIELDX + max_distance ||
8060       sy < -max_distance || sy >= SCR_FIELDY + max_distance)
8061     return;
8062
8063   volume = SOUND_MAX_VOLUME;
8064
8065   if (!IN_SCR_FIELD(sx, sy))
8066   {
8067     int dx = ABS(sx - SCR_FIELDX / 2) - SCR_FIELDX / 2;
8068     int dy = ABS(sy - SCR_FIELDY / 2) - SCR_FIELDY / 2;
8069
8070     volume -= volume * (dx > dy ? dx : dy) / max_distance;
8071   }
8072
8073   stereo_position = (SOUND_MAX_LEFT +
8074                      (sx + max_distance) * SOUND_MAX_LEFT2RIGHT /
8075                      (SCR_FIELDX + 2 * max_distance));
8076
8077   if (IS_LOOP_SOUND(nr))
8078   {
8079     /* This assures that quieter loop sounds do not overwrite louder ones,
8080        while restarting sound volume comparison with each new game frame. */
8081
8082     if (loop_sound_volume[nr] > volume && loop_sound_frame[nr] == FrameCounter)
8083       return;
8084
8085     loop_sound_volume[nr] = volume;
8086     loop_sound_frame[nr] = FrameCounter;
8087   }
8088
8089   PlaySoundExt(nr, volume, stereo_position, type);
8090 }
8091
8092 static void PlaySoundLevelNearest(int x, int y, int sound_action)
8093 {
8094   PlaySoundLevel(x < LEVELX(BX1) ? LEVELX(BX1) :
8095                  x > LEVELX(BX2) ? LEVELX(BX2) : x,
8096                  y < LEVELY(BY1) ? LEVELY(BY1) :
8097                  y > LEVELY(BY2) ? LEVELY(BY2) : y,
8098                  sound_action);
8099 }
8100
8101 static void PlaySoundLevelAction(int x, int y, int action)
8102 {
8103   PlaySoundLevelElementAction(x, y, Feld[x][y], action);
8104 }
8105
8106 static void PlaySoundLevelElementAction(int x, int y, int element, int action)
8107 {
8108   int sound_effect = element_info[element].sound[action];
8109
8110   if (sound_effect != SND_UNDEFINED)
8111     PlaySoundLevel(x, y, sound_effect);
8112 }
8113
8114 static void PlaySoundLevelActionIfLoop(int x, int y, int action)
8115 {
8116   int sound_effect = element_info[Feld[x][y]].sound[action];
8117
8118   if (sound_effect != SND_UNDEFINED && IS_LOOP_SOUND(sound_effect))
8119     PlaySoundLevel(x, y, sound_effect);
8120 }
8121
8122 static void StopSoundLevelActionIfLoop(int x, int y, int action)
8123 {
8124   int sound_effect = element_info[Feld[x][y]].sound[action];
8125
8126   if (sound_effect != SND_UNDEFINED && IS_LOOP_SOUND(sound_effect))
8127     StopSoundExt(sound_effect, SND_CTRL_STOP_SOUND);
8128 }
8129
8130 void RaiseScore(int value)
8131 {
8132   local_player->score += value;
8133   DrawText(DX_SCORE, DY_SCORE, int2str(local_player->score, 5), FONT_TEXT_2);
8134 }
8135
8136 void RaiseScoreElement(int element)
8137 {
8138   switch(element)
8139   {
8140     case EL_EMERALD:
8141     case EL_BD_DIAMOND:
8142     case EL_EMERALD_YELLOW:
8143     case EL_EMERALD_RED:
8144     case EL_EMERALD_PURPLE:
8145     case EL_SP_INFOTRON:
8146       RaiseScore(level.score[SC_EMERALD]);
8147       break;
8148     case EL_DIAMOND:
8149       RaiseScore(level.score[SC_DIAMOND]);
8150       break;
8151     case EL_CRYSTAL:
8152       RaiseScore(level.score[SC_CRYSTAL]);
8153       break;
8154     case EL_PEARL:
8155       RaiseScore(level.score[SC_PEARL]);
8156       break;
8157     case EL_BUG:
8158     case EL_BD_BUTTERFLY:
8159     case EL_SP_ELECTRON:
8160       RaiseScore(level.score[SC_BUG]);
8161       break;
8162     case EL_SPACESHIP:
8163     case EL_BD_FIREFLY:
8164     case EL_SP_SNIKSNAK:
8165       RaiseScore(level.score[SC_SPACESHIP]);
8166       break;
8167     case EL_YAMYAM:
8168     case EL_DARK_YAMYAM:
8169       RaiseScore(level.score[SC_YAMYAM]);
8170       break;
8171     case EL_ROBOT:
8172       RaiseScore(level.score[SC_ROBOT]);
8173       break;
8174     case EL_PACMAN:
8175       RaiseScore(level.score[SC_PACMAN]);
8176       break;
8177     case EL_NUT:
8178       RaiseScore(level.score[SC_NUT]);
8179       break;
8180     case EL_DYNAMITE:
8181     case EL_SP_DISK_RED:
8182     case EL_DYNABOMB_INCREASE_NUMBER:
8183     case EL_DYNABOMB_INCREASE_SIZE:
8184     case EL_DYNABOMB_INCREASE_POWER:
8185       RaiseScore(level.score[SC_DYNAMITE]);
8186       break;
8187     case EL_SHIELD_NORMAL:
8188     case EL_SHIELD_DEADLY:
8189       RaiseScore(level.score[SC_SHIELD]);
8190       break;
8191     case EL_EXTRA_TIME:
8192       RaiseScore(level.score[SC_TIME_BONUS]);
8193       break;
8194     case EL_KEY_1:
8195     case EL_KEY_2:
8196     case EL_KEY_3:
8197     case EL_KEY_4:
8198       RaiseScore(level.score[SC_KEY]);
8199       break;
8200     default:
8201       RaiseScore(element_info[element].collect_score);
8202       break;
8203   }
8204 }
8205
8206 void RequestQuitGame(boolean ask_if_really_quit)
8207 {
8208   if (AllPlayersGone ||
8209       !ask_if_really_quit ||
8210       level_editor_test_game ||
8211       Request("Do you really want to quit the game ?",
8212               REQ_ASK | REQ_STAY_CLOSED))
8213   {
8214 #if defined(PLATFORM_UNIX)
8215     if (options.network)
8216       SendToServer_StopPlaying();
8217     else
8218 #endif
8219     {
8220       game_status = GAME_MODE_MAIN;
8221       DrawMainMenu();
8222     }
8223   }
8224   else
8225   {
8226     OpenDoor(DOOR_OPEN_1 | DOOR_COPY_BACK);
8227   }
8228 }
8229
8230
8231 /* ---------- new game button stuff ---------------------------------------- */
8232
8233 /* graphic position values for game buttons */
8234 #define GAME_BUTTON_XSIZE       30
8235 #define GAME_BUTTON_YSIZE       30
8236 #define GAME_BUTTON_XPOS        5
8237 #define GAME_BUTTON_YPOS        215
8238 #define SOUND_BUTTON_XPOS       5
8239 #define SOUND_BUTTON_YPOS       (GAME_BUTTON_YPOS + GAME_BUTTON_YSIZE)
8240
8241 #define GAME_BUTTON_STOP_XPOS   (GAME_BUTTON_XPOS + 0 * GAME_BUTTON_XSIZE)
8242 #define GAME_BUTTON_PAUSE_XPOS  (GAME_BUTTON_XPOS + 1 * GAME_BUTTON_XSIZE)
8243 #define GAME_BUTTON_PLAY_XPOS   (GAME_BUTTON_XPOS + 2 * GAME_BUTTON_XSIZE)
8244 #define SOUND_BUTTON_MUSIC_XPOS (SOUND_BUTTON_XPOS + 0 * GAME_BUTTON_XSIZE)
8245 #define SOUND_BUTTON_LOOPS_XPOS (SOUND_BUTTON_XPOS + 1 * GAME_BUTTON_XSIZE)
8246 #define SOUND_BUTTON_SIMPLE_XPOS (SOUND_BUTTON_XPOS + 2 * GAME_BUTTON_XSIZE)
8247
8248 static struct
8249 {
8250   int x, y;
8251   int gadget_id;
8252   char *infotext;
8253 } gamebutton_info[NUM_GAME_BUTTONS] =
8254 {
8255   {
8256     GAME_BUTTON_STOP_XPOS,      GAME_BUTTON_YPOS,
8257     GAME_CTRL_ID_STOP,
8258     "stop game"
8259   },
8260   {
8261     GAME_BUTTON_PAUSE_XPOS,     GAME_BUTTON_YPOS,
8262     GAME_CTRL_ID_PAUSE,
8263     "pause game"
8264   },
8265   {
8266     GAME_BUTTON_PLAY_XPOS,      GAME_BUTTON_YPOS,
8267     GAME_CTRL_ID_PLAY,
8268     "play game"
8269   },
8270   {
8271     SOUND_BUTTON_MUSIC_XPOS,    SOUND_BUTTON_YPOS,
8272     SOUND_CTRL_ID_MUSIC,
8273     "background music on/off"
8274   },
8275   {
8276     SOUND_BUTTON_LOOPS_XPOS,    SOUND_BUTTON_YPOS,
8277     SOUND_CTRL_ID_LOOPS,
8278     "sound loops on/off"
8279   },
8280   {
8281     SOUND_BUTTON_SIMPLE_XPOS,   SOUND_BUTTON_YPOS,
8282     SOUND_CTRL_ID_SIMPLE,
8283     "normal sounds on/off"
8284   }
8285 };
8286
8287 void CreateGameButtons()
8288 {
8289   int i;
8290
8291   for (i=0; i<NUM_GAME_BUTTONS; i++)
8292   {
8293     Bitmap *gd_bitmap = graphic_info[IMG_GLOBAL_DOOR].bitmap;
8294     struct GadgetInfo *gi;
8295     int button_type;
8296     boolean checked;
8297     unsigned long event_mask;
8298     int gd_xoffset, gd_yoffset;
8299     int gd_x1, gd_x2, gd_y1, gd_y2;
8300     int id = i;
8301
8302     gd_xoffset = gamebutton_info[i].x;
8303     gd_yoffset = gamebutton_info[i].y;
8304     gd_x1 = DOOR_GFX_PAGEX4 + gd_xoffset;
8305     gd_x2 = DOOR_GFX_PAGEX3 + gd_xoffset;
8306
8307     if (id == GAME_CTRL_ID_STOP ||
8308         id == GAME_CTRL_ID_PAUSE ||
8309         id == GAME_CTRL_ID_PLAY)
8310     {
8311       button_type = GD_TYPE_NORMAL_BUTTON;
8312       checked = FALSE;
8313       event_mask = GD_EVENT_RELEASED;
8314       gd_y1  = DOOR_GFX_PAGEY1 + gd_yoffset - GAME_BUTTON_YSIZE;
8315       gd_y2  = DOOR_GFX_PAGEY1 + gd_yoffset - GAME_BUTTON_YSIZE;
8316     }
8317     else
8318     {
8319       button_type = GD_TYPE_CHECK_BUTTON;
8320       checked =
8321         ((id == SOUND_CTRL_ID_MUSIC && setup.sound_music) ||
8322          (id == SOUND_CTRL_ID_LOOPS && setup.sound_loops) ||
8323          (id == SOUND_CTRL_ID_SIMPLE && setup.sound_simple) ? TRUE : FALSE);
8324       event_mask = GD_EVENT_PRESSED;
8325       gd_y1  = DOOR_GFX_PAGEY1 + gd_yoffset;
8326       gd_y2  = DOOR_GFX_PAGEY1 + gd_yoffset - GAME_BUTTON_YSIZE;
8327     }
8328
8329     gi = CreateGadget(GDI_CUSTOM_ID, id,
8330                       GDI_INFO_TEXT, gamebutton_info[i].infotext,
8331                       GDI_X, DX + gd_xoffset,
8332                       GDI_Y, DY + gd_yoffset,
8333                       GDI_WIDTH, GAME_BUTTON_XSIZE,
8334                       GDI_HEIGHT, GAME_BUTTON_YSIZE,
8335                       GDI_TYPE, button_type,
8336                       GDI_STATE, GD_BUTTON_UNPRESSED,
8337                       GDI_CHECKED, checked,
8338                       GDI_DESIGN_UNPRESSED, gd_bitmap, gd_x1, gd_y1,
8339                       GDI_DESIGN_PRESSED, gd_bitmap, gd_x2, gd_y1,
8340                       GDI_ALT_DESIGN_UNPRESSED, gd_bitmap, gd_x1, gd_y2,
8341                       GDI_ALT_DESIGN_PRESSED, gd_bitmap, gd_x2, gd_y2,
8342                       GDI_EVENT_MASK, event_mask,
8343                       GDI_CALLBACK_ACTION, HandleGameButtons,
8344                       GDI_END);
8345
8346     if (gi == NULL)
8347       Error(ERR_EXIT, "cannot create gadget");
8348
8349     game_gadget[id] = gi;
8350   }
8351 }
8352
8353 void FreeGameButtons()
8354 {
8355   int i;
8356
8357   for (i=0; i<NUM_GAME_BUTTONS; i++)
8358     FreeGadget(game_gadget[i]);
8359 }
8360
8361 static void MapGameButtons()
8362 {
8363   int i;
8364
8365   for (i=0; i<NUM_GAME_BUTTONS; i++)
8366     MapGadget(game_gadget[i]);
8367 }
8368
8369 void UnmapGameButtons()
8370 {
8371   int i;
8372
8373   for (i=0; i<NUM_GAME_BUTTONS; i++)
8374     UnmapGadget(game_gadget[i]);
8375 }
8376
8377 static void HandleGameButtons(struct GadgetInfo *gi)
8378 {
8379   int id = gi->custom_id;
8380
8381   if (game_status != GAME_MODE_PLAYING)
8382     return;
8383
8384   switch (id)
8385   {
8386     case GAME_CTRL_ID_STOP:
8387       RequestQuitGame(TRUE);
8388       break;
8389
8390     case GAME_CTRL_ID_PAUSE:
8391       if (options.network)
8392       {
8393 #if defined(PLATFORM_UNIX)
8394         if (tape.pausing)
8395           SendToServer_ContinuePlaying();
8396         else
8397           SendToServer_PausePlaying();
8398 #endif
8399       }
8400       else
8401         TapeTogglePause(TAPE_TOGGLE_MANUAL);
8402       break;
8403
8404     case GAME_CTRL_ID_PLAY:
8405       if (tape.pausing)
8406       {
8407 #if defined(PLATFORM_UNIX)
8408         if (options.network)
8409           SendToServer_ContinuePlaying();
8410         else
8411 #endif
8412         {
8413           tape.pausing = FALSE;
8414           DrawVideoDisplay(VIDEO_STATE_PAUSE_OFF,0);
8415         }
8416       }
8417       break;
8418
8419     case SOUND_CTRL_ID_MUSIC:
8420       if (setup.sound_music)
8421       {
8422         setup.sound_music = FALSE;
8423         FadeMusic();
8424       }
8425       else if (audio.music_available)
8426       {
8427         setup.sound = setup.sound_music = TRUE;
8428
8429         SetAudioMode(setup.sound);
8430         PlayMusic(level_nr);
8431       }
8432       break;
8433
8434     case SOUND_CTRL_ID_LOOPS:
8435       if (setup.sound_loops)
8436         setup.sound_loops = FALSE;
8437       else if (audio.loops_available)
8438       {
8439         setup.sound = setup.sound_loops = TRUE;
8440         SetAudioMode(setup.sound);
8441       }
8442       break;
8443
8444     case SOUND_CTRL_ID_SIMPLE:
8445       if (setup.sound_simple)
8446         setup.sound_simple = FALSE;
8447       else if (audio.sound_available)
8448       {
8449         setup.sound = setup.sound_simple = TRUE;
8450         SetAudioMode(setup.sound);
8451       }
8452       break;
8453
8454     default:
8455       break;
8456   }
8457 }