src/tron/gGame.h File Reference

#include "rSDL.h"
#include "nNetObject.h"

Include dependency graph for gGame.h:

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Classes
class	gGame
class	gGameSettings
Enumerations
enum	gGameType { gFREESTYLE, gDUEL, gHUMAN_VS_AI }
enum	gFinishType { gFINISH_EXPRESS, gFINISH_IMMEDIATELY, gFINISH_SPEEDUP, gFINISH_NORMAL }
Functions
void	update_settings ()
void	ConnectToServer (nServerInfoBase *server)
void	sg_EnterGame (nNetState enter_state)
void	sg_HostGame ()
void	sg_HostGameMenu ()
void	MainMenu (bool ingame=false)
bool	GridIsReady (int c)
void	Activate (bool act)
void	sg_DeclareWinner (eTeam *team, char const *message)
void	sg_FullscreenMessage (tOutput const &title, tOutput const &message, REAL timeout=60, int client=0)
	Displays a message on a specific client or all clients that gets displayed on the whole screen, blocking view to the game.
void	sg_ClientFullscreenMessage (tOutput const &title, tOutput const &message, REAL timeout=60)
	Displays a message locally that gets displayed on the whole screen, blocking view to the game.
void	sg_RespawnPlayer (eGrid *grid, gArena *arena, ePlayerNetID *p)
gArena *	sg_GetArena ()
void	init_second_pass_zones (eGrid *grid, gParser *parser)
void	rotate ()
Variables
bool	sg_TalkToMaster
gGameSettings *	sg_currentSettings

---

Enumeration Type Documentation

enum gFinishType

Enumerator:

gFINISH_EXPRESS
gFINISH_IMMEDIATELY
gFINISH_SPEEDUP
gFINISH_NORMAL

Definition at line 50 of file gGame.h.

{gFINISH_EXPRESS,gFINISH_IMMEDIATELY,gFINISH_SPEEDUP,gFINISH_NORMAL}

enum gGameType

Enumerator:

gFREESTYLE
gDUEL
gHUMAN_VS_AI

Definition at line 44 of file gGame.h.

{gFREESTYLE,gDUEL,gHUMAN_VS_AI}

---

Function Documentation

void Activate

(

bool

act

)

Definition at line 4142 of file gGame.cpp.

References ePlayerNetID::ChatFlags_Away, currentScreensetting, rScreenSettings::fullscreen, tRecorderBase::IsRunning(), nSTANDALONE, se_ChatState(), se_PauseGameTimer(), sn_GetNetState(), and sr_Activate().

