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.

Extends class OOOpenGLExtensionManager.

Definition at line 529 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];
    NSEnumerator    *argEnum = nil;
    NSString        *arg = nil;
    // scan for shader overrides: -noshaders || --noshaders
    for (argEnum = [arguments objectEnumerator]; (arg = [argEnum nextObject]); )
    {
        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 -nosplash, –nosplash, -splash, –splash- -novsync and –novsync arguments.

Definition at line 50 of file MyOpenGLView.m.

{
    self = [super init];
 
    Uint32          colorkey;
    SDL_Surface     *icon=NULL;
    NSString        *imagesDir;
    NSString        *cmdLineArgsStr = @"Startup command: ";
 
    // SDL splash screen  settings
 
    NSUserDefaults *prefs = [NSUserDefaults standardUserDefaults];
    showSplashScreen = [prefs oo_boolForKey:@"splash-screen" defaultValue:YES];
    BOOL    vSyncPreference = [prefs oo_boolForKey:@"v-sync" defaultValue:YES];
    int     bitsPerColorComponent = [prefs oo_boolForKey:@"hdr" defaultValue:NO] ? 16 : 8;
    int     vSyncValue;
 
    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) < 0)
    {
        OOLog(@"sdl.init.failed", @"Unable to init SDL: %s\n", SDL_GetError());
        [self dealloc];
        return nil;
    }
 
    SDL_putenv ("SDL_VIDEO_WINDOW_POS=center");
 
    [OOJoystickManager setStickHandlerClass:[OOSDLJoystickManager class]];
    // end TODO
 
    [OOSound setUp];
    if (![OOSound isSoundOK])  OOLog(@"sound.init", @"%@", @"Sound system disabled.");
 
    // Generate the window caption, containing the version number and the date the executable was compiled.
    static char windowCaption[128];
    NSString *versionString = [NSString stringWithFormat:@"Oolite v%@", [[[NSBundle mainBundle] infoDictionary] objectForKey:@"CFBundleVersion"]];
 
    strcpy (windowCaption, [versionString UTF8String]);
    strcat (windowCaption, " - "__DATE__);
    SDL_WM_SetCaption (windowCaption, "Oolite");    // Set window title.
 
#if OOLITE_WINDOWS
    // needed for enabling system window manager events, which is needed for handling window movement messages
    SDL_EventState (SDL_SYSWMEVENT, SDL_ENABLE);
    
    //capture the window handle for later
    static SDL_SysWMinfo wInfo;
    SDL_VERSION(&wInfo.version);
    SDL_GetWMInfo(&wInfo);
    SDL_Window   = wInfo.window;
    
    // This must be inited after SDL_Window has been set - we need the main window handle in order to get monitor info
    if (![self getCurrentMonitorInfo:&monitorInfo])
    {
        OOLogWARN(@"display.initGL.monitorInfoWarning", @"Could not get current monitor information.");
    }
 
    atDesktopResolution = YES;
    
#if USE_UNDOCUMENTED_DARKMODE_API
    // dark mode stuff - this is mainly for the winodw titlebar's context menu
    HMODULE hUxTheme = LoadLibraryExW(L"uxtheme.dll", NULL, LOAD_LIBRARY_SEARCH_SYSTEM32);
    if (hUxTheme)
    {
        // hack alert! ordinal 135 is undocumented and could change in a future version of Windows
        pfnSetPreferredAppMode SetPreferredAppMode = (pfnSetPreferredAppMode)GetProcAddress(hUxTheme, MAKEINTRESOURCEA(135));
        if (SetPreferredAppMode)  SetPreferredAppMode(AllowDark);
        FreeLibrary(hUxTheme);
    }
#endif
#endif //OOLITE_WINDOWS
 
    grabMouseStatus = NO;
 
    imagesDir = [[[NSBundle mainBundle] resourcePath] stringByAppendingPathComponent:@"Images"];
    icon = SDL_LoadBMP([[imagesDir stringByAppendingPathComponent:@"WMicon.bmp"] UTF8String]);
 
    if (icon != NULL)
    {
        colorkey = SDL_MapRGB(icon->format, 128, 0, 128);
        SDL_SetColorKey(icon, SDL_SRCCOLORKEY, colorkey);
        SDL_WM_SetIcon(icon, NULL);
    }
    SDL_FreeSurface(icon);
 
    SDL_GL_SetAttribute(SDL_GL_RED_SIZE, bitsPerColorComponent);
    SDL_GL_SetAttribute(SDL_GL_GREEN_SIZE, bitsPerColorComponent);
    SDL_GL_SetAttribute(SDL_GL_BLUE_SIZE, bitsPerColorComponent);
    SDL_GL_SetAttribute(SDL_GL_ALPHA_SIZE, bitsPerColorComponent);
    SDL_GL_SetAttribute(SDL_GL_DEPTH_SIZE, 24);
    SDL_GL_SetAttribute(SDL_GL_DOUBLEBUFFER, 1);
    
    _colorSaturation = 1.0f;
    
    _hdrOutput = NO;
