gGame Class Reference

#include <gGame.h>

Inheritance diagram for gGame:

[legend]

Collaboration diagram for gGame:

[legend]

List of all members.

Public Member Functions
	gGame ()
	gGame (nMessage &m)
virtual	~gGame ()
virtual void	WriteSync (nMessage &m)
virtual void	ReadSync (nMessage &m)
virtual nDescriptor &	CreatorDescriptor () const
virtual void	Verify ()
virtual void	StateUpdate ()
virtual void	SetState (unsigned short act, unsigned short next)
virtual short	GetState ()
void	SyncState (unsigned short state)
virtual void	Timestep (REAL time, bool cam=false)
virtual void	Analysis (REAL time)
virtual bool	GameLoop (bool input=true)
bool	GridIsReady (int c)
eGrid *	Grid () const
void	NoLongerGoOn ()
void	StartNewMatch ()
void	StartNewMatchNow ()
Static Public Member Functions
static void	NetSync ()
static void	NetSyncIdle ()
Public Attributes
eSoundMixer *	m_Mixer
Private Member Functions
	tCONTROLLED_PTR (eGrid) grid
void	Init ()
Private Attributes
unsigned short	state
unsigned short	stateNext
tJUST_CONTROLLED_PTR< gZone >	winDeathZone_
bool	goon
int	rounds
double	startTime
int	warning
bool	synced_
	flag indicating whether the game is considered synced
gParser *	aParser

---

Detailed Description

Definition at line 61 of file gGame.h.

---

Constructor & Destructor Documentation

gGame::gGame

(

)

Definition at line 2374 of file gGame.cpp.

