Command Line Interface

Functions
int	main (int argc, const char *argv[])
(id)	- OOOpenALController::init
(void)	- Universe(OOPrivate)::runLocalizationTools
int	main (int argc, char *argv[])
(id)	- MyOpenGLView::init
(void)	- PlayerEntity::setGuiToIntroFirstGo:
(void)	- OOOpenGLExtensionManager(OOPrivate)::checkShadersSupported
(BOOL)	+ OOOXPVerifier::runVerificationIfRequested

Detailed Description

The command line is parsed and interpreted at various locations in the code. Here are the known functions that participate on cli arguments.

Function Documentation

checkShadersSupported

- (void) checkShadersSupported

Scans the command line for -noshaders or –noshaders arguments.

Definition at line 528 of file OOOpenGLExtensionManager.m.

{
    shadersAvailable = NO;
    shadersForceDisabled = NO;
 
    /* Some cards claim to support shaders but do so extremely
     * badly. These are listed in gpu-settings.plist where we know
     * about them; for those we don't being able to run with
     * -noshaders may help get the game up and running at a frame rate
     * where thegraphics settings can be changed.  - CIM */
    NSArray         *arguments = [[NSProcessInfo processInfo] arguments];
    NSString        *arg = nil;
    // scan for shader overrides: -noshaders || --noshaders
    foreach (arg, arguments)
    {
        if ([arg isEqual:@"-noshaders"] || [arg isEqual:@"--noshaders"])
        {
            shadersForceDisabled = YES;
            OOLog(kOOLogOpenGLShaderSupport, @"%@", @"Shaders will not be used (disabled on command line).");
            return;
        }
    }   
 
    NSString * const requiredExtension[] = 
                        {
                            @"GL_ARB_shading_language_100",
                            @"GL_ARB_fragment_shader",
                            @"GL_ARB_vertex_shader",
                            @"GL_ARB_multitexture",
                            @"GL_ARB_shader_objects",
                            nil // sentinel - don't remove!
                        };
    NSString * const *required = NULL;
    
    for (required = requiredExtension; *required != nil; ++required)
    {
        if (![self haveExtension:*required])
        {
            OOLog(kOOLogOpenGLShaderSupport, @"Shaders will not be used (OpenGL extension %@ is not available).", *required);
            return;
        }
    }
    
#if OOLITE_WINDOWS
    glGetObjectParameterivARB   =   (PFNGLGETOBJECTPARAMETERIVARBPROC)wglGetProcAddress("glGetObjectParameterivARB");
    glCreateShaderObjectARB     =   (PFNGLCREATESHADEROBJECTARBPROC)wglGetProcAddress("glCreateShaderObjectARB");
    glGetInfoLogARB             =   (PFNGLGETINFOLOGARBPROC)wglGetProcAddress("glGetInfoLogARB");
    glCreateProgramObjectARB    =   (PFNGLCREATEPROGRAMOBJECTARBPROC)wglGetProcAddress("glCreateProgramObjectARB");
    glAttachObjectARB           =   (PFNGLATTACHOBJECTARBPROC)wglGetProcAddress("glAttachObjectARB");
    glDeleteObjectARB           =   (PFNGLDELETEOBJECTARBPROC)wglGetProcAddress("glDeleteObjectARB");
    glLinkProgramARB            =   (PFNGLLINKPROGRAMARBPROC)wglGetProcAddress("glLinkProgramARB");
    glCompileShaderARB          =   (PFNGLCOMPILESHADERARBPROC)wglGetProcAddress("glCompileShaderARB");
    glShaderSourceARB           =   (PFNGLSHADERSOURCEARBPROC)wglGetProcAddress("glShaderSourceARB");
    glUseProgramObjectARB       =   (PFNGLUSEPROGRAMOBJECTARBPROC)wglGetProcAddress("glUseProgramObjectARB");
    glActiveTextureARB          =   (PFNGLACTIVETEXTUREARBPROC)wglGetProcAddress("glActiveTextureARB");
    glGetUniformLocationARB     =   (PFNGLGETUNIFORMLOCATIONARBPROC)wglGetProcAddress("glGetUniformLocationARB");
    glUniform1iARB              =   (PFNGLUNIFORM1IARBPROC)wglGetProcAddress("glUniform1iARB");
    glUniform1fARB              =   (PFNGLUNIFORM1FARBPROC)wglGetProcAddress("glUniform1fARB");
    glUniformMatrix3fvARB       =   (PFNGLUNIFORMMATRIX3FVARBPROC)wglGetProcAddress("glUniformMatrix3fvARB");
    glUniformMatrix4fvARB       =   (PFNGLUNIFORMMATRIX4FVARBPROC)wglGetProcAddress("glUniformMatrix4fvARB");
    glUniform4fvARB             =   (PFNGLUNIFORM4FVARBPROC)wglGetProcAddress("glUniform4fvARB");
    glUniform2fvARB             =   (PFNGLUNIFORM2FVARBPROC)wglGetProcAddress("glUniform2fvARB");
    glBindAttribLocationARB     =   (PFNGLBINDATTRIBLOCATIONARBPROC)wglGetProcAddress("glBindAttribLocationARB");
    glEnableVertexAttribArrayARB =  (PFNGLENABLEVERTEXATTRIBARRAYARBPROC)wglGetProcAddress("glEnableVertexAttribArrayARB");
    glVertexAttribPointerARB    =   (PFNGLVERTEXATTRIBPOINTERARBPROC)wglGetProcAddress("glVertexAttribPointerARB");
    glDisableVertexAttribArrayARB = (PFNGLDISABLEVERTEXATTRIBARRAYARBPROC)wglGetProcAddress("glDisableVertexAttribArrayARB");
    glValidateProgramARB        =   (PFNGLVALIDATEPROGRAMARBPROC)wglGetProcAddress("glValidateProgramARB");
#endif
    
    glGetIntegerv(GL_MAX_TEXTURE_IMAGE_UNITS_ARB, &textureImageUnitCount);
    
    shadersAvailable = YES;
}

