(s)==SND_TYGER || (s)==SND_VOYAGER || \
(s)==SND_TWILIGHT)
-/* score for elements */
-#define SC_EDELSTEIN 0
-#define SC_DIAMANT 1
-#define SC_KAEFER 2
-#define SC_FLIEGER 3
-#define SC_MAMPFER 4
-#define SC_ROBOT 5
-#define SC_PACMAN 6
-#define SC_KOKOSNUSS 7
-#define SC_DYNAMIT 8
-#define SC_SCHLUESSEL 9
-#define SC_ZEITBONUS 10
+/* values for player movement speed (which is in fact a delay value) */
+#define MOVE_DELAY_NORMAL_SPEED 8
+#define MOVE_DELAY_HIGH_SPEED 4
+
+#define DOUBLE_MOVE_DELAY(x) (x = (x <= MOVE_DELAY_HIGH_SPEED ? x * 2 : x))
+#define HALVE_MOVE_DELAY(x) (x = (x >= MOVE_DELAY_HIGH_SPEED ? x / 2 : x))
+#define DOUBLE_PLAYER_SPEED(p) (HALVE_MOVE_DELAY((p)->move_delay_value))
+#define HALVE_PLAYER_SPEED(p) (DOUBLE_MOVE_DELAY((p)->move_delay_value))
/* game button identifiers */
#define GAME_CTRL_ID_STOP 0
#define NUM_GAME_BUTTONS 6
/* forward declaration for internal use */
+static void CheckGravityMovement(struct PlayerInfo *);
+
static void MapGameButtons();
static void HandleGameButtons(struct GadgetInfo *);
player->present = TRUE;
- /*
- if (!network_playing || player->connected)
- */
-
if (!options.network || player->connected)
{
player->active = TRUE;
+ player->gone = FALSE;
/* remove potentially duplicate players */
if (StorePlayer[jx][jy] == Feld[x][y])
Feld[x][y] = EL_LEERRAUM;
break;
+ case EL_EM_KEY_1_FILE:
+ Feld[x][y] = EL_EM_KEY_1;
+ break;
+ case EL_EM_KEY_2_FILE:
+ Feld[x][y] = EL_EM_KEY_2;
+ break;
+ case EL_EM_KEY_3_FILE:
+ Feld[x][y] = EL_EM_KEY_3;
+ break;
+ case EL_EM_KEY_4_FILE:
+ Feld[x][y] = EL_EM_KEY_4;
+ break;
+
default:
break;
}
player->move_delay = 0;
player->last_move_dir = MV_NO_MOVING;
+ player->move_delay_value =
+ (level.double_speed ? MOVE_DELAY_HIGH_SPEED : MOVE_DELAY_NORMAL_SPEED);
+
player->snapped = FALSE;
- player->gone = FALSE;
+ player->gone = TRUE;
player->last_jx = player->last_jy = 0;
player->jx = player->jy = 0;
ScreenMovPos = 0;
ScreenGfxPos = 0;
- MoveSpeed = (level.double_speed ? 4 : 8);
- ScrollStepSize = TILEX / MoveSpeed;
+ ScrollStepSize = 0; /* will be correctly initialized by ScrollScreen() */
AllPlayersGone = FALSE;
SiebAktiv = FALSE;
{
player->present = TRUE;
player->active = TRUE;
+ player->gone = FALSE;
some_player->present = FALSE;
StorePlayer[jx][jy] = player->element_nr;
int jx = player->jx, jy = player->jy;
player->active = FALSE;
+ player->gone = TRUE;
StorePlayer[jx][jy] = 0;
Feld[jx][jy] = EL_LEERRAUM;
}
int jx = player->jx, jy = player->jy;
player->active = FALSE;
+ player->gone = TRUE;
StorePlayer[jx][jy] = 0;
Feld[jx][jy] = EL_LEERRAUM;
}
DrawAllPlayers();
FadeToFront();
- XCopyArea(display, pix[PIX_DOOR], pix[PIX_DB_DOOR], gc,
- DOOR_GFX_PAGEX5, DOOR_GFX_PAGEY1, DXSIZE, DYSIZE,
- DOOR_GFX_PAGEX1, DOOR_GFX_PAGEY1);
- DrawTextExt(pix[PIX_DB_DOOR], gc,
- DOOR_GFX_PAGEX1 + XX_LEVEL, DOOR_GFX_PAGEY1 + YY_LEVEL,
- int2str(level_nr, 2), FS_SMALL, FC_YELLOW);
- DrawTextExt(pix[PIX_DB_DOOR], gc,
- DOOR_GFX_PAGEX1 + XX_EMERALDS, DOOR_GFX_PAGEY1 + YY_EMERALDS,
- int2str(local_player->gems_still_needed,3), FS_SMALL, FC_YELLOW);
- DrawTextExt(pix[PIX_DB_DOOR], gc,
- DOOR_GFX_PAGEX1 + XX_DYNAMITE, DOOR_GFX_PAGEY1 + YY_DYNAMITE,
- int2str(local_player->dynamite, 3), FS_SMALL, FC_YELLOW);
- DrawTextExt(pix[PIX_DB_DOOR], gc,
- DOOR_GFX_PAGEX1 + XX_SCORE, DOOR_GFX_PAGEY1 + YY_SCORE,
- int2str(local_player->score, 5), FS_SMALL, FC_YELLOW);
- DrawTextExt(pix[PIX_DB_DOOR], gc,
- DOOR_GFX_PAGEX1 + XX_TIME, DOOR_GFX_PAGEY1 + YY_TIME,
- int2str(TimeLeft, 3), FS_SMALL, FC_YELLOW);
-
+ /* copy default game door content to main double buffer */
+ XCopyArea(display, pix[PIX_DOOR], drawto, gc,
+ DOOR_GFX_PAGEX5, DOOR_GFX_PAGEY1, DXSIZE, DYSIZE, DX, DY);
+
+ DrawText(DX + XX_LEVEL, DY + YY_LEVEL,
+ int2str(level_nr, 2), FS_SMALL, FC_YELLOW);
+ DrawText(DX + XX_EMERALDS, DY + YY_EMERALDS,
+ int2str(local_player->gems_still_needed,3), FS_SMALL, FC_YELLOW);
+ DrawText(DX + XX_DYNAMITE, DY + YY_DYNAMITE,
+ int2str(local_player->dynamite, 3), FS_SMALL, FC_YELLOW);
+ DrawText(DX + XX_SCORE, DY + YY_SCORE,
+ int2str(local_player->score, 5), FS_SMALL, FC_YELLOW);
+ DrawText(DX + XX_TIME, DY + YY_TIME,
+ int2str(TimeLeft, 3), FS_SMALL, FC_YELLOW);
-
-#if 0
- DrawGameButton(BUTTON_GAME_STOP);
- DrawGameButton(BUTTON_GAME_PAUSE);
- DrawGameButton(BUTTON_GAME_PLAY);
- DrawSoundDisplay(BUTTON_SOUND_MUSIC | (setup.sound_music ? BUTTON_ON : 0));
- DrawSoundDisplay(BUTTON_SOUND_LOOPS | (setup.sound_loops ? BUTTON_ON : 0));
- DrawSoundDisplay(BUTTON_SOUND_SIMPLE | (setup.sound_simple ? BUTTON_ON : 0));
-#else
UnmapGameButtons();
game_gadget[SOUND_CTRL_ID_MUSIC]->checked = setup.sound_music;
game_gadget[SOUND_CTRL_ID_LOOPS]->checked = setup.sound_loops;
game_gadget[SOUND_CTRL_ID_SIMPLE]->checked = setup.sound_simple;
MapGameButtons();
MapTapeButtons();
-#endif
+ /* copy actual game door content to door double buffer for OpenDoor() */
XCopyArea(display, drawto, pix[PIX_DB_DOOR], gc,
- DX + GAME_CONTROL_XPOS, DY + GAME_CONTROL_YPOS,
- GAME_CONTROL_XSIZE, 2 * GAME_CONTROL_YSIZE,
- DOOR_GFX_PAGEX1 + GAME_CONTROL_XPOS,
- DOOR_GFX_PAGEY1 + GAME_CONTROL_YPOS);
-
-
+ DX, DY, DXSIZE, DYSIZE, DOOR_GFX_PAGEX1, DOOR_GFX_PAGEY1);
OpenDoor(DOOR_OPEN_ALL);
if (options.verbose)
{
for (i=0; i<4; i++)
- printf("Spieler %d %saktiv.\n",
- i+1, (stored_player[i].active ? "" : "nicht "));
+ printf("Player %d %sactive.\n",
+ i + 1, (stored_player[i].active ? "" : "not "));
}
}
return element;
}
+static int MovingOrBlocked2ElementIfNotLeaving(int x, int y)
+{
+ /* like MovingOrBlocked2Element(), but if element is moving
+ and (x,y) is the field the moving element is just leaving,
+ return EL_BLOCKED instead of the element value */
+ int element = Feld[x][y];
+
+ if (IS_MOVING(x, y))
+ {
+ if (element == EL_BLOCKED)
+ {
+ int oldx, oldy;
+
+ Blocked2Moving(x, y, &oldx, &oldy);
+ return Feld[oldx][oldy];
+ }
+ else
+ return EL_BLOCKED;
+ }
+ else
+ return element;
+}
+
static void RemoveField(int x, int y)
{
Feld[x][y] = EL_LEERRAUM;
case EL_SCHLUESSEL2:
case EL_SCHLUESSEL3:
case EL_SCHLUESSEL4:
+ case EL_EM_KEY_1:
+ case EL_EM_KEY_2:
+ case EL_EM_KEY_3:
+ case EL_EM_KEY_4:
sound = SND_KINK;
break;
case EL_ZEIT_VOLL:
player_action &= JOY_BUTTON;
stored_player_action[player->index_nr] = player_action;
-
-#if 0
- /* this allows cycled sequences of PlayerActions() */
- if (num_stored_actions >= MAX_PLAYERS)
- {
- TapeRecordAction(stored_player_action);
- num_stored_actions = 0;
- }
-#endif
-
}
else if (tape.playing && snapped)
SnapField(player, 0, 0); /* stop snapping */
}
else
{
+ /* no actions for this player (no input at player's configured device) */
+
DigField(player, 0, 0, 0, 0, DF_NO_PUSH);
SnapField(player, 0, 0);
- if (++player->frame_reset_delay > MoveSpeed)
+ CheckGravityMovement(player);
+
+ if (++player->frame_reset_delay > player->move_delay_value)
player->Frame = 0;
}
action_delay_value =
(tape.playing && tape.fast_forward ? FfwdFrameDelay : GameFrameDelay);
- /*
- if (tape.playing && tape.fast_forward)
- {
- char buf[100];
-
- sprintf(buf, "FFWD: %ld ms", action_delay_value);
- print_debug(buf);
- }
- */
-
-
- /* main game synchronization point */
+ /* ---------- main game synchronization point ---------- */
-
-
-
-#if 1
WaitUntilDelayReached(&action_delay, action_delay_value);
-#else
-
- while (!DelayReached(&action_delay, action_delay_value))
- {
- char buf[100];
-
- sprintf(buf, "%ld %ld %ld",
- Counter(), action_delay, action_delay_value);
- print_debug(buf);
- }
- print_debug("done");
-
-#endif
-
-
-
if (network_playing && !network_player_action_received)
{
}
}
-
- /*
- if (tape.pausing || (tape.playing && !TapePlayDelay()))
- return;
- else if (tape.recording)
- TapeRecordDelay();
- */
-
if (tape.pausing)
return;
int actual_player_action = stored_player[i].effective_action;
if (stored_player[i].programmed_action)
- {
- /* this is very bad and need to be fixed!!! */
- unsigned long move_delay = stored_player[i].move_delay;
-
- if (FrameReached(&move_delay, MoveSpeed))
- {
- actual_player_action = stored_player[i].programmed_action;
- stored_player[i].programmed_action = 0;
- }
- }
+ actual_player_action = stored_player[i].programmed_action;
if (recorded_player_action)
actual_player_action = recorded_player_action[i];
ScrollScreen(NULL, SCROLL_GO_ON);
- /*
- if (tape.pausing || (tape.playing && !TapePlayDelay()))
- return;
- else if (tape.recording)
- TapeRecordDelay();
- */
-
-
-
-
#ifdef DEBUG
- /*
+#if 0
if (TimeFrames == 0 && !local_player->gone)
{
extern unsigned int last_RND();
printf("DEBUG: %03d last RND was %d \t [state checksum is %d]\n",
- TimePlayed,
- last_RND(),
- getStateCheckSum(TimePlayed));
+ TimePlayed, last_RND(), getStateCheckSum(TimePlayed));
}
- */
#endif
-
-
+#endif
#ifdef DEBUG
- /*
+#if 0
if (GameFrameDelay >= 500)
printf("FrameCounter == %d\n", FrameCounter);
- */
#endif
-
-
+#endif
Blocked2Moving(x, y, &oldx, &oldy);
if (!IS_MOVING(oldx, oldy))
{
- printf("GameActions(): (BLOCKED=>MOVING) context corrupted!\n");
+ 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");
redraw_mask |= REDRAW_FIELD;
}
+static void CheckGravityMovement(struct PlayerInfo *player)
+{
+ if (level.gravity && !player->programmed_action)
+ {
+ int move_dir_vertical = player->action & (MV_UP | MV_DOWN);
+ int move_dir_horizontal = player->action & (MV_LEFT | MV_RIGHT);
+ int move_dir =
+ (player->last_move_dir & (MV_LEFT | MV_RIGHT) ?
+ (move_dir_vertical ? move_dir_vertical : move_dir_horizontal) :
+ (move_dir_horizontal ? move_dir_horizontal : move_dir_vertical));
+ int jx = player->jx, jy = player->jy;
+ int dx = (move_dir & MV_LEFT ? -1 : move_dir & MV_RIGHT ? +1 : 0);
+ int dy = (move_dir & MV_UP ? -1 : move_dir & MV_DOWN ? +1 : 0);
+ int new_jx = jx + dx, new_jy = jy + dy;
+ boolean field_under_player_is_free =
+ (IN_LEV_FIELD(jx, jy + 1) && IS_FREE(jx, jy + 1));
+ boolean player_is_moving_to_valid_field =
+ (IN_LEV_FIELD(new_jx, new_jy) &&
+ (Feld[new_jx][new_jy] == EL_SP_BASE ||
+ Feld[new_jx][new_jy] == EL_ERDREICH));
+
+ if (field_under_player_is_free && !player_is_moving_to_valid_field)
+ player->programmed_action = MV_DOWN;
+ }
+}
+
boolean MoveFigureOneStep(struct PlayerInfo *player,
int dx, int dy, int real_dx, int real_dy)
{
if (!options.network && !AllPlayersInSight(player, new_jx, new_jy))
return MF_NO_ACTION;
+#if 0
element = MovingOrBlocked2Element(new_jx, new_jy);
+#else
+ element = MovingOrBlocked2ElementIfNotLeaving(new_jx, new_jy);
+#endif
if (DONT_GO_TO(element))
{
jy = player->jy = new_jy;
StorePlayer[jx][jy] = player->element_nr;
- player->MovPos = (dx > 0 || dy > 0 ? -1 : 1) * (TILEX - TILEX / MoveSpeed);
+ player->MovPos =
+ (dx > 0 || dy > 0 ? -1 : 1) * (TILEX - TILEX / player->move_delay_value);
ScrollFigure(player, SCROLL_INIT);
if (player->gone || (!dx && !dy))
return FALSE;
- if (!FrameReached(&player->move_delay, MoveSpeed) && !tape.playing)
+ if (!FrameReached(&player->move_delay, player->move_delay_value) &&
+ !tape.playing)
return FALSE;
+ /* remove the last programmed player action */
+ player->programmed_action = 0;
+
if (player->MovPos)
{
/* should only happen if pre-1.2 tape recordings are played */
/* this is only for backward compatibility */
- int old_move_speed = MoveSpeed;
+ int original_move_delay_value = player->move_delay_value;
#if DEBUG
printf("THIS SHOULD ONLY HAPPEN WITH PRE-1.2 LEVEL TAPES.\n");
#endif
/* scroll remaining steps with finest movement resolution */
- MoveSpeed = 8;
+ player->move_delay_value = MOVE_DELAY_NORMAL_SPEED;
while (player->MovPos)
{
BackToFront();
}
- MoveSpeed = old_move_speed;
+ player->move_delay_value = original_move_delay_value;
}
if (player->last_move_dir & (MV_LEFT | MV_RIGHT))
player->last_move_dir = player->MovDir;
}
else
+ {
+ CheckGravityMovement(player);
+
player->last_move_dir = MV_NO_MOVING;
+ }
TestIfHeroHitsBadThing(jx, jy);
{
int jx = player->jx, jy = player->jy;
int last_jx = player->last_jx, last_jy = player->last_jy;
+ int move_stepsize = TILEX / player->move_delay_value;
if (!player->active || player->gone || !player->MovPos)
return;
if (mode == SCROLL_INIT)
{
player->actual_frame_counter = FrameCounter;
- player->GfxPos = ScrollStepSize * (player->MovPos / ScrollStepSize);
+ player->GfxPos = move_stepsize * (player->MovPos / move_stepsize);
if (Feld[last_jx][last_jy] == EL_LEERRAUM)
Feld[last_jx][last_jy] = EL_PLAYER_IS_LEAVING;
else if (!FrameReached(&player->actual_frame_counter, 1))
return;
- player->MovPos += (player->MovPos > 0 ? -1 : 1) * TILEX / MoveSpeed;
- player->GfxPos = ScrollStepSize * (player->MovPos / ScrollStepSize);
+ player->MovPos += (player->MovPos > 0 ? -1 : 1) * move_stepsize;
+ player->GfxPos = move_stepsize * (player->MovPos / move_stepsize);
if (Feld[last_jx][last_jy] == EL_PLAYER_IS_LEAVING)
Feld[last_jx][last_jy] = EL_LEERRAUM;
+ /* before DrawPlayer() to draw correct player graphic for this case */
+ if (player->MovPos == 0)
+ CheckGravityMovement(player);
+
DrawPlayer(player);
- if (!player->MovPos)
+ if (player->MovPos == 0)
{
- switch (Feld[last_jx][last_jy])
+ if (IS_QUICK_GATE(Feld[last_jx][last_jy]))
{
- case EL_SP_PORT1_LEFT:
- case EL_SP_PORT2_LEFT:
- case EL_SP_PORT1_RIGHT:
- case EL_SP_PORT2_RIGHT:
- case EL_SP_PORT1_UP:
- case EL_SP_PORT2_UP:
- case EL_SP_PORT1_DOWN:
- case EL_SP_PORT2_DOWN:
- case EL_SP_PORT_X:
- case EL_SP_PORT_Y:
- case EL_SP_PORT_XY:
- /* continue with normal speed after moving through port */
- /* FIX THIS: what about player already having eaten a speed pill? */
- MoveSpeed = 8;
- ScrollStepSize = TILEX / MoveSpeed;
-
- /* don't wait for the next move -- the whole move delay stuff
- is worse at the moment; FIX THIS! ;-) */
- player->move_delay = 0;
- break;
+ /* continue with normal speed after quickly moving through gate */
+ HALVE_PLAYER_SPEED(player);
- default:
- break;
+ /* be able to make the next move without delay */
+ player->move_delay = 0;
}
player->last_jx = jx;
if (mode == SCROLL_INIT)
{
+ /* set scrolling step size according to actual player's moving speed */
+ ScrollStepSize = TILEX / player->move_delay_value;
+
screen_frame_counter = FrameCounter;
ScreenMovDir = player->MovDir;
ScreenMovPos = player->MovPos;
if (ScreenMovPos)
{
- ScreenMovPos += (ScreenMovPos > 0 ? -1 : 1) * TILEX / MoveSpeed;
+ ScreenMovPos += (ScreenMovPos > 0 ? -1 : 1) * ScrollStepSize;
ScreenGfxPos = ScrollStepSize * (ScreenMovPos / ScrollStepSize);
redraw_mask |= REDRAW_FIELD;
}
if (!IN_LEV_FIELD(x, y))
continue;
+#if 0
element = Feld[x][y];
+#else
+ element = MovingOrBlocked2ElementIfNotLeaving(x, y);
+#endif
if (DONT_TOUCH(element))
{
{
int jx = player->jx, jy = player->jy;
int dx = x - jx, dy = y - jy;
+ int move_direction = (dx == -1 ? MV_LEFT :
+ dx == +1 ? MV_RIGHT :
+ dy == -1 ? MV_UP :
+ dy == +1 ? MV_DOWN : MV_NO_MOVING);
int element;
if (!player->MovPos)
case EL_SPEED_PILL:
RemoveField(x, y);
- MoveSpeed = 4;
- ScrollStepSize = TILEX / MoveSpeed;
+ player->move_delay_value = MOVE_DELAY_HIGH_SPEED;
PlaySoundLevel(x, y, SND_PONG);
break;
case EL_SCHLUESSEL3:
case EL_SCHLUESSEL4:
{
- int key_nr = element-EL_SCHLUESSEL1;
+ int key_nr = element - EL_SCHLUESSEL1;
+
+ RemoveField(x, y);
+ player->key[key_nr] = TRUE;
+ RaiseScoreElement(EL_SCHLUESSEL);
+ DrawMiniGraphicExt(drawto, gc,
+ DX_KEYS+key_nr*MINI_TILEX, DY_KEYS,
+ GFX_SCHLUESSEL1+key_nr);
+ DrawMiniGraphicExt(window, gc,
+ DX_KEYS+key_nr*MINI_TILEX, DY_KEYS,
+ GFX_SCHLUESSEL1+key_nr);
+ PlaySoundLevel(x, y, SND_PONG);
+ break;
+ }
+
+ case EL_EM_KEY_1:
+ case EL_EM_KEY_2:
+ case EL_EM_KEY_3:
+ case EL_EM_KEY_4:
+ {
+ int key_nr = element - EL_EM_KEY_1;
RemoveField(x, y);
player->key[key_nr] = TRUE;
case EL_PFORTE2:
case EL_PFORTE3:
case EL_PFORTE4:
- if (!player->key[element-EL_PFORTE1])
+ if (!player->key[element - EL_PFORTE1])
return MF_NO_ACTION;
break;
case EL_PFORTE2X:
case EL_PFORTE3X:
case EL_PFORTE4X:
- if (!player->key[element-EL_PFORTE1X])
+ if (!player->key[element - EL_PFORTE1X])
return MF_NO_ACTION;
break;
+ case EL_EM_GATE_1:
+ case EL_EM_GATE_2:
+ case EL_EM_GATE_3:
+ case EL_EM_GATE_4:
+ if (!player->key[element - EL_EM_GATE_1])
+ return MF_NO_ACTION;
+ if (!IN_LEV_FIELD(x + dx, y + dy) || !IS_FREE(x + dx, y + dy))
+ return MF_NO_ACTION;
+
+ /* automatically move to the next field with double speed */
+ player->programmed_action = move_direction;
+ DOUBLE_PLAYER_SPEED(player);
+
+ break;
+
+ case EL_EM_GATE_1X:
+ case EL_EM_GATE_2X:
+ case EL_EM_GATE_3X:
+ case EL_EM_GATE_4X:
+ if (!player->key[element - EL_EM_GATE_1X])
+ return MF_NO_ACTION;
+ if (!IN_LEV_FIELD(x + dx, y + dy) || !IS_FREE(x + dx, y + dy))
+ return MF_NO_ACTION;
+
+ /* automatically move to the next field with double speed */
+ player->programmed_action = move_direction;
+ DOUBLE_PLAYER_SPEED(player);
+
+ break;
+
case EL_SP_PORT1_LEFT:
case EL_SP_PORT2_LEFT:
case EL_SP_PORT1_RIGHT:
!IS_FREE(x + dx, y + dy))
return MF_NO_ACTION;
- /* automatically move to field behind the port */
- player->programmed_action = (dx == -1 ? MV_LEFT :
- dx == +1 ? MV_RIGHT :
- dy == -1 ? MV_UP :
- dy == +1 ? MV_DOWN : MV_NO_MOVING);
- /* move through port with double speed */
- MoveSpeed = 4;
- ScrollStepSize = TILEX / MoveSpeed;
+ /* automatically move to the next field with double speed */
+ player->programmed_action = move_direction;
+ DOUBLE_PLAYER_SPEED(player);
+
break;
case EL_AUSGANG_ZU:
PlaySoundLevel(x, y, SND_BUING);
- /*
- player->gone = TRUE;
- PlaySoundLevel(x, y, SND_BUING);
-
- if (!local_player->friends_still_needed)
- player->LevelSolved = player->GameOver = TRUE;
- */
-
break;
case EL_BIRNE_AUS:
volume = PSND_MAX_VOLUME;
#ifndef MSDOS
- stereo = (sx-SCR_FIELDX/2)*12;
+ stereo = (sx - SCR_FIELDX/2) * 12;
#else
- stereo = PSND_MIDDLE+(2*sx-(SCR_FIELDX-1))*5;
- if(stereo > PSND_MAX_RIGHT) stereo = PSND_MAX_RIGHT;
- if(stereo < PSND_MAX_LEFT) stereo = PSND_MAX_LEFT;
+ stereo = PSND_MIDDLE + (2 * sx - (SCR_FIELDX - 1)) * 5;
+ if (stereo > PSND_MAX_RIGHT)
+ stereo = PSND_MAX_RIGHT;
+ if (stereo < PSND_MAX_LEFT)
+ stereo = PSND_MAX_LEFT;
#endif
if (!IN_SCR_FIELD(sx, sy))
{
- int dx = ABS(sx-SCR_FIELDX/2)-SCR_FIELDX/2;
- int dy = ABS(sy-SCR_FIELDY/2)-SCR_FIELDY/2;
+ int dx = ABS(sx - SCR_FIELDX/2) - SCR_FIELDX/2;
+ int dy = ABS(sy - SCR_FIELDY/2) - SCR_FIELDY/2;
- volume -= volume*(dx > dy ? dx : dy)/silence_distance;
+ volume -= volume * (dx > dy ? dx : dy) / silence_distance;
}
PlaySoundExt(sound_nr, volume, stereo, PSND_NO_LOOP);
break;
}
- if (Request("Do you really want to quit the game ?",
+ if (level_editor_test_game ||
+ Request("Do you really want to quit the game ?",
REQ_ASK | REQ_STAY_CLOSED))
{
#ifndef MSDOS