#include "config.h"
#include "cs_python.h"
#include "audio/test.h"
#include "cmd/role_bitmask.h"
#include "gfxlib.h"
#include "in_kb.h"
#include "lin_time.h"
#include "main_loop.h"
#include "config_xml.h"
#include "cmd/script/mission.h"
#include "audiolib.h"
#include "vsfilesystem.h"
#include "vs_globals.h"
#include "gfx/animation.h"
#include "cmd/unit.h"
#include "gfx/cockpit.h"
#include "python/init.h"
#include "savegame.h"
#include "force_feedback.h"
#include "gfx/hud.h"
#include "gldrv/winsys.h"
#include "universe_util.h"
#include "networking/netclient.h"
#include "universe.h"
#include "save_util.h"
#include "gfx/masks.h"
#include "cmd/music.h"
#include "ship_commands.h"
#include "gamemenu.h"
#include "audio/SceneManager.h"
#include "audio/TemplateManager.h"
#include "audio/renderers/OpenAL/BorrowedOpenALRenderer.h"
#include <time.h>
#include <sys/signal.h>
#include "options.h"

Functions
void	enableNetwork (bool usenetwork)

void	setup_game_data ()

VegaConfig *	createVegaConfig (const char *file)

std::string	ParseCommandLine (int argc, char **CmdLine)

int	readCommandLineOptions (int argc, char **argv)

void	VSExit (int code)

void	cleanup (void)

void	bootstrap_main_loop ()

void	bootstrap_first_loop ()

void	nothinghappens (unsigned int, unsigned int, bool, int, int)

void	initSceneManager ()

void	initALRenderer ()

void	initScenes ()

void	closeRenderer ()

void	InitUnitTables ()

void	CleanupUnitTables ()

int	main (int argc, char *argv[])

void	SetStarSystemLoading (bool value)

bool	GetStarSystemLoading ()

void	SetSplashScreen (Animation *ss)

Animation *	GetSplashScreen ()

void	bootstrap_draw (const std::string &message, Animation *newSplashScreen)

bool	SetPlayerLoc (QVector &sys, bool set)

bool	SetPlayerSystem (std::string &sys, bool set)

vector< string >	parse_space_string (std::string s)

void	SetStartupView (Cockpit *cp)

Variables
std::string	global_username

std::string	global_password

vs_options	game_options
	needed for assert() calls. More...

Universe *	_Universe

TextPlane *	bs_tp = NULL

char	SERVER = 0

static bool	ignore_network = true

LeakVector< Mission * >	active_missions

char	mission_name [1024]

bool	isVista = false

static Animation *	SplashScreen = NULL

static bool	BootstrapMyStarSystemLoading = true

Unit **	fighters

const char	helpmessage []

Function Documentation

void bootstrap_draw	(	const std::string &	message,
		Animation *	newSplashScreen
	)

Definition at line 378 of file main.cpp.

References BootstrapMyStarSystemLoading, DEPTHTEST, TextPlane::Draw(), Animation::DrawNow(), GetElapsedTime(), VegaConfig::getVariable(), GFXBeginScene(), GFXBlendMode(), GFXClear(), GFXColor4f(), GFXDisable(), GFXEnable(), GFXEndScene(), GFXFALSE, GFXHudMode(), GFXLoadIdentity(), GFXLoadMatrixModel(), GFXTRUE, Identity(), LIGHTING, Texture::MakeActive(), MIPMAP, Music::MuzakCycle(), ONE, PROJECTION, ScaleMatrix(), TextPlane::SetCharSize(), TextPlane::SetPos(), TEXTURE0, TEXTURE1, TEXTURE2D, TEXTURE_2D, AnimatedTexture::UpdateAllFrame(), UpdateTime(), Vector, VIEW, vs_config, and ZERO.

 {
     static Animation *ani = NULL;
     static bool reentryWatchdog = false;
     if (!BootstrapMyStarSystemLoading || reentryWatchdog)
         return;
     Music::MuzakCycle();     //Allow for loading music...
     if (SplashScreen == NULL && newSplashScreen == NULL) {
         //if there's no splashscreen, we don't draw on it
         //this happens, when the splash screens texture is loaded
         return;
     }
     
     reentryWatchdog = true;
     if (newSplashScreen != NULL)
         ani = newSplashScreen;
     UpdateTime();
 
     Matrix tmp;
     Identity( tmp );
     BootstrapMyStarSystemLoading = false;
     static Texture dummy( "white.bmp", 0, MIPMAP, TEXTURE2D, TEXTURE_2D, 1 );
     BootstrapMyStarSystemLoading = true;
     dummy.MakeActive();
     GFXDisable( LIGHTING );
     GFXDisable( DEPTHTEST );
     GFXBlendMode( ONE, ZERO );
     GFXEnable( TEXTURE0 );
     GFXDisable( TEXTURE1 );
     GFXColor4f( 1, 1, 1, 1 );
     GFXClear( GFXTRUE );
     GFXLoadIdentity( PROJECTION );
     GFXLoadIdentity( VIEW );
     GFXLoadMatrixModel( tmp );
     GFXBeginScene();
 
     bs_tp->SetPos( -.99, -.97 );     //Leave a little bit of room for the bottoms of characters.
     bs_tp->SetCharSize( .4, .8 );
     ScaleMatrix( tmp, Vector( 6500, 6500, 0 ) );
     GFXLoadMatrixModel( tmp );
     GFXHudMode( GFXTRUE );
     if (ani) {
         if (GetElapsedTime() < 10) ani->UpdateAllFrame();
         {
         ani->DrawNow( tmp ); //VSFileSystem::vs_fprintf( stderr, "(new?) splash screen ('animation'?) %d.  ", (long long)ani ); //temporary, by chuck
         }
     }
 
     static std::string defaultbootmessage = vs_config->getVariable( "graphics", "default_boot_message", "" );
     static std::string initialbootmessage = vs_config->getVariable( "graphics", "initial_boot_message", "Loading..." );
     bs_tp->Draw( defaultbootmessage.length() > 0 ? defaultbootmessage : message.length() > 0 ? message : initialbootmessage );
 
     GFXHudMode( GFXFALSE );
     GFXEndScene();
 
     reentryWatchdog = false;
 }