References EXPECT_NOT.

init [1/2]

- (id) init

Scans the command line for -nosound or –nosound arguments.

Returns

returns the instance to OOOpenALController if sound shall be played and can be played, otherwise null

Definition at line 30 of file OOOpenALController.m.

{
    self = [super init];
    if (self != nil)
    {
        NSArray             *arguments = nil;
        NSEnumerator        *argEnum = nil;
        NSString            *arg = nil;
    
        arguments = [[NSProcessInfo processInfo] arguments];
        for (argEnum = [arguments objectEnumerator]; (arg = [argEnum nextObject]); )
        {
            if ([arg isEqual:@"-nosound"] || [arg isEqual:@"--nosound"])  
            {
                [self release];
                return nil;
            }
        }
 
        ALuint error;
        device = alcOpenDevice(NULL); // default device
        if (!device)
        {
            OOLog(kOOLogSoundInitError, @"%@", @"Failed to open default sound device");
            [self release];
            return nil;
        }
        context = alcCreateContext(device,NULL); // default context
        if (!alcMakeContextCurrent(context))
        {
            OOLog(kOOLogSoundInitError, @"%@", @"Failed to create default sound context");
            [self release];
            return nil;
        }
        if ((error = alGetError()) != AL_NO_ERROR)
        {
            OOLog(kOOLogSoundInitError,@"Error %d creating sound context",error);
        }
        OOAL(alDistanceModel(AL_NONE)); 
    }
    return self;
}

References nil, and sSingleton.

init [2/2]

- (id) init

Scans the command line for -nosplash, –nosplash, -splash, –splash- -novsync and –novsync arguments.

Definition at line 50 of file MyOpenGLView.m.

