static void PlayLevelSoundElementActionIfLoop(int, int, int, int);
static void PlayLevelSoundActionIfLoop(int, int, int);
static void StopLevelSoundActionIfLoop(int, int, int);
-static void PlayLevelMusic();
-static void FadeLevelSoundsAndMusic();
+static void PlayLevelMusic(void);
+static void FadeLevelSoundsAndMusic(void);
static void HandleGameButtons(struct GadgetInfo *);
void Bang(int, int);
void InitMovDir(int, int);
void InitAmoebaNr(int, int);
-int NewHiScore(void);
+int NewHiScore(int);
void TestIfGoodThingHitsBadThing(int, int, int);
void TestIfBadThingHitsGoodThing(int, int, int);
void KillPlayer(struct PlayerInfo *);
void BuryPlayer(struct PlayerInfo *);
void RemovePlayer(struct PlayerInfo *);
+void ExitPlayer(struct PlayerInfo *);
static int getInvisibleActiveFromInvisibleElement(int);
static int getInvisibleFromInvisibleActiveElement(int);
(x) += playfield_scan_delta_x)
#ifdef DEBUG
-void DEBUG_SetMaximumDynamite()
+void DEBUG_SetMaximumDynamite(void)
{
int i;
}
#endif
-static void InitPlayfieldScanModeVars()
+static void InitPlayfieldScanModeVars(void)
{
if (game.use_reverse_scan_direction)
{
}
}
-void GetPlayerConfig()
+void GetPlayerConfig(void)
{
GameFrameDelay = setup.game_frame_delay;
if (game.use_block_last_field_bug)
player->block_delay_adjustment = (player->block_last_field ? -1 : 1);
- if (!options.network || player->connected)
+ if (!network.enabled || player->connected_network)
{
player->active = TRUE;
return stored_player[player_nr].inventory_size;
}
-void InitGameControlValues()
+static void InitGameControlValues(void)
{
int i;
sizeof(struct GamePanelOrderInfo), compareGamePanelOrderInfo);
}
-void UpdatePlayfieldElementCount()
+static void UpdatePlayfieldElementCount(void)
{
boolean use_element_count = FALSE;
int i, j, x, y;
element_info[j].element_count;
}
-void UpdateGameControlValues()
+static void UpdateGameControlValues(void)
{
int i, k;
int time = (local_player->LevelSolved ?
/* update game panel control values */
- game_panel_controls[GAME_PANEL_LEVEL_NUMBER].value = level_nr;
+ /* used instead of "level_nr" (for network games) */
+ game_panel_controls[GAME_PANEL_LEVEL_NUMBER].value = levelset.level_nr;
game_panel_controls[GAME_PANEL_GEMS].value = gems;
game_panel_controls[GAME_PANEL_INVENTORY_COUNT].value = 0;
}
}
-void DisplayGameControlValues()
+static void DisplayGameControlValues(void)
{
boolean redraw_panel = FALSE;
int i;
SetGameStatus(GAME_MODE_PLAYING);
}
-void UpdateAndDisplayGameControlValues()
+void UpdateAndDisplayGameControlValues(void)
{
if (tape.deactivate_display)
return;
DisplayGameControlValues();
}
-void UpdateGameDoorValues()
+#if 0
+static void UpdateGameDoorValues(void)
{
UpdateGameControlValues();
}
+#endif
-void DrawGameDoorValues()
+void DrawGameDoorValues(void)
{
DisplayGameControlValues();
}
=============================================================================
*/
-static void InitGameEngine()
+static void InitGameEngine(void)
{
int i, j, k, l, x, y;
level.time = 0;
}
-int get_num_special_action(int element, int action_first, int action_last)
+static int get_num_special_action(int element, int action_first,
+ int action_last)
{
int num_special_action = 0;
int i, j;
=============================================================================
*/
-void InitGame()
+#if DEBUG_INIT_PLAYER
+static void DebugPrintPlayerStatus(char *message)
+{
+ int i;
+
+ if (!options.debug)
+ return;
+
+ printf("%s:\n", message);
+
+ for (i = 0; i < MAX_PLAYERS; i++)
+ {
+ struct PlayerInfo *player = &stored_player[i];
+
+ printf("- player %d: present == %d, connected == %d [%d/%d], active == %d",
+ i + 1,
+ player->present,
+ player->connected,
+ player->connected_locally,
+ player->connected_network,
+ player->active);
+
+ if (local_player == player)
+ printf(" (local player)");
+
+ printf("\n");
+ }
+}
+#endif
+
+void InitGame(void)
{
int full_lev_fieldx = lev_fieldx + (BorderElement != EL_EMPTY ? 2 : 0);
int full_lev_fieldy = lev_fieldy + (BorderElement != EL_EMPTY ? 2 : 0);
ExpireSoundLoops(TRUE);
- if (!level_editor_test_game)
- FadeOut(fade_mask);
+ FadeOut(fade_mask);
/* needed if different viewport properties defined for playing */
ChangeViewportPropertiesIfNeeded();
InitGameControlValues();
/* don't play tapes over network */
- network_playing = (options.network && !tape.playing);
+ network_playing = (network.enabled && !tape.playing);
for (i = 0; i < MAX_PLAYERS; i++)
{
player->gems_still_needed = level.gems_needed;
player->sokobanfields_still_needed = 0;
player->lights_still_needed = 0;
+ player->players_still_needed = 0;
player->friends_still_needed = 0;
for (j = 0; j < MAX_NUM_KEYS; j++)
network_player_action_received = FALSE;
-#if defined(NETWORK_AVALIABLE)
/* initial null action */
if (network_playing)
SendToServer_MovePlayer(MV_NONE);
-#endif
ZX = ZY = -1;
ExitX = ExitY = -1;
game.ball_state = level.ball_state_initial;
game.ball_content_nr = 0;
- game.envelope_active = FALSE;
-
- /* set focus to local player for network games, else to all players */
- game.centered_player_nr = (network_playing ? local_player->index_nr : -1);
- game.centered_player_nr_next = game.centered_player_nr;
- game.set_centered_player = FALSE;
+ game.explosions_delayed = TRUE;
- if (network_playing && tape.recording)
- {
- /* store client dependent player focus when recording network games */
- tape.centered_player_nr_next = game.centered_player_nr_next;
- tape.set_centered_player = TRUE;
- }
+ game.envelope_active = FALSE;
for (i = 0; i < NUM_BELTS; i++)
{
AmoebaCnt[i] = AmoebaCnt2[i] = 0;
#if DEBUG_INIT_PLAYER
- if (options.debug)
- {
- printf("Player status at level initialization:\n");
- }
+ DebugPrintPlayerStatus("Player status at level initialization");
#endif
SCAN_PLAYFIELD(x, y)
game.belt_dir_nr[i] = 3; /* not moving, next moving left */
#if USE_NEW_PLAYER_ASSIGNMENTS
- /* !!! SAME AS init.c:InitPlayerInfo() -- FIX THIS !!! */
- /* choose default local player */
- local_player = &stored_player[0];
-
for (i = 0; i < MAX_PLAYERS; i++)
+ {
stored_player[i].connected = FALSE;
- local_player->connected = TRUE;
- /* !!! SAME AS init.c:InitPlayerInfo() -- FIX THIS !!! */
+ /* in network game mode, the local player might not be the first player */
+ if (stored_player[i].connected_locally)
+ local_player = &stored_player[i];
+ }
+
+ if (!network.enabled)
+ local_player->connected = TRUE;
if (tape.playing)
{
for (i = 0; i < MAX_PLAYERS; i++)
stored_player[i].connected = tape.player_participates[i];
}
- else if (game.team_mode && !options.network)
+ else if (network.enabled)
+ {
+ /* add team mode players connected over the network (needed for correct
+ assignment of player figures from level to locally playing players) */
+
+ for (i = 0; i < MAX_PLAYERS; i++)
+ if (stored_player[i].connected_network)
+ stored_player[i].connected = TRUE;
+ }
+ else if (game.team_mode)
{
/* try to guess locally connected team mode players (needed for correct
assignment of player figures from level to locally playing players) */
}
#if DEBUG_INIT_PLAYER
- if (options.debug)
- {
- printf("Player status after level initialization:\n");
-
- for (i = 0; i < MAX_PLAYERS; i++)
- {
- struct PlayerInfo *player = &stored_player[i];
-
- printf("- player %d: present == %d, connected == %d, active == %d",
- i + 1,
- player->present,
- player->connected,
- player->active);
-
- if (local_player == player)
- printf(" (local player)");
-
- printf("\n");
- }
- }
+ DebugPrintPlayerStatus("Player status after level initialization");
#endif
#if DEBUG_INIT_PLAYER
}
#if DEBUG_INIT_PLAYER
- if (options.debug)
- {
- printf("Player status after player assignment (first stage):\n");
-
- for (i = 0; i < MAX_PLAYERS; i++)
- {
- struct PlayerInfo *player = &stored_player[i];
-
- printf("- player %d: present == %d, connected == %d, active == %d",
- i + 1,
- player->present,
- player->connected,
- player->active);
-
- if (local_player == player)
- printf(" (local player)");
-
- printf("\n");
- }
- }
+ DebugPrintPlayerStatus("Player status after player assignment (first stage)");
#endif
#else
printf("::: local_player->present == %d\n", local_player->present);
#endif
+ /* set focus to local player for network games, else to all players */
+ game.centered_player_nr = (network_playing ? local_player->index_nr : -1);
+ game.centered_player_nr_next = game.centered_player_nr;
+ game.set_centered_player = FALSE;
+
+ if (network_playing && tape.recording)
+ {
+ /* store client dependent player focus when recording network games */
+ tape.centered_player_nr_next = game.centered_player_nr_next;
+ tape.set_centered_player = TRUE;
+ }
+
if (tape.playing)
{
/* when playing a tape, eliminate all players who do not participate */
}
#endif
}
- else if (!options.network && !game.team_mode) /* && !tape.playing */
+ else if (!network.enabled && !game.team_mode) /* && !tape.playing */
{
- /* when in single player mode, eliminate all but the first active player */
+ /* when in single player mode, eliminate all but the local player */
for (i = 0; i < MAX_PLAYERS; i++)
{
- if (stored_player[i].active)
+ struct PlayerInfo *player = &stored_player[i];
+
+ if (player->active && player != local_player)
{
- for (j = i + 1; j < MAX_PLAYERS; j++)
- {
- if (stored_player[j].active)
- {
- struct PlayerInfo *player = &stored_player[j];
- int jx = player->jx, jy = player->jy;
+ int jx = player->jx, jy = player->jy;
- player->active = FALSE;
- player->present = FALSE;
+ player->active = FALSE;
+ player->present = FALSE;
- StorePlayer[jx][jy] = 0;
- Feld[jx][jy] = EL_EMPTY;
- }
- }
+ StorePlayer[jx][jy] = 0;
+ Feld[jx][jy] = EL_EMPTY;
}
}
}
+ for (i = 0; i < MAX_PLAYERS; i++)
+ if (stored_player[i].active)
+ local_player->players_still_needed++;
+
+ if (level.solved_by_one_player)
+ local_player->players_still_needed = 1;
+
/* when recording the game, store which players take part in the game */
if (tape.recording)
{
}
#if DEBUG_INIT_PLAYER
- if (options.debug)
- {
- printf("Player status after player assignment (final stage):\n");
-
- for (i = 0; i < MAX_PLAYERS; i++)
- {
- struct PlayerInfo *player = &stored_player[i];
-
- printf("- player %d: present == %d, connected == %d, active == %d",
- i + 1,
- player->present,
- player->connected,
- player->active);
-
- if (local_player == player)
- printf(" (local player)");
-
- printf("\n");
- }
- }
+ DebugPrintPlayerStatus("Player status after player assignment (final stage)");
#endif
if (BorderElement == EL_EMPTY)
OpenDoor(DOOR_OPEN_ALL);
- PlaySound(SND_GAME_STARTING);
-
- if (setup.sound_music)
- PlayLevelMusic();
-
KeyboardAutoRepeatOffUnlessAutoplay();
#if DEBUG_INIT_PLAYER
- if (options.debug)
- {
- printf("Player status (final):\n");
-
- for (i = 0; i < MAX_PLAYERS; i++)
- {
- struct PlayerInfo *player = &stored_player[i];
-
- printf("- player %d: present == %d, connected == %d, active == %d",
- i + 1,
- player->present,
- player->connected,
- player->active);
-
- if (local_player == player)
- printf(" (local player)");
-
- printf("\n");
- }
- }
+ DebugPrintPlayerStatus("Player status (final)");
#endif
}
InitGameActions_MM();
SaveEngineSnapshotToListInitial();
+
+ if (!game.restart_level)
+ {
+ PlaySound(SND_GAME_STARTING);
+
+ if (setup.sound_music)
+ PlayLevelMusic();
+ }
}
void UpdateEngineValues(int actual_scroll_x, int actual_scroll_y,
static void PlayerWins(struct PlayerInfo *player)
{
+ if (level.game_engine_type == GAME_ENGINE_TYPE_RND &&
+ local_player->players_still_needed > 0)
+ return;
+
player->LevelSolved = TRUE;
player->GameOver = TRUE;
player->LevelSolved_CountingHealth = player->health_final;
}
-void GameWon()
+void GameWon(void)
{
static int time_count_steps;
static int time, time_final;
GameEnd();
}
-void GameEnd()
+void GameEnd(void)
{
int hi_pos;
- boolean raise_level = FALSE;
local_player->LevelSolved_GameEnd = TRUE;
}
if (setup.increment_levels &&
- level_nr < leveldir_current->last_level)
- raise_level = TRUE; /* advance to next level */
-
- if ((hi_pos = NewHiScore()) >= 0)
+ level_nr < leveldir_current->last_level &&
+ !network_playing)
{
- SetGameStatus(GAME_MODE_SCORES);
+ level_nr++; /* advance to next level */
+ TapeErase(); /* start with empty tape */
- DrawHallOfFame(hi_pos);
-
- if (raise_level)
+ if (setup.auto_play_next_level)
{
- level_nr++;
- TapeErase();
+ LoadLevel(level_nr);
+
+ SaveLevelSetup_SeriesInfo();
}
}
+
+ /* used instead of last "level_nr" (for network games) */
+ hi_pos = NewHiScore(levelset.level_nr);
+
+ if (hi_pos >= 0 && !setup.skip_scores_after_game)
+ {
+ SetGameStatus(GAME_MODE_SCORES);
+
+ DrawHallOfFame(levelset.level_nr, hi_pos);
+ }
+ else if (setup.auto_play_next_level && setup.increment_levels &&
+ !network_playing)
+ {
+ StartGameActions(network.enabled, setup.autorecord, level.random_seed);
+ }
else
{
SetGameStatus(GAME_MODE_MAIN);
- if (raise_level)
- {
- level_nr++;
- TapeErase();
- }
-
DrawMainMenu();
}
}
-int NewHiScore()
+int NewHiScore(int level_nr)
{
int k, l;
int position = -1;
GfxRandom[x][y] = INIT_GFX_RANDOM();
}
-void InitMovingField(int x, int y, int direction)
+static void InitMovingField(int x, int y, int direction)
{
int element = Feld[x][y];
int dx = (direction == MV_LEFT ? -1 : direction == MV_RIGHT ? +1 : 0);
*comes_from_y = oldy;
}
-int MovingOrBlocked2Element(int x, int y)
+static int MovingOrBlocked2Element(int x, int y)
{
int element = Feld[x][y];
GfxDir[x][y] = MV_NONE;
}
-void RemoveMovingField(int x, int y)
+static void RemoveMovingField(int x, int y)
{
int oldx = x, oldy = y, newx = x, newy = y;
int element = Feld[x][y];
DrawGraphic(sx, sy, graphic, frame);
}
-void CheckDynamite(int x, int y)
+static void CheckDynamite(int x, int y)
{
if (MovDelay[x][y] != 0) /* dynamite is still waiting to explode */
{
}
}
-static boolean checkIfAllPlayersFitToScreen_RND()
+static boolean checkIfAllPlayersFitToScreen_RND(void)
{
int sx1 = 0, sy1 = 0, sx2 = 0, sy2 = 0;
*sy = (sy1 + sy2) / 2;
}
-void DrawRelocateScreen(int old_x, int old_y, int x, int y, int move_dir,
- boolean center_screen, boolean quick_relocation)
+static void DrawRelocateScreen(int old_x, int old_y, int x, int y, int move_dir,
+ boolean center_screen, boolean quick_relocation)
{
unsigned int frame_delay_value_old = GetVideoFrameDelay();
boolean ffwd_delay = (tape.playing && tape.fast_forward);
SetVideoFrameDelay(frame_delay_value_old);
}
-void RelocatePlayer(int jx, int jy, int el_player_raw)
+static void RelocatePlayer(int jx, int jy, int el_player_raw)
{
int el_player = GET_PLAYER_ELEMENT(el_player_raw);
int player_nr = GET_PLAYER_NR(el_player);
}
}
-void Explode(int ex, int ey, int phase, int mode)
+static void Explode(int ex, int ey, int phase, int mode)
{
int x, y;
int last_phase;
}
}
-void DynaExplode(int ex, int ey)
+static void DynaExplode(int ex, int ey)
{
int i, j;
int dynabomb_element = Feld[ex][ey];
CheckTriggeredElementChange(x, y, element, CE_EXPLOSION_OF_X);
}
-void SplashAcid(int x, int y)
+static void SplashAcid(int x, int y)
{
if (IN_LEV_FIELD(x - 1, y - 1) && IS_FREE(x - 1, y - 1) &&
(!IN_LEV_FIELD(x - 1, y - 2) ||
PlayLevelSound(x, y, SND_ACID_SPLASHING);
}
-static void InitBeltMovement()
+static void InitBeltMovement(void)
{
static int belt_base_element[4] =
{
element);
}
-static void RedrawAllLightSwitchesAndInvisibleElements()
+static void RedrawAllLightSwitchesAndInvisibleElements(void)
{
int x, y;
}
}
-static void RedrawAllInvisibleElementsForLenses()
+static void RedrawAllInvisibleElementsForLenses(void)
{
int x, y;
}
}
-static void RedrawAllInvisibleElementsForMagnifier()
+static void RedrawAllInvisibleElementsForMagnifier(void)
{
int x, y;
EL_DC_TIMEGATE_SWITCH_ACTIVE);
}
-void Impact(int x, int y)
+static void Impact(int x, int y)
{
boolean last_line = (y == lev_fieldy - 1);
boolean object_hit = FALSE;
return FALSE;
}
-void StartMoving(int x, int y)
+static void StartMoving(int x, int y)
{
boolean started_moving = FALSE; /* some elements can fall _and_ move */
int element = Feld[x][y];
return group_nr;
}
-void AmoebenVereinigen(int ax, int ay)
+static void AmoebenVereinigen(int ax, int ay)
{
int i, x, y, xx, yy;
int new_group_nr = AmoebaNr[ax][ay];
}
}
-void AmoebeUmwandelnBD(int ax, int ay, int new_element)
+static void AmoebeUmwandelnBD(int ax, int ay, int new_element)
{
int x, y;
int group_nr = AmoebaNr[ax][ay];
SND_BD_AMOEBA_TURNING_TO_GEM));
}
-void AmoebeWaechst(int x, int y)
+static void AmoebeWaechst(int x, int y)
{
static unsigned int sound_delay = 0;
static unsigned int sound_delay_value = 0;
}
}
-void AmoebaDisappearing(int x, int y)
+static void AmoebaDisappearing(int x, int y)
{
static unsigned int sound_delay = 0;
static unsigned int sound_delay_value = 0;
}
}
-void AmoebeAbleger(int ax, int ay)
+static void AmoebeAbleger(int ax, int ay)
{
int i;
int element = Feld[ax][ay];
TEST_DrawLevelField(newax, neway);
}
-void Life(int ax, int ay)
+static void Life(int ax, int ay)
{
int x1, y1, x2, y2;
int life_time = 40;
game.ball_content_nr = (game.ball_content_nr + 1) % level.num_ball_contents;
}
-void CheckExit(int x, int y)
+static void CheckExit(int x, int y)
{
if (local_player->gems_still_needed > 0 ||
local_player->sokobanfields_still_needed > 0 ||
PlayLevelSoundNearest(x, y, SND_CLASS_EXIT_OPENING);
}
-void CheckExitEM(int x, int y)
+static void CheckExitEM(int x, int y)
{
if (local_player->gems_still_needed > 0 ||
local_player->sokobanfields_still_needed > 0 ||
PlayLevelSoundNearest(x, y, SND_CLASS_EM_EXIT_OPENING);
}
-void CheckExitSteel(int x, int y)
+static void CheckExitSteel(int x, int y)
{
if (local_player->gems_still_needed > 0 ||
local_player->sokobanfields_still_needed > 0 ||
PlayLevelSoundNearest(x, y, SND_CLASS_STEEL_EXIT_OPENING);
}
-void CheckExitSteelEM(int x, int y)
+static void CheckExitSteelEM(int x, int y)
{
if (local_player->gems_still_needed > 0 ||
local_player->sokobanfields_still_needed > 0 ||
PlayLevelSoundNearest(x, y, SND_CLASS_EM_STEEL_EXIT_OPENING);
}
-void CheckExitSP(int x, int y)
+static void CheckExitSP(int x, int y)
{
if (local_player->gems_still_needed > 0)
{
PlayLevelSoundNearest(x, y, SND_CLASS_SP_EXIT_OPENING);
}
-static void CloseAllOpenTimegates()
+static void CloseAllOpenTimegates(void)
{
int x, y;
}
}
-void DrawTwinkleOnField(int x, int y)
+static void DrawTwinkleOnField(int x, int y)
{
if (!IN_SCR_FIELD(SCREENX(x), SCREENY(y)) || IS_MOVING(x, y))
return;
}
}
-void MauerWaechst(int x, int y)
+static void MauerWaechst(int x, int y)
{
int delay = 6;
}
}
-void MauerAbleger(int ax, int ay)
+static void MauerAbleger(int ax, int ay)
{
int element = Feld[ax][ay];
int graphic = el2img(element);
PlayLevelSoundAction(ax, ay, ACTION_GROWING);
}
-void MauerAblegerStahl(int ax, int ay)
+static void MauerAblegerStahl(int ax, int ay)
{
int element = Feld[ax][ay];
int graphic = el2img(element);
PlayLevelSoundAction(ax, ay, ACTION_GROWING);
}
-void CheckForDragon(int x, int y)
+static void CheckForDragon(int x, int y)
{
int i, j;
boolean dragon_found = FALSE;
{
for (i = 0; i < MAX_PLAYERS; i++)
if (action_arg_player_bits & (1 << i))
- PlayerWins(&stored_player[i]);
+ ExitPlayer(&stored_player[i]);
+
+ if (AllPlayersGone)
+ PlayerWins(local_player);
break;
}
}
}
-static void PlayAllPlayersSound()
+static void PlayAllPlayersSound(void)
{
int i;
tape_action[TAPE_ACTION_BUTTON] = mouse_action->button;
}
-static void CheckLevelTime()
+static void CheckLevelTime(void)
{
int i;
if (record_tape)
TapeStartRecording(new_random_seed);
-#if defined(NETWORK_AVALIABLE)
if (init_network_game)
{
+ SendToServer_LevelFile();
SendToServer_StartPlaying();
return;
}
-#endif
InitGame();
}
-void GameActionsExt()
+static void GameActionsExt(void)
{
#if 0
static unsigned int game_frame_delay = 0;
}
if (game.restart_level)
- StartGameActions(options.network, setup.autorecord, level.random_seed);
+ StartGameActions(network.enabled, setup.autorecord, level.random_seed);
/* !!! SAME CODE AS IN "CheckLevelTime()" -- FIX THIS !!! */
if (level.game_engine_type == GAME_ENGINE_TYPE_EM)
{
/* try to get network player actions in time */
-#if defined(NETWORK_AVALIABLE)
/* last chance to get network player actions without main loop delay */
HandleNetworking();
-#endif
/* game was quit by network peer */
if (game_status != GAME_MODE_PLAYING)
stored_player[i].effective_action = stored_player[i].action;
}
-#if defined(NETWORK_AVALIABLE)
if (network_playing)
SendToServer_MovePlayer(summarized_player_action);
-#endif
// summarize all actions at local players mapped input device position
// (this allows using different input devices in single player mode)
- if (!options.network && !game.team_mode)
+ if (!network.enabled && !game.team_mode)
stored_player[map_player_action[local_player->index_nr]].effective_action =
summarized_player_action;
}
}
-static void GameActions_CheckSaveEngineSnapshot()
+static void GameActions_CheckSaveEngineSnapshot(void)
{
if (!game.snapshot.save_snapshot)
return;
SaveEngineSnapshotToList();
}
-void GameActions()
+void GameActions(void)
{
GameActionsExt();
GameActions_CheckSaveEngineSnapshot();
}
-void GameActions_EM_Main()
+void GameActions_EM_Main(void)
{
byte effective_action[MAX_PLAYERS];
boolean warp_mode = (tape.playing && tape.warp_forward && !tape.pausing);
GameActions_EM(effective_action, warp_mode);
}
-void GameActions_SP_Main()
+void GameActions_SP_Main(void)
{
byte effective_action[MAX_PLAYERS];
boolean warp_mode = (tape.playing && tape.warp_forward && !tape.pausing);
}
}
-void GameActions_MM_Main()
+void GameActions_MM_Main(void)
{
boolean warp_mode = (tape.playing && tape.warp_forward && !tape.pausing);
GameActions_MM(local_player->effective_mouse_action, warp_mode);
}
-void GameActions_RND_Main()
+void GameActions_RND_Main(void)
{
GameActions_RND();
}
-void GameActions_RND()
+void GameActions_RND(void)
{
int magic_wall_x = 0, magic_wall_y = 0;
int i, x, y, element, graphic, last_gfx_frame;
return (max_x - min_x < SCR_FIELDX && max_y - min_y < SCR_FIELDY);
}
-static boolean AllPlayersInVisibleScreen()
+static boolean AllPlayersInVisibleScreen(void)
{
int i;
}
}
- if (!options.network && game.centered_player_nr == -1 &&
+ if (!network.enabled && game.centered_player_nr == -1 &&
!AllPlayersInSight(player, new_jx, new_jy))
return MP_NO_ACTION;
if (scroll_x != old_scroll_x || scroll_y != old_scroll_y)
{
- if (!options.network && game.centered_player_nr == -1 &&
+ if (!network.enabled && game.centered_player_nr == -1 &&
!AllPlayersInVisibleScreen())
{
scroll_x = old_scroll_x;
Feld[jx][jy] == EL_SP_EXIT_OPEN ||
Feld[jx][jy] == EL_SP_EXIT_OPENING) /* <-- special case */
{
- DrawPlayer(player); /* needed here only to cleanup last field */
- RemovePlayer(player);
+ ExitPlayer(player);
- if (local_player->friends_still_needed == 0 ||
- IS_SP_ELEMENT(Feld[jx][jy]))
- PlayerWins(player);
+ if ((local_player->friends_still_needed == 0 ||
+ IS_SP_ELEMENT(Feld[jx][jy])) &&
+ AllPlayersGone)
+ PlayerWins(local_player);
}
/* this breaks one level: "machine", level 000 */
ExitY = ZY = jy;
}
+void ExitPlayer(struct PlayerInfo *player)
+{
+ DrawPlayer(player); /* needed here only to cleanup last field */
+ RemovePlayer(player);
+
+ if (local_player->players_still_needed > 0)
+ local_player->players_still_needed--;
+
+ /* also set if some players not yet gone, but not needed to solve level */
+ if (local_player->players_still_needed == 0)
+ AllPlayersGone = TRUE;
+}
+
static void setFieldForSnapping(int x, int y, int element, int direction)
{
struct ElementInfo *ei = &element_info[element];
if (local_player->sokobanfields_still_needed == 0 &&
(game.emulation == EMU_SOKOBAN || level.auto_exit_sokoban))
{
+ local_player->players_still_needed = 0;
+
PlayerWins(player);
PlayLevelSound(x, y, SND_GAME_SOKOBAN_SOLVING);
static int *loop_sound_frame = NULL;
static int *loop_sound_volume = NULL;
-void InitPlayLevelSound()
+void InitPlayLevelSound(void)
{
int num_sounds = getSoundListSize();
StopSound(sound_effect);
}
-static int getLevelMusicNr()
+static int getLevelMusicNr(void)
{
if (levelset.music[level_nr] != MUS_UNDEFINED)
return levelset.music[level_nr]; /* from config file */
return MAP_NOCONF_MUSIC(level_nr); /* from music dir */
}
-static void FadeLevelSounds()
+static void FadeLevelSounds(void)
{
FadeSounds();
}
-static void FadeLevelMusic()
+static void FadeLevelMusic(void)
{
int music_nr = getLevelMusicNr();
char *curr_music = getCurrentlyPlayingMusicFilename();
FadeMusic();
}
-void FadeLevelSoundsAndMusic()
+void FadeLevelSoundsAndMusic(void)
{
FadeLevelSounds();
FadeLevelMusic();
}
-static void PlayLevelMusic()
+static void PlayLevelMusic(void)
{
int music_nr = getLevelMusicNr();
char *curr_music = getCurrentlyPlayingMusicFilename();
char *next_music = getMusicInfoEntryFilename(music_nr);
if (!strEqual(curr_music, next_music))
- PlayMusic(music_nr);
+ PlayMusicLoop(music_nr);
}
void PlayLevelSound_EM(int xx, int yy, int element_em, int sample)
if (!skip_request)
CloseDoor(DOOR_CLOSE_1);
-#if defined(NETWORK_AVALIABLE)
- if (options.network)
+ if (network.enabled)
SendToServer_StopPlaying(NETWORK_STOP_BY_PLAYER);
else
-#endif
{
if (quick_quit)
FadeSkipNextFadeIn();
if (Request(message, REQ_ASK | REQ_STAY_CLOSED))
{
- StartGameActions(options.network, setup.autorecord, level.random_seed);
+ StartGameActions(network.enabled, setup.autorecord, level.random_seed);
}
else
{
static char *snapshot_level_identifier = NULL;
static int snapshot_level_nr = -1;
-static void SaveEngineSnapshotValues_RND()
+static void SaveEngineSnapshotValues_RND(void)
{
static int belt_base_active_element[4] =
{
}
}
-static void LoadEngineSnapshotValues_RND()
+static void LoadEngineSnapshotValues_RND(void)
{
unsigned int num_random_calls = game.num_random_calls;
int i, j;
}
}
-void FreeEngineSnapshotSingle()
+void FreeEngineSnapshotSingle(void)
{
FreeSnapshotSingle();
snapshot_level_nr = -1;
}
-void FreeEngineSnapshotList()
+void FreeEngineSnapshotList(void)
{
FreeSnapshotList();
}
-ListNode *SaveEngineSnapshotBuffers()
+static ListNode *SaveEngineSnapshotBuffers(void)
{
ListNode *buffers = NULL;
return buffers;
}
-void SaveEngineSnapshotSingle()
+void SaveEngineSnapshotSingle(void)
{
ListNode *buffers = SaveEngineSnapshotBuffers();
snapshot_level_nr = level_nr;
}
-boolean CheckSaveEngineSnapshotToList()
+boolean CheckSaveEngineSnapshotToList(void)
{
boolean save_snapshot =
((game.snapshot.mode == SNAPSHOT_MODE_EVERY_STEP) ||
return save_snapshot;
}
-void SaveEngineSnapshotToList()
+void SaveEngineSnapshotToList(void)
{
if (game.snapshot.mode == SNAPSHOT_MODE_OFF ||
tape.quick_resume)
SaveSnapshotToList(buffers);
}
-void SaveEngineSnapshotToListInitial()
+void SaveEngineSnapshotToListInitial(void)
{
FreeEngineSnapshotList();
SaveEngineSnapshotToList();
}
-void LoadEngineSnapshotValues()
+static void LoadEngineSnapshotValues(void)
{
/* restore special values from snapshot structure */
LoadEngineSnapshotValues_MM();
}
-void LoadEngineSnapshotSingle()
+void LoadEngineSnapshotSingle(void)
{
LoadSnapshotSingle();
LoadEngineSnapshotValues();
}
-void LoadEngineSnapshot_Undo(int steps)
+static void LoadEngineSnapshot_Undo(int steps)
{
LoadSnapshotFromList_Older(steps);
LoadEngineSnapshotValues();
}
-void LoadEngineSnapshot_Redo(int steps)
+static void LoadEngineSnapshot_Redo(int steps)
{
LoadSnapshotFromList_Newer(steps);
LoadEngineSnapshotValues();
}
-boolean CheckEngineSnapshotSingle()
+boolean CheckEngineSnapshotSingle(void)
{
return (strEqual(snapshot_level_identifier, leveldir_current->identifier) &&
snapshot_level_nr == level_nr);
}
-boolean CheckEngineSnapshotList()
+boolean CheckEngineSnapshotList(void)
{
return CheckSnapshotList();
}
}
};
-void CreateGameButtons()
+void CreateGameButtons(void)
{
int i;
for (i = 0; i < NUM_GAME_BUTTONS; i++)
{
- struct GraphicInfo *gfx = &graphic_info[gamebutton_info[i].graphic];
+ int graphic = gamebutton_info[i].graphic;
+ struct GraphicInfo *gfx = &graphic_info[graphic];
struct XY *pos = gamebutton_info[i].pos;
struct GadgetInfo *gi;
int button_type;
}
gi = CreateGadget(GDI_CUSTOM_ID, id,
+ GDI_IMAGE_ID, graphic,
GDI_INFO_TEXT, gamebutton_info[i].infotext,
GDI_X, base_x + GDI_ACTIVE_POS(pos->x),
GDI_Y, base_y + GDI_ACTIVE_POS(pos->y),
}
}
-void FreeGameButtons()
+void FreeGameButtons(void)
{
int i;
UnmapGadget(game_gadget[i]);
}
-static void UnmapGameButtonsAtSamePosition_All()
+static void UnmapGameButtonsAtSamePosition_All(void)
{
if (setup.show_snapshot_buttons)
{
UnmapGameButtonsAtSamePosition_All();
}
-void MapUndoRedoButtons()
+void MapUndoRedoButtons(void)
{
UnmapGameButtonsAtSamePosition(GAME_CTRL_ID_UNDO);
UnmapGameButtonsAtSamePosition(GAME_CTRL_ID_REDO);
ModifyGadget(game_gadget[GAME_CTRL_ID_PAUSE2], GDI_CHECKED, TRUE, GDI_END);
}
-void UnmapUndoRedoButtons()
+void UnmapUndoRedoButtons(void)
{
UnmapGadget(game_gadget[GAME_CTRL_ID_UNDO]);
UnmapGadget(game_gadget[GAME_CTRL_ID_REDO]);
ModifyGadget(game_gadget[GAME_CTRL_ID_PAUSE2], GDI_CHECKED, FALSE, GDI_END);
}
-void MapGameButtonsExt(boolean on_tape)
+static void MapGameButtonsExt(boolean on_tape)
{
int i;
RedrawGameButtons();
}
-void UnmapGameButtonsExt(boolean on_tape)
+static void UnmapGameButtonsExt(boolean on_tape)
{
int i;
UnmapGadget(game_gadget[i]);
}
-void RedrawGameButtonsExt(boolean on_tape)
+static void RedrawGameButtonsExt(boolean on_tape)
{
int i;
redraw_mask &= ~REDRAW_ALL;
}
-void SetGadgetState(struct GadgetInfo *gi, boolean state)
+static void SetGadgetState(struct GadgetInfo *gi, boolean state)
{
if (gi == NULL)
return;
gi->checked = state;
}
-void RedrawSoundButtonGadget(int id)
+static void RedrawSoundButtonGadget(int id)
{
int id2 = (id == SOUND_CTRL_ID_MUSIC ? SOUND_CTRL_ID_PANEL_MUSIC :
id == SOUND_CTRL_ID_LOOPS ? SOUND_CTRL_ID_PANEL_LOOPS :
RedrawGadget(game_gadget[id2]);
}
-void MapGameButtons()
+void MapGameButtons(void)
{
MapGameButtonsExt(FALSE);
}
-void UnmapGameButtons()
+void UnmapGameButtons(void)
{
UnmapGameButtonsExt(FALSE);
}
-void RedrawGameButtons()
+void RedrawGameButtons(void)
{
RedrawGameButtonsExt(FALSE);
}
-void MapGameButtonsOnTape()
+void MapGameButtonsOnTape(void)
{
MapGameButtonsExt(TRUE);
}
-void UnmapGameButtonsOnTape()
+void UnmapGameButtonsOnTape(void)
{
UnmapGameButtonsExt(TRUE);
}
-void RedrawGameButtonsOnTape()
+void RedrawGameButtonsOnTape(void)
{
RedrawGameButtonsExt(TRUE);
}
-void GameUndoRedoExt()
+static void GameUndoRedoExt(void)
{
ClearPlayerAction();
BackToFront();
}
-void GameUndo(int steps)
+static void GameUndo(int steps)
{
if (!CheckEngineSnapshotList())
return;
GameUndoRedoExt();
}
-void GameRedo(int steps)
+static void GameRedo(int steps)
{
if (!CheckEngineSnapshotList())
return;
case GAME_CTRL_ID_PAUSE:
case GAME_CTRL_ID_PAUSE2:
case GAME_CTRL_ID_PANEL_PAUSE:
- if (options.network && game_status == GAME_MODE_PLAYING)
+ if (network.enabled && game_status == GAME_MODE_PLAYING)
{
-#if defined(NETWORK_AVALIABLE)
if (tape.pausing)
SendToServer_ContinuePlaying();
else
SendToServer_PausePlaying();
-#endif
}
else
TapeTogglePause(TAPE_TOGGLE_MANUAL);
case GAME_CTRL_ID_PANEL_PLAY:
if (game_status == GAME_MODE_MAIN)
{
- StartGameActions(options.network, setup.autorecord, level.random_seed);
+ StartGameActions(network.enabled, setup.autorecord, level.random_seed);
}
else if (tape.pausing)
{
-#if defined(NETWORK_AVALIABLE)
- if (options.network)
+ if (network.enabled)
SendToServer_ContinuePlaying();
else
-#endif
TapeTogglePause(TAPE_TOGGLE_MANUAL | TAPE_TOGGLE_PLAY_PAUSE);
}
break;