1

     2

#include "Application.hh"

     3

     4

#include <stdexcept>

     6

#include <cstdio>

     7

#include <cassert>

     8

     9

enum ArgumentCodes {

    10

    ARG_HELP        = 'h',

    11

    ARG_PORT        = 'p',

    12

    ARG_SERVER      = 's',

    13

    ARG_CLIENT      = 'c',

    14

    ARG_GRAPHICS    = 'g',

    15

    ARG_FULLSCREEN  = 'F',

    16

    ARG_RESOLUTION  = 'R',

    17

    23

};

    24

    34

    35

/**

    36

 * Set the arg_* members

    37

 */

    38

bool Main::parse_args (int argc, char **argv) {

    39

    // set up the options

    40

    args.add_option(ARG_HELP, "help", "",

    41

            "display argument help and exit");

    42

    43

    args.add_option(ARG_PORT, "port", "PORT",

    44

            "set network port used");

    45

    46

    args.add_option(ARG_SERVER, "server", "",

    47

            "act as a network server");

    48

    49

    args.add_option(ARG_CLIENT, "client", "SERVERHOST",

    50

            "act as a network client");

    51

    52

    args.add_option(ARG_GRAPHICS, "graphics", "",        

    53

            "run graphics/local input. Implied with --connect");

    54

    55

    args.add_option(ARG_FULLSCREEN, "fullscreen", "",

    56

            "run graphics in fullscreen mode");

    57

    58

    args.add_option(ARG_RESOLUTION, "resolution", "WIDTHxHEIGHT",

    59

            "set graphics resolution");

    60

    61

    args.add_option(ARG_LIST_MODES, "list-modes", "",

    62

            "output a list of available display modes and exit");

    63

    70

    args.add_option(ARG_VERSION, "version", "",

    71

            "output application version and exit");

    72

    73

    // extra state

    74

    bool resolution_default = true;

    75

    76

    try {

    77

        // parse args

    78

        args.parse_args(argc, argv);

    79

    80

    } catch (CL_Error &e) {

    81

        throw ArgumentError(e.message);

    82

    }

    83

    84

    while (args.next()) {

    85

        switch (args.get_key()) {

    86

            case ARG_HELP:

    87

                args.print_help();

    88

                return false;

    89

    90

            case ARG_PORT:

    92

                break;

    93

    94

            case ARG_SERVER:

    96

                break;

    97

    98

            case ARG_CLIENT:

   100

                break;

   101

   102

            case ARG_GRAPHICS:

   104

                break;

   105

   106

            case ARG_FULLSCREEN:

   107

                graphics.fullscreen = true;

   108

   109

                // choose best resolution unless explicitly set

   110

                if (resolution_default) {

   111

                    const CL_DisplayMode best_mode = Graphics::getBestMode();

   112

                    const CL_Size best_resolution = best_mode.get_resolution();

   113

   114

                    graphics.resolution = PixelCoordinate(best_resolution.width, best_resolution.height);

   115

                }

   116

   117

                break;

   118

   119

            case ARG_RESOLUTION:

   121

                resolution_default = false;

   122

                break;

   123

   124

            case ARG_LIST_MODES:

   125

                dump_display_modes();

   126

                return false;

   127

   128

            case ARG_VERSION:

   129

                dump_version();

   130

                return false;

   131

   140

            case CL_CommandLine::REST_ARG:

   142

   143

            default:

   145

   146

        }

   147

    }

   148

   149

    // check for invalid combinations of arugments

   151

        throw ArgumentError("cannot be both server and client");

   152

   153

    // enable graphics by default unless server

   156

   157

    // continue

   158

    return true;

   159

}

   160

   174

    unsigned int w, h;

   175

   176

    // sccanf as unsigned

   179

   181

}

   182

   183

void Main::dump_display_modes (void) {

   184

    const std::vector<CL_DisplayMode> &modes = Graphics::getDisplayModes();

   185

   186

    std::cout << "Available display modes:" << std::endl;

   187

   188

    for (std::vector<CL_DisplayMode>::const_iterator it = modes.begin(); it != modes.end(); it++)

   189

        std::cout << "\t" << it->get_resolution().width << "x" << it->get_resolution().height << std::endl;

   190

}

   191

   192

void Main::dump_version (void) {

   193

    std::cout << PROJECT_LONG_NAME << " version " << PROJECT_VERSION << " built " << PROJECT_BUILD_TIMESTAMP << std::endl;

   194

}

   195

   196

/**

   197

 * IT BEGAN IN AFRIKA

   198

 */

   199

int Main::main (int argc, char **argv) {

   200

    // initialize the ClanLib components that we use

   201

    CL_SetupCore setup_core;

   202

    CL_SetupNetwork setup_network;

   203

    CL_SetupDisplay setup_disp;

   204

    CL_SetupGL setup_gl;

   205

   206

    try {

   207

        // parse arugments, exit if false

   208

        if (parse_args(argc, argv) == false)

   209

            return 0;

   210

   211

        // our engine

   212

        Engine engine;

   217

   218

        // setup graphics

   220

            engine.setupGraphics(graphics);

   221

   222

        // setup either network server, client or singleplayer

   225

   228

   229

        } else {

   230

            engine.setupSinglePlayer();

   231

        }

   232

   233

        // run the main loop

   234

        engine.run();

   235

   236

        // succesful return

   237

        return 0;

   238

   239

    } catch (ArgumentError &e) {

   240

        std::cerr << e.what() << std::endl;

   241

        args.print_help();

   242

   243

        // XXX: handle --help

   244

        return 1;

   245

    } catch (CL_Error &e) {

   246

        std::cerr << "main: CL_Error:" << e.message << std::endl;

   247

   248

        return 1;

   249

   250

    } catch (std::exception &e) {

   251

        std::cerr << "FATAL [uncaught_exception] " << e.what() << std::endl;

   252

   253

        return 1;

   254

    }

   255

}

   256