{
    self = [super init];
 
    NSString        *cmdLineArgsStr = @"Startup command: ";
 
    // SDL splash screen  settings
 
    NSUserDefaults *prefs = [NSUserDefaults standardUserDefaults];
    showSplashScreen = [prefs oo_boolForKey:@"splash-screen" defaultValue:YES];
    vSyncPreference = [prefs oo_boolForKey:@"v-sync" defaultValue:YES];
    bitsPerColorComponent = [prefs oo_boolForKey:@"hdr" defaultValue:NO] ? 16 : 8;
 
    NSArray             *arguments = nil;
    NSEnumerator        *argEnum = nil;
    NSString            *arg = nil;
    BOOL                noSplashArgFound = NO;
 
    [self initKeyMappingData];
 
    // preload the printscreen key into our translation array because SDLK_PRINTSCREEN isn't available
    scancode2Unicode[55] = gvPrintScreenKey;
 
    arguments = [[NSProcessInfo processInfo] arguments];
 
    // scan for splash screen overrides: -nosplash || --nosplash , -splash || --splash
    // scan for V-sync disabling overrides: -novsync || --novsync
    for (argEnum = [arguments objectEnumerator]; (arg = [argEnum nextObject]); )
    {
        if ([arg isEqual:@"-nosplash"] || [arg isEqual:@"--nosplash"])
        {
            showSplashScreen = NO;
            noSplashArgFound = YES; // -nosplash always trumps -splash
        }
        else if (([arg isEqual:@"-splash"] || [arg isEqual:@"--splash"]) && !noSplashArgFound)
        {
            showSplashScreen = YES;
        }
 
        // if V-sync is disabled at the command line, override the defaults file
        if ([arg isEqual:@"-novsync"] || [arg isEqual:@"--novsync"])  vSyncPreference = NO;
 
        if ([arg isEqual: @"-hdr"])  bitsPerColorComponent = 16;
 
        // build the startup command string so that we can log it
        cmdLineArgsStr = [cmdLineArgsStr stringByAppendingFormat:@"%@ ", arg];
    }
 
    OOLog(@"process.args", @"%@", cmdLineArgsStr);
 
    matrixManager = [[OOOpenGLMatrixManager alloc] init];
 
    // TODO: This code up to and including stickHandler really ought
    // not to be in this class.
    OOLog(@"sdl.init", @"%@", @"initialising SDL");
    if (!SDL_Init(SDL_INIT_VIDEO | SDL_INIT_AUDIO | SDL_INIT_JOYSTICK | SDL_INIT_GAMEPAD))
    {
        OOLog(@"sdl.init.failed", @"Unable to init SDL: %s\n", SDL_GetError());
        [self dealloc];
        return nil;
    }
 
    [self populateFullScreenModelist];
 
    // Find what the full screen and windowed settings are.
    fullScreen = NO;
    currentSize = 0;
    [self loadWindowSize];
    [self loadFullscreenSettings];
 
    // Set up the drawing surface's dimensions.
    firstScreen = (fullScreen) ? [self modeAsSize: currentSize] : currentWindowSize;
    viewSize = firstScreen; // viewSize must be set prior to splash screen initialization
 
    [OOJoystickManager setStickHandlerClass:[OOSDLJoystickManager class]];
    // end TODO
 
    [OOSound setUp];
    if (![OOSound isSoundOK])  OOLog(@"sound.init", @"%@", @"Sound system disabled.");
 
    grabMouseStatus = NO;
 
    OOLog(@"display.mode.list", @"%@", @"CREATING MODE LIST");
 
 
 
#if OOLITE_WINDOWS
    ShowWindow(windowHandle,SW_SHOWMINIMIZED);
    updateContext = !showSplashScreen;
#elif OOLITE_LINUX
    if (!showSplashScreen)
    {
        // blank the surface / go to fullscreen
        [self initialiseGLWithSize: firstScreen];
    }
#endif
 
    [self autoShowMouse];
 
    virtualJoystickPosition = NSMakePoint(0.0,0.0);
    mouseWarped = NO;
 
    _mouseVirtualStickSensitivityFactor = OOClamp_0_1_f([prefs oo_floatForKey:@"mouse-flight-sensitivity" defaultValue:0.95f]);
    // ensure no chance of a divide by zero later on
    if (_mouseVirtualStickSensitivityFactor < 0.005f)  _mouseVirtualStickSensitivityFactor = 0.005f;
 
    typedString = [[NSMutableString alloc] initWithString:@""];
    allowingStringInput = gvStringInputNo;
    isAlphabetKeyDown = NO;
 
    timeIntervalAtLastClick = timeSinceLastMouseWheel = [NSDate timeIntervalSinceReferenceDate];
 
    _mouseWheelDelta = 0.0f;
 
    m_glContextInitialized = NO;
 
    return self;
}

main() [1/2]

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

