src/game.c

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