void bootstrap_first_loop ( )

Definition at line 476 of file main.cpp.

References bootstrap_draw(), bootstrap_main_loop(), VegaConfig::getVariable(), Music::GotoSong(), i, Universe::Loop(), muzak, XMLSupport::parse_bool(), parse_space_string(), UniverseUtil::startMenuInterface(), and vs_config.

Referenced by GameUniverse::Init(), and main().

 {
     static int  i = 0;
     static std::string ss  = vs_config->getVariable( "graphics", "splash_screen", "vega_splash.ani" );
     static std::string sas = vs_config->getVariable( "graphics", "splash_audio", "" );
     static bool isgamemenu = XMLSupport::parse_bool( vs_config->getVariable( "graphics", "main_menu", "false" ) );
     if (i == 0) {
         vector< string >s  = parse_space_string( ss );
         vector< string >sa = parse_space_string( sas );
         int snum = time( NULL )%s.size();
         SplashScreen = new Animation( s[snum].c_str(), 0 );
         if ( sa.size() && sa[0].length() ) muzak->GotoSong( sa[snum%sa.size()] );
         bs_tp = new TextPlane();
     }
     bootstrap_draw( "Vegastrike Loading...", SplashScreen );
     if (i++ > 4) {
         if (_Universe) {
             if (isgamemenu)
                 UniverseUtil::startMenuInterface( true );
             else
                 _Universe->Loop( bootstrap_main_loop );
         }
     }
 }

void bootstrap_main_loop ( )

return to idle func which now should call main_loop mohahahah

Draw Texture

Definition at line 507 of file main.cpp.

References Universe::AccessCockpit(), AddUnitToSystem(), VegaConfig::bindKeys(), cleanexit, CopySavedShips(), createObjects(), Cockpit::credits, cur_check, game_data_t::difficulty, DockToSavedBases(), forcefeedback, g_game, getNewTime(), Mission::GetOrigin(), Cockpit::GetUnitFileName(), VegaConfig::getVariable(), Mission::getVariable(), global_password, global_username, UniverseUtil::hideSplashScreen(), i, ignore_network, Universe::Init(), InitializeInput(), Mission::initMission(), InitTime(), int, UniverseUtil::IOmessage(), j, k, FactionUtil::LoadContrabandLists(), LoadMission(), SaveGame::LoadSavedMissions(), Universe::Loop(), main_loop(), mission, mission_name, Network, Universe::numPlayers(), XMLSupport::parse_bool(), XMLSupport::parse_float(), XMLSupport::parse_int(), SaveGame::ParseSaveGame(), LeakVector< MyType >::push_back(), QVector, run_only_player_starsystem, Cockpit::savegame, NetClient::SetConfigServerAddress(), setNewTime(), SaveGame::SetOutputFileName(), SetPlayerLoc(), SaveGame::SetPlayerLocation(), SetPlayerSystem(), SaveGame::SetStarSystem(), SetStarSystemLoading(), SetStartupView(), Universe::SetupCockpits(), UniverseUtil::showSplashScreen(), Cockpit::TimeOfLastCollision, tostring(), Cockpit::UnpackUnitInfo(), UpdateTime(), Vector, vs_config, VSExit(), winsys_exit(), and WriteSaveGame().