#if OOLITE_WINDOWS
    _hdrMaxBrightness = [prefs oo_floatForKey:@"hdr-max-brightness" defaultValue:1000.0f];
    _hdrPaperWhiteBrightness = [prefs oo_floatForKey:@"hdr-paperwhite-brightness" defaultValue:200.0f];
    if (bitsPerColorComponent == 16)
    {
        // SDL.dll built specifically for Oolite required
        SDL_GL_SetAttribute(SDL_GL_PIXEL_TYPE_FLOAT, 1);
        _hdrOutput = YES;
    }
#endif
    
    // V-sync settings - we set here, but can only verify after SDL_SetVideoMode has been called.
    SDL_GL_SetAttribute(SDL_GL_SWAP_CONTROL, vSyncPreference);  // V-sync on by default.
    OOLog(@"display.initGL", @"V-Sync %@requested.", vSyncPreference ? @"" : @"not ");
    
    /* Multisampling significantly improves graphics quality with
     * basically no extra programming effort on our part, especially
     * for curved surfaces like the planet, but is also expensive - in
     * the worst case the entire scene must be rendered four
     * times. For now it can be a hidden setting. If early testing
     * doesn't give any problems (other than speed on low-end graphics
     * cards) a game options entry might be useful. - CIM, 24 Aug 2013*/
    if ([prefs oo_boolForKey:@"anti-aliasing" defaultValue:NO])
    {
        SDL_GL_SetAttribute(SDL_GL_MULTISAMPLEBUFFERS, 1);
        SDL_GL_SetAttribute(SDL_GL_MULTISAMPLESAMPLES, 4);
    }
 
    OOLog(@"display.mode.list", @"%@", @"CREATING MODE LIST");
    [self populateFullScreenModelist];
    currentSize = 0;
 
    // Find what the full screen and windowed settings are.
    fullScreen = NO;
    [self loadFullscreenSettings];
    [self loadWindowSize];
 
    // Set up the drawing surface's dimensions.
    firstScreen= (fullScreen) ? [self modeAsSize: currentSize] : currentWindowSize;
    viewSize = firstScreen; // viewSize must be set prior to splash screen initialization
 
    OOLog(@"display.initGL", @"Trying %d-bpcc, 24-bit depth buffer", bitsPerColorComponent);
    [self createSurface];
    
    if (surface == NULL)
    {
        // Retry with hardcoded 8 bits per color component
        OOLog(@"display.initGL", @"%@", @"Trying 8-bpcc, 32-bit depth buffer");
        SDL_GL_SetAttribute(SDL_GL_RED_SIZE, 8);
        SDL_GL_SetAttribute(SDL_GL_GREEN_SIZE, 8);
        SDL_GL_SetAttribute(SDL_GL_BLUE_SIZE, 8);
        SDL_GL_SetAttribute(SDL_GL_ALPHA_SIZE, 8);
        SDL_GL_SetAttribute(SDL_GL_DEPTH_SIZE, 32);
        [self createSurface];
        
        if (surface == NULL)
        {
            // Still not working? One last go...
            // Retry, allowing 16-bit contexts.
            OOLog(@"display.initGL", @"%@", @"Trying 5-bpcc, 16-bit depth buffer");
            SDL_GL_SetAttribute(SDL_GL_RED_SIZE, 5);
            SDL_GL_SetAttribute(SDL_GL_GREEN_SIZE, 5);
            SDL_GL_SetAttribute(SDL_GL_BLUE_SIZE, 5);
            SDL_GL_SetAttribute(SDL_GL_DEPTH_SIZE, 16);
            // and if it's this bad, forget even trying to multisample!
            SDL_GL_SetAttribute(SDL_GL_MULTISAMPLEBUFFERS, 0);
            SDL_GL_SetAttribute(SDL_GL_MULTISAMPLESAMPLES, 0);
 
            [self createSurface];
 
            if (surface == NULL)
            {
                char * errStr = SDL_GetError();
                OOLogERR(@"display.mode.error", @"Could not create display surface: %s", errStr);
#if OOLITE_WINDOWS
                if (showSplashScreen)
                {
                    [[NSUserDefaults standardUserDefaults] setBool:NO forKey:@"splash-screen"];
                    [[NSUserDefaults standardUserDefaults] synchronize];
                    OOLogWARN(@"display.mode.conflict",@"Possible incompatibility between the splash screen and video drivers detected.");
                    OOLogWARN(@"display.mode.conflict",@"Oolite will start without showing the splash screen from now on. Override with 'oolite.exe -splash'");
                }
#endif
                exit(1);
            }
        }
    }
    
    int testAttrib = -1;
    OOLog(@"display.initGL", @"%@", @"Achieved color / depth buffer sizes (bits):");
    SDL_GL_GetAttribute(SDL_GL_RED_SIZE, &testAttrib);
    OOLog(@"display.initGL", @"Red: %d", testAttrib);
    SDL_GL_GetAttribute(SDL_GL_GREEN_SIZE, &testAttrib);
    OOLog(@"display.initGL", @"Green: %d", testAttrib);
    SDL_GL_GetAttribute(SDL_GL_BLUE_SIZE, &testAttrib);
    OOLog(@"display.initGL", @"Blue: %d", testAttrib);
    SDL_GL_GetAttribute(SDL_GL_ALPHA_SIZE, &testAttrib);
    OOLog(@"display.initGL", @"Alpha: %d", testAttrib);
    SDL_GL_GetAttribute(SDL_GL_DEPTH_SIZE, &testAttrib);
    OOLog(@"display.initGL", @"Depth Buffer: %d", testAttrib);
