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