1

     2

#include "Application.hh"

     3

     4

#include <stdexcept>

     5

#include <cstdio>

     6

#include <cassert>

     7

     8

enum ArgumentCodes {

     9

    ARG_HELP        = 'h',

    10

    ARG_PORT        = 'p',

    11

    ARG_SERVER      = 's',

    12

    ARG_CLIENT      = 'c',

    13

    ARG_GRAPHICS    = 'g',

    14

    ARG_FULLSCREEN  = 'F',

    15

    ARG_RESOLUTION  = 'R',

    16

    17

    ARG_LIST_MODES  = 0xff01,

    18

    ARG_VERSION     = 0xff02,

    19

};

    20

    21

    22

/**

    23

 * Set the arg_* members

    24

 */

    25

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

    26

    // set up the options

    27

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

    28

            "display argument help and exit");

    29

    30

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

    31

            "set network port used");

    32

    33

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

    34

            "act as a network server");

    35

    36

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

    37

            "act as a network client");

    38

    39

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

    40

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

    41

    42

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

    43

            "run graphics in fullscreen mode");

    44

    45

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

    46

            "set graphics resolution");

    47

    48

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

    49

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

    50

    51

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

    52

            "output application version and exit");

    53

    54

    // set defaults

    55

    arg_graphics = false;

    56

    arg_port = NETWORK_PORT_STR;

    57

    arg_server = false;

    58

    arg_connect = "";

    61

    62

    // extra state

    63

    bool resolution_default = true;

    64

    65

    try {

    66

        // parse args

    67

        args.parse_args(argc, argv);

    68

    69

    } catch (CL_Error &e) {

    70

        throw ArgumentError(e.message);

    71

    }

    72

    73

    while (args.next()) {

    74

        switch (args.get_key()) {

    75

            case ARG_HELP:

    76

                args.print_help();

    77

                return false;

    78

    79

            case ARG_PORT:

    80

                arg_port = args.get_argument();

    81

                break;

    82

    83

            case ARG_SERVER:

    84

                arg_server = true;

    85

                break;

    86

    87

            case ARG_CLIENT:

    88

                arg_connect = args.get_argument();

    89

                break;

    90

    91

            case ARG_GRAPHICS:

    92

                arg_graphics = true;

    93

                break;

    94

    95

            case ARG_FULLSCREEN:

    97

    98

                // choose best resolution unless explicitly set

    99

                if (resolution_default) {

   100

                    const CL_DisplayMode best_mode = Graphics::getBestMode();

   101

                    const CL_Size best_resolution = best_mode.get_resolution();

   102

   104

                }

   105

   106

                break;

   107

   108

            case ARG_RESOLUTION:

   109

                parse_arg_resolution(args.get_argument());

   110

                resolution_default = false;

   111

                break;

   112

   113

            case ARG_LIST_MODES:

   114

                dump_display_modes();

   115

                return false;

   116

   117

            case ARG_VERSION:

   118

                dump_version();

   119

                return false;

   120

   121

            case CL_CommandLine::REST_ARG:

   122

                throw ArgumentError(args.get_argument());

   123

   124

            default:

   125

                throw ArgumentError(std::string(1, (char) args.get_key()));

   126

   127

        }

   128

    }

   129

   130

    // check for invalid combinations of arugments

   131

    if (arg_server and !arg_connect.empty())

   132

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

   133

   134

    // enable graphics by default unless server

   135

    if (!arg_server)

   136

        arg_graphics = true;

   137

   138

    // continue

   139

    return true;

   140

}

   141

   142

void Main::parse_arg_resolution (const std::string &val) {

   143

    unsigned int w, h;

   144

   145

    // sccanf as unsigned

   146

    if (sscanf(val.c_str(), "%ux%u", &w, &h) != 2)

   147

        throw ArgumentError("invalid format for --resolution");

   148

   149

    // store as PixelCoordinate

   151

}

   152

   153

void Main::dump_display_modes (void) {

   154

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

   155

   156

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

   157

   158

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

   159

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

   160

}

   161

   162

void Main::dump_version (void) {

   163

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

   164

}

   165

   166

/**

   167

 * IT BEGAN IN AFRIKA

   168

 */

   169

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

   170

    // initialize the ClanLib components that we use

   171

    CL_SetupCore setup_core;

   172

    CL_SetupNetwork setup_network;

   173

    CL_SetupDisplay setup_disp;

   174

    CL_SetupGL setup_gl;

   175

   176

    try {

   177

        // parse arugments, exit if false

   178

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

   179

            return 0;

   180

   181

        // our engine

   182

        Engine engine;

   183

   184

        // setup graphics

   185

        if (arg_graphics)

   187

   188

        // setup either network server, client or singleplayer

   189

        if (arg_server) {

   190

            engine.setupNetworkServer(arg_port);

   191

   192

        } else if (!arg_connect.empty()) {

   193

            engine.setupNetworkClient(arg_connect, arg_port);

   194

   195

        } else {

   196

            engine.setupSinglePlayer();

   197

        }

   198

   199

        // run the main loop

   200

        engine.run();

   201

   202

        // succesful return

   203

        return 0;

   204

   205

    } catch (ArgumentError &e) {

   206

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

   207

        args.print_help();

   208

   209

        // XXX: handle --help

   210

        return 1;

   211

    } catch (CL_Error &e) {

   212

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

   213

   214

        return 1;

   215

   216

    } catch (std::exception &e) {

   217

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

   218

   219

        return 1;

   220

    }

   221

}

   222