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