src/tron/gGame.cpp File Reference

#include "eEventNotification.h"
#include "gStuff.h"
#include "eSoundMixer.h"
#include "eGrid.h"
#include "eTeam.h"
#include "tSysTime.h"
#include "gGame.h"
#include "rTexture.h"
#include "gWall.h"
#include "rConsole.h"
#include "gCycle.h"
#include "eCoord.h"
#include "eTimer.h"
#include "gAIBase.h"
#include "rSysdep.h"
#include "rFont.h"
#include "uMenu.h"
#include "nConfig.h"
#include "rScreen.h"
#include "rViewport.h"
#include "uInput.h"
#include "ePlayer.h"
#include "gSpawn.h"
#include "uInputQueue.h"
#include "nNetObject.h"
#include "tToDo.h"
#include "gMenus.h"
#include "gCamera.h"
#include "gServerBrowser.h"
#include "gServerFavorites.h"
#include "gFriends.h"
#include "gLogo.h"
#include "gLanguageMenu.h"
#include "nServerInfo.h"
#include "gAICharacter.h"
#include "tDirectories.h"
#include "gTeam.h"
#include "gWinZone.h"
#include "eVoter.h"
#include "tRecorder.h"
#include "gStatistics.h"
#include "tXmlParser.h"
#include "gParser.h"
#include "nAuthentication.h"
#include "gRotation.h"
#include <math.h>
#include <stdlib.h>
#include <string>
#include <fstream>
#include <ctype.h>
#include <time.h>
#include "nSocket.h"
#include "gArena.h"
#include "rSDL.h"
#include <SDL_thread.h>
#include "rRender.h"
#include <fcntl.h>
#include <stdio.h>
#include <errno.h>

Go to the source code of this file.

Classes
class	tSettingRotation
class	gSettingsReverter
class	gNetIdler
class	gMapLoadConsoleFilter
Defines
#define	DEFAULT_MAP   "Anonymous/polygon/regular/square-1.0.1.aamap.xml"
#define	MAXAI   (gAICharacter::s_Characters.Len())
#define	AUTO_AI_MAXFRAC   6
#define	AUTO_AI_WIN   3
#define	AUTO_AI_LOSE   1
#define	PREPARE_TIME   4
#define	GS_CREATED   0
#define	GS_TRANSFER_SETTINGS   7
#define	GS_CREATE_GRID   10
#define	GS_CREATE_OBJECTS   20
#define	GS_TRANSFER_OBJECTS   30
#define	GS_CAMERA   35
#define	GS_SYNCING   40
#define	GS_SYNCING2   41
#define	GS_SYNCING3   42
#define	GS_PLAY   50
#define	GS_DELETE_OBJECTS   60
#define	GS_DELETE_GRID   70
#define	GS_STATE_MAX   80
Functions
	tCONFIG_ENUM (gGameType)
	tCONFIG_ENUM (gFinishType)
tString	sg_GetCurrentTime (char const *szFormat)
void	sg_PrintCurrentTime (char const *szFormat)
void	sg_PrintCurrentDate ()
void	sg_PrintCurrentTime ()
void	sg_Timestamp ()
static void	GameSettingsMP ()
static void	GameSettingsSP ()
static void	GameSettingsCurrent ()
void	sg_DeclareWinner (eTeam *team, char const *message)
static	tCONTROLLED_PTR (gGame) sg_currentGame
void	exit_game_grid (eGrid *grid)
void	exit_game_objects (eGrid *grid)
REAL	exponent (int i)
void	init_game_grid (eGrid *grid, gParser *aParser)
int	sg_NumHumans ()
int	sg_NumUsers ()
static void	sg_copySettings ()
void	update_settings ()
void	init_game_objects (eGrid *grid)
void	init_game_camera (eGrid *grid)
void	s_Timestep (eGrid *grid, REAL time, bool cam)
void	RenderAllViewports (eGrid *grid)
void	Render (eGrid *grid, REAL time, bool swap=true)
static void	own_game (nNetState enter_state)
static void	singlePlayer_game ()
void	sg_HostGame ()
static bool	sg_NetworkError (const tOutput &title, const tOutput &message, REAL timeout)
void	sg_Receive ()
bool	ConnectToServerCore (nServerInfoBase *server)
void	ConnectToServer (nServerInfoBase *server)
void	ret_to_MainMenu ()
void	net_options ()
void	sg_HostGameMenu ()
void	net_game ()
static void	StartNewMatch ()
static void	StartNewMatch_conf (std::istream &)
void	st_PrintPathInfo (tOutput &buf)
static void	PlayerLogIn ()
void	sg_DisplayVersionInfo ()
void	MainMenu (bool ingame)
static bool	sg_AbeforeB (int stateA, int stateB)
static void	ingame_menu_cleanup ()
static void	ingame_menu ()
static void	sg_ParseMap (gParser *aParser, tString mapfile)
static void	sg_ParseMap (gParser *aParser)
static void	client_gamestate_handler (nMessage &m)
static void	sg_VoteMenuIdle ()
void	sg_RespawnPlayer (eGrid *grid, gArena *arena, ePlayerNetID *p)
gArena *	sg_GetArena ()
static bool	sg_EnemyExists (int team)
void	rotate ()
static bool	togglemousegrab_func (REAL x)
static bool	pausegame_func (REAL x)
static bool	reloadtextures_func (REAL x)
static bool	ingamemenu_func (REAL x)
bool	GameLoop (bool input=true)
void	gameloop_idle ()
static void	sg_EnterGameCleanup ()
void	sg_EnterGameCore (nNetState enter_state)
void	sg_EnterGame (nNetState enter_state)
bool	GridIsReady (int c)
static bool	notrans ()
void	Activate (bool act)
static void	sg_FullscreenIdle ()
void	sg_ClientFullscreenMessage (tOutput const &title, tOutput const &message, REAL timeout)
	Displays a message locally that gets displayed on the whole screen, blocking view to the game.
static void	sg_TodoClientFullscreenMessage ()
static void	sg_ClientFullscreenMessage (nMessage &m)
void	sg_FullscreenMessage (tOutput const &title, tOutput const &message, REAL timeout, int client)
	Displays a message on a specific client or all clients that gets displayed on the whole screen, blocking view to the game.
