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