Entry point for Linux and Windows systems. Initializes logging. If -load is passed, the argument after that is loaded as savegame.

Parameters

argc	the number of command line arguments
argv	the string array values of the command line arguments

Returns

returns 0 on success, or EXITFAILURE when an exception is caught

Definition at line 68 of file main.m.

{
#ifdef GNUSTEP_BASE_LIBRARY
    int i;
 
#if (GNUSTEP_BASE_MAJOR_VERSION == 1 && (GNUSTEP_BASE_MINOR_VERSION == 24 && GNUSTEP_BASE_SUBMINOR_VERSION >= 9) || (GNUSTEP_BASE_MINOR_VERSION > 24)) || (GNUSTEP_BASE_MAJOR_VERSION > 1)
    [NSDate class]; // See github issue #202
#endif
 
#if OOLITE_WINDOWS
 
    #define OO_SHOW_MSG(ooMsg, ooMsgTitle, ooMsgFlags)  MessageBox(NULL, ooMsg, ooMsgTitle, ooMsgFlags)
    #define TABS1   "\t"
    #define TABS2   "\t\t"
    #define TABS3   "\t\t\t"
    #define TABS4   ""
 
    // Detect current working directory and set up GNUstep environment variables
    #define MAX_PATH_LEN 256
    char currentWorkingDir[MAX_PATH_LEN];
    DWORD bufferSize = MAX_PATH_LEN;
 
    QueryFullProcessImageName(GetCurrentProcess(), 0, currentWorkingDir, &bufferSize);
    // Strip the exe filenameb (from last backslash onwards), leave just the path
    char *probeString = strrchr(currentWorkingDir, '\\');
    if (probeString)  *probeString = '\0'; // currentWorkingDir now contains the path we need
 
    // Prepend system PATH env variable with our own executable's path
    char *pathEnvVar = "Path";
    const char *systemPath = SDL_getenv(pathEnvVar);
    if (!systemPath)
    {
        pathEnvVar = "PATH";
        systemPath = SDL_getenv(pathEnvVar);
    }
    size_t currentWorkingDirLen = strlen(currentWorkingDir);
    size_t systemPathLen = strlen(systemPath);
    // the max possible length of the string below is systemPath plus the path
    // we have determined for us, plus one char for the ";" and one char for the null terminator
    char *finalPath = malloc(systemPathLen + currentWorkingDirLen + 2 * sizeof(char));
    strcpy(finalPath, currentWorkingDir);
    strcat(finalPath, ";");
    strcat(finalPath, systemPath);
 
    SDL_setenv_unsafe("GNUSTEP_PATH_HANDLING", "windows", YES);
    SDL_setenv_unsafe(pathEnvVar, finalPath, YES);
    SDL_setenv_unsafe("GNUSTEP_SYSTEM_ROOT", currentWorkingDir, YES);
    SDL_setenv_unsafe("GNUSTEP_LOCAL_ROOT", currentWorkingDir, YES);
    SDL_setenv_unsafe("GNUSTEP_NETWORK_ROOT", currentWorkingDir, YES);
    SDL_setenv_unsafe("GNUSTEP_USERS_ROOT", currentWorkingDir, YES);
#if OO_GAME_DATA_TO_USER_FOLDER
    SDL_setenv_unsafe("HOMEPATH", strcat(SDL_getenv("LOCALAPPDATA"), "\\Oolite\\oolite.app"), YES);
#else
    SDL_setenv_unsafe("HOMEPATH", currentWorkingDir, YES);
#endif
 
    SetCurrentDirectory(currentWorkingDir);
 
    free(finalPath);
 
    /*  Windows amibtiously starts apps with the C library locale set to the
        system locale rather than the "C" locale as per spec. Fixing here so
        numbers don't behave strangely.
    */
    setlocale(LC_ALL, "C");
 
#else // Linux
    #define OO_SHOW_MSG(ooMsg, ooTitle, ooFlags)    fprintf(stdout, "%s", ooMsg)
    #define TABS1   "\t\t"
    #define TABS2   "\t\t\t"
    #define TABS3   "\t\t\t\t"
    #define TABS4   "\t"
#endif
 
    // Need this because we're not using the default run loop's autorelease
    // pool.
    NSAutoreleasePool *pool = [[NSAutoreleasePool alloc] init];
    OOLoggingInit();
    
    @try
    {
        // dajt: allocate and set the NSApplication delegate manually because not
        // using NIB to do this
        controller = [[GameController alloc] init];
        
        for (i = 1; i < argc; i++)
        {
            if (strcmp("-load", argv[i]) == 0)
            {
                i++;
            }
            NSString *argument = [NSString stringWithCString:argv[i]];
            if (i < argc && [[argument lowercaseString] hasSuffix:@".oolite-save"])
            {
                [controller setPlayerFileToLoad:argument];
            }
 
            if (!strcmp("-help", argv[i]) || !strcmp("--help", argv[i]))
            {
                char const *processName = [[[NSProcessInfo processInfo] processName] UTF8String];
                char s[2048];
                snprintf(s, sizeof(s), "Usage: %s [options]\n\n"
                            "Options can be any of the following: \n\n"
                            "--compile-sysdesc"TABS2"Compile system descriptions *\n"
                            "--export-sysdesc"TABS2"Export system descriptions *\n"
#if OOLITE_WINDOWS
                            "-hdr"TABS3"Start up in HDR mode\n"
#endif
                            "-load [filepath]"TABS2"Load commander from [filepath]\n"TABS3 TABS4"(\"-load\" is optional)\n"
                            "-message [messageString]"TABS1"Display [messageString] at startup\n"
                            "-nodust    "TABS2 TABS4"Do not draw space dust\n"
                            "-noshaders"TABS2 TABS4"Start up with shaders disabled\n"
                            "-nosplash    "TABS2 TABS4"Force disable splash screen on startup\n"
                            "-nosound    "TABS2 TABS4"Start up with sound disabled\n"
                            "-novsync"TABS3"Force disable V-Sync\n"
                            "--openstep"TABS2 TABS4"When compiling or exporting\n"TABS3 TABS4"system descriptions, use openstep\n"TABS3 TABS4"format *\n"
                            "-showversion"TABS2 TABS4"Display version at startup screen\n"
                            "-splash"TABS3 TABS4"Force splash screen on startup\n"
                            "-verify-oxp [filepath]    "TABS1"Verify OXP at [filepath] *\n"
                            "--xml"TABS3 TABS4"When compiling or exporting\n"TABS3 TABS4"system descriptions, use xml\n"TABS3 TABS4"format *\n"
                            "\n"
                            "Options marked with \"*\" are available only in Test Release configuration.\n"
                            "Version "OO_VERSION_FULL"\n"
                            "Debug functionality enabled (Test Release): "
#ifndef NDEBUG
                                "yes\n"
#else
                                "no\n"
#endif
                            "Built with "
#if OOLITE_HAVE_CLANG
                            "Clang version " STRINGIFY(__clang_major__) "." STRINGIFY(__clang_minor__) "." STRINGIFY(__clang_patchlevel__)
#else
                            "GCC version " STRINGIFY(__GNUC__) "." STRINGIFY(__GNUC_MINOR__) "." STRINGIFY(__GNUC_PATCHLEVEL__)
#endif  
                            "\n\n", processName
                        );
                OO_SHOW_MSG(s, processName, MB_OK);
                    OOLog(@"process.args", @"%s option detected, exiting after help page has been displayed.", argv[i]);
                return 0;
            }
        }
        
        // Release anything allocated during the controller initialisation that
        // is no longer required.
        DESTROY(pool);
        
        // Call applicationDidFinishLaunching because NSApp is not running in
        // GNUstep port.
        [controller applicationDidFinishLaunching: nil];
    }
    @catch (NSException *exception)
    {
        OOLogERR(kOOLogException, @"Root exception handler hit - terminating. This is an internal error, please report it. Exception name: %@, reason: %@", [exception name], [exception reason]);
        return EXIT_FAILURE;
    }
#endif
 
    // never reached
    return 0;
}