static void	sg_FullscreenMessageConf (std::istream &s)
static void	LoginCallback ()
Variables
gArena	Arena
static REAL	sg_extraRoundTime = 0.0f
static tSettingItem< REAL >	sg_extraRoundTimeConf ("EXTRA_ROUND_TIME", sg_extraRoundTime)
static REAL	sg_lastChatBreakTime = -1.0f
static tSettingItem< REAL >	sg_lastChatBreakTimeConf ("LAST_CHAT_BREAK_TIME", sg_lastChatBreakTime)
static tString	mapfile (DEFAULT_MAP)
static nSettingItemWatched < tString >	conf_mapfile ("MAP_FILE", mapfile, nConfItemVersionWatcher::Group_Breaking, 8)
static tSettingRotation	sg_mapRotation ("MAP_ROTATION")
static tSettingRotation	sg_configRotation ("CONFIG_ROTATION")
static int	rotationtype = 0
static tSettingItem< int >	conf_rotationtype ("ROTATION_TYPE", rotationtype)
static REAL	ded_idle = 24
static tSettingItem< REAL >	dedicaded_idle ("DEDICATED_IDLE", ded_idle)
static float	sg_gameTimeInterval = -1
static tSettingItem< float >	sggti ("LADDERLOG_GAME_TIME_INTERVAL", sg_gameTimeInterval)
gGameSettings	singlePlayer (10, 30, 10, 100000, 1, 0, 30, true, true, 0,-3, gDUEL, gFINISH_IMMEDIATELY, 1, 100000, 1000000)
gGameSettings	multiPlayer (10, 30, 10, 100, 0, 4, 100, false, false, 0,-3, gDUEL, gFINISH_IMMEDIATELY, 2, 60, 30)
gGameSettings *	sg_currentSettings = &singlePlayer
static tSettingItem< int >	mp_sw ("SCORE_WIN", multiPlayer.scoreWin)
static tSettingItem< int >	mp_lt ("LIMIT_TIME", multiPlayer.limitTime)
static tSettingItem< int >	mp_lr ("LIMIT_ROUNDS", multiPlayer.limitRounds)
static tSettingItem< int >	mp_ls ("LIMIT_SCORE", multiPlayer.limitScore)
static tConfItem< int >	mp_na ("NUM_AIS", multiPlayer.numAIs)
static tConfItem< int >	mp_mp ("MIN_PLAYERS", multiPlayer.minPlayers)
static tConfItem< int >	mp_iq ("AI_IQ", multiPlayer.AI_IQ)
static tConfItem< bool >	mp_an ("AUTO_AIS", multiPlayer.autoNum)
static tConfItem< bool >	mp_aq ("AUTO_IQ", multiPlayer.autoIQ)
static tConfItem< int >	mp_sf ("SPEED_FACTOR", multiPlayer.speedFactor)
static tConfItem< int >	mp_zf ("SIZE_FACTOR", multiPlayer.sizeFactor)
static tConfItem< gGameType >	mp_gt ("GAME_TYPE", multiPlayer.gameType)
static tConfItem< gFinishType >	mp_ft ("FINISH_TYPE", multiPlayer.finishType)
static tConfItem< int >	mp_wzmr ("WIN_ZONE_MIN_ROUND_TIME", multiPlayer.winZoneMinRoundTime)
static tConfItem< int >	mp_wzld ("WIN_ZONE_MIN_LAST_DEATH", multiPlayer.winZoneMinLastDeath)
static tConfItem< int >	mp_tmin ("TEAMS_MIN", multiPlayer.minTeams)
static tConfItem< int >	mp_tmax ("TEAMS_MAX", multiPlayer.maxTeams)
static tConfItem< int >	mp_mtp ("TEAM_MIN_PLAYERS", multiPlayer.minPlayersPerTeam)
static tConfItem< int >	mp_tp ("TEAM_MAX_PLAYERS", multiPlayer.maxPlayersPerTeam)
static tConfItem< int >	mp_tib ("TEAM_MAX_IMBALANCE", multiPlayer.maxTeamImbalance)
static tConfItem< bool >	mp_tbai ("TEAM_BALANCE_WITH_AIS", multiPlayer.balanceTeamsWithAIs)
static tConfItem< bool >	mp_tboq ("TEAM_BALANCE_ON_QUIT", multiPlayer.enforceTeamRulesOnQuit)
static tConfItem< REAL >	mp_wsu ("WALLS_STAY_UP_DELAY", multiPlayer.wallsStayUpDelay)
static tConfItem< REAL >	mp_wl ("WALLS_LENGTH", multiPlayer.wallsLength)
static tConfItem< REAL >	mp_er ("EXPLOSION_RADIUS", multiPlayer.explosionRadius)
static tSettingItem< int >	sp_sw ("SP_SCORE_WIN", singlePlayer.scoreWin)
static tSettingItem< int >	sp_lt ("SP_LIMIT_TIME", singlePlayer.limitTime)
static tSettingItem< int >	sp_lr ("SP_LIMIT_ROUNDS", singlePlayer.limitRounds)
static tSettingItem< int >	sp_ls ("SP_LIMIT_SCORE", singlePlayer.limitScore)
static tConfItem< int >	sp_na ("SP_NUM_AIS", singlePlayer.numAIs)
static tConfItem< int >	sp_mp ("SP_MIN_PLAYERS", singlePlayer.minPlayers)
static tConfItem< int >	sp_iq ("SP_AI_IQ", singlePlayer.AI_IQ)
static tConfItem< bool >	sp_an ("SP_AUTO_AIS", singlePlayer.autoNum)
static tConfItem< bool >	sp_aq ("SP_AUTO_IQ", singlePlayer.autoIQ)
static tConfItem< int >	sp_sf ("SP_SPEED_FACTOR", singlePlayer.speedFactor)
static tConfItem< int >	sp_zf ("SP_SIZE_FACTOR", singlePlayer.sizeFactor)
static tConfItem< gGameType >	sp_gt ("SP_GAME_TYPE", singlePlayer.gameType)
static tConfItem< gFinishType >	sp_ft ("SP_FINISH_TYPE", singlePlayer.finishType)
static tConfItem< int >	sp_wzmr ("SP_WIN_ZONE_MIN_ROUND_TIME", singlePlayer.winZoneMinRoundTime)
static tConfItem< int >	sp_wzld ("SP_WIN_ZONE_MIN_LAST_DEATH", singlePlayer.winZoneMinLastDeath)
static tConfItem< int >	sp_tmin ("SP_TEAMS_MIN", singlePlayer.minTeams)
static tConfItem< int >	sp_tmax ("SP_TEAMS_MAX", singlePlayer.maxTeams)
static tConfItem< int >	sp_mtp ("SP_TEAM_MIN_PLAYERS", singlePlayer.minPlayersPerTeam)
static tConfItem< int >	sp_tp ("SP_TEAM_MAX_PLAYERS", singlePlayer.maxPlayersPerTeam)
static tConfItem< int >	sp_tib ("SP_TEAM_MAX_IMBALANCE", singlePlayer.maxTeamImbalance)
static tConfItem< bool >	sp_tbai ("SP_TEAM_BALANCE_WITH_AIS", singlePlayer.balanceTeamsWithAIs)
static tConfItem< bool >	sp_tboq ("SP_TEAM_BALANCE_ON_QUIT", singlePlayer.enforceTeamRulesOnQuit)
static tConfItem< REAL >	sp_wsu ("SP_WALLS_STAY_UP_DELAY", singlePlayer.wallsStayUpDelay)
static tConfItem< REAL >	sp_wl ("SP_WALLS_LENGTH", singlePlayer.wallsLength)
static tConfItem< REAL >	sp_er ("SP_EXPLOSION_RADIUS", singlePlayer.explosionRadius)
static REAL	sg_Timeout = 5.0f
static tConfItem< REAL >	sg_ctimeout ("GAME_TIMEOUT", sg_Timeout)
bool	sg_TalkToMaster = true
static tSettingItem< bool >	sg_ttm ("TALK_TO_MASTER", sg_TalkToMaster)
static bool	just_connected = true
static bool	sg_singlePlayer = 0
static int	winner = 0
static int	absolute_winner = 0
static REAL	lastTime_gameloop = 0
static REAL	lastTimeTimestep = 0
static int	wishWinner = 0
static char const *	wishWinnerMessage = ""
REAL	stc_fastestSpeedRound
bool	sg_axesIndicator
static int	sg_spawnPointGroupSize = 0
static tSettingItem< int >	sg_spawnPointGroupSizeConf ("SPAWN_POINT_GROUP_SIZE", sg_spawnPointGroupSize)
bool	think = 1
static tString	sg_roundCenterMessage ("")
static tConfItemLine	sn_roundCM_ci ("ROUND_CENTER_MESSAGE", sg_roundCenterMessage)
static tString	sg_roundConsoleMessage ("")
static tConfItemLine	sn_roundCcM1_ci ("ROUND_CONSOLE_MESSAGE", sg_roundConsoleMessage)
static bool	sg_RequestedDisconnection = false
static tConfItem< int >	mor ("MAX_OUT_RATE", sn_maxRateOut)
static tConfItem< int >	mir ("MAX_IN_RATE", sn_maxRateIn)
static tConfItem< int >	pc ("PING_CHARITY", pingCharity)
uMenu *	sg_IngameMenu = NULL
uMenu *	sg_HostMenu = NULL
static tConfItemFunc	snm ("START_NEW_MATCH",&StartNewMatch_conf)
static nNOInitialisator< gGame >	game_init (310,"game")
unsigned short	client_gamestate [MAXCLIENTS+2]
static nDescriptor	client_gs (311, client_gamestate_handler,"client_gamestate")
REAL	planned_rate_control [MAXCLIENTS+2]
REAL	sent_per_messid [100]
static REAL	lastdeath = 0
static bool	roundOver = false
static REAL	sg_timestepMax = .2
static tSettingItem< REAL >	sg_timestepMaxConf ("TIMESTEP_MAX", sg_timestepMax)
static int	sg_timestepMaxCount = 10
static tSettingItem< int >	sg_timestepMaxCountConf ("TIMESTEP_MAX_COUNT", sg_timestepMaxCount)
static REAL	sg_winZoneRandomness = .8
static tSettingItem< REAL >	sg_winZoneSpreadConf ("WIN_ZONE_RANDOMNESS", sg_winZoneRandomness)
static uActionGlobal	togglemousegrab ("TOGGLE_MOUSEGRAB")
static uActionGlobal	pausegame ("PAUSE_GAME")
static uActionGlobal	reloadtextures ("RELOAD_TEXTURES")
static uActionGlobal	ingamemenu ("INGAME_MENU")
static eTransferInhibitor inh &	notrans
static nVersionFeature	sg_fullscreenMessages (14)
static tString	sg_fullscreenMessageTitle
static tString	sg_fullscreenMessageMessage
static REAL	sg_fullscreenMessageTimeout
static nDescriptor	sg_clientFullscreenMessage (312, sg_ClientFullscreenMessage,"client_fsm")
static tConfItemFunc	sg_fullscreenMessageConf ("FULLSCREEN_MESSAGE",&sg_FullscreenMessageConf)
tString	sg_greeting ("")
static tConfItemLine	a_mod ("MESSAGE_OF_DAY", sg_greeting)
tString	sg_greetingTitle ("")
static tConfItemLine	a_tod ("TITLE_OF_DAY", sg_greetingTitle)
REAL	sg_greetingTimeout = 60
static tSettingItem< REAL >	a_modt ("MESSAGE_OF_DAY_TIMEOUT", sg_greetingTimeout)
static nCallbackLoginLogout	lc (LoginCallback)

---

Define Documentation

#define AUTO_AI_LOSE   1

Definition at line 300 of file gGame.cpp.

Referenced by gGameSettings::AutoAI().

#define AUTO_AI_MAXFRAC   6

Definition at line 298 of file gGame.cpp.

Referenced by gGameSettings::AutoAI(), and gGameSettings::gGameSettings().

#define AUTO_AI_WIN   3

Definition at line 299 of file gGame.cpp.

Referenced by gGameSettings::AutoAI().

#define DEFAULT_MAP   "Anonymous/polygon/regular/square-1.0.1.aamap.xml"

Definition at line 127 of file gGame.cpp.

Referenced by sg_ParseMap().

#define GS_CAMERA   35

Definition at line 2219 of file gGame.cpp.

Referenced by gGame::StateUpdate().

#define GS_CREATE_GRID   10

Definition at line 2216 of file gGame.cpp.

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

#define GS_CREATE_OBJECTS   20

Definition at line 2217 of file gGame.cpp.

Referenced by gGame::StateUpdate().

#define GS_CREATED   0

Definition at line 2214 of file gGame.cpp.

Referenced by gGame::Init(), and gGame::StateUpdate().

#define GS_DELETE_GRID   70

Definition at line 2225 of file gGame.cpp.

Referenced by gGame::StateUpdate().

#define GS_DELETE_OBJECTS   60

Definition at line 2224 of file gGame.cpp.

Referenced by gGame::Analysis(), gGame::GameLoop(), gGame::GridIsReady(), and gGame::StateUpdate().

#define GS_PLAY   50

Definition at line 2223 of file gGame.cpp.

Referenced by gGame::Analysis(), gGame::GameLoop(), ingame_menu_cleanup(), and gGame::StateUpdate().

#define GS_STATE_MAX   80

Definition at line 2226 of file gGame.cpp.

Referenced by sg_AbeforeB().

#define GS_SYNCING   40

Definition at line 2220 of file gGame.cpp.

Referenced by gGame::StateUpdate().

#define GS_SYNCING2   41

Definition at line 2221 of file gGame.cpp.

#define GS_SYNCING3   42

Definition at line 2222 of file gGame.cpp.

#define GS_TRANSFER_OBJECTS   30

Definition at line 2218 of file gGame.cpp.

Referenced by gGame::GridIsReady(), and gGame::StateUpdate().

#define GS_TRANSFER_SETTINGS   7

Definition at line 2215 of file gGame.cpp.

Referenced by gGame::Init(), and gGame::StateUpdate().

#define MAXAI   (gAICharacter::s_Characters.Len())

Definition at line 296 of file gGame.cpp.

Referenced by gGameSettings::AutoAI(), and gGameSettings::Menu().

#define PREPARE_TIME   4

Definition at line 734 of file gGame.cpp.

Referenced by gGame::GameLoop(), and init_game_camera().

---

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:

static void client_gamestate_handler

(

nMessage &

m

)

[static]

Definition at line 2458 of file gGame.cpp.

