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 void GetPlayerConfig()
  27 {
  28   int old_joystick_nr = joystick_nr;
  29
  30   if (sound_status==SOUND_OFF)
  31     local_player->setup &= ~SETUP_SOUND;
  32   if (!sound_loops_allowed)
  33   {
  34     local_player->setup &= ~SETUP_SOUND_LOOPS;
  35     local_player->setup &= ~SETUP_SOUND_MUSIC;
  36   }
  37
  38   sound_on = sound_simple_on = SETUP_SOUND_ON(local_player->setup);
  39   sound_loops_on = SETUP_SOUND_LOOPS_ON(local_player->setup);
  40   sound_music_on = SETUP_SOUND_MUSIC_ON(local_player->setup);
  41   toons_on = SETUP_TOONS_ON(local_player->setup);
  42   direct_draw_on = SETUP_DIRECT_DRAW_ON(local_player->setup);
  43   fading_on = SETUP_FADING_ON(local_player->setup);
  44   autorecord_on = SETUP_AUTO_RECORD_ON(local_player->setup);
  45   joystick_nr = SETUP_2ND_JOYSTICK_ON(local_player->setup);
  46   quick_doors = SETUP_QUICK_DOORS_ON(local_player->setup);
  47   scroll_delay_on = SETUP_SCROLL_DELAY_ON(local_player->setup);
  48   soft_scrolling_on = SETUP_SOFT_SCROLL_ON(local_player->setup);
  49
  50 #ifndef MSDOS
  51   if (joystick_nr != old_joystick_nr)
  52   {
  53     if (joystick_device)
  54       close(joystick_device);
  55     InitJoystick();
  56   }
  57 #endif
  58 }
  59
  60 void InitGame()
  61 {
  62   int i,j, x,y;
  63   BOOL emulate_bd = TRUE;       /* unless non-BOULDERDASH elements found */
  64   BOOL emulate_sb = TRUE;       /* unless non-SOKOBAN     elements found */
  65
  66   for(i=0; i<MAX_PLAYERS; i++)
  67   {
  68     struct PlayerInfo *player = &stored_player[i];
  69
  70     player->index_nr = i;
  71     player->element_nr = EL_SPIELER1 + i;
  72     player->active = FALSE;
  73     player->local = FALSE;
  74
  75     player->score = 0;
  76     player->gems_still_needed = level.edelsteine;
  77     player->sokobanfields_still_needed = 0;
  78     player->lights_still_needed = 0;
  79     player->friends_still_needed = 0;
  80
  81     for(j=0; j<4; j++)
  82       player->key[j] = FALSE;
  83
  84     player->dynamite = 0;
  85     player->dynabomb_count = 0;
  86     player->dynabomb_size = 0;
  87     player->dynabombs_left = 0;
  88     player->dynabomb_xl = FALSE;
  89
  90     player->MovDir = MV_NO_MOVING;
  91     player->MovPos = 0;
  92     player->Pushing = FALSE;
  93     player->GfxPos = 0;
  94     player->Frame = 0;
  95
  96     player->actual_frame_counter = 0;
  97
  98     player->frame_reset_delay = 0;
  99
 100     player->push_delay = 0;
 101     player->push_delay_value = 5;
 102
 103     player->move_delay = 0;
 104     player->last_move_dir = MV_NO_MOVING;
 105
 106     player->snapped = FALSE;
 107
 108     player->gone = FALSE;
 109
 110     player->last_jx = player->last_jy = 0;
 111     player->jx = player->jy = 0;
 112
 113     DigField(player, 0,0,0,0,DF_NO_PUSH);
 114     SnapField(player, 0,0);
 115
 116
 117     /* TEST TEST TEST */
 118
 119     /*
 120     stored_player[i].active = TRUE;
 121     */
 122
 123     /* TEST TEST TEST */
 124
 125     player->LevelSolved = FALSE;
 126     player->GameOver = FALSE;
 127   }
 128
 129   local_player->active = TRUE;
 130   local_player->local = TRUE;
 131
 132   network_player_action_received = FALSE;
 133
 134
 135
 136   /* initial null action */
 137   SendToServer_MovePlayer(MV_NO_MOVING);
 138
 139
 140
 141   /*
 142   printf("BLURB\n");
 143   */
 144
 145
 146
 147   ZX = ZY = -1;
 148
 149   MampferNr = 0;
 150   FrameCounter = 0;
 151   TimeFrames = 0;
 152   TimeLeft = level.time;
 153
 154   ScreenMovDir = MV_NO_MOVING;
 155   ScreenMovPos = 0;
 156   ScreenGfxPos = 0;
 157
 158   AllPlayersGone = SiebAktiv = FALSE;
 159
 160   for(i=0;i<MAX_NUM_AMOEBA;i++)
 161     AmoebaCnt[i] = AmoebaCnt2[i] = 0;
 162
 163   for(y=0;y<lev_fieldy;y++) for(x=0;x<lev_fieldx;x++)
 164   {
 165     Feld[x][y] = Ur[x][y];
 166     MovPos[x][y] = MovDir[x][y] = MovDelay[x][y] = 0;
 167     Store[x][y] = Store2[x][y] = StorePlayer[x][y] = 0;
 168     Frame[x][y] = 0;
 169     AmoebaNr[x][y] = 0;
 170     JustHit[x][y] = 0;
 171
 172     if (emulate_bd && !IS_BD_ELEMENT(Feld[x][y]))
 173       emulate_bd = FALSE;
 174     if (emulate_sb && !IS_SB_ELEMENT(Feld[x][y]))
 175       emulate_sb = FALSE;
 176
 177     switch(Feld[x][y])
 178     {
 179       case EL_SPIELFIGUR:
 180         Feld[x][y] = EL_SPIELER1;
 181         /* no break! */
 182       case EL_SPIELER1:
 183       case EL_SPIELER2:
 184       case EL_SPIELER3:
 185       case EL_SPIELER4:
 186       {
 187         struct PlayerInfo *player = &stored_player[Feld[x][y] - EL_SPIELER1];
 188         int jx = player->jx, jy = player->jy;
 189
 190         /* remove duplicate players */
 191         if (StorePlayer[jx][jy] == Feld[x][y])
 192           StorePlayer[jx][jy] = 0;
 193
 194         player->active = TRUE;
 195
 196         StorePlayer[x][y] = Feld[x][y];
 197         Feld[x][y] = EL_LEERRAUM;
 198         player->jx = player->last_jx = x;
 199         player->jy = player->last_jy = y;
 200         break;
 201       }
 202       case EL_BADEWANNE:
 203         if (x<lev_fieldx-1 && Feld[x+1][y]==EL_SALZSAEURE)
 204           Feld[x][y] = EL_BADEWANNE1;
 205         else if (x>0 && Feld[x-1][y]==EL_SALZSAEURE)
 206           Feld[x][y] = EL_BADEWANNE2;
 207         else if (y>0 && Feld[x][y-1]==EL_BADEWANNE1)
 208           Feld[x][y] = EL_BADEWANNE3;
 209         else if (y>0 && Feld[x][y-1]==EL_SALZSAEURE)
 210           Feld[x][y] = EL_BADEWANNE4;
 211         else if (y>0 && Feld[x][y-1]==EL_BADEWANNE2)
 212           Feld[x][y] = EL_BADEWANNE5;
 213         break;
 214       case EL_KAEFER_R:
 215       case EL_KAEFER_O:
 216       case EL_KAEFER_L:
 217       case EL_KAEFER_U:
 218       case EL_KAEFER:
 219       case EL_FLIEGER_R:
 220       case EL_FLIEGER_O:
 221       case EL_FLIEGER_L:
 222       case EL_FLIEGER_U:
 223       case EL_FLIEGER:
 224       case EL_BUTTERFLY_R:
 225       case EL_BUTTERFLY_O:
 226       case EL_BUTTERFLY_L:
 227       case EL_BUTTERFLY_U:
 228       case EL_BUTTERFLY:
 229       case EL_FIREFLY_R:
 230       case EL_FIREFLY_O:
 231       case EL_FIREFLY_L:
 232       case EL_FIREFLY_U:
 233       case EL_FIREFLY:
 234       case EL_PACMAN_R:
 235       case EL_PACMAN_O:
 236       case EL_PACMAN_L:
 237       case EL_PACMAN_U:
 238       case EL_MAMPFER:
 239       case EL_MAMPFER2:
 240       case EL_ROBOT:
 241       case EL_PACMAN:
 242         InitMovDir(x,y);
 243         break;
 244       case EL_AMOEBE_VOLL:
 245       case EL_AMOEBE_BD:
 246         InitAmoebaNr(x,y);
 247         break;
 248       case EL_TROPFEN:
 249         if (y==lev_fieldy-1)
 250         {
 251           Feld[x][y] = EL_AMOEBING;
 252           Store[x][y] = EL_AMOEBE_NASS;
 253         }
 254         break;
 255       case EL_DYNAMIT:
 256         MovDelay[x][y] = 96;
 257         break;
 258       case EL_BIRNE_AUS:
 259         local_player->lights_still_needed++;
 260         break;
 261       case EL_SOKOBAN_FELD_LEER:
 262         local_player->sokobanfields_still_needed++;
 263         break;
 264       case EL_MAULWURF:
 265       case EL_PINGUIN:
 266         local_player->friends_still_needed++;
 267         break;
 268       case EL_SCHWEIN:
 269       case EL_DRACHE:
 270         MovDir[x][y] = 1<<RND(4);
 271         break;
 272       default:
 273         break;
 274     }
 275   }
 276
 277   game_emulation = (emulate_bd ? EMU_BOULDERDASH :
 278                     emulate_sb ? EMU_SOKOBAN : EMU_NONE);
 279
 280   scroll_x = scroll_y = -1;
 281   if (local_player->jx >= MIDPOSX-1)
 282     scroll_x = (local_player->jx <= lev_fieldx-MIDPOSX ?
 283                 local_player->jx - MIDPOSX :
 284                 lev_fieldx - SCR_FIELDX + 1);
 285   if (local_player->jy >= MIDPOSY-1)
 286     scroll_y = (local_player->jy <= lev_fieldy-MIDPOSY ?
 287                 local_player->jy - MIDPOSY :
 288                 lev_fieldy - SCR_FIELDY + 1);
 289
 290   CloseDoor(DOOR_CLOSE_1);
 291
 292   DrawLevel();
 293   DrawAllPlayers();
 294   FadeToFront();
 295
 296   XCopyArea(display,pix[PIX_DOOR],pix[PIX_DB_DOOR],gc,
 297             DOOR_GFX_PAGEX5,DOOR_GFX_PAGEY1, DXSIZE,DYSIZE,
 298             DOOR_GFX_PAGEX1,DOOR_GFX_PAGEY1);
 299   DrawTextExt(pix[PIX_DB_DOOR],gc,
 300               DOOR_GFX_PAGEX1+XX_LEVEL,DOOR_GFX_PAGEY1+YY_LEVEL,
 301               int2str(level_nr,2),FS_SMALL,FC_YELLOW);
 302   DrawTextExt(pix[PIX_DB_DOOR],gc,
 303               DOOR_GFX_PAGEX1+XX_EMERALDS,DOOR_GFX_PAGEY1+YY_EMERALDS,
 304               int2str(local_player->gems_still_needed,3),FS_SMALL,FC_YELLOW);
 305   DrawTextExt(pix[PIX_DB_DOOR],gc,
 306               DOOR_GFX_PAGEX1+XX_DYNAMITE,DOOR_GFX_PAGEY1+YY_DYNAMITE,
 307               int2str(local_player->dynamite,3),FS_SMALL,FC_YELLOW);
 308   DrawTextExt(pix[PIX_DB_DOOR],gc,
 309               DOOR_GFX_PAGEX1+XX_SCORE,DOOR_GFX_PAGEY1+YY_SCORE,
 310               int2str(local_player->score,5),FS_SMALL,FC_YELLOW);
 311   DrawTextExt(pix[PIX_DB_DOOR],gc,
 312               DOOR_GFX_PAGEX1+XX_TIME,DOOR_GFX_PAGEY1+YY_TIME,
 313               int2str(TimeLeft,3),FS_SMALL,FC_YELLOW);
 314
 315   DrawGameButton(BUTTON_GAME_STOP);
 316   DrawGameButton(BUTTON_GAME_PAUSE);
 317   DrawGameButton(BUTTON_GAME_PLAY);
 318   DrawSoundDisplay(BUTTON_SOUND_MUSIC  | (BUTTON_ON * sound_music_on));
 319   DrawSoundDisplay(BUTTON_SOUND_LOOPS  | (BUTTON_ON * sound_loops_on));
 320   DrawSoundDisplay(BUTTON_SOUND_SIMPLE | (BUTTON_ON * sound_simple_on));
 321   XCopyArea(display,drawto,pix[PIX_DB_DOOR],gc,
 322             DX+GAME_CONTROL_XPOS,DY+GAME_CONTROL_YPOS,
 323             GAME_CONTROL_XSIZE,2*GAME_CONTROL_YSIZE,
 324             DOOR_GFX_PAGEX1+GAME_CONTROL_XPOS,
 325             DOOR_GFX_PAGEY1+GAME_CONTROL_YPOS);
 326
 327   OpenDoor(DOOR_OPEN_1);
 328
 329   if (sound_music_on)
 330     PlaySoundLoop(background_loop[level_nr % num_bg_loops]);
 331
 332   XAutoRepeatOff(display);
 333 }
 334
 335 void InitMovDir(int x, int y)
 336 {
 337   int i, element = Feld[x][y];
 338   static int xy[4][2] =
 339   {
 340     { 0,+1 },
 341     { +1,0 },
 342     { 0,-1 },
 343     { -1,0 }
 344   };
 345   static int direction[2][4] =
 346   {
 347     { MV_RIGHT, MV_UP,   MV_LEFT,  MV_DOWN },
 348     { MV_LEFT,  MV_DOWN, MV_RIGHT, MV_UP }
 349   };
 350
 351   switch(element)
 352   {
 353     case EL_KAEFER_R:
 354     case EL_KAEFER_O:
 355     case EL_KAEFER_L:
 356     case EL_KAEFER_U:
 357       Feld[x][y] = EL_KAEFER;
 358       MovDir[x][y] = direction[0][element-EL_KAEFER_R];
 359       break;
 360     case EL_FLIEGER_R:
 361     case EL_FLIEGER_O:
 362     case EL_FLIEGER_L:
 363     case EL_FLIEGER_U:
 364       Feld[x][y] = EL_FLIEGER;
 365       MovDir[x][y] = direction[0][element-EL_FLIEGER_R];
 366       break;
 367     case EL_BUTTERFLY_R:
 368     case EL_BUTTERFLY_O:
 369     case EL_BUTTERFLY_L:
 370     case EL_BUTTERFLY_U:
 371       Feld[x][y] = EL_BUTTERFLY;
 372       MovDir[x][y] = direction[0][element-EL_BUTTERFLY_R];
 373       break;
 374     case EL_FIREFLY_R:
 375     case EL_FIREFLY_O:
 376     case EL_FIREFLY_L:
 377     case EL_FIREFLY_U:
 378       Feld[x][y] = EL_FIREFLY;
 379       MovDir[x][y] = direction[0][element-EL_FIREFLY_R];
 380       break;
 381     case EL_PACMAN_R:
 382     case EL_PACMAN_O:
 383     case EL_PACMAN_L:
 384     case EL_PACMAN_U:
 385       Feld[x][y] = EL_PACMAN;
 386       MovDir[x][y] = direction[0][element-EL_PACMAN_R];
 387       break;
 388     default:
 389       MovDir[x][y] = 1<<RND(4);
 390       if (element != EL_KAEFER &&
 391           element != EL_FLIEGER &&
 392           element != EL_BUTTERFLY &&
 393           element != EL_FIREFLY)
 394         break;
 395
 396       for(i=0;i<4;i++)
 397       {
 398         int x1,y1;
 399
 400         x1 = x+xy[i][0];
 401         y1 = y+xy[i][1];
 402
 403         if (!IN_LEV_FIELD(x1,y1) || !IS_FREE(x1,y1))
 404         {
 405           if (element==EL_KAEFER || element==EL_BUTTERFLY)
 406           {
 407             MovDir[x][y] = direction[0][i];
 408             break;
 409           }
 410           else if (element==EL_FLIEGER || element==EL_FIREFLY)
 411           {
 412             MovDir[x][y] = direction[1][i];
 413             break;
 414           }
 415         }
 416       }
 417       break;
 418   }
 419 }
 420
 421 void InitAmoebaNr(int x, int y)
 422 {
 423   int i;
 424   int group_nr = AmoebeNachbarNr(x,y);
 425
 426   if (group_nr==0)
 427   {
 428     for(i=1;i<MAX_NUM_AMOEBA;i++)
 429     {
 430       if (AmoebaCnt[i]==0)
 431       {
 432         group_nr = i;
 433         break;
 434       }
 435     }
 436   }
 437
 438   AmoebaNr[x][y] = group_nr;
 439   AmoebaCnt[group_nr]++;
 440   AmoebaCnt2[group_nr]++;
 441 }
 442
 443 void GameWon()
 444 {
 445   int hi_pos;
 446   int bumplevel = FALSE;
 447
 448   local_player->LevelSolved = FALSE;
 449
 450   if (TimeLeft)
 451   {
 452     if (sound_loops_on)
 453       PlaySoundExt(SND_SIRR, PSND_MAX_VOLUME, PSND_MAX_RIGHT, PSND_LOOP);
 454
 455     while(TimeLeft > 0)
 456     {
 457       if (!sound_loops_on)
 458         PlaySoundStereo(SND_SIRR, PSND_MAX_RIGHT);
 459       if (TimeLeft && !(TimeLeft % 10))
 460         RaiseScore(level.score[SC_ZEITBONUS]);
 461       if (TimeLeft > 100 && !(TimeLeft % 10))
 462         TimeLeft -= 10;
 463       else
 464         TimeLeft--;
 465       DrawText(DX_TIME, DY_TIME, int2str(TimeLeft,3), FS_SMALL, FC_YELLOW);
 466       BackToFront();
 467       Delay(10);
 468     }
 469
 470     if (sound_loops_on)
 471       StopSound(SND_SIRR);
 472   }
 473
 474   FadeSounds();
 475
 476   /* Hero disappears */
 477   DrawLevelField(ExitX, ExitY);
 478   BackToFront();
 479
 480   if (tape.playing)
 481     return;
 482
 483   CloseDoor(DOOR_CLOSE_1);
 484
 485   if (tape.recording)
 486   {
 487     TapeStop();
 488     SaveLevelTape(tape.level_nr);       /* Ask to save tape */
 489   }
 490
 491   if (level_nr == local_player->handicap &&
 492       level_nr < leveldir[leveldir_nr].levels-1)
 493   {
 494     local_player->handicap++;
 495     bumplevel = TRUE;
 496     SavePlayerInfo(PLAYER_LEVEL);
 497   }
 498
 499   if ((hi_pos=NewHiScore()) >= 0)
 500   {
 501     game_status = HALLOFFAME;
 502     DrawHallOfFame(hi_pos);
 503     if (bumplevel && TAPE_IS_EMPTY(tape))
 504       level_nr++;
 505   }
 506   else
 507   {
 508     game_status = MAINMENU;
 509     if (bumplevel && TAPE_IS_EMPTY(tape))
 510       level_nr++;
 511     DrawMainMenu();
 512   }
 513
 514   BackToFront();
 515 }
 516
 517 BOOL NewHiScore()
 518 {
 519   int k,l;
 520   int position = -1;
 521
 522   LoadScore(level_nr);
 523
 524   if (!strcmp(local_player->alias_name,EMPTY_ALIAS) ||
 525       local_player->score < highscore[MAX_SCORE_ENTRIES-1].Score)
 526     return(-1);
 527
 528   for(k=0;k<MAX_SCORE_ENTRIES;k++)
 529   {
 530     if (local_player->score > highscore[k].Score)
 531     {
 532       /* Spieler kommt in Highscore-Liste */
 533
 534       if (k<MAX_SCORE_ENTRIES-1)
 535       {
 536         int m = MAX_SCORE_ENTRIES-1;
 537
 538 #ifdef ONE_PER_NAME
 539         for(l=k;l<MAX_SCORE_ENTRIES;l++)
 540           if (!strcmp(local_player->alias_name,highscore[l].Name))
 541             m = l;
 542         if (m==k)       /* Spieler überschreibt seine alte Position */
 543           goto put_into_list;
 544 #endif
 545
 546         for(l=m;l>k;l--)
 547         {
 548           strcpy(highscore[l].Name,highscore[l-1].Name);
 549           highscore[l].Score = highscore[l-1].Score;
 550         }
 551       }
 552
 553 #ifdef ONE_PER_NAME
 554       put_into_list:
 555 #endif
 556       sprintf(highscore[k].Name,local_player->alias_name);
 557       highscore[k].Score = local_player->score;
 558       position = k;
 559       break;
 560     }
 561
 562 #ifdef ONE_PER_NAME
 563     else if (!strcmp(local_player->alias_name,highscore[k].Name))
 564       break;    /* Spieler schon mit besserer Punktzahl in der Liste */
 565 #endif
 566
 567   }
 568
 569   if (position>=0)
 570     SaveScore(level_nr);
 571
 572   return(position);
 573 }
 574
 575 void InitMovingField(int x, int y, int direction)
 576 {
 577   int newx = x + (direction==MV_LEFT ? -1 : direction==MV_RIGHT ? +1 : 0);
 578   int newy = y + (direction==MV_UP   ? -1 : direction==MV_DOWN  ? +1 : 0);
 579
 580   MovDir[x][y] = direction;
 581   MovDir[newx][newy] = direction;
 582   if (Feld[newx][newy] == EL_LEERRAUM)
 583     Feld[newx][newy] = EL_BLOCKED;
 584 }
 585
 586 void Moving2Blocked(int x, int y, int *goes_to_x, int *goes_to_y)
 587 {
 588   int direction = MovDir[x][y];
 589   int newx = x + (direction==MV_LEFT ? -1 : direction==MV_RIGHT ? +1 : 0);
 590   int newy = y + (direction==MV_UP   ? -1 : direction==MV_DOWN  ? +1 : 0);
 591
 592   *goes_to_x = newx;
 593   *goes_to_y = newy;
 594 }
 595
 596 void Blocked2Moving(int x, int y, int *comes_from_x, int *comes_from_y)
 597 {
 598   int oldx = x, oldy = y;
 599   int direction = MovDir[x][y];
 600
 601   if (direction==MV_LEFT)
 602     oldx++;
 603   else if (direction==MV_RIGHT)
 604     oldx--;
 605   else if (direction==MV_UP)
 606     oldy++;
 607   else if (direction==MV_DOWN)
 608     oldy--;
 609
 610   *comes_from_x = oldx;
 611   *comes_from_y = oldy;
 612 }
 613
 614 int MovingOrBlocked2Element(int x, int y)
 615 {
 616   int element = Feld[x][y];
 617
 618   if (element==EL_BLOCKED)
 619   {
 620     int oldx,oldy;
 621
 622     Blocked2Moving(x,y,&oldx,&oldy);
 623     return(Feld[oldx][oldy]);
 624   }
 625   else
 626     return(element);
 627 }
 628
 629 static void RemoveField(int x, int y)
 630 {
 631   Feld[x][y] = EL_LEERRAUM;
 632   MovPos[x][y] = 0;
 633   MovDir[x][y] = 0;
 634   MovDelay[x][y] = 0;
 635 }
 636
 637 void RemoveMovingField(int x, int y)
 638 {
 639   int oldx = x,oldy = y, newx = x,newy = y;
 640
 641   if (Feld[x][y] != EL_BLOCKED && !IS_MOVING(x,y))
 642     return;
 643
 644   if (IS_MOVING(x,y))
 645   {
 646     Moving2Blocked(x,y,&newx,&newy);
 647     if (Feld[newx][newy] != EL_BLOCKED)
 648       return;
 649   }
 650   else if (Feld[x][y]==EL_BLOCKED)
 651   {
 652     Blocked2Moving(x,y,&oldx,&oldy);
 653     if (!IS_MOVING(oldx,oldy))
 654       return;
 655   }
 656
 657   if (Feld[x][y]==EL_BLOCKED &&
 658       (Store[oldx][oldy]==EL_MORAST_LEER ||
 659        Store[oldx][oldy]==EL_SIEB_LEER ||
 660        Store[oldx][oldy]==EL_SIEB2_LEER ||
 661        Store[oldx][oldy]==EL_AMOEBE_NASS))
 662   {
 663     Feld[oldx][oldy] = Store[oldx][oldy];
 664     Store[oldx][oldy] = Store2[oldx][oldy] = 0;
 665   }
 666   else
 667     Feld[oldx][oldy] = EL_LEERRAUM;
 668
 669   Feld[newx][newy] = EL_LEERRAUM;
 670   MovPos[oldx][oldy] = MovDir[oldx][oldy] = MovDelay[oldx][oldy] = 0;
 671   MovPos[newx][newy] = MovDir[newx][newy] = MovDelay[newx][newy] = 0;
 672
 673   DrawLevelField(oldx,oldy);
 674   DrawLevelField(newx,newy);
 675 }
 676
 677 void DrawDynamite(int x, int y)
 678 {
 679   int sx = SCREENX(x), sy = SCREENY(y);
 680   int graphic = el2gfx(Feld[x][y]);
 681   int phase;
 682
 683   if (!IN_SCR_FIELD(sx,sy) || IS_PLAYER(x,y))
 684     return;
 685
 686   if (Store[x][y])
 687     DrawGraphic(sx,sy, el2gfx(Store[x][y]));
 688
 689   if (Feld[x][y]==EL_DYNAMIT)
 690   {
 691     if ((phase = (96-MovDelay[x][y])/12) > 6)
 692       phase = 6;
 693   }
 694   else
 695   {
 696     if ((phase = ((96-MovDelay[x][y])/6) % 8) > 3)
 697       phase = 7-phase;
 698   }
 699
 700   if (Store[x][y])
 701     DrawGraphicThruMask(sx,sy, graphic + phase);
 702   else
 703     DrawGraphic(sx,sy, graphic + phase);
 704 }
 705
 706 void CheckDynamite(int x, int y)
 707 {
 708   if (MovDelay[x][y])           /* neues Dynamit / in Wartezustand */
 709   {
 710     MovDelay[x][y]--;
 711     if (MovDelay[x][y])
 712     {
 713       if (!(MovDelay[x][y] % 12))
 714         PlaySoundLevel(x,y,SND_ZISCH);
 715
 716       if (Feld[x][y]==EL_DYNAMIT && !(MovDelay[x][y] % 12))
 717         DrawDynamite(x,y);
 718       else if (Feld[x][y]==EL_DYNABOMB && !(MovDelay[x][y] % 6))
 719         DrawDynamite(x,y);
 720
 721       return;
 722     }
 723   }
 724
 725   StopSound(SND_ZISCH);
 726   Bang(x,y);
 727 }
 728
 729 void Explode(int ex, int ey, int phase, int mode)
 730 {
 731   int x,y;
 732   int num_phase = 9, delay = 2;
 733   int last_phase = num_phase*delay;
 734   int half_phase = (num_phase/2)*delay;
 735
 736   if (phase==0)                 /* Feld 'Store' initialisieren */
 737   {
 738     int center_element = Feld[ex][ey];
 739
 740     if (IS_MOVING(ex,ey) || IS_BLOCKED(ex,ey))
 741     {
 742       center_element = MovingOrBlocked2Element(ex,ey);
 743       RemoveMovingField(ex,ey);
 744     }
 745
 746     for(y=ey-1;y<ey+2;y++) for(x=ex-1;x<ex+2;x++)
 747     {
 748       int element = Feld[x][y];
 749
 750       if (IS_MOVING(x,y) || IS_BLOCKED(x,y))
 751       {
 752         element = MovingOrBlocked2Element(x,y);
 753         RemoveMovingField(x,y);
 754       }
 755
 756       if (!IN_LEV_FIELD(x,y) || IS_MASSIV(element) || element==EL_BURNING)
 757         continue;
 758
 759       if ((mode!=EX_NORMAL || center_element==EL_AMOEBA2DIAM) &&
 760           (x!=ex || y!=ey))
 761         continue;
 762
 763       if (element==EL_EXPLODING)
 764         element = Store2[x][y];
 765
 766       if (IS_PLAYER(ex,ey))
 767       {
 768         switch(StorePlayer[ex][ey])
 769         {
 770           case EL_SPIELER2:
 771             Store[x][y] = EL_EDELSTEIN_ROT;
 772             break;
 773           case EL_SPIELER3:
 774             Store[x][y] = EL_EDELSTEIN;
 775             break;
 776           case EL_SPIELER4:
 777             Store[x][y] = EL_EDELSTEIN_LILA;
 778             break;
 779           case EL_SPIELER1:
 780           default:
 781             Store[x][y] = EL_EDELSTEIN_GELB;
 782             break;
 783         }
 784       }
 785       else if (center_element==EL_MAULWURF)
 786         Store[x][y] = EL_EDELSTEIN_ROT;
 787       else if (center_element==EL_PINGUIN)
 788         Store[x][y] = EL_EDELSTEIN_LILA;
 789       else if (center_element==EL_KAEFER)
 790         Store[x][y] = ((x==ex && y==ey) ? EL_DIAMANT : EL_EDELSTEIN);
 791       else if (center_element==EL_BUTTERFLY)
 792         Store[x][y] = EL_EDELSTEIN_BD;
 793       else if (center_element==EL_MAMPFER)
 794         Store[x][y] = level.mampfer_inhalt[MampferNr][x-ex+1][y-ey+1];
 795       else if (center_element==EL_AMOEBA2DIAM)
 796         Store[x][y] = level.amoebe_inhalt;
 797       else if (element==EL_ERZ_EDEL)
 798         Store[x][y] = EL_EDELSTEIN;
 799       else if (element==EL_ERZ_DIAM)
 800         Store[x][y] = EL_DIAMANT;
 801       else if (element==EL_ERZ_EDEL_BD)
 802         Store[x][y] = EL_EDELSTEIN_BD;
 803       else if (element==EL_ERZ_EDEL_GELB)
 804         Store[x][y] = EL_EDELSTEIN_GELB;
 805       else if (element==EL_ERZ_EDEL_ROT)
 806         Store[x][y] = EL_EDELSTEIN_ROT;
 807       else if (element==EL_ERZ_EDEL_LILA)
 808         Store[x][y] = EL_EDELSTEIN_LILA;
 809       else if (!IS_PFORTE(Store[x][y]))
 810         Store[x][y] = EL_LEERRAUM;
 811
 812       if (x!=ex || y!=ey || center_element==EL_AMOEBA2DIAM || mode==EX_BORDER)
 813         Store2[x][y] = element;
 814
 815       if (AmoebaNr[x][y] &&
 816           (element==EL_AMOEBE_VOLL ||
 817            element==EL_AMOEBE_BD ||
 818            element==EL_AMOEBING))
 819       {
 820         AmoebaCnt[AmoebaNr[x][y]]--;
 821         AmoebaCnt2[AmoebaNr[x][y]]--;
 822       }
 823
 824       Feld[x][y] = EL_EXPLODING;
 825       MovDir[x][y] = MovPos[x][y] = 0;
 826       AmoebaNr[x][y] = 0;
 827       Frame[x][y] = 1;
 828       Stop[x][y] = TRUE;
 829     }
 830
 831     if (center_element==EL_MAMPFER)
 832       MampferNr = (MampferNr+1) % 4;
 833
 834     return;
 835   }
 836
 837   if (Stop[ex][ey])
 838     return;
 839
 840   x = ex;
 841   y = ey;
 842
 843   Frame[x][y] = (phase<last_phase ? phase+1 : 0);
 844
 845   if (phase==half_phase)
 846   {
 847     int element = Store2[x][y];
 848
 849     if (IS_PLAYER(x,y))
 850       KillHero(PLAYERINFO(x,y));
 851     else if (IS_EXPLOSIVE(element))
 852     {
 853       Feld[x][y] = Store2[x][y];
 854       Store2[x][y] = 0;
 855       Bang(x,y);
 856     }
 857     else if (element==EL_AMOEBA2DIAM)
 858       AmoebeUmwandeln(x,y);
 859   }
 860
 861   if (phase==last_phase)
 862   {
 863     int element;
 864
 865     element = Feld[x][y] = Store[x][y];
 866     Store[x][y] = Store2[x][y] = 0;
 867     MovDir[x][y] = MovPos[x][y] = MovDelay[x][y] = 0;
 868     if (CAN_MOVE(element) || COULD_MOVE(element))
 869       InitMovDir(x,y);
 870     DrawLevelField(x,y);
 871   }
 872   else if (!(phase%delay) && IN_SCR_FIELD(SCREENX(x),SCREENY(y)))
 873   {
 874     if (phase==delay)
 875       ErdreichAnbroeckeln(SCREENX(x),SCREENY(y));
 876
 877     DrawGraphic(SCREENX(x),SCREENY(y),GFX_EXPLOSION+(phase/delay-1));
 878   }
 879 }
 880
 881 void DynaExplode(int ex, int ey)
 882 {
 883   int i,j;
 884   struct PlayerInfo *player = &stored_player[Store2[ex][ey] - EL_SPIELER1];
 885   static int xy[4][2] =
 886   {
 887     { 0,-1 },
 888     { -1,0 },
 889     { +1,0 },
 890     { 0,+1 }
 891   };
 892
 893   Store2[ex][ey] = 0;   /* delete player information */
 894
 895   Explode(ex,ey,0,EX_CENTER);
 896
 897   for(i=0;i<4;i++)
 898   {
 899     for(j=1; j<=player->dynabomb_size; j++)
 900     {
 901       int x = ex+j*xy[i%4][0];
 902       int y = ey+j*xy[i%4][1];
 903       int element;
 904
 905       if (!IN_LEV_FIELD(x,y) || IS_MASSIV(Feld[x][y]))
 906         break;
 907
 908       element = Feld[x][y];
 909       Explode(x,y,0,EX_BORDER);
 910
 911       if (element != EL_LEERRAUM &&
 912           element != EL_ERDREICH &&
 913           element != EL_EXPLODING &&
 914           !player->dynabomb_xl)
 915         break;
 916     }
 917   }
 918
 919   player->dynabombs_left++;
 920 }
 921
 922 void Bang(int x, int y)
 923 {
 924   int element = Feld[x][y];
 925
 926   PlaySoundLevel(x,y,SND_ROAAAR);
 927
 928   switch(element)
 929   {
 930     case EL_KAEFER:
 931     case EL_FLIEGER:
 932     case EL_BUTTERFLY:
 933     case EL_FIREFLY:
 934     case EL_MAMPFER:
 935     case EL_MAMPFER2:
 936     case EL_ROBOT:
 937     case EL_PACMAN:
 938       RaiseScoreElement(element);
 939       Explode(x,y,0,EX_NORMAL);
 940       break;
 941     case EL_DYNABOMB:
 942     case EL_DYNABOMB_NR:
 943     case EL_DYNABOMB_SZ:
 944     case EL_DYNABOMB_XL:
 945       DynaExplode(x,y);
 946       break;
 947     case EL_BIRNE_AUS:
 948     case EL_BIRNE_EIN:
 949       Explode(x,y,0,EX_CENTER);
 950       break;
 951     default:
 952       Explode(x,y,0,EX_NORMAL);
 953       break;
 954   }
 955 }
 956
 957 void Blurb(int x, int y)
 958 {
 959   int element = Feld[x][y];
 960
 961   if (element!=EL_BLURB_LEFT && element!=EL_BLURB_RIGHT) /* Anfang */
 962   {
 963     PlaySoundLevel(x,y,SND_BLURB);
 964     if (IN_LEV_FIELD(x-1,y) && IS_FREE(x-1,y) &&
 965         (!IN_LEV_FIELD(x-1,y-1) ||
 966          !CAN_FALL(MovingOrBlocked2Element(x-1,y-1))))
 967     {
 968       Feld[x-1][y] = EL_BLURB_LEFT;
 969     }
 970     if (IN_LEV_FIELD(x+1,y) && IS_FREE(x+1,y) &&
 971         (!IN_LEV_FIELD(x+1,y-1) ||
 972          !CAN_FALL(MovingOrBlocked2Element(x+1,y-1))))
 973     {
 974       Feld[x+1][y] = EL_BLURB_RIGHT;
 975     }
 976   }
 977   else                                                   /* Blubbern */
 978   {
 979     int graphic = (element==EL_BLURB_LEFT ? GFX_BLURB_LEFT : GFX_BLURB_RIGHT);
 980
 981     if (!MovDelay[x][y])        /* neue Phase / noch nicht gewartet */
 982       MovDelay[x][y] = 9;
 983
 984     if (MovDelay[x][y])         /* neue Phase / in Wartezustand */
 985     {
 986       MovDelay[x][y]--;
 987       if (MovDelay[x][y]/2 && IN_SCR_FIELD(SCREENX(x),SCREENY(y)))
 988         DrawGraphic(SCREENX(x),SCREENY(y),graphic+4-MovDelay[x][y]/2);
 989
 990       if (!MovDelay[x][y])
 991       {
 992         Feld[x][y] = EL_LEERRAUM;
 993         DrawLevelField(x,y);
 994       }
 995     }
 996   }
 997 }
 998
 999 void Impact(int x, int y)