Referenced by bootstrap_first_loop(), and GameMenu::processSinglePlayerButton().

 {
     static bool LoadMission  = true;
     static bool loadLastSave = XMLSupport::parse_bool( vs_config->getVariable( "general", "load_last_savegame", "false" ) );
     InitTime();
     if (LoadMission) {
         LoadMission = false;
         active_missions.push_back( mission = new Mission( mission_name ) );
 
         mission->initMission();
 
         UniverseUtil::showSplashScreen( "" );         //Twice for double or triple-buffering
         UniverseUtil::showSplashScreen( "" );
 
         QVector pos;
         string  planetname;
 
         mission->GetOrigin( pos, planetname );
         bool    setplayerloc = false;
         string  mysystem     = mission->getVariable( "system", "sol.system" );
 
         int     numplayers;
         numplayers = XMLSupport::parse_int( mission->getVariable( "num_players", "1" ) );
         vector< std::string >playername;
         vector< std::string >playerpasswd;
         string pname, ppasswd;
         for (int p = 0; p < numplayers; p++) {
             pname   = vs_config->getVariable( "player"+( (p > 0) ? tostring( p+1 ) : string( "" ) ), "callsign", "" );
             ppasswd = vs_config->getVariable( "player"+( (p > 0) ? tostring( p+1 ) : string( "" ) ), "password", "" );
             if ( p == 0 && global_username.length() )
                 pname = global_username;
             if ( p == 0 && global_password.length() )
                 ppasswd = global_password;
             if (!ignore_network) {
                 //In network mode, test if all player sections are present
                 if (pname == "") {
                     cout<<"Missing or incomlpete section for player "<<p<<endl;
                     cleanexit = true;
                     winsys_exit( 1 );
                 }
             }
             playername.push_back( pname );
             playerpasswd.push_back( ppasswd );
         }
         float  credits = XMLSupport::parse_float( mission->getVariable( "credits", "0" ) );
         g_game.difficulty = XMLSupport::parse_float( mission->getVariable( "difficulty", "1" ) );
         string savegamefile = mission->getVariable( "savegame", "" );
         vector< SavedUnits > savedun;
         vector< string >     playersaveunit;
         vector< StarSystem* >ss;
         vector< string >     starsysname;
         vector< QVector >    playerNloc;
 
         /************************* NETWORK INIT ***************************/
         vector< vector< std::string > >savefiles;
         if (!ignore_network) {
             cout<<"Number of local players = "<<numplayers<<endl;
             //Initiate the network if in networking play mode for each local player
             if (!ignore_network) {
                 setNewTime( 0. );
                 //Get the number of local players
                 Network = new NetClient[numplayers];
 
                 //Here we say we want to only handle activity in 1 starsystem not more
                 run_only_player_starsystem = true;
             } else {
                 Network = NULL;
                 cout<<"Non-networking mode"<<endl;
                 //Here we say we want to only handle activity in 1 starsystem not more
                 run_only_player_starsystem = true;
             }
         }
         _Universe->SetupCockpits( playername );
 
         /************************* NETWORK INIT ***************************/
         vector< std::string >::iterator it, jt;
         unsigned int k = 0;
         for (k = 0, it = playername.begin(), jt = playerpasswd.begin();
              k < (unsigned int) _Universe->numPlayers();
              k++, it++, jt++) {
             Cockpit    *cp = _Universe->AccessCockpit( k );
             SetStartupView( cp );
             bool        setplayerXloc = false;
             std::string psu;
             if (k == 0) {
                 QVector     myVec;
                 if ( SetPlayerLoc( myVec, false ) )
                     _Universe->AccessCockpit( 0 )->savegame->SetPlayerLocation( myVec );
                 std::string st;
                 if ( SetPlayerSystem( st, false ) )
                     _Universe->AccessCockpit( 0 )->savegame->SetStarSystem( st );
             }
             vector< SavedUnits >saved;
             /************* NETWORK PART ***************/
             vector< string > packedInfo;
             
             if (Network != NULL) {
                 string err;
                 string srvipadr;
                 unsigned short port;
                 //Are we using the directly account server to identify us ?
                 Network[k].SetConfigServerAddress( srvipadr, port );                 //Sets from the config vars.
                 if ( !Network[k].connectLoad( pname, ppasswd, err ) ) {
                     cout<<"error while connecting: "<<err<<endl;
                     VSExit( 1 );
                 }
                 savefiles.push_back( *Network[k].loginSavedGame( 0 ) );
                 
                 _Universe->AccessCockpit( k )->savegame->ParseSaveGame( "",
                                                                         mysystem,
                                                                         mysystem,
                                                                         pos,
                                                                         setplayerXloc,
                                                                         credits,
                                                                         packedInfo,
                                                                         k,
                                                                         savefiles[k][0],
                                                                         false );
                 _Universe->AccessCockpit( k )->TimeOfLastCollision = getNewTime();
             } else {
                 if (loadLastSave) {
                     _Universe->AccessCockpit( k )->savegame->ParseSaveGame( savegamefile,
                                                                             mysystem,
                                                                             mysystem,
                                                                             pos,
                                                                             setplayerXloc,
                                                                             credits,
                                                                             packedInfo,
                                                                             k );
                 } else {
                     _Universe->AccessCockpit( k )->savegame->SetOutputFileName( savegamefile );
                 }
             }
             _Universe->AccessCockpit( k )->UnpackUnitInfo(packedInfo);
             CopySavedShips( playername[k], k, packedInfo, true );
             playersaveunit.push_back( _Universe->AccessCockpit( k )->GetUnitFileName() );
             _Universe->AccessCockpit( k )->credits = credits;
             ss.push_back( _Universe->Init( mysystem, Vector( 0, 0, 0 ), planetname ) );
             if (setplayerXloc)
                 playerNloc.push_back( pos );
             else
                 playerNloc.push_back( QVector( FLT_MAX, FLT_MAX, FLT_MAX ) );
             setplayerloc = setplayerXloc;             //FIX ME will only set first player where he was
             for (unsigned int j = 0; j < saved.size(); j++)
                 savedun.push_back( saved[j] );
         }
         SetStarSystemLoading( true );
         InitializeInput();
 
         vs_config->bindKeys();         //gotta do this before we do ai
 
         createObjects( playersaveunit, ss, playerNloc, savefiles );
         while ( !savedun.empty() ) {
             AddUnitToSystem( &savedun.back() );
             savedun.pop_back();
         }
         forcefeedback = new ForceFeedback();
 
         UpdateTime();
         FactionUtil::LoadContrabandLists();
         {
             string str = vs_config->getVariable(
                 "general",
                 "intro1",
                 "Welcome to Vega Strike! Use #8080FFTab#000000 to afterburn (#8080FF+,-#000000 cruise control), #8080FFarrows#000000 to steer." );
             if ( !str.empty() ) {
                 UniverseUtil::IOmessage( 0, "game", "all", str );
                 str = vs_config->getVariable(
                     "general",
                     "intro2",
                     "The #8080FFt#000000 key targets objects; #8080FFspace#000000 fires at them & #8080FFa#000000 activates the SPEC drive. To" );
                 if ( !str.empty() ) {
                     UniverseUtil::IOmessage( 4, "game", "all", str );
                     str = vs_config->getVariable(
                         "general",
                         "intro3",
                         "go to another star system, buy a jump drive for about 10000 credits, fly to a" );
                     if ( !str.empty() ) {
                         UniverseUtil::IOmessage( 8, "game", "all", str );
                         str = vs_config->getVariable(
                             "general",
                             "intro4",
                             "wireframe jump-point and press #8080FFj#000000 to warp to a near star. Target a base or planet;" );
                         if ( !str.empty() ) {
                             UniverseUtil::IOmessage( 12, "game", "all", str );
                             str = vs_config->getVariable(
                                 "general",
                                 "intro5",
                                 "When you get close a green box will appear. Inside the box, #8080FFd#000000 will land." );
                             if ( !str.empty() )
                                 UniverseUtil::IOmessage( 16, "game", "all", str );
                         }
                     }
                 }
             }
         }
         //Never dock on load in networking if it was said so in the save file NETFIXME--this may change
         if ( Network == NULL
             && mission->getVariable( "savegame",
                                      "" ).length() != 0
             && XMLSupport::parse_bool( vs_config->getVariable( "AI", "dockOnLoad", "true" ) ) ) {
             for (size_t i = 0; i < _Universe->numPlayers(); i++) {
                 QVector vec;
                 DockToSavedBases( i, vec );
             }
         }
         cout<<"Loading completed, now network init"<<endl;
         //Send a network msg saying we are ready and also send position info
         if (Network != NULL) {
             size_t l;
             //Downloading zone info before setting inGame (CMD_ADDCLIENT) causes a race condition.
             //CMD_ADDEDYOU (response to CMD_ADDCLIENT) now sends zone info.
             for (l = 0; l < _Universe->numPlayers(); l++)
                 Network[l].inGame();
         }
         if (loadLastSave) {
             //Don't write if we didn't load...
             for (unsigned int i = 0; i < _Universe->numPlayers(); ++i)
                 WriteSaveGame( _Universe->AccessCockpit( i ), false );
         }
         cur_check = getNewTime();
         for (unsigned int i = 0; i < _Universe->numPlayers(); ++i)
             _Universe->AccessCockpit( i )->savegame->LoadSavedMissions();
         _Universe->Loop( main_loop );
         if ( XMLSupport::parse_bool( vs_config->getVariable( "splash", "auto_hide", "true" ) ) )
             UniverseUtil::hideSplashScreen();
     }
 }

