src/game.c

   1 /***********************************************************
   2 *  Rocks'n'Diamonds -- McDuffin Strikes Back!              *
   3 *----------------------------------------------------------*
   4 *  (c) 1995-98 Artsoft Entertainment                       *
   5 *              Holger Schemel                              *
   6 *              Oststrasse 11a                              *
   7 *              33604 Bielefeld                             *
   8 *              phone: ++49 +521 290471                     *
   9 *              email: aeglos@valinor.owl.de                *
  10 *----------------------------------------------------------*
  11 *  game.c                                                  *
  12 ***********************************************************/
  13
  14 #include "game.h"
  15 #include "misc.h"
  16 #include "tools.h"
  17 #include "screens.h"
  18 #include "sound.h"
  19 #include "init.h"
  20 #include "buttons.h"
  21 #include "files.h"
  22 #include "tape.h"
  23 #include "joystick.h"
  24 #include "network.h"
  25
  26 /* this switch controls how rocks move horizontally */
  27 #define OLD_GAME_BEHAVIOUR      FALSE
  28
  29 /* for DigField() */
  30 #define DF_NO_PUSH              0
  31 #define DF_DIG                  1
  32 #define DF_SNAP                 2
  33
  34 /* for MoveFigure() */
  35 #define MF_NO_ACTION            0
  36 #define MF_MOVING               1
  37 #define MF_ACTION               2
  38
  39 /* for ScrollFigure() */
  40 #define SCROLL_INIT             0
  41 #define SCROLL_GO_ON            1
  42
  43 /* for Explode() */
  44 #define EX_PHASE_START          0
  45 #define EX_NORMAL               0
  46 #define EX_CENTER               1
  47 #define EX_BORDER               2
  48
  49 /* special positions in the game control window (relative to control window) */
  50 #define XX_LEVEL                37
  51 #define YY_LEVEL                20
  52 #define XX_EMERALDS             29
  53 #define YY_EMERALDS             54
  54 #define XX_DYNAMITE             29
  55 #define YY_DYNAMITE             89
  56 #define XX_KEYS                 18
  57 #define YY_KEYS                 123
  58 #define XX_SCORE                15
  59 #define YY_SCORE                159
  60 #define XX_TIME                 29
  61 #define YY_TIME                 194
  62
  63 /* special positions in the game control window (relative to main window) */
  64 #define DX_LEVEL                (DX + XX_LEVEL)
  65 #define DY_LEVEL                (DY + YY_LEVEL)
  66 #define DX_EMERALDS             (DX + XX_EMERALDS)
  67 #define DY_EMERALDS             (DY + YY_EMERALDS)
  68 #define DX_DYNAMITE             (DX + XX_DYNAMITE)
  69 #define DY_DYNAMITE             (DY + YY_DYNAMITE)
  70 #define DX_KEYS                 (DX + XX_KEYS)
  71 #define DY_KEYS                 (DY + YY_KEYS)
  72 #define DX_SCORE                (DX + XX_SCORE)
  73 #define DY_SCORE                (DY + YY_SCORE)
  74 #define DX_TIME                 (DX + XX_TIME)
  75 #define DY_TIME                 (DY + YY_TIME)
  76
  77 #define IS_LOOP_SOUND(s)        ((s)==SND_KLAPPER || (s)==SND_ROEHR ||  \
  78                                  (s)==SND_NJAM || (s)==SND_MIEP)
  79 #define IS_MUSIC_SOUND(s)       ((s)==SND_ALCHEMY || (s)==SND_CHASE || \
  80                                  (s)==SND_NETWORK || (s)==SND_CZARDASZ || \
  81                                  (s)==SND_TYGER || (s)==SND_VOYAGER || \
  82                                  (s)==SND_TWILIGHT)
  83
  84 /* values for player movement speed (which is in fact a delay value) */
  85 #define MOVE_DELAY_NORMAL_SPEED 8
  86 #define MOVE_DELAY_HIGH_SPEED   4
  87
  88 #define DOUBLE_MOVE_DELAY(x)    (x = (x <= MOVE_DELAY_HIGH_SPEED ? x * 2 : x))
  89 #define HALVE_MOVE_DELAY(x)     (x = (x >= MOVE_DELAY_HIGH_SPEED ? x / 2 : x))
  90 #define DOUBLE_PLAYER_SPEED(p)  (HALVE_MOVE_DELAY((p)->move_delay_value))
  91 #define HALVE_PLAYER_SPEED(p)   (DOUBLE_MOVE_DELAY((p)->move_delay_value))
  92
  93 /* game button identifiers */
  94 #define GAME_CTRL_ID_STOP               0
  95 #define GAME_CTRL_ID_PAUSE              1
  96 #define GAME_CTRL_ID_PLAY               2
  97 #define SOUND_CTRL_ID_MUSIC             3
  98 #define SOUND_CTRL_ID_LOOPS             4
  99 #define SOUND_CTRL_ID_SIMPLE            5
 100
 101 #define NUM_GAME_BUTTONS                6
 102
 103 /* forward declaration for internal use */
 104 static void CheckGravityMovement(struct PlayerInfo *);
 105
 106 static void MapGameButtons();
 107 static void HandleGameButtons(struct GadgetInfo *);
 108
 109 static struct GadgetInfo *game_gadget[NUM_GAME_BUTTONS];
 110
 111
 112
 113 #ifdef DEBUG
 114 #if 0
 115 static unsigned int getStateCheckSum(int counter)
 116 {
 117   int x, y;
 118   unsigned int mult = 1;
 119   unsigned int checksum = 0;
 120   /*
 121   static short lastFeld[MAX_LEV_FIELDX][MAX_LEV_FIELDY];
 122   */
 123   static boolean first_game = TRUE;
 124
 125   for (y=0; y<lev_fieldy; y++) for(x=0; x<lev_fieldx; x++)
 126   {
 127     /*
 128     if (counter == 3)
 129     {
 130       if (first_game)
 131         lastFeld[x][y] = Feld[x][y];
 132       else if (lastFeld[x][y] != Feld[x][y])
 133         printf("DIFF: [%d][%d]: lastFeld == %d != %d == Feld\n",
 134                x, y, lastFeld[x][y], Feld[x][y]);
 135     }
 136     */
 137
 138     checksum += mult++ * Ur[x][y];
 139     checksum += mult++ * Feld[x][y];
 140
 141     /*
 142     checksum += mult++ * MovPos[x][y];
 143     checksum += mult++ * MovDir[x][y];
 144     checksum += mult++ * MovDelay[x][y];
 145     checksum += mult++ * Store[x][y];
 146     checksum += mult++ * Store2[x][y];
 147     checksum += mult++ * StorePlayer[x][y];
 148     checksum += mult++ * Frame[x][y];
 149     checksum += mult++ * AmoebaNr[x][y];
 150     checksum += mult++ * JustStopped[x][y];
 151     checksum += mult++ * Stop[x][y];
 152     */
 153   }
 154
 155   if (counter == 3 && first_game)
 156     first_game = FALSE;
 157
 158   return checksum;
 159 }
 160 #endif
 161 #endif
 162
 163
 164
 165
 166 void GetPlayerConfig()
 167 {
 168   if (sound_status == SOUND_OFF)
 169     setup.sound = FALSE;
 170
 171   if (!sound_loops_allowed)
 172   {
 173     setup.sound_loops = FALSE;
 174     setup.sound_music = FALSE;
 175   }
 176
 177   setup.sound_simple = setup.sound;
 178
 179   InitJoysticks();
 180 }
 181
 182 static void InitField(int x, int y, boolean init_game)
 183 {
 184   switch (Feld[x][y])
 185   {
 186     case EL_SPIELFIGUR:
 187     case EL_SP_MURPHY:
 188       if (init_game)
 189         Feld[x][y] = EL_SPIELER1;
 190       /* no break! */
 191     case EL_SPIELER1:
 192     case EL_SPIELER2:
 193     case EL_SPIELER3:
 194     case EL_SPIELER4:
 195       if (init_game)
 196       {
 197         struct PlayerInfo *player = &stored_player[Feld[x][y] - EL_SPIELER1];
 198         int jx = player->jx, jy = player->jy;
 199
 200         player->present = TRUE;
 201
 202         if (!options.network || player->connected)
 203         {
 204           player->active = TRUE;
 205
 206           /* remove potentially duplicate players */
 207           if (StorePlayer[jx][jy] == Feld[x][y])
 208             StorePlayer[jx][jy] = 0;
 209
 210           StorePlayer[x][y] = Feld[x][y];
 211
 212           if (options.verbose)
 213           {
 214             printf("Player %d activated.\n", player->element_nr);
 215             printf("[Local player is %d and currently %s.]\n",
 216                    local_player->element_nr,
 217                    local_player->active ? "active" : "not active");
 218           }
 219         }
 220
 221         Feld[x][y] = EL_LEERRAUM;
 222         player->jx = player->last_jx = x;
 223         player->jy = player->last_jy = y;
 224       }
 225       break;
 226
 227     case EL_BADEWANNE:
 228       if (x < lev_fieldx-1 && Feld[x+1][y] == EL_SALZSAEURE)
 229         Feld[x][y] = EL_BADEWANNE1;
 230       else if (x > 0 && Feld[x-1][y] == EL_SALZSAEURE)
 231         Feld[x][y] = EL_BADEWANNE2;
 232       else if (y > 0 && Feld[x][y-1] == EL_BADEWANNE1)
 233         Feld[x][y] = EL_BADEWANNE3;
 234       else if (y > 0 && Feld[x][y-1] == EL_SALZSAEURE)
 235         Feld[x][y] = EL_BADEWANNE4;
 236       else if (y > 0 && Feld[x][y-1] == EL_BADEWANNE2)
 237         Feld[x][y] = EL_BADEWANNE5;
 238       break;
 239
 240     case EL_KAEFER_R:
 241     case EL_KAEFER_O:
 242     case EL_KAEFER_L:
 243     case EL_KAEFER_U:
 244     case EL_KAEFER:
 245     case EL_FLIEGER_R:
 246     case EL_FLIEGER_O:
 247     case EL_FLIEGER_L:
 248     case EL_FLIEGER_U:
 249     case EL_FLIEGER:
 250     case EL_BUTTERFLY_R:
 251     case EL_BUTTERFLY_O:
 252     case EL_BUTTERFLY_L:
 253     case EL_BUTTERFLY_U:
 254     case EL_BUTTERFLY:
 255     case EL_FIREFLY_R:
 256     case EL_FIREFLY_O:
 257     case EL_FIREFLY_L:
 258     case EL_FIREFLY_U:
 259     case EL_FIREFLY:
 260     case EL_PACMAN_R:
 261     case EL_PACMAN_O:
 262     case EL_PACMAN_L:
 263     case EL_PACMAN_U:
 264     case EL_MAMPFER:
 265     case EL_MAMPFER2:
 266     case EL_ROBOT:
 267     case EL_PACMAN:
 268     case EL_SP_SNIKSNAK:
 269     case EL_SP_ELECTRON:
 270       InitMovDir(x, y);
 271       break;
 272
 273     case EL_AMOEBE_VOLL:
 274     case EL_AMOEBE_BD:
 275       InitAmoebaNr(x, y);
 276       break;
 277
 278     case EL_TROPFEN:
 279       if (y == lev_fieldy - 1)
 280       {
 281         Feld[x][y] = EL_AMOEBING;
 282         Store[x][y] = EL_AMOEBE_NASS;
 283       }
 284       break;
 285
 286     case EL_DYNAMITE_ACTIVE:
 287       MovDelay[x][y] = 96;
 288       break;
 289
 290     case EL_BIRNE_AUS:
 291       local_player->lights_still_needed++;
 292       break;
 293
 294     case EL_SOKOBAN_FELD_LEER:
 295       local_player->sokobanfields_still_needed++;
 296       break;
 297
 298     case EL_MAULWURF:
 299     case EL_PINGUIN:
 300       local_player->friends_still_needed++;
 301       break;
 302
 303     case EL_SCHWEIN:
 304     case EL_DRACHE:
 305       MovDir[x][y] = 1 << RND(4);
 306       break;
 307
 308     case EL_SP_EMPTY:
 309       Feld[x][y] = EL_LEERRAUM;
 310       break;
 311
 312     case EL_EM_KEY_1_FILE:
 313       Feld[x][y] = EL_EM_KEY_1;
 314       break;
 315     case EL_EM_KEY_2_FILE:
 316       Feld[x][y] = EL_EM_KEY_2;
 317       break;
 318     case EL_EM_KEY_3_FILE:
 319       Feld[x][y] = EL_EM_KEY_3;
 320       break;
 321     case EL_EM_KEY_4_FILE:
 322       Feld[x][y] = EL_EM_KEY_4;
 323       break;
 324
 325     default:
 326       break;
 327   }
 328 }
 329
 330 void InitGame()
 331 {
 332   int i, j, x, y;
 333   boolean emulate_bd = TRUE;    /* unless non-BOULDERDASH elements found */
 334   boolean emulate_sb = TRUE;    /* unless non-SOKOBAN     elements found */
 335   boolean emulate_sp = TRUE;    /* unless non-SUPAPLEX    elements found */
 336
 337   /* don't play tapes over network */
 338   network_playing = (options.network && !tape.playing);
 339
 340   for (i=0; i<MAX_PLAYERS; i++)
 341   {
 342     struct PlayerInfo *player = &stored_player[i];
 343
 344     player->index_nr = i;
 345     player->element_nr = EL_SPIELER1 + i;
 346
 347     player->present = FALSE;
 348     player->active = FALSE;
 349
 350     player->action = 0;
 351     player->effective_action = 0;
 352     player->programmed_action = 0;
 353
 354     player->score = 0;
 355     player->gems_still_needed = level.gems_needed;
 356     player->sokobanfields_still_needed = 0;
 357     player->lights_still_needed = 0;
 358     player->friends_still_needed = 0;
 359
 360     for (j=0; j<4; j++)
 361       player->key[j] = FALSE;
 362
 363     player->dynamite = 0;
 364     player->dynabomb_count = 0;
 365     player->dynabomb_size = 1;
 366     player->dynabombs_left = 0;
 367     player->dynabomb_xl = FALSE;
 368
 369     player->MovDir = MV_NO_MOVING;
 370     player->MovPos = 0;
 371     player->Pushing = FALSE;
 372     player->Switching = FALSE;
 373     player->GfxPos = 0;
 374     player->Frame = 0;
 375
 376     player->actual_frame_counter = 0;
 377
 378     player->frame_reset_delay = 0;
 379
 380     player->push_delay = 0;
 381     player->push_delay_value = 5;
 382
 383     player->move_delay = 0;
 384     player->last_move_dir = MV_NO_MOVING;
 385
 386     player->move_delay_value =
 387       (level.double_speed ? MOVE_DELAY_HIGH_SPEED : MOVE_DELAY_NORMAL_SPEED);
 388
 389     player->snapped = FALSE;
 390
 391     player->last_jx = player->last_jy = 0;
 392     player->jx = player->jy = 0;
 393
 394     DigField(player, 0, 0, 0, 0, DF_NO_PUSH);
 395     SnapField(player, 0, 0);
 396
 397     player->LevelSolved = FALSE;
 398     player->GameOver = FALSE;
 399   }
 400
 401   network_player_action_received = FALSE;
 402
 403 #ifndef MSDOS
 404   /* initial null action */
 405   if (network_playing)
 406     SendToServer_MovePlayer(MV_NO_MOVING);
 407 #endif
 408
 409   ZX = ZY = -1;
 410
 411   game.yam_content_nr = 0;
 412   FrameCounter = 0;
 413   TimeFrames = 0;
 414   TimePlayed = 0;
 415   TimeLeft = level.time;
 416
 417   ScreenMovDir = MV_NO_MOVING;
 418   ScreenMovPos = 0;
 419   ScreenGfxPos = 0;
 420
 421   ScrollStepSize = 0;   /* will be correctly initialized by ScrollScreen() */
 422
 423   AllPlayersGone = FALSE;
 424   game.magic_wall_active = FALSE;
 425   game.magic_wall_time_left = 0;
 426   for (i=0; i<4; i++)
 427     game.belt_dir[i] = MV_NO_MOVING;
 428
 429   for (i=0; i<MAX_NUM_AMOEBA; i++)
 430     AmoebaCnt[i] = AmoebaCnt2[i] = 0;
 431
 432   for (x=0; x<lev_fieldx; x++)
 433   {
 434     for (y=0; y<lev_fieldy; y++)
 435     {
 436       Feld[x][y] = Ur[x][y];
 437       MovPos[x][y] = MovDir[x][y] = MovDelay[x][y] = 0;
 438       Store[x][y] = Store2[x][y] = StorePlayer[x][y] = 0;
 439       Frame[x][y] = 0;
 440       AmoebaNr[x][y] = 0;
 441       JustStopped[x][y] = 0;
 442       Stop[x][y] = FALSE;
 443     }
 444   }
 445
 446   for(y=0; y<lev_fieldy; y++)
 447   {
 448     for(x=0; x<lev_fieldx; x++)
 449     {
 450       if (emulate_bd && !IS_BD_ELEMENT(Feld[x][y]))
 451         emulate_bd = FALSE;
 452       if (emulate_sb && !IS_SB_ELEMENT(Feld[x][y]))
 453         emulate_sb = FALSE;
 454       if (emulate_sp && !IS_SP_ELEMENT(Feld[x][y]))
 455         emulate_sp = FALSE;
 456
 457       InitField(x, y, TRUE);
 458     }
 459   }
 460
 461   /* check if any connected player was not found in playfield */
 462   for (i=0; i<MAX_PLAYERS; i++)
 463   {
 464     struct PlayerInfo *player = &stored_player[i];
 465
 466     if (player->connected && !player->present)
 467     {
 468       for (j=0; j<MAX_PLAYERS; j++)
 469       {
 470         struct PlayerInfo *some_player = &stored_player[j];
 471         int jx = some_player->jx, jy = some_player->jy;
 472
 473         /* assign first free player found that is present in the playfield */
 474         if (some_player->present && !some_player->connected)
 475         {
 476           player->present = TRUE;
 477           player->active = TRUE;
 478           some_player->present = FALSE;
 479
 480           StorePlayer[jx][jy] = player->element_nr;
 481           player->jx = player->last_jx = jx;
 482           player->jy = player->last_jy = jy;
 483
 484           break;
 485         }
 486       }
 487     }
 488   }
 489
 490   if (tape.playing)
 491   {
 492     /* when playing a tape, eliminate all players who do not participate */
 493
 494     for (i=0; i<MAX_PLAYERS; i++)
 495     {
 496       if (stored_player[i].active && !tape.player_participates[i])
 497       {
 498         struct PlayerInfo *player = &stored_player[i];
 499         int jx = player->jx, jy = player->jy;
 500
 501         player->active = FALSE;
 502         StorePlayer[jx][jy] = 0;
 503         Feld[jx][jy] = EL_LEERRAUM;
 504       }
 505     }
 506   }
 507   else if (!options.network && !setup.team_mode)        /* && !tape.playing */
 508   {
 509     /* when in single player mode, eliminate all but the first active player */
 510
 511     for (i=0; i<MAX_PLAYERS; i++)
 512     {
 513       if (stored_player[i].active)
 514       {
 515         for (j=i+1; j<MAX_PLAYERS; j++)
 516         {
 517           if (stored_player[j].active)
 518           {
 519             struct PlayerInfo *player = &stored_player[j];
 520             int jx = player->jx, jy = player->jy;
 521
 522             player->active = FALSE;
 523             StorePlayer[jx][jy] = 0;
 524             Feld[jx][jy] = EL_LEERRAUM;
 525           }
 526         }
 527       }
 528     }
 529   }
 530
 531   /* when recording the game, store which players take part in the game */
 532   if (tape.recording)
 533   {
 534     for (i=0; i<MAX_PLAYERS; i++)
 535       if (stored_player[i].active)
 536         tape.player_participates[i] = TRUE;
 537   }
 538
 539   if (options.verbose)
 540   {
 541     for (i=0; i<MAX_PLAYERS; i++)
 542     {
 543       struct PlayerInfo *player = &stored_player[i];
 544
 545       printf("Player %d: present == %d, connected == %d, active == %d.\n",
 546              i+1,
 547              player->present,
 548              player->connected,
 549              player->active);
 550       if (local_player == player)
 551         printf("Player  %d is local player.\n", i+1);
 552     }
 553   }
 554
 555   game.emulation = (emulate_bd ? EMU_BOULDERDASH :
 556                     emulate_sb ? EMU_SOKOBAN :
 557                     emulate_sp ? EMU_SUPAPLEX : EMU_NONE);
 558
 559   if (BorderElement == EL_LEERRAUM)
 560   {
 561     SBX_Left = 0;
 562     SBX_Right = lev_fieldx - SCR_FIELDX;
 563     SBY_Upper = 0;
 564     SBY_Lower = lev_fieldy - SCR_FIELDY;
 565   }
 566   else
 567   {
 568     SBX_Left = -1;
 569     SBX_Right = lev_fieldx - SCR_FIELDX + 1;
 570     SBY_Upper = -1;
 571     SBY_Lower = lev_fieldy - SCR_FIELDY + 1;
 572   }
 573
 574   if (lev_fieldx + (SBX_Left == -1 ? 2 : 0) <= SCR_FIELDX)
 575     SBX_Left = SBX_Right = -1 * (SCR_FIELDX - lev_fieldx) / 2;
 576
 577   if (lev_fieldy + (SBY_Upper == -1 ? 2 : 0) <= SCR_FIELDY)
 578     SBY_Upper = SBY_Lower = -1 * (SCR_FIELDY - lev_fieldy) / 2;
 579
 580   scroll_x = SBX_Left;
 581   scroll_y = SBY_Upper;
 582   if (local_player->jx >= SBX_Left + MIDPOSX)
 583     scroll_x = (local_player->jx <= SBX_Right + MIDPOSX ?
 584                 local_player->jx - MIDPOSX :
 585                 SBX_Right);
 586   if (local_player->jy >= SBY_Upper + MIDPOSY)
 587     scroll_y = (local_player->jy <= SBY_Lower + MIDPOSY ?
 588                 local_player->jy - MIDPOSY :
 589                 SBY_Lower);
 590
 591   CloseDoor(DOOR_CLOSE_1);
 592
 593   DrawLevel();
 594   DrawAllPlayers();
 595   FadeToFront();
 596
 597   if (setup.soft_scrolling)
 598     XCopyArea(display, fieldbuffer, backbuffer, gc,
 599               FX, FY, SXSIZE, SYSIZE, SX, SY);
 600
 601   redraw_mask |= REDRAW_FROM_BACKBUFFER;
 602
 603   /* copy default game door content to main double buffer */
 604   XCopyArea(display, pix[PIX_DOOR], drawto, gc,
 605             DOOR_GFX_PAGEX5, DOOR_GFX_PAGEY1, DXSIZE, DYSIZE, DX, DY);
 606
 607   if (level_nr < 100)
 608     DrawText(DX + XX_LEVEL, DY + YY_LEVEL,
 609              int2str(level_nr, 2), FS_SMALL, FC_YELLOW);
 610   else
 611   {
 612     DrawTextExt(drawto, gc, DX + XX_EMERALDS, DY + YY_EMERALDS,
 613                 int2str(level_nr, 3), FS_SMALL, FC_SPECIAL3);
 614     XCopyArea(display, drawto, drawto, gc,
 615               DX + XX_EMERALDS, DY + YY_EMERALDS + 1,
 616               FONT5_XSIZE * 3, FONT5_YSIZE - 1,
 617               DX + XX_LEVEL - 1, DY + YY_LEVEL + 1);
 618   }
 619
 620   DrawText(DX + XX_EMERALDS, DY + YY_EMERALDS,
 621            int2str(local_player->gems_still_needed, 3), FS_SMALL, FC_YELLOW);
 622   DrawText(DX + XX_DYNAMITE, DY + YY_DYNAMITE,
 623            int2str(local_player->dynamite, 3), FS_SMALL, FC_YELLOW);
 624   DrawText(DX + XX_SCORE, DY + YY_SCORE,
 625            int2str(local_player->score, 5), FS_SMALL, FC_YELLOW);
 626   DrawText(DX + XX_TIME, DY + YY_TIME,
 627            int2str(TimeLeft, 3), FS_SMALL, FC_YELLOW);
 628
 629   UnmapGameButtons();
 630   game_gadget[SOUND_CTRL_ID_MUSIC]->checked = setup.sound_music;
 631   game_gadget[SOUND_CTRL_ID_LOOPS]->checked = setup.sound_loops;
 632   game_gadget[SOUND_CTRL_ID_SIMPLE]->checked = setup.sound_simple;
 633   MapGameButtons();
 634   MapTapeButtons();
 635
 636   /* copy actual game door content to door double buffer for OpenDoor() */
 637   XCopyArea(display, drawto, pix[PIX_DB_DOOR], gc,
 638             DX, DY, DXSIZE, DYSIZE, DOOR_GFX_PAGEX1, DOOR_GFX_PAGEY1);
 639
 640   OpenDoor(DOOR_OPEN_ALL);
 641
 642   if (setup.sound_music)
 643     PlaySoundLoop(background_loop[level_nr % num_bg_loops]);
 644
 645   XAutoRepeatOff(display);
 646
 647   if (options.verbose)
 648   {
 649     for (i=0; i<4; i++)
 650       printf("Player %d %sactive.\n",
 651              i + 1, (stored_player[i].active ? "" : "not "));
 652   }
 653 }
 654
 655 void InitMovDir(int x, int y)
 656 {
 657   int i, element = Feld[x][y];
 658   static int xy[4][2] =
 659   {
 660     {  0, +1 },
 661     { +1,  0 },
 662     {  0, -1 },
 663     { -1,  0 }
 664   };
 665   static int direction[2][4] =
 666   {
 667     { MV_RIGHT, MV_UP,   MV_LEFT,  MV_DOWN },
 668     { MV_LEFT,  MV_DOWN, MV_RIGHT, MV_UP }
 669   };
 670
 671   switch(element)
 672   {
 673     case EL_KAEFER_R:
 674     case EL_KAEFER_O:
 675     case EL_KAEFER_L:
 676     case EL_KAEFER_U:
 677       Feld[x][y] = EL_KAEFER;
 678       MovDir[x][y] = direction[0][element - EL_KAEFER_R];
 679       break;
 680
 681     case EL_FLIEGER_R:
 682     case EL_FLIEGER_O:
 683     case EL_FLIEGER_L:
 684     case EL_FLIEGER_U:
 685       Feld[x][y] = EL_FLIEGER;
 686       MovDir[x][y] = direction[0][element - EL_FLIEGER_R];
 687       break;
 688
 689     case EL_BUTTERFLY_R:
 690     case EL_BUTTERFLY_O:
 691     case EL_BUTTERFLY_L:
 692     case EL_BUTTERFLY_U:
 693       Feld[x][y] = EL_BUTTERFLY;
 694       MovDir[x][y] = direction[0][element - EL_BUTTERFLY_R];
 695       break;
 696
 697     case EL_FIREFLY_R:
 698     case EL_FIREFLY_O:
 699     case EL_FIREFLY_L:
 700     case EL_FIREFLY_U:
 701       Feld[x][y] = EL_FIREFLY;
 702       MovDir[x][y] = direction[0][element - EL_FIREFLY_R];
 703       break;
 704
 705     case EL_PACMAN_R:
 706     case EL_PACMAN_O:
 707     case EL_PACMAN_L:
 708     case EL_PACMAN_U:
 709       Feld[x][y] = EL_PACMAN;
 710       MovDir[x][y] = direction[0][element - EL_PACMAN_R];
 711       break;
 712
 713     case EL_SP_SNIKSNAK:
 714       MovDir[x][y] = MV_UP;
 715       break;
 716
 717     case EL_SP_ELECTRON:
 718       MovDir[x][y] = MV_LEFT;
 719       break;
 720
 721     default:
 722       MovDir[x][y] = 1 << RND(4);
 723       if (element != EL_KAEFER &&
 724           element != EL_FLIEGER &&
 725           element != EL_BUTTERFLY &&
 726           element != EL_FIREFLY)
 727         break;
 728
 729       for (i=0; i<4; i++)
 730       {
 731         int x1 = x + xy[i][0];
 732         int y1 = y + xy[i][1];
 733
 734         if (!IN_LEV_FIELD(x1, y1) || !IS_FREE(x1, y1))
 735         {
 736           if (element == EL_KAEFER || element == EL_BUTTERFLY)
 737           {
 738             MovDir[x][y] = direction[0][i];
 739             break;
 740           }
 741           else if (element == EL_FLIEGER || element == EL_FIREFLY ||
 742                    element == EL_SP_SNIKSNAK || element == EL_SP_ELECTRON)
 743           {
 744             MovDir[x][y] = direction[1][i];
 745             break;
 746           }
 747         }
 748       }
 749       break;
 750   }
 751 }
 752
 753 void InitAmoebaNr(int x, int y)
 754 {
 755   int i;
 756   int group_nr = AmoebeNachbarNr(x, y);
 757
 758   if (group_nr == 0)
 759   {
 760     for (i=1; i<MAX_NUM_AMOEBA; i++)
 761     {
 762       if (AmoebaCnt[i] == 0)
 763       {
 764         group_nr = i;
 765         break;
 766       }
 767     }
 768   }
 769
 770   AmoebaNr[x][y] = group_nr;
 771   AmoebaCnt[group_nr]++;
 772   AmoebaCnt2[group_nr]++;
 773 }
 774
 775 void GameWon()
 776 {
 777   int hi_pos;
 778   int bumplevel = FALSE;
 779
 780   if (local_player->MovPos)
 781     return;
 782
 783   local_player->LevelSolved = FALSE;
 784
 785   if (TimeLeft)
 786   {
 787     if (setup.sound_loops)
 788       PlaySoundExt(SND_SIRR, PSND_MAX_VOLUME, PSND_MAX_RIGHT, PSND_LOOP);
 789
 790     while(TimeLeft > 0)
 791     {
 792       if (!setup.sound_loops)
 793         PlaySoundStereo(SND_SIRR, PSND_MAX_RIGHT);
 794       if (TimeLeft > 0 && !(TimeLeft % 10))
 795         RaiseScore(level.score[SC_ZEITBONUS]);
 796       if (TimeLeft > 100 && !(TimeLeft % 10))
 797         TimeLeft -= 10;
 798       else
 799         TimeLeft--;
 800       DrawText(DX_TIME, DY_TIME, int2str(TimeLeft, 3), FS_SMALL, FC_YELLOW);
 801       BackToFront();
 802       Delay(10);
 803     }
 804
 805     if (setup.sound_loops)
 806       StopSound(SND_SIRR);
 807   }
 808   else if (level.time == 0)             /* level without time limit */
 809   {
 810     if (setup.sound_loops)
 811       PlaySoundExt(SND_SIRR, PSND_MAX_VOLUME, PSND_MAX_RIGHT, PSND_LOOP);
 812
 813     while(TimePlayed < 999)
 814     {
 815       if (!setup.sound_loops)
 816         PlaySoundStereo(SND_SIRR, PSND_MAX_RIGHT);
 817       if (TimePlayed < 999 && !(TimePlayed % 10))
 818         RaiseScore(level.score[SC_ZEITBONUS]);
 819       if (TimePlayed < 900 && !(TimePlayed % 10))
 820         TimePlayed += 10;
 821       else
 822         TimePlayed++;
 823       DrawText(DX_TIME, DY_TIME, int2str(TimePlayed, 3), FS_SMALL, FC_YELLOW);
 824       BackToFront();
 825       Delay(10);
 826     }
 827
 828     if (setup.sound_loops)
 829       StopSound(SND_SIRR);
 830   }
 831
 832   FadeSounds();
 833
 834   /* Hero disappears */
 835   DrawLevelField(ExitX, ExitY);
 836   BackToFront();
 837
 838   if (tape.playing)
 839     return;
 840
 841   CloseDoor(DOOR_CLOSE_1);
 842
 843   if (tape.recording)
 844   {
 845     TapeStop();
 846     SaveTape(tape.level_nr);            /* Ask to save tape */
 847   }
 848
 849   if ((hi_pos = NewHiScore()) >= 0)
 850   {
 851     game_status = HALLOFFAME;
 852     DrawHallOfFame(hi_pos);
 853     if (bumplevel && TAPE_IS_EMPTY(tape))
 854       level_nr++;
 855   }
 856   else
 857   {
 858     game_status = MAINMENU;
 859     if (bumplevel && TAPE_IS_EMPTY(tape))
 860       level_nr++;
 861     DrawMainMenu();
 862   }
 863
 864   BackToFront();
 865 }
 866
 867 int NewHiScore()
 868 {
 869   int k, l;
 870   int position = -1;
 871
 872   LoadScore(level_nr);
 873
 874   if (strcmp(setup.player_name, EMPTY_PLAYER_NAME) == 0 ||
 875       local_player->score < highscore[MAX_SCORE_ENTRIES - 1].Score)
 876     return -1;
 877
 878   for (k=0; k<MAX_SCORE_ENTRIES; k++)
 879   {
 880     if (local_player->score > highscore[k].Score)
 881     {
 882       /* player has made it to the hall of fame */
 883
 884       if (k < MAX_SCORE_ENTRIES - 1)
 885       {
 886         int m = MAX_SCORE_ENTRIES - 1;
 887
 888 #ifdef ONE_PER_NAME
 889         for (l=k; l<MAX_SCORE_ENTRIES; l++)
 890           if (!strcmp(setup.player_name, highscore[l].Name))
 891             m = l;
 892         if (m == k)     /* player's new highscore overwrites his old one */
 893           goto put_into_list;
 894 #endif
 895
 896         for (l=m; l>k; l--)
 897         {
 898           strcpy(highscore[l].Name, highscore[l - 1].Name);
 899           highscore[l].Score = highscore[l - 1].Score;
 900         }
 901       }
 902
 903 #ifdef ONE_PER_NAME
 904       put_into_list:
 905 #endif
 906       strncpy(highscore[k].Name, setup.player_name, MAX_PLAYER_NAME_LEN);
 907       highscore[k].Name[MAX_PLAYER_NAME_LEN] = '\0';
 908       highscore[k].Score = local_player->score;
 909       position = k;
 910       break;
 911     }
 912
 913 #ifdef ONE_PER_NAME
 914     else if (!strncmp(setup.player_name, highscore[k].Name,
 915                       MAX_PLAYER_NAME_LEN))
 916       break;    /* player already there with a higher score */
 917 #endif
 918
 919   }
 920
 921   if (position >= 0)
 922     SaveScore(level_nr);
 923
 924   return position;
 925 }
 926
 927 void InitMovingField(int x, int y, int direction)
 928 {
 929   int newx = x + (direction == MV_LEFT ? -1 : direction == MV_RIGHT ? +1 : 0);
 930   int newy = y + (direction == MV_UP   ? -1 : direction == MV_DOWN  ? +1 : 0);
 931
 932   MovDir[x][y] = direction;
 933   MovDir[newx][newy] = direction;
 934   if (Feld[newx][newy] == EL_LEERRAUM)
 935     Feld[newx][newy] = EL_BLOCKED;
 936 }
 937
 938 void Moving2Blocked(int x, int y, int *goes_to_x, int *goes_to_y)
 939 {
 940   int direction = MovDir[x][y];
 941   int newx = x + (direction == MV_LEFT ? -1 : direction == MV_RIGHT ? +1 : 0);
 942   int newy = y + (direction == MV_UP   ? -1 : direction == MV_DOWN  ? +1 : 0);
 943
 944   *goes_to_x = newx;
 945   *goes_to_y = newy;
 946 }
 947
 948 void Blocked2Moving(int x, int y, int *comes_from_x, int *comes_from_y)
 949 {
 950   int oldx = x, oldy = y;
 951   int direction = MovDir[x][y];
 952
 953   if (direction == MV_LEFT)
 954     oldx++;
 955   else if (direction == MV_RIGHT)
 956     oldx--;
 957   else if (direction == MV_UP)
 958     oldy++;
 959   else if (direction == MV_DOWN)
 960     oldy--;
 961
 962   *comes_from_x = oldx;
 963   *comes_from_y = oldy;
 964 }
 965
 966 int MovingOrBlocked2Element(int x, int y)
 967 {
 968   int element = Feld[x][y];
 969
 970   if (element == EL_BLOCKED)
 971   {
 972     int oldx, oldy;
 973
 974     Blocked2Moving(x, y, &oldx, &oldy);
 975     return Feld[oldx][oldy];
 976   }
 977   else
 978     return element;
 979 }
 980
 981 static int MovingOrBlocked2ElementIfNotLeaving(int x, int y)
 982 {
 983   /* like MovingOrBlocked2Element(), but if element is moving
 984      and (x,y) is the field the moving element is just leaving,
 985      return EL_BLOCKED instead of the element value */
 986   int element = Feld[x][y];
 987
 988   if (IS_MOVING(x, y))
 989   {
 990     if (element == EL_BLOCKED)
 991     {
 992       int oldx, oldy;
 993
 994       Blocked2Moving(x, y, &oldx, &oldy);
 995       return Feld[oldx][oldy];
 996     }
 997     else
 998       return EL_BLOCKED;
 999   }
1000   else
1001     return element;
1002 }
1003
1004 static void RemoveField(int x, int y)
1005 {
1006   Feld[x][y] = EL_LEERRAUM;
1007   MovPos[x][y] = 0;
1008   MovDir[x][y] = 0;
1009   MovDelay[x][y] = 0;
1010 }
1011
1012 void RemoveMovingField(int x, int y)
1013 {
1014   int oldx = x, oldy = y, newx = x, newy = y;
1015
1016   if (Feld[x][y] != EL_BLOCKED && !IS_MOVING(x, y))
1017     return;
1018
1019   if (IS_MOVING(x, y))
1020   {
1021     Moving2Blocked(x, y, &newx, &newy);
1022     if (Feld[newx][newy] != EL_BLOCKED)
1023       return;
1024   }
1025   else if (Feld[x][y] == EL_BLOCKED)
1026   {
1027     Blocked2Moving(x, y, &oldx, &oldy);
1028     if (!IS_MOVING(oldx, oldy))
1029       return;
1030   }
1031
1032   if (Feld[x][y] == EL_BLOCKED &&
1033       (Store[oldx][oldy] == EL_MORAST_LEER ||
1034        Store[oldx][oldy] == EL_SIEB_LEER ||
1035        Store[oldx][oldy] == EL_SIEB2_LEER ||
1036        Store[oldx][oldy] == EL_AMOEBE_NASS))
1037   {
1038     Feld[oldx][oldy] = Store[oldx][oldy];
1039     Store[oldx][oldy] = Store2[oldx][oldy] = 0;
1040   }
1041   else
1042     Feld[oldx][oldy] = EL_LEERRAUM;
1043
1044   Feld[newx][newy] = EL_LEERRAUM;
1045   MovPos[oldx][oldy] = MovDir[oldx][oldy] = MovDelay[oldx][oldy] = 0;
1046   MovPos[newx][newy] = MovDir[newx][newy] = MovDelay[newx][newy] = 0;
1047
1048   DrawLevelField(oldx, oldy);
1049   DrawLevelField(newx, newy);
1050 }
1051
1052 void DrawDynamite(int x, int y)
1053 {
1054   int sx = SCREENX(x), sy = SCREENY(y);
1055   int graphic = el2gfx(Feld[x][y]);
1056   int phase;
1057
1058   if (!IN_SCR_FIELD(sx, sy) || IS_PLAYER(x, y))
1059     return;
1060
1061   if (Store[x][y])
1062     DrawGraphic(sx, sy, el2gfx(Store[x][y]));
1063
1064   if (Feld[x][y] == EL_DYNAMITE_ACTIVE)
1065   {
1066     if ((phase = (96 - MovDelay[x][y]) / 12) > 6)
1067       phase = 6;
1068   }
1069   else
1070   {
1071     if ((phase = ((96 - MovDelay[x][y]) / 6) % 8) > 3)
1072       phase = 7 - phase;
1073   }
1074
1075   if (game.emulation == EMU_SUPAPLEX)
1076     DrawGraphic(sx, sy, GFX_SP_DISK_RED);
1077   else if (Store[x][y])
1078     DrawGraphicThruMask(sx, sy, graphic + phase);
1079   else
1080     DrawGraphic(sx, sy, graphic + phase);
1081 }
1082
1083 void CheckDynamite(int x, int y)
1084 {
1085   if (MovDelay[x][y])           /* dynamite is still waiting to explode */
1086   {
1087     MovDelay[x][y]--;
1088     if (MovDelay[x][y])
1089     {
1090       if (!(MovDelay[x][y] % 12))
1091         PlaySoundLevel(x, y, SND_ZISCH);
1092
1093       if (IS_ACTIVE_BOMB(Feld[x][y]))
1094       {
1095         int delay = (Feld[x][y] == EL_DYNAMITE_ACTIVE ? 12 : 6);
1096
1097         if (!(MovDelay[x][y] % delay))
1098           DrawDynamite(x, y);
1099       }
1100
1101       return;
1102     }
1103   }
1104
1105   StopSound(SND_ZISCH);
1106   Bang(x, y);
1107 }
1108
1109 void Explode(int ex, int ey, int phase, int mode)
1110 {
1111   int x, y;
1112   int num_phase = 9, delay = 2;
1113   int last_phase = num_phase * delay;
1114   int half_phase = (num_phase / 2) * delay;
1115   int first_phase_after_start = EX_PHASE_START + 1;
1116
1117   if (phase == EX_PHASE_START)          /* initialize 'Store[][]' field */
1118   {
1119     int center_element = Feld[ex][ey];
1120
1121     if (IS_MOVING(ex, ey) || IS_BLOCKED(ex, ey))
1122     {
1123       /* put moving element to center field (and let it explode there) */
1124       center_element = MovingOrBlocked2Element(ex, ey);
1125       RemoveMovingField(ex, ey);
1126       Feld[ex][ey] = center_element;
1127     }
1128
1129     for (y=ey-1; y<=ey+1; y++) for(x=ex-1; x<=ex+1; x++)
1130     {
1131       int element;
1132
1133       if (!IN_LEV_FIELD(x, y) ||
1134           ((mode != EX_NORMAL || center_element == EL_AMOEBA2DIAM) &&
1135            (x != ex || y != ey)))
1136         continue;
1137
1138       element = Feld[x][y];
1139
1140       if (IS_MOVING(x, y) || IS_BLOCKED(x, y))
1141       {
1142         element = MovingOrBlocked2Element(x, y);
1143         RemoveMovingField(x, y);
1144       }
1145
1146       if (IS_MASSIVE(element) || element == EL_BURNING)
1147         continue;
1148
1149       if (element == EL_EXPLODING)
1150         element = Store2[x][y];
1151
1152       if (IS_PLAYER(ex, ey))
1153       {
1154         switch(StorePlayer[ex][ey])
1155         {
1156           case EL_SPIELER2:
1157             Store[x][y] = EL_EDELSTEIN_ROT;
1158             break;
1159           case EL_SPIELER3:
1160             Store[x][y] = EL_EDELSTEIN;
1161             break;
1162           case EL_SPIELER4:
1163             Store[x][y] = EL_EDELSTEIN_LILA;
1164             break;
1165           case EL_SPIELER1:
1166           default:
1167             Store[x][y] = EL_EDELSTEIN_GELB;
1168             break;
1169         }
1170
1171         if (game.emulation == EMU_SUPAPLEX)
1172           Store[x][y] = EL_LEERRAUM;
1173       }
1174       else if (center_element == EL_MAULWURF)
1175         Store[x][y] = EL_EDELSTEIN_ROT;
1176       else if (center_element == EL_PINGUIN)
1177         Store[x][y] = EL_EDELSTEIN_LILA;
1178       else if (center_element == EL_KAEFER)
1179         Store[x][y] = ((x == ex && y == ey) ? EL_DIAMANT : EL_EDELSTEIN);
1180       else if (center_element == EL_BUTTERFLY)
1181         Store[x][y] = EL_EDELSTEIN_BD;
1182       else if (center_element == EL_SP_ELECTRON)
1183         Store[x][y] = EL_SP_INFOTRON;
1184       else if (center_element == EL_MAMPFER)
1185         Store[x][y] = level.yam_content[game.yam_content_nr][x-ex+1][y-ey+1];
1186       else if (center_element == EL_AMOEBA2DIAM)
1187         Store[x][y] = level.amoeba_content;
1188       else if (element == EL_ERZ_EDEL)
1189         Store[x][y] = EL_EDELSTEIN;
1190       else if (element == EL_ERZ_DIAM)
1191         Store[x][y] = EL_DIAMANT;
1192       else if (element == EL_ERZ_EDEL_BD)
1193         Store[x][y] = EL_EDELSTEIN_BD;
1194       else if (element == EL_ERZ_EDEL_GELB)
1195         Store[x][y] = EL_EDELSTEIN_GELB;
1196       else if (element == EL_ERZ_EDEL_ROT)
1197         Store[x][y] = EL_EDELSTEIN_ROT;
1198       else if (element == EL_ERZ_EDEL_LILA)
1199         Store[x][y] = EL_EDELSTEIN_LILA;
1200       else if (!IS_PFORTE(Store[x][y]))
1201         Store[x][y] = EL_LEERRAUM;
1202
1203       if (x != ex || y != ey ||
1204           center_element == EL_AMOEBA2DIAM || mode == EX_BORDER)
1205         Store2[x][y] = element;
1206
1207       if (AmoebaNr[x][y] &&
1208           (element == EL_AMOEBE_VOLL ||
1209            element == EL_AMOEBE_BD ||
1210            element == EL_AMOEBING))
1211       {
1212         AmoebaCnt[AmoebaNr[x][y]]--;
1213         AmoebaCnt2[AmoebaNr[x][y]]--;
1214       }
1215
1216       Feld[x][y] = EL_EXPLODING;
1217       MovDir[x][y] = MovPos[x][y] = 0;
1218       AmoebaNr[x][y] = 0;
1219       Frame[x][y] = 1;
1220       Stop[x][y] = TRUE;
1221     }
1222
1223     if (center_element == EL_MAMPFER)
1224       game.yam_content_nr = (game.yam_content_nr + 1) % level.num_yam_contents;
1225
1226     return;
1227   }
1228
1229   if (Stop[ex][ey])
1230     return;
1231
1232   x = ex;
1233   y = ey;
1234
1235   Frame[x][y] = (phase < last_phase ? phase + 1 : 0);
1236
1237   if (phase == first_phase_after_start)
1238   {
1239     int element = Store2[x][y];
1240
1241     if (element == EL_BLACK_ORB)
1242     {
1243       Feld[x][y] = Store2[x][y];
1244       Store2[x][y] = 0;
1245       Bang(x, y);
1246     }
1247   }
1248   else if (phase == half_phase)
1249   {
1250     int element = Store2[x][y];
1251
1252     if (IS_PLAYER(x, y))
1253       KillHero(PLAYERINFO(x, y));
1254     else if (IS_EXPLOSIVE(element))
1255     {
1256       Feld[x][y] = Store2[x][y];
1257       Store2[x][y] = 0;
1258       Bang(x, y);
1259     }
1260     else if (element == EL_AMOEBA2DIAM)
1261       AmoebeUmwandeln(x, y);
1262   }
1263
1264   if (phase == last_phase)
1265   {
1266     int element;
1267
1268     element = Feld[x][y] = Store[x][y];
1269     Store[x][y] = Store2[x][y] = 0;
1270     MovDir[x][y] = MovPos[x][y] = MovDelay[x][y] = 0;
1271     InitField(x, y, FALSE);
1272     if (CAN_MOVE(element) || COULD_MOVE(element))
1273       InitMovDir(x, y);
1274     DrawLevelField(x, y);
1275   }
1276   else if (!(phase % delay) && IN_SCR_FIELD(SCREENX(x), SCREENY(y)))
1277   {
1278     int graphic = GFX_EXPLOSION;
1279
1280     if (game.emulation == EMU_SUPAPLEX)
1281       graphic = (Store[x][y] == EL_SP_INFOTRON ?
1282                  GFX_SP_EXPLODE_INFOTRON :
1283                  GFX_SP_EXPLODE_EMPTY);
1284
1285     if (phase == delay)
1286       ErdreichAnbroeckeln(SCREENX(x), SCREENY(y));
1287
1288     DrawGraphic(SCREENX(x), SCREENY(y), graphic + (phase / delay - 1));
1289   }
1290 }
1291
1292 void DynaExplode(int ex, int ey)
1293 {
1294   int i, j;
1295   int dynabomb_size = 1;
1296   boolean dynabomb_xl = FALSE;
1297   struct PlayerInfo *player;
1298   static int xy[4][2] =
1299   {
1300     { 0, -1 },
1301     { -1, 0 },
1302     { +1, 0 },
1303     { 0, +1 }
1304   };
1305
1306   if (IS_ACTIVE_BOMB(Feld[ex][ey]))
1307   {
1308     player = &stored_player[Feld[ex][ey] - EL_DYNABOMB_ACTIVE_1];
1309     dynabomb_size = player->dynabomb_size;
1310     dynabomb_xl = player->dynabomb_xl;
1311     player->dynabombs_left++;
1312   }
1313
1314   Explode(ex, ey, EX_PHASE_START, EX_CENTER);
1315
1316   for (i=0; i<4; i++)
1317   {
1318     for (j=1; j<=dynabomb_size; j++)
1319     {
1320       int x = ex + j * xy[i % 4][0];
1321       int y = ey + j * xy[i % 4][1];
1322       int element;
1323
1324       if (!IN_LEV_FIELD(x, y) || IS_MASSIVE(Feld[x][y]))
1325         break;
1326
1327       element = Feld[x][y];
1328
1329       /* do not restart explosions of fields with active bombs */
1330       if (element == EL_EXPLODING && IS_ACTIVE_BOMB(Store2[x][y]))
1331         continue;
1332
1333       Explode(x, y, EX_PHASE_START, EX_BORDER);
1334
1335       if (element != EL_LEERRAUM &&
1336           element != EL_ERDREICH &&
1337           element != EL_EXPLODING &&
1338           !dynabomb_xl)
1339         break;
1340     }
1341   }
1342 }
1343
1344 void Bang(int x, int y)
1345 {
1346   int element = Feld[x][y];
1347
1348   if (game.emulation == EMU_SUPAPLEX)
1349     PlaySoundLevel(x, y, SND_SP_BOOOM);
1350   else
1351     PlaySoundLevel(x, y, SND_ROAAAR);
1352
1353   if (IS_PLAYER(x, y))  /* remove objects that might cause smaller explosion */
1354     element = EL_LEERRAUM;
1355
1356   switch(element)
1357   {
1358     case EL_KAEFER:
1359     case EL_FLIEGER:
1360     case EL_BUTTERFLY:
1361     case EL_FIREFLY:
1362     case EL_MAMPFER:
1363     case EL_MAMPFER2:
1364     case EL_ROBOT:
1365     case EL_PACMAN:
1366       RaiseScoreElement(element);
1367       Explode(x, y, EX_PHASE_START, EX_NORMAL);
1368       break;
1369     case EL_DYNABOMB_ACTIVE_1:
1370     case EL_DYNABOMB_ACTIVE_2:
1371     case EL_DYNABOMB_ACTIVE_3:
1372     case EL_DYNABOMB_ACTIVE_4:
1373     case EL_DYNABOMB_NR:
1374     case EL_DYNABOMB_SZ:
1375     case EL_DYNABOMB_XL:
1376       DynaExplode(x, y);
1377       break;
1378     case EL_MAULWURF:
1379     case EL_PINGUIN:
1380     case EL_BIRNE_AUS:
1381     case EL_BIRNE_EIN:
1382       Explode(x, y, EX_PHASE_START, EX_CENTER);
1383       break;
1384     default:
1385       Explode(x, y, EX_PHASE_START, EX_NORMAL);
1386       break;
1387   }
1388 }
1389
1390 void Blurb(int x, int y)
1391 {
1392   int element = Feld[x][y];
1393
1394   if (element != EL_BLURB_LEFT && element != EL_BLURB_RIGHT)    /* start */
1395   {
1396     PlaySoundLevel(x, y, SND_BLURB);
1397     if (IN_LEV_FIELD(x-1, y) && IS_FREE(x-1, y) &&
1398         (!IN_LEV_FIELD(x-1, y-1) ||
1399          !CAN_FALL(MovingOrBlocked2Element(x-1, y-1))))
1400     {
1401       Feld[x-1][y] = EL_BLURB_LEFT;
1402     }
1403     if (IN_LEV_FIELD(x+1, y) && IS_FREE(x+1, y) &&
1404         (!IN_LEV_FIELD(x+1, y-1) ||
1405          !CAN_FALL(MovingOrBlocked2Element(x+1, y-1))))
1406     {
1407       Feld[x+1][y] = EL_BLURB_RIGHT;
1408     }
1409   }
1410   else                                                          /* go on */
1411   {
1412     int graphic = (element==EL_BLURB_LEFT ? GFX_BLURB_LEFT : GFX_BLURB_RIGHT);
1413
1414     if (!MovDelay[x][y])        /* initialize animation counter */
1415       MovDelay[x][y] = 9;
1416
1417     if (MovDelay[x][y])         /* continue animation */
1418     {
1419       MovDelay[x][y]--;
1420       if (MovDelay[x][y]/2 && IN_SCR_FIELD(SCREENX(x), SCREENY(y)))
1421         DrawGraphic(SCREENX(x), SCREENY(y), graphic+4-MovDelay[x][y]/2);
1422
1423       if (!MovDelay[x][y])
1424       {
1425         Feld[x][y] = EL_LEERRAUM;
1426         DrawLevelField(x, y);
1427       }
1428     }
1429   }
1430 }
1431
1432 void Impact(int x, int y)
1433 {
1434   boolean lastline = (y == lev_fieldy-1);
1435   boolean object_hit = FALSE;
1436   int element = Feld[x][y];
1437   int smashed = 0;
1438
1439   if (!lastline)        /* check if element below was hit */
1440   {
1441     if (Feld[x][y+1] == EL_PLAYER_IS_LEAVING)
1442       return;
1443
1444     object_hit = (!IS_FREE(x, y+1) && (!IS_MOVING(x, y+1) ||
1445                                       MovDir[x][y+1]!=MV_DOWN ||
1446                                       MovPos[x][y+1]<=TILEY/2));
1447     if (object_hit)
1448       smashed = MovingOrBlocked2Element(x, y+1);
1449   }
1450
1451   if (!lastline && smashed == EL_SALZSAEURE)    /* element falls into acid */
1452   {
1453     Blurb(x, y);
1454     return;
1455   }
1456
1457   if ((element == EL_BOMBE || element == EL_SP_DISK_ORANGE) &&
1458       (lastline || object_hit)) /* element is bomb */
1459   {
1460     Bang(x, y);
1461     return;
1462   }
1463
1464   if (element == EL_TROPFEN && (lastline || object_hit))        /* acid drop */
1465   {
1466     if (object_hit && IS_PLAYER(x, y+1))
1467       KillHero(PLAYERINFO(x, y+1));
1468     else if (object_hit && (smashed == EL_MAULWURF || smashed == EL_PINGUIN))
1469       Bang(x, y+1);
1470     else
1471     {
1472       Feld[x][y] = EL_AMOEBING;
1473       Store[x][y] = EL_AMOEBE_NASS;
1474     }
1475     return;
1476   }
1477
1478   if (!lastline && object_hit)          /* check which object was hit */
1479   {
1480     if (CAN_CHANGE(element) &&
1481         (smashed == EL_SIEB_INAKTIV || smashed == EL_SIEB2_INAKTIV))
1482     {
1483       int x, y;
1484       int activated_magic_wall =
1485         (smashed == EL_SIEB_INAKTIV ? EL_SIEB_LEER : EL_SIEB2_LEER);
1486
1487       /* activate magic wall / mill */
1488
1489       for (y=0; y<lev_fieldy; y++)
1490         for (x=0; x<lev_fieldx; x++)
1491           if (Feld[x][y] == smashed)
1492             Feld[x][y] = activated_magic_wall;
1493
1494       game.magic_wall_time_left = level.time_magic_wall * FRAMES_PER_SECOND;
1495       game.magic_wall_active = TRUE;
1496     }
1497
1498     if (IS_PLAYER(x, y+1))
1499     {
1500       KillHero(PLAYERINFO(x, y+1));
1501       return;
1502     }
1503     else if (smashed == EL_MAULWURF || smashed == EL_PINGUIN)
1504     {
1505       Bang(x, y+1);
1506       return;
1507     }
1508     else if (element == EL_EDELSTEIN_BD)
1509     {
1510       if (IS_ENEMY(smashed) && IS_BD_ELEMENT(smashed))
1511       {
1512         Bang(x, y+1);
1513         return;
1514       }
1515     }
1516     else if (element == EL_FELSBROCKEN || element == EL_SP_ZONK)
1517     {
1518       if (IS_ENEMY(smashed) ||
1519           smashed == EL_BOMBE || smashed == EL_SP_DISK_ORANGE ||
1520           smashed == EL_SONDE || smashed == EL_SCHWEIN || smashed == EL_DRACHE)
1521       {
1522         Bang(x, y+1);
1523         return;
1524       }
1525       else if (!IS_MOVING(x, y+1))
1526       {
1527         if (smashed == EL_BIRNE_AUS || smashed == EL_BIRNE_EIN)
1528         {
1529           Bang(x, y+1);
1530           return;
1531         }
1532         else if (smashed == EL_KOKOSNUSS)
1533         {
1534           Feld[x][y+1] = EL_CRACKINGNUT;
1535           PlaySoundLevel(x, y, SND_KNACK);
1536           RaiseScoreElement(EL_KOKOSNUSS);
1537           return;
1538         }
1539         else if (smashed == EL_DIAMANT)
1540         {
1541           Feld[x][y+1] = EL_LEERRAUM;
1542           PlaySoundLevel(x, y, SND_QUIRK);
1543           return;
1544         }
1545       }
1546     }
1547   }
1548
1549   /* play sound of magic wall / mill */
1550   if (!lastline &&
1551       (Feld[x][y+1] == EL_SIEB_LEER || Feld[x][y+1] == EL_SIEB2_LEER))
1552   {
1553     PlaySoundLevel(x, y, SND_QUIRK);
1554     return;
1555   }
1556
1557   /* play sound of object that hits the ground */
1558   if (lastline || object_hit)
1559   {
1560     int sound;
1561
1562     switch(element)
1563     {
1564       case EL_EDELSTEIN:
1565       case EL_EDELSTEIN_BD:
1566       case EL_EDELSTEIN_GELB:
1567       case EL_EDELSTEIN_ROT:
1568       case EL_EDELSTEIN_LILA:
1569       case EL_DIAMANT:
1570       case EL_SP_INFOTRON:
1571         sound = SND_PLING;
1572         break;
1573       case EL_KOKOSNUSS:
1574         sound = SND_KLUMPF;
1575         break;
1576       case EL_FELSBROCKEN:
1577         sound = SND_KLOPF;
1578         break;
1579       case EL_SP_ZONK:
1580         sound = SND_SP_ZONKDOWN;
1581         break;
1582       case EL_SCHLUESSEL:
1583       case EL_SCHLUESSEL1:
1584       case EL_SCHLUESSEL2:
1585       case EL_SCHLUESSEL3:
1586       case EL_SCHLUESSEL4:
1587       case EL_EM_KEY_1:
1588       case EL_EM_KEY_2:
1589       case EL_EM_KEY_3:
1590       case EL_EM_KEY_4:
1591         sound = SND_KINK;
1592         break;
1593       case EL_ZEIT_VOLL:
1594       case EL_ZEIT_LEER:
1595         sound = SND_DENG;
1596         break;
1597       default:
1598         sound = -1;
1599         break;
1600     }
1601
1602     if (sound>=0)
1603       PlaySoundLevel(x, y, sound);
1604   }
1605 }
1606
1607 void TurnRound(int x, int y)
1608 {
1609   static struct
1610   {
1611     int x, y;
1612   } move_xy[] =
1613   {
1614     { 0, 0 },
1615     {-1, 0 },
1616     {+1, 0 },
1617     { 0, 0 },
1618     { 0, -1 },
1619     { 0, 0 }, { 0, 0 }, { 0, 0 },
1620     { 0, +1 }
1621   };
1622   static struct
1623   {
1624     int left, right, back;
1625   } turn[] =
1626   {
1627     { 0,        0,              0 },
1628     { MV_DOWN,  MV_UP,          MV_RIGHT },
1629     { MV_UP,    MV_DOWN,        MV_LEFT },
1630     { 0,        0,              0 },
1631     { MV_LEFT,  MV_RIGHT,       MV_DOWN },
1632     { 0,0,0 },  { 0,0,0 },      { 0,0,0 },
1633     { MV_RIGHT, MV_LEFT,        MV_UP }
1634   };
1635
1636   int element = Feld[x][y];
1637   int old_move_dir = MovDir[x][y];
1638   int left_dir = turn[old_move_dir].left;
1639   int right_dir = turn[old_move_dir].right;
1640   int back_dir = turn[old_move_dir].back;
1641
1642   int left_dx = move_xy[left_dir].x, left_dy = move_xy[left_dir].y;
1643   int right_dx = move_xy[right_dir].x, right_dy = move_xy[right_dir].y;
1644   int move_dx = move_xy[old_move_dir].x, move_dy = move_xy[old_move_dir].y;
1645   int back_dx = move_xy[back_dir].x, back_dy = move_xy[back_dir].y;
1646
1647   int left_x = x+left_dx, left_y = y+left_dy;
1648   int right_x = x+right_dx, right_y = y+right_dy;
1649   int move_x = x+move_dx, move_y = y+move_dy;
1650
1651   if (element == EL_KAEFER || element == EL_BUTTERFLY)
1652   {
1653     TestIfBadThingHitsOtherBadThing(x, y);
1654
1655     if (IN_LEV_FIELD(right_x, right_y) &&
1656         IS_FREE_OR_PLAYER(right_x, right_y))
1657       MovDir[x][y] = right_dir;
1658     else if (!IN_LEV_FIELD(move_x, move_y) ||
1659              !IS_FREE_OR_PLAYER(move_x, move_y))
1660       MovDir[x][y] = left_dir;
1661
1662     if (element == EL_KAEFER && MovDir[x][y] != old_move_dir)
1663       MovDelay[x][y] = 9;
1664     else if (element == EL_BUTTERFLY)   /* && MovDir[x][y] == left_dir) */
1665       MovDelay[x][y] = 1;
1666   }
1667   else if (element == EL_FLIEGER || element == EL_FIREFLY ||
1668            element == EL_SP_SNIKSNAK || element == EL_SP_ELECTRON)
1669   {
1670     TestIfBadThingHitsOtherBadThing(x, y);
1671
1672     if (IN_LEV_FIELD(left_x, left_y) &&
1673         IS_FREE_OR_PLAYER(left_x, left_y))
1674       MovDir[x][y] = left_dir;
1675     else if (!IN_LEV_FIELD(move_x, move_y) ||
1676              !IS_FREE_OR_PLAYER(move_x, move_y))
1677       MovDir[x][y] = right_dir;
1678
1679     if ((element == EL_FLIEGER ||
1680          element == EL_SP_SNIKSNAK || element == EL_SP_ELECTRON)
1681         && MovDir[x][y] != old_move_dir)
1682       MovDelay[x][y] = 9;
1683     else if (element == EL_FIREFLY)     /* && MovDir[x][y] == right_dir) */
1684       MovDelay[x][y] = 1;
1685   }
1686   else if (element == EL_MAMPFER)
1687   {
1688     boolean can_turn_left = FALSE, can_turn_right = FALSE;
1689
1690     if (IN_LEV_FIELD(left_x, left_y) &&
1691         (IS_FREE_OR_PLAYER(left_x, left_y) ||
1692          Feld[left_x][left_y] == EL_DIAMANT))
1693       can_turn_left = TRUE;
1694     if (IN_LEV_FIELD(right_x, right_y) &&
1695         (IS_FREE_OR_PLAYER(right_x, right_y) ||
1696          Feld[right_x][right_y] == EL_DIAMANT))
1697       can_turn_right = TRUE;
1698
1699     if (can_turn_left && can_turn_right)
1700       MovDir[x][y] = (RND(3) ? (RND(2) ? left_dir : right_dir) : back_dir);
1701     else if (can_turn_left)
1702       MovDir[x][y] = (RND(2) ? left_dir : back_dir);
1703     else if (can_turn_right)
1704       MovDir[x][y] = (RND(2) ? right_dir : back_dir);
1705     else
1706       MovDir[x][y] = back_dir;
1707
1708     MovDelay[x][y] = 16+16*RND(3);
1709   }
1710   else if (element == EL_MAMPFER2)
1711   {
1712     boolean can_turn_left = FALSE, can_turn_right = FALSE;
1713
1714     if (IN_LEV_FIELD(left_x, left_y) &&
1715         (IS_FREE_OR_PLAYER(left_x, left_y) ||
1716          IS_MAMPF2(Feld[left_x][left_y])))
1717       can_turn_left = TRUE;
1718     if (IN_LEV_FIELD(right_x, right_y) &&
1719         (IS_FREE_OR_PLAYER(right_x, right_y) ||
1720          IS_MAMPF2(Feld[right_x][right_y])))
1721       can_turn_right = TRUE;
1722
1723     if (can_turn_left && can_turn_right)
1724       MovDir[x][y] = (RND(3) ? (RND(2) ? left_dir : right_dir) : back_dir);
1725     else if (can_turn_left)
1726       MovDir[x][y] = (RND(2) ? left_dir : back_dir);
1727     else if (can_turn_right)
1728       MovDir[x][y] = (RND(2) ? right_dir : back_dir);
1729     else
1730       MovDir[x][y] = back_dir;
1731
1732     MovDelay[x][y] = 16+16*RND(3);
1733   }
1734   else if (element == EL_PACMAN)
1735   {
1736     boolean can_turn_left = FALSE, can_turn_right = FALSE;
1737
1738     if (IN_LEV_FIELD(left_x, left_y) &&
1739         (IS_FREE_OR_PLAYER(left_x, left_y) ||
1740          IS_AMOEBOID(Feld[left_x][left_y])))
1741       can_turn_left = TRUE;
1742     if (IN_LEV_FIELD(right_x, right_y) &&
1743         (IS_FREE_OR_PLAYER(right_x, right_y) ||
1744          IS_AMOEBOID(Feld[right_x][right_y])))
1745       can_turn_right = TRUE;
1746
1747     if (can_turn_left && can_turn_right)
1748       MovDir[x][y] = (RND(3) ? (RND(2) ? left_dir : right_dir) : back_dir);
1749     else if (can_turn_left)
1750       MovDir[x][y] = (RND(2) ? left_dir : back_dir);
1751     else if (can_turn_right)
1752       MovDir[x][y] = (RND(2) ? right_dir : back_dir);
1753     else
1754       MovDir[x][y] = back_dir;
1755
1756     MovDelay[x][y] = 6+RND(40);
1757   }
1758   else if (element == EL_SCHWEIN)
1759   {
1760     boolean can_turn_left = FALSE, can_turn_right = FALSE, can_move_on = FALSE;
1761     boolean should_turn_left = FALSE, should_turn_right = FALSE;
1762     boolean should_move_on = FALSE;
1763     int rnd_value = 24;
1764     int rnd = RND(rnd_value);
1765
1766     if (IN_LEV_FIELD(left_x, left_y) &&
1767         (IS_FREE(left_x, left_y) || IS_GEM(Feld[left_x][left_y])))
1768       can_turn_left = TRUE;
1769     if (IN_LEV_FIELD(right_x, right_y) &&
1770         (IS_FREE(right_x, right_y) || IS_GEM(Feld[right_x][right_y])))
1771       can_turn_right = TRUE;
1772     if (IN_LEV_FIELD(move_x, move_y) &&
1773         (IS_FREE(move_x, move_y) || IS_GEM(Feld[move_x][move_y])))
1774       can_move_on = TRUE;
1775
1776     if (can_turn_left &&
1777         (!can_move_on ||
1778          (IN_LEV_FIELD(x+back_dx+left_dx, y+back_dy+left_dy) &&
1779           !IS_FREE(x+back_dx+left_dx, y+back_dy+left_dy))))
1780       should_turn_left = TRUE;
1781     if (can_turn_right &&
1782         (!can_move_on ||
1783          (IN_LEV_FIELD(x+back_dx+right_dx, y+back_dy+right_dy) &&
1784           !IS_FREE(x+back_dx+right_dx, y+back_dy+right_dy))))
1785       should_turn_right = TRUE;
1786     if (can_move_on &&
1787         (!can_turn_left || !can_turn_right ||
1788          (IN_LEV_FIELD(x+move_dx+left_dx, y+move_dy+left_dy) &&
1789           !IS_FREE(x+move_dx+left_dx, y+move_dy+left_dy)) ||
1790          (IN_LEV_FIELD(x+move_dx+right_dx, y+move_dy+right_dy) &&
1791           !IS_FREE(x+move_dx+right_dx, y+move_dy+right_dy))))
1792       should_move_on = TRUE;
1793
1794     if (should_turn_left || should_turn_right || should_move_on)
1795     {
1796       if (should_turn_left && should_turn_right && should_move_on)
1797         MovDir[x][y] = (rnd < rnd_value/3 ? left_dir :
1798                         rnd < 2*rnd_value/3 ? right_dir :
1799                         old_move_dir);
1800       else if (should_turn_left && should_turn_right)
1801         MovDir[x][y] = (rnd < rnd_value/2 ? left_dir : right_dir);
1802       else if (should_turn_left && should_move_on)
1803         MovDir[x][y] = (rnd < rnd_value/2 ? left_dir : old_move_dir);
1804       else if (should_turn_right && should_move_on)
1805         MovDir[x][y] = (rnd < rnd_value/2 ? right_dir : old_move_dir);
1806       else if (should_turn_left)
1807         MovDir[x][y] = left_dir;
1808       else if (should_turn_right)
1809         MovDir[x][y] = right_dir;
1810       else if (should_move_on)
1811         MovDir[x][y] = old_move_dir;
1812     }
1813     else if (can_move_on && rnd > rnd_value/8)
1814       MovDir[x][y] = old_move_dir;
1815     else if (can_turn_left && can_turn_right)
1816       MovDir[x][y] = (rnd < rnd_value/2 ? left_dir : right_dir);
1817     else if (can_turn_left && rnd > rnd_value/8)
1818       MovDir[x][y] = left_dir;
1819     else if (can_turn_right && rnd > rnd_value/8)
1820       MovDir[x][y] = right_dir;
1821     else
1822       MovDir[x][y] = back_dir;
1823
1824     if (!IS_FREE(x+move_xy[MovDir[x][y]].x, y+move_xy[MovDir[x][y]].y) &&
1825         !IS_GEM(Feld[x+move_xy[MovDir[x][y]].x][y+move_xy[MovDir[x][y]].y]))
1826       MovDir[x][y] = old_move_dir;
1827
1828     MovDelay[x][y] = 0;
1829   }
1830   else if (element == EL_DRACHE)
1831   {
1832     boolean can_turn_left = FALSE, can_turn_right = FALSE, can_move_on = FALSE;
1833     int rnd_value = 24;
1834     int rnd = RND(rnd_value);
1835
1836     if (IN_LEV_FIELD(left_x, left_y) && IS_FREE(left_x, left_y))
1837       can_turn_left = TRUE;
1838     if (IN_LEV_FIELD(right_x, right_y) && IS_FREE(right_x, right_y))
1839       can_turn_right = TRUE;
1840     if (IN_LEV_FIELD(move_x, move_y) && IS_FREE(move_x, move_y))
1841       can_move_on = TRUE;
1842
1843     if (can_move_on && rnd > rnd_value/8)
1844       MovDir[x][y] = old_move_dir;
1845     else if (can_turn_left && can_turn_right)
1846       MovDir[x][y] = (rnd < rnd_value/2 ? left_dir : right_dir);
1847     else if (can_turn_left && rnd > rnd_value/8)
1848       MovDir[x][y] = left_dir;
1849     else if (can_turn_right && rnd > rnd_value/8)
1850       MovDir[x][y] = right_dir;
1851     else
1852       MovDir[x][y] = back_dir;
1853
1854     if (!IS_FREE(x+move_xy[MovDir[x][y]].x, y+move_xy[MovDir[x][y]].y))
1855       MovDir[x][y] = old_move_dir;
1856
1857     MovDelay[x][y] = 0;
1858   }
1859   else if (element == EL_ROBOT || element == EL_SONDE ||
1860            element == EL_MAULWURF || element == EL_PINGUIN)
1861   {
1862     int attr_x = -1, attr_y = -1;
1863
1864     if (AllPlayersGone)
1865     {
1866       attr_x = ExitX;
1867       attr_y = ExitY;
1868     }
1869     else
1870     {
1871       int i;
1872
1873       for (i=0; i<MAX_PLAYERS; i++)
1874       {
1875         struct PlayerInfo *player = &stored_player[i];
1876         int jx = player->jx, jy = player->jy;
1877
1878         if (!player->active)
1879           continue;
1880
1881         if (attr_x == -1 || ABS(jx-x)+ABS(jy-y) < ABS(attr_x-x)+ABS(attr_y-y))
1882         {
1883           attr_x = jx;
1884           attr_y = jy;
1885         }
1886       }
1887     }
1888
1889     if (element == EL_ROBOT && ZX>=0 && ZY>=0)
1890     {
1891       attr_x = ZX;
1892       attr_y = ZY;
1893     }
1894
1895     if (element == EL_MAULWURF || element == EL_PINGUIN)
1896     {
1897       int i;
1898       static int xy[4][2] =
1899       {
1900         { 0, -1 },
1901         { -1, 0 },
1902         { +1, 0 },
1903         { 0, +1 }
1904       };
1905
1906       for (i=0; i<4; i++)
1907       {
1908         int ex = x + xy[i%4][0];
1909         int ey = y + xy[i%4][1];
1910
1911         if (IN_LEV_FIELD(ex, ey) && Feld[ex][ey] == EL_AUSGANG_AUF)
1912         {
1913           attr_x = ex;
1914           attr_y = ey;
1915           break;
1916         }
1917       }
1918     }
1919
1920     MovDir[x][y] = MV_NO_MOVING;
1921     if (attr_x<x)
1922       MovDir[x][y] |= (AllPlayersGone ? MV_RIGHT : MV_LEFT);
1923     else if (attr_x>x)
1924       MovDir[x][y] |= (AllPlayersGone ? MV_LEFT : MV_RIGHT);
1925     if (attr_y<y)
1926       MovDir[x][y] |= (AllPlayersGone ? MV_DOWN : MV_UP);
1927     else if (attr_y>y)
1928       MovDir[x][y] |= (AllPlayersGone ? MV_UP : MV_DOWN);
1929
1930     if (element == EL_ROBOT)
1931     {
1932       int newx, newy;
1933
1934       if ((MovDir[x][y]&(MV_LEFT|MV_RIGHT)) && (MovDir[x][y]&(MV_UP|MV_DOWN)))
1935         MovDir[x][y] &= (RND(2) ? (MV_LEFT|MV_RIGHT) : (MV_UP|MV_DOWN));
1936       Moving2Blocked(x, y, &newx, &newy);
1937
1938       if (IN_LEV_FIELD(newx, newy) && IS_FREE_OR_PLAYER(newx, newy))
1939         MovDelay[x][y] = 8+8*!RND(3);
1940       else
1941         MovDelay[x][y] = 16;
1942     }
1943     else
1944     {
1945       int newx, newy;
1946
1947       MovDelay[x][y] = 1;
1948
1949       if ((MovDir[x][y]&(MV_LEFT|MV_RIGHT)) && (MovDir[x][y]&(MV_UP|MV_DOWN)))
1950       {
1951         boolean first_horiz = RND(2);
1952         int new_move_dir = MovDir[x][y];
1953
1954         MovDir[x][y] =
1955           new_move_dir & (first_horiz ? (MV_LEFT|MV_RIGHT) : (MV_UP|MV_DOWN));
1956         Moving2Blocked(x, y, &newx, &newy);
1957
1958         if (IN_LEV_FIELD(newx, newy) &&
1959             (IS_FREE(newx, newy) ||
1960              Feld[newx][newy] == EL_SALZSAEURE ||
1961              ((element == EL_MAULWURF || element == EL_PINGUIN) &&
1962               (Feld[newx][newy] == EL_AUSGANG_AUF ||
1963                IS_MAMPF3(Feld[newx][newy])))))
1964           return;
1965
1966         MovDir[x][y] =
1967           new_move_dir & (!first_horiz ? (MV_LEFT|MV_RIGHT) : (MV_UP|MV_DOWN));
1968         Moving2Blocked(x, y, &newx, &newy);
1969
1970         if (IN_LEV_FIELD(newx, newy) &&
1971             (IS_FREE(newx, newy) ||
1972              Feld[newx][newy] == EL_SALZSAEURE ||
1973              ((element == EL_MAULWURF || element == EL_PINGUIN) &&
1974               (Feld[newx][newy] == EL_AUSGANG_AUF ||
1975                IS_MAMPF3(Feld[newx][newy])))))
1976           return;
1977
1978         MovDir[x][y] = old_move_dir;
1979         return;
1980       }
1981     }
1982   }
1983 }
1984
1985 static boolean JustBeingPushed(int x, int y)
1986 {
1987   int i;
1988
1989   for (i=0; i<MAX_PLAYERS; i++)
1990   {
1991     struct PlayerInfo *player = &stored_player[i];
1992
1993     if (player->active && player->Pushing && player->MovPos)
1994     {
1995       int next_jx = player->jx + (player->jx - player->last_jx);
1996       int next_jy = player->jy + (player->jy - player->last_jy);
1997
1998       if (x == next_jx && y == next_jy)
1999         return TRUE;
2000     }
2001   }
2002
2003   return FALSE;
2004 }
2005
2006 void StartMoving(int x, int y)
2007 {
2008   int element = Feld[x][y];
2009
2010   if (Stop[x][y])
2011     return;
2012
2013   if (CAN_FALL(element) && y<lev_fieldy-1)
2014   {
2015     if ((x>0 && IS_PLAYER(x-1, y)) || (x<lev_fieldx-1 && IS_PLAYER(x+1, y)))
2016       if (JustBeingPushed(x, y))
2017         return;
2018
2019     if (element == EL_MORAST_VOLL)
2020     {
2021       if (IS_FREE(x, y+1))
2022       {
2023         InitMovingField(x, y, MV_DOWN);
2024         Feld[x][y] = EL_FELSBROCKEN;
2025         Store[x][y] = EL_MORAST_LEER;
2026       }
2027       else if (Feld[x][y+1] == EL_MORAST_LEER)
2028       {
2029         if (!MovDelay[x][y])
2030           MovDelay[x][y] = TILEY + 1;
2031
2032         if (MovDelay[x][y])
2033         {
2034           MovDelay[x][y]--;
2035           if (MovDelay[x][y])
2036             return;
2037         }
2038
2039         Feld[x][y] = EL_MORAST_LEER;
2040         Feld[x][y+1] = EL_MORAST_VOLL;
2041       }
2042     }
2043     else if (element == EL_FELSBROCKEN && Feld[x][y+1] == EL_MORAST_LEER)
2044     {
2045       InitMovingField(x, y, MV_DOWN);
2046       Store[x][y] = EL_MORAST_VOLL;
2047     }
2048     else if (element == EL_SIEB_VOLL)
2049     {
2050       if (IS_FREE(x, y+1))
2051       {
2052         InitMovingField(x, y, MV_DOWN);
2053         Feld[x][y] = EL_CHANGED(Store2[x][y]);
2054         Store[x][y] = EL_SIEB_LEER;
2055       }
2056       else if (Feld[x][y+1] == EL_SIEB_LEER)
2057       {
2058         if (!MovDelay[x][y])
2059           MovDelay[x][y] = TILEY/4 + 1;
2060
2061         if (MovDelay[x][y])
2062         {
2063           MovDelay[x][y]--;
2064           if (MovDelay[x][y])
2065             return;
2066         }
2067
2068         Feld[x][y] = EL_SIEB_LEER;
2069         Feld[x][y+1] = EL_SIEB_VOLL;
2070         Store2[x][y+1] = EL_CHANGED(Store2[x][y]);
2071         Store2[x][y] = 0;
2072       }
2073     }
2074     else if (element == EL_SIEB2_VOLL)
2075     {
2076       if (IS_FREE(x, y+1))
2077       {
2078         InitMovingField(x, y, MV_DOWN);
2079         Feld[x][y] = EL_CHANGED2(Store2[x][y]);
2080         Store[x][y] = EL_SIEB2_LEER;
2081       }
2082       else if (Feld[x][y+1] == EL_SIEB2_LEER)
2083       {
2084         if (!MovDelay[x][y])
2085           MovDelay[x][y] = TILEY/4 + 1;
2086
2087         if (MovDelay[x][y])
2088         {
2089           MovDelay[x][y]--;
2090           if (MovDelay[x][y])
2091             return;
2092         }
2093
2094         Feld[x][y] = EL_SIEB2_LEER;
2095         Feld[x][y+1] = EL_SIEB2_VOLL;
2096         Store2[x][y+1] = EL_CHANGED2(Store2[x][y]);
2097         Store2[x][y] = 0;
2098       }
2099     }
2100     else if (CAN_CHANGE(element) &&
2101              (Feld[x][y+1] == EL_SIEB_LEER || Feld[x][y+1] == EL_SIEB2_LEER))
2102     {
2103       InitMovingField(x, y, MV_DOWN);
2104       Store[x][y] =
2105         (Feld[x][y+1] == EL_SIEB_LEER ? EL_SIEB_VOLL : EL_SIEB2_VOLL);
2106       Store2[x][y+1] = element;
2107     }
2108     else if (CAN_SMASH(element) && Feld[x][y+1] == EL_SALZSAEURE)
2109     {
2110       Blurb(x, y);
2111       InitMovingField(x, y, MV_DOWN);
2112       Store[x][y] = EL_SALZSAEURE;
2113     }
2114     else if (CAN_SMASH(element) && Feld[x][y+1] == EL_BLOCKED &&
2115              JustStopped[x][y])
2116     {
2117       Impact(x, y);
2118     }
2119     else if (IS_FREE(x, y+1))
2120     {
2121       InitMovingField(x, y, MV_DOWN);
2122     }
2123     else if (element == EL_TROPFEN)
2124     {
2125       Feld[x][y] = EL_AMOEBING;
2126       Store[x][y] = EL_AMOEBE_NASS;
2127     }
2128 #if OLD_GAME_BEHAVIOUR
2129     else if (IS_SLIPPERY(Feld[x][y+1]) && !Store[x][y+1])
2130 #else
2131     else if (IS_SLIPPERY(Feld[x][y+1]) && !Store[x][y+1] &&
2132              !IS_FALLING(x, y+1) && !JustStopped[x][y+1])
2133 #endif
2134     {
2135       boolean left  = (x>0 && IS_FREE(x-1, y) &&
2136                        (IS_FREE(x-1, y+1) || Feld[x-1][y+1] == EL_SALZSAEURE));
2137       boolean right = (x<lev_fieldx-1 && IS_FREE(x+1, y) &&
2138                        (IS_FREE(x+1, y+1) || Feld[x+1][y+1] == EL_SALZSAEURE));
2139
2140       if (left || right)
2141       {
2142         if (left && right && game.emulation != EMU_BOULDERDASH)
2143           left = !(right = RND(2));
2144
2145         InitMovingField(x, y, left ? MV_LEFT : MV_RIGHT);
2146       }
2147     }
2148   }
2149   else if (CAN_MOVE(element))
2150   {
2151     int newx, newy;
2152
2153     if (element == EL_SONDE && JustBeingPushed(x, y))
2154       return;
2155
2156     if (!MovDelay[x][y])        /* start new movement phase */
2157     {
2158       /* all objects that can change their move direction after each step */
2159       /* (MAMPFER, MAMPFER2 and PACMAN go straight until they hit a wall  */
2160
2161       if (element!=EL_MAMPFER && element!=EL_MAMPFER2 && element!=EL_PACMAN)
2162       {
2163         TurnRound(x, y);
2164         if (MovDelay[x][y] && (element == EL_KAEFER || element == EL_FLIEGER ||
2165                                element == EL_SP_SNIKSNAK ||
2166                                element == EL_SP_ELECTRON))
2167           DrawLevelField(x, y);
2168       }
2169     }
2170
2171     if (MovDelay[x][y])         /* wait some time before next movement */
2172     {
2173       MovDelay[x][y]--;
2174
2175       if (element == EL_ROBOT ||
2176           element == EL_MAMPFER || element == EL_MAMPFER2)
2177       {
2178         int phase = MovDelay[x][y] % 8;
2179
2180         if (phase>3)
2181           phase = 7-phase;
2182
2183         if (IN_SCR_FIELD(SCREENX(x), SCREENY(y)))
2184           DrawGraphic(SCREENX(x), SCREENY(y), el2gfx(element)+phase);
2185
2186         if ((element == EL_MAMPFER || element == EL_MAMPFER2)
2187             && MovDelay[x][y]%4 == 3)
2188           PlaySoundLevel(x, y, SND_NJAM);
2189       }
2190       else if (element == EL_SP_ELECTRON)
2191         DrawGraphicAnimation(x, y, GFX2_SP_ELECTRON, 8, 2, ANIM_NORMAL);
2192       else if (element == EL_DRACHE)
2193       {
2194         int i;
2195         int dir = MovDir[x][y];
2196         int dx = (dir == MV_LEFT ? -1 : dir == MV_RIGHT ? +1 : 0);
2197         int dy = (dir == MV_UP   ? -1 : dir == MV_DOWN  ? +1 : 0);
2198         int graphic = (dir == MV_LEFT   ? GFX_FLAMMEN_LEFT :
2199                        dir == MV_RIGHT  ? GFX_FLAMMEN_RIGHT :
2200                        dir == MV_UP     ? GFX_FLAMMEN_UP :
2201                        dir == MV_DOWN   ? GFX_FLAMMEN_DOWN : GFX_LEERRAUM);
2202         int phase = FrameCounter % 2;
2203
2204         for (i=1; i<=3; i++)
2205         {
2206           int xx = x + i*dx, yy = y + i*dy;
2207           int sx = SCREENX(xx), sy = SCREENY(yy);
2208
2209           if (!IN_LEV_FIELD(xx, yy) ||
2210               IS_SOLID(Feld[xx][yy]) || Feld[xx][yy] == EL_EXPLODING)
2211             break;
2212
2213           if (MovDelay[x][y])
2214           {
2215             int flamed = MovingOrBlocked2Element(xx, yy);
2216
2217             if (IS_ENEMY(flamed) || IS_EXPLOSIVE(flamed))
2218               Bang(xx, yy);
2219             else
2220               RemoveMovingField(xx, yy);
2221
2222             Feld[xx][yy] = EL_BURNING;
2223             if (IN_SCR_FIELD(sx, sy))
2224               DrawGraphic(sx, sy, graphic + phase*3 + i-1);
2225           }
2226           else
2227           {
2228             if (Feld[xx][yy] == EL_BURNING)
2229               Feld[xx][yy] = EL_LEERRAUM;
2230             DrawLevelField(xx, yy);
2231           }
2232         }
2233       }
2234
2235       if (MovDelay[x][y])
2236         return;
2237     }
2238
2239     if (element == EL_KAEFER || element == EL_BUTTERFLY)
2240     {
2241       PlaySoundLevel(x, y, SND_KLAPPER);
2242     }
2243     else if (element == EL_FLIEGER || element == EL_FIREFLY)
2244     {
2245       PlaySoundLevel(x, y, SND_ROEHR);
2246     }
2247
2248     /* now make next step */
2249
2250     Moving2Blocked(x, y, &newx, &newy); /* get next screen position */
2251
2252     if (IS_ENEMY(element) && IS_PLAYER(newx, newy))
2253     {
2254       /* enemy got the player */
2255       MovDir[x][y] = 0;
2256       KillHero(PLAYERINFO(newx, newy));
2257       return;
2258     }
2259     else if ((element == EL_MAULWURF || element == EL_PINGUIN ||
2260               element == EL_ROBOT || element == EL_SONDE) &&
2261              IN_LEV_FIELD(newx, newy) &&
2262              MovDir[x][y] == MV_DOWN && Feld[newx][newy] == EL_SALZSAEURE)
2263     {
2264       Blurb(x, y);
2265       Store[x][y] = EL_SALZSAEURE;
2266     }
2267     else if ((element == EL_MAULWURF || element == EL_PINGUIN) &&
2268              IN_LEV_FIELD(newx, newy))
2269     {
2270       if (Feld[newx][newy] == EL_AUSGANG_AUF)
2271       {
2272         Feld[x][y] = EL_LEERRAUM;
2273         DrawLevelField(x, y);
2274
2275         PlaySoundLevel(newx, newy, SND_BUING);
2276         if (IN_SCR_FIELD(SCREENX(newx), SCREENY(newy)))
2277           DrawGraphicThruMask(SCREENX(newx), SCREENY(newy), el2gfx(element));
2278
2279         local_player->friends_still_needed--;
2280         if (!local_player->friends_still_needed &&
2281             !local_player->GameOver && AllPlayersGone)
2282           local_player->LevelSolved = local_player->GameOver = TRUE;
2283
2284         return;
2285       }
2286       else if (IS_MAMPF3(Feld[newx][newy]))
2287       {
2288         if (DigField(local_player, newx, newy, 0, 0, DF_DIG) == MF_MOVING)
2289           DrawLevelField(newx, newy);
2290         else
2291           MovDir[x][y] = MV_NO_MOVING;
2292       }
2293       else if (!IS_FREE(newx, newy))
2294       {
2295         if (IS_PLAYER(x, y))
2296           DrawPlayerField(x, y);
2297         else
2298           DrawLevelField(x, y);
2299         return;
2300       }
2301     }
2302     else if (element == EL_SCHWEIN && IN_LEV_FIELD(newx, newy))
2303     {
2304       if (IS_GEM(Feld[newx][newy]))
2305       {
2306         if (IS_MOVING(newx, newy))
2307           RemoveMovingField(newx, newy);
2308         else
2309         {
2310           Feld[newx][newy] = EL_LEERRAUM;
2311           DrawLevelField(newx, newy);
2312         }
2313       }
2314       else if (!IS_FREE(newx, newy))
2315       {
2316         if (IS_PLAYER(x, y))
2317           DrawPlayerField(x, y);
2318         else
2319           DrawLevelField(x, y);
2320         return;
2321       }
2322     }
2323     else if (element == EL_DRACHE && IN_LEV_FIELD(newx, newy))
2324     {
2325       if (!IS_FREE(newx, newy))
2326       {
2327         if (IS_PLAYER(x, y))
2328           DrawPlayerField(x, y);
2329         else
2330           DrawLevelField(x, y);
2331         return;
2332       }
2333       else
2334       {
2335         boolean wanna_flame = !RND(10);
2336         int dx = newx - x, dy = newy - y;
2337         int newx1 = newx+1*dx, newy1 = newy+1*dy;
2338         int newx2 = newx+2*dx, newy2 = newy+2*dy;
2339         int element1 = (IN_LEV_FIELD(newx1, newy1) ?
2340                         MovingOrBlocked2Element(newx1, newy1) : EL_BETON);
2341         int element2 = (IN_LEV_FIELD(newx2, newy2) ?
2342                         MovingOrBlocked2Element(newx2, newy2) : EL_BETON);
2343
2344         if ((wanna_flame || IS_ENEMY(element1) || IS_ENEMY(element2)) &&
2345             element1 != EL_DRACHE && element2 != EL_DRACHE &&
2346             element1 != EL_BURNING && element2 != EL_BURNING)
2347         {
2348           if (IS_PLAYER(x, y))
2349             DrawPlayerField(x, y);
2350           else
2351             DrawLevelField(x, y);
2352
2353           MovDelay[x][y] = 50;
2354           Feld[newx][newy] = EL_BURNING;
2355           if (IN_LEV_FIELD(newx1, newy1) && Feld[newx1][newy1] == EL_LEERRAUM)
2356             Feld[newx1][newy1] = EL_BURNING;
2357           if (IN_LEV_FIELD(newx2, newy2) && Feld[newx2][newy2] == EL_LEERRAUM)
2358             Feld[newx2][newy2] = EL_BURNING;
2359           return;
2360         }
2361       }
2362     }
2363     else if (element == EL_MAMPFER && IN_LEV_FIELD(newx, newy) &&
2364              Feld[newx][newy] == EL_DIAMANT)
2365     {
2366       if (IS_MOVING(newx, newy))
2367         RemoveMovingField(newx, newy);
2368       else
2369       {
2370         Feld[newx][newy] = EL_LEERRAUM;
2371         DrawLevelField(newx, newy);
2372       }
2373     }
2374     else if (element == EL_MAMPFER2 && IN_LEV_FIELD(newx, newy) &&
2375              IS_MAMPF2(Feld[newx][newy]))
2376     {
2377       if (AmoebaNr[newx][newy])
2378       {
2379         AmoebaCnt2[AmoebaNr[newx][newy]]--;
2380         if (Feld[newx][newy] == EL_AMOEBE_VOLL ||
2381             Feld[newx][newy] == EL_AMOEBE_BD)
2382           AmoebaCnt[AmoebaNr[newx][newy]]--;
2383       }
2384
2385       if (IS_MOVING(newx, newy))
2386         RemoveMovingField(newx, newy);
2387       else
2388       {
2389         Feld[newx][newy] = EL_LEERRAUM;
2390         DrawLevelField(newx, newy);
2391       }
2392     }
2393     else if (element == EL_PACMAN && IN_LEV_FIELD(newx, newy) &&
2394              IS_AMOEBOID(Feld[newx][newy]))
2395     {
2396       if (AmoebaNr[newx][newy])
2397       {
2398         AmoebaCnt2[AmoebaNr[newx][newy]]--;
2399         if (Feld[newx][newy] == EL_AMOEBE_VOLL ||
2400             Feld[newx][newy] == EL_AMOEBE_BD)
2401           AmoebaCnt[AmoebaNr[newx][newy]]--;
2402       }
2403
2404       Feld[newx][newy] = EL_LEERRAUM;
2405       DrawLevelField(newx, newy);
2406     }
2407     else if (!IN_LEV_FIELD(newx, newy) || !IS_FREE(newx, newy))
2408     {
2409       /* object was running against a wall */
2410
2411       TurnRound(x, y);
2412
2413       if (element == EL_KAEFER || element == EL_FLIEGER ||
2414           element == EL_SP_SNIKSNAK)
2415         DrawLevelField(x, y);
2416       else if (element == EL_BUTTERFLY || element == EL_FIREFLY)
2417         DrawGraphicAnimation(x, y, el2gfx(element), 2, 4, ANIM_NORMAL);
2418       else if (element == EL_SONDE)
2419         DrawGraphicAnimation(x, y, GFX_SONDE_START, 8, 2, ANIM_NORMAL);
2420       else if (element == EL_SP_ELECTRON)
2421         DrawGraphicAnimation(x, y, GFX2_SP_ELECTRON, 8, 2, ANIM_NORMAL);
2422
2423       return;
2424     }
2425
2426     if (element == EL_ROBOT && IN_SCR_FIELD(x, y))
2427       PlaySoundLevel(x, y, SND_SCHLURF);
2428
2429     InitMovingField(x, y, MovDir[x][y]);
2430   }
2431
2432   if (MovDir[x][y])
2433     ContinueMoving(x, y);
2434 }
2435
2436 void ContinueMoving(int x, int y)
2437 {
2438   int element = Feld[x][y];
2439   int direction = MovDir[x][y];
2440   int dx = (direction == MV_LEFT ? -1 : direction == MV_RIGHT ? +1 : 0);
2441   int dy = (direction == MV_UP   ? -1 : direction == MV_DOWN  ? +1 : 0);
2442   int horiz_move = (dx!=0);
2443   int newx = x + dx, newy = y + dy;
2444   int step = (horiz_move ? dx : dy) * TILEX/8;
2445
2446   if (element == EL_TROPFEN)
2447     step/=2;
2448   else if (Store[x][y] == EL_MORAST_VOLL || Store[x][y] == EL_MORAST_LEER)
2449     step/=4;
2450 #if OLD_GAME_BEHAVIOUR
2451   else if (CAN_FALL(element) && horiz_move && !IS_SP_ELEMENT(element))
2452     step*=2;
2453 #endif
2454
2455   MovPos[x][y] += step;
2456
2457   if (ABS(MovPos[x][y])>=TILEX)         /* object reached its destination */
2458   {
2459     Feld[x][y] = EL_LEERRAUM;
2460     Feld[newx][newy] = element;
2461
2462     if (Store[x][y] == EL_MORAST_VOLL)
2463     {
2464       Store[x][y] = 0;
2465       Feld[newx][newy] = EL_MORAST_VOLL;
2466       element = EL_MORAST_VOLL;
2467     }
2468     else if (Store[x][y] == EL_MORAST_LEER)
2469     {
2470       Store[x][y] = 0;
2471       Feld[x][y] = EL_MORAST_LEER;
2472     }
2473     else if (Store[x][y] == EL_SIEB_VOLL)
2474     {
2475       Store[x][y] = 0;
2476       element = Feld[newx][newy] =
2477         (game.magic_wall_active ? EL_SIEB_VOLL : EL_SIEB_TOT);
2478     }
2479     else if (Store[x][y] == EL_SIEB_LEER)
2480     {
2481       Store[x][y] = Store2[x][y] = 0;
2482       Feld[x][y] = (game.magic_wall_active ? EL_SIEB_LEER : EL_SIEB_TOT);
2483     }
2484     else if (Store[x][y] == EL_SIEB2_VOLL)
2485     {
2486       Store[x][y] = 0;
2487       element = Feld[newx][newy] =
2488         (game.magic_wall_active ? EL_SIEB2_VOLL : EL_SIEB2_TOT);
2489     }
2490     else if (Store[x][y] == EL_SIEB2_LEER)
2491     {
2492       Store[x][y] = Store2[x][y] = 0;
2493       Feld[x][y] = (game.magic_wall_active ? EL_SIEB2_LEER : EL_SIEB2_TOT);
2494     }
2495     else if (Store[x][y] == EL_SALZSAEURE)
2496     {
2497       Store[x][y] = 0;
2498       Feld[newx][newy] = EL_SALZSAEURE;
2499       element = EL_SALZSAEURE;
2500     }
2501     else if (Store[x][y] == EL_AMOEBE_NASS)
2502     {
2503       Store[x][y] = 0;
2504       Feld[x][y] = EL_AMOEBE_NASS;
2505     }
2506
2507     MovPos[x][y] = MovDir[x][y] = MovDelay[x][y] = 0;
2508     MovDelay[newx][newy] = 0;
2509
2510     if (!CAN_MOVE(element))
2511       MovDir[newx][newy] = 0;
2512
2513     DrawLevelField(x, y);
2514     DrawLevelField(newx, newy);
2515
2516     Stop[newx][newy] = TRUE;
2517     JustStopped[newx][newy] = 3;
2518
2519     if (DONT_TOUCH(element))    /* object may be nasty to player or others */
2520     {
2521       TestIfBadThingHitsHero(newx, newy);
2522       TestIfBadThingHitsFriend(newx, newy);
2523       TestIfBadThingHitsOtherBadThing(newx, newy);
2524     }
2525     else if (element == EL_PINGUIN)
2526       TestIfFriendHitsBadThing(newx, newy);
2527
2528     if (CAN_SMASH(element) && direction == MV_DOWN &&
2529         (newy == lev_fieldy-1 || !IS_FREE(x, newy+1)))
2530       Impact(x, newy);
2531   }
2532   else                          /* still moving on */
2533     DrawLevelField(x, y);
2534 }
2535
2536 int AmoebeNachbarNr(int ax, int ay)
2537 {
2538   int i;
2539   int element = Feld[ax][ay];
2540   int group_nr = 0;
2541   static int xy[4][2] =
2542   {
2543     { 0, -1 },
2544     { -1, 0 },
2545     { +1, 0 },
2546     { 0, +1 }
2547   };
2548
2549   for (i=0; i<4; i++)
2550   {
2551     int x = ax + xy[i][0];
2552     int y = ay + xy[i][1];
2553
2554     if (!IN_LEV_FIELD(x, y))
2555       continue;
2556
2557     if (Feld[x][y] == element && AmoebaNr[x][y] > 0)
2558       group_nr = AmoebaNr[x][y];
2559   }
2560
2561   return group_nr;
2562 }
2563
2564 void AmoebenVereinigen(int ax, int ay)
2565 {
2566   int i, x, y, xx, yy;
2567   int new_group_nr = AmoebaNr[ax][ay];
2568   static int xy[4][2] =
2569   {
2570     { 0, -1 },
2571     { -1, 0 },
2572     { +1, 0 },
2573     { 0, +1 }
2574   };
2575
2576   if (new_group_nr == 0)
2577     return;
2578
2579   for (i=0; i<4; i++)
2580   {
2581     x = ax + xy[i][0];
2582     y = ay + xy[i][1];
2583
2584     if (!IN_LEV_FIELD(x, y))
2585       continue;
2586
2587     if ((Feld[x][y] == EL_AMOEBE_VOLL ||
2588          Feld[x][y] == EL_AMOEBE_BD ||
2589          Feld[x][y] == EL_AMOEBE_TOT) &&
2590         AmoebaNr[x][y] != new_group_nr)
2591     {
2592       int old_group_nr = AmoebaNr[x][y];
2593
2594       if (old_group_nr == 0)
2595         return;
2596
2597       AmoebaCnt[new_group_nr] += AmoebaCnt[old_group_nr];
2598       AmoebaCnt[old_group_nr] = 0;
2599       AmoebaCnt2[new_group_nr] += AmoebaCnt2[old_group_nr];
2600       AmoebaCnt2[old_group_nr] = 0;
2601
2602       for (yy=0; yy<lev_fieldy; yy++)
2603       {
2604         for (xx=0; xx<lev_fieldx; xx++)
2605         {
2606           if (AmoebaNr[xx][yy] == old_group_nr)
2607             AmoebaNr[xx][yy] = new_group_nr;
2608         }
2609       }
2610     }
2611   }
2612 }
2613
2614 void AmoebeUmwandeln(int ax, int ay)
2615 {
2616   int i, x, y;
2617
2618   if (Feld[ax][ay] == EL_AMOEBE_TOT)
2619   {
2620     int group_nr = AmoebaNr[ax][ay];
2621
2622 #ifdef DEBUG
2623     if (group_nr == 0)
2624     {
2625       printf("AmoebeUmwandeln(): ax = %d, ay = %d\n", ax, ay);
2626       printf("AmoebeUmwandeln(): This should never happen!\n");
2627       return;
2628     }
2629 #endif
2630
2631     for (y=0; y<lev_fieldy; y++)
2632     {
2633       for (x=0; x<lev_fieldx; x++)
2634       {
2635         if (Feld[x][y] == EL_AMOEBE_TOT && AmoebaNr[x][y] == group_nr)
2636         {
2637           AmoebaNr[x][y] = 0;
2638           Feld[x][y] = EL_AMOEBA2DIAM;
2639         }
2640       }
2641     }
2642     Bang(ax, ay);
2643   }
2644   else
2645   {
2646     static int xy[4][2] =
2647     {
2648       { 0, -1 },
2649       { -1, 0 },
2650       { +1, 0 },
2651       { 0, +1 }
2652     };
2653
2654     for (i=0; i<4; i++)
2655     {
2656       x = ax + xy[i][0];
2657       y = ay + xy[i][1];
2658
2659       if (!IN_LEV_FIELD(x, y))
2660         continue;
2661
2662       if (Feld[x][y] == EL_AMOEBA2DIAM)
2663         Bang(x, y);
2664     }
2665   }
2666 }
2667
2668 void AmoebeUmwandelnBD(int ax, int ay, int new_element)
2669 {
2670   int x, y;
2671   int group_nr = AmoebaNr[ax][ay];
2672   boolean done = FALSE;
2673
2674 #ifdef DEBUG
2675   if (group_nr == 0)
2676   {
2677     printf("AmoebeUmwandelnBD(): ax = %d, ay = %d\n", ax, ay);
2678     printf("AmoebeUmwandelnBD(): This should never happen!\n");
2679     return;
2680   }
2681 #endif
2682
2683   for (y=0; y<lev_fieldy; y++)
2684   {
2685     for (x=0; x<lev_fieldx; x++)
2686     {
2687       if (AmoebaNr[x][y] == group_nr &&
2688           (Feld[x][y] == EL_AMOEBE_TOT ||
2689            Feld[x][y] == EL_AMOEBE_BD ||
2690            Feld[x][y] == EL_AMOEBING))
2691       {
2692         AmoebaNr[x][y] = 0;
2693         Feld[x][y] = new_element;
2694         InitField(x, y, FALSE);
2695         DrawLevelField(x, y);
2696         done = TRUE;
2697       }
2698     }
2699   }
2700
2701   if (done)
2702     PlaySoundLevel(ax, ay,
2703                    (new_element == EL_FELSBROCKEN ? SND_KLOPF : SND_PLING));
2704 }
2705
2706 void AmoebeWaechst(int x, int y)
2707 {
2708   static unsigned long sound_delay = 0;
2709   static unsigned long sound_delay_value = 0;
2710
2711   if (!MovDelay[x][y])          /* start new growing cycle */
2712   {
2713     MovDelay[x][y] = 7;
2714
2715     if (DelayReached(&sound_delay, sound_delay_value))
2716     {
2717       PlaySoundLevel(x, y, SND_AMOEBE);
2718       sound_delay_value = 30;
2719     }
2720   }
2721
2722   if (MovDelay[x][y])           /* wait some time before growing bigger */
2723   {
2724     MovDelay[x][y]--;
2725     if (MovDelay[x][y]/2 && IN_SCR_FIELD(SCREENX(x), SCREENY(y)))
2726       DrawGraphic(SCREENX(x), SCREENY(y), GFX_AMOEBING + 3 - MovDelay[x][y]/2);
2727
2728     if (!MovDelay[x][y])
2729     {
2730       Feld[x][y] = Store[x][y];
2731       Store[x][y] = 0;
2732       DrawLevelField(x, y);
2733     }
2734   }
2735 }
2736
2737 void AmoebeAbleger(int ax, int ay)
2738 {
2739   int i;
2740   int element = Feld[ax][ay];
2741   int newax = ax, neway = ay;
2742   static int xy[4][2] =
2743   {
2744     { 0, -1 },
2745     { -1, 0 },
2746     { +1, 0 },
2747     { 0, +1 }
2748   };
2749
2750   if (!level.amoeba_speed)
2751   {
2752     Feld[ax][ay] = EL_AMOEBE_TOT;
2753     DrawLevelField(ax, ay);
2754     return;
2755   }
2756
2757   if (!MovDelay[ax][ay])        /* start making new amoeba field */
2758     MovDelay[ax][ay] = RND(FRAMES_PER_SECOND * 25 / (1 + level.amoeba_speed));
2759
2760   if (MovDelay[ax][ay])         /* wait some time before making new amoeba */
2761   {
2762     MovDelay[ax][ay]--;
2763     if (MovDelay[ax][ay])
2764       return;
2765   }
2766
2767   if (element == EL_AMOEBE_NASS)        /* object is an acid / amoeba drop */
2768   {
2769     int start = RND(4);
2770     int x = ax + xy[start][0];
2771     int y = ay + xy[start][1];
2772
2773     if (!IN_LEV_FIELD(x, y))
2774       return;
2775
2776     if (IS_FREE(x, y) ||
2777         Feld[x][y] == EL_ERDREICH || Feld[x][y] == EL_MORAST_LEER)
2778     {
2779       newax = x;
2780       neway = y;
2781     }
2782
2783     if (newax == ax && neway == ay)
2784       return;
2785   }
2786   else                          /* normal or "filled" (BD style) amoeba */
2787   {
2788     int start = RND(4);
2789     boolean waiting_for_player = FALSE;
2790
2791     for (i=0; i<4; i++)
2792     {
2793       int j = (start + i) % 4;
2794       int x = ax + xy[j][0];
2795       int y = ay + xy[j][1];
2796
2797       if (!IN_LEV_FIELD(x, y))
2798         continue;
2799
2800       if (IS_FREE(x, y) ||
2801           Feld[x][y] == EL_ERDREICH || Feld[x][y] == EL_MORAST_LEER)
2802       {
2803         newax = x;
2804         neway = y;
2805         break;
2806       }
2807       else if (IS_PLAYER(x, y))
2808         waiting_for_player = TRUE;
2809     }
2810
2811     if (newax == ax && neway == ay)             /* amoeba cannot grow */
2812     {
2813       if (i == 4 && (!waiting_for_player || game.emulation == EMU_BOULDERDASH))
2814       {
2815         Feld[ax][ay] = EL_AMOEBE_TOT;
2816         DrawLevelField(ax, ay);
2817         AmoebaCnt[AmoebaNr[ax][ay]]--;
2818
2819         if (AmoebaCnt[AmoebaNr[ax][ay]] <= 0)   /* amoeba is completely dead */
2820         {
2821           if (element == EL_AMOEBE_VOLL)
2822             AmoebeUmwandeln(ax, ay);
2823           else if (element == EL_AMOEBE_BD)
2824             AmoebeUmwandelnBD(ax, ay, level.amoeba_content);
2825         }
2826       }
2827       return;
2828     }
2829     else if (element == EL_AMOEBE_VOLL || element == EL_AMOEBE_BD)
2830     {
2831       /* amoeba gets larger by growing in some direction */
2832
2833       int new_group_nr = AmoebaNr[ax][ay];
2834
2835 #ifdef DEBUG
2836   if (new_group_nr == 0)
2837   {
2838     printf("AmoebeAbleger(): newax = %d, neway = %d\n", newax, neway);
2839     printf("AmoebeAbleger(): This should never happen!\n");
2840     return;
2841   }
2842 #endif
2843
2844       AmoebaNr[newax][neway] = new_group_nr;
2845       AmoebaCnt[new_group_nr]++;
2846       AmoebaCnt2[new_group_nr]++;
2847
2848       /* if amoeba touches other amoeba(s) after growing, unify them */
2849       AmoebenVereinigen(newax, neway);
2850
2851       if (element == EL_AMOEBE_BD && AmoebaCnt2[new_group_nr] >= 200)
2852       {
2853         AmoebeUmwandelnBD(newax, neway, EL_FELSBROCKEN);
2854         return;
2855       }
2856     }
2857   }
2858
2859   if (element != EL_AMOEBE_NASS || neway < ay || !IS_FREE(newax, neway) ||
2860       (neway == lev_fieldy - 1 && newax != ax))
2861   {
2862     Feld[newax][neway] = EL_AMOEBING;
2863     Store[newax][neway] = element;
2864   }
2865   else if (neway == ay)
2866     Feld[newax][neway] = EL_TROPFEN;
2867   else
2868   {
2869     InitMovingField(ax, ay, MV_DOWN);
2870     Feld[ax][ay] = EL_TROPFEN;
2871     Store[ax][ay] = EL_AMOEBE_NASS;
2872     ContinueMoving(ax, ay);
2873     return;
2874   }
2875
2876   DrawLevelField(newax, neway);
2877 }
2878
2879 void Life(int ax, int ay)
2880 {
2881   int x1, y1, x2, y2;
2882   static int life[4] = { 2, 3, 3, 3 };  /* parameters for "game of life" */
2883   int life_time = 40;
2884   int element = Feld[ax][ay];
2885
2886   if (Stop[ax][ay])
2887     return;
2888
2889   if (!MovDelay[ax][ay])        /* start new "game of life" cycle */
2890     MovDelay[ax][ay] = life_time;
2891
2892   if (MovDelay[ax][ay])         /* wait some time before next cycle */
2893   {
2894     MovDelay[ax][ay]--;
2895     if (MovDelay[ax][ay])
2896       return;
2897   }
2898
2899   for (y1=-1; y1<2; y1++) for(x1=-1; x1<2; x1++)
2900   {
2901     int xx = ax+x1, yy = ay+y1;
2902     int nachbarn = 0;
2903
2904     if (!IN_LEV_FIELD(xx, yy))
2905       continue;
2906
2907     for (y2=-1; y2<2; y2++) for (x2=-1; x2<2; x2++)
2908     {
2909       int x = xx+x2, y = yy+y2;
2910
2911       if (!IN_LEV_FIELD(x, y) || (x == xx && y == yy))
2912         continue;
2913
2914       if (((Feld[x][y] == element ||
2915             (element == EL_LIFE && IS_PLAYER(x, y))) &&
2916            !Stop[x][y]) ||
2917           (IS_FREE(x, y) && Stop[x][y]))
2918         nachbarn++;
2919     }
2920
2921     if (xx == ax && yy == ay)           /* field in the middle */
2922     {
2923       if (nachbarn<life[0] || nachbarn>life[1])
2924       {
2925         Feld[xx][yy] = EL_LEERRAUM;
2926         if (!Stop[xx][yy])
2927           DrawLevelField(xx, yy);
2928         Stop[xx][yy] = TRUE;
2929       }
2930     }
2931     else if (IS_FREE(xx, yy) || Feld[xx][yy] == EL_ERDREICH)
2932     {                                   /* free border field */
2933       if (nachbarn>=life[2] && nachbarn<=life[3])
2934       {
2935         Feld[xx][yy] = element;
2936         MovDelay[xx][yy] = (element == EL_LIFE ? 0 : life_time-1);
2937         if (!Stop[xx][yy])
2938           DrawLevelField(xx, yy);
2939         Stop[xx][yy] = TRUE;
2940       }
2941     }
2942   }
2943 }
2944
2945 void Ablenk(int x, int y)
2946 {
2947   if (!MovDelay[x][y])          /* next animation frame */
2948     MovDelay[x][y] = level.time_wheel * FRAMES_PER_SECOND;
2949
2950   if (MovDelay[x][y])           /* wait some time before next frame */
2951   {
2952     MovDelay[x][y]--;
2953     if (MovDelay[x][y])
2954     {
2955       if (IN_SCR_FIELD(SCREENX(x), SCREENY(y)))
2956         DrawGraphic(SCREENX(x), SCREENY(y), GFX_ABLENK+MovDelay[x][y]%4);
2957       if (!(MovDelay[x][y]%4))
2958         PlaySoundLevel(x, y, SND_MIEP);
2959       return;
2960     }
2961   }
2962
2963   Feld[x][y] = EL_ABLENK_AUS;
2964   DrawLevelField(x, y);
2965   if (ZX == x && ZY == y)
2966     ZX = ZY = -1;
2967 }
2968
2969 void Birne(int x, int y)
2970 {
2971   if (!MovDelay[x][y])          /* next animation frame */
2972     MovDelay[x][y] = 800;
2973
2974   if (MovDelay[x][y])           /* wait some time before next frame */
2975   {
2976     MovDelay[x][y]--;
2977     if (MovDelay[x][y])
2978     {
2979       if (!(MovDelay[x][y]%5))
2980       {
2981         if (!(MovDelay[x][y]%10))
2982           Feld[x][y]=EL_ABLENK_EIN;
2983         else
2984           Feld[x][y]=EL_ABLENK_AUS;
2985         DrawLevelField(x, y);
2986         Feld[x][y]=EL_ABLENK_EIN;
2987       }
2988       return;
2989     }
2990   }
2991
2992   Feld[x][y]=EL_ABLENK_AUS;
2993   DrawLevelField(x, y);
2994   if (ZX == x && ZY == y)
2995     ZX=ZY=-1;
2996 }
2997
2998 void Blubber(int x, int y)
2999 {
3000   if (y > 0 && IS_MOVING(x, y-1) && MovDir[x][y-1] == MV_DOWN)
3001     DrawLevelField(x, y-1);
3002   else
3003     DrawGraphicAnimation(x, y, GFX_GEBLUBBER, 4, 10, ANIM_NORMAL);
3004 }
3005
3006 void NussKnacken(int x, int y)
3007 {
3008   if (!MovDelay[x][y])          /* next animation frame */
3009     MovDelay[x][y] = 7;
3010
3011   if (MovDelay[x][y])           /* wait some time before next frame */
3012   {
3013     MovDelay[x][y]--;
3014     if (MovDelay[x][y]/2 && IN_SCR_FIELD(SCREENX(x), SCREENY(y)))
3015       DrawGraphic(SCREENX(x), SCREENY(y), GFX_CRACKINGNUT+3-MovDelay[x][y]/2);
3016
3017     if (!MovDelay[x][y])
3018     {
3019       Feld[x][y] = EL_EDELSTEIN;
3020       DrawLevelField(x, y);
3021     }
3022   }
3023 }
3024
3025 void SiebAktivieren(int x, int y, int typ)
3026 {
3027   int graphic = (typ == 1 ? GFX_SIEB_VOLL : GFX_SIEB2_VOLL) + 3;
3028
3029   DrawGraphicAnimation(x, y, graphic, 4, 4, ANIM_REVERSE);
3030 }
3031
3032 void AusgangstuerPruefen(int x, int y)
3033 {
3034   if (!local_player->gems_still_needed &&
3035       !local_player->sokobanfields_still_needed &&
3036       !local_player->lights_still_needed)
3037   {
3038     Feld[x][y] = EL_AUSGANG_ACT;
3039
3040     PlaySoundLevel(x < LEVELX(BX1) ? LEVELX(BX1) :
3041                    (x > LEVELX(BX2) ? LEVELX(BX2) : x),
3042                    y < LEVELY(BY1) ? LEVELY(BY1) :
3043                    (y > LEVELY(BY2) ? LEVELY(BY2) : y),
3044                    SND_OEFFNEN);
3045   }
3046 }
3047
3048 void AusgangstuerOeffnen(int x, int y)
3049 {
3050   int delay = 6;
3051
3052   if (!MovDelay[x][y])          /* next animation frame */
3053     MovDelay[x][y] = 5*delay;
3054
3055   if (MovDelay[x][y])           /* wait some time before next frame */
3056   {
3057     int tuer;
3058
3059     MovDelay[x][y]--;
3060     tuer = MovDelay[x][y]/delay;
3061     if (!(MovDelay[x][y]%delay) && IN_SCR_FIELD(SCREENX(x), SCREENY(y)))
3062       DrawGraphic(SCREENX(x), SCREENY(y), GFX_AUSGANG_AUF-tuer);
3063
3064     if (!MovDelay[x][y])
3065     {
3066       Feld[x][y] = EL_AUSGANG_AUF;
3067       DrawLevelField(x, y);
3068     }
3069   }
3070 }
3071
3072 void AusgangstuerBlinken(int x, int y)
3073 {
3074   DrawGraphicAnimation(x, y, GFX_AUSGANG_AUF, 4, 4, ANIM_OSCILLATE);
3075 }
3076
3077 void EdelsteinFunkeln(int x, int y)
3078 {
3079   if (!IN_SCR_FIELD(SCREENX(x), SCREENY(y)) || IS_MOVING(x, y))
3080     return;
3081
3082   if (Feld[x][y] == EL_EDELSTEIN_BD)
3083     DrawGraphicAnimation(x, y, GFX_EDELSTEIN_BD, 4, 4, ANIM_REVERSE);
3084   else
3085   {
3086     if (!MovDelay[x][y])        /* next animation frame */
3087       MovDelay[x][y] = 11 * !SimpleRND(500);
3088
3089     if (MovDelay[x][y])         /* wait some time before next frame */
3090     {
3091       MovDelay[x][y]--;
3092
3093       if (setup.direct_draw && MovDelay[x][y])
3094         SetDrawtoField(DRAW_BUFFERED);
3095
3096       DrawGraphic(SCREENX(x), SCREENY(y), el2gfx(Feld[x][y]));
3097
3098       if (MovDelay[x][y])
3099       {
3100         int phase = (MovDelay[x][y]-1)/2;
3101
3102         if (phase > 2)
3103           phase = 4-phase;
3104
3105         DrawGraphicThruMask(SCREENX(x), SCREENY(y), GFX_FUNKELN_WEISS + phase);
3106
3107         if (setup.direct_draw)
3108         {
3109           int dest_x, dest_y;
3110
3111           dest_x = FX + SCREENX(x)*TILEX;
3112           dest_y = FY + SCREENY(y)*TILEY;
3113
3114           XCopyArea(display, drawto_field, window, gc,
3115                     dest_x, dest_y, TILEX, TILEY, dest_x, dest_y);
3116           SetDrawtoField(DRAW_DIRECT);
3117         }
3118       }
3119     }
3120   }
3121 }
3122
3123 void MauerWaechst(int x, int y)
3124 {
3125   int delay = 6;
3126
3127   if (!MovDelay[x][y])          /* next animation frame */
3128     MovDelay[x][y] = 3*delay;
3129
3130   if (MovDelay[x][y])           /* wait some time before next frame */
3131   {
3132     int phase;
3133
3134     MovDelay[x][y]--;
3135     phase = 2-MovDelay[x][y]/delay;
3136     if (!(MovDelay[x][y]%delay) && IN_SCR_FIELD(SCREENX(x), SCREENY(y)))
3137       DrawGraphic(SCREENX(x), SCREENY(y),
3138                   (MovDir[x][y] == MV_LEFT  ? GFX_MAUER_LEFT  :
3139                    MovDir[x][y] == MV_RIGHT ? GFX_MAUER_RIGHT :
3140                    MovDir[x][y] == MV_UP    ? GFX_MAUER_UP    :
3141                                               GFX_MAUER_DOWN  ) + phase);
3142
3143     if (!MovDelay[x][y])
3144     {
3145       if (MovDir[x][y] == MV_LEFT)
3146       {
3147         if (IN_LEV_FIELD(x-1, y) && IS_MAUER(Feld[x-1][y]))
3148           DrawLevelField(x-1, y);
3149       }
3150       else if (MovDir[x][y] == MV_RIGHT)
3151       {
3152         if (IN_LEV_FIELD(x+1, y) && IS_MAUER(Feld[x+1][y]))
3153           DrawLevelField(x+1, y);
3154       }
3155       else if (MovDir[x][y] == MV_UP)
3156       {
3157         if (IN_LEV_FIELD(x, y-1) && IS_MAUER(Feld[x][y-1]))
3158           DrawLevelField(x, y-1);
3159       }
3160       else
3161       {
3162         if (IN_LEV_FIELD(x, y+1) && IS_MAUER(Feld[x][y+1]))
3163           DrawLevelField(x, y+1);
3164       }
3165
3166       Feld[x][y] = Store[x][y];
3167       Store[x][y] = 0;
3168       MovDir[x][y] = MV_NO_MOVING;
3169       DrawLevelField(x, y);
3170     }
3171   }
3172 }
3173
3174 void MauerAbleger(int ax, int ay)
3175 {
3176   int element = Feld[ax][ay];
3177   boolean oben_frei = FALSE, unten_frei = FALSE;
3178   boolean links_frei = FALSE, rechts_frei = FALSE;
3179   boolean oben_massiv = FALSE, unten_massiv = FALSE;
3180   boolean links_massiv = FALSE, rechts_massiv = FALSE;
3181
3182   if (!MovDelay[ax][ay])        /* start building new wall */
3183     MovDelay[ax][ay] = 6;
3184
3185   if (MovDelay[ax][ay])         /* wait some time before building new wall */
3186   {
3187     MovDelay[ax][ay]--;
3188     if (MovDelay[ax][ay])
3189       return;
3190   }
3191
3192   if (IN_LEV_FIELD(ax, ay-1) && IS_FREE(ax, ay-1))
3193     oben_frei = TRUE;
3194   if (IN_LEV_FIELD(ax, ay+1) && IS_FREE(ax, ay+1))
3195     unten_frei = TRUE;
3196   if (IN_LEV_FIELD(ax-1, ay) && IS_FREE(ax-1, ay))
3197     links_frei = TRUE;
3198   if (IN_LEV_FIELD(ax+1, ay) && IS_FREE(ax+1, ay))
3199     rechts_frei = TRUE;
3200
3201   if (element == EL_MAUER_Y || element == EL_MAUER_XY)
3202   {
3203     if (oben_frei)
3204     {
3205       Feld[ax][ay-1] = EL_MAUERND;
3206       Store[ax][ay-1] = element;
3207       MovDir[ax][ay-1] = MV_UP;
3208       if (IN_SCR_FIELD(SCREENX(ax), SCREENY(ay-1)))
3209         DrawGraphic(SCREENX(ax), SCREENY(ay-1), GFX_MAUER_UP);
3210     }
3211     if (unten_frei)
3212     {
3213       Feld[ax][ay+1] = EL_MAUERND;
3214       Store[ax][ay+1] = element;
3215       MovDir[ax][ay+1] = MV_DOWN;
3216       if (IN_SCR_FIELD(SCREENX(ax), SCREENY(ay+1)))
3217         DrawGraphic(SCREENX(ax), SCREENY(ay+1), GFX_MAUER_DOWN);
3218     }
3219   }
3220
3221   if (element == EL_MAUER_X || element == EL_MAUER_XY ||
3222       element == EL_MAUER_LEBT)
3223   {
3224     if (links_frei)
3225     {
3226       Feld[ax-1][ay] = EL_MAUERND;
3227       Store[ax-1][ay] = element;
3228       MovDir[ax-1][ay] = MV_LEFT;
3229       if (IN_SCR_FIELD(SCREENX(ax-1), SCREENY(ay)))
3230         DrawGraphic(SCREENX(ax-1), SCREENY(ay), GFX_MAUER_LEFT);
3231     }
3232     if (rechts_frei)
3233     {
3234       Feld[ax+1][ay] = EL_MAUERND;
3235       Store[ax+1][ay] = element;
3236       MovDir[ax+1][ay] = MV_RIGHT;
3237       if (IN_SCR_FIELD(SCREENX(ax+1), SCREENY(ay)))
3238         DrawGraphic(SCREENX(ax+1), SCREENY(ay), GFX_MAUER_RIGHT);
3239     }
3240   }
3241
3242   if (element == EL_MAUER_LEBT && (links_frei || rechts_frei))
3243     DrawLevelField(ax, ay);
3244
3245   if (!IN_LEV_FIELD(ax, ay-1) || IS_MAUER(Feld[ax][ay-1]))
3246     oben_massiv = TRUE;
3247   if (!IN_LEV_FIELD(ax, ay+1) || IS_MAUER(Feld[ax][ay+1]))
3248     unten_massiv = TRUE;
3249   if (!IN_LEV_FIELD(ax-1, ay) || IS_MAUER(Feld[ax-1][ay]))
3250     links_massiv = TRUE;
3251   if (!IN_LEV_FIELD(ax+1, ay) || IS_MAUER(Feld[ax+1][ay]))
3252     rechts_massiv = TRUE;
3253
3254   if (((oben_massiv && unten_massiv) ||
3255        element == EL_MAUER_X || element == EL_MAUER_LEBT) &&
3256       ((links_massiv && rechts_massiv) ||
3257        element == EL_MAUER_Y))
3258     Feld[ax][ay] = EL_MAUERWERK;
3259 }
3260
3261 void CheckForDragon(int x, int y)
3262 {
3263   int i, j;
3264   boolean dragon_found = FALSE;
3265   static int xy[4][2] =
3266   {
3267     { 0, -1 },
3268     { -1, 0 },
3269     { +1, 0 },
3270     { 0, +1 }
3271   };
3272
3273   for (i=0; i<4; i++)
3274   {
3275     for (j=0; j<4; j++)
3276     {
3277       int xx = x + j*xy[i][0], yy = y + j*xy[i][1];
3278
3279       if (IN_LEV_FIELD(xx, yy) &&
3280           (Feld[xx][yy] == EL_BURNING || Feld[xx][yy] == EL_DRACHE))
3281       {
3282         if (Feld[xx][yy] == EL_DRACHE)
3283           dragon_found = TRUE;
3284       }
3285       else
3286         break;
3287     }
3288   }
3289
3290   if (!dragon_found)
3291   {
3292     for (i=0; i<4; i++)
3293     {
3294       for (j=0; j<3; j++)
3295       {
3296         int xx = x + j*xy[i][0], yy = y + j*xy[i][1];
3297
3298         if (IN_LEV_FIELD(xx, yy) && Feld[xx][yy] == EL_BURNING)
3299         {
3300           Feld[xx][yy] = EL_LEERRAUM;
3301           DrawLevelField(xx, yy);
3302         }
3303         else
3304           break;
3305       }
3306     }
3307   }
3308 }
3309
3310 static void CheckBuggyBase(int x, int y)
3311 {
3312   int element = Feld[x][y];
3313
3314   if (element == EL_SP_BUG)
3315   {
3316     if (!MovDelay[x][y])        /* start activating buggy base */
3317       MovDelay[x][y] = 2 * FRAMES_PER_SECOND + RND(5 * FRAMES_PER_SECOND);
3318
3319     if (MovDelay[x][y])         /* wait some time before activating base */
3320     {
3321       MovDelay[x][y]--;
3322       if (MovDelay[x][y] < 5 && IN_SCR_FIELD(SCREENX(x), SCREENY(y)))
3323         DrawGraphic(SCREENX(x), SCREENY(y), GFX_SP_BUG_WARNING);
3324       if (MovDelay[x][y])
3325         return;
3326
3327       Feld[x][y] = EL_SP_BUG_ACTIVE;
3328     }
3329   }
3330   else if (element == EL_SP_BUG_ACTIVE)
3331   {
3332     if (!MovDelay[x][y])        /* start activating buggy base */
3333       MovDelay[x][y] = 1 * FRAMES_PER_SECOND + RND(1 * FRAMES_PER_SECOND);
3334
3335     if (MovDelay[x][y])         /* wait some time before activating base */
3336     {
3337       MovDelay[x][y]--;
3338       if (MovDelay[x][y])
3339       {
3340         int i;
3341         static int xy[4][2] =
3342         {
3343           { 0, -1 },
3344           { -1, 0 },
3345           { +1, 0 },
3346           { 0, +1 }
3347         };
3348
3349         if (IN_SCR_FIELD(SCREENX(x), SCREENY(y)))
3350           DrawGraphic(SCREENX(x),SCREENY(y), GFX_SP_BUG_ACTIVE + SimpleRND(4));
3351
3352         for (i=0; i<4; i++)
3353         {
3354           int xx = x + xy[i][0], yy = y + xy[i][1];
3355
3356           if (IS_PLAYER(xx, yy))
3357           {
3358             PlaySoundLevel(x, y, SND_SP_BUG);
3359             break;
3360           }
3361         }
3362
3363         return;
3364       }
3365
3366       Feld[x][y] = EL_SP_BUG;
3367       DrawLevelField(x, y);
3368     }
3369   }
3370 }
3371
3372 static void PlayerActions(struct PlayerInfo *player, byte player_action)
3373 {
3374   static byte stored_player_action[MAX_PLAYERS];
3375   static int num_stored_actions = 0;
3376   static boolean save_tape_entry = FALSE;
3377   boolean moved = FALSE, snapped = FALSE, bombed = FALSE;
3378   int jx = player->jx, jy = player->jy;
3379   int left      = player_action & JOY_LEFT;
3380   int right     = player_action & JOY_RIGHT;
3381   int up        = player_action & JOY_UP;
3382   int down      = player_action & JOY_DOWN;
3383   int button1   = player_action & JOY_BUTTON_1;
3384   int button2   = player_action & JOY_BUTTON_2;
3385   int dx        = (left ? -1    : right ? 1     : 0);
3386   int dy        = (up   ? -1    : down  ? 1     : 0);
3387
3388   stored_player_action[player->index_nr] = 0;
3389   num_stored_actions++;
3390
3391   if (!player->active || tape.pausing)
3392     return;
3393
3394   if (player_action)
3395   {
3396     save_tape_entry = TRUE;
3397     player->frame_reset_delay = 0;
3398
3399     if (button1)
3400       snapped = SnapField(player, dx, dy);
3401     else
3402     {
3403       if (button2)
3404         bombed = PlaceBomb(player);
3405       moved = MoveFigure(player, dx, dy);
3406     }
3407
3408     if (tape.recording && (moved || snapped || bombed))
3409     {
3410       if (bombed && !moved)
3411         player_action &= JOY_BUTTON;
3412
3413       stored_player_action[player->index_nr] = player_action;
3414     }
3415     else if (tape.playing && snapped)
3416       SnapField(player, 0, 0);                  /* stop snapping */
3417   }
3418   else
3419   {
3420     /* no actions for this player (no input at player's configured device) */
3421
3422     DigField(player, 0, 0, 0, 0, DF_NO_PUSH);
3423     SnapField(player, 0, 0);
3424     CheckGravityMovement(player);
3425
3426     if (++player->frame_reset_delay > player->move_delay_value)
3427       player->Frame = 0;
3428   }
3429
3430   if (tape.recording && num_stored_actions >= MAX_PLAYERS && save_tape_entry)
3431   {
3432     TapeRecordAction(stored_player_action);
3433     num_stored_actions = 0;
3434     save_tape_entry = FALSE;
3435   }
3436
3437   if (tape.playing && !tape.pausing && !player_action &&
3438       tape.counter < tape.length)
3439   {
3440     int next_joy =
3441       tape.pos[tape.counter].action[player->index_nr] & (JOY_LEFT|JOY_RIGHT);
3442
3443     if ((next_joy == JOY_LEFT || next_joy == JOY_RIGHT) &&
3444         (player->MovDir != JOY_UP && player->MovDir != JOY_DOWN))
3445     {
3446       int dx = (next_joy == JOY_LEFT ? -1 : +1);
3447
3448       if (IN_LEV_FIELD(jx+dx, jy) && IS_PUSHABLE(Feld[jx+dx][jy]))
3449       {
3450         int el = Feld[jx+dx][jy];
3451         int push_delay = (IS_SB_ELEMENT(el) || el == EL_SONDE ? 2 : 10);
3452
3453         if (tape.delay_played + push_delay >= tape.pos[tape.counter].delay)
3454         {
3455           player->MovDir = next_joy;
3456           player->Frame = FrameCounter % 4;
3457           player->Pushing = TRUE;
3458         }
3459       }
3460     }
3461   }
3462 }
3463
3464 void GameActions()
3465 {
3466   static unsigned long action_delay = 0;
3467   unsigned long action_delay_value;
3468   int sieb_x = 0, sieb_y = 0;
3469   int i, x, y, element;
3470   byte *recorded_player_action;
3471   byte summarized_player_action = 0;
3472
3473   if (game_status != PLAYING)
3474     return;
3475
3476   action_delay_value =
3477     (tape.playing && tape.fast_forward ? FfwdFrameDelay : GameFrameDelay);
3478
3479   /* ---------- main game synchronization point ---------- */
3480
3481   WaitUntilDelayReached(&action_delay, action_delay_value);
3482
3483   if (network_playing && !network_player_action_received)
3484   {
3485     /*
3486 #ifdef DEBUG
3487     printf("DEBUG: try to get network player actions in time\n");
3488 #endif
3489     */
3490
3491 #ifndef MSDOS
3492     /* last chance to get network player actions without main loop delay */
3493     HandleNetworking();
3494 #endif
3495
3496     if (game_status != PLAYING)
3497       return;
3498
3499     if (!network_player_action_received)
3500     {
3501       /*
3502 #ifdef DEBUG
3503       printf("DEBUG: failed to get network player actions in time\n");
3504 #endif
3505       */
3506       return;
3507     }
3508   }
3509
3510   if (tape.pausing)
3511     return;
3512
3513   if (tape.playing)
3514     TapePlayDelay();
3515   else if (tape.recording)
3516     TapeRecordDelay();
3517
3518   recorded_player_action = (tape.playing ? TapePlayAction() : NULL);
3519
3520   for (i=0; i<MAX_PLAYERS; i++)
3521   {
3522     summarized_player_action |= stored_player[i].action;
3523
3524     if (!network_playing)
3525       stored_player[i].effective_action = stored_player[i].action;
3526   }
3527
3528 #ifndef MSDOS
3529   if (network_playing)
3530     SendToServer_MovePlayer(summarized_player_action);
3531 #endif
3532
3533   if (!options.network && !setup.team_mode)
3534     local_player->effective_action = summarized_player_action;
3535
3536   for (i=0; i<MAX_PLAYERS; i++)
3537   {
3538     int actual_player_action = stored_player[i].effective_action;
3539
3540     if (stored_player[i].programmed_action)
3541       actual_player_action = stored_player[i].programmed_action;
3542
3543     if (recorded_player_action)
3544       actual_player_action = recorded_player_action[i];
3545
3546     PlayerActions(&stored_player[i], actual_player_action);
3547     ScrollFigure(&stored_player[i], SCROLL_GO_ON);
3548   }
3549
3550   network_player_action_received = FALSE;
3551
3552   ScrollScreen(NULL, SCROLL_GO_ON);
3553
3554
3555
3556 #ifdef DEBUG
3557 #if 0
3558   if (TimeFrames == 0 && local_player->active)
3559   {
3560     extern unsigned int last_RND();
3561
3562     printf("DEBUG: %03d last RND was %d \t [state checksum is %d]\n",
3563            TimePlayed, last_RND(), getStateCheckSum(TimePlayed));
3564   }
3565 #endif
3566 #endif
3567
3568 #ifdef DEBUG
3569 #if 0
3570   if (GameFrameDelay >= 500)
3571     printf("FrameCounter == %d\n", FrameCounter);
3572 #endif
3573 #endif
3574
3575
3576
3577   FrameCounter++;
3578   TimeFrames++;
3579
3580   for (y=0; y<lev_fieldy; y++) for (x=0; x<lev_fieldx; x++)
3581   {
3582     Stop[x][y] = FALSE;
3583     if (JustStopped[x][y] > 0)
3584       JustStopped[x][y]--;
3585
3586 #if DEBUG
3587     if (IS_BLOCKED(x, y))
3588     {
3589       int oldx, oldy;
3590
3591       Blocked2Moving(x, y, &oldx, &oldy);
3592       if (!IS_MOVING(oldx, oldy))
3593       {
3594         printf("GameActions(): (BLOCKED => MOVING) context corrupted!\n");
3595         printf("GameActions(): BLOCKED: x = %d, y = %d\n", x, y);
3596         printf("GameActions(): !MOVING: oldx = %d, oldy = %d\n", oldx, oldy);
3597         printf("GameActions(): This should never happen!\n");
3598       }
3599     }
3600 #endif
3601   }
3602
3603   for (y=0; y<lev_fieldy; y++) for (x=0; x<lev_fieldx; x++)
3604   {
3605     element = Feld[x][y];
3606
3607     if (IS_INACTIVE(element))
3608       continue;
3609
3610     if (!IS_MOVING(x, y) && (CAN_FALL(element) || CAN_MOVE(element)))
3611     {
3612       StartMoving(x, y);
3613
3614       if (IS_GEM(element))
3615         EdelsteinFunkeln(x, y);
3616     }
3617     else if (IS_MOVING(x, y))
3618       ContinueMoving(x, y);
3619     else if (IS_ACTIVE_BOMB(element))
3620       CheckDynamite(x, y);
3621     else if (element == EL_EXPLODING)
3622       Explode(x, y, Frame[x][y], EX_NORMAL);
3623     else if (element == EL_AMOEBING)
3624       AmoebeWaechst(x, y);
3625     else if (IS_AMOEBALIVE(element))
3626       AmoebeAbleger(x, y);
3627     else if (element == EL_LIFE || element == EL_LIFE_ASYNC)
3628       Life(x, y);
3629     else if (element == EL_ABLENK_EIN)
3630       Ablenk(x, y);
3631     else if (element == EL_SALZSAEURE)
3632       Blubber(x, y);
3633     else if (element == EL_BLURB_LEFT || element == EL_BLURB_RIGHT)
3634       Blurb(x, y);
3635     else if (element == EL_CRACKINGNUT)
3636       NussKnacken(x, y);
3637     else if (element == EL_AUSGANG_ZU)
3638       AusgangstuerPruefen(x, y);
3639     else if (element == EL_AUSGANG_ACT)
3640       AusgangstuerOeffnen(x, y);
3641     else if (element == EL_AUSGANG_AUF)
3642       AusgangstuerBlinken(x, y);
3643     else if (element == EL_MAUERND)
3644       MauerWaechst(x, y);
3645     else if (element == EL_MAUER_LEBT ||
3646              element == EL_MAUER_X ||
3647              element == EL_MAUER_Y ||
3648              element == EL_MAUER_XY)
3649       MauerAbleger(x, y);
3650     else if (element == EL_BURNING)
3651       CheckForDragon(x, y);
3652     else if (element == EL_SP_BUG || element == EL_SP_BUG_ACTIVE)
3653       CheckBuggyBase(x, y);
3654     else if (element == EL_SP_TERMINAL)
3655       DrawGraphicAnimation(x, y, GFX2_SP_TERMINAL, 7, 12, ANIM_NORMAL);
3656     else if (element == EL_SP_TERMINAL_ACTIVE)
3657       DrawGraphicAnimation(x, y, GFX2_SP_TERMINAL_ACTIVE, 7, 4, ANIM_NORMAL);
3658
3659     if (game.magic_wall_active)
3660     {
3661       boolean sieb = FALSE;
3662       int jx = local_player->jx, jy = local_player->jy;
3663
3664       if (element == EL_SIEB_LEER || element == EL_SIEB_VOLL ||
3665           Store[x][y] == EL_SIEB_LEER)
3666       {
3667         SiebAktivieren(x, y, 1);
3668         sieb = TRUE;
3669       }
3670       else if (element == EL_SIEB2_LEER || element == EL_SIEB2_VOLL ||
3671                Store[x][y] == EL_SIEB2_LEER)
3672       {
3673         SiebAktivieren(x, y, 2);
3674         sieb = TRUE;
3675       }
3676
3677       /* play the element sound at the position nearest to the player */
3678       if (sieb && ABS(x-jx)+ABS(y-jy) < ABS(sieb_x-jx)+ABS(sieb_y-jy))
3679       {
3680         sieb_x = x;
3681         sieb_y = y;
3682       }
3683     }
3684   }
3685
3686   if (game.magic_wall_active)
3687   {
3688     if (!(game.magic_wall_time_left % 4))
3689       PlaySoundLevel(sieb_x, sieb_y, SND_MIEP);
3690
3691     if (game.magic_wall_time_left > 0)
3692     {
3693       game.magic_wall_time_left--;
3694       if (!game.magic_wall_time_left)
3695       {
3696         for (y=0; y<lev_fieldy; y++) for (x=0; x<lev_fieldx; x++)
3697         {
3698           element = Feld[x][y];
3699           if (element == EL_SIEB_LEER || element == EL_SIEB_VOLL)
3700           {
3701             Feld[x][y] = EL_SIEB_TOT;
3702             DrawLevelField(x, y);
3703           }
3704           else if (element == EL_SIEB2_LEER || element == EL_SIEB2_VOLL)
3705           {
3706             Feld[x][y] = EL_SIEB2_TOT;
3707             DrawLevelField(x, y);
3708           }
3709         }
3710
3711         game.magic_wall_active = FALSE;
3712       }
3713     }
3714   }
3715
3716   if (TimeFrames >= (1000 / GameFrameDelay) && !tape.pausing)
3717   {
3718     TimeFrames = 0;
3719     TimePlayed++;
3720
3721     if (tape.recording || tape.playing)
3722       DrawVideoDisplay(VIDEO_STATE_TIME_ON, TimePlayed);
3723
3724     if (TimeLeft > 0)
3725     {
3726       TimeLeft--;
3727
3728       if (TimeLeft <= 10)
3729         PlaySoundStereo(SND_GONG, PSND_MAX_RIGHT);
3730
3731       DrawText(DX_TIME, DY_TIME, int2str(TimeLeft, 3), FS_SMALL, FC_YELLOW);
3732
3733       if (!TimeLeft)
3734         for (i=0; i<MAX_PLAYERS; i++)
3735           KillHero(&stored_player[i]);
3736     }
3737     else if (level.time == 0)           /* level without time limit */
3738       DrawText(DX_TIME, DY_TIME, int2str(TimePlayed, 3), FS_SMALL, FC_YELLOW);
3739   }
3740
3741   DrawAllPlayers();
3742 }
3743
3744 static boolean AllPlayersInSight(struct PlayerInfo *player, int x, int y)
3745 {
3746   int min_x = x, min_y = y, max_x = x, max_y = y;
3747   int i;
3748
3749   for (i=0; i<MAX_PLAYERS; i++)
3750   {
3751     int jx = stored_player[i].jx, jy = stored_player[i].jy;
3752
3753     if (!stored_player[i].active || &stored_player[i] == player)
3754       continue;
3755
3756     min_x = MIN(min_x, jx);
3757     min_y = MIN(min_y, jy);
3758     max_x = MAX(max_x, jx);
3759     max_y = MAX(max_y, jy);
3760   }
3761
3762   return (max_x - min_x < SCR_FIELDX && max_y - min_y < SCR_FIELDY);
3763 }
3764
3765 static boolean AllPlayersInVisibleScreen()
3766 {
3767   int i;
3768
3769   for (i=0; i<MAX_PLAYERS; i++)
3770   {
3771     int jx = stored_player[i].jx, jy = stored_player[i].jy;
3772
3773     if (!stored_player[i].active)
3774       continue;
3775
3776     if (!IN_VIS_FIELD(SCREENX(jx), SCREENY(jy)))
3777       return FALSE;
3778   }
3779
3780   return TRUE;
3781 }
3782
3783 void ScrollLevel(int dx, int dy)
3784 {
3785   int softscroll_offset = (setup.soft_scrolling ? TILEX : 0);
3786   int x, y;
3787
3788   XCopyArea(display, drawto_field, drawto_field, gc,
3789             FX + TILEX*(dx == -1) - softscroll_offset,
3790             FY + TILEY*(dy == -1) - softscroll_offset,
3791             SXSIZE - TILEX*(dx!=0) + 2*softscroll_offset,
3792             SYSIZE - TILEY*(dy!=0) + 2*softscroll_offset,
3793             FX + TILEX*(dx == 1) - softscroll_offset,
3794             FY + TILEY*(dy == 1) - softscroll_offset);
3795
3796   if (dx)
3797   {
3798     x = (dx == 1 ? BX1 : BX2);
3799     for (y=BY1; y<=BY2; y++)
3800       DrawScreenField(x, y);
3801   }
3802   if (dy)
3803   {
3804     y = (dy == 1 ? BY1 : BY2);
3805     for (x=BX1; x<=BX2; x++)
3806       DrawScreenField(x, y);
3807   }
3808
3809   redraw_mask |= REDRAW_FIELD;
3810 }
3811
3812 static void CheckGravityMovement(struct PlayerInfo *player)
3813 {
3814   if (level.gravity && !player->programmed_action)
3815   {
3816     int move_dir_vertical = player->action & (MV_UP | MV_DOWN);
3817     int move_dir_horizontal = player->action & (MV_LEFT | MV_RIGHT);
3818     int move_dir =
3819       (player->last_move_dir & (MV_LEFT | MV_RIGHT) ?
3820        (move_dir_vertical ? move_dir_vertical : move_dir_horizontal) :
3821        (move_dir_horizontal ? move_dir_horizontal : move_dir_vertical));
3822     int jx = player->jx, jy = player->jy;
3823     int dx = (move_dir & MV_LEFT ? -1 : move_dir & MV_RIGHT ? +1 : 0);
3824     int dy = (move_dir & MV_UP ? -1 : move_dir & MV_DOWN ? +1 : 0);
3825     int new_jx = jx + dx, new_jy = jy + dy;
3826     boolean field_under_player_is_free =
3827       (IN_LEV_FIELD(jx, jy + 1) && IS_FREE(jx, jy + 1));
3828     boolean player_is_moving_to_valid_field =
3829       (IN_LEV_FIELD(new_jx, new_jy) &&
3830        (Feld[new_jx][new_jy] == EL_SP_BASE ||
3831         Feld[new_jx][new_jy] == EL_ERDREICH));
3832
3833     if (field_under_player_is_free && !player_is_moving_to_valid_field)
3834       player->programmed_action = MV_DOWN;
3835   }
3836 }
3837
3838 boolean MoveFigureOneStep(struct PlayerInfo *player,
3839                           int dx, int dy, int real_dx, int real_dy)
3840 {
3841   int jx = player->jx, jy = player->jy;
3842   int new_jx = jx+dx, new_jy = jy+dy;
3843   int element;
3844   int can_move;
3845
3846   if (!player->active || (!dx && !dy))
3847     return MF_NO_ACTION;
3848
3849   player->MovDir = (dx < 0 ? MV_LEFT :
3850                     dx > 0 ? MV_RIGHT :
3851                     dy < 0 ? MV_UP :
3852                     dy > 0 ? MV_DOWN :  MV_NO_MOVING);
3853
3854   if (!IN_LEV_FIELD(new_jx, new_jy))
3855     return MF_NO_ACTION;
3856
3857   if (!options.network && !AllPlayersInSight(player, new_jx, new_jy))
3858     return MF_NO_ACTION;
3859
3860 #if 0
3861   element = MovingOrBlocked2Element(new_jx, new_jy);
3862 #else
3863   element = MovingOrBlocked2ElementIfNotLeaving(new_jx, new_jy);
3864 #endif
3865
3866   if (DONT_GO_TO(element))
3867   {
3868     if (element == EL_SALZSAEURE && dx == 0 && dy == 1)
3869     {
3870       Blurb(jx, jy);
3871       Feld[jx][jy] = EL_SPIELFIGUR;
3872       InitMovingField(jx, jy, MV_DOWN);
3873       Store[jx][jy] = EL_SALZSAEURE;
3874       ContinueMoving(jx, jy);
3875       BuryHero(player);
3876     }
3877     else
3878       KillHero(player);
3879
3880     return MF_MOVING;
3881   }
3882
3883   can_move = DigField(player, new_jx, new_jy, real_dx, real_dy, DF_DIG);
3884   if (can_move != MF_MOVING)
3885     return can_move;
3886
3887   StorePlayer[jx][jy] = 0;
3888   player->last_jx = jx;
3889   player->last_jy = jy;
3890   jx = player->jx = new_jx;
3891   jy = player->jy = new_jy;
3892   StorePlayer[jx][jy] = player->element_nr;
3893
3894   player->MovPos =
3895     (dx > 0 || dy > 0 ? -1 : 1) * (TILEX - TILEX / player->move_delay_value);
3896
3897   ScrollFigure(player, SCROLL_INIT);
3898
3899   return MF_MOVING;
3900 }
3901
3902 boolean MoveFigure(struct PlayerInfo *player, int dx, int dy)
3903 {
3904   int jx = player->jx, jy = player->jy;
3905   int old_jx = jx, old_jy = jy;
3906   int moved = MF_NO_ACTION;
3907
3908   if (!player->active || (!dx && !dy))
3909     return FALSE;
3910
3911   if (!FrameReached(&player->move_delay, player->move_delay_value) &&
3912       !tape.playing)
3913     return FALSE;
3914
3915   /* remove the last programmed player action */
3916   player->programmed_action = 0;
3917
3918   if (player->MovPos)
3919   {
3920     /* should only happen if pre-1.2 tape recordings are played */
3921     /* this is only for backward compatibility */
3922
3923     int original_move_delay_value = player->move_delay_value;
3924
3925 #if DEBUG
3926     printf("THIS SHOULD ONLY HAPPEN WITH PRE-1.2 LEVEL TAPES.\n");
3927 #endif
3928
3929     /* scroll remaining steps with finest movement resolution */
3930     player->move_delay_value = MOVE_DELAY_NORMAL_SPEED;
3931
3932     while (player->MovPos)
3933     {
3934       ScrollFigure(player, SCROLL_GO_ON);
3935       ScrollScreen(NULL, SCROLL_GO_ON);
3936       FrameCounter++;
3937       DrawAllPlayers();
3938       BackToFront();
3939     }
3940
3941     player->move_delay_value = original_move_delay_value;
3942   }
3943
3944   if (player->last_move_dir & (MV_LEFT | MV_RIGHT))
3945   {
3946     if (!(moved |= MoveFigureOneStep(player, 0, dy, dx, dy)))
3947       moved |= MoveFigureOneStep(player, dx, 0, dx, dy);
3948   }
3949   else
3950   {
3951     if (!(moved |= MoveFigureOneStep(player, dx, 0, dx, dy)))
3952       moved |= MoveFigureOneStep(player, 0, dy, dx, dy);
3953   }
3954
3955   jx = player->jx;
3956   jy = player->jy;
3957
3958   if (moved & MF_MOVING && !ScreenMovPos &&
3959       (player == local_player || !options.network))
3960   {
3961     int old_scroll_x = scroll_x, old_scroll_y = scroll_y;
3962     int offset = (setup.scroll_delay ? 3 : 0);
3963
3964     if (!IN_VIS_FIELD(SCREENX(jx), SCREENY(jy)))
3965     {
3966       /* actual player has left the screen -- scroll in that direction */
3967       if (jx != old_jx)         /* player has moved horizontally */
3968         scroll_x += (jx - old_jx);
3969       else                      /* player has moved vertically */
3970         scroll_y += (jy - old_jy);
3971     }
3972     else
3973     {
3974       if (jx != old_jx)         /* player has moved horizontally */
3975       {
3976         if ((player->MovDir == MV_LEFT && scroll_x > jx - MIDPOSX + offset) ||
3977             (player->MovDir == MV_RIGHT && scroll_x < jx - MIDPOSX - offset))
3978           scroll_x = jx-MIDPOSX + (scroll_x < jx-MIDPOSX ? -offset : +offset);
3979
3980         /* don't scroll over playfield boundaries */
3981         if (scroll_x < SBX_Left || scroll_x > SBX_Right)
3982           scroll_x = (scroll_x < SBX_Left ? SBX_Left : SBX_Right);
3983
3984         /* don't scroll more than one field at a time */
3985         scroll_x = old_scroll_x + SIGN(scroll_x - old_scroll_x);
3986
3987         /* don't scroll against the player's moving direction */
3988         if ((player->MovDir == MV_LEFT && scroll_x > old_scroll_x) ||
3989             (player->MovDir == MV_RIGHT && scroll_x < old_scroll_x))
3990           scroll_x = old_scroll_x;
3991       }
3992       else                      /* player has moved vertically */
3993       {
3994         if ((player->MovDir == MV_UP && scroll_y > jy - MIDPOSY + offset) ||
3995             (player->MovDir == MV_DOWN && scroll_y < jy - MIDPOSY - offset))
3996           scroll_y = jy-MIDPOSY + (scroll_y < jy-MIDPOSY ? -offset : +offset);
3997
3998         /* don't scroll over playfield boundaries */
3999         if (scroll_y < SBY_Upper || scroll_y > SBY_Lower)
4000           scroll_y = (scroll_y < SBY_Upper ? SBY_Upper : SBY_Lower);
4001
4002         /* don't scroll more than one field at a time */
4003         scroll_y = old_scroll_y + SIGN(scroll_y - old_scroll_y);
4004
4005         /* don't scroll against the player's moving direction */
4006         if ((player->MovDir == MV_UP && scroll_y > old_scroll_y) ||
4007             (player->MovDir == MV_DOWN && scroll_y < old_scroll_y))
4008           scroll_y = old_scroll_y;
4009       }
4010     }
4011
4012     if (scroll_x != old_scroll_x || scroll_y != old_scroll_y)
4013     {
4014       if (!options.network && !AllPlayersInVisibleScreen())
4015       {
4016         scroll_x = old_scroll_x;
4017         scroll_y = old_scroll_y;
4018       }
4019       else
4020       {
4021         ScrollScreen(player, SCROLL_INIT);
4022         ScrollLevel(old_scroll_x - scroll_x, old_scroll_y - scroll_y);
4023       }
4024     }
4025   }
4026
4027   if (!(moved & MF_MOVING) && !player->Pushing)
4028     player->Frame = 0;
4029   else
4030     player->Frame = (player->Frame + 1) % 4;
4031
4032   if (moved & MF_MOVING)
4033   {
4034     if (old_jx != jx && old_jy == jy)
4035       player->MovDir = (old_jx < jx ? MV_RIGHT : MV_LEFT);
4036     else if (old_jx == jx && old_jy != jy)
4037       player->MovDir = (old_jy < jy ? MV_DOWN : MV_UP);
4038
4039     DrawLevelField(jx, jy);     /* for "ErdreichAnbroeckeln()" */
4040
4041     player->last_move_dir = player->MovDir;
4042   }
4043   else
4044   {
4045     CheckGravityMovement(player);
4046
4047     player->last_move_dir = MV_NO_MOVING;
4048   }
4049
4050   TestIfHeroHitsBadThing(jx, jy);
4051
4052   if (!player->active)
4053     RemoveHero(player);
4054
4055   return moved;
4056 }
4057
4058 void ScrollFigure(struct PlayerInfo *player, int mode)
4059 {
4060   int jx = player->jx, jy = player->jy;
4061   int last_jx = player->last_jx, last_jy = player->last_jy;
4062   int move_stepsize = TILEX / player->move_delay_value;
4063
4064   if (!player->active || !player->MovPos)
4065     return;
4066
4067   if (mode == SCROLL_INIT)
4068   {
4069     player->actual_frame_counter = FrameCounter;
4070     player->GfxPos = move_stepsize * (player->MovPos / move_stepsize);
4071
4072     if (Feld[last_jx][last_jy] == EL_LEERRAUM)
4073       Feld[last_jx][last_jy] = EL_PLAYER_IS_LEAVING;
4074
4075     DrawPlayer(player);
4076     return;
4077   }
4078   else if (!FrameReached(&player->actual_frame_counter, 1))
4079     return;
4080
4081   player->MovPos += (player->MovPos > 0 ? -1 : 1) * move_stepsize;
4082   player->GfxPos = move_stepsize * (player->MovPos / move_stepsize);
4083
4084   if (Feld[last_jx][last_jy] == EL_PLAYER_IS_LEAVING)
4085     Feld[last_jx][last_jy] = EL_LEERRAUM;
4086
4087   /* before DrawPlayer() to draw correct player graphic for this case */
4088   if (player->MovPos == 0)
4089     CheckGravityMovement(player);
4090
4091   DrawPlayer(player);
4092
4093   if (player->MovPos == 0)
4094   {
4095     if (IS_QUICK_GATE(Feld[last_jx][last_jy]))
4096     {
4097       /* continue with normal speed after quickly moving through gate */
4098       HALVE_PLAYER_SPEED(player);
4099
4100       /* be able to make the next move without delay */
4101       player->move_delay = 0;
4102     }
4103
4104     player->last_jx = jx;
4105     player->last_jy = jy;
4106
4107     if (Feld[jx][jy] == EL_AUSGANG_AUF)
4108     {
4109       RemoveHero(player);
4110
4111       if (!local_player->friends_still_needed)
4112         player->LevelSolved = player->GameOver = TRUE;
4113     }
4114   }
4115 }
4116
4117 void ScrollScreen(struct PlayerInfo *player, int mode)
4118 {
4119   static unsigned long screen_frame_counter = 0;
4120
4121   if (mode == SCROLL_INIT)
4122   {
4123     /* set scrolling step size according to actual player's moving speed */
4124     ScrollStepSize = TILEX / player->move_delay_value;
4125
4126     screen_frame_counter = FrameCounter;
4127     ScreenMovDir = player->MovDir;
4128     ScreenMovPos = player->MovPos;
4129     ScreenGfxPos = ScrollStepSize * (ScreenMovPos / ScrollStepSize);
4130     return;
4131   }
4132   else if (!FrameReached(&screen_frame_counter, 1))
4133     return;
4134
4135   if (ScreenMovPos)
4136   {
4137     ScreenMovPos += (ScreenMovPos > 0 ? -1 : 1) * ScrollStepSize;
4138     ScreenGfxPos = ScrollStepSize * (ScreenMovPos / ScrollStepSize);
4139     redraw_mask |= REDRAW_FIELD;
4140   }
4141   else
4142     ScreenMovDir = MV_NO_MOVING;
4143 }
4144
4145 void TestIfGoodThingHitsBadThing(int goodx, int goody)
4146 {
4147   int i, killx = goodx, killy = goody;
4148   static int xy[4][2] =
4149   {
4150     { 0, -1 },
4151     { -1, 0 },
4152     { +1, 0 },
4153     { 0, +1 }
4154   };
4155   static int harmless[4] =
4156   {
4157     MV_UP,
4158     MV_LEFT,
4159     MV_RIGHT,
4160     MV_DOWN
4161   };
4162
4163   for (i=0; i<4; i++)
4164   {
4165     int x, y, element;
4166
4167     x = goodx + xy[i][0];
4168     y = goody + xy[i][1];
4169     if (!IN_LEV_FIELD(x, y))
4170       continue;
4171
4172 #if 0
4173     element = Feld[x][y];
4174 #else
4175     element = MovingOrBlocked2ElementIfNotLeaving(x, y);
4176 #endif
4177
4178     if (DONT_TOUCH(element))
4179     {
4180       if (MovDir[x][y] == harmless[i])
4181         continue;
4182
4183       killx = x;
4184       killy = y;
4185       break;
4186     }
4187   }
4188
4189   if (killx != goodx || killy != goody)
4190   {
4191     if (IS_PLAYER(goodx, goody))
4192       KillHero(PLAYERINFO(goodx, goody));
4193     else
4194       Bang(goodx, goody);
4195   }
4196 }
4197
4198 void TestIfBadThingHitsGoodThing(int badx, int bady)
4199 {
4200   int i, killx = badx, killy = bady;
4201   static int xy[4][2] =
4202   {
4203     { 0, -1 },
4204     { -1, 0 },
4205     { +1, 0 },
4206     { 0, +1 }
4207   };
4208   static int harmless[4] =
4209   {
4210     MV_UP,
4211     MV_LEFT,
4212     MV_RIGHT,
4213     MV_DOWN
4214   };
4215
4216   for (i=0; i<4; i++)
4217   {
4218     int x, y, element;
4219
4220     x = badx + xy[i][0];
4221     y = bady + xy[i][1];
4222     if (!IN_LEV_FIELD(x, y))
4223       continue;
4224
4225     element = Feld[x][y];
4226
4227     if (IS_PLAYER(x, y))
4228     {
4229       killx = x;
4230       killy = y;
4231       break;
4232     }
4233     else if (element == EL_PINGUIN)
4234     {
4235       if (MovDir[x][y] == harmless[i] && IS_MOVING(x, y))
4236         continue;
4237
4238       killx = x;
4239       killy = y;
4240       break;
4241     }
4242   }
4243
4244   if (killx != badx || killy != bady)
4245   {
4246     if (IS_PLAYER(killx, killy))
4247       KillHero(PLAYERINFO(killx, killy));
4248     else
4249       Bang(killx, killy);
4250   }
4251 }
4252
4253 void TestIfHeroHitsBadThing(int x, int y)
4254 {
4255   TestIfGoodThingHitsBadThing(x, y);
4256 }
4257
4258 void TestIfBadThingHitsHero(int x, int y)
4259 {
4260   TestIfBadThingHitsGoodThing(x, y);
4261 }
4262
4263 void TestIfFriendHitsBadThing(int x, int y)
4264 {
4265   TestIfGoodThingHitsBadThing(x, y);
4266 }
4267
4268 void TestIfBadThingHitsFriend(int x, int y)
4269 {
4270   TestIfBadThingHitsGoodThing(x, y);
4271 }
4272
4273 void TestIfBadThingHitsOtherBadThing(int badx, int bady)
4274 {
4275   int i, killx = badx, killy = bady;
4276   static int xy[4][2] =
4277   {
4278     { 0, -1 },
4279     { -1, 0 },
4280     { +1, 0 },
4281     { 0, +1 }
4282   };
4283
4284   for (i=0; i<4; i++)
4285   {
4286     int x, y, element;
4287
4288     x=badx + xy[i][0];
4289     y=bady + xy[i][1];
4290     if (!IN_LEV_FIELD(x, y))
4291       continue;
4292
4293     element = Feld[x][y];
4294     if (IS_AMOEBOID(element) || element == EL_LIFE ||
4295         element == EL_AMOEBING || element == EL_TROPFEN)
4296     {
4297       killx = x;
4298       killy = y;
4299       break;
4300     }
4301   }
4302
4303   if (killx != badx || killy != bady)
4304     Bang(badx, bady);
4305 }
4306
4307 void KillHero(struct PlayerInfo *player)
4308 {
4309   int jx = player->jx, jy = player->jy;
4310
4311   if (!player->active)
4312     return;
4313
4314   if (IS_PFORTE(Feld[jx][jy]))
4315     Feld[jx][jy] = EL_LEERRAUM;
4316
4317   Bang(jx, jy);
4318   BuryHero(player);
4319 }
4320
4321 void BuryHero(struct PlayerInfo *player)
4322 {
4323   int jx = player->jx, jy = player->jy;
4324
4325   if (!player->active)
4326     return;
4327
4328   PlaySoundLevel(jx, jy, SND_AUTSCH);
4329   PlaySoundLevel(jx, jy, SND_LACHEN);
4330
4331   player->GameOver = TRUE;
4332   RemoveHero(player);
4333 }
4334
4335 void RemoveHero(struct PlayerInfo *player)
4336 {
4337   int jx = player->jx, jy = player->jy;
4338   int i, found = FALSE;
4339
4340   player->present = FALSE;
4341   player->active = FALSE;
4342
4343   StorePlayer[jx][jy] = 0;
4344
4345   for (i=0; i<MAX_PLAYERS; i++)
4346     if (stored_player[i].active)
4347       found = TRUE;
4348
4349   if (!found)
4350     AllPlayersGone = TRUE;
4351
4352   ExitX = ZX = jx;
4353   ExitY = ZY = jy;
4354 }
4355
4356 int DigField(struct PlayerInfo *player,
4357              int x, int y, int real_dx, int real_dy, int mode)
4358 {
4359   int jx = player->jx, jy = player->jy;
4360   int dx = x - jx, dy = y - jy;
4361   int move_direction = (dx == -1 ? MV_LEFT :
4362                         dx == +1 ? MV_RIGHT :
4363                         dy == -1 ? MV_UP :
4364                         dy == +1 ? MV_DOWN : MV_NO_MOVING);
4365   int element;
4366
4367   if (!player->MovPos)
4368     player->Pushing = FALSE;
4369
4370   if (mode == DF_NO_PUSH)
4371   {
4372     player->Switching = FALSE;
4373     player->push_delay = 0;
4374     return MF_NO_ACTION;
4375   }
4376
4377   if (IS_MOVING(x, y) || IS_PLAYER(x, y))
4378     return MF_NO_ACTION;
4379
4380   element = Feld[x][y];
4381
4382   switch (element)
4383   {
4384     case EL_LEERRAUM:
4385       PlaySoundLevel(x, y, SND_EMPTY);
4386       break;
4387
4388     case EL_ERDREICH:
4389       Feld[x][y] = EL_LEERRAUM;
4390       PlaySoundLevel(x, y, SND_SCHLURF);
4391       break;
4392
4393     case EL_SP_BASE:
4394     case EL_SP_BUG:
4395       Feld[x][y] = EL_LEERRAUM;
4396       PlaySoundLevel(x, y, SND_SP_BASE);
4397       break;
4398
4399     case EL_EDELSTEIN:
4400     case EL_EDELSTEIN_BD:
4401     case EL_EDELSTEIN_GELB:
4402     case EL_EDELSTEIN_ROT:
4403     case EL_EDELSTEIN_LILA:
4404     case EL_DIAMANT:
4405     case EL_SP_INFOTRON:
4406       RemoveField(x, y);
4407       local_player->gems_still_needed -= (element == EL_DIAMANT ? 3 : 1);
4408       if (local_player->gems_still_needed < 0)
4409         local_player->gems_still_needed = 0;
4410       RaiseScoreElement(element);
4411       DrawText(DX_EMERALDS, DY_EMERALDS,
4412                int2str(local_player->gems_still_needed, 3),
4413                FS_SMALL, FC_YELLOW);
4414       if (element == EL_SP_INFOTRON)
4415         PlaySoundLevel(x, y, SND_SP_INFOTRON);
4416       else
4417         PlaySoundLevel(x, y, SND_PONG);
4418       break;
4419
4420     case EL_SPEED_PILL:
4421       RemoveField(x, y);
4422       player->move_delay_value = MOVE_DELAY_HIGH_SPEED;
4423       PlaySoundLevel(x, y, SND_PONG);
4424       break;
4425
4426     case EL_DYNAMITE_INACTIVE:
4427     case EL_SP_DISK_RED:
4428       RemoveField(x, y);
4429       player->dynamite++;
4430       RaiseScoreElement(EL_DYNAMITE_INACTIVE);
4431       DrawText(DX_DYNAMITE, DY_DYNAMITE,
4432                int2str(local_player->dynamite, 3),
4433                FS_SMALL, FC_YELLOW);
4434       if (element == EL_SP_DISK_RED)
4435         PlaySoundLevel(x, y, SND_SP_INFOTRON);
4436       else
4437         PlaySoundLevel(x, y, SND_PONG);
4438       break;
4439
4440     case EL_DYNABOMB_NR:
4441       RemoveField(x, y);
4442       player->dynabomb_count++;
4443       player->dynabombs_left++;
4444       RaiseScoreElement(EL_DYNAMITE_INACTIVE);
4445       PlaySoundLevel(x, y, SND_PONG);
4446       break;
4447
4448     case EL_DYNABOMB_SZ:
4449       RemoveField(x, y);
4450       player->dynabomb_size++;
4451       RaiseScoreElement(EL_DYNAMITE_INACTIVE);
4452       PlaySoundLevel(x, y, SND_PONG);
4453       break;
4454
4455     case EL_DYNABOMB_XL:
4456       RemoveField(x, y);
4457       player->dynabomb_xl = TRUE;
4458       RaiseScoreElement(EL_DYNAMITE_INACTIVE);
4459       PlaySoundLevel(x, y, SND_PONG);
4460       break;
4461
4462     case EL_SCHLUESSEL1:
4463     case EL_SCHLUESSEL2:
4464     case EL_SCHLUESSEL3:
4465     case EL_SCHLUESSEL4:
4466     {
4467       int key_nr = element - EL_SCHLUESSEL1;
4468
4469       RemoveField(x, y);
4470       player->key[key_nr] = TRUE;
4471       RaiseScoreElement(EL_SCHLUESSEL);
4472       DrawMiniGraphicExt(drawto, gc,
4473                          DX_KEYS+key_nr*MINI_TILEX, DY_KEYS,
4474                          GFX_SCHLUESSEL1+key_nr);
4475       DrawMiniGraphicExt(window, gc,
4476                          DX_KEYS+key_nr*MINI_TILEX, DY_KEYS,
4477                          GFX_SCHLUESSEL1+key_nr);
4478       PlaySoundLevel(x, y, SND_PONG);
4479       break;
4480     }
4481
4482     case EL_EM_KEY_1:
4483     case EL_EM_KEY_2:
4484     case EL_EM_KEY_3:
4485     case EL_EM_KEY_4:
4486     {
4487       int key_nr = element - EL_EM_KEY_1;
4488
4489       RemoveField(x, y);
4490       player->key[key_nr] = TRUE;
4491       RaiseScoreElement(EL_SCHLUESSEL);
4492       DrawMiniGraphicExt(drawto, gc,
4493                          DX_KEYS+key_nr*MINI_TILEX, DY_KEYS,
4494                          GFX_SCHLUESSEL1+key_nr);
4495       DrawMiniGraphicExt(window, gc,
4496                          DX_KEYS+key_nr*MINI_TILEX, DY_KEYS,
4497                          GFX_SCHLUESSEL1+key_nr);
4498       PlaySoundLevel(x, y, SND_PONG);
4499       break;
4500     }
4501
4502     case EL_ABLENK_AUS:
4503       Feld[x][y] = EL_ABLENK_EIN;
4504       ZX = x;
4505       ZY = y;
4506       DrawLevelField(x, y);
4507       return MF_ACTION;
4508       break;
4509
4510     case EL_SP_TERMINAL:
4511       {
4512         int xx, yy;
4513
4514         for (yy=0; yy<lev_fieldy; yy++)
4515         {
4516           for (xx=0; xx<lev_fieldx; xx++)
4517           {
4518             if (Feld[xx][yy] == EL_SP_DISK_YELLOW)
4519               Bang(xx, yy);
4520             else if (Feld[xx][yy] == EL_SP_TERMINAL)
4521               Feld[xx][yy] = EL_SP_TERMINAL_ACTIVE;
4522           }
4523         }
4524
4525         return MF_ACTION;
4526       }
4527       break;
4528
4529     case EL_BELT1_SWITCH_L:
4530     case EL_BELT1_SWITCH_M:
4531     case EL_BELT1_SWITCH_R:
4532     case EL_BELT2_SWITCH_L:
4533     case EL_BELT2_SWITCH_M:
4534     case EL_BELT2_SWITCH_R:
4535     case EL_BELT3_SWITCH_L:
4536     case EL_BELT3_SWITCH_M:
4537     case EL_BELT3_SWITCH_R:
4538     case EL_BELT4_SWITCH_L:
4539     case EL_BELT4_SWITCH_M:
4540     case EL_BELT4_SWITCH_R:
4541       {
4542         static int belt_base_element[4] =
4543         {
4544           EL_BELT1_SWITCH_L,
4545           EL_BELT2_SWITCH_L,
4546           EL_BELT3_SWITCH_L,
4547           EL_BELT4_SWITCH_L
4548         };
4549         static int belt_move_dir[3] =
4550         {
4551           MV_LEFT,
4552           MV_NO_MOVING,
4553           MV_RIGHT
4554         };
4555
4556         int belt_nr = (element < EL_BELT2_SWITCH_L ? 0 :
4557                        element < EL_BELT3_SWITCH_L ? 1 :
4558                        element < EL_BELT4_SWITCH_L ? 2 : 3);
4559         int belt_dir_nr = element - belt_base_element[belt_nr];
4560         int belt_dir_nr_next = (belt_dir_nr + 1) % 3;
4561         int belt_dir_next = belt_move_dir[belt_dir_nr_next];
4562         int xx, yy;
4563
4564         if (player->Switching)
4565           return MF_ACTION;
4566
4567         game.belt_dir[belt_nr] = belt_dir_next;
4568
4569         for (yy=0; yy<lev_fieldy; yy++)
4570         {
4571           for (xx=0; xx<lev_fieldx; xx++)
4572           {
4573             if (IS_BELT_SWITCH(Feld[xx][yy]))
4574             {
4575               int e = Feld[xx][yy];
4576               int e_belt_nr = (e < EL_BELT2_SWITCH_L ? 0 :
4577                                e < EL_BELT3_SWITCH_L ? 1 :
4578                                e < EL_BELT4_SWITCH_L ? 2 : 3);
4579
4580               if (e_belt_nr == belt_nr)
4581               {
4582                 Feld[xx][yy] = belt_base_element[belt_nr] + belt_dir_nr_next;
4583                 DrawLevelField(xx, yy);
4584               }
4585             }
4586           }
4587         }
4588
4589         player->Switching = TRUE;
4590
4591         return MF_ACTION;
4592       }
4593       break;
4594
4595     case EL_SP_EXIT:
4596       if (local_player->gems_still_needed > 0)
4597         return MF_NO_ACTION;
4598
4599       player->LevelSolved = player->GameOver = TRUE;
4600       PlaySoundStereo(SND_SP_EXIT, PSND_MAX_RIGHT);
4601       break;
4602
4603     case EL_FELSBROCKEN:
4604     case EL_BOMBE:
4605     case EL_KOKOSNUSS:
4606     case EL_ZEIT_LEER:
4607     case EL_SP_ZONK:
4608     case EL_SP_DISK_ORANGE:
4609       if (dy || mode == DF_SNAP)
4610         return MF_NO_ACTION;
4611
4612       player->Pushing = TRUE;
4613
4614       if (!IN_LEV_FIELD(x+dx, y+dy) || !IS_FREE(x+dx, y+dy))
4615         return MF_NO_ACTION;
4616
4617       if (real_dy)
4618       {
4619         if (IN_LEV_FIELD(jx, jy+real_dy) && !IS_SOLID(Feld[jx][jy+real_dy]))
4620           return MF_NO_ACTION;
4621       }
4622
4623       if (player->push_delay == 0)
4624         player->push_delay = FrameCounter;
4625       if (!FrameReached(&player->push_delay, player->push_delay_value) &&
4626           !tape.playing)
4627         return MF_NO_ACTION;
4628
4629       RemoveField(x, y);
4630       Feld[x+dx][y+dy] = element;
4631
4632       player->push_delay_value = 2+RND(8);
4633
4634       DrawLevelField(x+dx, y+dy);
4635       if (element == EL_FELSBROCKEN)
4636         PlaySoundLevel(x+dx, y+dy, SND_PUSCH);
4637       else if (element == EL_KOKOSNUSS)
4638         PlaySoundLevel(x+dx, y+dy, SND_KNURK);
4639       else if (IS_SP_ELEMENT(element))
4640         PlaySoundLevel(x+dx, y+dy, SND_SP_ZONKPUSH);
4641       else
4642         PlaySoundLevel(x+dx, y+dy, SND_KLOPF);
4643       break;
4644
4645     case EL_PFORTE1:
4646     case EL_PFORTE2:
4647     case EL_PFORTE3:
4648     case EL_PFORTE4:
4649       if (!player->key[element - EL_PFORTE1])
4650         return MF_NO_ACTION;
4651       break;
4652
4653     case EL_PFORTE1X:
4654     case EL_PFORTE2X:
4655     case EL_PFORTE3X:
4656     case EL_PFORTE4X:
4657       if (!player->key[element - EL_PFORTE1X])
4658         return MF_NO_ACTION;
4659       break;
4660
4661     case EL_EM_GATE_1:
4662     case EL_EM_GATE_2:
4663     case EL_EM_GATE_3:
4664     case EL_EM_GATE_4:
4665       if (!player->key[element - EL_EM_GATE_1])
4666         return MF_NO_ACTION;
4667       if (!IN_LEV_FIELD(x + dx, y + dy) || !IS_FREE(x + dx, y + dy))
4668         return MF_NO_ACTION;
4669
4670       /* automatically move to the next field with double speed */
4671       player->programmed_action = move_direction;
4672       DOUBLE_PLAYER_SPEED(player);
4673
4674       PlaySoundLevel(x, y, SND_GATE);
4675
4676       break;
4677
4678     case EL_EM_GATE_1X:
4679     case EL_EM_GATE_2X:
4680     case EL_EM_GATE_3X:
4681     case EL_EM_GATE_4X:
4682       if (!player->key[element - EL_EM_GATE_1X])
4683         return MF_NO_ACTION;
4684       if (!IN_LEV_FIELD(x + dx, y + dy) || !IS_FREE(x + dx, y + dy))
4685         return MF_NO_ACTION;
4686
4687       /* automatically move to the next field with double speed */
4688       player->programmed_action = move_direction;
4689       DOUBLE_PLAYER_SPEED(player);
4690
4691       PlaySoundLevel(x, y, SND_GATE);
4692
4693       break;
4694
4695     case EL_SP_PORT1_LEFT:
4696     case EL_SP_PORT2_LEFT:
4697     case EL_SP_PORT1_RIGHT:
4698     case EL_SP_PORT2_RIGHT:
4699     case EL_SP_PORT1_UP:
4700     case EL_SP_PORT2_UP:
4701     case EL_SP_PORT1_DOWN:
4702     case EL_SP_PORT2_DOWN:
4703     case EL_SP_PORT_X:
4704     case EL_SP_PORT_Y:
4705     case EL_SP_PORT_XY:
4706       if ((dx == -1 &&
4707            element != EL_SP_PORT1_LEFT &&
4708            element != EL_SP_PORT2_LEFT &&
4709            element != EL_SP_PORT_X &&
4710            element != EL_SP_PORT_XY) ||
4711           (dx == +1 &&
4712            element != EL_SP_PORT1_RIGHT &&
4713            element != EL_SP_PORT2_RIGHT &&
4714            element != EL_SP_PORT_X &&
4715            element != EL_SP_PORT_XY) ||
4716           (dy == -1 &&
4717            element != EL_SP_PORT1_UP &&
4718            element != EL_SP_PORT2_UP &&
4719            element != EL_SP_PORT_Y &&
4720            element != EL_SP_PORT_XY) ||
4721           (dy == +1 &&
4722            element != EL_SP_PORT1_DOWN &&
4723            element != EL_SP_PORT2_DOWN &&
4724            element != EL_SP_PORT_Y &&
4725            element != EL_SP_PORT_XY) ||
4726           !IN_LEV_FIELD(x + dx, y + dy) ||
4727           !IS_FREE(x + dx, y + dy))
4728         return MF_NO_ACTION;
4729
4730       /* automatically move to the next field with double speed */
4731       player->programmed_action = move_direction;
4732       DOUBLE_PLAYER_SPEED(player);
4733
4734       PlaySoundLevel(x, y, SND_GATE);
4735
4736       break;
4737
4738     case EL_AUSGANG_ZU:
4739     case EL_AUSGANG_ACT:
4740       /* door is not (yet) open */
4741       return MF_NO_ACTION;
4742       break;
4743
4744     case EL_AUSGANG_AUF:
4745       if (mode == DF_SNAP)
4746         return MF_NO_ACTION;
4747
4748       PlaySoundLevel(x, y, SND_BUING);
4749
4750       break;
4751
4752     case EL_BIRNE_AUS:
4753       Feld[x][y] = EL_BIRNE_EIN;
4754       local_player->lights_still_needed--;
4755       DrawLevelField(x, y);
4756       PlaySoundLevel(x, y, SND_DENG);
4757       return MF_ACTION;
4758       break;
4759
4760     case EL_ZEIT_VOLL:
4761       Feld[x][y] = EL_ZEIT_LEER;
4762       TimeLeft += 10;
4763       DrawText(DX_TIME, DY_TIME, int2str(TimeLeft, 3), FS_SMALL, FC_YELLOW);
4764       DrawLevelField(x, y);
4765       PlaySoundStereo(SND_GONG, PSND_MAX_RIGHT);
4766       return MF_ACTION;
4767       break;
4768
4769     case EL_SOKOBAN_FELD_LEER:
4770       break;
4771
4772     case EL_SOKOBAN_FELD_VOLL:
4773     case EL_SOKOBAN_OBJEKT:
4774     case EL_SONDE:
4775     case EL_SP_DISK_YELLOW:
4776       if (mode == DF_SNAP)
4777         return MF_NO_ACTION;
4778
4779       player->Pushing = TRUE;
4780
4781       if (!IN_LEV_FIELD(x+dx, y+dy)
4782           || (!IS_FREE(x+dx, y+dy)
4783               && (Feld[x+dx][y+dy] != EL_SOKOBAN_FELD_LEER
4784                   || !IS_SB_ELEMENT(element))))
4785         return MF_NO_ACTION;
4786
4787       if (dx && real_dy)
4788       {
4789         if (IN_LEV_FIELD(jx, jy+real_dy) && !IS_SOLID(Feld[jx][jy+real_dy]))
4790           return MF_NO_ACTION;
4791       }
4792       else if (dy && real_dx)
4793       {
4794         if (IN_LEV_FIELD(jx+real_dx, jy) && !IS_SOLID(Feld[jx+real_dx][jy]))
4795           return MF_NO_ACTION;
4796       }
4797
4798       if (player->push_delay == 0)
4799         player->push_delay = FrameCounter;
4800       if (!FrameReached(&player->push_delay, player->push_delay_value) &&
4801           !tape.playing)
4802         return MF_NO_ACTION;
4803
4804       if (IS_SB_ELEMENT(element))
4805       {
4806         if (element == EL_SOKOBAN_FELD_VOLL)
4807         {
4808           Feld[x][y] = EL_SOKOBAN_FELD_LEER;
4809           local_player->sokobanfields_still_needed++;
4810         }
4811         else
4812           RemoveField(x, y);
4813
4814         if (Feld[x+dx][y+dy] == EL_SOKOBAN_FELD_LEER)
4815         {
4816           Feld[x+dx][y+dy] = EL_SOKOBAN_FELD_VOLL;
4817           local_player->sokobanfields_still_needed--;
4818           if (element == EL_SOKOBAN_OBJEKT)
4819             PlaySoundLevel(x, y, SND_DENG);
4820         }
4821         else
4822           Feld[x+dx][y+dy] = EL_SOKOBAN_OBJEKT;
4823       }
4824       else
4825       {
4826         RemoveField(x, y);
4827         Feld[x+dx][y+dy] = element;
4828       }
4829
4830       player->push_delay_value = 2;
4831
4832       DrawLevelField(x, y);
4833       DrawLevelField(x+dx, y+dy);
4834       PlaySoundLevel(x+dx, y+dy, SND_PUSCH);
4835
4836       if (IS_SB_ELEMENT(element) &&
4837           local_player->sokobanfields_still_needed == 0 &&
4838           game.emulation == EMU_SOKOBAN)
4839       {
4840         player->LevelSolved = player->GameOver = TRUE;
4841         PlaySoundLevel(x, y, SND_BUING);
4842       }
4843
4844       break;
4845
4846     case EL_MAULWURF:
4847     case EL_PINGUIN:
4848     case EL_SCHWEIN:
4849     case EL_DRACHE:
4850       break;
4851
4852     default:
4853       return MF_NO_ACTION;
4854   }
4855
4856   player->push_delay = 0;
4857
4858   return MF_MOVING;
4859 }
4860
4861 boolean SnapField(struct PlayerInfo *player, int dx, int dy)
4862 {
4863   int jx = player->jx, jy = player->jy;
4864   int x = jx + dx, y = jy + dy;
4865
4866   if (!player->active || !IN_LEV_FIELD(x, y))
4867     return FALSE;
4868
4869   if (dx && dy)
4870     return FALSE;
4871
4872   if (!dx && !dy)
4873   {
4874     player->snapped = FALSE;
4875     return FALSE;
4876   }
4877
4878   if (player->snapped)
4879     return FALSE;
4880
4881   player->MovDir = (dx < 0 ? MV_LEFT :
4882                     dx > 0 ? MV_RIGHT :
4883                     dy < 0 ? MV_UP :
4884                     dy > 0 ? MV_DOWN :  MV_NO_MOVING);
4885
4886   if (!DigField(player, x, y, 0, 0, DF_SNAP))
4887     return FALSE;
4888
4889   player->snapped = TRUE;
4890   DrawLevelField(x, y);
4891   BackToFront();
4892
4893   return TRUE;
4894 }
4895
4896 boolean PlaceBomb(struct PlayerInfo *player)
4897 {
4898   int jx = player->jx, jy = player->jy;
4899   int element;
4900
4901   if (!player->active || player->MovPos)
4902     return FALSE;
4903
4904   element = Feld[jx][jy];
4905
4906   if ((player->dynamite == 0 && player->dynabombs_left == 0) ||
4907       IS_ACTIVE_BOMB(element) || element == EL_EXPLODING)
4908     return FALSE;
4909
4910   if (element != EL_LEERRAUM)
4911     Store[jx][jy] = element;
4912
4913   if (player->dynamite)
4914   {
4915     Feld[jx][jy] = EL_DYNAMITE_ACTIVE;
4916     MovDelay[jx][jy] = 96;
4917     player->dynamite--;
4918     DrawText(DX_DYNAMITE, DY_DYNAMITE, int2str(local_player->dynamite, 3),
4919              FS_SMALL, FC_YELLOW);
4920     if (IN_SCR_FIELD(SCREENX(jx), SCREENY(jy)))
4921     {
4922       if (game.emulation == EMU_SUPAPLEX)
4923         DrawGraphic(SCREENX(jx), SCREENY(jy), GFX_SP_DISK_RED);
4924       else
4925         DrawGraphicThruMask(SCREENX(jx), SCREENY(jy), GFX_DYNAMIT);
4926     }
4927   }
4928   else
4929   {
4930     Feld[jx][jy] = EL_DYNABOMB_ACTIVE_1 + (player->element_nr - EL_SPIELER1);
4931     MovDelay[jx][jy] = 96;
4932     player->dynabombs_left--;
4933     if (IN_SCR_FIELD(SCREENX(jx), SCREENY(jy)))
4934       DrawGraphicThruMask(SCREENX(jx), SCREENY(jy), GFX_DYNABOMB);
4935   }
4936
4937   return TRUE;
4938 }
4939
4940 void PlaySoundLevel(int x, int y, int sound_nr)
4941 {
4942   int sx = SCREENX(x), sy = SCREENY(y);
4943   int volume, stereo;
4944   int silence_distance = 8;
4945
4946   if ((!setup.sound_simple && !IS_LOOP_SOUND(sound_nr)) ||
4947       (!setup.sound_loops && IS_LOOP_SOUND(sound_nr)))
4948     return;
4949
4950   if (!IN_LEV_FIELD(x, y) ||
4951       sx < -silence_distance || sx >= SCR_FIELDX+silence_distance ||
4952       sy < -silence_distance || sy >= SCR_FIELDY+silence_distance)
4953     return;
4954
4955   volume = PSND_MAX_VOLUME;
4956
4957 #ifndef MSDOS
4958   stereo = (sx - SCR_FIELDX/2) * 12;
4959 #else
4960   stereo = PSND_MIDDLE + (2 * sx - (SCR_FIELDX - 1)) * 5;
4961   if (stereo > PSND_MAX_RIGHT)
4962     stereo = PSND_MAX_RIGHT;
4963   if (stereo < PSND_MAX_LEFT)
4964     stereo = PSND_MAX_LEFT;
4965 #endif
4966
4967   if (!IN_SCR_FIELD(sx, sy))
4968   {
4969     int dx = ABS(sx - SCR_FIELDX/2) - SCR_FIELDX/2;
4970     int dy = ABS(sy - SCR_FIELDY/2) - SCR_FIELDY/2;
4971
4972     volume -= volume * (dx > dy ? dx : dy) / silence_distance;
4973   }
4974
4975   PlaySoundExt(sound_nr, volume, stereo, PSND_NO_LOOP);
4976 }
4977
4978 void RaiseScore(int value)
4979 {
4980   local_player->score += value;
4981   DrawText(DX_SCORE, DY_SCORE, int2str(local_player->score, 5),
4982            FS_SMALL, FC_YELLOW);
4983 }
4984
4985 void RaiseScoreElement(int element)
4986 {
4987   switch(element)
4988   {
4989     case EL_EDELSTEIN:
4990     case EL_EDELSTEIN_BD:
4991     case EL_EDELSTEIN_GELB:
4992     case EL_EDELSTEIN_ROT:
4993     case EL_EDELSTEIN_LILA:
4994       RaiseScore(level.score[SC_EDELSTEIN]);
4995       break;
4996     case EL_DIAMANT:
4997       RaiseScore(level.score[SC_DIAMANT]);
4998       break;
4999     case EL_KAEFER:
5000     case EL_BUTTERFLY:
5001       RaiseScore(level.score[SC_KAEFER]);
5002       break;
5003     case EL_FLIEGER:
5004     case EL_FIREFLY:
5005       RaiseScore(level.score[SC_FLIEGER]);
5006       break;
5007     case EL_MAMPFER:
5008     case EL_MAMPFER2:
5009       RaiseScore(level.score[SC_MAMPFER]);
5010       break;
5011     case EL_ROBOT:
5012       RaiseScore(level.score[SC_ROBOT]);
5013       break;
5014     case EL_PACMAN:
5015       RaiseScore(level.score[SC_PACMAN]);
5016       break;
5017     case EL_KOKOSNUSS:
5018       RaiseScore(level.score[SC_KOKOSNUSS]);
5019       break;
5020     case EL_DYNAMITE_INACTIVE:
5021       RaiseScore(level.score[SC_DYNAMIT]);
5022       break;
5023     case EL_SCHLUESSEL:
5024       RaiseScore(level.score[SC_SCHLUESSEL]);
5025       break;
5026     default:
5027       break;
5028   }
5029 }
5030
5031 /* ---------- new game button stuff ---------------------------------------- */
5032
5033 /* graphic position values for game buttons */
5034 #define GAME_BUTTON_XSIZE       30
5035 #define GAME_BUTTON_YSIZE       30
5036 #define GAME_BUTTON_XPOS        5
5037 #define GAME_BUTTON_YPOS        215
5038 #define SOUND_BUTTON_XPOS       5
5039 #define SOUND_BUTTON_YPOS       (GAME_BUTTON_YPOS + GAME_BUTTON_YSIZE)
5040
5041 #define GAME_BUTTON_STOP_XPOS   (GAME_BUTTON_XPOS + 0 * GAME_BUTTON_XSIZE)
5042 #define GAME_BUTTON_PAUSE_XPOS  (GAME_BUTTON_XPOS + 1 * GAME_BUTTON_XSIZE)
5043 #define GAME_BUTTON_PLAY_XPOS   (GAME_BUTTON_XPOS + 2 * GAME_BUTTON_XSIZE)
5044 #define SOUND_BUTTON_MUSIC_XPOS (SOUND_BUTTON_XPOS + 0 * GAME_BUTTON_XSIZE)
5045 #define SOUND_BUTTON_LOOPS_XPOS (SOUND_BUTTON_XPOS + 1 * GAME_BUTTON_XSIZE)
5046 #define SOUND_BUTTON_SIMPLE_XPOS (SOUND_BUTTON_XPOS + 2 * GAME_BUTTON_XSIZE)
5047
5048 static struct
5049 {
5050   int x, y;
5051   int gadget_id;
5052   char *infotext;
5053 } gamebutton_info[NUM_GAME_BUTTONS] =
5054 {
5055   {
5056     GAME_BUTTON_STOP_XPOS,      GAME_BUTTON_YPOS,
5057     GAME_CTRL_ID_STOP,
5058     "stop game"
5059   },
5060   {
5061     GAME_BUTTON_PAUSE_XPOS,     GAME_BUTTON_YPOS,
5062     GAME_CTRL_ID_PAUSE,
5063     "pause game"
5064   },
5065   {
5066     GAME_BUTTON_PLAY_XPOS,      GAME_BUTTON_YPOS,
5067     GAME_CTRL_ID_PLAY,
5068     "play game"
5069   },
5070   {
5071     SOUND_BUTTON_MUSIC_XPOS,    SOUND_BUTTON_YPOS,
5072     SOUND_CTRL_ID_MUSIC,
5073     "background music on/off"
5074   },
5075   {
5076     SOUND_BUTTON_LOOPS_XPOS,    SOUND_BUTTON_YPOS,
5077     SOUND_CTRL_ID_LOOPS,
5078     "sound loops on/off"
5079   },
5080   {
5081     SOUND_BUTTON_SIMPLE_XPOS,   SOUND_BUTTON_YPOS,
5082     SOUND_CTRL_ID_SIMPLE,
5083     "normal sounds on/off"
5084   }
5085 };
5086
5087 void CreateGameButtons()
5088 {
5089   int i;
5090
5091   for (i=0; i<NUM_GAME_BUTTONS; i++)
5092   {
5093     Pixmap gd_pixmap = pix[PIX_DOOR];
5094     struct GadgetInfo *gi;
5095     int button_type;
5096     boolean checked;
5097     unsigned long event_mask;
5098     int gd_xoffset, gd_yoffset;
5099     int gd_x1, gd_x2, gd_y1, gd_y2;
5100     int id = i;
5101
5102     gd_xoffset = gamebutton_info[i].x;
5103     gd_yoffset = gamebutton_info[i].y;
5104     gd_x1 = DOOR_GFX_PAGEX4 + gd_xoffset;
5105     gd_x2 = DOOR_GFX_PAGEX3 + gd_xoffset;
5106
5107     if (id == GAME_CTRL_ID_STOP ||
5108         id == GAME_CTRL_ID_PAUSE ||
5109         id == GAME_CTRL_ID_PLAY)
5110     {
5111       button_type = GD_TYPE_NORMAL_BUTTON;
5112       checked = FALSE;
5113       event_mask = GD_EVENT_RELEASED;
5114       gd_y1  = DOOR_GFX_PAGEY1 + gd_yoffset - GAME_BUTTON_YSIZE;
5115       gd_y2  = DOOR_GFX_PAGEY1 + gd_yoffset - GAME_BUTTON_YSIZE;
5116     }
5117     else
5118     {
5119       button_type = GD_TYPE_CHECK_BUTTON;
5120       checked =
5121         ((id == SOUND_CTRL_ID_MUSIC && setup.sound_music) ||
5122          (id == SOUND_CTRL_ID_LOOPS && setup.sound_loops) ||
5123          (id == SOUND_CTRL_ID_SIMPLE && setup.sound_simple) ? TRUE : FALSE);
5124       event_mask = GD_EVENT_PRESSED;
5125       gd_y1  = DOOR_GFX_PAGEY1 + gd_yoffset;
5126       gd_y2  = DOOR_GFX_PAGEY1 + gd_yoffset - GAME_BUTTON_YSIZE;
5127     }
5128
5129     gi = CreateGadget(GDI_CUSTOM_ID, id,
5130                       GDI_INFO_TEXT, gamebutton_info[i].infotext,
5131                       GDI_X, DX + gd_xoffset,
5132                       GDI_Y, DY + gd_yoffset,
5133                       GDI_WIDTH, GAME_BUTTON_XSIZE,
5134                       GDI_HEIGHT, GAME_BUTTON_YSIZE,
5135                       GDI_TYPE, button_type,
5136                       GDI_STATE, GD_BUTTON_UNPRESSED,
5137                       GDI_CHECKED, checked,
5138                       GDI_DESIGN_UNPRESSED, gd_pixmap, gd_x1, gd_y1,
5139                       GDI_DESIGN_PRESSED, gd_pixmap, gd_x2, gd_y1,
5140                       GDI_ALT_DESIGN_UNPRESSED, gd_pixmap, gd_x1, gd_y2,
5141                       GDI_ALT_DESIGN_PRESSED, gd_pixmap, gd_x2, gd_y2,
5142                       GDI_EVENT_MASK, event_mask,
5143                       GDI_CALLBACK_ACTION, HandleGameButtons,
5144                       GDI_END);
5145
5146     if (gi == NULL)
5147       Error(ERR_EXIT, "cannot create gadget");
5148
5149     game_gadget[id] = gi;
5150   }
5151 }
5152
5153 static void MapGameButtons()
5154 {
5155   int i;
5156
5157   for (i=0; i<NUM_GAME_BUTTONS; i++)
5158     MapGadget(game_gadget[i]);
5159 }
5160
5161 void UnmapGameButtons()
5162 {
5163   int i;
5164
5165   for (i=0; i<NUM_GAME_BUTTONS; i++)
5166     UnmapGadget(game_gadget[i]);
5167 }
5168
5169 static void HandleGameButtons(struct GadgetInfo *gi)
5170 {
5171   int id = gi->custom_id;
5172
5173   if (game_status != PLAYING)
5174     return;
5175
5176   switch (id)
5177   {
5178     case GAME_CTRL_ID_STOP:
5179       if (AllPlayersGone)
5180       {
5181         CloseDoor(DOOR_CLOSE_1);
5182         game_status = MAINMENU;
5183         DrawMainMenu();
5184         break;
5185       }
5186
5187       if (level_editor_test_game ||
5188           Request("Do you really want to quit the game ?",
5189                   REQ_ASK | REQ_STAY_CLOSED))
5190       {
5191 #ifndef MSDOS
5192         if (options.network)
5193           SendToServer_StopPlaying();
5194         else
5195 #endif
5196         {
5197           game_status = MAINMENU;
5198           DrawMainMenu();
5199         }
5200       }
5201       else
5202         OpenDoor(DOOR_OPEN_1 | DOOR_COPY_BACK);
5203       break;
5204
5205     case GAME_CTRL_ID_PAUSE:
5206       if (options.network)
5207       {
5208 #ifndef MSDOS
5209         if (tape.pausing)
5210           SendToServer_ContinuePlaying();
5211         else
5212           SendToServer_PausePlaying();
5213 #endif
5214       }
5215       else
5216         TapeTogglePause();
5217       break;
5218
5219     case GAME_CTRL_ID_PLAY:
5220       if (tape.pausing)
5221       {
5222 #ifndef MSDOS
5223         if (options.network)
5224           SendToServer_ContinuePlaying();
5225         else
5226 #endif
5227         {
5228           tape.pausing = FALSE;
5229           DrawVideoDisplay(VIDEO_STATE_PAUSE_OFF,0);
5230         }
5231       }
5232       break;
5233
5234     case SOUND_CTRL_ID_MUSIC:
5235       if (setup.sound_music)
5236       {
5237         setup.sound_music = FALSE;
5238         FadeSound(background_loop[level_nr % num_bg_loops]);
5239       }
5240       else if (sound_loops_allowed)
5241       {
5242         setup.sound = setup.sound_music = TRUE;
5243         PlaySoundLoop(background_loop[level_nr % num_bg_loops]);
5244       }
5245       break;
5246
5247     case SOUND_CTRL_ID_LOOPS:
5248       if (setup.sound_loops)
5249         setup.sound_loops = FALSE;
5250       else if (sound_loops_allowed)
5251         setup.sound = setup.sound_loops = TRUE;
5252       break;
5253
5254     case SOUND_CTRL_ID_SIMPLE:
5255       if (setup.sound_simple)
5256         setup.sound_simple = FALSE;
5257       else if (sound_status==SOUND_AVAILABLE)
5258         setup.sound = setup.sound_simple = TRUE;
5259       break;
5260
5261     default:
5262       break;
5263   }
5264 }