References nMessage::Read(), nMessage::SenderID(), and gGame::state.

                                                 {
    unsigned short state;
    m.Read( state );
    client_gamestate[m.SenderID()] = state;
#ifdef DEBUG
    //  con << "User " << m.SenderID() << " is in Mode " << state << '\n';
#endif

Here is the call 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 ConnectToServerCore

(

nServerInfoBase *

server

)

Definition at line 1532 of file gGame.cpp.

References rConsole::autoDisplayAtNewline, nNetObject::ClearAll(), ePlayerNetID::ClearAll(), rSysDep::ClearGL(), con, nServerInfoBase::Connect(), rConsole::fullscreen, nServerInfoBase::GetName(), just_connected, tString::Len(), MAX_PLAYERS, nABORT, nCLIENT, nDENIED, nOK, nSTANDALONE, nTIMEOUT, NULL, uMenu::quickexit, REAL, renderer_identification, tOutput::SetTemplateParameter(), sg_EnterGame(), sg_NetworkError(), sg_Receive(), sn_bigBrotherString, sn_Delay(), sn_DenyReason, sn_GetLastError(), sn_GetNetState(), sn_SendPlanned(), sn_SetNetState(), sr_con, sr_textOut, st_DoToDo(), rSysDep::SwapGL(), nNetObject::SyncAll(), tAdvanceFrame(), tASSERT, to, tSysTimeFloat(), and rViewport::Update().

Referenced by ConnectToServer().

              : false if there was an error or abort
bool ConnectToServerCore(nServerInfoBase *server)
{
    tASSERT( server );

    ePlayerNetID::ClearAll();

    // revert to default settings, restore current vlaues on exit
    gSettingsReverter reverter;

    sn_bigBrotherString = renderer_identification;

    nNetObject::ClearAll();

    just_connected=true;

    rViewport::Update(MAX_PLAYERS);
    // ePlayerNetID::Update();

#ifndef DEDICATED
    rSysDep::SwapGL();
    rSysDep::ClearGL();
    rSysDep::SwapGL();
    rSysDep::ClearGL();
#endif

    sr_con.autoDisplayAtNewline=true;
    sr_con.fullscreen=true;

    bool to=sr_textOut;
    sr_textOut=true;

    tOutput o;

    nConnectError error = nOK;

    nNetObject::ClearAll();

    o.SetTemplateParameter(1, server->GetName());
    o << "$network_connecting_to_server";
    con << o;
    error = server->Connect();

    switch (error)
    {
    case nABORT:
        return false;
        break;
    case nOK:
        break;
    case nTIMEOUT:
        sg_NetworkError("$network_message_timeout_title", "$network_message_timeout_inter", 20);
        return false;
        break;

    case nDENIED:
        sg_NetworkError("$network_message_denied_title", sn_DenyReason.Len() > 2 ? "$network_message_denied_inter2" : "$network_message_denied_inter", 20);
        return false;
        break;
    }

    // ePlayerNetID::CompleteRebuild();

    if (sn_GetNetState()==nCLIENT){
        REAL endTime=tSysTimeFloat()+30;
        con << tOutput("$network_connecting_gamestate");
        while (!sg_currentGame && tSysTimeFloat()<endTime && (sn_GetNetState() != nSTANDALONE)){
            tAdvanceFrame();
            sg_Receive();
            nNetObject::SyncAll();
            tAdvanceFrame();
            sn_SendPlanned();
            st_DoToDo();

#ifndef DEDICATED
            rSysDep::SwapGL();
            rSysDep::ClearGL();
#endif

            sn_Delay();
        }
        if (sg_currentGame){
            sr_con.autoDisplayAtNewline=false;
            sr_con.fullscreen=false;

            con << tOutput("$network_syncing_gamestate");
            sg_EnterGame( nCLIENT );
        }
        else{
            //con << "Timeout. Try again!\n";
            sg_NetworkError("$network_message_lateto_title", "$network_message_lateto_inter", 20);
        }
    }

    bool ret = true;

    if (!sg_RequestedDisconnection && !uMenu::quickexit)
        switch (sn_GetLastError())
        {
        case nOK:
            ret = sg_NetworkError("$network_message_abortconn_title",
                                  "$network_message_abortconn_inter", 20);
            break;
        default:
            ret = sg_NetworkError("$network_message_lostconn_title",
                                  "$network_message_lostconn_inter", 20);
            break;
        }

    sr_con.autoDisplayAtNewline=false;
    sr_con.fullscreen=false;

    sn_SetNetState(nSTANDALONE);

    sg_currentGame = NULL;
    nNetObject::ClearAll();
    ePlayerNetID::ClearAll();

    sr_textOut=to;

    return ret;

Here is the call graph for this function:

Here is the caller graph for this function:

void exit_game_grid

(

eGrid *

grid

)

Definition at line 780 of file gGame.cpp.

References eGrid::Clear().

Referenced by exit_game_objects(), and gGame::Verify().

                                {
    grid->Clear();
}

Here is the call graph for this function:

Here is the caller graph for this function:

void exit_game_objects

(

eGrid *

grid

)

Definition at line 784 of file gGame.cpp.

References gNetPlayerWall::Clear(), eGameObject::DeleteAll(), exit_game_grid(), rConsole::fullscreen, GrowingArrayBase::Len(), nCLIENT, uPlayerPrototype::Num(), ePlayer::PlayerConfig(), se_PlayerNetIDs, sn_GetNetState(), sr_con, su_prefetchInput, and tDESTROY.

Referenced by cleanup(), gGame::StateUpdate(), and gGame::~gGame().

                                   {
    sr_con.fullscreen=true;

    su_prefetchInput=false;

    int i;
    for (i=ePlayer::Num()-1;i>=0;i--){
        if (ePlayer::PlayerConfig(i))
            tDESTROY(ePlayer::PlayerConfig(i)->cam);
    }

    eGameObject::DeleteAll(grid);

    if (sn_GetNetState()!=nCLIENT)
        for (int i=se_PlayerNetIDs.Len()-1;i>=0;i--)
            if (se_PlayerNetIDs(i))
                se_PlayerNetIDs(i)->ClearObject();

    gNetPlayerWall::Clear();

    exit_game_grid(grid);
}

Here is the call graph for this function:

Here is the caller graph for this function:

REAL exponent

(

int

i

)

Definition at line 807 of file gGame.cpp.

References abs(), REAL, and sqrtf().

Referenced by sg_copySettings().

{
    int abs = i;
    if ( abs < 0 )
        abs = -abs;

    REAL ret = 1;
    REAL fac = sqrtf(2);

    while (abs > 0)
    {
        if ( 1 == (abs & 1) )
            ret *= fac;

        fac *= fac;
        abs >>= 1;
    }

    if (i < 0)
        ret = 1/ret;

    return ret;
}

Here is the call graph for this function:

Here is the caller graph for this function:

bool GameLoop

(

bool

input = true

)

Definition at line 3934 of file gGame.cpp.

References gGame::GameLoop(), nAverager::GetDataVariance(), nPingAverager::GetPing(), nPingAverager::GetSlowAverager(), gGame::goon, ePlayerNetID::lastSync, GrowingArrayBase::Len(), nSERVER, nNetObject::Owner(), ePlayerNetID::ping, nConnectionInfo::ping, uMenu::quickexit, REAL, nNetObject::RequestSync(), se_PlayerNetIDs, sn_Connections, sn_GetNetState(), gGame::StateUpdate(), and tSysTimeFloat().

                              {
    /*
      int oldflags = fcntl (fileno(stdin), F_GETFD, 0);
      if (oldflags<0)
      std::cout << errno << '\n';
       
      if (fcntl(fileno(stdin), F_SETFL, oldflags | O_NONBLOCK)<0)
      std::cout << errno << '\n';
      
    //if (std::cin && std::cin.good() && !std::cin.eof() && !std::cin.fail() && !std::cin.bad()){
    //if (std::cin.rdbuf()->overflow()!=EOF){
    //if (std::cin.rdbuf()->in_avail()>0){

    char c[10];
    int in=0;
    in=read (fileno(stdin),c,9);
    for (int i=0;i<in;i++)
    std::cout << c;
     */

    // see if pings have dramatically changed
    if (sn_GetNetState()==nSERVER){
        REAL t=tSysTimeFloat();
        for (int i=se_PlayerNetIDs.Len()-1;i>=0;i--){
            ePlayerNetID *p=se_PlayerNetIDs(i);

            // get average and variance (increased a bit) of this player's ping
            nPingAverager const & averager = sn_Connections[p->Owner()].ping;
            REAL realping = averager.GetPing();
            REAL pingvariance = averager.GetSlowAverager().GetDataVariance() + realping * realping * .01;

            // deviation of real ping and synced ping
            REAL deviation = realping - p->ping;

            // measured against the variance, this player's ping deviates this much
            // from the communicated value
            REAL relativedeviation = deviation * deviation / pingvariance;

            if (0 == p->Owner())
                realping = 0;

            if ( ( t - p->lastSync - 5 ) * relativedeviation > 5 ){
                // if yes, send a message about it
                p->ping = realping;
                p->RequestSync(false);
            }
        }
    }

    bool goon=false;
    if (sg_currentGame){
        tControlledPTR< nNetObject > keep( sg_currentGame );
        sg_currentGame->StateUpdate();
        goon=!uMenu::quickexit && bool(sg_currentGame) && sg_currentGame->GameLoop(input);
    }

Here is the call graph for this function:

void gameloop_idle

(

)

Definition at line 3992 of file gGame.cpp.

Referenced by sg_FullscreenMessage().

{
    se_UserShowScores( false );
    sg_Receive();
    nNetObject::SyncAll();
    sn_SendPlanned();

Here is the caller graph for this function:

static void GameSettingsCurrent

(

)

[static]

Definition at line 723 of file gGame.cpp.

References gGameSettings::Menu().

Referenced by MainMenu().

                                 {
    sg_currentSettings->Menu();
}

Here is the call graph for this function:

Here is the caller graph for this function:

static void GameSettingsMP

(

)

[static]

Definition at line 715 of file gGame.cpp.

References gGameSettings::Menu(), and multiPlayer.

Referenced by sg_HostGameMenu().

                            {
    multiPlayer.Menu();
}

Here is the call graph for this function:

Here is the caller graph for this function:

static void GameSettingsSP

(

)

[static]

Definition at line 719 of file gGame.cpp.

References gGameSettings::Menu(), and singlePlayer.

Referenced by MainMenu().

                            {
    singlePlayer.Menu();
}

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:

static void ingame_menu

(

)

[static]

Definition at line 2235 of file gGame.cpp.

Referenced by gGame::GameLoop().

{
    //    globalingame=true;
    try
    {
        se_ChatState( ePlayerNetID::ChatFlags_Menu, true );
        if (sn_GetNetState()==nSTANDALONE)
            se_PauseGameTimer(true);
        MainMenu(true);
    }
    catch ( ... )
    {
        ingame_menu_cleanup();
        ret_to_MainMenu();
        sg_IngameMenu=NULL;
        sg_HostMenu=NULL;
        throw;
    }
    ingame_menu_cleanup();

Here is the caller graph for this function:

static void ingame_menu_cleanup

(

)

[static]

Definition at line 2256 of file gGame.cpp.

References ePlayerNetID::ChatFlags_Menu, gGame::GetState(), GS_PLAY, MAX_PLAYERS, nSTANDALONE, se_ChatState(), se_PauseGameTimer(), sn_GetNetState(), ePlayerNetID::Update(), and rViewport::Update().

{
    if (sn_GetNetState()==nSTANDALONE)
        se_PauseGameTimer(false);
    se_ChatState(ePlayerNetID::ChatFlags_Menu, false);
    if ((bool(sg_currentGame) && sg_currentGame->GetState()!=GS_PLAY))
        //      || se_PlayerNetIDs.Len()==0)
    {
        rViewport::Update(MAX_PLAYERS);
        ePlayerNetID::Update();
    }
    //    globalingame=false;

Here is the call graph for this function:

static bool ingamemenu_func

(

REAL

x

)

[static]

Definition at line 3633 of file gGame.cpp.

                                   {
    if (x>0){
        st_ToDo(&ingame_menu);
    }

void init_game_camera

(

eGrid *

grid

)

Definition at line 1195 of file gGame.cpp.

References CAMERA_SMART, gGameSettings::finishType, gFINISH_EXPRESS, lastTime_gameloop, lastTimeTimestep, nCLIENT, uPlayerPrototype::Num(), ePlayer::PlayerConfig(), ePlayer::PlayerIsInGame(), ePlayer::PlayerViewport(), PREPARE_TIME, se_PauseGameTimer(), se_ResetGameTimer(), sg_extraRoundTime, and sn_GetNetState().

Referenced by gGame::StateUpdate().

                                  {
#ifndef DEDICATED
    for (int i=ePlayer::Num()-1;i>=0;i--)
        if (ePlayer::PlayerIsInGame(i)){
            ePlayerNetID *p=ePlayer::PlayerConfig(i)->netPlayer;

            if ( sg_currentSettings->finishType == gFINISH_EXPRESS && ( sn_GetNetState() != nCLIENT ) )
                se_ResetGameTimer( -PREPARE_TIME/5 - sg_extraRoundTime );
            else
                se_ResetGameTimer( -PREPARE_TIME - sg_extraRoundTime );

            // se_PauseGameTimer(true);

            ePlayer::PlayerConfig(i)->cam=new gCamera(grid,
                                          ePlayer::PlayerViewport(i),
                                          p,
                                          ePlayer::PlayerConfig(i),
                                          CAMERA_SMART);

            lastTime_gameloop=lastTimeTimestep=0;
        }
#else
    se_ResetGameTimer( -PREPARE_TIME - sg_extraRoundTime );
    se_PauseGameTimer(false);
#endif
    /*
      for(int p=se_PlayerNetIDs.Len()-1;p>=0;p--){
      int i=se_PlayerNetIDs(p)->pID;

      se_ResetGameTimer(-PREPARE_TIME);
      se_PauseGameTimer(true);

      if (i>=0)
         playerConfig[i]->cam=new eCamera(PlayerViewport(i),
      se_PlayerNetIDs(p),CAMERA_SMART);
      }

    */

Here is the call graph for this function:

Here is the caller graph for this function:

void init_game_grid	(	eGrid *	grid,
		gParser *	aParser
	)

Definition at line 836 of file gGame.cpp.

References absolute_winner, gArena::PrepareGrid(), se_PauseGameTimer(), se_ResetGameTimer(), sr_glOut, sr_ResetRenderState(), winner, and wishWinner.

Referenced by gGame::StateUpdate(), and gGame::Verify().

                                                  {
    se_ResetGameTimer();
    se_PauseGameTimer(true);

#ifndef DEDICATED
    if (sr_glOut){
        sr_ResetRenderState();

        // rSysDep::ClearGL();

        // glViewport (0, 0, static_cast<GLsizei>(sr_screenWidth), static_cast<GLsizei>(sr_screenHeight));

        // rSysDep::SwapGL();
    }
    stc_fastestSpeedRound = .0;
#endif

    /*
      if(!speedup)
      SDL_Delay(1000);
    */

    Arena.PrepareGrid(grid, aParser);

    absolute_winner=winner=wishWinner=0;
}

Here is the call graph for this function:

Here is the caller graph for this function:

void init_game_objects

(

eGrid *

grid

)

Definition at line 983 of file gGame.cpp.

References gGameSettings::AI_IQ, ePlayerNetID::ControlObject(), ePlayerNetID::CurrentTeam(), eCoord, ePlayerNetID::Greet(), ePlayerNetID::IsActive(), eTeam::IsHuman(), lastTime_gameloop, lastTimeTimestep, gArena::LeastDangerousSpawnPoint(), GrowingArrayBase::Len(), rITexture::LoadAll(), gGameSettings::minPlayers, nCLIENT, NULL, gGameSettings::numAIs, eTeam::NumPlayers(), eTeam::Player(), pos, ePlayerNetID::ResetScoreDifferences(), se_PlayerNetIDs, gAIPlayer::SetNumberOfAIs(), sn_GetNetState(), gSpawnPoint::Spawn(), st_Breakpoint(), su_prefetchInput, nNetObject::SyncAll(), eTeam::teams, and eTeam::Update().

Referenced by gGame::StateUpdate().

                                   {
    /*
      static REAL r[MAX_PLAYERS]={1,.2,.2,1};
      static REAL g[MAX_PLAYERS]={.2,1,.2,1};
      static REAL b[MAX_PLAYERS]={.2,.2,1,.2};
    */

    if (sn_GetNetState()!=nCLIENT)
    {
        // update team settings
        gAIPlayer::SetNumberOfAIs(sg_currentSettings->numAIs,
                                  sg_currentSettings->minPlayers,
                                  sg_currentSettings->AI_IQ);

        int spawnPointsUsed = 0;
        for (int t=eTeam::teams.Len()-1;t>=0;t--)
        {
            eTeam *team = eTeam::teams(t);
            team->Update();

            gSpawnPoint *spawn = Arena.LeastDangerousSpawnPoint();
            spawnPointsUsed++;

            // if the spawn points are grouped, make sure the last player is not in a goup of his
            // own by skipping one spawnpoint
            if ( ( eTeam::teams(0)->IsHuman() || eTeam::teams(0)->NumPlayers() == 1 ) && sg_spawnPointGroupSize > 2 && ( spawnPointsUsed % sg_spawnPointGroupSize == sg_spawnPointGroupSize - 1 ) )
            {
                // the next spawn point is the last of this group. Skip it if
                // either only two players are left (and the one would need to play alone)
                // or we can fill the remaining groups well with one player short.
                if ( t == 2 || ( ( t % ( sg_spawnPointGroupSize - 1 ) ) == 0 && t < ( sg_spawnPointGroupSize - 1 ) * ( sg_spawnPointGroupSize - 1 ) ) )
                {
                    eCoord pos, dir;
                    spawn->Spawn( pos, dir );
                    spawn = Arena.LeastDangerousSpawnPoint();
                    spawnPointsUsed++;
                }
            }

            int numPlayers = team->NumPlayers();
            for (int p = 0; p<numPlayers; ++p)
            {
                ePlayerNetID *pni=team->Player( p );

                if ( !team->IsHuman() )
                {
                    spawn = Arena.LeastDangerousSpawnPoint();
                    spawnPointsUsed++;
                }

                //                      bool isHuman = pni->IsHuman();

                // don't give inactive players a cycle
                if (!pni->IsActive())
                    continue;

                eCoord pos,dir;
                gCycle *cycle=NULL;
                if (sn_GetNetState()!=nCLIENT){
#ifdef DEBUG
                    //                std::cout << "spawning player " << pni->name << '\n';
#endif
                    spawn->Spawn(pos,dir);
                    pni->Greet();
                    cycle = new gCycle(grid, pos, dir, pni);
                    pni->ControlObject(cycle);
                    nNetObject::SyncAll();
                }
                //    int i=se_PlayerNetIDs(p)->pID;

                // se_ResetGameTimer();
                // se_PauseGameTimer(true);
            }
        }


#ifdef ALLOW_NO_TEAM
        for (int p=se_PlayerNetIDs.Len()-1;p>=0;p--){
            ePlayerNetID *pni=se_PlayerNetIDs(p);

            gSpawnPoint *spawn=Arena.LeastDangerousSpawnPoint();

            if ( NULL == pni->CurrentTeam() )
            {
#ifdef KRAWALL_SERVER
                // don't allow unknown players to play
                if (!pni->IsAuth())
                    continue;
#endif

                // don't give inactive players a cycle
                if (!pni->IsActive())
                    continue;

                eCoord pos,dir;
                gCycle *cycle=NULL;
                if (sn_GetNetState()!=nCLIENT){
#ifdef DEBUG
                    //con << "spawning player " << se_PlayerNetIDs[p]->name << '\n';
#endif
                    st_Breakpoint();

                    spawn->Spawn(pos,dir);
                    pni->Greet();
                    cycle = new gCycle(grid, pos, dir, pni, 0);
                    pni->ControlObject(cycle);
                    nNetObject::SyncAll();
                }
                //    int i=se_PlayerNetIDs(p)->pID;

                // se_ResetGameTimer();
                // se_PauseGameTimer(true);
            }
        }
#endif
    }

    /*
    for(int p=se_PlayerNetIDs.Len()-1;p>=0;p--){
        ePlayerNetID *pni=se_PlayerNetIDs(p);

        bool isHuman = pni->IsHuman();

    #ifdef KRAWALL_SERVER
        // don't allow unknown players to play
        if (!pni->IsAuth())
                continue;
    #endif

        // don't give inactive players a cycle
        if (!pni->IsActive())
                continue;
       
        eCoord pos,dir;
        gCycle *cycle=NULL;
        if (sn_GetNetState()!=nCLIENT){
    #ifdef DEBUG
                //con << "spawning player " << se_PlayerNetIDs[p]->name << '\n';
    #endif
                spawn->Spawn(pos,dir);
                pni->Greet();
                cycle = new gCycle(grid, pos, dir, pni, 0);
                pni->ControlObject(cycle);
                nNetObject::SyncAll();
        }
        //    int i=se_PlayerNetIDs(p)->pID;

        se_ResetGameTimer();
        se_PauseGameTimer(true);

        if (sg_currentSettings->gameType==gHUMAN_VS_AI){
                //      if (Cycle(p))
                //      Cycle(p)->team=1;
                if (cycle)
                {
                        spawn=Arena.LeastDangerousSpawnPoint();
                        if (isHuman)
                                cycle->team=2;
                        else
                        {
                                cycle->team=1;
                        }
                }
        }
        else{
    #ifdef DEBUG
                //con << "new eSpawnPoint.\n";
    #endif
                if (cycle)
                {
                        spawn=Arena.LeastDangerousSpawnPoint();
                        if (isHuman)
                                cycle->team=p + 2;
                        else
                                cycle->team=1;
                }
                //      if (Cycle(p))
                //      Cycle(p)->team=p+1;
        }
    }
    */

    //  spawn=Arena.LeastDangerousSpawnPoint();

    /*
    static REAL rgb[MAXAI][3]={
      {1,1,.2},
      {1,.2,1},
      {.2,1,1},
      {1,.6,.2},
      {.2,1,.6},
      {.6,.2,1},
      {1,.2,.6},
      {.6,1,.2},
      {1,1,1},
      {.2,.2,.2}
    };
    */


    rITexture::LoadAll();
    // se_ResetGameTimer();
    // se_PauseGameTimer(true);

    su_prefetchInput=true;

    lastTime_gameloop=lastTimeTimestep=0;

    // reset scores, all players that are spawned need to get ladder points
    ePlayerNetID::ResetScoreDifferences();
}

Here is the call graph for this function:

Here is the caller graph for this function:

static void LoginCallback

(

)

[static]

Definition at line 4341 of file gGame.cpp.

                           {
    client_gamestate[nCallbackLoginLogout::User()]=0;
    if ( nCallbackLoginLogout::Login() && nCallbackLoginLogout::User() > 0 )
    {
        if ( sg_greeting.Len()>1 )
        {
            if ( sg_greetingTitle.Len() <= 1 )
                sg_greetingTitle = "Server message";

            sg_FullscreenMessage( sg_greetingTitle, sg_greeting, sg_greetingTimeout, nCallbackLoginLogout::User() );
        }

void MainMenu

(

bool

ingame

)

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 net_game

(

)

Definition at line 1857 of file gGame.cpp.

References gServerFavorites::AlternativesMenu(), gServerBrowser::BrowseLAN(), gServerBrowser::BrowseMaster(), gServerFavorites::CustomConnectMenu(), uMenu::Enter(), gServerFavorites::FavoritesMenu(), gFriends::FriendsMenu(), net_options(), and rSysDep::StopNetSyncThread().

Referenced by MainMenu().

               {
#ifndef DEDICATED
    uMenu net_menu("$network_menu_text");

    uMenuItemFunction cust
    (&net_menu,"$network_custjoin_text",
     "$network_custjoin_help",&gServerFavorites::CustomConnectMenu);

    uMenuItemFunction mas
    (&net_menu,"$masters_menu",
     "$masters_menu_help",&gServerFavorites::AlternativesMenu);

    uMenuItemFunction fav
    (&net_menu,"$bookmarks_menu",
     "$bookmarks_menu_help",&gServerFavorites::FavoritesMenu);

    uMenuItemFunction bud
    (&net_menu,"$friends_menu",
     "$friends_menu_help",&gFriends::FriendsMenu);

    uMenuItemFunction opt
    (&net_menu,"$network_opts_text",
     "$network_opts_help",&net_options);

    /*
      uMenuItemFunction serv
      (&net_menu,"$network_host_text",
      "$network_host_help",&sg_HostGameMenu);
    */

    uMenuItemFunction inter
    (&net_menu,"$network_menu_internet_text",
     "$network_menu_internet_help",&gServerBrowser::BrowseMaster);

    uMenuItemFunction lan
    (&net_menu,"$network_menu_lan_text",
     "$network_menu_lan_help",&gServerBrowser::BrowseLAN);

    gNetIdler idler;
    // rSysDep::StartNetSyncThread( &idler );
    net_menu.Enter();
    rSysDep::StopNetSyncThread();
#endif

Here is the call graph for this function:

Here is the caller graph for this function:

void net_options

(

)

Definition at line 1728 of file gGame.cpp.

References ai, uMenu::Enter(), gServerBrowser::highPort, gServerBrowser::lowPort, pingCharity, sn_maxRateIn, sn_maxRateOut, sr_laggometer, and sr_predictObjects.

Referenced by net_game().

                  {
    uMenu net_menu("$network_opts_text");

    uMenuItemInt high_port
    (&net_menu,"$network_opts_maxport_text",
     "$network_opts_maxport_help",
     gServerBrowser::highPort,1024,65536);

    uMenuItemInt low_port
    (&net_menu,"$network_opts_minport_text",
     "$network_opts_minport_help",
     gServerBrowser::lowPort,1024,65536);

    /*
        uMenuItemFunction delpw(&net_menu,
                                                        "$network_opts_deletepw_text",
                                                        "$network_opts_deletepw_help",
                                                        &se_DeletePasswords);
      
        uMenuItemSelection<int> storepw(&net_menu,
                                                                        "$login_storepw_text",
                                                                        "$login_storepw_help",
                                                                        se_PasswordStorageMode);
        storepw.NewChoice("$login_storepw_dont_text",
                                          "$login_storepw_dont_help",
                                          -1);
        storepw.NewChoice("$login_storepw_mem_text",
                                          "$login_storepw_mem_help",
                                          0);
        storepw.NewChoice("$login_storepw_disk_text",
                                          "$login_storepw_disk_help",
                                          1);
    */

    /*
      uMenuItemToggle master
      (&net_menu,"$network_opts_master_text",
      "$network_opts_master_help",
      sg_TalkToMaster);
    */


    uMenuItemInt out_rate
    (&net_menu,"$network_opts_outrate_text",
     "$network_opts_outrate_help",
     sn_maxRateOut,1,20);


    uMenuItemInt in_rate
    (&net_menu,"$network_opts_inrate_text",
     "$network_opts_inrate_help",
     sn_maxRateIn,1,20);


    uMenuItemToggle po2
    (&net_menu,"$network_opts_predict_text",
     "$network_opts_predict_help",
     sr_predictObjects);

    uMenuItemToggle lm2
    (&net_menu,"$network_opts_lagometer_text",
     "$network_opts_lagometer_help",
     sr_laggometer);

    uMenuItemToggle ai
    (&net_menu,"$network_opts_axesindicator_text",
     "$network_opts_axesindicator_help",
     sg_axesIndicator);


    uMenuItemInt p_s
    (&net_menu,"$network_opts_pingchar_text",
     "$network_opts_pingchar_help",
     pingCharity,0,300,20);

    net_menu.Enter();

    if (gServerBrowser::lowPort > gServerBrowser::highPort)
        gServerBrowser::highPort = gServerBrowser::lowPort;

Here is the call graph for this function:

Here is the caller graph for this function:

static bool notrans

(

)

[static]

Definition at line 4135 of file gGame.cpp.

References gGame::GridIsReady(), and eTransferInhibitor::User().

                     {

Here is the call graph for this function:

static void own_game

(

nNetState

enter_state

)

[static]

Definition at line 1361 of file gGame.cpp.

References ePlayerNetID::LogScoreDifferences(), NULL, se_KillGameTimer(), se_MakeGameTimer(), se_SaveToLadderLog(), se_sendEventNotification(), sg_EnterGame(), and tNEW.

Referenced by sg_HostGame(), and singlePlayer_game().

                                             {
    tNEW(gGame);
    se_MakeGameTimer();
#ifndef DEDICATED
    stc_fastestSpeedRound = .0;
#endif
    sg_EnterGame( enter_state );

    // write scores one last time
    ePlayerNetID::LogScoreDifferences();
    se_SaveToLadderLog(tString("GAME_END\n"));
    se_sendEventNotification(tString("Game end"), tString("The Game has ended"));

    sg_currentGame=NULL;
    se_KillGameTimer();

Here is the call graph for this function:

Here is the caller graph for this function:

static bool pausegame_func

(

REAL

x

)

[static]

Definition at line 3608 of file gGame.cpp.

                                  {
    static bool paused=false;

    if (x>0){
        paused=!paused;
        se_PauseGameTimer(paused);
    }

static void PlayerLogIn

(

)

[static]

Definition at line 1939 of file gGame.cpp.

References con, uMenu::Exit(), and ePlayer::LogIn().

Referenced by MainMenu().

{
    ePlayer::LogIn();

    if ( sg_IngameMenu )
    {
        sg_IngameMenu->Exit();
    }

    con << tOutput( "$player_authenticate_action" );

Here is the call graph for this function:

Here is the caller graph for this function:

static bool reloadtextures_func

(

REAL

x

)

[static]

Definition at line 3622 of file gGame.cpp.

                                       {
    if (x>0){
        rITexture::UnloadAll();
    }

void Render	(	eGrid *	grid,
		REAL	time,
		bool	swap = true
	)

Definition at line 1302 of file gGame.cpp.

References rSysDep::ClearGL(), gLogo::Display(), RenderAllViewports(), sn_defaultDelay, sr_glOut, sr_ResetRenderState(), rSysDep::SwapGL(), and tDelay().

Referenced by _wrap_EGameObject_render(), _wrap_UMenuItem_render__SWIG_0(), _wrap_UMenuItem_render__SWIG_1(), _wrap_UMenuItem_render__SWIG_2(), _wrap_UMenuItemAction_render__SWIG_0(), _wrap_UMenuItemAction_render__SWIG_1(), _wrap_UMenuItemAction_render__SWIG_2(), _wrap_UMenuItemExit_render__SWIG_0(), _wrap_UMenuItemExit_render__SWIG_1(), _wrap_UMenuItemExit_render__SWIG_2(), _wrap_UMenuItemInt_render__SWIG_0(), _wrap_UMenuItemInt_render__SWIG_1(), _wrap_UMenuItemInt_render__SWIG_2(), _wrap_UMenuItemString_render__SWIG_0(), _wrap_UMenuItemString_render__SWIG_1(), _wrap_UMenuItemString_render__SWIG_2(), _wrap_UMenuItemSubmenu_render__SWIG_0(), _wrap_UMenuItemSubmenu_render__SWIG_1(), _wrap_UMenuItemSubmenu_render__SWIG_2(), and gGame::GameLoop().

                                                   {
#ifdef DEBUG
    //  eFace::UpdateVisAll(10);
#endif
    //  se_debugExt=0;

#ifndef DEDICATED
    if (sr_glOut){
        RenderAllViewports(grid);

        sr_ResetRenderState(true);
        gLogo::Display();

        if (swap){
            rSysDep::SwapGL();
            rSysDep::ClearGL();
        }
    }
    else
    {
        if ( swap )
            rSysDep::SwapGL();

        tDelay( sn_defaultDelay );
    }
#endif

Here is the call graph for this function:

Here is the caller graph for this function:

void RenderAllViewports

(

eGrid *

grid

)

Definition at line 1263 of file gGame.cpp.

References eGrid::Cameras(), con, rViewportConfiguration::CurrentViewportConfiguration(), GrowingArrayBase::Len(), ePlayer::PlayerConfig(), rViewportConfiguration::Port(), pp_out, eGameObject::PPDisplayAll(), ePlayer::Render(), rViewportConfiguration::Select(), sr_glOut, sr_ResetRenderState(), and sr_viewportBelongsToPlayer.

Referenced by Render().

                                    {
    rViewportConfiguration *conf=rViewportConfiguration::CurrentViewportConfiguration();

    if (sr_glOut){
        sr_ResetRenderState();

        // enable distance based fog
        /*
        glFogi( GL_FOG_MODE, GL_EXP );
        glFogf( GL_FOG_DENSITY, .01/gArena::SizeMultiplier() );
        GLfloat black[3]={0,0,0};
        glFogfv( GL_FOG_COLOR, black );
        glEnable( GL_FOG );
        */

        const tList<eCamera>& cameras = grid->Cameras();

        for (int i=cameras.Len()-1;i>=0;i--){
            int p=sr_viewportBelongsToPlayer[i];
            conf->Select(i);
            rViewport *act=conf->Port(i);
            if (act && ePlayer::PlayerConfig(p))
                ePlayer::PlayerConfig(p)->Render();
            else con << "hey! viewport " << i << " does not exist!\n";
        }

        // glDisable( GL_FOG );
    }

#ifdef POWERPAK_DEB
    if (pp_out){
        eGameObject::PPDisplayAll();
        PD_ShowDoubleBuffer();
    }
#endif

Here is the call graph for this function:

Here is the caller graph for this function:

void ret_to_MainMenu

(

)

Definition at line 1706 of file gGame.cpp.

References rConsole::autoDisplayAtNewline, uMenu::Exit(), rConsole::fullscreen, gGame::NoLongerGoOn(), nSTANDALONE, NULL, uMenu::SetIdle(), sn_SetNetState(), and sr_con.

Referenced by MainMenu().

                      {
    sg_RequestedDisconnection = true;

    if (sg_HostMenu)
        sg_HostMenu->Exit();

    if (sg_IngameMenu)
        sg_IngameMenu->Exit();

    sr_con.fullscreen=true;
    sr_con.autoDisplayAtNewline=true;

    if (sg_currentGame)
        sg_currentGame->NoLongerGoOn();

    sn_SetNetState(nSTANDALONE);

    uMenu::SetIdle(NULL);

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 s_Timestep	(	eGrid *	grid,
		REAL	time,
		bool	cam
	)

Definition at line 1244 of file gGame.cpp.

References lastTimeTimestep, REAL, gNetPlayerWall::s_CopyIntoGrid(), eCamera::s_Timestep(), eGameObject::s_Timestep(), and eGameObject::SetMaxLazyLag().

Referenced by gGame::StateUpdate(), and gGame::Timestep().

                                                {
    gNetPlayerWall::s_CopyIntoGrid();
    REAL minstep = 0;
#ifdef DEDICATED
    minstep = 1.0/sg_dedicatedFPS;

    // the low possible simulation frequency, together with lazy timesteps, produces
    // this much possible extra time difference between gameobjects
    eGameObject::SetMaxLazyLag( ( 1 + sg_dedicatedFPSIdleFactor )/( sg_dedicatedFPSIdleFactor * sg_dedicatedFPS ) );
#endif
    eGameObject::s_Timestep(grid, time, minstep );

    if (cam)
        eCamera::s_Timestep(grid, time);

    lastTimeTimestep=time;

Here is the call graph for this function:

Here is the caller graph for this function:

static bool sg_AbeforeB	(	int	stateA,
		int	stateB
	)			[static]

Definition at line 2228 of file gGame.cpp.

References GS_STATE_MAX.

Referenced by gGame::ReadSync(), gGame::StateUpdate(), and gGame::SyncState().

{
    return ( ( GS_STATE_MAX + stateA - stateB ) % GS_STATE_MAX > GS_STATE_MAX >> 2 );

Here is the caller graph for this function:

static void sg_ClientFullscreenMessage

(

nMessage &

m

)

[static]

Definition at line 4215 of file gGame.cpp.

                                                   {
    if (sn_GetNetState()!=nSERVER){
        sg_fullscreenMessageTimeout = 60;

        m >> sg_fullscreenMessageTitle;
        m >> sg_fullscreenMessageMessage;
        m >> sg_fullscreenMessageTimeout;

        st_ToDo( sg_TodoClientFullscreenMessage );

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

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:

static void sg_copySettings

(

)

[static]

Definition at line 886 of file gGame.cpp.

References gGameSettings::balanceTeamsWithAIs, eTeam::balanceWithAIs, eTeam::enforceRulesOnQuit, gGameSettings::enforceTeamRulesOnQuit, gGameSettings::explosionRadius, exponent(), eTeam::maxImbalance, eTeam::maxPlayers, gGameSettings::maxPlayersPerTeam, gGameSettings::maxTeamImbalance, gGameSettings::maxTeams, eTeam::maxTeams, eTeam::minPlayers, gGameSettings::minPlayersPerTeam, gGameSettings::minTeams, eTeam::minTeams, gCycle::SetExplosionRadius(), gArena::SetSizeMultiplier(), gCycleMovement::SetSpeedMultiplier(), gCycle::SetWallsLength(), gCycle::SetWallsStayUpDelay(), gGameSettings::sizeFactor, gGameSettings::speedFactor, gGameSettings::wallsLength, and gGameSettings::wallsStayUpDelay.

Referenced by update_settings().

{
    eTeam::minTeams                                     = sg_currentSettings->minTeams;
    eTeam::maxTeams                                     = sg_currentSettings->maxTeams;
    eTeam::maxPlayers                           = sg_currentSettings->maxPlayersPerTeam;
    eTeam::minPlayers                           = sg_currentSettings->minPlayersPerTeam;
    eTeam::maxImbalance                         = sg_currentSettings->maxTeamImbalance;
    eTeam::balanceWithAIs                       = sg_currentSettings->balanceTeamsWithAIs;
    eTeam::enforceRulesOnQuit           = sg_currentSettings->enforceTeamRulesOnQuit;

    gCycle::SetWallsStayUpDelay ( sg_currentSettings->wallsStayUpDelay  );
    gCycle::SetWallsLength              ( sg_currentSettings->wallsLength               );
    gCycle::SetExplosionRadius  ( sg_currentSettings->explosionRadius   );
    gCycle::SetSpeedMultiplier  ( exponent( sg_currentSettings->speedFactor ) );
    gArena::SetSizeMultiplier   ( exponent( sg_currentSettings->sizeFactor ) );
}

Here is the call graph for this function:

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_DisplayVersionInfo

(

)

Definition at line 1951 of file gGame.cpp.

References sg_FullscreenMessage(), and st_PrintPathInfo().

Referenced by MainMenu().

                             {
    tOutput versionInfo;
    versionInfo << "$version_info_version" << "\n";
    st_PrintPathInfo(versionInfo);
    versionInfo << "$version_info_misc_stuff";
    sg_FullscreenMessage("$version_info_title", versionInfo, 1000);

Here is the call graph for this function:

Here is the caller graph for this function:

static bool sg_EnemyExists

(

int

team

)

[static]

Definition at line 2979 of file gGame.cpp.

References eTeam::Enemies(), and eTeam::teams.

Referenced by gGame::Analysis().

{
    // check if the win was legitimate: at least one enemy team needs to bo online
    for ( int i = eTeam::teams.Len()-1; i>= 0; --i )
    {
        if ( i != team && eTeam::Enemies( eTeam::teams[i], eTeam::teams[team] ) )
            return true;
    }

    return false;

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_EnterGameCleanup

(

)

[static]

Definition at line 4067 of file gGame.cpp.

{
    //gStatistics - save high scores

    eSoundMixer* mixer = eSoundMixer::GetMixer();
    mixer->SetMode(GUI_TRACK);

    sn_SetNetState( nSTANDALONE );

    // delete all AI players
    gAIPlayer::ClearAll();
    // gAIPlayer::SetNumberOfAIs(0, 0, 0, -1);
    // gAITeam::BalanceWithAIs( false );
    // gAIPlayer::ClearAll();

    gLogo::SetDisplayed(true);
    uMenu::SetIdle(NULL);
    sr_con.autoDisplayAtSwap=false;
    sr_con.fullscreen=false;

    //  exit_game_objects(grid);
    nNetObject::ClearAll();
    ePlayerNetID::ClearAll();
    sg_currentGame = NULL;

void sg_EnterGameCore

(

nNetState

enter_state

)

Definition at line 4003 of file gGame.cpp.

                                              {
    gLogo::SetBig(false);

    sg_RequestedDisconnection = false;

    sr_con.SetHeight(7);

    //  exit_game_objects(grid);
    eSoundMixer* mixer = eSoundMixer::GetMixer();
    mixer->SetMode(GRID_TRACK);

    // enter single player settings
    if ( sn_GetNetState() != nCLIENT )
    {
        sg_currentSettings = &singlePlayer;
        sg_copySettings();

        // initiate rotation
        rotate();
        gRotation::HandleNewRound();
        gRotation::HandleNewMatch();
    }

    //gStatistics - original load call

    uMenu::SetIdle(gameloop_idle);
    sr_con.autoDisplayAtSwap=true;
    bool goon=true;
    while (bool(sg_currentGame) && goon && sn_GetNetState()==enter_state){
#ifdef DEDICATED // read input
        sr_Read_stdin();

        if ( sn_BasicNetworkSystem.Select( 1.0 / ( sg_dedicatedFPSIdleFactor * sg_dedicatedFPS )  ) )
        {
            // new network data arrived, do the most urgent work now
            tAdvanceFrame();
            sg_Receive();
            se_SyncGameTimer();
            REAL time=se_GameTime();
            sg_currentGame->StateUpdate();
            if ( time > 0 )
            {
                // only simulate the objects that have pending events to execute
                eGameObject::s_Timestep(sg_currentGame->Grid(), time, 1E+10 );

                // send out updates immediately
                nNetObject::SyncAll();
                tAdvanceFrame();
                sn_SendPlanned();
            }
        }
#endif

        // do the regular simulation
        tAdvanceFrame();

        goon=GameLoop();

        st_DoToDo();
    }

static void sg_FullscreenIdle

(

)

[static]

Definition at line 4177 of file gGame.cpp.

Referenced by sg_FullscreenMessage().

{
    tAdvanceFrame();
    se_SyncGameTimer();
    gGame::NetSync();
    if ( sg_currentGame )

Here is the caller graph for this function:

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

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:

static void sg_FullscreenMessageConf

(

std::istream &

s

)

[static]

Definition at line 4303 of file gGame.cpp.

{
    // read the timeout
    REAL timeout;
    s >> timeout;

    if ( !s.good() || s.eof() )
    {
        con << "Usage: FULLSCREEN_MESSAGE <timeout> <message>\n";
        return;
    }

    // read the message
    tString message;
    message.ReadLine( s, true );

    message += "\n";

    // display it

gArena* sg_GetArena

(

)

Definition at line 2936 of file gGame.cpp.

                       {
    return &Arena;

tString sg_GetCurrentTime

(

char const *

szFormat

)

Definition at line 245 of file gGame.cpp.

References NULL.

Referenced by gGame::Analysis(), and sg_PrintCurrentTime().

{
    char szTemp[128];
    time_t     now;
    struct tm *pTime;
    now = time(NULL);
    pTime = localtime(&now);
    strftime(szTemp,sizeof(szTemp),szFormat,pTime);
    return tString(szTemp);
}

Here is the caller graph for this function:

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:

static bool sg_NetworkError	(	const tOutput &	title,
		const tOutput &	message,
		REAL	timeout
	)			[static]

Definition at line 1480 of file gGame.cpp.

References tOutput::AddLiteral(), tOutput::AddLocale(), tOutput::Append(), nServerInfoBase::GetConnectionName(), nServerInfoBase::GetPort(), tString::Len(), tConsole::Message(), sn_DenyReason, and sn_PeekRedirectTo().

Referenced by ConnectToServerCore().

{
    tOutput message2 ( message );

    if ( sn_DenyReason.Len() > 2 )
    {
        message2.AddLiteral("\n\n");
        message2.AddLocale("network_kill_preface");
        message2.AddLiteral("\n");
        message2.AddLiteral(sn_DenyReason);
    }

    nServerInfoBase * redirect = sn_PeekRedirectTo();
    if ( redirect )
    {
        message2.Append( tOutput( "$network_redirect", redirect->GetConnectionName(), (int)redirect->GetPort() ) );
    }

    return tConsole::Message( title, message2, timeout );

Here is the call graph for this function:

Here is the caller graph for this function:

int sg_NumHumans

(

)

Definition at line 863 of file gGame.cpp.

References ePlayerNetID::CurrentTeam(), ePlayerNetID::IsActive(), ePlayerNetID::IsHuman(), GrowingArrayBase::Len(), ePlayerNetID::NextTeam(), and se_PlayerNetIDs.

Referenced by update_settings().

{
    int humans = 0;
    for (int i = se_PlayerNetIDs.Len()-1; i>=0; i--)
    {
        ePlayerNetID* p = se_PlayerNetIDs(i);
        if (p->IsHuman() && p->IsActive() && ( bool(p->CurrentTeam()) || bool(p->NextTeam()) ) )
            humans++;
    }

    return humans;
}

Here is the call graph for this function:

Here is the caller graph for this function:

int sg_NumUsers

(

)

Definition at line 876 of file gGame.cpp.

References sn_NumUsers().

Referenced by gGame::Analysis(), sg_HostGame(), gGame::StateUpdate(), and update_settings().

{
    // return se_PlayerNetIDs.Len() ;
#ifdef DEDICATED
    return sn_NumUsers();
#else
    return sn_NumUsers() + 1;
#endif
}

Here is the call graph for this function:

Here is the caller graph for this function:

static void sg_ParseMap

(

gParser *

aParser

)

[static]

Definition at line 2361 of file gGame.cpp.

References mapfile, and sg_ParseMap().

{
    sg_ParseMap(aParser, mapfile);

Here is the call graph for this function:

static void sg_ParseMap	(	gParser *	aParser,
		tString	mapfile
	)			[static]

Definition at line 2329 of file gGame.cpp.

References con, DEFAULT_MAP, gMapLoadConsoleFilter::message_, nCLIENT, nSTANDALONE, and sn_GetNetState().

Referenced by sg_ParseMap(), gGame::StateUpdate(), and gGame::Verify().

{
    {
        gMapLoadConsoleFilter consoleLog;
#ifdef DEBUG
        con << "Loading map " << mapfile << "...\n";
#endif
        if (!aParser->LoadWithoutParsing(mapfile))
        {
            tOutput errorMessage( sn_GetNetState() == nCLIENT ? "$map_file_load_failure_server" : "$map_file_load_failure_self", mapfile );

#ifndef DEDICATED
            errorMessage << "\nLog:\n" << consoleLog.message_;
#endif

            con << errorMessage;

            tOutput errorTitle("$map_file_load_failure_title");

            if ( sn_GetNetState() != nSTANDALONE )
            {
                throw tGenericException( errorMessage, errorTitle );
            }

            if (!aParser->LoadWithoutParsing(DEFAULT_MAP)) {
                errorMessage << "$map_file_load_failure_default";
                throw tGenericException( errorMessage, errorTitle );
            }
        }
    }

Here is the call graph for this function:

Here is the caller graph for this function:

void sg_PrintCurrentDate

(

)

Definition at line 261 of file gGame.cpp.

References sg_PrintCurrentTime().

{
    sg_PrintCurrentTime( "%Y%m%d");
}

Here is the call graph for this function:

void sg_PrintCurrentTime

(

)

Definition at line 266 of file gGame.cpp.

References sg_PrintCurrentTime().

{
    sg_PrintCurrentTime( "%H%M%S" );
}

Here is the call graph for this function:

void sg_PrintCurrentTime

(

char const *

szFormat

)

Definition at line 256 of file gGame.cpp.

References con, and sg_GetCurrentTime().

Referenced by sg_PrintCurrentDate(), sg_PrintCurrentTime(), and sg_Timestamp().

{
    con << sg_GetCurrentTime(szFormat);
}

Here is the call graph for this function:

Here is the caller graph for this function:

void sg_Receive

(

)

Definition at line 1520 of file gGame.cpp.

References nSERVER, sn_DiscardFromControlSocket(), sn_GetNetState(), and sn_Receive().

Referenced by ConnectToServerCore(), gGame::GameLoop(), and gGame::NetSync().

{
    sn_Receive();
    if ( sn_GetNetState() == nSERVER )
    {
        // servers should ignore data sent to the control socket. It probably would be better
        // to close the socket altogether, but that opens another can of worms.
        sn_DiscardFromControlSocket();
    }

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 sg_Timestamp

(

)

Definition at line 271 of file gGame.cpp.

References con, tRecorderBase::IsRunning(), sg_PrintCurrentTime(), st_Breakpoint(), and tSysTimeFloat().

Referenced by sg_HostGame(), sg_RespawnPlayer(), and gGame::StateUpdate().

{
#ifdef DEDICATED
    sg_PrintCurrentTime( "Timestamp: %Y/%m/%d %H:%M:%S\n" );
    if ( tRecorder::IsRunning() )
    {
        con << "Uptime: " << int(tSysTimeFloat()) << " seconds.\n";

#ifdef DEBUG_X
        // to set breakpoints at specific round starts
        static double breakTime = 0;
        if ( tSysTimeFloat() > breakTime )
            st_Breakpoint();
#endif
    }
#endif
}

Here is the call graph for this function:

Here is the caller graph for this function:

static void sg_TodoClientFullscreenMessage

(

)

[static]

Definition at line 4210 of file gGame.cpp.

References sg_ClientFullscreenMessage().

{

Here is the call graph for this function:

static void sg_VoteMenuIdle

(

)

[static]

Definition at line 2546 of file gGame.cpp.

References ePlayerNetID::ChatFlags_Menu, uMenu::MenuActive(), se_ChatState(), and eVoter::VotingMenu().

Referenced by gGame::StateUpdate().

{
    if ( !uMenu::MenuActive() )
    {
        se_ChatState( ePlayerNetID::ChatFlags_Menu, true );
        eVoter::VotingMenu();
        se_ChatState( ePlayerNetID::ChatFlags_Menu, false );
    }

Here is the call graph for this function:

Here is the caller graph for this function:

static void singlePlayer_game

(

)

[static]

Definition at line 1378 of file gGame.cpp.

References ePlayerNetID::CompleteRebuild(), nSTANDALONE, own_game(), sn_SetNetState(), and update_settings().

Referenced by MainMenu().

                               {
    sn_SetNetState(nSTANDALONE);

    update_settings();
    ePlayerNetID::CompleteRebuild();

    own_game( nSTANDALONE );

Here is the call graph for this function:

Here is the caller graph for this function:

void st_PrintPathInfo

(

tOutput &

buf

)

Definition at line 1671 of file tDirectories.cpp.

References tDirectories::Config(), tDirectories::Data(), tPath::GetPaths(), tPath::GetReadPath(), tDirectories::Resource(), tDirectories::Screenshot(), and tDirectories::Var().

Referenced by sg_DisplayVersionInfo().

                                    {
    tString const hcol("0xff8888");
    buf << hcol << "$path_info_user_cfg"   << "0xRESETT\n   " << tDirectories::Var().GetReadPath("user.cfg") << "\n"
    << hcol << "$path_info_config"     << "0xRESETT\n" << tDirectories::Config().GetPaths()
    << hcol << "$path_info_resource"   << "0xRESETT\n" << tDirectories::Resource().GetPaths()
    << hcol << "$path_info_data"       << "0xRESETT\n" << tDirectories::Data().GetPaths()
    << hcol << "$path_info_screenshot" << "0xRESETT\n" << tDirectories::Screenshot().GetPaths()
    << hcol << "$path_info_var"        << "0xRESETT\n" << tDirectories::Var().GetPaths();
}

Here is the call graph for this function:

Here is the caller graph for this function:

static void StartNewMatch

(

)

[static]

Definition at line 1904 of file gGame.cpp.

References nCLIENT, sn_CenterMessage(), sn_ConsoleOut(), sn_GetNetState(), and gGame::StartNewMatch().

Referenced by MainMenu(), and StartNewMatch_conf().

                           {
    if (sg_currentGame)
        sg_currentGame->StartNewMatch();
    if (sn_GetNetState()!=nCLIENT){
        sn_CenterMessage("$gamestate_reset_center");
        sn_ConsoleOut("$gamestate_reset_console");
    }

Here is the call graph for this function:

Here is the caller graph for this function:

static void StartNewMatch_conf

(

std::istream &

)

[static]

Definition at line 1913 of file gGame.cpp.

References StartNewMatch().

                                            {
    StartNewMatch();

Here is the call graph for this function:

tCONFIG_ENUM

(

gFinishType

)

tCONFIG_ENUM

(

gGameType

)

static tCONTROLLED_PTR

(

gGame

)

[static]

static bool togglemousegrab_func

(

REAL

x

)

[static]

Definition at line 3597 of file gGame.cpp.

                                        {
    if (x>0){
        su_mouseGrab = !su_mouseGrab;
    }

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

tConfItemLine a_mod("MESSAGE_OF_DAY", sg_greeting) [static]

tSettingItem< REAL > a_modt("MESSAGE_OF_DAY_TIMEOUT", sg_greetingTimeout) [static]

tConfItemLine a_tod("TITLE_OF_DAY", sg_greetingTitle) [static]

int absolute_winner = 0 [static]

Definition at line 739 of file gGame.cpp.

Referenced by gGame::Analysis(), and init_game_grid().

gArena Arena

Definition at line 93 of file gGame.cpp.

unsigned short client_gamestate[MAXCLIENTS+2]

Definition at line 2456 of file gGame.cpp.

nDescriptor client_gs(311, client_gamestate_handler,"client_gamestate") [static]

Referenced by gGame::StateUpdate().

nSettingItemWatched<tString> conf_mapfile("MAP_FILE", mapfile, nConfItemVersionWatcher::Group_Breaking, 8) [static]

tSettingItem<int> conf_rotationtype("ROTATION_TYPE", rotationtype) [static]

REAL ded_idle = 24 [static]

Definition at line 289 of file gGame.cpp.

Referenced by sg_HostGame().

tSettingItem<REAL> dedicaded_idle("DEDICATED_IDLE", ded_idle) [static]

nNOInitialisator<gGame> game_init(310,"game") [static]

Referenced by gGame::CreatorDescriptor().

static uActionGlobalFunc ingamemenu_action & ingamemenu [static]

Definition at line 3640 of file gGame.cpp.

bool just_connected = true [static]

Definition at line 736 of file gGame.cpp.

Referenced by ConnectToServerCore(), and gGame::StateUpdate().

REAL lastdeath = 0 [static]

Definition at line 2543 of file gGame.cpp.

REAL lastTime_gameloop = 0 [static]

Definition at line 740 of file gGame.cpp.

Referenced by gGame::GameLoop(), init_game_camera(), and init_game_objects().

REAL lastTimeTimestep = 0 [static]

Definition at line 741 of file gGame.cpp.

Referenced by init_game_camera(), init_game_objects(), s_Timestep(), and gGame::Timestep().

nCallbackLoginLogout lc(LoginCallback) [static]

tString mapfile(DEFAULT_MAP) [static]

Referenced by sg_ParseMap().

tConfItem<int> mir("MAX_IN_RATE", sn_maxRateIn) [static]

tConfItem<int> mor("MAX_OUT_RATE", sn_maxRateOut) [static]

tConfItem<bool> mp_an("AUTO_AIS",multiPlayer.autoNum) [static]

tConfItem<bool> mp_aq("AUTO_IQ",multiPlayer.autoIQ) [static]

tConfItem<REAL> mp_er("EXPLOSION_RADIUS", multiPlayer.explosionRadius) [static]

tConfItem<gFinishType> mp_ft("FINISH_TYPE", multiPlayer.finishType) [static]

tConfItem<gGameType> mp_gt("GAME_TYPE", multiPlayer.gameType) [static]

tConfItem<int> mp_iq("AI_IQ",multiPlayer.AI_IQ) [static]

tSettingItem<int> mp_lr("LIMIT_ROUNDS", multiPlayer.limitRounds) [static]

tSettingItem<int> mp_ls("LIMIT_SCORE",multiPlayer.limitScore) [static]

tSettingItem<int> mp_lt("LIMIT_TIME",multiPlayer.limitTime) [static]

tConfItem<int> mp_mp("MIN_PLAYERS",multiPlayer.minPlayers) [static]

tConfItem<int> mp_mtp("TEAM_MIN_PLAYERS", multiPlayer.minPlayersPerTeam) [static]

tConfItem<int> mp_na("NUM_AIS",multiPlayer.numAIs) [static]

tConfItem<int> mp_sf("SPEED_FACTOR", multiPlayer.speedFactor) [static]

tSettingItem<int> mp_sw("SCORE_WIN",multiPlayer.scoreWin) [static]

tConfItem<bool> mp_tbai("TEAM_BALANCE_WITH_AIS", multiPlayer.balanceTeamsWithAIs) [static]

tConfItem<bool> mp_tboq("TEAM_BALANCE_ON_QUIT", multiPlayer.enforceTeamRulesOnQuit) [static]

tConfItem<int> mp_tib("TEAM_MAX_IMBALANCE", multiPlayer.maxTeamImbalance) [static]

tConfItem<int> mp_tmax("TEAMS_MAX", multiPlayer.maxTeams) [static]

tConfItem<int> mp_tmin("TEAMS_MIN", multiPlayer.minTeams) [static]

tConfItem<int> mp_tp("TEAM_MAX_PLAYERS", multiPlayer.maxPlayersPerTeam) [static]

tConfItem<REAL> mp_wl("WALLS_LENGTH", multiPlayer.wallsLength) [static]

tConfItem<REAL> mp_wsu("WALLS_STAY_UP_DELAY", multiPlayer.wallsStayUpDelay) [static]

tConfItem<int> mp_wzld("WIN_ZONE_MIN_LAST_DEATH", multiPlayer.winZoneMinLastDeath) [static]

tConfItem<int> mp_wzmr("WIN_ZONE_MIN_ROUND_TIME", multiPlayer.winZoneMinRoundTime) [static]

tConfItem<int> mp_zf("SIZE_FACTOR",multiPlayer.sizeFactor) [static]

gGameSettings multiPlayer(10, 30, 10, 100, 0, 4, 100, false, false, 0,-3, gDUEL, gFINISH_IMMEDIATELY, 2, 60, 30)

Referenced by GameSettingsMP(), and update_settings().

eTransferInhibitor inh& notrans [static]

Definition at line 4139 of file gGame.cpp.

Referenced by nServerInfo::GiveSmallServerInfo(), and nServerInfo::NetReadThis().

static uActionGlobalFunc pausegame_action & pausegame [static]

Definition at line 3618 of file gGame.cpp.

tConfItem<int> pc("PING_CHARITY", pingCharity) [static]

REAL planned_rate_control[MAXCLIENTS+2]

static uActionGlobalFunc reloadtextures_action & reloadtextures [static]

Definition at line 3629 of file gGame.cpp.

int rotationtype = 0 [static]

Definition at line 241 of file gGame.cpp.

Referenced by gGame::Analysis(), and gGame::StateUpdate().

bool roundOver = false [static]

Definition at line 2544 of file gGame.cpp.

REAL sent_per_messid[100]

Definition at line 2130 of file nNetwork.cpp.

bool sg_axesIndicator

Definition at line 3795 of file gCycle.cpp.

nDescriptor sg_clientFullscreenMessage(312, sg_ClientFullscreenMessage,"client_fsm") [static]

Referenced by sg_FullscreenMessage().

tSettingRotation sg_configRotation("CONFIG_ROTATION") [static]

tConfItem<REAL> sg_ctimeout("GAME_TIMEOUT", sg_Timeout) [static]

gGameSettings* sg_currentSettings = &singlePlayer

Definition at line 645 of file gGame.cpp.

Referenced by gCamera::MyInit().

REAL sg_extraRoundTime = 0.0f [static]

Definition at line 121 of file gGame.cpp.

Referenced by init_game_camera().

tSettingItem<REAL> sg_extraRoundTimeConf("EXTRA_ROUND_TIME", sg_extraRoundTime) [static]

tConfItemFunc sg_fullscreenMessageConf("FULLSCREEN_MESSAGE",&sg_FullscreenMessageConf) [static]

tString sg_fullscreenMessageMessage [static]

Definition at line 4208 of file gGame.cpp.

nVersionFeature sg_fullscreenMessages(14) [static]

Referenced by sg_FullscreenMessage().

REAL sg_fullscreenMessageTimeout [static]

Definition at line 4209 of file gGame.cpp.

tString sg_fullscreenMessageTitle [static]

Definition at line 4207 of file gGame.cpp.

float sg_gameTimeInterval = -1 [static]

Definition at line 292 of file gGame.cpp.

Referenced by gGame::GameLoop().

tString sg_greeting("")

REAL sg_greetingTimeout = 60

Definition at line 4338 of file gGame.cpp.

tString sg_greetingTitle("")

uMenu* sg_HostMenu = NULL

Definition at line 1704 of file gGame.cpp.

uMenu* sg_IngameMenu = NULL

Definition at line 1703 of file gGame.cpp.

REAL sg_lastChatBreakTime = -1.0f [static]

Definition at line 124 of file gGame.cpp.

Referenced by gGame::GameLoop(), and sg_FullscreenMessage().

tSettingItem<REAL> sg_lastChatBreakTimeConf("LAST_CHAT_BREAK_TIME", sg_lastChatBreakTime) [static]

tSettingRotation sg_mapRotation("MAP_ROTATION") [static]

bool sg_RequestedDisconnection = false [static]

Definition at line 1478 of file gGame.cpp.

tString sg_roundCenterMessage("") [static]

Referenced by gGame::StateUpdate().

tString sg_roundConsoleMessage("") [static]

Referenced by gGame::StateUpdate().

bool sg_singlePlayer = 0 [static]

Definition at line 737 of file gGame.cpp.

Referenced by gGame::Analysis(), and update_settings().

int sg_spawnPointGroupSize = 0 [static]

Definition at line 980 of file gGame.cpp.

tSettingItem< int > sg_spawnPointGroupSizeConf("SPAWN_POINT_GROUP_SIZE", sg_spawnPointGroupSize) [static]

bool sg_TalkToMaster = true

Definition at line 730 of file gGame.cpp.

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

REAL sg_Timeout = 5.0f [static]

Definition at line 727 of file gGame.cpp.

Referenced by gGame::StateUpdate(), and gGame::SyncState().

REAL sg_timestepMax = .2 [static]

Definition at line 2941 of file gGame.cpp.

tSettingItem<REAL> sg_timestepMaxConf("TIMESTEP_MAX", sg_timestepMax) [static]

int sg_timestepMaxCount = 10 [static]

Definition at line 2943 of file gGame.cpp.

tSettingItem<int> sg_timestepMaxCountConf("TIMESTEP_MAX_COUNT", sg_timestepMaxCount) [static]

tSettingItem<bool> sg_ttm("TALK_TO_MASTER", sg_TalkToMaster) [static]

REAL sg_winZoneRandomness = .8 [static]

Definition at line 2991 of file gGame.cpp.

tSettingItem< REAL > sg_winZoneSpreadConf("WIN_ZONE_RANDOMNESS", sg_winZoneRandomness) [static]

tSettingItem<float> sggti("LADDERLOG_GAME_TIME_INTERVAL", sg_gameTimeInterval) [static]

gGameSettings singlePlayer(10, 30, 10, 100000, 1, 0, 30, true, true, 0,-3, gDUEL, gFINISH_IMMEDIATELY, 1, 100000, 1000000)

Referenced by GameSettingsSP(), and update_settings().

tConfItemLine sn_roundCcM1_ci("ROUND_CONSOLE_MESSAGE", sg_roundConsoleMessage) [static]

tConfItemLine sn_roundCM_ci("ROUND_CENTER_MESSAGE", sg_roundCenterMessage) [static]

tConfItemFunc snm("START_NEW_MATCH",&StartNewMatch_conf) [static]

tConfItem<bool> sp_an("SP_AUTO_AIS",singlePlayer.autoNum) [static]

tConfItem<bool> sp_aq("SP_AUTO_IQ",singlePlayer.autoIQ) [static]

tConfItem<REAL> sp_er("SP_EXPLOSION_RADIUS", singlePlayer.explosionRadius) [static]

tConfItem<gFinishType> sp_ft("SP_FINISH_TYPE", singlePlayer.finishType) [static]

tConfItem<gGameType> sp_gt("SP_GAME_TYPE", singlePlayer.gameType) [static]

tConfItem<int> sp_iq("SP_AI_IQ",singlePlayer.AI_IQ) [static]

tSettingItem<int> sp_lr("SP_LIMIT_ROUNDS", singlePlayer.limitRounds) [static]

tSettingItem<int> sp_ls("SP_LIMIT_SCORE",singlePlayer.limitScore) [static]

tSettingItem<int> sp_lt("SP_LIMIT_TIME",singlePlayer.limitTime) [static]

tConfItem<int> sp_mp("SP_MIN_PLAYERS",singlePlayer.minPlayers) [static]

tConfItem<int> sp_mtp("SP_TEAM_MIN_PLAYERS", singlePlayer.minPlayersPerTeam) [static]

tConfItem<int> sp_na("SP_NUM_AIS",singlePlayer.numAIs) [static]

tConfItem<int> sp_sf("SP_SPEED_FACTOR", singlePlayer.speedFactor) [static]

tSettingItem<int> sp_sw("SP_SCORE_WIN",singlePlayer.scoreWin) [static]

tConfItem<bool> sp_tbai("SP_TEAM_BALANCE_WITH_AIS", singlePlayer.balanceTeamsWithAIs) [static]

tConfItem<bool> sp_tboq("SP_TEAM_BALANCE_ON_QUIT", singlePlayer.enforceTeamRulesOnQuit) [static]

tConfItem<int> sp_tib("SP_TEAM_MAX_IMBALANCE", singlePlayer.maxTeamImbalance) [static]

tConfItem<int> sp_tmax("SP_TEAMS_MAX", singlePlayer.maxTeams) [static]

tConfItem<int> sp_tmin("SP_TEAMS_MIN", singlePlayer.minTeams) [static]

tConfItem<int> sp_tp("SP_TEAM_MAX_PLAYERS", singlePlayer.maxPlayersPerTeam) [static]

tConfItem<REAL> sp_wl("SP_WALLS_LENGTH", singlePlayer.wallsLength) [static]

tConfItem<REAL> sp_wsu("SP_WALLS_STAY_UP_DELAY", singlePlayer.wallsStayUpDelay) [static]

tConfItem<int> sp_wzld("SP_WIN_ZONE_MIN_LAST_DEATH", singlePlayer.winZoneMinLastDeath) [static]

tConfItem<int> sp_wzmr("SP_WIN_ZONE_MIN_ROUND_TIME", singlePlayer.winZoneMinRoundTime) [static]

tConfItem<int> sp_zf("SP_SIZE_FACTOR",singlePlayer.sizeFactor) [static]

REAL stc_fastestSpeedRound

Definition at line 300 of file cCockpit.cpp.

bool think = 1

Definition at line 1234 of file gGame.cpp.

static uActionGlobalFunc togglemousegrab_action & togglemousegrab [static]

Definition at line 3604 of file gGame.cpp.

int winner = 0 [static]

Definition at line 738 of file gGame.cpp.

Referenced by gGame::Analysis(), init_game_grid(), and sg_DeclareWinner().

int wishWinner = 0 [static]

Definition at line 743 of file gGame.cpp.

Referenced by gGame::Analysis(), init_game_grid(), and sg_DeclareWinner().

char const* wishWinnerMessage = "" [static]

Definition at line 744 of file gGame.cpp.

Referenced by gGame::Analysis(), and sg_DeclareWinner().

---