void cleanup ( void )

Definition at line 146 of file main.cpp.

References AUDDestroy(), cleanexit, Music::CleanupMuzak(), CONFIGFILE, i, Network, Universe::numPlayers(), STATIC_VARS_DESTROYED, winsys_shutdown(), and Universe::WriteSaveGame().

Referenced by main().

 {
     STATIC_VARS_DESTROYED = true;
     printf( "Thank you for playing!\n" );
     //In network mode, we may not do the save since it is useless
     if (_Universe != NULL && Network == NULL)
         _Universe->WriteSaveGame( true );
 #ifdef _WIN32
 #if defined (_MSC_VER) && defined (_DEBUG)
     if (!cleanexit)
         _RPT0( _CRT_ERROR, "WARNING: Vega Strike exit not clean\n" );
     return;
 #endif
 #else
     while (!cleanexit)
         usleep(10000);
 #endif
     if (Network != NULL) {
         cout<<"Number of players"<<_Universe->numPlayers()<<endl;
         for (size_t i = 0; i < _Universe->numPlayers(); i++)
             if ( Network[i].isInGame() )
                 Network[i].logout( false );
         delete[] Network;
     }
 #if defined (CG_SUPPORT)
     if (cloak_cg->vertexProgram) cgDestroyProgram( cloak_cg->vertexProgram );
     if (cloak_cg->shaderContext) cgDestroyContext( cloak_cg->shaderContext );
 #endif
     Music::CleanupMuzak();
     winsys_shutdown();
     AUDDestroy();
     delete[] CONFIGFILE;
 }

void CleanupUnitTables ( )

Definition at line 367 of file universe_generic.cpp.

References unitTables.