References GameController::applicationDidFinishLaunching:, DESTROY, kOOLogException, OO_VERSION_FULL, OOLITE_HAVE_CLANG, OOLITE_WINDOWS, OOLog, OOLogERR, OOLoggingInit(), and GameController::setPlayerFileToLoad:.

Here is the call graph for this function:

main() [2/2]

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

Entry point for MacOS. Initializes logging and runs NSApplicationMain.

Parameters

argc	the number of command line arguments
argv	the string array values of the command line arguments

Returns

whatever NSApplicationMain returns

Definition at line 18 of file main.m.

{
    OOLoggingInit();
    return NSApplicationMain(argc, argv);
}

References OOLoggingInit().

Here is the call graph for this function:

runLocalizationTools

- (void) runLocalizationTools

Scans the command line for –complie-sysdesc, –export-sysdec, –xml and –penstep arguments.

Extends class Universe.

Definition at line 10753 of file Universe.m.

{
    // Handle command line options to transform system_description array for easier localization
    
    NSArray             *arguments = nil;
    NSString            *arg = nil;
    BOOL                compileSysDesc = NO, exportSysDesc = NO, xml = NO;
    
    arguments = [[NSProcessInfo processInfo] arguments];
    
    foreach (arg, arguments)
    {
        if ([arg isEqual:@"--compile-sysdesc"])  compileSysDesc = YES;
        else if ([arg isEqual:@"--export-sysdesc"])  exportSysDesc = YES;
        else if ([arg isEqual:@"--xml"])  xml = YES;
        else if ([arg isEqual:@"--openstep"])  xml = NO;
    }
    
    if (compileSysDesc)  CompileSystemDescriptions(xml);
    if (exportSysDesc)  ExportSystemDescriptions(xml);
}