1000 {
1001   BOOL lastline = (y==lev_fieldy-1);
1002   BOOL object_hit = FALSE;
1003   int element = Feld[x][y];
1004   int smashed = 0;
1005
1006   /* Element darunter berührt? */
1007   if (!lastline)
1008   {
1009     if (Feld[x][y+1] == EL_PLAYER_IS_LEAVING)
1010       return;
1011
1012     object_hit = (!IS_FREE(x,y+1) && (!IS_MOVING(x,y+1) ||
1013                                       MovDir[x][y+1]!=MV_DOWN ||
1014                                       MovPos[x][y+1]<=TILEY/2));
1015     if (object_hit)
1016       smashed = MovingOrBlocked2Element(x,y+1);
1017   }
1018
1019   /* Auftreffendes Element fällt in Salzsäure */
1020   if (!lastline && smashed==EL_SALZSAEURE)
1021   {
1022     Blurb(x,y);
1023     return;
1024   }
1025
1026   /* Auftreffendes Element ist Bombe */
1027   if (element==EL_BOMBE && (lastline || object_hit))
1028   {
1029     Bang(x,y);
1030     return;
1031   }
1032
1033   /* Auftreffendes Element ist Säuretropfen */
1034   if (element==EL_TROPFEN && (lastline || object_hit))
1035   {
1036     if (object_hit && IS_PLAYER(x,y+1))
1037       KillHero(PLAYERINFO(x,y+1));
1038     else if (object_hit && (smashed==EL_MAULWURF || smashed==EL_PINGUIN))
1039       Bang(x,y+1);
1040     else
1041     {
1042       Feld[x][y] = EL_AMOEBING;
1043       Store[x][y] = EL_AMOEBE_NASS;
1044     }
1045     return;
1046   }
1047
1048   /* Welches Element kriegt was auf die Rübe? */
1049   if (!lastline && object_hit)
1050   {
1051     if (CAN_CHANGE(element) &&
1052         (smashed==EL_SIEB_LEER || smashed==EL_SIEB2_LEER) && !SiebAktiv)
1053       SiebAktiv = level.dauer_sieb * FRAMES_PER_SECOND;
1054
1055     if (IS_PLAYER(x,y+1))
1056     {
1057       KillHero(PLAYERINFO(x,y+1));
1058       return;
1059     }
1060     else if (smashed==EL_MAULWURF || smashed==EL_PINGUIN)
1061     {
1062       Bang(x,y+1);
1063       return;
1064     }
1065     else if (element==EL_EDELSTEIN_BD)
1066     {
1067       if (IS_ENEMY(smashed) && IS_BD_ELEMENT(smashed))
1068       {
1069         Bang(x,y+1);
1070         return;
1071       }
1072     }
1073     else if (element==EL_FELSBROCKEN)
1074     {
1075       if (IS_ENEMY(smashed) || smashed==EL_BOMBE || smashed==EL_SONDE ||
1076           smashed==EL_SCHWEIN || smashed==EL_DRACHE)
1077       {
1078         Bang(x,y+1);
1079         return;
1080       }
1081       else if (!IS_MOVING(x,y+1))
1082       {
1083         if (smashed==EL_BIRNE_AUS || smashed==EL_BIRNE_EIN)
1084         {
1085           Bang(x,y+1);
1086           return;
1087         }
1088         else if (smashed==EL_KOKOSNUSS)
1089         {
1090           Feld[x][y+1] = EL_CRACKINGNUT;
1091           PlaySoundLevel(x,y,SND_KNACK);
1092           RaiseScoreElement(EL_KOKOSNUSS);
1093           return;
1094         }
1095         else if (smashed==EL_DIAMANT)
1096         {
1097           Feld[x][y+1] = EL_LEERRAUM;
1098           PlaySoundLevel(x,y,SND_QUIRK);
1099           return;
1100         }
1101       }
1102     }
1103   }
1104
1105   /* Geräusch beim Durchqueren des Siebes */
1106   if (!lastline && (Feld[x][y+1]==EL_SIEB_LEER || Feld[x][y+1]==EL_SIEB2_LEER))
1107   {
1108     PlaySoundLevel(x,y,SND_QUIRK);
1109     return;
1110   }
1111
1112   /* Geräusch beim Auftreffen */
1113   if (lastline || object_hit)
1114   {
1115     int sound;
1116
1117     switch(element)
1118     {
1119       case EL_EDELSTEIN:
1120       case EL_EDELSTEIN_BD:
1121       case EL_EDELSTEIN_GELB:
1122       case EL_EDELSTEIN_ROT:
1123       case EL_EDELSTEIN_LILA:
1124       case EL_DIAMANT:
1125         sound = SND_PLING;
1126         break;
1127       case EL_KOKOSNUSS:
1128         sound = SND_KLUMPF;
1129         break;
1130       case EL_FELSBROCKEN:
1131         sound = SND_KLOPF;
1132         break;
1133       case EL_SCHLUESSEL:
1134       case EL_SCHLUESSEL1:
1135       case EL_SCHLUESSEL2:
1136       case EL_SCHLUESSEL3:
1137       case EL_SCHLUESSEL4:
1138         sound = SND_KINK;
1139         break;
1140       case EL_ZEIT_VOLL:
1141       case EL_ZEIT_LEER:
1142         sound = SND_DENG;
1143         break;
1144       default:
1145         sound = -1;
1146         break;
1147     }
1148
1149     if (sound>=0)
1150       PlaySoundLevel(x,y,sound);
1151   }
1152 }
1153
1154 void TurnRound(int x, int y)
1155 {
1156   static struct
1157   {
1158     int x,y;
1159   } move_xy[] =
1160   {
1161     { 0,0 },
1162     {-1,0 },
1163     {+1,0 },
1164     { 0,0 },
1165     { 0,-1 },
1166     { 0,0 }, { 0,0 }, { 0,0 },
1167     { 0,+1 }
1168   };
1169   static struct
1170   {
1171     int left,right,back;
1172   } turn[] =
1173   {
1174     { 0,        0,              0 },
1175     { MV_DOWN,  MV_UP,          MV_RIGHT },
1176     { MV_UP,    MV_DOWN,        MV_LEFT },
1177     { 0,        0,              0 },
1178     { MV_LEFT,  MV_RIGHT,       MV_DOWN },
1179     { 0,0,0 },  { 0,0,0 },      { 0,0,0 },
1180     { MV_RIGHT, MV_LEFT,        MV_UP }
1181   };
1182
1183   int element = Feld[x][y];
1184   int old_move_dir = MovDir[x][y];
1185   int left_dir = turn[old_move_dir].left;
1186   int right_dir = turn[old_move_dir].right;
1187   int back_dir = turn[old_move_dir].back;
1188
1189   int left_dx = move_xy[left_dir].x, left_dy = move_xy[left_dir].y;
1190   int right_dx = move_xy[right_dir].x, right_dy = move_xy[right_dir].y;
1191   int move_dx = move_xy[old_move_dir].x, move_dy = move_xy[old_move_dir].y;
1192   int back_dx = move_xy[back_dir].x, back_dy = move_xy[back_dir].y;
1193
1194   int left_x = x+left_dx, left_y = y+left_dy;
1195   int right_x = x+right_dx, right_y = y+right_dy;
1196   int move_x = x+move_dx, move_y = y+move_dy;
1197
1198   if (element==EL_KAEFER || element==EL_BUTTERFLY)
1199   {
1200     TestIfBadThingHitsOtherBadThing(x,y);
1201
1202     if (IN_LEV_FIELD(right_x,right_y) &&
1203         IS_FREE_OR_PLAYER(right_x,right_y))
1204       MovDir[x][y] = right_dir;
1205     else if (!IN_LEV_FIELD(move_x,move_y) ||
1206              !IS_FREE_OR_PLAYER(move_x,move_y))
1207       MovDir[x][y] = left_dir;
1208
1209     if (element==EL_KAEFER && MovDir[x][y] != old_move_dir)
1210       MovDelay[x][y] = 9;
1211     else if (element==EL_BUTTERFLY)     /* && MovDir[x][y]==left_dir) */
1212       MovDelay[x][y] = 1;
1213   }
1214   else if (element==EL_FLIEGER || element==EL_FIREFLY)
1215   {
1216     TestIfBadThingHitsOtherBadThing(x,y);
1217
1218     if (IN_LEV_FIELD(left_x,left_y) &&
1219         IS_FREE_OR_PLAYER(left_x,left_y))
1220       MovDir[x][y] = left_dir;
1221     else if (!IN_LEV_FIELD(move_x,move_y) ||
1222              !IS_FREE_OR_PLAYER(move_x,move_y))
1223       MovDir[x][y] = right_dir;
1224
1225     if (element==EL_FLIEGER && MovDir[x][y] != old_move_dir)
1226       MovDelay[x][y] = 9;
1227     else if (element==EL_FIREFLY)       /* && MovDir[x][y]==right_dir) */
1228       MovDelay[x][y] = 1;
1229   }
1230   else if (element==EL_MAMPFER)
1231   {
1232     BOOL can_turn_left = FALSE, can_turn_right = FALSE;
1233
1234     if (IN_LEV_FIELD(left_x,left_y) &&
1235         (IS_FREE_OR_PLAYER(left_x,left_y) ||
1236          Feld[left_x][left_y] == EL_DIAMANT))
1237       can_turn_left = TRUE;
1238     if (IN_LEV_FIELD(right_x,right_y) &&
1239         (IS_FREE_OR_PLAYER(right_x,right_y) ||
1240          Feld[right_x][right_y] == EL_DIAMANT))
1241       can_turn_right = TRUE;
1242
1243     if (can_turn_left && can_turn_right)
1244       MovDir[x][y] = (RND(3) ? (RND(2) ? left_dir : right_dir) : back_dir);
1245     else if (can_turn_left)
1246       MovDir[x][y] = (RND(2) ? left_dir : back_dir);
1247     else if (can_turn_right)
1248       MovDir[x][y] = (RND(2) ? right_dir : back_dir);
1249     else
1250       MovDir[x][y] = back_dir;
1251
1252     MovDelay[x][y] = 16+16*RND(3);
1253   }
1254   else if (element==EL_MAMPFER2)
1255   {
1256     BOOL can_turn_left = FALSE, can_turn_right = FALSE;
1257
1258     if (IN_LEV_FIELD(left_x,left_y) &&
1259         (IS_FREE_OR_PLAYER(left_x,left_y) ||
1260          IS_MAMPF2(Feld[left_x][left_y])))
1261       can_turn_left = TRUE;
1262     if (IN_LEV_FIELD(right_x,right_y) &&
1263         (IS_FREE_OR_PLAYER(right_x,right_y) ||
1264          IS_MAMPF2(Feld[right_x][right_y])))
1265       can_turn_right = TRUE;
1266
1267     if (can_turn_left && can_turn_right)
1268       MovDir[x][y] = (RND(3) ? (RND(2) ? left_dir : right_dir) : back_dir);
1269     else if (can_turn_left)
1270       MovDir[x][y] = (RND(2) ? left_dir : back_dir);
1271     else if (can_turn_right)
1272       MovDir[x][y] = (RND(2) ? right_dir : back_dir);
1273     else
1274       MovDir[x][y] = back_dir;
1275
1276     MovDelay[x][y] = 16+16*RND(3);
1277   }
1278   else if (element==EL_PACMAN)
1279   {
1280     BOOL can_turn_left = FALSE, can_turn_right = FALSE;
1281
1282     if (IN_LEV_FIELD(left_x,left_y) &&
1283         (IS_FREE_OR_PLAYER(left_x,left_y) ||
1284          IS_AMOEBOID(Feld[left_x][left_y])))
1285       can_turn_left = TRUE;
1286     if (IN_LEV_FIELD(right_x,right_y) &&
1287         (IS_FREE_OR_PLAYER(right_x,right_y) ||
1288          IS_AMOEBOID(Feld[right_x][right_y])))
1289       can_turn_right = TRUE;
1290
1291     if (can_turn_left && can_turn_right)
1292       MovDir[x][y] = (RND(3) ? (RND(2) ? left_dir : right_dir) : back_dir);
1293     else if (can_turn_left)
1294       MovDir[x][y] = (RND(2) ? left_dir : back_dir);
1295     else if (can_turn_right)
1296       MovDir[x][y] = (RND(2) ? right_dir : back_dir);
1297     else
1298       MovDir[x][y] = back_dir;
1299
1300     MovDelay[x][y] = 6+RND(40);
1301   }
1302   else if (element==EL_SCHWEIN)
1303   {
1304     BOOL can_turn_left = FALSE, can_turn_right = FALSE, can_move_on = FALSE;
1305     BOOL should_turn_left = FALSE, should_turn_right = FALSE;
1306     BOOL should_move_on = FALSE;
1307     int rnd_value = 24;
1308     int rnd = RND(rnd_value);
1309
1310     if (IN_LEV_FIELD(left_x,left_y) &&
1311         (IS_FREE(left_x,left_y) || IS_GEM(Feld[left_x][left_y])))
1312       can_turn_left = TRUE;
1313     if (IN_LEV_FIELD(right_x,right_y) &&
1314         (IS_FREE(right_x,right_y) || IS_GEM(Feld[right_x][right_y])))
1315       can_turn_right = TRUE;
1316     if (IN_LEV_FIELD(move_x,move_y) &&
1317         (IS_FREE(move_x,move_y) || IS_GEM(Feld[move_x][move_y])))
1318       can_move_on = TRUE;
1319
1320     if (can_turn_left &&
1321         (!can_move_on ||
1322          (IN_LEV_FIELD(x+back_dx+left_dx,y+back_dy+left_dy) &&
1323           !IS_FREE(x+back_dx+left_dx,y+back_dy+left_dy))))
1324       should_turn_left = TRUE;
1325     if (can_turn_right &&
1326         (!can_move_on ||
1327          (IN_LEV_FIELD(x+back_dx+right_dx,y+back_dy+right_dy) &&
1328           !IS_FREE(x+back_dx+right_dx,y+back_dy+right_dy))))
1329       should_turn_right = TRUE;
1330     if (can_move_on &&
1331         (!can_turn_left || !can_turn_right ||
1332          (IN_LEV_FIELD(x+move_dx+left_dx,y+move_dy+left_dy) &&
1333           !IS_FREE(x+move_dx+left_dx,y+move_dy+left_dy)) ||
1334          (IN_LEV_FIELD(x+move_dx+right_dx,y+move_dy+right_dy) &&
1335           !IS_FREE(x+move_dx+right_dx,y+move_dy+right_dy))))
1336       should_move_on = TRUE;
1337
1338     if (should_turn_left || should_turn_right || should_move_on)
1339     {
1340       if (should_turn_left && should_turn_right && should_move_on)
1341         MovDir[x][y] = (rnd < rnd_value/3 ? left_dir :
1342                         rnd < 2*rnd_value/3 ? right_dir :
1343                         old_move_dir);
1344       else if (should_turn_left && should_turn_right)
1345         MovDir[x][y] = (rnd < rnd_value/2 ? left_dir : right_dir);
1346       else if (should_turn_left && should_move_on)
1347         MovDir[x][y] = (rnd < rnd_value/2 ? left_dir : old_move_dir);
1348       else if (should_turn_right && should_move_on)
1349         MovDir[x][y] = (rnd < rnd_value/2 ? right_dir : old_move_dir);
1350       else if (should_turn_left)
1351         MovDir[x][y] = left_dir;
1352       else if (should_turn_right)
1353         MovDir[x][y] = right_dir;
1354       else if (should_move_on)
1355         MovDir[x][y] = old_move_dir;
1356     }
1357     else if (can_move_on && rnd > rnd_value/8)
1358       MovDir[x][y] = old_move_dir;
1359     else if (can_turn_left && can_turn_right)
1360       MovDir[x][y] = (rnd < rnd_value/2 ? left_dir : right_dir);
1361     else if (can_turn_left && rnd > rnd_value/8)
1362       MovDir[x][y] = left_dir;
1363     else if (can_turn_right && rnd > rnd_value/8)
1364       MovDir[x][y] = right_dir;
1365     else
1366       MovDir[x][y] = back_dir;
1367
1368     if (!IS_FREE(x+move_xy[MovDir[x][y]].x,y+move_xy[MovDir[x][y]].y) &&
1369         !IS_GEM(Feld[x+move_xy[MovDir[x][y]].x][y+move_xy[MovDir[x][y]].y]))
1370       MovDir[x][y] = old_move_dir;
1371
1372     MovDelay[x][y] = 0;
1373   }
1374   else if (element==EL_DRACHE)
1375   {
1376     BOOL can_turn_left = FALSE, can_turn_right = FALSE, can_move_on = FALSE;
1377     int rnd_value = 24;
1378     int rnd = RND(rnd_value);
1379
1380     if (IN_LEV_FIELD(left_x,left_y) && IS_FREE(left_x,left_y))
1381       can_turn_left = TRUE;
1382     if (IN_LEV_FIELD(right_x,right_y) && IS_FREE(right_x,right_y))
1383       can_turn_right = TRUE;
1384     if (IN_LEV_FIELD(move_x,move_y) && IS_FREE(move_x,move_y))
1385       can_move_on = TRUE;
1386
1387     if (can_move_on && rnd > rnd_value/8)
1388       MovDir[x][y] = old_move_dir;
1389     else if (can_turn_left && can_turn_right)
1390       MovDir[x][y] = (rnd < rnd_value/2 ? left_dir : right_dir);
1391     else if (can_turn_left && rnd > rnd_value/8)
1392       MovDir[x][y] = left_dir;
1393     else if (can_turn_right && rnd > rnd_value/8)
1394       MovDir[x][y] = right_dir;
1395     else
1396       MovDir[x][y] = back_dir;
1397
1398     if (!IS_FREE(x+move_xy[MovDir[x][y]].x,y+move_xy[MovDir[x][y]].y))
1399       MovDir[x][y] = old_move_dir;
1400
1401     MovDelay[x][y] = 0;
1402   }
1403   else if (element==EL_ROBOT || element==EL_SONDE ||
1404            element==EL_MAULWURF || element==EL_PINGUIN)
1405   {
1406     int attr_x = -1, attr_y = -1;
1407
1408     if (AllPlayersGone)
1409     {
1410       attr_x = ExitX;
1411       attr_y = ExitY;
1412     }
1413     else
1414     {
1415       int i;
1416
1417       for(i=0; i<MAX_PLAYERS; i++)
1418       {
1419         struct PlayerInfo *player = &stored_player[i];
1420         int jx = player->jx, jy = player->jy;
1421
1422         if (!player->active || player->gone)
1423           continue;
1424
1425         if (attr_x == -1 || ABS(jx-x)+ABS(jy-y) < ABS(attr_x-x)+ABS(attr_y-y))
1426         {
1427           attr_x = jx;
1428           attr_y = jy;
1429         }
1430       }
1431     }
1432
1433     if (element==EL_ROBOT && ZX>=0 && ZY>=0)
1434     {
1435       attr_x = ZX;
1436       attr_y = ZY;
1437     }
1438
1439     if (element==EL_MAULWURF || element==EL_PINGUIN)
1440     {
1441       int i;
1442       static int xy[4][2] =
1443       {
1444         { 0,-1 },
1445         { -1,0 },
1446         { +1,0 },
1447         { 0,+1 }
1448       };
1449
1450       for(i=0;i<4;i++)
1451       {
1452         int ex = x + xy[i%4][0];
1453         int ey = y + xy[i%4][1];
1454
1455         if (IN_LEV_FIELD(ex,ey) && Feld[ex][ey] == EL_AUSGANG_AUF)
1456         {
1457           attr_x = ex;
1458           attr_y = ey;
1459           break;
1460         }
1461       }
1462     }
1463
1464     MovDir[x][y] = MV_NO_MOVING;
1465     if (attr_x<x)
1466       MovDir[x][y] |= (AllPlayersGone ? MV_RIGHT : MV_LEFT);
1467     else if (attr_x>x)
1468       MovDir[x][y] |= (AllPlayersGone ? MV_LEFT : MV_RIGHT);
1469     if (attr_y<y)
1470       MovDir[x][y] |= (AllPlayersGone ? MV_DOWN : MV_UP);
1471     else if (attr_y>y)
1472       MovDir[x][y] |= (AllPlayersGone ? MV_UP : MV_DOWN);
1473
1474     if (element==EL_ROBOT)
1475     {
1476       int newx, newy;
1477
1478       if ((MovDir[x][y]&(MV_LEFT|MV_RIGHT)) && (MovDir[x][y]&(MV_UP|MV_DOWN)))
1479         MovDir[x][y] &= (RND(2) ? (MV_LEFT|MV_RIGHT) : (MV_UP|MV_DOWN));
1480       Moving2Blocked(x,y,&newx,&newy);
1481
1482       if (IN_LEV_FIELD(newx,newy) && IS_FREE_OR_PLAYER(newx,newy))
1483         MovDelay[x][y] = 8+8*!RND(3);
1484       else
1485         MovDelay[x][y] = 16;
1486     }
1487     else
1488     {
1489       int newx, newy;
1490
1491       MovDelay[x][y] = 1;
1492
1493       if ((MovDir[x][y]&(MV_LEFT|MV_RIGHT)) && (MovDir[x][y]&(MV_UP|MV_DOWN)))
1494       {
1495         BOOL first_horiz = RND(2);
1496         int new_move_dir = MovDir[x][y];
1497
1498         MovDir[x][y] =
1499           new_move_dir & (first_horiz ? (MV_LEFT|MV_RIGHT) : (MV_UP|MV_DOWN));
1500         Moving2Blocked(x,y,&newx,&newy);
1501
1502         if (IN_LEV_FIELD(newx,newy) &&
1503             (IS_FREE(newx,newy) ||
1504              Feld[newx][newy] == EL_SALZSAEURE ||
1505              ((element == EL_MAULWURF || element==EL_PINGUIN) &&
1506               (Feld[newx][newy] == EL_AUSGANG_AUF ||
1507                IS_MAMPF3(Feld[newx][newy])))))
1508           return;
1509
1510         MovDir[x][y] =
1511           new_move_dir & (!first_horiz ? (MV_LEFT|MV_RIGHT) : (MV_UP|MV_DOWN));
1512         Moving2Blocked(x,y,&newx,&newy);
1513
1514         if (IN_LEV_FIELD(newx,newy) &&
1515             (IS_FREE(newx,newy) ||
1516              Feld[newx][newy] == EL_SALZSAEURE ||
1517              ((element == EL_MAULWURF || element==EL_PINGUIN) &&
1518               (Feld[newx][newy] == EL_AUSGANG_AUF ||
1519                IS_MAMPF3(Feld[newx][newy])))))
1520           return;
1521
1522         MovDir[x][y] = old_move_dir;
1523         return;
1524       }
1525     }
1526   }
1527 }
1528
1529 static BOOL JustBeingPushed(int x, int y)
1530 {
1531   int i;
1532
1533   for(i=0; i<MAX_PLAYERS; i++)
1534   {
1535     struct PlayerInfo *player = &stored_player[i];
1536
1537     if (player->active && !player->gone &&
1538         player->Pushing && player->MovPos)
1539     {
1540       int next_jx = player->jx + (player->jx - player->last_jx);
1541       int next_jy = player->jy + (player->jy - player->last_jy);
1542
1543       if (x == next_jx && y == next_jy)
1544         return(TRUE);
1545     }
1546   }
1547
1548   return(FALSE);
1549 }
1550
1551 void StartMoving(int x, int y)
1552 {
1553   int element = Feld[x][y];
1554
1555   if (Stop[x][y])
1556     return;
1557
1558   if (CAN_FALL(element) && y<lev_fieldy-1)
1559   {
1560     if ((x>0 && IS_PLAYER(x-1,y)) || (x<lev_fieldx-1 && IS_PLAYER(x+1,y)))
1561       if (JustBeingPushed(x,y))
1562         return;
1563
1564     if (element==EL_MORAST_VOLL)
1565     {
1566       if (IS_FREE(x,y+1))
1567       {
1568         InitMovingField(x,y,MV_DOWN);
1569         Feld[x][y] = EL_FELSBROCKEN;
1570         Store[x][y] = EL_MORAST_LEER;
1571       }
1572       else if (Feld[x][y+1]==EL_MORAST_LEER)
1573       {
1574         if (!MovDelay[x][y])
1575           MovDelay[x][y] = TILEY + 1;
1576
1577         if (MovDelay[x][y])
1578         {
1579           MovDelay[x][y]--;
1580           if (MovDelay[x][y])
1581             return;
1582         }
1583
1584         Feld[x][y] = EL_MORAST_LEER;
1585         Feld[x][y+1] = EL_MORAST_VOLL;
1586       }
1587     }
1588     else if (element==EL_FELSBROCKEN && Feld[x][y+1]==EL_MORAST_LEER)
1589     {
1590       InitMovingField(x,y,MV_DOWN);
1591       Store[x][y] = EL_MORAST_VOLL;
1592     }
1593     else if (element==EL_SIEB_VOLL)
1594     {
1595       if (IS_FREE(x,y+1))
1596       {
1597         InitMovingField(x,y,MV_DOWN);
1598         Feld[x][y] = EL_CHANGED(Store2[x][y]);
1599         Store[x][y] = EL_SIEB_LEER;
1600       }
1601       else if (Feld[x][y+1]==EL_SIEB_LEER)
1602       {
1603         if (!MovDelay[x][y])
1604           MovDelay[x][y] = TILEY/4 + 1;
1605
1606         if (MovDelay[x][y])
1607         {
1608           MovDelay[x][y]--;
1609           if (MovDelay[x][y])
1610             return;
1611         }
1612
1613         Feld[x][y] = EL_SIEB_LEER;
1614         Feld[x][y+1] = EL_SIEB_VOLL;
1615         Store2[x][y+1] = EL_CHANGED(Store2[x][y]);
1616         Store2[x][y] = 0;
1617       }
1618     }
1619     else if (element==EL_SIEB2_VOLL)
1620     {
1621       if (IS_FREE(x,y+1))
1622       {
1623         InitMovingField(x,y,MV_DOWN);
1624         Feld[x][y] = EL_CHANGED2(Store2[x][y]);
1625         Store[x][y] = EL_SIEB2_LEER;
1626       }
1627       else if (Feld[x][y+1]==EL_SIEB2_LEER)
1628       {
1629         if (!MovDelay[x][y])
1630           MovDelay[x][y] = TILEY/4 + 1;
1631
1632         if (MovDelay[x][y])
1633         {
1634           MovDelay[x][y]--;
1635           if (MovDelay[x][y])
1636             return;
1637         }
1638
1639         Feld[x][y] = EL_SIEB2_LEER;
1640         Feld[x][y+1] = EL_SIEB2_VOLL;
1641         Store2[x][y+1] = EL_CHANGED2(Store2[x][y]);
1642         Store2[x][y] = 0;
1643       }
1644     }
1645     else if (SiebAktiv && CAN_CHANGE(element) &&
1646              (Feld[x][y+1]==EL_SIEB_LEER || Feld[x][y+1]==EL_SIEB2_LEER))
1647     {
1648       InitMovingField(x,y,MV_DOWN);
1649       Store[x][y] =
1650         (Feld[x][y+1]==EL_SIEB_LEER ? EL_SIEB_VOLL : EL_SIEB2_VOLL);
1651       Store2[x][y+1] = element;
1652     }
1653     else if (CAN_SMASH(element) && Feld[x][y+1]==EL_SALZSAEURE)
1654     {
1655       Blurb(x,y);
1656       InitMovingField(x,y,MV_DOWN);
1657       Store[x][y] = EL_SALZSAEURE;
1658     }
1659     else if (CAN_SMASH(element) && Feld[x][y+1]==EL_BLOCKED && JustHit[x][y])
1660     {
1661       Impact(x,y);
1662     }
1663     else if (IS_FREE(x,y+1))
1664     {
1665       InitMovingField(x,y,MV_DOWN);
1666     }
1667     else if (element==EL_TROPFEN)
1668     {
1669       Feld[x][y] = EL_AMOEBING;
1670       Store[x][y] = EL_AMOEBE_NASS;
1671     }
1672     else if (IS_SLIPPERY(Feld[x][y+1]) && !Store[x][y+1])
1673     {
1674       BOOL left  = (x>0 && IS_FREE(x-1,y) &&
1675                     (IS_FREE(x-1,y+1) || Feld[x-1][y+1]==EL_SALZSAEURE));
1676       BOOL right = (x<lev_fieldx-1 && IS_FREE(x+1,y) &&
1677                     (IS_FREE(x+1,y+1) || Feld[x+1][y+1]==EL_SALZSAEURE));
1678
1679       if (left || right)
1680       {
1681         if (left && right && game_emulation != EMU_BOULDERDASH)
1682           left = !(right = RND(2));
1683
1684         InitMovingField(x,y,left ? MV_LEFT : MV_RIGHT);
1685       }
1686     }
1687   }
1688   else if (CAN_MOVE(element))
1689   {
1690     int newx,newy;
1691
1692     if (element == EL_SONDE && JustBeingPushed(x,y))
1693       return;
1694
1695     if (!MovDelay[x][y])        /* neuer Schritt / noch nicht gewartet */
1696     {
1697       /* Alle Figuren, die nach jeden Schritt die Richtung wechseln können.
1698        * (MAMPFER, MAMPFER2 und PACMAN laufen bis zur nächsten Wand.)
1699        */
1700
1701       if (element!=EL_MAMPFER && element!=EL_MAMPFER2 && element!=EL_PACMAN)
1702       {
1703         TurnRound(x,y);
1704         if (MovDelay[x][y] && (element == EL_KAEFER || element == EL_FLIEGER))
1705           DrawLevelField(x,y);
1706       }
1707     }
1708
1709     if (MovDelay[x][y])         /* neuer Schritt / in Wartezustand */
1710     {
1711       MovDelay[x][y]--;
1712
1713       if (element==EL_ROBOT || element==EL_MAMPFER || element==EL_MAMPFER2)
1714       {
1715         int phase = MovDelay[x][y] % 8;
1716
1717         if (phase>3)
1718           phase = 7-phase;
1719
1720         if (IN_SCR_FIELD(SCREENX(x),SCREENY(y)))
1721           DrawGraphic(SCREENX(x),SCREENY(y), el2gfx(element)+phase);
1722
1723         if ((element==EL_MAMPFER || element==EL_MAMPFER2)
1724             && MovDelay[x][y]%4==3)
1725           PlaySoundLevel(x,y,SND_NJAM);
1726       }
1727       else if (element==EL_DRACHE)
1728       {
1729         int i;
1730         int dir = MovDir[x][y];
1731         int dx = (dir == MV_LEFT ? -1 : dir == MV_RIGHT ? +1 : 0);
1732         int dy = (dir == MV_UP   ? -1 : dir == MV_DOWN  ? +1 : 0);
1733         int graphic = (dir == MV_LEFT   ? GFX_FLAMMEN_LEFT :
1734                        dir == MV_RIGHT  ? GFX_FLAMMEN_RIGHT :
1735                        dir == MV_UP     ? GFX_FLAMMEN_UP :
1736                        dir == MV_DOWN   ? GFX_FLAMMEN_DOWN : GFX_LEERRAUM);
1737         int phase = FrameCounter % 2;
1738
1739         for(i=1;i<=3;i++)
1740         {
1741           int xx = x + i*dx, yy = y + i*dy;
1742           int sx = SCREENX(xx), sy = SCREENY(yy);
1743
1744           if (!IN_LEV_FIELD(xx,yy) ||
1745               IS_SOLID(Feld[xx][yy]) || Feld[xx][yy]==EL_EXPLODING)
1746             break;
1747
1748           if (MovDelay[x][y])
1749           {
1750             int flamed = MovingOrBlocked2Element(xx,yy);
1751
1752             if (IS_ENEMY(flamed) || IS_EXPLOSIVE(flamed))
1753               Bang(xx,yy);
1754             else
1755               RemoveMovingField(xx,yy);
1756
1757             Feld[xx][yy] = EL_BURNING;
1758             if (IN_SCR_FIELD(sx,sy))
1759               DrawGraphic(sx,sy, graphic + phase*3 + i-1);
1760           }
1761           else
1762           {
1763             if (Feld[xx][yy] == EL_BURNING)
1764               Feld[xx][yy] = EL_LEERRAUM;
1765             DrawLevelField(xx,yy);
1766           }
1767         }
1768       }
1769
1770       if (MovDelay[x][y])
1771         return;
1772     }
1773
1774     if (element==EL_KAEFER || element==EL_BUTTERFLY)
1775     {
1776       PlaySoundLevel(x,y,SND_KLAPPER);
1777     }
1778     else if (element==EL_FLIEGER || element==EL_FIREFLY)
1779     {
1780       PlaySoundLevel(x,y,SND_ROEHR);
1781     }
1782
1783     /* neuer Schritt / Wartezustand beendet */
1784
1785     Moving2Blocked(x,y,&newx,&newy);    /* wohin soll's gehen? */
1786
1787     if (IS_ENEMY(element) && IS_PLAYER(newx,newy))
1788     {
1789       /* Spieler erwischt */
1790       MovDir[x][y] = 0;
1791       KillHero(PLAYERINFO(newx,newy));
1792       return;
1793     }
1794     else if ((element == EL_MAULWURF || element == EL_PINGUIN ||
1795               element==EL_ROBOT || element==EL_SONDE) &&
1796              IN_LEV_FIELD(newx,newy) &&
1797              MovDir[x][y]==MV_DOWN && Feld[newx][newy]==EL_SALZSAEURE)
1798     {
1799       Blurb(x,y);
1800       Store[x][y] = EL_SALZSAEURE;
1801     }
1802     else if ((element == EL_MAULWURF || element == EL_PINGUIN) &&
1803              IN_LEV_FIELD(newx,newy))
1804     {
1805       if (Feld[newx][newy] == EL_AUSGANG_AUF)
1806       {
1807         Feld[x][y] = EL_LEERRAUM;
1808         DrawLevelField(x,y);
1809
1810         PlaySoundLevel(newx,newy,SND_BUING);
1811         if (IN_SCR_FIELD(SCREENX(newx),SCREENY(newy)))
1812           DrawGraphicThruMask(SCREENX(newx),SCREENY(newy),el2gfx(element));
1813
1814         local_player->friends_still_needed--;
1815         if (!local_player->friends_still_needed &&
1816             !local_player->GameOver && AllPlayersGone)
1817           local_player->LevelSolved = local_player->GameOver = TRUE;
1818
1819         return;
1820       }
1821       else if (IS_MAMPF3(Feld[newx][newy]))
1822       {
1823         if (DigField(local_player, newx,newy, 0,0, DF_DIG) == MF_MOVING)
1824           DrawLevelField(newx,newy);
1825         else
1826           MovDir[x][y] = MV_NO_MOVING;
1827       }
1828       else if (!IS_FREE(newx,newy))
1829       {
1830         if (IS_PLAYER(x,y))
1831           DrawPlayerField(x,y);
1832         else
1833           DrawLevelField(x,y);
1834         return;
1835       }
1836     }
1837     else if (element == EL_SCHWEIN && IN_LEV_FIELD(newx,newy))
1838     {
1839       if (IS_GEM(Feld[newx][newy]))
1840       {
1841         if (IS_MOVING(newx,newy))
1842           RemoveMovingField(newx,newy);
1843         else
1844         {
1845           Feld[newx][newy] = EL_LEERRAUM;
1846           DrawLevelField(newx,newy);
1847         }
1848       }
1849       else if (!IS_FREE(newx,newy))
1850       {
1851         if (IS_PLAYER(x,y))
1852           DrawPlayerField(x,y);
1853         else
1854           DrawLevelField(x,y);
1855         return;
1856       }
1857     }
1858     else if (element==EL_DRACHE && IN_LEV_FIELD(newx,newy))
1859     {
1860       if (!IS_FREE(newx,newy))
1861       {
1862         if (IS_PLAYER(x,y))
1863           DrawPlayerField(x,y);
1864         else
1865           DrawLevelField(x,y);
1866         return;
1867       }
1868       else
1869       {
1870         BOOL wanna_flame = !RND(10);
1871         int dx = newx - x, dy = newy - y;
1872         int newx1 = newx+1*dx, newy1 = newy+1*dy;
1873         int newx2 = newx+2*dx, newy2 = newy+2*dy;
1874         int element1 = (IN_LEV_FIELD(newx1,newy1) ?
1875                         MovingOrBlocked2Element(newx1,newy1) : EL_BETON);
1876         int element2 = (IN_LEV_FIELD(newx2,newy2) ?
1877                         MovingOrBlocked2Element(newx2,newy2) : EL_BETON);
1878
1879         if ((wanna_flame || IS_ENEMY(element1) || IS_ENEMY(element2)) &&
1880             element1 != EL_DRACHE && element2 != EL_DRACHE &&
1881             element1 != EL_BURNING && element2 != EL_BURNING)
1882         {
1883           if (IS_PLAYER(x,y))
1884             DrawPlayerField(x,y);
1885           else
1886             DrawLevelField(x,y);
1887
1888           MovDelay[x][y] = 50;
1889           Feld[newx][newy] = EL_BURNING;
1890           if (IN_LEV_FIELD(newx1,newy1) && Feld[newx1][newy1] == EL_LEERRAUM)
1891             Feld[newx1][newy1] = EL_BURNING;
1892           if (IN_LEV_FIELD(newx2,newy2) && Feld[newx2][newy2] == EL_LEERRAUM)
1893             Feld[newx2][newy2] = EL_BURNING;
1894           return;
1895         }
1896       }
1897     }
1898     else if (element==EL_MAMPFER && IN_LEV_FIELD(newx,newy) &&
1899              Feld[newx][newy]==EL_DIAMANT)
1900     {
1901       if (IS_MOVING(newx,newy))
1902         RemoveMovingField(newx,newy);
1903       else
1904       {
1905         Feld[newx][newy] = EL_LEERRAUM;
1906         DrawLevelField(newx,newy);
1907       }
1908     }
1909     else if (element==EL_MAMPFER2 && IN_LEV_FIELD(newx,newy) &&
1910              IS_MAMPF2(Feld[newx][newy]))
1911     {
1912       if (AmoebaNr[newx][newy])
1913       {
1914         AmoebaCnt2[AmoebaNr[newx][newy]]--;
1915         if (Feld[newx][newy]==EL_AMOEBE_VOLL || Feld[newx][newy]==EL_AMOEBE_BD)
1916           AmoebaCnt[AmoebaNr[newx][newy]]--;
1917       }
1918
1919       if (IS_MOVING(newx,newy))
1920         RemoveMovingField(newx,newy);
1921       else
1922       {
1923         Feld[newx][newy] = EL_LEERRAUM;
1924         DrawLevelField(newx,newy);
1925       }
1926     }
1927     else if (element==EL_PACMAN && IN_LEV_FIELD(newx,newy) &&
1928              IS_AMOEBOID(Feld[newx][newy]))
1929     {
1930       if (AmoebaNr[newx][newy])
1931       {
1932         AmoebaCnt2[AmoebaNr[newx][newy]]--;
1933         if (Feld[newx][newy]==EL_AMOEBE_VOLL || Feld[newx][newy]==EL_AMOEBE_BD)
1934           AmoebaCnt[AmoebaNr[newx][newy]]--;
1935       }
1936
1937       Feld[newx][newy] = EL_LEERRAUM;
1938       DrawLevelField(newx,newy);
1939     }
1940     else if (!IN_LEV_FIELD(newx,newy) || !IS_FREE(newx,newy))
1941     {                                   /* gegen Wand gelaufen */
1942       TurnRound(x,y);
1943
1944       if (element == EL_KAEFER || element == EL_FLIEGER)
1945         DrawLevelField(x,y);
1946       else if (element == EL_BUTTERFLY || element == EL_FIREFLY)
1947         DrawGraphicAnimation(x,y, el2gfx(element), 2, 4, ANIM_NORMAL);
1948       else if (element==EL_SONDE)
1949         DrawGraphicAnimation(x,y, GFX_SONDE_START, 8, 2, ANIM_NORMAL);
1950
1951       return;
1952     }
1953
1954     if (element==EL_ROBOT && IN_SCR_FIELD(x,y))
1955       PlaySoundLevel(x,y,SND_SCHLURF);
1956
1957     InitMovingField(x,y,MovDir[x][y]);
1958   }
1959
1960   if (MovDir[x][y])
1961     ContinueMoving(x,y);
1962 }
1963
1964 void ContinueMoving(int x, int y)
1965 {
1966   int element = Feld[x][y];
1967   int direction = MovDir[x][y];
1968   int dx = (direction==MV_LEFT ? -1 : direction==MV_RIGHT ? +1 : 0);
1969   int dy = (direction==MV_UP   ? -1 : direction==MV_DOWN  ? +1 : 0);
1970   int horiz_move = (dx!=0);
1971   int newx = x + dx, newy = y + dy;
1972   int step = (horiz_move ? dx : dy) * TILEX/8;
1973
1974   if (CAN_FALL(element) && horiz_move)
1975     step*=2;
1976   else if (element==EL_TROPFEN)
1977     step/=2;
1978   else if (Store[x][y]==EL_MORAST_VOLL || Store[x][y]==EL_MORAST_LEER)
1979     step/=4;
1980
1981   MovPos[x][y] += step;
1982
1983   if (ABS(MovPos[x][y])>=TILEX)         /* Zielfeld erreicht */
1984   {
1985     Feld[x][y] = EL_LEERRAUM;
1986     Feld[newx][newy] = element;
1987
1988     if (Store[x][y]==EL_MORAST_VOLL)
1989     {
1990       Store[x][y] = 0;
1991       Feld[newx][newy] = EL_MORAST_VOLL;
1992       element = EL_MORAST_VOLL;
1993     }
1994     else if (Store[x][y]==EL_MORAST_LEER)
1995     {
1996       Store[x][y] = 0;
1997       Feld[x][y] = EL_MORAST_LEER;
1998     }
1999     else if (Store[x][y]==EL_SIEB_VOLL)
2000     {
2001       Store[x][y] = 0;
2002       element = Feld[newx][newy] = (SiebAktiv ? EL_SIEB_VOLL : EL_SIEB_TOT);
2003     }
2004     else if (Store[x][y]==EL_SIEB_LEER)
2005     {
2006       Store[x][y] = Store2[x][y] = 0;
2007       Feld[x][y] = (SiebAktiv ? EL_SIEB_LEER : EL_SIEB_TOT);
2008     }
2009     else if (Store[x][y]==EL_SIEB2_VOLL)
2010     {
2011       Store[x][y] = 0;
2012       element = Feld[newx][newy] = (SiebAktiv ? EL_SIEB2_VOLL : EL_SIEB2_TOT);
2013     }
2014     else if (Store[x][y]==EL_SIEB2_LEER)
2015     {
2016       Store[x][y] = Store2[x][y] = 0;
2017       Feld[x][y] = (SiebAktiv ? EL_SIEB2_LEER : EL_SIEB2_TOT);
2018     }
2019     else if (Store[x][y]==EL_SALZSAEURE)
2020     {
2021       Store[x][y] = 0;
2022       Feld[newx][newy] = EL_SALZSAEURE;
2023       element = EL_SALZSAEURE;
2024     }
2025     else if (Store[x][y]==EL_AMOEBE_NASS)
2026     {
2027       Store[x][y] = 0;
2028       Feld[x][y] = EL_AMOEBE_NASS;
2029     }
2030
2031     MovPos[x][y] = MovDir[x][y] = MovDelay[x][y] = 0;
2032     MovDelay[newx][newy] = 0;
2033
2034     if (!CAN_MOVE(element))
2035       MovDir[newx][newy] = 0;
2036
2037     DrawLevelField(x,y);
2038     DrawLevelField(newx,newy);
2039
2040     Stop[newx][newy] = TRUE;
2041     JustHit[x][newy] = 3;
2042
2043     if (DONT_TOUCH(element))    /* Käfer oder Flieger */
2044     {
2045       TestIfBadThingHitsHero(newx,newy);
2046       TestIfBadThingHitsFriend(newx,newy);
2047       TestIfBadThingHitsOtherBadThing(newx,newy);
2048     }
2049     else if (element == EL_PINGUIN)
2050       TestIfFriendHitsBadThing(newx,newy);
2051
2052     if (CAN_SMASH(element) && direction==MV_DOWN &&
2053         (newy==lev_fieldy-1 || !IS_FREE(x,newy+1)))
2054       Impact(x,newy);
2055   }
2056   else                          /* noch in Bewegung */
2057     DrawLevelField(x,y);
2058 }
2059
2060 int AmoebeNachbarNr(int ax, int ay)
2061 {
2062   int i;
2063   int element = Feld[ax][ay];
2064   int group_nr = 0;
2065   static int xy[4][2] =
2066   {
2067     { 0,-1 },
2068     { -1,0 },
2069     { +1,0 },
2070     { 0,+1 }
2071   };
2072
2073   for(i=0;i<4;i++)
2074   {
2075     int x = ax+xy[i%4][0];
2076     int y = ay+xy[i%4][1];
2077
2078     if (!IN_LEV_FIELD(x,y))
2079       continue;
2080
2081     if (Feld[x][y]==element && AmoebaNr[x][y]>0)
2082       group_nr = AmoebaNr[x][y];
2083   }
2084
2085   return(group_nr);
2086 }
2087
2088 void AmoebenVereinigen(int ax, int ay)
2089 {
2090   int i,x,y,xx,yy;
2091   int new_group_nr = AmoebaNr[ax][ay];
2092   static int xy[4][2] =
2093   {
2094     { 0,-1 },
2095     { -1,0 },
2096     { +1,0 },
2097     { 0,+1 }
2098   };
2099
2100   if (!new_group_nr)
2101     return;
2102
2103   for(i=0;i<4;i++)
2104   {
2105     x = ax+xy[i%4][0];
2106     y = ay+xy[i%4][1];
2107
2108     if (!IN_LEV_FIELD(x,y))
2109       continue;
2110
2111     if ((Feld[x][y]==EL_AMOEBE_VOLL ||
2112          Feld[x][y]==EL_AMOEBE_BD ||
2113          Feld[x][y]==EL_AMOEBE_TOT) &&
2114         AmoebaNr[x][y] != new_group_nr)
2115     {
2116       int old_group_nr = AmoebaNr[x][y];
2117
2118       AmoebaCnt[new_group_nr] += AmoebaCnt[old_group_nr];
2119       AmoebaCnt[old_group_nr] = 0;
2120       AmoebaCnt2[new_group_nr] += AmoebaCnt2[old_group_nr];
2121       AmoebaCnt2[old_group_nr] = 0;
2122
2123       for(yy=0;yy<lev_fieldy;yy++) for(xx=0;xx<lev_fieldx;xx++)
2124         if (AmoebaNr[xx][yy]==old_group_nr)
2125           AmoebaNr[xx][yy] = new_group_nr;
2126     }
2127   }
2128 }
2129
2130 void AmoebeUmwandeln(int ax, int ay)
2131 {
2132   int i,x,y;
2133   int group_nr = AmoebaNr[ax][ay];
2134   static int xy[4][2] =
2135   {
2136     { 0,-1 },
2137     { -1,0 },
2138     { +1,0 },
2139     { 0,+1 }
2140   };
2141
2142   if (Feld[ax][ay]==EL_AMOEBE_TOT)
2143   {
2144     for(y=0;y<lev_fieldy;y++) for(x=0;x<lev_fieldx;x++)
2145     {
2146       if (Feld[x][y]==EL_AMOEBE_TOT && AmoebaNr[x][y]==group_nr)
2147       {
2148         AmoebaNr[x][y] = 0;
2149         Feld[x][y] = EL_AMOEBA2DIAM;
2150       }
2151     }
2152     Bang(ax,ay);
2153   }
2154   else
2155   {
2156     for(i=0;i<4;i++)
2157     {
2158       x = ax+xy[i%4][0];
2159       y = ay+xy[i%4][1];
2160
2161       if (!IN_LEV_FIELD(x,y))
2162         continue;
2163
2164       if (Feld[x][y]==EL_AMOEBA2DIAM)
2165         Bang(x,y);
2166     }
2167   }
2168 }
2169
2170 void AmoebeUmwandeln2(int ax, int ay, int new_element)
2171 {
2172   int x,y;
2173   int group_nr = AmoebaNr[ax][ay];
2174   BOOL done = FALSE;
2175
2176   for(y=0;y<lev_fieldy;y++) for(x=0;x<lev_fieldx;x++)
2177   {
2178     if (AmoebaNr[x][y]==group_nr &&
2179         (Feld[x][y]==EL_AMOEBE_TOT ||
2180          Feld[x][y]==EL_AMOEBE_BD ||
2181          Feld[x][y]==EL_AMOEBING))
2182     {
2183       AmoebaNr[x][y] = 0;
2184       Feld[x][y] = new_element;
2185       DrawLevelField(x,y);
2186       done = TRUE;
2187     }
2188   }
2189
2190   if (done)
2191     PlaySoundLevel(ax,ay,new_element==EL_FELSBROCKEN ? SND_KLOPF : SND_PLING);
2192 }
2193
2194 void AmoebeWaechst(int x, int y)
2195 {
2196   static long sound_delay = 0;
2197   static int sound_delay_value = 0;
2198
2199   if (!MovDelay[x][y])          /* neue Phase / noch nicht gewartet */
2200   {
2201     MovDelay[x][y] = 7;
2202
2203     if (DelayReached(&sound_delay, sound_delay_value))
2204     {
2205       PlaySoundLevel(x,y,SND_AMOEBE);
2206       sound_delay_value = 30;
2207     }
2208   }
2209
2210   if (MovDelay[x][y])           /* neue Phase / in Wartezustand */
2211   {
2212     MovDelay[x][y]--;
2213     if (MovDelay[x][y]/2 && IN_SCR_FIELD(SCREENX(x),SCREENY(y)))
2214       DrawGraphic(SCREENX(x),SCREENY(y),GFX_AMOEBING+3-MovDelay[x][y]/2);
2215
2216     if (!MovDelay[x][y])
2217     {
2218       Feld[x][y] = Store[x][y];
2219       Store[x][y] = 0;
2220       DrawLevelField(x,y);
2221     }
2222   }
2223 }
2224
2225 void AmoebeAbleger(int ax, int ay)
2226 {
2227   int i;
2228   int element = Feld[ax][ay];
2229   int newax = ax, neway = ay;
2230   static int xy[4][2] =
2231   {
2232     { 0,-1 },
2233     { -1,0 },
2234     { +1,0 },
2235     { 0,+1 }
2236   };
2237
2238   if (!level.tempo_amoebe)
2239   {
2240     Feld[ax][ay] = EL_AMOEBE_TOT;
2241     DrawLevelField(ax,ay);
2242     return;
2243   }
2244
2245   if (!MovDelay[ax][ay])        /* neue Amoebe / noch nicht gewartet */
2246     MovDelay[ax][ay] = RND(FRAMES_PER_SECOND * 25/(1+level.tempo_amoebe));
2247
2248   if (MovDelay[ax][ay])         /* neue Amoebe / in Wartezustand */
2249   {
2250     MovDelay[ax][ay]--;
2251     if (MovDelay[ax][ay])
2252       return;
2253   }
2254
2255   if (element==EL_AMOEBE_NASS)  /* tropfende Amöbe */
2256   {
2257     int start = RND(4);
2258     int x = ax+xy[start][0];
2259     int y = ay+xy[start][1];
2260
2261     if (!IN_LEV_FIELD(x,y))
2262       return;
2263
2264     if (IS_FREE(x,y) ||
2265         Feld[x][y]==EL_ERDREICH || Feld[x][y]==EL_MORAST_LEER)
2266     {
2267       newax = x;
2268       neway = y;
2269     }
2270
2271     if (newax==ax && neway==ay)
2272       return;
2273   }
2274   else                          /* normale oder "gefüllte" Amöbe */
2275   {
2276     int start = RND(4);
2277     BOOL waiting_for_player = FALSE;
2278
2279     for(i=0;i<4;i++)
2280     {
2281       int j = (start+i)%4;
2282       int x = ax+xy[j][0];
2283       int y = ay+xy[j][1];
2284
2285       if (!IN_LEV_FIELD(x,y))
2286         continue;
2287
2288       if (IS_FREE(x,y) ||
2289           Feld[x][y]==EL_ERDREICH || Feld[x][y]==EL_MORAST_LEER)
2290       {
2291         newax = x;
2292         neway = y;
2293         break;
2294       }
2295       else if (IS_PLAYER(x,y))
2296         waiting_for_player = TRUE;
2297     }
2298
2299     if (newax==ax && neway==ay)
2300     {
2301       if (i==4 && !waiting_for_player)
2302       {
2303         Feld[ax][ay] = EL_AMOEBE_TOT;
2304         DrawLevelField(ax,ay);
2305         AmoebaCnt[AmoebaNr[ax][ay]]--;
2306
2307         if (AmoebaCnt[AmoebaNr[ax][ay]]<=0)     /* Amöbe vollständig tot */
2308         {
2309           if (element==EL_AMOEBE_VOLL)
2310             AmoebeUmwandeln(ax,ay);
2311           else if (element==EL_AMOEBE_BD)
2312             AmoebeUmwandeln2(ax,ay,level.amoebe_inhalt);
2313         }
2314       }
2315       return;
2316     }
2317     else if (element==EL_AMOEBE_VOLL || element==EL_AMOEBE_BD)
2318     {
2319       int new_group_nr = AmoebaNr[ax][ay];
2320
2321       AmoebaNr[newax][neway] = new_group_nr;
2322       AmoebaCnt[new_group_nr]++;
2323       AmoebaCnt2[new_group_nr]++;
2324       AmoebenVereinigen(newax,neway);
2325
2326       if (AmoebaCnt2[new_group_nr] >= 200 && element==EL_AMOEBE_BD)
2327       {
2328         AmoebeUmwandeln2(newax,neway,EL_FELSBROCKEN);
2329         return;
2330       }
2331     }
2332   }
2333
2334   if (element!=EL_AMOEBE_NASS || neway<ay || !IS_FREE(newax,neway) ||
2335       (neway==lev_fieldy-1 && newax!=ax))
2336   {
2337     Feld[newax][neway] = EL_AMOEBING;
2338     Store[newax][neway] = element;
2339   }
2340   else if (neway==ay)
2341     Feld[newax][neway] = EL_TROPFEN;
2342   else
2343   {
2344     InitMovingField(ax,ay,MV_DOWN);
2345     Feld[ax][ay] = EL_TROPFEN;
2346     Store[ax][ay] = EL_AMOEBE_NASS;
2347     ContinueMoving(ax,ay);
2348     return;
2349   }
2350
2351   DrawLevelField(newax,neway);
2352 }
2353
2354 void Life(int ax, int ay)
2355 {
2356   int x1,y1,x2,y2;
2357   static int life[4] = { 2,3,3,3 };     /* "Life"-Parameter */
2358   int life_time = 40;
2359   int element = Feld[ax][ay];
2360
2361   if (Stop[ax][ay])
2362     return;
2363
2364   if (!MovDelay[ax][ay])        /* neue Phase / noch nicht gewartet */
2365     MovDelay[ax][ay] = life_time;
2366
2367   if (MovDelay[ax][ay])         /* neue Phase / in Wartezustand */
2368   {
2369     MovDelay[ax][ay]--;
2370     if (MovDelay[ax][ay])
2371       return;
2372   }
2373
2374   for(y1=-1;y1<2;y1++) for(x1=-1;x1<2;x1++)
2375   {
2376     int xx = ax+x1, yy = ay+y1;
2377     int nachbarn = 0;
2378
2379     if (!IN_LEV_FIELD(xx,yy))
2380       continue;
2381
2382     for(y2=-1;y2<2;y2++) for(x2=-1;x2<2;x2++)
2383     {
2384       int x = xx+x2, y = yy+y2;
2385
2386       if (!IN_LEV_FIELD(x,y) || (x==xx && y==yy))
2387         continue;
2388
2389       if (((Feld[x][y]==element || (element==EL_LIFE && IS_PLAYER(x,y))) &&
2390            !Stop[x][y]) ||
2391           (IS_FREE(x,y) && Stop[x][y]))
2392         nachbarn++;
2393     }
2394
2395     if (xx==ax && yy==ay)               /* mittleres Feld mit Amoebe */
2396     {
2397       if (nachbarn<life[0] || nachbarn>life[1])
2398       {
2399         Feld[xx][yy] = EL_LEERRAUM;
2400         if (!Stop[xx][yy])
2401           DrawLevelField(xx,yy);
2402         Stop[xx][yy] = TRUE;
2403       }
2404     }
2405     else if (IS_FREE(xx,yy) || Feld[xx][yy]==EL_ERDREICH)
2406     {                                   /* Randfeld ohne Amoebe */
2407       if (nachbarn>=life[2] && nachbarn<=life[3])
2408       {
2409         Feld[xx][yy] = element;
2410         MovDelay[xx][yy] = (element==EL_LIFE ? 0 : life_time-1);
2411         if (!Stop[xx][yy])
2412           DrawLevelField(xx,yy);
2413         Stop[xx][yy] = TRUE;
2414       }
2415     }
2416   }
2417 }
2418
2419 void Ablenk(int x, int y)
2420 {
2421   if (!MovDelay[x][y])          /* neue Phase / noch nicht gewartet */
2422     MovDelay[x][y] = level.dauer_ablenk * FRAMES_PER_SECOND;
2423
2424   if (MovDelay[x][y])           /* neue Phase / in Wartezustand */
2425   {
2426     MovDelay[x][y]--;
2427     if (MovDelay[x][y])
2428     {
2429       if (IN_SCR_FIELD(SCREENX(x),SCREENY(y)))
2430         DrawGraphic(SCREENX(x),SCREENY(y),GFX_ABLENK+MovDelay[x][y]%4);
2431       if (!(MovDelay[x][y]%4))
2432         PlaySoundLevel(x,y,SND_MIEP);
2433       return;
2434     }
2435   }
2436
2437   Feld[x][y] = EL_ABLENK_AUS;
2438   DrawLevelField(x,y);
2439   if (ZX==x && ZY==y)
2440     ZX = ZY = -1;
2441 }
2442
2443 void Birne(int x, int y)
2444 {
2445   if (!MovDelay[x][y])          /* neue Phase / noch nicht gewartet */
2446     MovDelay[x][y] = 800;
2447
2448   if (MovDelay[x][y])           /* neue Phase / in Wartezustand */
2449   {
2450     MovDelay[x][y]--;
2451     if (MovDelay[x][y])
2452     {
2453       if (!(MovDelay[x][y]%5))
2454       {
2455         if (!(MovDelay[x][y]%10))
2456           Feld[x][y]=EL_ABLENK_EIN;
2457         else
2458           Feld[x][y]=EL_ABLENK_AUS;
2459         DrawLevelField(x,y);
2460         Feld[x][y]=EL_ABLENK_EIN;
2461       }
2462       return;
2463     }
2464   }
2465
2466   Feld[x][y]=EL_ABLENK_AUS;
2467   DrawLevelField(x,y);
2468   if (ZX==x && ZY==y)
2469     ZX=ZY=-1;
2470 }
2471
2472 void Blubber(int x, int y)
2473 {
2474   if (y > 0 && IS_MOVING(x,y-1) && MovDir[x][y-1] == MV_DOWN)
2475     DrawLevelField(x,y-1);
2476   else
2477     DrawGraphicAnimation(x,y, GFX_GEBLUBBER, 4, 10, ANIM_NORMAL);
2478 }
2479
2480 void NussKnacken(int x, int y)
2481 {
2482   if (!MovDelay[x][y])          /* neue Phase / noch nicht gewartet */
2483     MovDelay[x][y] = 7;
2484
2485   if (MovDelay[x][y])           /* neue Phase / in Wartezustand */
2486   {
2487     MovDelay[x][y]--;
2488     if (MovDelay[x][y]/2 && IN_SCR_FIELD(SCREENX(x),SCREENY(y)))
2489       DrawGraphic(SCREENX(x),SCREENY(y),GFX_CRACKINGNUT+3-MovDelay[x][y]/2);
2490
2491     if (!MovDelay[x][y])
2492     {
2493       Feld[x][y] = EL_EDELSTEIN;
2494       DrawLevelField(x,y);
2495     }
2496   }
2497 }
2498
2499 void SiebAktivieren(int x, int y, int typ)
2500 {
2501   if (!(SiebAktiv % 4) && IN_SCR_FIELD(SCREENX(x),SCREENY(y)))
2502     DrawGraphic(SCREENX(x),SCREENY(y),
2503                 (typ==1 ? GFX_SIEB_VOLL : GFX_SIEB2_VOLL)+3-(SiebAktiv%16)/4);
2504 }
2505
2506 void AusgangstuerPruefen(int x, int y)
2507 {
2508   if (!local_player->gems_still_needed &&
2509       !local_player->sokobanfields_still_needed &&
2510       !local_player->lights_still_needed)
2511   {
2512     Feld[x][y] = EL_AUSGANG_ACT;
2513
2514     PlaySoundLevel(x < LEVELX(BX1) ? LEVELX(BX1) :
2515                    (x > LEVELX(BX2) ? LEVELX(BX2) : x),
2516                    y < LEVELY(BY1) ? LEVELY(BY1) :
2517                    (y > LEVELY(BY2) ? LEVELY(BY2) : y),
2518                    SND_OEFFNEN);
2519   }
2520 }
2521
2522 void AusgangstuerOeffnen(int x, int y)
2523 {
2524   int delay = 6;
2525
2526   if (!MovDelay[x][y])          /* neue Phase / noch nicht gewartet */
2527     MovDelay[x][y] = 5*delay;
2528
2529   if (MovDelay[x][y])           /* neue Phase / in Wartezustand */
2530   {
2531     int tuer;
2532
2533     MovDelay[x][y]--;
2534     tuer = MovDelay[x][y]/delay;
2535     if (!(MovDelay[x][y]%delay) && IN_SCR_FIELD(SCREENX(x),SCREENY(y)))
2536       DrawGraphic(SCREENX(x),SCREENY(y),GFX_AUSGANG_AUF-tuer);
2537
2538     if (!MovDelay[x][y])
2539     {
2540       Feld[x][y] = EL_AUSGANG_AUF;
2541       DrawLevelField(x,y);
2542     }
2543   }
2544 }
2545
2546 void AusgangstuerBlinken(int x, int y)
2547 {
2548   DrawGraphicAnimation(x,y, GFX_AUSGANG_AUF, 4, 4, ANIM_OSCILLATE);
2549 }
2550
2551 void EdelsteinFunkeln(int x, int y)
2552 {
2553   if (!IN_SCR_FIELD(SCREENX(x),SCREENY(y)) || IS_MOVING(x,y))
2554     return;
2555
2556   if (Feld[x][y] == EL_EDELSTEIN_BD)
2557     DrawGraphicAnimation(x,y, GFX_EDELSTEIN_BD, 4, 4, ANIM_REVERSE);
2558   else
2559   {
2560     if (!MovDelay[x][y])        /* neue Phase / noch nicht gewartet */
2561       MovDelay[x][y] = 11 * !SimpleRND(500);
2562
2563     if (MovDelay[x][y])         /* neue Phase / in Wartezustand */
2564     {
2565       MovDelay[x][y]--;
2566
2567       if (direct_draw_on && MovDelay[x][y])
2568         SetDrawtoField(DRAW_BUFFERED);
2569
2570       DrawGraphic(SCREENX(x),SCREENY(y), el2gfx(Feld[x][y]));
2571
2572       if (MovDelay[x][y])
2573       {
2574         int phase = (MovDelay[x][y]-1)/2;
2575
2576         if (phase > 2)
2577           phase = 4-phase;
2578
2579         DrawGraphicThruMask(SCREENX(x),SCREENY(y), GFX_FUNKELN_WEISS + phase);
2580
2581         if (direct_draw_on)
2582         {
2583           int dest_x,dest_y;
2584
2585           dest_x = FX + SCREENX(x)*TILEX;
2586           dest_y = FY + SCREENY(y)*TILEY;
2587
2588           XCopyArea(display,drawto_field,window,gc,
2589                     dest_x,dest_y, TILEX,TILEY, dest_x,dest_y);
2590           SetDrawtoField(DRAW_DIRECT);
2591         }
2592       }
2593     }
2594   }
2595 }
2596
2597 void MauerWaechst(int x, int y)
2598 {
2599   int delay = 6;
2600
2601   if (!MovDelay[x][y])          /* neue Phase / noch nicht gewartet */
2602     MovDelay[x][y] = 3*delay;
2603
2604   if (MovDelay[x][y])           /* neue Phase / in Wartezustand */
2605   {
2606     int phase;
2607
2608     MovDelay[x][y]--;
2609     phase = 2-MovDelay[x][y]/delay;
2610     if (!(MovDelay[x][y]%delay) && IN_SCR_FIELD(SCREENX(x),SCREENY(y)))
2611       DrawGraphic(SCREENX(x),SCREENY(y),
2612                   (MovDir[x][y] == MV_LEFT  ? GFX_MAUER_LEFT  :
2613                    MovDir[x][y] == MV_RIGHT ? GFX_MAUER_RIGHT :
2614                    MovDir[x][y] == MV_UP    ? GFX_MAUER_UP    :
2615                                               GFX_MAUER_DOWN  ) + phase);
2616
2617     if (!MovDelay[x][y])
2618     {
2619       if (MovDir[x][y] == MV_LEFT)
2620       {
2621         if (IN_LEV_FIELD(x-1,y) && IS_MAUER(Feld[x-1][y]))
2622           DrawLevelField(x-1,y);
2623       }
2624       else if (MovDir[x][y] == MV_RIGHT)
2625       {
2626         if (IN_LEV_FIELD(x+1,y) && IS_MAUER(Feld[x+1][y]))
2627           DrawLevelField(x+1,y);
2628       }
2629       else if (MovDir[x][y] == MV_UP)
2630       {
2631         if (IN_LEV_FIELD(x,y-1) && IS_MAUER(Feld[x][y-1]))
2632           DrawLevelField(x,y-1);
2633       }
2634       else
2635       {
2636         if (IN_LEV_FIELD(x,y+1) && IS_MAUER(Feld[x][y+1]))
2637           DrawLevelField(x,y+1);
2638       }
2639
2640       Feld[x][y] = Store[x][y];
2641       Store[x][y] = 0;
2642       MovDir[x][y] = MV_NO_MOVING;
2643       DrawLevelField(x,y);
2644     }
2645   }
2646 }
2647
2648 void MauerAbleger(int ax, int ay)
2649 {
2650   int element = Feld[ax][ay];
2651   BOOL oben_frei = FALSE, unten_frei = FALSE;
2652   BOOL links_frei = FALSE, rechts_frei = FALSE;
2653   BOOL oben_massiv = FALSE, unten_massiv = FALSE;
2654   BOOL links_massiv = FALSE, rechts_massiv = FALSE;
2655
2656   if (!MovDelay[ax][ay])        /* neue Mauer / noch nicht gewartet */
2657     MovDelay[ax][ay] = 6;
2658
2659   if (MovDelay[ax][ay])         /* neue Mauer / in Wartezustand */
2660   {
2661     MovDelay[ax][ay]--;
2662     if (MovDelay[ax][ay])
2663       return;
2664   }
2665
2666   if (IN_LEV_FIELD(ax,ay-1) && IS_FREE(ax,ay-1))
2667     oben_frei = TRUE;
2668   if (IN_LEV_FIELD(ax,ay+1) && IS_FREE(ax,ay+1))
2669     unten_frei = TRUE;
2670   if (IN_LEV_FIELD(ax-1,ay) && IS_FREE(ax-1,ay))
2671     links_frei = TRUE;
2672   if (IN_LEV_FIELD(ax+1,ay) && IS_FREE(ax+1,ay))
2673     rechts_frei = TRUE;
2674
2675   if (element == EL_MAUER_Y || element == EL_MAUER_XY)
2676   {
2677     if (oben_frei)
2678     {
2679       Feld[ax][ay-1] = EL_MAUERND;
2680       Store[ax][ay-1] = element;
2681       MovDir[ax][ay-1] = MV_UP;
2682       if (IN_SCR_FIELD(SCREENX(ax),SCREENY(ay-1)))
2683         DrawGraphic(SCREENX(ax),SCREENY(ay-1),GFX_MAUER_UP);
2684     }
2685     if (unten_frei)
2686     {
2687       Feld[ax][ay+1] = EL_MAUERND;
2688       Store[ax][ay+1] = element;
2689       MovDir[ax][ay+1] = MV_DOWN;
2690       if (IN_SCR_FIELD(SCREENX(ax),SCREENY(ay+1)))
2691         DrawGraphic(SCREENX(ax),SCREENY(ay+1),GFX_MAUER_DOWN);
2692     }
2693   }
2694
2695   if (element == EL_MAUER_X || element == EL_MAUER_XY ||
2696       element == EL_MAUER_LEBT)
2697   {
2698     if (links_frei)
2699     {
2700       Feld[ax-1][ay] = EL_MAUERND;
2701       Store[ax-1][ay] = element;
2702       MovDir[ax-1][ay] = MV_LEFT;
2703       if (IN_SCR_FIELD(SCREENX(ax-1),SCREENY(ay)))
2704         DrawGraphic(SCREENX(ax-1),SCREENY(ay),GFX_MAUER_LEFT);
2705     }
2706     if (rechts_frei)
2707     {
2708       Feld[ax+1][ay] = EL_MAUERND;
2709       Store[ax+1][ay] = element;
2710       MovDir[ax+1][ay] = MV_RIGHT;
2711       if (IN_SCR_FIELD(SCREENX(ax+1),SCREENY(ay)))
2712         DrawGraphic(SCREENX(ax+1),SCREENY(ay),GFX_MAUER_RIGHT);
2713     }
2714   }
2715
2716   if (element == EL_MAUER_LEBT && (links_frei || rechts_frei))
2717     DrawLevelField(ax,ay);
2718
2719   if (!IN_LEV_FIELD(ax,ay-1) || IS_MAUER(Feld[ax][ay-1]))
2720     oben_massiv = TRUE;
2721   if (!IN_LEV_FIELD(ax,ay+1) || IS_MAUER(Feld[ax][ay+1]))
2722     unten_massiv = TRUE;
2723   if (!IN_LEV_FIELD(ax-1,ay) || IS_MAUER(Feld[ax-1][ay]))
2724     links_massiv = TRUE;
2725   if (!IN_LEV_FIELD(ax+1,ay) || IS_MAUER(Feld[ax+1][ay]))
2726     rechts_massiv = TRUE;
2727
2728   if (((oben_massiv && unten_massiv) ||
2729        element == EL_MAUER_X || element == EL_MAUER_LEBT) &&
2730       ((links_massiv && rechts_massiv) ||
2731        element == EL_MAUER_Y))
2732     Feld[ax][ay] = EL_MAUERWERK;
2733 }
2734
2735 void CheckForDragon(int x, int y)
2736 {
2737   int i,j;
2738   BOOL dragon_found = FALSE;
2739   static int xy[4][2] =
2740   {
2741     { 0,-1 },
2742     { -1,0 },
2743     { +1,0 },
2744     { 0,+1 }
2745   };
2746
2747   for(i=0;i<4;i++)
2748   {
2749     for(j=0;j<4;j++)
2750     {
2751       int xx = x + j*xy[i][0], yy = y + j*xy[i][1];
2752
2753       if (IN_LEV_FIELD(xx,yy) &&
2754           (Feld[xx][yy] == EL_BURNING || Feld[xx][yy] == EL_DRACHE))
2755       {
2756         if (Feld[xx][yy] == EL_DRACHE)
2757           dragon_found = TRUE;
2758       }
2759       else
2760         break;
2761     }
2762   }
2763
2764   if (!dragon_found)
2765   {
2766     for(i=0;i<4;i++)
2767     {
2768       for(j=0;j<3;j++)
2769       {
2770         int xx = x + j*xy[i][0], yy = y + j*xy[i][1];
2771
2772         if (IN_LEV_FIELD(xx,yy) && Feld[xx][yy] == EL_BURNING)
2773         {
2774           Feld[xx][yy] = EL_LEERRAUM;
2775           DrawLevelField(xx,yy);
2776         }
2777         else
2778           break;
2779       }
2780     }
2781   }
2782 }
2783
2784 void PlayerActions(struct PlayerInfo *player, byte player_action)
2785 {
2786   static byte stored_player_action[MAX_PLAYERS];
2787   static int num_stored_actions = 0;
2788   BOOL moved = FALSE, snapped = FALSE, bombed = FALSE;
2789   int jx = player->jx, jy = player->jy;
2790   int left      = player_action & JOY_LEFT;
2791   int right     = player_action & JOY_RIGHT;
2792   int up        = player_action & JOY_UP;
2793   int down      = player_action & JOY_DOWN;
2794   int button1   = player_action & JOY_BUTTON_1;
2795   int button2   = player_action & JOY_BUTTON_2;
2796   int dx        = (left ? -1    : right ? 1     : 0);
2797   int dy        = (up   ? -1    : down  ? 1     : 0);
2798
2799   stored_player_action[player->index_nr] = 0;
2800   num_stored_actions++;
2801
2802   if (!player->active || player->gone)
2803     return;
2804
2805   if (player_action)
2806   {
2807     player->frame_reset_delay = 0;
2808
2809     if (button1)
2810       snapped = SnapField(player, dx,dy);
2811     else
2812     {
2813       if (button2)
2814         bombed = PlaceBomb(player);
2815       moved = MoveFigure(player, dx,dy);
2816     }
2817
2818     if (tape.recording && (moved || snapped || bombed))
2819     {
2820       if (bombed && !moved)
2821         player_action &= JOY_BUTTON;
2822
2823       stored_player_action[player->index_nr] = player_action;
2824
2825       /* this allows cycled sequences of PlayerActions() */
2826       if (num_stored_actions >= MAX_PLAYERS)
2827       {
2828         TapeRecordAction(stored_player_action);
2829         num_stored_actions = 0;
2830       }
2831     }
2832     else if (tape.playing && snapped)
2833       SnapField(player, 0,0);                   /* stop snapping */
2834   }
2835   else
2836   {
2837     DigField(player, 0,0, 0,0, DF_NO_PUSH);
2838     SnapField(player, 0,0);
2839     if (++player->frame_reset_delay > MoveSpeed)
2840       player->Frame = 0;
2841   }
2842
2843   if (tape.playing && !tape.pausing && !player_action &&
2844       tape.counter < tape.length)
2845   {
2846     int next_joy =
2847       tape.pos[tape.counter].action[player->index_nr] & (JOY_LEFT|JOY_RIGHT);
2848
2849     if (next_joy == JOY_LEFT || next_joy == JOY_RIGHT)
2850     {
2851       int dx = (next_joy == JOY_LEFT ? -1 : +1);
2852
2853       if (IN_LEV_FIELD(jx+dx,jy) && IS_PUSHABLE(Feld[jx+dx][jy]))
2854       {
2855         int el = Feld[jx+dx][jy];
2856         int push_delay = (IS_SB_ELEMENT(el) || el==EL_SONDE ? 2 : 10);
2857
2858         if (tape.delay_played + push_delay >= tape.pos[tape.counter].delay)
2859         {
2860           player->MovDir = next_joy;
2861           player->Frame = FrameCounter % 4;
2862           player->Pushing = TRUE;
2863         }
2864       }
2865     }
2866   }
2867 }
2868
2869 void GameActions(byte player_action)
2870 {
2871   static long action_delay = 0;
2872   long action_delay_value;
2873   int sieb_x = 0, sieb_y = 0;
2874   int i, x,y, element;
2875   int *recorded_player_action;
2876
2877   if (game_status != PLAYING)
2878     return;
2879
2880 #ifdef DEBUG
2881   action_delay_value =
2882     (tape.playing && tape.fast_forward ? FFWD_FRAME_DELAY : GameFrameDelay);
2883 #else
2884   action_delay_value =
2885     (tape.playing && tape.fast_forward ? FFWD_FRAME_DELAY : GAME_FRAME_DELAY);
2886 #endif
2887
2888   /* main game synchronization point */
2889   WaitUntilDelayReached(&action_delay, action_delay_value);
2890
2891   if (!standalone && !network_player_action_received)
2892   {
2893     /*
2894 #ifdef DEBUG
2895     printf("DEBUG: try to get network player actions in time\n");
2896 #endif
2897     */
2898
2899     /* last chance to get network player actions without main loop delay */
2900     HandleNetworking();
2901
2902     if (game_status != PLAYING)
2903       return;
2904
2905     if (!network_player_action_received)
2906     {
2907       /*
2908 #ifdef DEBUG
2909       printf("DEBUG: failed to get network player actions in time\n");
2910 #endif
2911       */
2912       return;
2913     }
2914   }
2915
2916   if (tape.playing)
2917     recorded_player_action = TapePlayAction();
2918   else
2919     recorded_player_action = NULL;
2920
2921   if (!standalone)
2922     SendToServer_MovePlayer(player_action);
2923
2924   for(i=0; i<MAX_PLAYERS; i++)
2925   {
2926     int actual_player_action =
2927       (standalone ? player_action : network_player_action[i]);
2928
2929     /*
2930     int actual_player_action = network_player_action[i];
2931     */
2932
2933     /*
2934     int actual_player_action = player_action;
2935     */
2936
2937     /* TEST TEST TEST */
2938
2939     /*
2940     if (i != TestPlayer && !stored_player[i].MovPos)
2941       actual_player_action = 0;
2942     */
2943
2944     if (standalone && i != TestPlayer)
2945       actual_player_action = 0;
2946
2947     /* TEST TEST TEST */
2948
2949     if (recorded_player_action)
2950       actual_player_action = recorded_player_action[i];
2951
2952     PlayerActions(&stored_player[i], actual_player_action);
2953     ScrollFigure(&stored_player[i], SCROLL_GO_ON);
2954
2955     network_player_action[i] = 0;
2956   }
2957
2958   network_player_action_received = FALSE;
2959
2960   ScrollScreen(NULL, SCROLL_GO_ON);
2961
2962   if (tape.pausing || (tape.playing && !TapePlayDelay()))
2963     return;
2964   else if (tape.recording)
2965     TapeRecordDelay();
2966
2967   FrameCounter++;
2968   TimeFrames++;
2969
2970
2971   /*
2972   printf("FrameCounter == %d, RND(100) == %d\n", FrameCounter, RND(100));
2973   */
2974
2975
2976   for(y=0;y<lev_fieldy;y++) for(x=0;x<lev_fieldx;x++)
2977   {
2978     Stop[x][y] = FALSE;
2979     if (JustHit[x][y]>0)
2980       JustHit[x][y]--;
2981
2982 #if DEBUG
2983     if (IS_BLOCKED(x,y))
2984     {
2985       int oldx,oldy;
2986
2987       Blocked2Moving(x,y,&oldx,&oldy);
2988       if (!IS_MOVING(oldx,oldy))
2989       {
2990         printf("GameActions(): (BLOCKED=>MOVING) context corrupted!\n");
2991         printf("GameActions(): BLOCKED: x = %d, y = %d\n",x,y);
2992         printf("GameActions(): !MOVING: oldx = %d, oldy = %d\n",oldx,oldy);
2993         printf("GameActions(): This should never happen!\n");
2994       }
2995     }
2996 #endif
2997   }
2998
2999   for(y=0;y<lev_fieldy;y++) for(x=0;x<lev_fieldx;x++)
3000   {
3001     element = Feld[x][y];
3002
3003     if (IS_INACTIVE(element))
3004       continue;
3005
3006     if (!IS_MOVING(x,y) && (CAN_FALL(element) || CAN_MOVE(element)))
3007     {
3008       StartMoving(x,y);
3009
3010       if (IS_GEM(element))
3011         EdelsteinFunkeln(x,y);
3012     }
3013     else if (IS_MOVING(x,y))
3014       ContinueMoving(x,y);
3015     else if (element==EL_DYNAMIT || element==EL_DYNABOMB)
3016       CheckDynamite(x,y);
3017     else if (element==EL_EXPLODING)
3018       Explode(x,y,Frame[x][y],EX_NORMAL);
3019     else if (element==EL_AMOEBING)
3020       AmoebeWaechst(x,y);
3021     else if (IS_AMOEBALIVE(element))
3022       AmoebeAbleger(x,y);
3023     else if (element==EL_LIFE || element==EL_LIFE_ASYNC)
3024       Life(x,y);
3025     else if (element==EL_ABLENK_EIN)
3026       Ablenk(x,y);
3027     else if (element==EL_SALZSAEURE)
3028       Blubber(x,y);
3029     else if (element==EL_BLURB_LEFT || element==EL_BLURB_RIGHT)
3030       Blurb(x,y);
3031     else if (element==EL_CRACKINGNUT)
3032       NussKnacken(x,y);
3033     else if (element==EL_AUSGANG_ZU)
3034       AusgangstuerPruefen(x,y);
3035     else if (element==EL_AUSGANG_ACT)
3036       AusgangstuerOeffnen(x,y);
3037     else if (element==EL_AUSGANG_AUF)
3038       AusgangstuerBlinken(x,y);
3039     else if (element==EL_MAUERND)
3040       MauerWaechst(x,y);
3041     else if (element==EL_MAUER_LEBT ||
3042              element==EL_MAUER_X ||
3043              element==EL_MAUER_Y ||
3044              element==EL_MAUER_XY)
3045       MauerAbleger(x,y);
3046     else if (element==EL_BURNING)
3047       CheckForDragon(x,y);
3048
3049     if (SiebAktiv)
3050     {
3051       BOOL sieb = FALSE;
3052       int jx = local_player->jx, jy = local_player->jy;
3053
3054       if (element==EL_SIEB_LEER || element==EL_SIEB_VOLL ||
3055           Store[x][y]==EL_SIEB_LEER)
3056       {
3057         SiebAktivieren(x, y, 1);
3058         sieb = TRUE;
3059       }
3060       else if (element==EL_SIEB2_LEER || element==EL_SIEB2_VOLL ||
3061                Store[x][y]==EL_SIEB2_LEER)
3062       {
3063         SiebAktivieren(x, y, 2);
3064         sieb = TRUE;
3065       }
3066
3067       /* play the element sound at the position nearest to the player */
3068       if (sieb && ABS(x-jx)+ABS(y-jy) < ABS(sieb_x-jx)+ABS(sieb_y-jy))
3069       {
3070         sieb_x = x;
3071         sieb_y = y;
3072       }
3073     }
3074   }
3075
3076   if (SiebAktiv)
3077   {
3078     if (!(SiebAktiv%4))
3079       PlaySoundLevel(sieb_x,sieb_y,SND_MIEP);
3080     SiebAktiv--;
3081     if (!SiebAktiv)
3082     {
3083       for(y=0;y<lev_fieldy;y++) for(x=0;x<lev_fieldx;x++)
3084       {
3085         element = Feld[x][y];
3086         if (element==EL_SIEB_LEER || element==EL_SIEB_VOLL)
3087         {
3088           Feld[x][y] = EL_SIEB_TOT;
3089           DrawLevelField(x,y);
3090         }
3091         else if (element==EL_SIEB2_LEER || element==EL_SIEB2_VOLL)
3092         {
3093           Feld[x][y] = EL_SIEB2_TOT;
3094           DrawLevelField(x,y);
3095         }
3096       }
3097     }
3098   }
3099
3100   if (TimeLeft>0 && TimeFrames>=(1000/GameFrameDelay) && !tape.pausing)
3101   {
3102     TimeFrames = 0;
3103     TimeLeft--;
3104
3105     if (tape.recording || tape.playing)
3106       DrawVideoDisplay(VIDEO_STATE_TIME_ON,level.time-TimeLeft);
3107
3108     if (TimeLeft<=10)
3109       PlaySoundStereo(SND_GONG,PSND_MAX_RIGHT);
3110
3111     DrawText(DX_TIME,DY_TIME,int2str(TimeLeft,3),FS_SMALL,FC_YELLOW);
3112
3113     if (!TimeLeft)
3114       for(i=0; i<MAX_PLAYERS; i++)
3115         KillHero(&stored_player[i]);
3116   }
3117
3118   DrawAllPlayers();
3119 }
3120
3121 static BOOL AllPlayersInSight(struct PlayerInfo *player, int x, int y)
3122 {
3123   int min_x = x, min_y = y, max_x = x, max_y = y;
3124   int i;
3125
3126   for(i=0; i<MAX_PLAYERS; i++)
3127   {
3128     int jx = stored_player[i].jx, jy = stored_player[i].jy;
3129
3130     if (!stored_player[i].active || stored_player[i].gone ||
3131         &stored_player[i] == player)
3132       continue;
3133
3134     min_x = MIN(min_x, jx);
3135     min_y = MIN(min_y, jy);
3136     max_x = MAX(max_x, jx);
3137     max_y = MAX(max_y, jy);
3138   }
3139
3140   return(max_x - min_x < SCR_FIELDX && max_y - min_y < SCR_FIELDY);
3141 }
3142
3143 static BOOL AllPlayersInVisibleScreen()
3144 {
3145   int i;
3146
3147   for(i=0; i<MAX_PLAYERS; i++)
3148   {
3149     int jx = stored_player[i].jx, jy = stored_player[i].jy;
3150
3151     if (!stored_player[i].active || stored_player[i].gone)
3152       continue;
3153
3154     if (!IN_VIS_FIELD(SCREENX(jx), SCREENY(jy)))
3155       return(FALSE);
3156   }
3157
3158   return(TRUE);
3159 }
3160
3161 void ScrollLevel(int dx, int dy)
3162 {
3163   int softscroll_offset = (soft_scrolling_on ? TILEX : 0);
3164   int x,y;
3165
3166   /*
3167   ScreenGfxPos = local_player->GfxPos;
3168   */
3169
3170   XCopyArea(display,drawto_field,drawto_field,gc,
3171             FX + TILEX*(dx==-1) - softscroll_offset,
3172             FY + TILEY*(dy==-1) - softscroll_offset,
3173             SXSIZE - TILEX*(dx!=0) + 2*softscroll_offset,
3174             SYSIZE - TILEY*(dy!=0) + 2*softscroll_offset,
3175             FX + TILEX*(dx==1) - softscroll_offset,
3176             FY + TILEY*(dy==1) - softscroll_offset);
3177
3178   if (dx)
3179   {
3180     x = (dx==1 ? BX1 : BX2);
3181     for(y=BY1; y<=BY2; y++)
3182       DrawScreenField(x,y);
3183   }
3184   if (dy)
3185   {
3186     y = (dy==1 ? BY1 : BY2);
3187     for(x=BX1; x<=BX2; x++)
3188       DrawScreenField(x,y);
3189   }
3190
3191   redraw_mask |= REDRAW_FIELD;
3192 }
3193
3194 BOOL MoveFigureOneStep(struct PlayerInfo *player,
3195                        int dx, int dy, int real_dx, int real_dy)
3196 {
3197   int jx = player->jx, jy = player->jy;
3198   int new_jx = jx+dx, new_jy = jy+dy;
3199   int element;
3200   int can_move;
3201
3202   if (player->gone || (!dx && !dy))
3203     return(MF_NO_ACTION);
3204
3205   player->MovDir = (dx < 0 ? MV_LEFT :
3206                     dx > 0 ? MV_RIGHT :
3207                     dy < 0 ? MV_UP :
3208                     dy > 0 ? MV_DOWN :  MV_NO_MOVING);
3209
3210   if (!IN_LEV_FIELD(new_jx,new_jy))
3211     return(MF_NO_ACTION);
3212
3213   if (standalone && !AllPlayersInSight(player, new_jx,new_jy))
3214     return(MF_NO_ACTION);
3215
3216   element = MovingOrBlocked2Element(new_jx,new_jy);
3217
3218   if (DONT_GO_TO(element))
3219   {
3220     if (element==EL_SALZSAEURE && dx==0 && dy==1)
3221     {
3222       Blurb(jx,jy);
3223       Feld[jx][jy] = EL_SPIELFIGUR;
3224       InitMovingField(jx,jy,MV_DOWN);
3225       Store[jx][jy] = EL_SALZSAEURE;
3226       ContinueMoving(jx,jy);
3227       BuryHero(player);
3228     }
3229     else
3230       KillHero(player);
3231
3232     return(MF_MOVING);
3233   }
3234
3235   can_move = DigField(player, new_jx,new_jy, real_dx,real_dy, DF_DIG);
3236   if (can_move != MF_MOVING)
3237     return(can_move);
3238
3239   StorePlayer[jx][jy] = 0;
3240   player->last_jx = jx;
3241   player->last_jy = jy;
3242   jx = player->jx = new_jx;
3243   jy = player->jy = new_jy;
3244   StorePlayer[jx][jy] = player->element_nr;
3245
3246   player->MovPos = (dx > 0 || dy > 0 ? -1 : 1) * 7*TILEX/8;
3247
3248   ScrollFigure(player, SCROLL_INIT);
3249
3250   return(MF_MOVING);
3251 }
3252
3253 BOOL MoveFigure(struct PlayerInfo *player, int dx, int dy)
3254 {
3255   int jx = player->jx, jy = player->jy;
3256   int old_jx = jx, old_jy = jy;
3257   int moved = MF_NO_ACTION;
3258
3259   if (player->gone || (!dx && !dy))
3260     return(FALSE);
3261
3262   if (!FrameReached(&player->move_delay,MoveSpeed) && !tape.playing)
3263     return(FALSE);
3264
3265   if (player->last_move_dir & (MV_LEFT | MV_RIGHT))
3266   {
3267     if (!(moved |= MoveFigureOneStep(player, 0,dy, dx,dy)))
3268       moved |= MoveFigureOneStep(player, dx,0, dx,dy);
3269   }
3270   else
3271   {
3272     if (!(moved |= MoveFigureOneStep(player, dx,0, dx,dy)))
3273       moved |= MoveFigureOneStep(player, 0,dy, dx,dy);
3274   }
3275
3276   jx = player->jx;
3277   jy = player->jy;
3278
3279
3280
3281   /*
3282   if (moved & MF_MOVING && player == local_player)
3283   */
3284
3285   if (moved & MF_MOVING && !ScreenMovPos &&
3286       (player == local_player || standalone))
3287   {
3288     int old_scroll_x = scroll_x, old_scroll_y = scroll_y;
3289     int offset = (scroll_delay_on ? 3 : 0);
3290
3291     /*
3292     if (player == local_player)
3293     {
3294       printf("MOVING LOCAL PLAYER && SCROLLING\n");
3295     }
3296     */
3297
3298     if (!IN_VIS_FIELD(SCREENX(jx),SCREENY(jy)))
3299     {
3300       /* actual player has left the screen -- scroll in that direction */
3301       if (jx != old_jx)         /* player has moved horizontally */
3302         scroll_x += (jx - old_jx);
3303       else                      /* player has moved vertically */
3304         scroll_y += (jy - old_jy);
3305     }
3306     else
3307     {
3308       if (jx != old_jx)         /* player has moved horizontally */
3309       {
3310         if ((scroll_x < jx-MIDPOSX-offset || scroll_x > jx-MIDPOSX+offset) &&
3311             jx >= MIDPOSX-1-offset && jx <= lev_fieldx-(MIDPOSX-offset))
3312           scroll_x = jx-MIDPOSX + (scroll_x < jx-MIDPOSX ? -offset : offset);
3313
3314         /* don't scroll more than one field at a time */
3315         scroll_x = old_scroll_x + SIGN(scroll_x - old_scroll_x);
3316
3317         /* don't scroll against the player's moving direction */
3318         if ((player->MovDir == MV_LEFT && scroll_x > old_scroll_x) ||
3319             (player->MovDir == MV_RIGHT && scroll_x < old_scroll_x))
3320           scroll_x = old_scroll_x;
3321       }
3322       else                      /* player has moved vertically */
3323       {
3324         if ((scroll_y < jy-MIDPOSY-offset || scroll_y > jy-MIDPOSY+offset) &&
3325             jy >= MIDPOSY-1-offset && jy <= lev_fieldy-(MIDPOSY-offset))
3326           scroll_y = jy-MIDPOSY + (scroll_y < jy-MIDPOSY ? -offset : offset);
3327
3328         /* don't scroll more than one field at a time */
3329         scroll_y = old_scroll_y + SIGN(scroll_y - old_scroll_y);
3330
3331         /* don't scroll against the player's moving direction */
3332         if ((player->MovDir == MV_UP && scroll_y > old_scroll_y) ||
3333             (player->MovDir == MV_DOWN && scroll_y < old_scroll_y))
3334           scroll_y = old_scroll_y;
3335       }
3336     }
3337
3338 #if 0
3339     if (player == local_player)
3340     {
3341       if ((scroll_x < jx-MIDPOSX-offset || scroll_x > jx-MIDPOSX+offset) &&
3342           jx >= MIDPOSX-1-offset && jx <= lev_fieldx-(MIDPOSX-offset))
3343         scroll_x = jx-MIDPOSX + (scroll_x < jx-MIDPOSX ? -offset : offset);
3344       if ((scroll_y < jy-MIDPOSY-offset || scroll_y > jy-MIDPOSY+offset) &&
3345           jy >= MIDPOSY-1-offset && jy <= lev_fieldy-(MIDPOSY-offset))
3346         scroll_y = jy-MIDPOSY + (scroll_y < jy-MIDPOSY ? -offset : offset);
3347
3348       /* don't scroll more than one field at a time */
3349       scroll_x = old_scroll_x + SIGN(scroll_x - old_scroll_x);
3350       scroll_y = old_scroll_y + SIGN(scroll_y - old_scroll_y);
3351     }
3352 #endif
3353
3354     if (scroll_x != old_scroll_x || scroll_y != old_scroll_y)
3355     {
3356       if (standalone && !AllPlayersInVisibleScreen())
3357       {
3358         scroll_x = old_scroll_x;
3359         scroll_y = old_scroll_y;
3360       }
3361       else
3362       {
3363         ScrollScreen(player, SCROLL_INIT);
3364         ScrollLevel(old_scroll_x - scroll_x, old_scroll_y - scroll_y);
3365       }
3366     }
3367   }
3368
3369   if (!(moved & MF_MOVING) && !player->Pushing)
3370     player->Frame = 0;
3371   else
3372     player->Frame = (player->Frame + 1) % 4;
3373
3374   if (moved & MF_MOVING)
3375   {
3376     if (old_jx != jx && old_jy == jy)
3377       player->MovDir = (old_jx < jx ? MV_RIGHT : MV_LEFT);
3378     else if (old_jx == jx && old_jy != jy)
3379       player->MovDir = (old_jy < jy ? MV_DOWN : MV_UP);
3380
3381     DrawLevelField(jx,jy);      /* für "ErdreichAnbroeckeln()" */
3382
3383     player->last_move_dir = player->MovDir;
3384   }
3385   else
3386     player->last_move_dir = MV_NO_MOVING;
3387
3388   TestIfHeroHitsBadThing(jx,jy);
3389
3390   if (player->gone)
3391     RemoveHero(player);
3392
3393   return(moved);
3394 }
3395
3396 void ScrollFigure(struct PlayerInfo *player, int mode)
3397 {
3398   int jx = player->jx, jy = player->jy;
3399   int last_jx = player->last_jx, last_jy = player->last_jy;
3400
3401   if (!player->active || player->gone || !player->MovPos)
3402     return;
3403
3404   if (mode == SCROLL_INIT)
3405   {
3406     player->actual_frame_counter = FrameCounter;
3407     player->GfxPos = ScrollStepSize * (player->MovPos / ScrollStepSize);
3408
3409     if (Feld[last_jx][last_jy] == EL_LEERRAUM)
3410       Feld[last_jx][last_jy] = EL_PLAYER_IS_LEAVING;
3411
3412     DrawPlayer(player);
3413     return;
3414   }
3415   else if (!FrameReached(&player->actual_frame_counter,1))
3416     return;
3417
3418   player->MovPos += (player->MovPos > 0 ? -1 : 1) * TILEX/8;
3419   player->GfxPos = ScrollStepSize * (player->MovPos / ScrollStepSize);
3420
3421   if (Feld[last_jx][last_jy] == EL_PLAYER_IS_LEAVING)
3422     Feld[last_jx][last_jy] = EL_LEERRAUM;
3423
3424   DrawPlayer(player);
3425
3426   if (!player->MovPos)
3427   {
3428     player->last_jx = jx;
3429     player->last_jy = jy;
3430
3431     if (Feld[jx][jy] == EL_AUSGANG_AUF)
3432     {
3433       RemoveHero(player);
3434
3435       if (!local_player->friends_still_needed)
3436         player->LevelSolved = player->GameOver = TRUE;
3437     }
3438   }
3439 }
3440
3441 void ScrollScreen(struct PlayerInfo *player, int mode)
3442 {
3443   static long screen_frame_counter = 0;
3444
3445   if (mode == SCROLL_INIT)
3446   {
3447     screen_frame_counter = FrameCounter;
3448     ScreenMovDir = player->MovDir;
3449     ScreenMovPos = player->MovPos;
3450     ScreenGfxPos = ScrollStepSize * (ScreenMovPos / ScrollStepSize);
3451     return;
3452   }
3453   else if (!FrameReached(&screen_frame_counter,1))
3454     return;
3455
3456   if (ScreenMovPos)
3457   {
3458     ScreenMovPos += (ScreenMovPos > 0 ? -1 : 1) * TILEX/8;
3459     ScreenGfxPos = ScrollStepSize * (ScreenMovPos / ScrollStepSize);
3460     redraw_mask |= REDRAW_FIELD;
3461   }
3462   else
3463     ScreenMovDir = MV_NO_MOVING;
3464 }
3465
3466 void TestIfGoodThingHitsBadThing(int goodx, int goody)
3467 {
3468   int i, killx = goodx, killy = goody;
3469   static int xy[4][2] =
3470   {
3471     { 0,-1 },
3472     { -1,0 },
3473     { +1,0 },
3474     { 0,+1 }
3475   };
3476   static int harmless[4] =
3477   {
3478     MV_UP,
3479     MV_LEFT,
3480     MV_RIGHT,
3481     MV_DOWN
3482   };
3483
3484   for(i=0; i<4; i++)
3485   {
3486     int x,y, element;
3487
3488     x = goodx + xy[i][0];
3489     y = goody + xy[i][1];
3490     if (!IN_LEV_FIELD(x,y))
3491       continue;
3492
3493     element = Feld[x][y];
3494
3495     if (DONT_TOUCH(element))
3496     {
3497       if (MovDir[x][y] == harmless[i])
3498         continue;
3499
3500       killx = x;
3501       killy = y;
3502       break;
3503     }
3504   }
3505
3506   if (killx != goodx || killy != goody)
3507   {
3508     if (IS_PLAYER(goodx,goody))
3509       KillHero(PLAYERINFO(goodx,goody));
3510     else
3511       Bang(goodx,goody);
3512   }
3513 }
3514
3515 void TestIfBadThingHitsGoodThing(int badx, int bady)
3516 {
3517   int i, killx = badx, killy = bady;
3518   static int xy[4][2] =
3519   {
3520     { 0,-1 },
3521     { -1,0 },
3522     { +1,0 },
3523     { 0,+1 }
3524   };
3525   static int harmless[4] =
3526   {
3527     MV_UP,
3528     MV_LEFT,
3529     MV_RIGHT,
3530     MV_DOWN
3531   };
3532
3533   for(i=0; i<4; i++)
3534   {
3535     int x,y, element;
3536
3537     x = badx + xy[i][0];
3538     y = bady + xy[i][1];
3539     if (!IN_LEV_FIELD(x,y))
3540       continue;
3541
3542     element = Feld[x][y];
3543
3544     if (IS_PLAYER(x,y))
3545     {
3546       killx = x;
3547       killy = y;
3548       break;
3549     }
3550     else if (element == EL_PINGUIN)
3551     {
3552       if (MovDir[x][y] == harmless[i] && IS_MOVING(x,y))
3553         continue;
3554
3555       killx = x;
3556       killy = y;
3557       break;
3558     }
3559   }
3560
3561   if (killx != badx || killy != bady)
3562   {
3563     if (IS_PLAYER(killx,killy))
3564       KillHero(PLAYERINFO(killx,killy));
3565     else
3566       Bang(killx,killy);
3567   }
3568 }
3569
3570 void TestIfHeroHitsBadThing(int x, int y)
3571 {
3572   TestIfGoodThingHitsBadThing(x,y);
3573 }
3574
3575 void TestIfBadThingHitsHero(int x, int y)
3576 {
3577   /*
3578   TestIfGoodThingHitsBadThing(JX,JY);
3579   */
3580
3581   TestIfBadThingHitsGoodThing(x,y);
3582 }
3583
3584 void TestIfFriendHitsBadThing(int x, int y)
3585 {
3586   TestIfGoodThingHitsBadThing(x,y);
3587 }
3588
3589 void TestIfBadThingHitsFriend(int x, int y)
3590 {
3591   TestIfBadThingHitsGoodThing(x,y);
3592 }
3593
3594 void TestIfBadThingHitsOtherBadThing(int badx, int bady)
3595 {
3596   int i, killx = badx, killy = bady;
3597   static int xy[4][2] =
3598   {
3599     { 0,-1 },
3600     { -1,0 },
3601     { +1,0 },
3602     { 0,+1 }
3603   };
3604
3605   for(i=0; i<4; i++)
3606   {
3607     int x,y, element;
3608
3609     x=badx + xy[i][0];
3610     y=bady + xy[i][1];
3611     if (!IN_LEV_FIELD(x,y))
3612       continue;
3613
3614     element = Feld[x][y];
3615     if (IS_AMOEBOID(element) || element == EL_LIFE ||
3616         element == EL_AMOEBING || element == EL_TROPFEN)
3617     {
3618       killx = x;
3619       killy = y;
3620       break;
3621     }
3622   }
3623
3624   if (killx != badx || killy != bady)
3625     Bang(badx,bady);
3626 }
3627
3628 void KillHero(struct PlayerInfo *player)
3629 {
3630   int jx = player->jx, jy = player->jy;
3631
3632   if (player->gone)
3633     return;
3634
3635   if (IS_PFORTE(Feld[jx][jy]))
3636     Feld[jx][jy] = EL_LEERRAUM;
3637
3638   Bang(jx,jy);
3639   BuryHero(player);
3640 }
3641
3642 void BuryHero(struct PlayerInfo *player)
3643 {
3644   int jx = player->jx, jy = player->jy;
3645
3646   if (player->gone)
3647     return;
3648
3649   PlaySoundLevel(jx,jy, SND_AUTSCH);
3650   PlaySoundLevel(jx,jy, SND_LACHEN);
3651
3652   player->GameOver = TRUE;
3653   RemoveHero(player);
3654 }
3655
3656 void RemoveHero(struct PlayerInfo *player)
3657 {
3658   int jx = player->jx, jy = player->jy;
3659   int i, found = FALSE;
3660
3661   player->gone = TRUE;
3662   StorePlayer[jx][jy] = 0;
3663
3664   for(i=0; i<MAX_PLAYERS; i++)
3665     if (stored_player[i].active && !stored_player[i].gone)
3666       found = TRUE;
3667
3668   if (!found)
3669     AllPlayersGone = TRUE;
3670
3671   ExitX = ZX = jx;
3672   ExitY = ZY = jy;
3673 }
3674
3675 int DigField(struct PlayerInfo *player,
3676              int x, int y, int real_dx, int real_dy, int mode)
3677 {
3678   int jx = player->jx, jy = player->jy;
3679   int dx = x - jx, dy = y - jy;
3680   int element;
3681
3682   if (!player->MovPos)
3683     player->Pushing = FALSE;
3684
3685   if (mode == DF_NO_PUSH)
3686   {
3687     player->push_delay = 0;
3688     return(MF_NO_ACTION);
3689   }
3690
3691   if (IS_MOVING(x,y) || IS_PLAYER(x,y))
3692     return(MF_NO_ACTION);
3693
3694   element = Feld[x][y];
3695
3696   switch(element)
3697   {
3698     case EL_LEERRAUM:
3699       break;
3700
3701     case EL_ERDREICH:
3702       Feld[x][y] = EL_LEERRAUM;
3703       break;
3704
3705     case EL_EDELSTEIN:
3706     case EL_EDELSTEIN_BD:
3707     case EL_EDELSTEIN_GELB:
3708     case EL_EDELSTEIN_ROT:
3709     case EL_EDELSTEIN_LILA:
3710     case EL_DIAMANT:
3711       RemoveField(x,y);
3712       local_player->gems_still_needed -= (element == EL_DIAMANT ? 3 : 1);
3713       if (local_player->gems_still_needed < 0)
3714         local_player->gems_still_needed = 0;
3715       RaiseScoreElement(element);
3716       DrawText(DX_EMERALDS, DY_EMERALDS,
3717                int2str(local_player->gems_still_needed, 3),
3718                FS_SMALL, FC_YELLOW);
3719       PlaySoundLevel(x, y, SND_PONG);
3720       break;
3721
3722     case EL_DYNAMIT_AUS:
3723       RemoveField(x,y);
3724       player->dynamite++;
3725       RaiseScoreElement(EL_DYNAMIT);
3726       DrawText(DX_DYNAMITE, DY_DYNAMITE,
3727                int2str(local_player->dynamite, 3),
3728                FS_SMALL, FC_YELLOW);
3729       PlaySoundLevel(x,y,SND_PONG);
3730       break;
3731
3732     case EL_DYNABOMB_NR:
3733       RemoveField(x,y);
3734       player->dynabomb_count++;
3735       player->dynabombs_left++;
3736       RaiseScoreElement(EL_DYNAMIT);
3737       PlaySoundLevel(x,y,SND_PONG);
3738       break;
3739
3740     case EL_DYNABOMB_SZ:
3741       RemoveField(x,y);
3742       player->dynabomb_size++;
3743       RaiseScoreElement(EL_DYNAMIT);
3744       PlaySoundLevel(x,y,SND_PONG);
3745       break;
3746
3747     case EL_DYNABOMB_XL:
3748       RemoveField(x,y);
3749       player->dynabomb_xl = TRUE;
3750       RaiseScoreElement(EL_DYNAMIT);
3751       PlaySoundLevel(x,y,SND_PONG);
3752       break;
3753
3754     case EL_SCHLUESSEL1:
3755     case EL_SCHLUESSEL2:
3756     case EL_SCHLUESSEL3:
3757     case EL_SCHLUESSEL4:
3758     {
3759       int key_nr = element-EL_SCHLUESSEL1;
3760
3761       RemoveField(x,y);
3762       player->key[key_nr] = TRUE;
3763       RaiseScoreElement(EL_SCHLUESSEL);
3764       DrawMiniGraphicExt(drawto,gc,
3765                          DX_KEYS+key_nr*MINI_TILEX,DY_KEYS,
3766                          GFX_SCHLUESSEL1+key_nr);
3767       DrawMiniGraphicExt(window,gc,
3768                          DX_KEYS+key_nr*MINI_TILEX,DY_KEYS,
3769                          GFX_SCHLUESSEL1+key_nr);
3770       PlaySoundLevel(x,y,SND_PONG);
3771       break;
3772     }
3773
3774     case EL_ABLENK_AUS:
3775       Feld[x][y] = EL_ABLENK_EIN;
3776       ZX = x;
3777       ZY = y;
3778       DrawLevelField(x,y);
3779       return(MF_ACTION);
3780       break;
3781
3782     case EL_FELSBROCKEN:
3783     case EL_BOMBE:
3784     case EL_KOKOSNUSS:
3785     case EL_ZEIT_LEER:
3786       if (dy || mode==DF_SNAP)
3787         return(MF_NO_ACTION);
3788
3789       player->Pushing = TRUE;
3790
3791       if (!IN_LEV_FIELD(x+dx,y+dy) || !IS_FREE(x+dx,y+dy))
3792         return(MF_NO_ACTION);
3793
3794       if (real_dy)
3795       {
3796         if (IN_LEV_FIELD(jx,jy+real_dy) && !IS_SOLID(Feld[jx][jy+real_dy]))
3797           return(MF_NO_ACTION);
3798       }
3799
3800       if (player->push_delay == 0)
3801         player->push_delay = FrameCounter;
3802       if (!FrameReached(&player->push_delay, player->push_delay_value) &&
3803           !tape.playing)
3804         return(MF_NO_ACTION);
3805
3806       RemoveField(x,y);
3807       Feld[x+dx][y+dy] = element;
3808
3809       player->push_delay_value = 2+RND(8);
3810
3811       DrawLevelField(x+dx,y+dy);
3812       if (element==EL_FELSBROCKEN)
3813         PlaySoundLevel(x+dx,y+dy,SND_PUSCH);
3814       else if (element==EL_KOKOSNUSS)
3815         PlaySoundLevel(x+dx,y+dy,SND_KNURK);
3816       else
3817         PlaySoundLevel(x+dx,y+dy,SND_KLOPF);
3818       break;
3819
3820     case EL_PFORTE1:
3821     case EL_PFORTE2:
3822     case EL_PFORTE3:
3823     case EL_PFORTE4:
3824       if (!player->key[element-EL_PFORTE1])
3825         return(MF_NO_ACTION);
3826       break;
3827
3828     case EL_PFORTE1X:
3829     case EL_PFORTE2X:
3830     case EL_PFORTE3X:
3831     case EL_PFORTE4X:
3832       if (!player->key[element-EL_PFORTE1X])
3833         return(MF_NO_ACTION);
3834       break;
3835
3836     case EL_AUSGANG_ZU:
3837     case EL_AUSGANG_ACT:
3838       /* Tür ist (noch) nicht offen! */
3839       return(MF_NO_ACTION);
3840       break;
3841
3842     case EL_AUSGANG_AUF:
3843       if (mode==DF_SNAP)
3844         return(MF_NO_ACTION);
3845
3846       PlaySoundLevel(x,y,SND_BUING);
3847
3848       /*
3849       player->gone = TRUE;
3850       PlaySoundLevel(x,y,SND_BUING);
3851
3852       if (!local_player->friends_still_needed)
3853         player->LevelSolved = player->GameOver = TRUE;
3854       */
3855
3856       break;
3857
3858     case EL_BIRNE_AUS:
3859       Feld[x][y] = EL_BIRNE_EIN;
3860       local_player->lights_still_needed--;
3861       DrawLevelField(x,y);
3862       PlaySoundLevel(x,y,SND_DENG);
3863       return(MF_ACTION);
3864       break;
3865
3866     case EL_ZEIT_VOLL:
3867       Feld[x][y] = EL_ZEIT_LEER;
3868       TimeLeft += 10;
3869       DrawText(DX_TIME,DY_TIME,int2str(TimeLeft,3),FS_SMALL,FC_YELLOW);
3870       DrawLevelField(x,y);
3871       PlaySoundStereo(SND_GONG,PSND_MAX_RIGHT);
3872       return(MF_ACTION);
3873       break;
3874
3875     case EL_SOKOBAN_FELD_LEER:
3876       break;
3877
3878     case EL_SOKOBAN_FELD_VOLL:
3879     case EL_SOKOBAN_OBJEKT:
3880     case EL_SONDE:
3881       if (mode==DF_SNAP)
3882         return(MF_NO_ACTION);
3883
3884       player->Pushing = TRUE;
3885
3886       if (!IN_LEV_FIELD(x+dx,y+dy)
3887           || (!IS_FREE(x+dx,y+dy)
3888               && (Feld[x+dx][y+dy] != EL_SOKOBAN_FELD_LEER
3889                   || !IS_SB_ELEMENT(element))))
3890         return(MF_NO_ACTION);
3891
3892       if (dx && real_dy)
3893       {
3894         if (IN_LEV_FIELD(jx,jy+real_dy) && !IS_SOLID(Feld[jx][jy+real_dy]))
3895           return(MF_NO_ACTION);
3896       }
3897       else if (dy && real_dx)
3898       {
3899         if (IN_LEV_FIELD(jx+real_dx,jy) && !IS_SOLID(Feld[jx+real_dx][jy]))
3900           return(MF_NO_ACTION);
3901       }
3902
3903       if (player->push_delay == 0)
3904         player->push_delay = FrameCounter;
3905       if (!FrameReached(&player->push_delay, player->push_delay_value) &&
3906           !tape.playing)
3907         return(MF_NO_ACTION);
3908
3909       if (IS_SB_ELEMENT(element))
3910       {
3911         if (element == EL_SOKOBAN_FELD_VOLL)
3912         {
3913           Feld[x][y] = EL_SOKOBAN_FELD_LEER;
3914           local_player->sokobanfields_still_needed++;
3915         }
3916         else
3917           RemoveField(x,y);
3918
3919         if (Feld[x+dx][y+dy] == EL_SOKOBAN_FELD_LEER)
3920         {
3921           Feld[x+dx][y+dy] = EL_SOKOBAN_FELD_VOLL;
3922           local_player->sokobanfields_still_needed--;
3923           if (element == EL_SOKOBAN_OBJEKT)
3924             PlaySoundLevel(x,y,SND_DENG);
3925         }
3926         else
3927           Feld[x+dx][y+dy] = EL_SOKOBAN_OBJEKT;
3928       }
3929       else
3930       {
3931         RemoveField(x,y);
3932         Feld[x+dx][y+dy] = element;
3933       }
3934
3935       player->push_delay_value = 2;
3936
3937       DrawLevelField(x,y);
3938       DrawLevelField(x+dx,y+dy);
3939       PlaySoundLevel(x+dx,y+dy,SND_PUSCH);
3940
3941       if (IS_SB_ELEMENT(element) &&
3942           local_player->sokobanfields_still_needed == 0 &&
3943           game_emulation == EMU_SOKOBAN)
3944       {
3945         player->LevelSolved = player->GameOver = TRUE;
3946         PlaySoundLevel(x,y,SND_BUING);
3947       }
3948
3949       break;
3950
3951     case EL_MAULWURF:
3952     case EL_PINGUIN:
3953     case EL_SCHWEIN:
3954     case EL_DRACHE:
3955       break;
3956
3957     default:
3958       return(MF_NO_ACTION);
3959       break;
3960   }
3961
3962   player->push_delay = 0;
3963
3964   return(MF_MOVING);
3965 }
3966
3967 BOOL SnapField(struct PlayerInfo *player, int dx, int dy)
3968 {
3969   int jx = player->jx, jy = player->jy;
3970   int x = jx + dx, y = jy + dy;
3971
3972   if (player->gone || !IN_LEV_FIELD(x,y))
3973     return(FALSE);
3974
3975   if (dx && dy)
3976     return(FALSE);
3977
3978   if (!dx && !dy)
3979   {
3980     player->snapped = FALSE;
3981     return(FALSE);
3982   }
3983
3984   if (player->snapped)
3985     return(FALSE);
3986
3987   player->MovDir = (dx < 0 ? MV_LEFT :
3988                     dx > 0 ? MV_RIGHT :
3989                     dy < 0 ? MV_UP :
3990                     dy > 0 ? MV_DOWN :  MV_NO_MOVING);
3991
3992   if (!DigField(player, x,y, 0,0, DF_SNAP))
3993     return(FALSE);
3994
3995   player->snapped = TRUE;
3996   DrawLevelField(x,y);
3997   BackToFront();
3998
3999   return(TRUE);
4000 }
4001
4002 BOOL PlaceBomb(struct PlayerInfo *player)
4003 {
4004   int jx = player->jx, jy = player->jy;
4005   int element;
4006
4007   if (player->gone || player->MovPos)
4008     return(FALSE);
4009
4010   element = Feld[jx][jy];
4011
4012   if ((player->dynamite==0 && player->dynabombs_left==0) ||
4013       element==EL_DYNAMIT || element==EL_DYNABOMB || element==EL_EXPLODING)
4014     return(FALSE);
4015
4016   if (element != EL_LEERRAUM)
4017     Store[jx][jy] = element;
4018
4019   if (player->dynamite)
4020   {
4021     Feld[jx][jy] = EL_DYNAMIT;
4022     MovDelay[jx][jy] = 96;
4023     player->dynamite--;
4024     DrawText(DX_DYNAMITE, DY_DYNAMITE, int2str(local_player->dynamite, 3),
4025              FS_SMALL, FC_YELLOW);
4026     if (IN_SCR_FIELD(SCREENX(jx),SCREENY(jy)))
4027       DrawGraphicThruMask(SCREENX(jx),SCREENY(jy),GFX_DYNAMIT);
4028   }
4029   else
4030   {
4031     Feld[jx][jy] = EL_DYNABOMB;
4032     Store2[jx][jy] = player->element_nr;        /* for DynaExplode() */
4033     MovDelay[jx][jy] = 96;
4034     player->dynabombs_left--;
4035     if (IN_SCR_FIELD(SCREENX(jx),SCREENY(jy)))
4036       DrawGraphicThruMask(SCREENX(jx),SCREENY(jy),GFX_DYNABOMB);
4037   }
4038
4039   return(TRUE);
4040 }
4041
4042 void PlaySoundLevel(int x, int y, int sound_nr)
4043 {
4044   int sx = SCREENX(x), sy = SCREENY(y);
4045   int volume, stereo;
4046   int silence_distance = 8;
4047
4048   if ((!sound_simple_on && !IS_LOOP_SOUND(sound_nr)) ||
4049       (!sound_loops_on && IS_LOOP_SOUND(sound_nr)))
4050     return;
4051
4052   if (!IN_LEV_FIELD(x,y) ||
4053       sx < -silence_distance || sx >= SCR_FIELDX+silence_distance ||
4054       sy < -silence_distance || sy >= SCR_FIELDY+silence_distance)
4055     return;
4056
4057   volume = PSND_MAX_VOLUME;
4058 #ifndef MSDOS
4059   stereo = (sx-SCR_FIELDX/2)*12;
4060 #else
4061   stereo = PSND_MIDDLE+(2*sx-(SCR_FIELDX-1))*5;
4062   if(stereo > PSND_MAX_RIGHT) stereo = PSND_MAX_RIGHT;
4063   if(stereo < PSND_MAX_LEFT) stereo = PSND_MAX_LEFT;
4064 #endif
4065
4066   if (!IN_SCR_FIELD(sx,sy))
4067   {
4068     int dx = ABS(sx-SCR_FIELDX/2)-SCR_FIELDX/2;
4069     int dy = ABS(sy-SCR_FIELDY/2)-SCR_FIELDY/2;
4070
4071     volume -= volume*(dx > dy ? dx : dy)/silence_distance;
4072   }
4073
4074   PlaySoundExt(sound_nr, volume, stereo, PSND_NO_LOOP);
4075 }
4076
4077 void RaiseScore(int value)
4078 {
4079   local_player->score += value;
4080   DrawText(DX_SCORE, DY_SCORE, int2str(local_player->score, 5),
4081            FS_SMALL, FC_YELLOW);
4082 }
4083
4084 void RaiseScoreElement(int element)
4085 {
4086   switch(element)
4087   {
4088     case EL_EDELSTEIN:
4089     case EL_EDELSTEIN_BD:
4090     case EL_EDELSTEIN_GELB:
4091     case EL_EDELSTEIN_ROT:
4092     case EL_EDELSTEIN_LILA:
4093       RaiseScore(level.score[SC_EDELSTEIN]);
4094       break;
4095     case EL_DIAMANT:
4096       RaiseScore(level.score[SC_DIAMANT]);
4097       break;
4098     case EL_KAEFER:
4099     case EL_BUTTERFLY:
4100       RaiseScore(level.score[SC_KAEFER]);
4101       break;
4102     case EL_FLIEGER:
4103     case EL_FIREFLY:
4104       RaiseScore(level.score[SC_FLIEGER]);
4105       break;
4106     case EL_MAMPFER:
4107     case EL_MAMPFER2:
4108       RaiseScore(level.score[SC_MAMPFER]);
4109       break;
4110     case EL_ROBOT:
4111       RaiseScore(level.score[SC_ROBOT]);
4112       break;
4113     case EL_PACMAN:
4114       RaiseScore(level.score[SC_PACMAN]);
4115       break;
4116     case EL_KOKOSNUSS:
4117       RaiseScore(level.score[SC_KOKOSNUSS]);
4118       break;
4119     case EL_DYNAMIT:
4120       RaiseScore(level.score[SC_DYNAMIT]);
4121       break;
4122     case EL_SCHLUESSEL:
4123       RaiseScore(level.score[SC_SCHLUESSEL]);
4124       break;
4125     default:
4126       break;
4127   }
4128 }