Referenced by main().

 {
     for (std::vector<CSVTable*>::iterator it = unitTables.begin(); it != unitTables.end(); ++it)
     {
         delete *it;
     }
     unitTables.clear();
 }

void closeRenderer ( )

Definition at line 232 of file main.cpp.

References Singleton< SceneManager >::getSingleton().

Referenced by main(), and Audio::Test::main().

 {
     cerr << "Shutting down renderer..." << endl;
     Audio::SceneManager::getSingleton()->setRenderer( SharedPtr<Audio::Renderer>() );
 }

VegaConfig* createVegaConfig ( const char * file)

Definition at line 127 of file main.cpp.

 {
     return new GameVegaConfig( file );
 }

void enableNetwork ( bool usenetwork)

Definition at line 95 of file main.cpp.

References ignore_network.

Referenced by GameMenu::processSinglePlayerButton(), and GameMenu::readJoinGameControls().

 {
     ignore_network = !usenetwork;
 }

Animation* GetSplashScreen ( )

Definition at line 374 of file main.cpp.

References SplashScreen.

Referenced by UniverseUtil::showSplashScreen().

 {
     return SplashScreen;
 }

bool GetStarSystemLoading ( )

Definition at line 366 of file main.cpp.

References BootstrapMyStarSystemLoading.

Referenced by UniverseUtil::isSplashScreenShowing().

 {
     return BootstrapMyStarSystemLoading;
 }

void initALRenderer ( )

Definition at line 205 of file main.cpp.

References g_game, Singleton< SceneManager >::getSingleton(), Audio::SceneManager::setRenderer(), and game_data_t::sound_enabled.

Referenced by main(), and Audio::Test::main().

 {
     cerr << "  Initializing renderer..." << endl;
     Audio::SceneManager *sm = Audio::SceneManager::getSingleton();
     
     if (g_game.sound_enabled) {
         SharedPtr<Audio::Renderer> renderer(new Audio::BorrowedOpenALRenderer);
         renderer->setMeterDistance(1.0);
         renderer->setDopplerFactor(0.0);
         
         sm->setRenderer( renderer );
     }
 }

void initSceneManager ( )

Definition at line 191 of file main.cpp.

References g_game, Singleton< SceneManager >::getSingleton(), Singleton< TemplateManager >::getSingleton(), game_data_t::max_sound_sources, and Audio::SceneManager::setMaxSources().

Referenced by main(), and Audio::Test::main().

 {
     cout << "Creating scene manager..." << endl;
     Audio::SceneManager *sm = Audio::SceneManager::getSingleton();
     
     cout << "Creating template manager..." << endl;
     Audio::TemplateManager::getSingleton();
     
     if (Audio::SceneManager::getSingleton() == 0)
         throw Audio::Exception("Singleton null after SceneManager instantiation");
 
     sm->setMaxSources( g_game.max_sound_sources );
 }

void initScenes ( )

Definition at line 219 of file main.cpp.

References Audio::SceneManager::createScene(), Singleton< SceneManager >::getSingleton(), and Audio::SceneManager::setSceneActive().

Referenced by main().

 {
     Audio::SceneManager *sm = Audio::SceneManager::getSingleton();
     
     sm->createScene("video");
     sm->createScene("music");
     sm->createScene("cockpit");
     sm->createScene("base");
     sm->createScene("space");
     
     sm->setSceneActive("video", true);
 }

void InitUnitTables ( )

Definition at line 341 of file universe_generic.cpp.

Referenced by main(), and NetServer::start().

 {
     VSFile  allUnits;
     VSError err;
     static string unitdata = vs_config->getVariable( "data", "UnitCSV", "modunits.csv" );
     while (unitdata.length() != 0) {
         string::size_type where = unitdata.find( " " ), where2 = where;
         if (where == string::npos)
             where = unitdata.length();
         string tmp = unitdata.substr( 0, where );
         err = allUnits.OpenReadOnly( tmp, UnitFile );
         if (err <= Ok) {
             unitTables.push_back( new CSVTable( allUnits, allUnits.GetRoot() ) );
             allUnits.Close();
         }
         if (where2 == string::npos) break;
         unitdata = unitdata.substr( where+1, unitdata.length() );
     }
     //Now include units.csv at the end.
     err = allUnits.OpenReadOnly( "units.csv", UnitFile );
     if (err <= Ok) {
         unitTables.push_back( new CSVTable( allUnits, allUnits.GetRoot() ) );
         allUnits.Close();
     }
 }

int main	(	int	argc,
		char *	argv[]
	)

Definition at line 241 of file main.cpp.

