+ if (element == EL_MAUER_LEBT && (links_frei || rechts_frei))
+ DrawLevelField(ax,ay);
+
+ if (!IN_LEV_FIELD(ax,ay-1) || IS_MAUER(Feld[ax][ay-1]))
+ oben_massiv = TRUE;
+ if (!IN_LEV_FIELD(ax,ay+1) || IS_MAUER(Feld[ax][ay+1]))
+ unten_massiv = TRUE;
+ if (!IN_LEV_FIELD(ax-1,ay) || IS_MAUER(Feld[ax-1][ay]))
+ links_massiv = TRUE;
+ if (!IN_LEV_FIELD(ax+1,ay) || IS_MAUER(Feld[ax+1][ay]))
+ rechts_massiv = TRUE;
+
+ if (((oben_massiv && unten_massiv) ||
+ element == EL_MAUER_X || element == EL_MAUER_LEBT) &&
+ ((links_massiv && rechts_massiv) ||
+ element == EL_MAUER_Y))
+ Feld[ax][ay] = EL_MAUERWERK;
+}
+
+void CheckForDragon(int x, int y)
+{
+ int i,j;
+ BOOL dragon_found = FALSE;
+ static int xy[4][2] =
+ {
+ { 0,-1 },
+ { -1,0 },
+ { +1,0 },
+ { 0,+1 }
+ };
+
+ for(i=0;i<4;i++)
+ {
+ for(j=0;j<4;j++)
+ {
+ int xx = x + j*xy[i][0], yy = y + j*xy[i][1];
+
+ if (IN_LEV_FIELD(xx,yy) &&
+ (Feld[xx][yy] == EL_BURNING || Feld[xx][yy] == EL_DRACHE))
+ {
+ if (Feld[xx][yy] == EL_DRACHE)
+ dragon_found = TRUE;
+ }
+ else
+ break;
+ }
+ }
+
+ if (!dragon_found)
+ {
+ for(i=0;i<4;i++)
+ {
+ for(j=0;j<3;j++)
+ {
+ int xx = x + j*xy[i][0], yy = y + j*xy[i][1];
+
+ if (IN_LEV_FIELD(xx,yy) && Feld[xx][yy] == EL_BURNING)
+ {
+ Feld[xx][yy] = EL_LEERRAUM;
+ DrawLevelField(xx,yy);
+ }
+ else
+ break;
+ }
+ }
+ }
+}
+
+void PlayerActions(struct PlayerInfo *player, byte player_action)
+{
+ static byte stored_player_action[MAX_PLAYERS];
+ static int num_stored_actions = 0;
+ BOOL moved = FALSE, snapped = FALSE, bombed = FALSE;
+ int jx = player->jx, jy = player->jy;
+ int left = player_action & JOY_LEFT;
+ int right = player_action & JOY_RIGHT;
+ int up = player_action & JOY_UP;
+ int down = player_action & JOY_DOWN;
+ int button1 = player_action & JOY_BUTTON_1;
+ int button2 = player_action & JOY_BUTTON_2;
+ int dx = (left ? -1 : right ? 1 : 0);
+ int dy = (up ? -1 : down ? 1 : 0);
+
+ stored_player_action[player->index_nr] = 0;
+ num_stored_actions++;
+
+ if (!player->active || player->gone)
+ return;
+
+ if (player_action)
+ {
+ player->frame_reset_delay = 0;
+
+ if (button1)
+ snapped = SnapField(player, dx,dy);
+ else
+ {
+ if (button2)
+ bombed = PlaceBomb(player);
+ moved = MoveFigure(player, dx,dy);
+ }
+
+ if (tape.recording && (moved || snapped || bombed))
+ {
+ if (bombed && !moved)
+ player_action &= JOY_BUTTON;
+
+ stored_player_action[player->index_nr] = player_action;
+
+ /* this allows cycled sequences of PlayerActions() */
+ if (num_stored_actions >= MAX_PLAYERS)
+ {
+ TapeRecordAction(stored_player_action);
+ num_stored_actions = 0;
+ }
+ }
+ else if (tape.playing && snapped)
+ SnapField(player, 0,0); /* stop snapping */
+ }
+ else
+ {
+ DigField(player, 0,0, 0,0, DF_NO_PUSH);
+ SnapField(player, 0,0);
+ if (++player->frame_reset_delay > MoveSpeed)
+ player->Frame = 0;
+ }
+
+ if (tape.playing && !tape.pausing && !player_action &&
+ tape.counter < tape.length)
+ {
+ int next_joy =
+ tape.pos[tape.counter].action[player->index_nr] & (JOY_LEFT|JOY_RIGHT);
+
+ if (next_joy == JOY_LEFT || next_joy == JOY_RIGHT)
+ {
+ int dx = (next_joy == JOY_LEFT ? -1 : +1);
+
+ if (IN_LEV_FIELD(jx+dx,jy) && IS_PUSHABLE(Feld[jx+dx][jy]))
+ {
+ int el = Feld[jx+dx][jy];
+ int push_delay = (IS_SB_ELEMENT(el) || el==EL_SONDE ? 2 : 10);
+
+ if (tape.delay_played + push_delay >= tape.pos[tape.counter].delay)
+ {
+ player->MovDir = next_joy;
+ player->Frame = FrameCounter % 4;
+ player->Pushing = TRUE;
+ }
+ }
+ }
+ }
+}
+
+void GameActions(byte player_action)
+{
+ static long action_delay = 0;
+ long action_delay_value;
+ int sieb_x = 0, sieb_y = 0;
+ int i, x,y, element;
+ int *recorded_player_action;
+
+
+ if (game_status != PLAYING)
+ return;
+
+
+#ifdef DEBUG
+ action_delay_value =
+ (tape.playing && tape.fast_forward ? FFWD_FRAME_DELAY : GameFrameDelay);
+#else
+ action_delay_value =
+ (tape.playing && tape.fast_forward ? FFWD_FRAME_DELAY : GAME_FRAME_DELAY);
+#endif
+
+ /*
+ HandleNetworking();
+
+ if (game_status != PLAYING)
+ return;
+ */
+
+ /* main game synchronization point */
+ WaitUntilDelayReached(&action_delay, action_delay_value);
+
+ if (!network_player_action_stored)
+ {
+#ifdef DEBUG
+ printf("DEBUG: try to get network player actions in time\n");
+#endif
+
+ /* last chance to get network player actions without main loop delay */
+ HandleNetworking();
+
+ if (game_status != PLAYING)
+ return;
+
+ if (!network_player_action_stored)
+ {
+#ifdef DEBUG
+ printf("DEBUG: failed to get network player actions in time\n");
+#endif
+ return;
+ }
+ }
+
+ if (tape.playing)
+ recorded_player_action = TapePlayAction();
+ else
+ recorded_player_action = NULL;
+
+
+ SendToServer_MovePlayer(player_action, FrameCounter);
+
+
+ for(i=0; i<MAX_PLAYERS; i++)
+ {
+ int actual_player_action = network_player_action[i];
+
+ /*
+ int actual_player_action = player_action;
+ */
+
+ /* TEST TEST TEST */
+
+ /*
+ if (i != TestPlayer && !stored_player[i].MovPos)
+ actual_player_action = 0;
+ */
+
+ /* TEST TEST TEST */
+
+ if (recorded_player_action)
+ actual_player_action = recorded_player_action[i];
+
+ PlayerActions(&stored_player[i], actual_player_action);
+ ScrollFigure(&stored_player[i], SCROLL_GO_ON);
+
+ network_player_action[i] = 0;
+ }
+
+ network_player_action_stored = FALSE;
+
+ ScrollScreen(NULL, SCROLL_GO_ON);
+
+ if (tape.pausing || (tape.playing && !TapePlayDelay()))
+ return;
+ else if (tape.recording)
+ TapeRecordDelay();
+
+ FrameCounter++;
+ TimeFrames++;
+
+ /*
+ printf("advancing FrameCounter to %d\n",
+ FrameCounter);
+ */
+
+ for(y=0;y<lev_fieldy;y++) for(x=0;x<lev_fieldx;x++)
+ {
+ Stop[x][y] = FALSE;
+ if (JustHit[x][y]>0)
+ JustHit[x][y]--;
+
+#if DEBUG
+ if (IS_BLOCKED(x,y))
+ {
+ int oldx,oldy;
+
+ Blocked2Moving(x,y,&oldx,&oldy);
+ if (!IS_MOVING(oldx,oldy))
+ {
+ printf("GameActions(): (BLOCKED=>MOVING) context corrupted!\n");
+ printf("GameActions(): BLOCKED: x = %d, y = %d\n",x,y);
+ printf("GameActions(): !MOVING: oldx = %d, oldy = %d\n",oldx,oldy);
+ printf("GameActions(): This should never happen!\n");
+ }
+ }
+#endif
+ }
+
+ for(y=0;y<lev_fieldy;y++) for(x=0;x<lev_fieldx;x++)
+ {
+ element = Feld[x][y];
+
+ if (IS_INACTIVE(element))
+ continue;
+
+ if (!IS_MOVING(x,y) && (CAN_FALL(element) || CAN_MOVE(element)))
+ {
+ StartMoving(x,y);
+
+ if (IS_GEM(element))
+ EdelsteinFunkeln(x,y);
+ }
+ else if (IS_MOVING(x,y))
+ ContinueMoving(x,y);
+ else if (element==EL_DYNAMIT || element==EL_DYNABOMB)
+ CheckDynamite(x,y);
+ else if (element==EL_EXPLODING)
+ Explode(x,y,Frame[x][y],EX_NORMAL);
+ else if (element==EL_AMOEBING)
+ AmoebeWaechst(x,y);
+ else if (IS_AMOEBALIVE(element))
+ AmoebeAbleger(x,y);
+ else if (element==EL_LIFE || element==EL_LIFE_ASYNC)
+ Life(x,y);
+ else if (element==EL_ABLENK_EIN)
+ Ablenk(x,y);
+ else if (element==EL_SALZSAEURE)
+ Blubber(x,y);
+ else if (element==EL_BLURB_LEFT || element==EL_BLURB_RIGHT)
+ Blurb(x,y);
+ else if (element==EL_CRACKINGNUT)
+ NussKnacken(x,y);
+ else if (element==EL_AUSGANG_ZU)
+ AusgangstuerPruefen(x,y);
+ else if (element==EL_AUSGANG_ACT)
+ AusgangstuerOeffnen(x,y);
+ else if (element==EL_AUSGANG_AUF)
+ AusgangstuerBlinken(x,y);
+ else if (element==EL_MAUERND)
+ MauerWaechst(x,y);
+ else if (element==EL_MAUER_LEBT ||
+ element==EL_MAUER_X ||
+ element==EL_MAUER_Y ||
+ element==EL_MAUER_XY)
+ MauerAbleger(x,y);
+ else if (element==EL_BURNING)
+ CheckForDragon(x,y);
+
+ if (SiebAktiv)
+ {
+ BOOL sieb = FALSE;
+ int jx = local_player->jx, jy = local_player->jy;
+
+ if (element==EL_SIEB_LEER || element==EL_SIEB_VOLL ||
+ Store[x][y]==EL_SIEB_LEER)
+ {
+ SiebAktivieren(x, y, 1);
+ sieb = TRUE;
+ }
+ else if (element==EL_SIEB2_LEER || element==EL_SIEB2_VOLL ||
+ Store[x][y]==EL_SIEB2_LEER)
+ {
+ SiebAktivieren(x, y, 2);
+ sieb = TRUE;
+ }
+
+ /* play the element sound at the position nearest to the player */
+ if (sieb && ABS(x-jx)+ABS(y-jy) < ABS(sieb_x-jx)+ABS(sieb_y-jy))
+ {
+ sieb_x = x;
+ sieb_y = y;
+ }
+ }
+ }
+
+ if (SiebAktiv)
+ {
+ if (!(SiebAktiv%4))
+ PlaySoundLevel(sieb_x,sieb_y,SND_MIEP);
+ SiebAktiv--;
+ if (!SiebAktiv)
+ {
+ for(y=0;y<lev_fieldy;y++) for(x=0;x<lev_fieldx;x++)
+ {
+ element = Feld[x][y];
+ if (element==EL_SIEB_LEER || element==EL_SIEB_VOLL)
+ {
+ Feld[x][y] = EL_SIEB_TOT;
+ DrawLevelField(x,y);
+ }
+ else if (element==EL_SIEB2_LEER || element==EL_SIEB2_VOLL)
+ {
+ Feld[x][y] = EL_SIEB2_TOT;
+ DrawLevelField(x,y);
+ }
+ }
+ }
+ }
+
+ if (TimeLeft>0 && TimeFrames>=(1000/GameFrameDelay) && !tape.pausing)
+ {
+ TimeFrames = 0;
+ TimeLeft--;
+
+ if (tape.recording || tape.playing)
+ DrawVideoDisplay(VIDEO_STATE_TIME_ON,level.time-TimeLeft);
+
+ if (TimeLeft<=10)
+ PlaySoundStereo(SND_GONG,PSND_MAX_RIGHT);
+
+ DrawText(DX_TIME,DY_TIME,int2str(TimeLeft,3),FS_SMALL,FC_YELLOW);
+
+ if (!TimeLeft)
+ for(i=0; i<MAX_PLAYERS; i++)
+ KillHero(&stored_player[i]);
+ }
+
+ DrawAllPlayers();
+}
+
+static BOOL AllPlayersInSight(struct PlayerInfo *player, int x, int y)
+{
+ int min_x = x, min_y = y, max_x = x, max_y = y;
+ int i;
+
+ for(i=0; i<MAX_PLAYERS; i++)
+ {
+ int jx = stored_player[i].jx, jy = stored_player[i].jy;
+
+ if (!stored_player[i].active || stored_player[i].gone ||
+ &stored_player[i] == player)
+ continue;
+
+ min_x = MIN(min_x, jx);
+ min_y = MIN(min_y, jy);
+ max_x = MAX(max_x, jx);
+ max_y = MAX(max_y, jy);
+ }
+
+ return(max_x - min_x < SCR_FIELDX && max_y - min_y < SCR_FIELDY);
+}
+
+static BOOL AllPlayersInVisibleScreen()
+{
+ int i;
+
+ for(i=0; i<MAX_PLAYERS; i++)
+ {
+ int jx = stored_player[i].jx, jy = stored_player[i].jy;
+
+ if (!stored_player[i].active || stored_player[i].gone)
+ continue;
+
+ if (!IN_VIS_FIELD(SCREENX(jx), SCREENY(jy)))
+ return(FALSE);
+ }
+
+ return(TRUE);
+}
+
+void ScrollLevel(int dx, int dy)
+{
+ int softscroll_offset = (soft_scrolling_on ? TILEX : 0);
+ int x,y;
+
+ /*
+ ScreenGfxPos = local_player->GfxPos;
+ */
+
+ XCopyArea(display,drawto_field,drawto_field,gc,
+ FX + TILEX*(dx==-1) - softscroll_offset,
+ FY + TILEY*(dy==-1) - softscroll_offset,
+ SXSIZE - TILEX*(dx!=0) + 2*softscroll_offset,
+ SYSIZE - TILEY*(dy!=0) + 2*softscroll_offset,
+ FX + TILEX*(dx==1) - softscroll_offset,
+ FY + TILEY*(dy==1) - softscroll_offset);
+
+ if (dx)
+ {
+ x = (dx==1 ? BX1 : BX2);
+ for(y=BY1; y<=BY2; y++)
+ DrawScreenField(x,y);
+ }
+ if (dy)
+ {
+ y = (dy==1 ? BY1 : BY2);
+ for(x=BX1; x<=BX2; x++)
+ DrawScreenField(x,y);
+ }
+
+ redraw_mask |= REDRAW_FIELD;
+}
+
+BOOL MoveFigureOneStep(struct PlayerInfo *player,
+ int dx, int dy, int real_dx, int real_dy)
+{
+ int jx = player->jx, jy = player->jy;
+ int new_jx = jx+dx, new_jy = jy+dy;
+ int element;
+ int can_move;
+
+ if (player->gone || (!dx && !dy))
+ return(MF_NO_ACTION);
+
+ player->MovDir = (dx < 0 ? MV_LEFT :
+ dx > 0 ? MV_RIGHT :
+ dy < 0 ? MV_UP :
+ dy > 0 ? MV_DOWN : MV_NO_MOVING);
+
+ if (!IN_LEV_FIELD(new_jx,new_jy))