runVerificationIfRequested

+ (BOOL) runVerificationIfRequested

Scans the command line for -verify-oxp or –verify-oxp, followed by a path to the oxp to verify.

Returns

YES or NO

Definition at line 736 of file OOOXPVerifier.m.

{
    NSArray             *arguments = nil;
    NSEnumerator        *argEnum = nil;
    NSString            *arg = nil;
    NSString            *foundPath = nil;
    BOOL                exists, isDirectory;
    OOOXPVerifier       *verifier = nil;
    NSAutoreleasePool   *pool = nil;
    
    pool = [[NSAutoreleasePool alloc] init];
    
    arguments = [[NSProcessInfo processInfo] arguments];
    
    // Scan for -verify-oxp or --verify-oxp followed by relative path
    for (argEnum = [arguments objectEnumerator]; (arg = [argEnum nextObject]); )
    {
        if ([arg isEqual:@"-verify-oxp"] || [arg isEqual:@"--verify-oxp"])
        {
            foundPath = [argEnum nextObject];
            if (foundPath == nil)
            {
                OOLog(@"verifyOXP.noPath", @"***** ERROR: %@ passed without path argument; nothing to verify.", arg);
                [pool release];
                return YES;
            }
            foundPath = [foundPath stringByExpandingTildeInPath];
            break;
        }
    }
    
    if (foundPath == nil)
    {
        [pool release];
        return NO;
    }
    
    // We got a path; does it point to a directory?
    exists = [[NSFileManager defaultManager] fileExistsAtPath:foundPath isDirectory:&isDirectory];
    if (!exists)
    {
        OOLog(@"verifyOXP.badPath", @"***** ERROR: no OXP exists at path \"%@\"; nothing to verify.", foundPath);
    }
    else if (!isDirectory)
    {
        OOLog(@"verifyOXP.badPath", @"***** ERROR: \"%@\" is a file, not an OXP directory; nothing to verify.", foundPath);
    }
    else
    {
        verifier = [[OOOXPVerifier alloc] initWithPath:foundPath];
        [pool release];
        pool = [[NSAutoreleasePool alloc] init];
        [verifier run];
        [verifier release];
    }
    [pool release];
    
    // Whether or not we got a valid path, -verify-oxp was passed.
    return YES;
}

setGuiToIntroFirstGo:

- (void) setGuiToIntroFirstGo:

(BOOL)

justCobra

Scans the command line for -message or -showversion arguments.