References _Universe, AUDInit(), AUDListenerGain(), benchmark, bootstrap_first_loop(), VSFileSystem::ChangeToProgramDirectory(), cleanup(), CleanupUnitTables(), closeRenderer(), CommandInterpretor, CONFIGFILE, g_game, ROLES::getAllRolePriorities(), VegaConfig::getVariable(), ignore_network, vs_options::init(), initALRenderer(), Music::InitMuzak(), VSFileSystem::InitPaths(), initSceneManager(), initScenes(), InitShipCommands(), InitTime(), InitUnitTables(), isVista, Universe::Loop(), mission_name, game_data_t::music_enabled, XMLSupport::parse_bool(), XMLSupport::parse_float(), ParseCommandLine(), pwd, readCommandLineOptions(), setup_game_data(), test, UninitShipCommands(), UpdateTime(), vs_config, VSFileSystem::vs_fprintf(), vs_options::vsdebug, game_data_t::vsdebug, winsys_exit(), and ZeroMemory().

 {
     VSFileSystem::ChangeToProgramDirectory( argv[0] );
     CONFIGFILE = 0;
     mission_name[0] = '\0';
     {
         char pwd[8192] = "";
         if (NULL != getcwd( pwd, 8191 )) {
             pwd[8191] = '\0';
             printf( " In path %s\n", pwd );
         } else {
             printf( " In path <<path too long>>\n" );
         }
     }
 #ifdef _WIN32
     OSVERSIONINFO osvi;
     ZeroMemory( &osvi, sizeof (OSVERSIONINFO) );
     osvi.dwOSVersionInfoSize = sizeof (OSVERSIONINFO);
 
     GetVersionEx( &osvi );
     isVista = (osvi.dwMajorVersion == 6);
     printf( "Windows version %d %d\n", osvi.dwMajorVersion, osvi.dwMinorVersion );
 #endif
     /* Print copyright notice */
     printf( "Vega Strike "  " \n"
             "See http://www.gnu.org/copyleft/gpl.html for license details.\n\n" );
     /* Seed the random number generator */
     if (benchmark < 0.0)
         srand( time( NULL ) );
     else
         //in benchmark mode, always use the same seed
         srand( 171070 );
     //this sets up the vegastrike config variable
     setup_game_data();
     //loads the configuration file .vegastrike/vegastrike.config from home dir if such exists
     {
         string subdir = ParseCommandLine( argc, argv );
         cerr<<"GOT SUBDIR ARG = "<<subdir<<endl;
         if (CONFIGFILE == 0) {
             CONFIGFILE = new char[42];
             sprintf( CONFIGFILE, "vegastrike.config" );
         }
         //Specify the config file and the possible mod subdir to play
         VSFileSystem::InitPaths( CONFIGFILE, subdir );
     }
 
     //This should be put into some common function...
     //Keep in mind that initialization must also go into networking/netserver.cpp
     game_options.init();
     //If no debug argument is supplied, set to what the config file has.
     if (g_game.vsdebug == '0')
         g_game.vsdebug = game_options.vsdebug;
     //can use the vegastrike config variable to read in the default mission
     if ( XMLSupport::parse_bool( vs_config->getVariable( "network", "force_client_connect", "false" ) ) )
         ignore_network = false;
     g_game.music_enabled = XMLSupport::parse_bool( vs_config->getVariable( "audio", "Music", "true" ) );
     if (mission_name[0] == '\0') {
         std::string defmis = vs_config->getVariable( "general", "default_mission", "test/test1.mission" );
         strncpy( mission_name, defmis.c_str(), 1023 );
         mission_name[1023] = '\0';
         cerr<<"MISSION_NAME is empty using : "<<mission_name<<endl;
     }
     
 
     int exitcode;
     if ((exitcode = readCommandLineOptions(argc,argv)) >= 0)
         return exitcode;
 
     //might overwrite the default mission with the command line
     InitUnitTables();
 #ifdef HAVE_PYTHON
       Python::init();
 
       Python::test();
 #endif
 
     std::vector<std::vector <char > > temp = ROLES::getAllRolePriorities();
 #if defined(HAVE_SDL)
 #ifndef NO_SDL_JOYSTICK
     if ( SDL_InitSubSystem( SDL_INIT_JOYSTICK ) ) {
         VSFileSystem::vs_fprintf( stderr, "Couldn't initialize SDL: %s\n", SDL_GetError() );
         winsys_exit( 1 );
     }
 #endif
 #endif
 #if 0
     InitTime();
     UpdateTime();
 #endif
 
     AUDInit();
     AUDListenerGain( XMLSupport::parse_float( vs_config->getVariable( "audio", "sound_gain", ".5" ) ) );
     Music::InitMuzak();
     
     initSceneManager();
     initALRenderer();
     initScenes();
     
     //Register commands
     //COmmand Interpretor Seems to break VC8, so I'm leaving disabled for now - Patrick, Dec 24
     if ( XMLSupport::parse_bool( vs_config->getVariable( "general", "command_interpretor", "false" ) ) ) {
         CommandInterpretor = new commandI;
         InitShipCommands();
     }
     _Universe = new GameUniverse( argc, argv, vs_config->getVariable( "general", "galaxy", "milky_way.xml" ).c_str() );
     _Universe->Loop( bootstrap_first_loop );
 
     //Unregister commands - and cleanup memory
     UninitShipCommands();
     
     closeRenderer();
 
     cleanup();
 
     delete _Universe;
     CleanupUnitTables();
     return 0;
 }

void nothinghappens	(	unsigned	int,
		unsigned	int,
		bool	,
		int	,
		int
	)

Definition at line 189 of file main.cpp.

189 {}

vector< string > parse_space_string ( std::string s)

Definition at line 465 of file main.cpp.

References index.

