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