Definition at line 9242 of file PlayerEntity.m.

                             :(BOOL)justCobra
{
    NSString        *text = nil;
    GuiDisplayGen   *gui = [UNIVERSE gui];
    OOGUIRow        msgLine = 2;
    
    [[UNIVERSE gameController] setMouseInteractionModeForUIWithMouseInteraction:NO];
    [[UNIVERSE gameView] clearMouse];
    [[UNIVERSE gameView] clearKeys];
 
 
    if (justCobra)
    {
        [UNIVERSE removeDemoShips];
        [[OOCacheManager sharedCache] flush];   // At first startup, a lot of stuff is cached
    }
    
    if (justCobra)
    {
        [self setupStartScreenGui];
        
        // check for error messages from Resource Manager
        //[ResourceManager paths]; done in Universe already
        NSString *errors = [ResourceManager errors];
        if (errors != nil)
        {
            OOGUIRow ms_start = msgLine;
            OOGUIRow i = msgLine = [gui addLongText:errors startingAtRow:ms_start align:GUI_ALIGN_LEFT];
            for (i-- ; i >= ms_start ; i--) [gui setColor:[OOColor redColor] forRow:i];
            msgLine++;
        }
        
        // check for messages from OXPs
        NSArray *OXPsWithMessages = [ResourceManager OXPsWithMessagesFound];
        if ([OXPsWithMessages count] > 0)
        {
            NSString *messageToDisplay = @"";
            
            // Show which OXPs were found with messages, but don't spam the screen if more than
            // a certain number of them exist
            if ([OXPsWithMessages count] < 5)
            {
                NSString *messageSourceList = [OXPsWithMessages componentsJoinedByString:@", "];
                messageToDisplay = OOExpandKey(@"oxp-containing-messages-list", messageSourceList);
            } else {
                messageToDisplay = OOExpandKey(@"oxp-containing-messages-found");
            }
            
            OOGUIRow ms_start = msgLine;
            OOGUIRow i = msgLine = [gui addLongText:messageToDisplay startingAtRow:ms_start align:GUI_ALIGN_LEFT];
            for (i--; i >= ms_start; i--)
            {
                [gui setColor:[OOColor orangeColor] forRow:i];
            }
            msgLine++;
        }
        
        // check for messages from the command line
        NSArray* arguments = [[NSProcessInfo processInfo] arguments];
        unsigned i;
        for (i = 0; i < [arguments count]; i++)
        {
            if (([[arguments objectAtIndex:i] isEqual:@"-message"])&&(i < [arguments count] - 1))
            {
                OOGUIRow ms_start = msgLine;
                NSString* message = [arguments oo_stringAtIndex:i + 1];
                OOGUIRow i = msgLine = [gui addLongText:message startingAtRow:ms_start align:GUI_ALIGN_CENTER];
                for (i-- ; i >= ms_start; i--)
                {
                    [gui setColor:[OOColor magentaColor] forRow:i];
                }
            }
            if ([[arguments objectAtIndex:i] isEqual:@"-showversion"])
            {
                OOGUIRow ms_start = msgLine;
                NSString *version = @"Version " @OO_VERSION_FULL;
                OOGUIRow i = msgLine = [gui addLongText:version startingAtRow:ms_start align:GUI_ALIGN_CENTER];
                for (i-- ; i >= ms_start; i--)
                {
                    [gui setColor:[OOColor magentaColor] forRow:i];
                }
            }
        }
    }
    else
    {
        [gui clear];
 
        text = DESC(@"oolite-ship-library-title");
        [gui setTitle:text];
 
        text = DESC(@"oolite-ship-library-exit");
        [gui setText:text forRow:27 align:GUI_ALIGN_CENTER];
        [gui setColor:[OOColor yellowColor] forRow:27];
    }
    
    [gui setShowTextCursor:NO];
    
    [UNIVERSE setupIntroFirstGo: justCobra];
    
    if (gui != nil)  
    {
        gui_screen = justCobra ? GUI_SCREEN_INTRO1 : GUI_SCREEN_SHIPLIBRARY;
    }
    if ([self status] == STATUS_START_GAME)
    {
        [[OOMusicController sharedController] playThemeMusic];
    }
    
    [self setShowDemoShips:YES];
    if (justCobra)
    {
        [gui setBackgroundTextureKey:@"intro"];
    }
    else
    {
        [gui setBackgroundTextureKey:@"shiplibrary"];
    }
    [UNIVERSE enterGUIViewModeWithMouseInteraction:YES];
}