Referenced by bootstrap_first_loop().

 {
     vector< string >  ret;
     string::size_type index = 0;
     while ( ( index = s.find( " " ) ) != string::npos ) {
         ret.push_back( s.substr( 0, index ) );
         s = s.substr( index+1 );
     }
     ret.push_back( s );
     return ret;
 }

std::string ParseCommandLine	(	int	argc,
		char **	CmdLine
	)

Definition at line 753 of file main.cpp.

References benchmark, CONFIGFILE, VSFileSystem::datadir, VSFileSystem::DirectoryExists(), g_game, global_password, global_username, helpmessage, i, ignore_network, mission_name, QVector, SetPlayerLoc(), SetPlayerSystem(), game_data_t::vsdebug, game_data_t::x_resolution, and game_data_t::y_resolution.

Referenced by main().

 {
     std::string st;
     std::string retstr;
     std::string datatmp;
     g_game.vsdebug = '0';
     QVector     PlayerLocation;
     for (int i = 1; i < argc; i++) {
         if (lpCmdLine[i][0] == '-') {
             cerr<<"ARG #"<<i<<" = "<<lpCmdLine[i]<<endl;
             switch (lpCmdLine[i][1])
             {
             case 'd':
             case 'D':
                 //Specifying data directory
                 if (lpCmdLine[i][2] == 0) {
                     cout<<"Option -D requires an argument"<<endl;
                     exit( 1 );
                 }
                 datatmp = &lpCmdLine[i][2];
                 if ( VSFileSystem::DirectoryExists( datatmp ) ) {
                     VSFileSystem::datadir = datatmp;
                 } else {
                     cout<<"Specified data directory not found... exiting"<<endl;
                     exit( 1 );
                 }
                 cout<<"Using data dir specified on command line : "<<datatmp<<endl;
                 break;
             case 'r':
             case 'R':
                 break;
             case 'N':
             case 'n':
                 if ( !(lpCmdLine[i][2] == '1' && lpCmdLine[i][3] == '\0') ) {
                     CONFIGFILE = new char[40+strlen( lpCmdLine[i] )+1];
                     sprintf( CONFIGFILE, "vegastrike.config.%splayer", lpCmdLine[i]+2 );
                 }
                 break;
             case 'M':
             case 'm':
                 retstr = string( lpCmdLine[i]+2 );
                 break;
             case 'f':
             case 'F':
                 break;
             case 'U':
             case 'u':
                 global_username = lpCmdLine[i]+2;
                 break;
             case 'P':
             case 'p':
                 global_password = lpCmdLine[i]+2;
                 break;
             case 'L':
             case 'l':
                 if ( 3 == sscanf( lpCmdLine[i]+2, "%lf,%lf,%lf", &PlayerLocation.i, &PlayerLocation.j, &PlayerLocation.k ) )
                     SetPlayerLoc( PlayerLocation, true );
                 break;
             case 'J':
             case 'j':             //low rez
                 st = string( (lpCmdLine[i])+2 );
                 SetPlayerSystem( st, true );
                 break;
             case 'A':             //average rez
             case 'a':
                 g_game.y_resolution = 600;
                 g_game.x_resolution = 800;
                 break;
             case 'H':
             case 'h':             //high rez
                 g_game.y_resolution = 768;
                 g_game.x_resolution = 1024;
                 break;
             case 'V':
             case 'v':
                 g_game.y_resolution = 1024;
                 g_game.x_resolution = 1280;
                 break;
             case 'G':
             case 'g':
                 break;
             case '-':
                 //long options
                 if (strcmp( lpCmdLine[i], "--benchmark" ) == 0) {
                     benchmark = atof( lpCmdLine[i+1] );
                     i++;
                 } else if (strcmp( lpCmdLine[i], "--net" ) == 0) {
                     //don't ignore the network section of the config file
                     ignore_network = false;
                 } else if (strcmp( lpCmdLine[i], "--help" ) == 0) {
                     cout<<helpmessage;
                     exit( 0 );
                 } else if (strncmp( lpCmdLine[i], "--debug", 7 ) == 0) {
                     if (lpCmdLine[i][7] == 0) {
                         g_game.vsdebug = 1;
                     } else if (lpCmdLine[i][8] == 0) {
                         cout<<helpmessage;
                         exit( 0 );
                     }
                     g_game.vsdebug = lpCmdLine[i][8] - '0';
                     ++i;
                 }
                 break;
             }
         } else {
             //no "-" before it - it's the mission name
             strncpy( mission_name, lpCmdLine[i], 1023 );
             mission_name[1023] = '\0';
         }
     }
     return retstr;
 }

int readCommandLineOptions	(	int	argc,
		char **	argv
	)

Returns an exit code >= 0 if the game is supposed to exit rightaway Returns an exit code < 0 if the game can continue loading.

Definition at line 866 of file main.cpp.

References i, and Audio::Test::main().

Referenced by main().

 {
     for (int i=1; i < argc; ++i) {
         if (argv[i][0] == '-') {
             if (strcmp("--test-audio", argv[i])==0) {
                 return Audio::Test::main(argc, argv);
             }
         }
     }
     return -1;
 }

bool SetPlayerLoc	(	QVector &	sys,
		bool	set
	)

Definition at line 437 of file main.cpp.

References QVector.