Referenced by filter().

                       {
#ifdef DEBUG
    return;
#endif

// another fullscreen fix ammendmend: avoid the short screen flicker
// by ignoring deactivation events in fullscreen mode completely.
#ifndef WIN32
#ifndef MACOSX
    if ( currentScreensetting.fullscreen && !act )
    {
        return;
    }
#endif
#endif

    sr_Activate( act );

    if (!tRecorder::IsRunning() )
    {
        if (sn_GetNetState()==nSTANDALONE)
        {
            se_PauseGameTimer(!act);
        }

        se_ChatState( ePlayerNetID::ChatFlags_Away, !act);

Here is the call graph for this function:

Here is the caller graph for this function:

void ConnectToServer

(

nServerInfoBase *

server

)

Definition at line 1654 of file gGame.cpp.

References ConnectToServerCore(), and sn_GetRedirectTo().

Referenced by gServerFavorite::Connect(), gCommandLineJumpStartAnalyzer::Connect(), and gServerMenuItem::Enter().

{
    bool okToRedirect = ConnectToServerCore( server );

    // REAL redirections = 0;
    // double lastTime = tSysTimeFloat();

    // check for redirection
    while( okToRedirect )
    {
        std::auto_ptr< nServerInfoBase > redirectTo( sn_GetRedirectTo() );

        // abort loop
        if ( !(&(*redirectTo)) )
        {
            break;
        }

        okToRedirect = ConnectToServerCore( redirectTo.get() );

        /*
        // redirection spam chain protection, allow one redirection every 30 seconds. Should
        // be short enough to allow hacky applications (server-to-server teleport), but
        // long enough to allow players to escape via the menu or at least shift-esc.
        static const REAL timeout = 30;
        static const REAL maxRedirections = 5;

        redirections = redirections + 1;
        if ( redirections > maxRedirections )
        {
            break;
        }

        // decay spam protection
        double newTime = tSysTimeFloat();
        REAL dt = newTime - lastTime;
        lastTime = newTime;
        redirections *= 1/(1 + dt * maxRedirections * timeout );
        */
    }

Here is the call graph for this function:

Here is the caller graph for this function:

bool GridIsReady

(

int

c

)

Definition at line 4129 of file gGame.cpp.

Referenced by gNetPlayerWall::ClearToTransmit().

                       {

Here is the caller graph for this function:

void init_second_pass_zones	(	eGrid *	grid,
		gParser *	parser
	)

Referenced by gGame::StateUpdate().

Here is the caller graph for this function:

void MainMenu

(

bool

ingame = false

)

Definition at line 1959 of file gGame.cpp.

References uMenu::Enter(), GameSettingsCurrent(), GameSettingsSP(), MainMenu(), MAX_PLAYERS, mp, nCLIENT, net_game(), nSTANDALONE, NULL, PlayerLogIn(), ePlayerNetID::PoliceMenu(), ret_to_MainMenu(), se_SoundMenu(), gLogo::SetDisplayed(), rConsole::SetHeight(), tOutput::SetTemplateParameter(), sg_DisplayVersionInfo(), sg_LanguageMenu(), sg_moviepackUse, sg_PlayerMenu(), sg_screenMenu, singlePlayer_game(), sn_GetNetState(), sn_programVersion, sr_con, sr_textOut, StartNewMatch(), su_InputConfigGlobal(), nVersionFeature::Supported(), gTeam::TeamMenu(), tNEW, rViewport::Update(), eVoter::VotingMenu(), eVoter::VotingPossible(), and uMenu::wrap.

Referenced by main(), and MainMenu().

                          {
    //  update_settings();

    if (ingame)
        sr_con.SetHeight(2);

    //gLogo::SetDisplayed(true);

    tOutput gametitle;
    if (!ingame)
        gametitle << "$game_menu_text";
    else
        gametitle << "$game_menu_ingame_text";

    uMenu game_menu(gametitle);

    uMenuItemFunction *reset=NULL;

    if (ingame && sn_GetNetState()!=nCLIENT){
        reset=new uMenuItemFunction
              (&game_menu,"$game_menu_reset_text",
               "$game_menu_reset_help",
               &StartNewMatch);
    }

    uMenuItemFunction *settings1=NULL;

    if (!ingame)
        settings1=tNEW(uMenuItemFunction)
                  (&game_menu,
                   "$game_settings_menu_text",
                   "$game_settings_menu_help",
                   &GameSettingsSP);
    else
        settings1=tNEW(uMenuItemFunction)
                  (&game_menu,
                   "$game_settings_menu_text",
                   "$game_settings_menu_help",
                   &GameSettingsCurrent);

    uMenuItemFunction *connect=NULL,*start=NULL,*sound=NULL;

    if (!ingame){
        connect=new uMenuItemFunction
                (&game_menu,
                 "$network_menu_text",
                 "$network_menu_help",
                 &net_game);

        start= new uMenuItemFunction(&game_menu,"$game_menu_start_text",
                                     "$game_menu_start_help",&singlePlayer_game);
    }

    tOutput title;
    title.SetTemplateParameter( 1, sn_programVersion );
    if (!ingame)
        title << "$main_menu_text";
    else
        title << "$ingame_menu_text";

    uMenu MainMenu(title,false);

    if (ingame)
        sg_IngameMenu = &MainMenu;

    char const * extitle,* exhelp;
    if (!ingame){
        extitle="$main_menu_exit_text";
        exhelp="$main_menu_exit_help";
    }
    else{
        extitle="$ingame_menu_exit_text";
        exhelp="$ingame_menu_exit_help";
    }

    uMenuItemExit exx(&MainMenu,extitle,
                      exhelp);

    uMenuItemFunction *return_to_main=NULL;
    if (ingame){
        if (sn_GetNetState()==nSTANDALONE)
            return_to_main=new uMenuItemFunction
                           (&MainMenu,"$game_menu_exit_text",
                            "$game_menu_exit_help",
                            &ret_to_MainMenu);
        else if (sn_GetNetState()==nCLIENT)
            return_to_main=new uMenuItemFunction
                           (&MainMenu,"$game_menu_disconnect_text",
                            "$game_menu_disconnect_help",
                            &ret_to_MainMenu);
        else
            return_to_main=new uMenuItemFunction
                           (&MainMenu,
                            "$game_menu_shutdown_text",
                            "game_menu_shutdown_help",
                            &ret_to_MainMenu);
    }

    uMenuItemFunction * auth = 0;
    static nVersionFeature authentication( 15 );
    if ( sn_GetNetState() == nCLIENT && ingame && authentication.Supported(0) )
    {
        auth =tNEW(uMenuItemFunction)(&MainMenu,
                                      "$player_authenticate_text",
                                      "$player_authenticate_help",
                                      &PlayerLogIn );
    }

    uMenuItemFunction abb(&MainMenu,
                          "$main_menu_about_text",
                          "$main_menu_about_help",
                          &sg_DisplayVersionInfo);


    uMenu Settings("$system_settings_menu_text");

    uMenuItemSubmenu subm_settings
    (&MainMenu,&Settings,
     "$system_settings_menu_help");


    uMenuItem* team = NULL;
    if ( ingame )
    {
        team = tNEW( uMenuItemFunction) ( &MainMenu,
                                          "$team_menu_title",
                                          "$team_menu_help",
                                          &gTeam::TeamMenu );
    }

    uMenuItemFunction *se_PlayerMenu=NULL;

    //   if (!ingame)
    se_PlayerMenu= new uMenuItemFunction
                   (&MainMenu,"$player_mainmenu_text",
                    "$player_mainmenu_help",
                    &sg_PlayerMenu);

    uMenuItemFunction *player_police=NULL;
    uMenuItemFunction *voting=NULL;
    if ( ingame && sn_GetNetState() != nSTANDALONE )
    {
        player_police = tNEW( uMenuItemFunction )( &MainMenu, "$player_police_text", "$player_police_help", ePlayerNetID::PoliceMenu );

        if ( eVoter::VotingPossible() )
            voting = tNEW( uMenuItemFunction )( &MainMenu, "$voting_menu_text", "$voting_menu_help", eVoter::VotingMenu );
    }

    uMenu misc("$misc_menu_text");

    //  misc.SetCenter(.25);

    uMenuItemFunction language
    (&misc,"$language_menu_title",
     "$language_menu_help",
     &sg_LanguageMenu);

    uMenuItemFunction global_key
    (&misc,"$misc_global_key_text",
     "$misc_global_key_help",
     &su_InputConfigGlobal);

    uMenuItemToggle wrap
    (&misc,"$misc_menuwrap_text",
     "$misc_menuwrap_help",
     uMenu::wrap);

    uMenuItemToggle to2
    (&misc,"$misc_textout_text",
     "$misc_textout_help",sr_textOut);



    uMenuItemToggle mp
    (&misc,"$misc_moviepack_text",
     "$misc_moviepack_help",sg_moviepackUse);


    uMenuItemSubmenu misc_sm
    (&Settings,&misc,
     "$misc_menu_help");

    sound = new uMenuItemFunction
            (&Settings,"$sound_menu_text",
             "$sound_menu_help",&se_SoundMenu);

    uMenuItemSubmenu subm
    (&Settings,&sg_screenMenu,
     "$display_settings_menu_help");

    uMenuItemSubmenu *gamemenuitem = NULL;
    if (sn_GetNetState() != nCLIENT)
    {
        char const * gamehelp;
        if (!ingame)
            gamehelp="$game_menu_main_help";
        else
            gamehelp="$game_menu_ingame_help";

        gamemenuitem = tNEW(uMenuItemSubmenu) (&MainMenu,
                                               &game_menu,
                                               gamehelp
                                              );
    }

    if (!ingame)
    {
        rViewport::Update(MAX_PLAYERS);
        // ePlayerNetID::Update();
    }

    MainMenu.Enter();

    if (settings1)
        delete settings1;
    if (team)
        delete team;
    if (gamemenuitem)
        delete gamemenuitem;
    if (sound)
        delete sound;
    if (connect)
        delete connect;
    if (start)
        delete start;
    if (return_to_main)
        delete return_to_main;
    if (se_PlayerMenu)
        delete se_PlayerMenu;
    if (reset)
        delete reset;
    if ( player_police )
        delete player_police;
    if ( voting )
        delete voting;

    if (ingame)
        sg_IngameMenu=NULL;

    if (ingame)
    {
        gLogo::SetDisplayed(false);
        sr_con.SetHeight(7);
    }

    if ( auth )
    {
        delete auth;
    }

Here is the call graph for this function:

Here is the caller graph for this function:

void rotate

(

)

Definition at line 3547 of file gGame.cpp.

{
    if ( sg_mapRotation.Size() > 0 )
    {
        conf_mapfile.Set( sg_mapRotation.Current() );
        sg_mapRotation.Rotate();
    }

    if ( sg_configRotation.Size() > 0 )
    {
        st_Include( sg_configRotation.Current() );
        sg_configRotation.Rotate();

void sg_ClientFullscreenMessage	(	tOutput const &	title,
		tOutput const &	message,
		REAL	timeout = 60
	)

Displays a message locally that gets displayed on the whole screen, blocking view to the game.

Definition at line 4186 of file gGame.cpp.

Referenced by sg_FullscreenMessage(), and sg_TodoClientFullscreenMessage().

                                                                                               {
    // keep syncing the network
    rPerFrameTask idle( sg_FullscreenIdle );

    // put players into idle mode
    ePlayerNetID::SpectateAll();
    se_ChatState( ePlayerNetID::ChatFlags_Menu, true );

    // show message
    uMenu::Message( title, message, timeout );

    // and print it to the console
#ifndef DEDICATED
    con <<  title << "\n" << message << "\n";
#endif

    // get players out of idle mode again
    ePlayerNetID::SpectateAll(false);

Here is the caller graph for this function:

void sg_DeclareWinner	(	eTeam *	team,
		char const *	message
	)

Definition at line 746 of file gGame.cpp.

References eTeam::TeamID(), winner, wishWinner, and wishWinnerMessage.

Referenced by zEffectorWin::effect(), gBaseZoneHack::OnConquest(), gWinZoneHack::OnEnter(), and gBaseZoneHack::Timestep().

{
    if ( team && !winner )
    {
        wishWinner = team->TeamID() + 1;
        wishWinnerMessage = message;
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

void sg_EnterGame

(

nNetState

enter_state

)

Definition at line 4094 of file gGame.cpp.

Referenced by ConnectToServerCore(), and own_game().

{
    try
    {
        // enter the game
        sg_EnterGameCore( enter_state );
    }
    catch (tException const & e)
    {
        // cleanup
        sg_EnterGameCleanup();

        // inform user of generic errors
        tConsole::Message( e.GetName(), e.GetDescription(), 120000 );
    }
    // again: VC6 does not catch tGenericException with above statement
#ifdef _MSC_VER
#pragma warning ( disable : 4286 )
    catch (tGenericException const & e)
    {
        // cleanup
        sg_EnterGameCleanup();

        // inform user of generic errors
        tConsole::Message( e.GetName(), e.GetDescription(), 120000 );
    }
#endif

    // bounce teams
    for ( int i = eTeam::teams.Len()-1; i>=0; --i )
    {
        tJUST_CONTROLLED_PTR< eTeam > t = eTeam::teams(i);

Here is the caller graph for this function:

void sg_FullscreenMessage	(	tOutput const &	title,
		tOutput const &	message,
		REAL	timeout = 60,
		int	client = 0
	)

Displays a message on a specific client or all clients that gets displayed on the whole screen, blocking view to the game.

Definition at line 4230 of file gGame.cpp.

References c, gameloop_idle(), ePlayerNetID::IsChatting(), GrowingArrayBase::Len(), MAXCLIENTS, gGame::NetSyncIdle(), REAL, se_GameTime(), se_mainGameTimer, se_PauseGameTimer(), se_PlayerNetIDs, sg_ClientFullscreenMessage(), sg_clientFullscreenMessage, sg_FullscreenIdle(), sg_fullscreenMessages, sg_lastChatBreakTime, sn_Connections, sn_ConsoleOut(), eTimer::speed, nVersionFeature::Supported(), and tSysTimeFloat().

Referenced by sg_DisplayVersionInfo().

                                                                                                   {
    tJUST_CONTROLLED_PTR< nMessage > m=new nMessage(sg_clientFullscreenMessage);
    *m << title;
    *m << message;
    *m << timeout;

    tString complete( title );
    complete << "\n" << message << "\n";

    if (client <= 0){
        if ( sg_fullscreenMessages.Supported() )
            m->BroadCast();
        else
        {
            for (int c = MAXCLIENTS; c > 0; --c)
            {
                if ( sn_Connections[c].socket )
                {
                    if ( sg_fullscreenMessages.Supported(c) )
                        m->Send(c);
                    else
                        sn_ConsoleOut(complete, c);
                }
            }
        }

        // display the message locally, waiting for the clients to have seen it
        {
            // stop the game
            bool paused = se_mainGameTimer && se_mainGameTimer->speed < .0001;
            se_PauseGameTimer(true);
            gGame::NetSyncIdle();

            REAL waitTo = tSysTimeFloat() + timeout;
            REAL waitToMin = tSysTimeFloat() + 1.0;
            sg_ClientFullscreenMessage( title, message, timeout );

            // wait for players to see it
            bool goon = true;
            while ( goon && waitTo > tSysTimeFloat() )
            {
                sg_FullscreenIdle();
                gameloop_idle();
                if ( se_GameTime() > sg_lastChatBreakTime )
                    se_PauseGameTimer(true);

                // give the clients a second to enter chat state
                if ( tSysTimeFloat() > waitToMin )
                {
                    goon = false;
                    for ( int i = se_PlayerNetIDs.Len()-1; i>=0; --i )
                    {
                        ePlayerNetID* player = se_PlayerNetIDs(i);
                        if ( player->IsChatting() )
                            goon = true;
                    }
                }
            }

            // continue the game
            se_PauseGameTimer(paused);
            gGame::NetSyncIdle();
        }
    }
    else
    {
        if ( sg_fullscreenMessages.Supported(client) )
            m->Send(client);
        else
            sn_ConsoleOut(complete, client);

Here is the call graph for this function:

Here is the caller graph for this function:

gArena* sg_GetArena

(

)

Definition at line 2936 of file gGame.cpp.

                       {
    return &Arena;

void sg_HostGame

(

)

Definition at line 1387 of file gGame.cpp.

References nBasicNetworkSystem::AccessListener(), ePlayerNetID::CompleteRebuild(), con, gServerBrowser::CurrentMaster(), ded_idle, gStats, nSocketListener::Listen(), gGame::NetSyncIdle(), nSERVER, nSTANDALONE, own_game(), uMenu::quickexit, nBasicNetworkSystem::Select(), sg_NumUsers(), sg_TalkToMaster, sg_Timestamp(), sn_BasicNetworkSystem, sn_SetNetState(), sr_Read_stdin(), st_DoToDo(), tAdvanceFrame(), nServerInfo::TellMasterAboutMe(), tNEW, tSysTimeFloat(), and update_settings().

Referenced by main(), and sg_HostGameMenu().

                  {
    //we'll want to collect stats
    gStats = new gStatistics();

    {
        // create a game to check map once
        tJUST_CONTROLLED_PTR< gGame > game = tNEW(gGame);
        game->Verify();
    }

    if (sg_TalkToMaster)
    {
        nServerInfo::TellMasterAboutMe( gServerBrowser::CurrentMaster() );
    }

    sn_SetNetState(nSERVER);

    update_settings();
    ePlayerNetID::CompleteRebuild();

    tAdvanceFrame();

    //#ifndef DEBUG
#ifdef DEDICATED
    static double startTime=tSysTimeFloat();

    if ( sg_NumUsers() == 0)
    {
        cp();
        con << tOutput("$online_activity_napping") << "\n";
        sg_Timestamp();

        int counter = -1;

        int numPlayers = 0;

        while (numPlayers == 0 &&
                (ded_idle<.0001 || tSysTimeFloat()<startTime + ded_idle * 3600 ) && !uMenu::quickexit ){
            sr_Read_stdin();
            st_DoToDo();
            gGame::NetSyncIdle();

            sn_BasicNetworkSystem.Select( 1.0f );

            // std::cout the players who are logged in:
            numPlayers = sg_NumUsers();
            /*
                                for (int i = se_PlayerNetIDs.Len()-1; i>=0; i--)
                                        if (se_PlayerNetIDs(i)->IsAuth())
                                                numPlayers++;
            */

            if (counter <= 0)
            {
                // restart network, just in case we lost the input socket
                sn_BasicNetworkSystem.AccessListener().Listen(false);
                sn_BasicNetworkSystem.AccessListener().Listen(true);
                counter = 50;
            }
        }

        if (sg_NumUsers() <= 0 && ded_idle>0.0001 &&
                tSysTimeFloat()>= startTime + ded_idle * 3600 )
        {
            sg_Timestamp();
            con << "Server exiting due to DEDICATED_IDLE after " << (tSysTimeFloat() - startTime)/3600 << " hours.\n";
            uMenu::quickexit = true;
        }
    }
    cp();

    if (!uMenu::quickexit)
#endif
        //#endif
        own_game( nSERVER );

    sn_SetNetState(nSTANDALONE);

    // close listening sockets
    sn_BasicNetworkSystem.AccessListener().Listen(false);

    //wrap up the stats
    delete gStats;

Here is the call graph for this function:

Here is the caller graph for this function:

void sg_HostGameMenu

(

)

Definition at line 1809 of file gGame.cpp.

References uMenu::Enter(), GameSettingsMP(), gServerBrowser::highPort, gServerBrowser::lowPort, NULL, uMenu::ReverseItems(), uMenu::SetSelected(), sg_HostGame(), sn_serverName, and sn_serverPort.

Referenced by gServerStartMenuItem::Enter().

                      {
    uMenu net_menu("$network_host_text");

    sg_HostMenu = &net_menu;

    uMenuItemInt port(&net_menu, "$network_host_port_text",
                      "$network_host_port_help"
                      ,reinterpret_cast<int &>(sn_serverPort), gServerBrowser::lowPort, gServerBrowser::highPort);

    uMenuItemString serverName
    (&net_menu,"$network_host_name_text",
     "$network_host_name_help",
     sn_serverName);

    uMenuItemFunction settings1
    (&net_menu,
     "$game_settings_menu_text",
     "$game_settings_menu_help",
     &GameSettingsMP);

    uMenuItemFunction serv
    (&net_menu,"$network_host_host_text",
     "$network_host_host_help",&sg_HostGame);

    net_menu.ReverseItems();
    net_menu.SetSelected(0);
    net_menu.Enter();

    sg_HostMenu = NULL;

Here is the call graph for this function:

Here is the caller graph for this function:

void sg_RespawnPlayer	(	eGrid *	grid,
		gArena *	arena,
		ePlayerNetID *	p
	)

Definition at line 2905 of file gGame.cpp.

References eGameObject::Alive(), eWallRim::Bound(), ePlayerNetID::ControlObject(), eGameObject::Direction(), eCoord, gArena::LeastDangerousSpawnPoint(), nCLIENT, ePlayerNetID::Object(), pos, eGameObject::Position(), sg_Timestamp(), sn_GetNetState(), and gSpawnPoint::Spawn().

Referenced by zEffectorSpawnPlayer::effect().

{
    eGameObject *e=p->Object();

    if ( ( !e || !e->Alive()) && sn_GetNetState() != nCLIENT )
    {
        eCoord pos,dir;
        if ( e )
        {
            dir = e->Direction();
            pos = e->Position();
            eWallRim::Bound( pos, 1 );
            eCoord displacement = pos - e->Position();
            if ( displacement.NormSquared() > .01 )
            {
                dir = displacement;
                dir.Normalize();
            }
        }
        else
            arena->LeastDangerousSpawnPoint()->Spawn( pos, dir );
#ifdef DEBUG
        //                std::cout << "spawning player " << pni->name << '\n';
#endif
        gCycle * cycle = new gCycle(grid, pos, dir, p);
        p->ControlObject(cycle);

        sg_Timestamp();
    }

Here is the call graph for this function:

Here is the caller graph for this function:

void update_settings

(

)

Definition at line 903 of file gGame.cpp.

References nMachine::KickSpectators(), multiPlayer, nCLIENT, gGame::NetSyncIdle(), gGame::NoLongerGoOn(), nSTANDALONE, nAuthentication::OnBreak(), REAL, ePlayerNetID::RemoveChatbots(), nBasicNetworkSystem::Select(), sg_copySettings(), sg_NumHumans(), sg_NumUsers(), sg_singlePlayer, singlePlayer, sn_BasicNetworkSystem, sn_CenterMessage(), sn_ConsoleOut(), sn_GetNetState(), sr_Read_stdin(), st_DoToDo(), gGame::StartNewMatch(), eTeam::teams, and tSysTimeFloat().

Referenced by gParser::parseSettings(), sg_HostGame(), singlePlayer_game(), and gGame::StateUpdate().

{
    if (sn_GetNetState()!=nCLIENT)
    {
#ifdef DEDICATED
        // wait for players to join
        {
            bool restarted = false;

            REAL timeout = tSysTimeFloat() + 3.0f;
            while ( sg_NumHumans() <= 0 && sg_NumUsers() > 0 )
            {
                if ( !restarted && bool(sg_currentGame) )
                {
                    sg_currentGame->StartNewMatch();
                    restarted = true;
                }

                if ( tSysTimeFloat() > timeout )
                {
                    tOutput o("$gamestate_wait_players");
                    sn_CenterMessage(o);

                    tOutput o2("$gamestate_wait_players_con");
                    sn_ConsoleOut(o2);

                    timeout = tSysTimeFloat() + 10.0f;

                    // do tasks
                    st_DoToDo();
                    nAuthentication::OnBreak();
                }

                // kick spectators and chatbots
                nMachine::KickSpectators();
                ePlayerNetID::RemoveChatbots();

                // wait for network messages
                sn_BasicNetworkSystem.Select( 0.1f );
                gGame::NetSyncIdle();

                // handle console input
                sr_Read_stdin();
            }
        }

        if ( sg_NumUsers() <= 0 && bool( sg_currentGame ) )
        {
            sg_currentGame->NoLongerGoOn();
        }

        // count the active players
        int humans = sg_NumHumans();

        bool newsg_singlePlayer = (humans<=1);
#else
        bool newsg_singlePlayer = (sn_GetNetState() == nSTANDALONE);
#endif
        if (sg_singlePlayer != newsg_singlePlayer && bool( sg_currentGame ) )
        {
            sg_currentGame->StartNewMatch();
        }
        sg_singlePlayer=newsg_singlePlayer;

        if (sg_singlePlayer)
            sg_currentSettings = &singlePlayer;
        else
            sg_currentSettings = &multiPlayer;

        sg_copySettings();
    }

    // update team properties
    for (int i = eTeam::teams.Len() - 1; i>=0; --i)
        eTeam::teams(i)->UpdateProperties();
}

Here is the call graph for this function:

Here is the caller graph for this function:

---

Variable Documentation

gGameSettings* sg_currentSettings

Definition at line 645 of file gGame.cpp.

Referenced by gCamera::MyInit().

bool sg_TalkToMaster

Definition at line 730 of file gGame.cpp.

Referenced by gServerBrowser::BrowseLAN(), gServerBrowser::BrowseSpecialMaster(), and sg_HostGame().

---