References Init(), nCLIENT, nNetObject::RequestSync(), gLogo::SetDisplayed(), sn_GetNetState(), and synced_.

            {
    synced_ = true;
    gLogo::SetDisplayed(false);
    if (sn_GetNetState()!=nCLIENT)
        RequestSync();
    Init();

Here is the call graph for this function:

gGame::gGame

(

nMessage &

m

)

Definition at line 2382 of file gGame.cpp.

References Init(), and synced_.

                       :nNetObject(m){
    synced_ = false;
    Init();

Here is the call graph for this function:

gGame::~gGame

(

)

[virtual]

Definition at line 2388 of file gGame.cpp.

References aParser, exit_game_objects(), tASSERT, and ePlayerNetID::ThrowOutDisconnected().

             {
#ifdef DEBUG
    //con << "deleting game...\n";
#endif
    //stateNext=GS_CREATE_GRID;
    //StateUpdate();

    tASSERT( sg_currentGame != this );

    exit_game_objects(grid);
    grid->Clear();
    ePlayerNetID::ThrowOutDisconnected();

    delete aParser;

Here is the call graph for this function:

---

Member Function Documentation

gGame::tCONTROLLED_PTR

(

eGrid

)

[private]

void gGame::Init

(

void

)

[private]

Definition at line 2279 of file gGame.cpp.

References aParser, eSoundMixer::GetMixer(), goon, GS_CREATED, GS_TRANSFER_SETTINGS, m_Mixer, rounds, StartNewMatchNow(), state, stateNext, and tNEW.

Referenced by gGame().

                {
    m_Mixer = eSoundMixer::GetMixer();
    grid = tNEW(eGrid());
    state=GS_CREATED;
    stateNext=GS_TRANSFER_SETTINGS;
    goon=true;

    sg_currentGame=this;
#ifdef DEBUG
    // con << "Game created.\n";
#endif
    aParser = tNEW(gParser)(&Arena, grid);

    rounds = 0;
    StartNewMatchNow();

Here is the call graph for this function:

Here is the caller graph for this function:

void gGame::WriteSync

(

nMessage &

m

)

[virtual]

Reimplemented from nNetObject.

Definition at line 2405 of file gGame.cpp.

References stateNext, nMessage::Write(), and nNetObject::WriteSync().

                                {
    nNetObject::WriteSync(m);
    m.Write(stateNext);
#ifdef DEBUG
    //con << "Wrote game state " << stateNext << ".\n";
#endif

Here is the call graph for this function:

void gGame::ReadSync

(

nMessage &

m

)

[virtual]

Reimplemented from nNetObject.

Definition at line 2413 of file gGame.cpp.

References con, nMessage::Read(), nNetObject::ReadSync(), sg_AbeforeB(), and stateNext.

                               {
    nNetObject::ReadSync(m);

    unsigned short newState;
    m.Read(newState);

#ifdef DEBUG
    con << "Read gamestate " << newState << ".\n";
#endif

    // only update the state if it does not go back a few steps
    if ( sg_AbeforeB( stateNext, newState ) )
        stateNext = newState;

#ifdef DEBUG
    //con << "Read game state " << stateNext << ".\n";
#endif

Here is the call graph for this function:

nDescriptor & gGame::CreatorDescriptor

(

void

)

const [virtual]

Implements nNetObject.

Definition at line 2274 of file gGame.cpp.

References game_init.

                                           {
    return game_init;

void gGame::NetSync

(

)

[static]

Definition at line 2433 of file gGame.cpp.

References tRecorder::Playback(), ePlayer::PlayerConfig(), uMenu::quickexit, tRecorder::Record(), sg_Receive(), sn_SendPlanned(), sr_glOut, nNetObject::SyncAll(), tAdvanceFrame(), and tERR_ERROR_INT.

Referenced by NetSyncIdle().

                   {
    // find end of recording in playback
    if ( tRecorder::Playback("END") )
    {
        tRecorder::Record("END");
        uMenu::quickexit=true;
    }

#ifdef DEDICATED
    if (!sr_glOut && ePlayer::PlayerConfig(0)->cam)
        tERR_ERROR_INT("Someone messed with the camera!");
#endif
    sg_Receive();
    nNetObject::SyncAll();
    tAdvanceFrame();
    sn_SendPlanned();

Here is the call graph for this function:

Here is the caller graph for this function:

void gGame::NetSyncIdle

(

)

[static]

Definition at line 2451 of file gGame.cpp.

References NetSync(), and sn_Delay().

Referenced by SetState(), sg_FullscreenMessage(), sg_HostGame(), StateUpdate(), SyncState(), and update_settings().

                       {
    NetSync();
    sn_Delay();

Here is the call graph for this function:

Here is the caller graph for this function:

void gGame::Verify

(

)

[virtual]

Definition at line 2366 of file gGame.cpp.

References aParser, exit_game_grid(), init_game_grid(), and sg_ParseMap().

{
    // test map and load map settings
    sg_ParseMap( aParser );
    init_game_grid(grid, aParser);
    exit_game_grid(grid);

Here is the call graph for this function:

void gGame::StateUpdate

(

)

[virtual]

Definition at line 2556 of file gGame.cpp.

References Analysis(), aParser, rConsole::autoDisplayAtNewline, ePlayerNetID::ChatFlags_Away, nNetObject::ClearAllDeleted(), client_gs, con, tDirectories::Config(), exit_game_objects(), rConsole::fullscreen, eGrid::GameObjects(), tRandomizer::Get(), tRandomizer::GetInstance(), goon, Grid(), GS_CAMERA, GS_CREATE_GRID, GS_CREATE_OBJECTS, GS_CREATED, GS_DELETE_GRID, GS_DELETE_OBJECTS, GS_PLAY, GS_SYNCING, GS_TRANSFER_OBJECTS, GS_TRANSFER_SETTINGS, gRotation::HandleNewRound(), init_game_camera(), init_game_grid(), init_game_objects(), init_second_pass_zones(), just_connected, nMachine::KickSpectators(), GrowingArrayBase::Len(), gGameSettings::limitRounds, tConfItemBase::LoadAll(), rITexture::LoadAll(), tConfItemBase::LoadPlayback(), ePlayerNetID::LogScoreDifferences(), MAX_PLAYERS, MAXCLIENTS, nCLIENT, NetSyncIdle(), nSERVER, NULL, nAuthentication::OnBreak(), eGameObject::OnRoundBegin(), ePlayerNetID::RankingLadderLog(), ePlayerNetID::RemoveChatbots(), nNetObject::RequestSync(), rotate(), rotationtype, rounds, nConfItemBase::s_SendConfig(), s_Timestep(), se_ChatState(), se_GameTime(), se_PauseGameTimer(), se_SaveToLadderLog(), se_SaveToScoreFile(), se_sendEventNotification(), se_SyncGameTimer(), se_UserShowScores(), nMessage::Send(), SetState(), tOutput::SetTemplateParameter(), nPingAverager::SetWeight(), sg_AbeforeB(), sg_NumUsers(), sg_ParseMap(), sg_roundCenterMessage, sg_roundConsoleMessage, sg_Timeout, sg_Timestamp(), sg_VoteMenuIdle(), sn_CenterMessage(), sn_Connections, sn_ConsoleOut(), sn_GetNetState(), sn_netObjects, sn_Statistics(), sn_Sync(), sr_con, st_ToDo(), StartNewMatchNow(), state, stateNext, synced_, tAdvanceFrame(), tSysTimeFloat(), ePlayerNetID::Update(), rViewport::Update(), update_settings(), tDirectories::Var(), ePlayerNetID::WaitToLeaveChat(), winDeathZone_, and nMessage::Write().

Referenced by GameLoop().

                       {

    //  if (state==GS_CREATED)
    //          stateNext=GS_CREATE_GRID;

    while ( sg_AbeforeB( state, stateNext ) && goon )
    {
#ifdef CONNECTION_STRESS
        if ( sg_ConnectionStress )
        {
            tRandomizer & randomizer = tRandomizer::GetInstance();
            int random = randomizer.Get( 16 );
            if ( random == 0 )
            {
                sg_RequestedDisconnection = true;
                //                                              sn_SetNetState( nSTANDALONE );
                goon = false;
            }

            se_ChatState( ePlayerNetID::ChatFlags_Away, 1 );
        }
#endif

        // unsigned short int mes1 = 1, mes2 = 1, mes3 = 1, mes4 = 1, mes5 = 1;

        switch (state){
        case GS_DELETE_GRID:
            // sr_con.autoDisplayAtNewline=true;

            con << tOutput("$gamestate_deleting_grid");
            //                          sn_ConsoleOut(sg_roundCenterMessage + "\n");
            sn_CenterMessage(sg_roundCenterMessage);

            //                          for (unsigned short int mycy = 0; mycy > sg_roundConsoleMessage5.Len(); c++)

            exit_game_objects(grid);
            nNetObject::ClearAllDeleted();

            if (goon)
                SetState(GS_TRANSFER_SETTINGS,GS_CREATE_GRID);
            else
                state=GS_CREATE_GRID;
            break;
        case GS_CREATED:
        case GS_TRANSFER_SETTINGS:
            // sr_con.autoDisplayAtNewline=true;

            // transfer game settings
            if ( nCLIENT != sn_GetNetState() )
            {
                update_settings();
                ePlayerNetID::RemoveChatbots();
            }

            rViewport::Update(MAX_PLAYERS);

            // log scores before players get renamed
            ePlayerNetID::LogScoreDifferences();
            se_SaveToLadderLog(tString("NEW_ROUND\n"));
            se_sendEventNotification(tString("New Round"), tString("Starting a new round"));

            // kick spectators
            nMachine::KickSpectators();

            // rename players as per request
            if ( synced_ && sn_GetNetState() != nSERVER )
                ePlayerNetID::Update();

            // delete game objects again (in case new ones were spawned)
            exit_game_objects(grid);

            nConfItemBase::s_SendConfig(false);

            // wait extra long for the clients to delete the grid; they really need to be
            // synced this time
            sn_Sync( sg_Timeout*.4, true );

            SetState(GS_CREATE_GRID,GS_CAMERA);
            break;

        case GS_CREATE_GRID:
            // sr_con.autoDisplayAtNewline=true;

            sg_ParseMap( aParser );

            sn_Statistics();
            sg_Timestamp();

            con << tOutput("$gamestate_creating_grid");

            tAdvanceFrame();

            init_game_grid(grid, aParser);

            nNetObject::ClearAllDeleted();

            SetState(GS_CREATE_OBJECTS,GS_CAMERA);
            break;
        case GS_CREATE_OBJECTS:
            // con << "Creating objects...\n";

            lastdeath = -100;
            roundOver = false;

            // rename players as per request
            if ( synced_ )
                ePlayerNetID::Update();

            init_game_objects(grid);

            ePlayerNetID::RankingLadderLog();

            // do round begin stuff
            {
                const tList<eGameObject>& gameObjects = Grid()->GameObjects();
                for (int i=gameObjects.Len()-1;i>=0;i--)
                {
                    eGameObject * e = gameObjects(i);
                    if ( e )
                    {
                        e->OnRoundBegin();
                    }
                }
            }

            // do the first analysis of the round, now is the time to get it used to the number of teams
            Analysis( -1000 );

            s_Timestep(grid, se_GameTime(), false);
            SetState(GS_TRANSFER_OBJECTS,GS_CAMERA);

            if (sn_GetNetState() == nCLIENT && just_connected){
                sn_Sync(sg_Timeout*.1,true);
                sn_Sync(sg_Timeout*.1,true);
            }
            just_connected=false;

#ifdef ENABLE_ZONESV2
            init_second_pass_zones(grid, aParser);
#endif
            break;
        case GS_TRANSFER_OBJECTS:
            // con << "Transferring objects...\n";
            rITexture::LoadAll();
            // se_ResetGameTimer();
            // se_PauseGameTimer(true);


            // push all data
            if (sn_GetNetState()==nSERVER){
                bool goon=true;
                double timeout=tSysTimeFloat()+sg_Timeout*.4;
                while (goon && tSysTimeFloat()<timeout){
                    NetSyncIdle();
                    goon=false;
                    for (int i=MAXCLIENTS;i>0;i--)
                        if (sn_Connections[i].socket)
                            for (int j=sn_netObjects.Len()-1;j>=0;j--)
                                if (sn_netObjects(j) &&
                                        !sn_netObjects(j)->HasBeenTransmitted(i) &&
                                        sn_netObjects(j)->syncRequested(i))
                                    goon=true;
                }
                if (tSysTimeFloat()<timeout)
                    con << tOutput("$gamestate_done");
                else{
                    con << tOutput("$gamestate_timeout_intro");
                    for (int i=MAXCLIENTS;i>0;i--)
                        if (sn_Connections[i].socket)
                            for (int j=sn_netObjects.Len()-1;j>=0;j--)
                                if (sn_netObjects(j) && !sn_netObjects(j)->HasBeenTransmitted(i))
                                {
                                    tOutput o;
                                    tString name;
                                    sn_netObjects(j)->PrintName( name );
                                    o.SetTemplateParameter(1, i);
                                    o.SetTemplateParameter(2, j);
                                    o.SetTemplateParameter(3, name);
                                    o << "$gamestate_timeout_message";
                                    con << o;
                                }
                    con << "\n\n\n";
                }
            }

            // wait for players to ready
            if ( sn_GetNetState() == nSERVER )
                while ( ePlayerNetID::WaitToLeaveChat() )
                {
                    NetSyncIdle();
                    se_SyncGameTimer();
                }

            SetState(GS_CAMERA,GS_SYNCING);
            break;
        case GS_CAMERA:
            // con << "Setting camera position...\n";
            rITexture::LoadAll();
            // se_ResetGameTimer(-PREPARE_TIME);
            // se_PauseGameTimer(true);
            init_game_camera(grid);
            SetState(GS_SYNCING,GS_PLAY);
            break;
        case GS_SYNCING:
            // con << "Syncing timer...\n";
            rITexture::LoadAll();
            SetState(GS_PLAY,GS_PLAY);
            if (sn_GetNetState()!=nCLIENT){
                if (rounds<=0){
                    sn_ConsoleOut("$gamestate_resetnow_console");
                    StartNewMatchNow();
                    sn_CenterMessage("$gamestate_resetnow_center");
                    se_SaveToScoreFile("$gamestate_resetnow_log");
                }

                tOutput mess;
                if (rounds < sg_currentSettings->limitRounds)
                {
                    mess.SetTemplateParameter(1, rounds+1);
                    mess.SetTemplateParameter(2, sg_currentSettings->limitRounds);
                    mess << "$gamestate_newround_console";

                    if (strlen(sg_roundConsoleMessage) > 2)
                        sn_ConsoleOut(sg_roundConsoleMessage + "\n");
                }
                else
                    mess << "$gamestate_newround_goldengoal";
                sn_ConsoleOut(mess);

                se_SaveToScoreFile("$gamestate_newround_log");
            }
            //con << ePlayerNetID::Ranking();

            se_PauseGameTimer(false);
            se_SyncGameTimer();
            sr_con.fullscreen=false;
            sr_con.autoDisplayAtNewline=false;

            break;
        case GS_PLAY:
            sr_con.autoDisplayAtNewline=false;
#ifdef DEDICATED
            {
                // safe current players in a file
                cp();

                if ( sg_NumUsers() <= 0 )
                    goon = 0;

                Analysis(0);

                {
                    std::ifstream s;

                    // load contents of everytime.cfg for real
                    if ( tDirectories::Config().Open(s, "everytime.cfg" ) )
                        tConfItemBase::LoadAll(s);

                    s.close();

                    if ( tDirectories::Var().Open(s, "everytime.cfg" ) )
                        tConfItemBase::LoadAll(s);

                    // load contents of everytime.cfg from playback
                    tConfItemBase::LoadPlayback();
                }
            }
#endif
            // pings should not count as much in the between-round phase
            nPingAverager::SetWeight(1E-20);

            se_UserShowScores(false);

            // rotate, if rotate is once per round
            if (rotationtype == 1)
                rotate();
            gRotation::HandleNewRound();

            //con.autoDisplayAtNewline=true;
            sr_con.fullscreen=true;
            SetState(GS_DELETE_OBJECTS,GS_DELETE_GRID);
            break;
        case GS_DELETE_OBJECTS:

            winDeathZone_ = NULL;

            rViewport::Update(MAX_PLAYERS);
            if ( synced_ && sn_GetNetState() != nSERVER )
                ePlayerNetID::Update();

            // sr_con.autoDisplayAtNewline=true;

            //gStatistics - save all

            con << tOutput("$gamestate_deleting_objects");
            exit_game_objects(grid);
            st_ToDo( sg_VoteMenuIdle );
            nNetObject::ClearAllDeleted();
            SetState(GS_DELETE_GRID,GS_TRANSFER_SETTINGS);
            break;
        default:
            break;
        }

        // now would be a good time to tend for pending tasks
        nAuthentication::OnBreak();

        if (sn_GetNetState()==nSERVER){
            NetSyncIdle();
            RequestSync();
            NetSyncIdle();
        }
        else if (sn_GetNetState()==nCLIENT){ // inform the server of our progress
            NetSyncIdle();
            nMessage *m=new nMessage(client_gs);
            m->Write(state);
            m->Send(0);
#ifdef DEBUG
            //                  con << "sending gamestate " << state << '\n';
#endif
            NetSyncIdle();
        }
    }

Here is the caller graph for this function:

void gGame::SetState	(	unsigned short	act,
		unsigned short	next
	)			[virtual]

Definition at line 2513 of file gGame.cpp.

References goon, nCLIENT, NetSyncIdle(), nSERVER, nNetObject::RequestSync(), sn_GetNetState(), state, stateNext, and SyncState().

Referenced by Analysis(), and StateUpdate().

                                                          {
    state=act;
#ifdef DEBUG
    //con << "Entering gamestate " << state
    //<< ", next state: " << next << '\n';
#endif

    if (sn_GetNetState()==nSERVER){
        RequestSync();
        NetSyncIdle();
        SyncState(state);
    }

    if (stateNext!=next){
        if (sn_GetNetState()!=nCLIENT || goon==false){

            stateNext=next;

            if (sn_GetNetState()==nSERVER){
                RequestSync();
                NetSyncIdle();
            }
        }
    }

Here is the call graph for this function:

Here is the caller graph for this function:

virtual short gGame::GetState

(

)

[inline, virtual]

Definition at line 104 of file gGame.h.

References state.

Referenced by ingame_menu_cleanup().

{return state;}

Here is the caller graph for this function:

void gGame::SyncState

(

unsigned short

state

)

Definition at line 2471 of file gGame.cpp.

References nConnectionInfo::ackPending, con, goon, MAXCLIENTS, NetSyncIdle(), nSERVER, REAL, sg_AbeforeB(), sg_Timeout, sn_Connections, sn_GetNetState(), sn_Sync(), and tSysTimeFloat().

Referenced by SetState().

                                         {
    if (sn_GetNetState()==nSERVER){

        bool firsttime=true;
        bool goon=true;
        REAL timeout=tSysTimeFloat()+sg_Timeout*.1;

        sn_Sync(sg_Timeout*.1,true);
        NetSyncIdle();

        while (goon && tSysTimeFloat()<timeout){
            /*
              if (sg_currentGame)
              sg_currentGame->RequestSync();
            */

            sn_Sync(sg_Timeout*.1,true);
            NetSyncIdle();

            goon=false;
            for (int i=MAXCLIENTS;i>0;i--)
                if ( sn_Connections[i].socket )
                {
                    int clientState = client_gamestate[i];
                    if ( sg_AbeforeB( clientState, state ) )
                    {
                        goon=true;
                    }
                }
            if (goon && firsttime){
                firsttime=false;
#ifdef DEBUG
                con << "Waiting for users to enter gamestate " << state << '\n';
                if (sn_Connections[1].ackPending>2)
                    con << "Ack_pending=" << sn_Connections[1].ackPending << ".\n";
#endif
            }
        }
    }

Here is the call graph for this function:

Here is the caller graph for this function:

void gGame::Timestep	(	REAL	time,
		bool	cam = false
	)			[virtual]

Definition at line 2946 of file gGame.cpp.

References tMemManBase::Check(), dt, lastTimeTimestep, REAL, and s_Timestep().

Referenced by GameLoop().

                                      {
#ifdef DEBUG
    tMemManBase::Check();
#endif

#ifdef RESPAWN_HACK
    sg_Respawn(time,grid,Arena);
#endif

    // chop timestep into small, managable bits
    REAL dt = time - lastTimeTimestep;
    if ( dt < 0 )
        return;
    REAL lt = lastTimeTimestep;

    // determine the number of bits
    int number_of_steps=int(fabs((dt)/sg_timestepMax));
    if (number_of_steps<1)
        number_of_steps=1;
    if ( number_of_steps > sg_timestepMaxCount )
    {
        number_of_steps = sg_timestepMaxCount;
    }

    // chop
    for (int i=1;i<=number_of_steps;i++)
    {
        REAL stepTime = lt + i * dt/number_of_steps;
        s_Timestep(grid, stepTime, cam);
    }

Here is the call graph for this function:

Here is the caller graph for this function:

void gGame::Analysis

(

REAL

time

)

[virtual]

Definition at line 2994 of file gGame.cpp.

References absolute_winner, gStatList::add(), gCycleMovement::Alive(), eTeam::Alive(), gGameSettings::AutoAI(), tColoredString::ColorString(), eGameObject::DeathTime(), DEDICATED, dt, ePlayerNetID::FilterName(), gGameSettings::finishType, eGrid::GameObjects(), gGameSettings::gameType, ePlayerNetID::GetName(), gArena::GetRandomPos(), gFINISH_EXPRESS, gFINISH_IMMEDIATELY, gFINISH_SPEEDUP, gFREESTYLE, goon, gStatList::greater(), Grid(), GS_DELETE_OBJECTS, GS_PLAY, gStats, gRotation::HandleNewMatch(), gStatistics::highscores, ePlayerNetID::IsActive(), ePlayerNetID::IsHuman(), gCycle::Kill(), GrowingArrayBase::Len(), gGameSettings::limitRounds, gGameSettings::limitScore, gGameSettings::limitTime, m_Mixer, MATCH_WINNER, nCLIENT, eTeam::NumAIPlayers(), eTeam::NumHumanPlayers(), eTeam::NumPlayers(), ePlayerNetID::Object(), eGameObject::OnRoundEnd(), eTeam::Player(), players, eSoundMixer::PushButton(), ePlayerNetID::Ranking(), eTeam::Ranking(), REAL, rotate(), rotationtype, ROUND_WINNER, rounds, gGameSettings::scoreWin, se_mainGameTimer, se_PlayerNetIDs, se_SaveToLadderLog(), se_SaveToScoreFile(), se_sendEventNotification(), SetState(), tOutput::SetTemplateParameter(), sg_CreateWinDeathZone(), sg_EnemyExists(), sg_GetCurrentTime(), sg_NumUsers(), sg_singlePlayer, sn_CenterMessage(), sn_ConsoleOut(), sn_GetNetState(), eTeam::SortByScore(), ePlayerNetID::SortByScore(), eTimer::speed, StartNewMatch(), StartNewMatchNow(), startTime, nVersionFeature::Supported(), eTeam::teams, tSysTimeFloat(), warning, winDeathZone_, winner, gGameSettings::winZoneMinLastDeath, gGameSettings::winZoneMinRoundTime, wishWinner, wishWinnerMessage, gStatistics::won_matches, and gStatistics::won_rounds.

Referenced by GameLoop(), and StateUpdate().

                             {
    if ( nCLIENT == sn_GetNetState() )
        return;

    static REAL wintimer=0;

    // only do this expensive stuff once a second
    {
        static double nextTime = -1;
        if ( tSysTimeFloat() > nextTime || time < -10 )
        {
            nextTime = tSysTimeFloat() + 1.0;
        }
        else
        {
            return;
        }
    }

    // send timeout warnings


    if (tSysTimeFloat()-startTime>10){
        if ((startTime+sg_currentSettings->limitTime*60)-tSysTimeFloat()<10 && warning<6){
            tOutput o("$gamestate_tensecond_warn");
            sn_CenterMessage(o);
            sn_ConsoleOut(o);
            warning=6;
        }


        if ((startTime+sg_currentSettings->limitTime*60)-tSysTimeFloat()<30 && warning<5){
            tOutput o("$gamestate_30seconds_warn");
            sn_CenterMessage(o);
            sn_ConsoleOut(o);
            warning=5;
        }

        if ((startTime+sg_currentSettings->limitTime*60)-tSysTimeFloat()<60 && warning<4){
            tOutput o("$gamestate_minute_warn");
            sn_CenterMessage(o);
            sn_ConsoleOut(o);
            warning=4;
        }

        if ((startTime+sg_currentSettings->limitTime*60)-tSysTimeFloat()<2*60 && warning<3){
            tOutput o("$gamestate_2minutes_warn");
            sn_ConsoleOut(o);
            warning=3;
        }

        if ((startTime+sg_currentSettings->limitTime*60)-tSysTimeFloat()<5*60 && warning<2){
            tOutput o("$gamestate_5minutes_warn");
            sn_ConsoleOut(o);
            warning=2;
        }

        if ((startTime+sg_currentSettings->limitTime*60)-tSysTimeFloat()<10*60 && warning<1){
            tOutput o("$gamestate_10minutes_warn");
            sn_ConsoleOut(o);
            warning=1;
        }
    }

    // count active players
    int active = 0;
    int i;
    for (i=se_PlayerNetIDs.Len()-1;i>=0;i--){
        ePlayerNetID *pni=se_PlayerNetIDs(i);
        if (pni->IsActive())
            active ++;
    }

    // count other statistics
    int alive_and_not_disconnected = 0;
    int alive=0;
    int ai_alive=0;
    int human_teams=0;
    int teams_alive=0;
    int last_alive=-1;
    int last_team_alive=-1;
    int last_alive_and_not_disconnected=-1;
    int humans = 0;
    int active_humans = 0;
    int ais    = 0;
    REAL deathTime=0;

    bool notyetloggedin = true;  // are all current users not yet logged in?

    for (i=eTeam::teams.Len()-1;i>=0;i--){
        eTeam *t = eTeam::teams(i);

        humans += t->NumHumanPlayers();
        ais    += t->NumAIPlayers();

        if ( t->Alive() )
        {
            teams_alive++;
            last_team_alive = i;
        }

        if ( t->NumHumanPlayers() > 0 )
        { // human players
            human_teams++;

            for (int j=t->NumPlayers()-1; j>=0; --j)
            {
                ePlayerNetID* p = t->Player(j);
                if (p->IsActive())
                    active_humans++;

                gCycle *g=dynamic_cast<gCycle *>(p->Object());
                if (g){
                    notyetloggedin = false;

                    if (g->Alive())
                    {

                        if ( p->IsHuman() )
                        {
                            alive++;
                            if (p->IsActive())
                            {
                                last_alive_and_not_disconnected=i;
                                alive_and_not_disconnected++;
                            }
                        }
                        else
                            ai_alive++;

                        last_alive=i;
                    }
                    else
                    {
                        REAL dt=g->DeathTime();
                        if (dt>deathTime)
                            deathTime=dt;
                    }
                }
#ifdef KRAWALL_SERVER
                else if (p->IsAuthenticated())
                    notyetloggedin = false;
#endif
            }
        }
        else
        {
            for (int j=t->NumPlayers()-1; j>=0; --j)
            {
                ePlayerNetID* p = t->Player(j);

                gCycle *g=dynamic_cast<gCycle *>(p->Object());
                if (g){
                    if (g->Alive())
                    {
                        ai_alive++;
                    }
                }
            }
        }
    }

#ifdef DEDICATED
    //activeHumans
    if (sg_NumUsers() <= 0)
        goon = false;
#endif


    if (last_alive_and_not_disconnected >= 0)
        last_alive = last_alive_and_not_disconnected;

    // kill all disconnected players if they are the only reason the round goes on:
    if ( alive_and_not_disconnected <= 1 && alive > alive_and_not_disconnected )
    {
        for (int i=se_PlayerNetIDs.Len()-1;i>=0;i--)
        {
            gCycle *g=dynamic_cast<gCycle *>(se_PlayerNetIDs(i)->Object());
            if (g && !se_PlayerNetIDs(i)->IsActive())
            {
                g->Kill();
            }

            //                  alive = alive_and_not_disconnected;
        }
    }

    // keep the game running when there are only login processes running
    if (notyetloggedin && humans > 0)
        alive++;


    static int all_alive_last=0;
    {
        int all_alive = ai_alive+alive;
        if (all_alive != all_alive_last)
        {
            all_alive_last = ai_alive+alive;
            lastdeath = time;
        }
    }

    static nVersionFeature winZone(2);

    /*
    ***************** ===================== ********************
    HACK
    THIS HAS SIMPLY BEEN DEACTIVATED.
    IT SHOULD BE REACTIVATED WITH THE NEW ZONE CODE
    ***************** ===================== ********************
    */
#ifndef ENABLE_ZONESV2
    // activate instant win zone
    if ( winZone.Supported() && !bool( winDeathZone_ ) && winner == 0 && time - lastdeath > sg_currentSettings->winZoneMinLastDeath && time > sg_currentSettings->winZoneMinRoundTime )
    {
        winDeathZone_ = sg_CreateWinDeathZone( grid, Arena.GetRandomPos( sg_winZoneRandomness ) );
    }
#endif

    bool holdBackNextRound = false;

    // start a new match if the number of teams changes from 1 to 2 or from 2 to 1
    {
        static int lastTeams = 0; // the number of teams when this was last called.

        // check for relevent status change, form 0 to 1 or 1 to 2 or 2 to 1 or 1 to 0 human teams.
        int humanTeamsClamp = human_teams;
        if ( humanTeamsClamp > 2 )
            humanTeamsClamp = 2;
        if ( humanTeamsClamp != lastTeams )
        {
            StartNewMatch();
            // if this is the beginning of a round, just start the match now
            if ( time < -100 )
            {
                StartNewMatchNow();
            }
            else
            {
                // start a new round and match.
                winner=-1;
                wintimer=time;
            }
        }

        lastTeams=humanTeamsClamp; // update last team count
    }

    // who is alive?
    if ( time-lastdeath < 1.0f )
    {
        holdBackNextRound = true;
    }
    else if (winner==0 && absolute_winner==0 ){
        if ( teams_alive <= 1 )
        {
            if ( sg_currentSettings->gameType!=gFREESTYLE )
            {
                if ( eTeam::teams.Len()>1 && teams_alive<=1 ){
                    winner=last_team_alive+1;
                    wintimer=time;
                }
            }
            else
            {
                if ( teams_alive < 1 )
                    winner=-1;
                wintimer=time;
            }
        }

        const char* survivor="$player_win_survivor";
        const char* messagetype = survivor;

        if ( wishWinner )
        {
            wintimer=time;
            winner = wishWinner;
            wishWinner = 0;
            messagetype = wishWinnerMessage;
        }

        if (winner <= 0 && alive <= 0 && ai_alive <= 0 && teams_alive <= 0){
            if ( se_mainGameTimer )
                se_mainGameTimer->speed = 1;

            // emergency
            winner=-1;
            wintimer=time;
        }
        else
            if (winner){
                if ( se_mainGameTimer )
                    se_mainGameTimer->speed = 1;
                lastdeath = time;

                tOutput message;
                message << "$gamestate_winner_winner";

                if ( last_team_alive >= 0 )
                    sg_currentSettings->AutoAI( eTeam::teams( last_team_alive )->NumHumanPlayers() > 0 );


                if ( ( sg_currentSettings->scoreWin != 0 || sg_currentSettings->gameType != gFREESTYLE ) && winner > 0 )
                {
                    // check if the win was legitimate: at least one enemy team needs to be online
                    if ( sg_EnemyExists( winner-1 ) || sg_currentSettings->gameType==gFREESTYLE )
                    {
#ifdef KRAWALL_SERVER_LEAGUE
                        // send the result to the master server
                        if (!dynamic_cast<gAIPlayer*>(eTeam::teams(winner-1)))
                        {
                            tArray<tString> players;
                            for (int i = eTeam::teams.Len()-1; i>=0; i--)
                                if (i != winner-1 &&
                                        eTeam::teams(i)->Alive() &&
                                        eTeam::teams(i)->IsHuman() )
                                {
                                    players[players.Len()] = eTeam::teams(i)->Name();
                                }

                            players[players.Len()] = eTeam::teams(winner-1)->Name();
                            if (players.Len() > 1)
                                nKrawall::ServerRoundEnd(&players(0), players.Len());
                        }
#endif

                        // scoring
                        eTeam::teams[winner-1]->AddScore
                        (sg_currentSettings->scoreWin,messagetype, tOutput());
                        if (!sg_singlePlayer && eTeam::teams(winner-1)->NumHumanPlayers() >= 1 && gStats &&
                                eTeam::teams(winner-1)->NumPlayers() >= 1 && eTeam::teams[winner-1]->NumHumanPlayers() > 0)
                        {
                            //gStatistics - won rounds add
                            for (int i = eTeam::teams[winner-1]->NumPlayers() - 1; i>=0; --i) //count down in case of mid count changes?
                            {
                                if (eTeam::teams[winner-1]->Player(i)->IsHuman())
                                {
                                    gStats->won_rounds->add(eTeam::teams[winner-1]->Player(i)->GetName(), 1);
                                }
                            }
                            //gStatistics - ladder add
                        }

                        // print winning message
                        tOutput message;
                        message << "$gamestate_winner_winner";
                        message << eTeam::teams[winner-1]->Name();

                        m_Mixer->PushButton(ROUND_WINNER);

                        sn_CenterMessage(message);
                        message << '\n';
                        se_SaveToScoreFile(message);

                        tString ladderLog;
                        ladderLog << "ROUND_WINNER " << ePlayerNetID::FilterName( eTeam::teams[winner-1]->Name() ) << "\n";
                        se_SaveToLadderLog( ladderLog );
                        tString notificationMessage( ePlayerNetID::FilterName( eTeam::teams[winner-1]->Name() ) );
                        notificationMessage << " has won the round";
                        se_sendEventNotification(tString("Round winner"), notificationMessage);
                    }
                }
                //gStatistics - highscore check
                if (sg_singlePlayer && gStats && se_PlayerNetIDs.Len() > 0 && se_PlayerNetIDs(0)->IsHuman())
                {
                    gStats->highscores->greater(se_PlayerNetIDs(0)->GetName(), se_PlayerNetIDs(0)->Score());
                }
                winner = -1;
            }
    }

    int winnerExtraRound = ( winner != 0 || alive == 0 ) ? 1 : 0;


    // do round end stuff one second after a winner was declared
    if ( winner && !roundOver && time-lastdeath >= 2.0f )
    {
        roundOver = true;

        const tList<eGameObject>& gameObjects = Grid()->GameObjects();
        for (int i=gameObjects.Len()-1;i>=0;i--)
        {
            eGameObject * e = gameObjects(i);
            if ( e )
            {
                e->OnRoundEnd();
            }
        }
    }

    // analyze the ranking list
    if ( time-lastdeath < 2.0f )
    {
        holdBackNextRound = true;
    }
    else if (absolute_winner==0 &&
             sn_GetNetState()!=nCLIENT && se_PlayerNetIDs.Len()){
        ePlayerNetID::SortByScore();
        eTeam::SortByScore();
        if ( eTeam::teams.Len() > 0 )
            if (eTeam::teams.Len() <= 1
                    || ( eTeam::teams(0)->Score() > eTeam::teams(1)->Score() && sg_EnemyExists(0))){

                // only then we can have a true winner:
                if (eTeam::teams(0)->Score() >= sg_currentSettings->limitScore ||               // the score limit must be hit
                        rounds + winnerExtraRound >= sg_currentSettings->limitRounds ||     // or the round limit
                        tSysTimeFloat()>=startTime+sg_currentSettings->limitTime*60 ||      // or the time limit
                        (active <= 1 && eTeam::teams.Len() > 1)                                                         // or all but one players must have disconnected.
                   )
                {
                    bool declareChampion = true;
                    if ( winner!=0 && wintimer > time - ( sg_currentSettings->finishType==gFINISH_EXPRESS ? 2.0f : 4.0 ) )
                    {
                        declareChampion = false;
                        holdBackNextRound= true;
                    }

                    if ( declareChampion )
                    {
                        lastdeath = time + ( sg_currentSettings->finishType==gFINISH_EXPRESS ? 2.0f : 6.0f );

                        {
                            tOutput message;
                            message.SetTemplateParameter(1, eTeam::teams[0]->Name() );
                            message << "$gamestate_champ_center";
                            sn_CenterMessage(message);

                            m_Mixer->PushButton(MATCH_WINNER);
                        }

                        tOutput message;
                        tColoredString name;
                        name << eTeam::teams[0]->Name();
                        name << tColoredString::ColorString(1,1,1);

                        tString ladderLog;
                        ladderLog << "MATCH_WINNER " << ePlayerNetID::FilterName( eTeam::teams[0]->Name() ) << "\n";
                        se_SaveToLadderLog( ladderLog );
                        tString notificationMessage( ePlayerNetID::FilterName( eTeam::teams[0]->Name() ) );
                        notificationMessage << " has won the match";
                        se_sendEventNotification(tString("Match winner"), notificationMessage);


                        message.SetTemplateParameter(1, name);
                        message << "$gamestate_champ_console";

                        if (eTeam::teams(0)->Score() >=sg_currentSettings->limitScore)
                        {
                            message.SetTemplateParameter(1, eTeam::teams(0)->Score());
                            message.SetTemplateParameter(2, sg_currentSettings->limitScore);
                            message << "$gamestate_champ_scorehit";
                        }
                        else if ( tSysTimeFloat()>=startTime+sg_currentSettings->limitTime*60)
                        {
                            message.SetTemplateParameter(1, sg_currentSettings->limitTime);
                            message << "$gamestate_champ_timehit";
                        }
                        else
                        {
                            message.SetTemplateParameter(1, rounds + 1);
                            message << "$gamestate_champ_default";
                        }

                        se_SaveToScoreFile(message);
                        se_SaveToScoreFile("$gamestate_champ_finalscores");
                        se_SaveToScoreFile(eTeam::Ranking( -1, false ));
                        se_SaveToScoreFile(ePlayerNetID::Ranking( -1, false ));
                        se_SaveToScoreFile(sg_GetCurrentTime( "Time: %Y/%m/%d %H:%M:%S\n" ));
                        se_SaveToScoreFile("\n\n");

                        eTeam* winningTeam = eTeam::teams(0);
                        if (!sg_singlePlayer && winningTeam->NumHumanPlayers() > 0 && winningTeam->NumHumanPlayers() > 0 && gStats)
                        {
                            //gStatistics - won matches add
                            for (int i = winningTeam->NumPlayers() - 1; i>=0; --i) //count down in case of mid count changes?
                            {
                                if (winningTeam->Player(i)->IsHuman())
                                {
                                    gStats->won_matches->add(winningTeam->Player(i)->GetName(), 1);
                                }
                            }
                        }

                        sn_ConsoleOut(message);

                        m_Mixer->PushButton(MATCH_WINNER);

                        wintimer=time;
                        absolute_winner=1;

                        if ( se_mainGameTimer )
                            se_mainGameTimer->speed = 1;

                        //check for map rotation, new match...
                        if (rotationtype == 2)
                            rotate();

                        gRotation::HandleNewMatch();

                        StartNewMatch();
                    }
                }
            }
    }


    // time to wait after last death til we start a new round
    REAL fintime=6;

    if (sg_currentSettings->finishType==gFINISH_EXPRESS)
        fintime=2.5;

    if (( ( winner || absolute_winner ) && wintimer+fintime < time)
            || (((alive==0 && eTeam::teams.Len()>=
#ifndef DEDICATED
                  1
#else
                  0
#endif
                 )) && time-lastdeath >fintime-2
#ifndef DEDICATED
                && humans > 0
#endif
               )){
#ifdef DEBUG
        //con << "winner=" << winner << ' ';
        //con << "wintimer=" << wintimer << ' ';
        //con << "time=" << time << ' ';
        //con << "dt=" << deathTime << '\n';
#endif
        if (!holdBackNextRound &&
                (
                    ( sg_currentSettings->finishType==gFINISH_IMMEDIATELY ||
                      sg_currentSettings->finishType==gFINISH_EXPRESS ||
                      absolute_winner || ( teams_alive <= 1 && time-lastdeath>4.0f ) ) ||
                    ( winner && time - wintimer> 4.0f )
                )
           )
        {
            rounds++;
            SetState(GS_PLAY,GS_DELETE_OBJECTS);
        }

        if ( !winner && !absolute_winner && sg_currentSettings->finishType==gFINISH_SPEEDUP && se_mainGameTimer)
        {
            se_mainGameTimer->speed*=1.01;
            if (se_mainGameTimer->speed>16)
                se_mainGameTimer->speed=16;
        }

Here is the call graph for this function:

Here is the caller graph for this function:

bool gGame::GameLoop

(

bool

input = true

)

[virtual]

Definition at line 3643 of file gGame.cpp.

References ai, Analysis(), ANNOUNCER_1, ANNOUNCER_2, ANNOUNCER_3, ANNOUNCER_GO, cd, tConsole::CenterDisplay(), eGrid::Check(), rSysDep::ClearGL(), con, tRandomizer::Get(), tRandomizer::GetInstance(), goon, GS_CREATE_GRID, GS_DELETE_OBJECTS, GS_PLAY, ingame_menu(), eTimer::IsSynced(), lastTime, lastTime_gameloop, GrowingArrayBase::Len(), m_Mixer, MAX_PLAYERS, nCLIENT, nSERVER, nSTANDALONE, ePlayerNetID::Object(), ePlayer::PlayerConfig(), PREPARE_TIME, eSoundMixer::PushButton(), REAL, Render(), eCamera::s_Timestep(), se_GameTime(), se_mainGameTimer, se_PauseGameTimer(), se_PlayerNetIDs, se_SaveToLadderLog(), se_SyncGameTimer(), ePlayer::SendAuthNames(), nPingAverager::SetWeight(), sg_gameTimeInterval, sg_lastChatBreakTime, sg_Receive(), eGrid::SimplifyAll(), sn_GetNetState(), sn_SendPlanned(), sr_glOut, st_Breakpoint(), st_ToDo(), state, stateNext, su_GetSDLInput(), su_HandleDelayedEvents(), su_HandleEvent(), su_InputSync(), rSysDep::SwapGL(), nNetObject::SyncAll(), synced_, tDelay(), gAIPlayer::Timestep(), Timestep(), ePlayerNetID::Update(), and ePlayerNetID::WaitToLeaveChat().

Referenced by GameLoop().

                              {
    nNetState netstate = sn_GetNetState();

#ifdef DEBUG
    grid->Check();
    if (simplify_grid)
#endif
        grid->SimplifyAll(10);

#ifdef DEBUG
    grid->Check();
#endif

    //if (std::cin.good() && !std::cin.underflow())
    //tConfItemBase::LoadAll(std::cin);
    // network syncing
    REAL gtime=0;
    REAL time=0;
    se_SyncGameTimer();
    if (state==GS_PLAY){
        if ( netstate != sn_GetNetState() )
        {
            return false;
        }
        gtime=se_GameTime();
        time=gtime;

        if (sn_GetNetState()==nSTANDALONE && sg_IngameMenu)
            se_PauseGameTimer(true);

        static int lastcountdown=0;
        int cd=int(floor(-time))+1;
        if (cd>=0 && cd<PREPARE_TIME && cd!=lastcountdown && se_mainGameTimer && se_mainGameTimer->IsSynced() ){
            lastcountdown=cd;
            tString s;
            s << cd;

            switch (cd) {
            case 3:
                m_Mixer->PushButton(ANNOUNCER_3);
                break;
            case 2:
                m_Mixer->PushButton(ANNOUNCER_2);
                break;
            case 1:
                m_Mixer->PushButton(ANNOUNCER_1);
                break;
            case 0:
                m_Mixer->PushButton(ANNOUNCER_GO);
                break;
            }
            con.CenterDisplay(s,0);
        }
    }
    //con << sg_netPlayerWalls.Len() << '\n';

#ifndef DEDICATED
    if (input){
        su_HandleDelayedEvents();

        SDL_Event tEvent;

        uInputProcessGuard inputProcessGuard;
        while (su_GetSDLInput(tEvent,time)){
            if (time>gtime) time=gtime;
            if (time>lastTime_gameloop){
                Timestep(time);
                lastTime_gameloop=time;
            }


            if (!su_HandleEvent(tEvent, false))
                switch (tEvent.type){
                case SDL_MOUSEBUTTONDOWN:
                    break;
                case SDL_KEYDOWN:
                    switch (tEvent.key.keysym.sym){

                    case(27):
                                    //                                case('q'):
                                    st_ToDo(&ingame_menu);
                        break;
#ifdef DEBUG
                    case('d'):
                                    debug_grid=!debug_grid;
                        break;

                    case('a'):
                                    simplify_grid=!simplify_grid;
                        break;

                    case('l'):
                                    sr_glOut=!sr_glOut;
                        break;

                    case('b'):
                                    st_Breakpoint();
                        break;

                    case('t'):
                                    think=!think;
                        break;
                        /* #ifndef WIN32
                           case('f'):
                           fullscreen=(!fullscreen);
                           con << fullscreen << "x!\n";
                           XMesaSetFXmode(fullscreen ? XMESA_FX_FULLSCREEN : XMESA_FX_WINDOW);
                           break;
                           #endif */
#endif

                    default:
                        break;
                    }
                    break;

                default:
                    break;
                }
        }

        su_InputSync();
    }
#endif

    if ( netstate != sn_GetNetState() )
    {
        return false;
    }

    // do basic network receiving and sending. This pushes out all input the player makes as fast as possible.
    sg_Receive();
    sn_SendPlanned();

    bool synced = se_mainGameTimer && ( se_mainGameTimer->IsSynced() || ( stateNext >= GS_DELETE_OBJECTS || stateNext <= GS_CREATE_GRID ) );

    if  (!synced)
    {
        // see if there is a game object owned by this client, if so, declare emergency sync
        for (int pi = MAX_PLAYERS-1; pi >= 0; --pi )
        {
            ePlayer * p = ePlayer::PlayerConfig(pi);
            if ( !p )
                break;
            ePlayerNetID * np = p->netPlayer;
            if ( !np )
                break;
            if ( np->Object() )
            {
                synced = true;
                break;
            }
        }
    }
    else if ( !synced_ )
    {
        // synced finally. Send our player info over so we can join the game.
        ePlayerNetID::Update();

        // and trigger the scheduled auto-logons.
        ePlayer::SendAuthNames();

        synced_ = true;
    }

    static float lastTime = -1;

    if (sg_gameTimeInterval >= 0 && (gtime >= lastTime + sg_gameTimeInterval || (gtime < lastTime && gtime >= 0))) {
        tOutput out;
        out << "GAME_TIME " << gtime << '\n';
        se_SaveToLadderLog(out);
        lastTime = gtime;
    }

    if (state==GS_PLAY){
        if (gtime<0 && gtime>-PREPARE_TIME+.3)
            eCamera::s_Timestep(grid, gtime);
        else{
            // keep ping weight high while playing, that gives the best meassurements
            nPingAverager::SetWeight(1);

            if (gtime>=lastTime_gameloop){

#ifdef CONNECTION_STRESS
                if ( sg_ConnectionStress )
                {
                    tRandomizer & randomizer = tRandomizer::GetInstance();
                    int random = randomizer.Get( 1000 );
                    if ( random == 0 )
                    {
                        sg_RequestedDisconnection = true;
                        //                                              sn_SetNetState( nSTANDALONE );
                        goon = false;
                    }
                }
#endif


                Timestep(gtime,true);
                lastTime_gameloop=gtime;
            }
            lastTime_gameloop=gtime;
        }
        //    else if (lastTime_gameloop>gtime+10)
        // lastTime_gameloop=gtime;



        if (sn_GetNetState()!=nCLIENT)
        {
            // simulate IAs
            for (int i=se_PlayerNetIDs.Len()-1;i>=0;i--)
            {
                gAIPlayer *ai = dynamic_cast<gAIPlayer*>(se_PlayerNetIDs(i));
                if (ai && think)
                    ai->Timestep(gtime);
            }

            Analysis(gtime);

            // wait for chatting players
            if ( sn_GetNetState()==nSERVER && gtime < sg_lastChatBreakTime + 1 )
                se_PauseGameTimer( gtime < sg_lastChatBreakTime && ePlayerNetID::WaitToLeaveChat() );
        }

        // send game object updates
        nNetObject::SyncAll();
        sn_SendPlanned();

        if ( gtime<=-PREPARE_TIME+.5 || !goon || !synced )
        {
#ifndef DEDICATED
            if (input)
            {
                if ( !synced )
                {
                    con.CenterDisplay(tString(tOutput("$network_login_sync")),0);
                }

                if ( sr_glOut )
                    rSysDep::ClearGL();
            }

            if ( input )
                rSysDep::SwapGL();
#endif
        }
        else
            Render(grid, gtime, input);

        if ( netstate != sn_GetNetState() )
        {
            return false;
        }

        return goon;
    }
    else{
        // between rounds, assume we're synced
        //if ( !synced_ && sn_GetNetState() != nSERVER )
        //    ePlayerNetID::Update();
        // synced_ = true;

#ifndef DEDICATED
        // send game object updates
        nNetObject::SyncAll();
        sn_SendPlanned();

        if (input)
        {
            if (sr_glOut)
                rSysDep::ClearGL();
            rSysDep::SwapGL();
        }
#endif
        tDelay( 10000 );
        return goon;

Here is the call graph for this function:

Here is the caller graph for this function:

bool gGame::GridIsReady

(

int

c

)

Definition at line 3924 of file gGame.cpp.

References GS_DELETE_OBJECTS, GS_TRANSFER_OBJECTS, and nNetObject::HasBeenTransmitted().

Referenced by notrans().

                                 {
    return HasBeenTransmitted(client) &&
           (client_gamestate[client]>=GS_TRANSFER_OBJECTS &&

Here is the call graph for this function:

Here is the caller graph for this function:

eGrid* gGame::Grid

(

)

const [inline]

Definition at line 115 of file gGame.h.

Referenced by Analysis(), and StateUpdate().

{ return grid; }

Here is the caller graph for this function:

void gGame::NoLongerGoOn

(

)

Definition at line 2297 of file gGame.cpp.

References goon, nSERVER, nNetObject::RequestSync(), and sn_GetNetState().

Referenced by ret_to_MainMenu(), and update_settings().

                        {
    goon=false;
    //  stateNext=GS_DELETE_OBJECTS;
    if (sn_GetNetState()==nSERVER)
        RequestSync();

Here is the call graph for this function:

Here is the caller graph for this function:

void gGame::StartNewMatch

(

)

Definition at line 3562 of file gGame.cpp.

Referenced by Analysis(), StartNewMatch(), and update_settings().

                         {
    //gStatistics - highscore check
    if (sg_singlePlayer && gStats && se_PlayerNetIDs.Len() > 0 && se_PlayerNetIDs(0)->IsHuman())
    {
        gStats->highscores->greater(se_PlayerNetIDs(0)->GetName(), se_PlayerNetIDs(0)->Score());
    }

Here is the caller graph for this function:

void gGame::StartNewMatchNow

(

)

Definition at line 3572 of file gGame.cpp.

Referenced by Analysis(), Init(), and StateUpdate().

                            {
    if ( rounds != 0 )
    {
        se_SaveToLadderLog(tString("NEW_MATCH\n"));
        se_sendEventNotification(tString("New match"), tString("Starting a new match"));
    }


    rounds=0;
    warning=0;
    startTime=tSysTimeFloat()-10;

    ePlayerNetID::ThrowOutDisconnected();

Here is the caller graph for this function:

---

Member Data Documentation

unsigned short gGame::state [private]

Definition at line 62 of file gGame.h.

Referenced by client_gamestate_handler(), GameLoop(), GetState(), Init(), SetState(), and StateUpdate().

unsigned short gGame::stateNext [private]

Definition at line 63 of file gGame.h.

Referenced by GameLoop(), Init(), ReadSync(), SetState(), StateUpdate(), and WriteSync().

tJUST_CONTROLLED_PTR< gZone > gGame::winDeathZone_ [private]

Definition at line 68 of file gGame.h.

Referenced by Analysis(), and StateUpdate().

bool gGame::goon [private]

Definition at line 71 of file gGame.h.

Referenced by Analysis(), GameLoop(), GameLoop(), Init(), NoLongerGoOn(), SetState(), StateUpdate(), and SyncState().

int gGame::rounds [private]

Definition at line 73 of file gGame.h.

Referenced by Analysis(), Init(), and StateUpdate().

double gGame::startTime [private]

Definition at line 75 of file gGame.h.

Referenced by Analysis().

int gGame::warning [private]

Definition at line 77 of file gGame.h.

Referenced by Analysis().

bool gGame::synced_ [private]

flag indicating whether the game is considered synced

Definition at line 81 of file gGame.h.

Referenced by GameLoop(), gGame(), and StateUpdate().

gParser* gGame::aParser [private]

Definition at line 85 of file gGame.h.

Referenced by Init(), StateUpdate(), Verify(), and ~gGame().

eSoundMixer* gGame::m_Mixer

Definition at line 123 of file gGame.h.

Referenced by Analysis(), GameLoop(), and Init().

---

The documentation for this class was generated from the following files:

• src/tron/gGame.h
• src/tron/gGame.cpp

---