Referenced by bootstrap_main_loop(), and ParseCommandLine().

 {
     static QVector mysys;
     static bool    isset = false;
     if (set) {
         isset = true;
         mysys = sys;
         return true;
     } else {
         if (isset)
             sys = mysys;
         return isset;
     }
 }

bool SetPlayerSystem	(	std::string &	sys,
		bool	set
	)

Definition at line 451 of file main.cpp.

Referenced by bootstrap_main_loop(), and ParseCommandLine().

 {
     static std::string mysys;
     static bool isset = false;
     if (set) {
         isset = true;
         mysys = sys;
         return true;
     } else {
         if (isset)
             sys = mysys;
         return isset;
     }
 }

void SetSplashScreen ( Animation * ss)

Definition at line 370 of file main.cpp.

 {
     SplashScreen = ss;
 }

void SetStarSystemLoading ( bool value)

Definition at line 362 of file main.cpp.

Referenced by bootstrap_main_loop(), UniverseUtil::hideSplashScreen(), and UniverseUtil::showSplashScreen().

 {
     BootstrapMyStarSystemLoading = value;
 }

void SetStartupView ( Cockpit * cp)

Definition at line 500 of file main.cpp.

References CP_BACK, CP_CHASE, CP_FRONT, CP_TARGET, VegaConfig::getVariable(), Cockpit::SetView(), and vs_config.

Referenced by bootstrap_main_loop(), and GameCockpit::UpdAutoPilot().

 {
     static std::string startupview = vs_config->getVariable( "graphics", "startup_cockpit_view", "front" );
     cp->SetView( startupview
                 == "view_target" ? CP_TARGET : ( startupview
                                                 == "back" ? CP_BACK : (startupview == "chase" ? CP_CHASE : CP_FRONT) ) );
 }

void setup_game_data ( )

Definition at line 104 of file main.cpp.

References game_data_t::audio_frequency_mode, game_data_t::capture_mouse, game_data_t::fov, g_game, GFXFALSE, game_data_t::MouseSensitivityX, game_data_t::MouseSensitivityY, game_data_t::music_enabled, game_data_t::music_volume, game_data_t::sound_enabled, game_data_t::sound_volume, game_data_t::use_animations, game_data_t::use_logos, game_data_t::use_planet_textures, game_data_t::use_ship_textures, game_data_t::use_sprites, game_data_t::use_textures, game_data_t::use_videos, game_data_t::warning_level, game_data_t::x_resolution, and game_data_t::y_resolution.

Referenced by main().

 {
     //pass in config file l8r??
     g_game.audio_frequency_mode = 4;     //22050/16
     g_game.sound_enabled = 1;
     g_game.use_textures = 1;
     g_game.use_ship_textures    = 0;
     g_game.use_planet_textures  = 0;
     g_game.use_sprites       = 1;
     g_game.use_animations    = 1;
     g_game.use_videos        = 1;
     g_game.use_logos = 1;
     g_game.music_enabled     = 1;
     g_game.sound_volume      = 1;
     g_game.music_volume      = 1;
     g_game.warning_level     = 20;
     g_game.capture_mouse     = GFXFALSE;
     g_game.y_resolution      = 768;
     g_game.x_resolution      = 1024;
     g_game.fov = 78;
     g_game.MouseSensitivityX = 2;
     g_game.MouseSensitivityY = 4;
 }

void VSExit ( int code)

Definition at line 140 of file main.cpp.

References Music::CleanupMuzak(), and winsys_exit().

 {
     Music::CleanupMuzak();
     winsys_exit( code );
 }

Variable Documentation

Universe* _Universe

Definition at line 88 of file main.cpp.

bool BootstrapMyStarSystemLoading = true

static

Definition at line 361 of file main.cpp.

Referenced by bootstrap_draw(), GetStarSystemLoading(), and SetStarSystemLoading().

TextPlane* bs_tp = NULL

Definition at line 89 of file main.cpp.

Unit** fighters

Definition at line 74 of file main_loop.cpp.

Referenced by destroyObjects().

vs_options game_options

needed for assert() calls.

Draws cockpit parts Draws gauges, info strings, radar, ...

Definition at line 83 of file main.cpp.

std::string global_password

Definition at line 19 of file netclient_login.cpp.

Referenced by NetClient::authenticate(), bootstrap_main_loop(), and ParseCommandLine().

std::string global_username

Definition at line 18 of file netclient_login.cpp.

Referenced by NetClient::authenticate(), bootstrap_main_loop(), createObjects(), and ParseCommandLine().

const char helpmessage[]

Initial value:

=
    "Command line options for vegastrike\n"
    "\n"
    " -D -d \t Specify data directory\n"
    " -N -n \t Number of players\n"
    " -M -m \t Specify a mod to play\n"
    " -P -p \t Specify player location\n"
    " -J -j \t Start in a specific system\n"
    " -A -a \t Normal resolution (800x600)\n"
    " -H -h \t High resolution (1024x768)\n"
    " -V -v \t Super high resolution (1280x1024)\n"
    " --net \t Networking Enabled (Experimental)\n"
    " --debug[=#] \t Enable debugging output, 1 major warnings, 2 medium, 3 developer notes\n"
    " --test-audio \t Run audio tests\n"
    "\n"