#if OOLITE_WINDOWS
    SDL_GL_GetAttribute(SDL_GL_PIXEL_TYPE_FLOAT, &testAttrib);
    OOLog(@"display.initGL", @"Pixel type is float : %d", testAttrib);
 
    OOLog(@"display.initGL", @"Pixel format index: %d", GetPixelFormat(GetDC(SDL_Window)));
#endif
    
    // Verify V-sync successfully set - report it if not
    if (vSyncPreference && SDL_GL_GetAttribute(SDL_GL_SWAP_CONTROL, &vSyncValue) == -1)
    {
        OOLogWARN(@"display.initGL", @"Could not enable V-Sync. Please check that your graphics driver supports the %@_swap_control extension.",
                    OOLITE_WINDOWS ? @"WGL_EXT" : @"[GLX_SGI/GLX_MESA]");
    }
 
    bounds.size.width = surface->w;
    bounds.size.height = surface->h;
 
    [self autoShowMouse];
 
    virtualJoystickPosition = NSMakePoint(0.0,0.0);
    mouseWarped = NO;
 
    typedString = [[NSMutableString alloc] initWithString:@""];
    allowingStringInput = gvStringInputNo;
    isAlphabetKeyDown = NO;
 
    timeIntervalAtLastClick = timeSinceLastMouseWheel = [NSDate timeIntervalSinceReferenceDate];
    
    _mouseWheelDelta = 0.0f;
 
    m_glContextInitialized = NO;
 
    return self;
}

init [2/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.

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 62 of file main.m.

{
#ifdef GNUSTEP
    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];
    char envVarString[2 * 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 finalPath[16 * MAX_PATH_LEN];
    char *systemPath = SDL_getenv("PATH");
    strcpy(finalPath, currentWorkingDir);
    strcat(finalPath, ";");
    strcat(finalPath, systemPath);
 
    #define SETENVVAR(var, value) do {\
            sprintf(envVarString, "%s=%s", (var), (value));\
            SDL_putenv (envVarString);\
            } while (0);
    
    SETENVVAR("GNUSTEP_PATH_HANDLING", "windows");
    SETENVVAR("PATH", finalPath);
    SETENVVAR("GNUSTEP_SYSTEM_ROOT", currentWorkingDir);
    SETENVVAR("GNUSTEP_LOCAL_ROOT", currentWorkingDir);
    SETENVVAR("GNUSTEP_NETWORK_ROOT", currentWorkingDir);
    SETENVVAR("GNUSTEP_USERS_ROOT", currentWorkingDir);
    SETENVVAR("HOMEPATH", currentWorkingDir);
    
    SetCurrentDirectory(currentWorkingDir);
 
    /*  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, 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++;
                if (i < argc)
                    [controller setPlayerFileToLoad: [NSString stringWithCString: argv[i]]];
            }
 
            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"
                            "-message [messageString]"TABS1"Display [messageString] at startup\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\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, 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 10697 of file Universe.m.

{
    // Handle command line options to transform system_description array for easier localization
    
    NSArray             *arguments = nil;
    NSEnumerator        *argEnum = nil;
    NSString            *arg = nil;
    BOOL                compileSysDesc = NO, exportSysDesc = NO, xml = NO;
    
    arguments = [[NSProcessInfo processInfo] arguments];
    
    for (argEnum = [arguments objectEnumerator]; (arg = [argEnum nextObject]); )
    {
        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 727 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 9211 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 = [NSString stringWithFormat:@"Version %@", [[[NSBundle mainBundle] infoDictionary] objectForKey:@"CFBundleVersion"]];
                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];
}