1

     2

#include "Application.hh"

     3

#include "Config.hh"

     4

     5

#if GRAPHICS_ENABLED

     6

    // for dump_display_modes

     7

    #include "Graphics/Display.hh"

     8

     9

    // for CL_SetupGL

    10

    #include <ClanLib/gl.h>

    11

#endif

    12

    13

#include <stdexcept>

    14

#include <sstream>

    15

#include <cstdio>

    16

#include <cassert>

    17

    18

enum ArgumentCodes {

    19

    ARG_HELP        = 'h',

    20

    ARG_PORT        = 'p',

    21

    ARG_SERVER      = 's',

    22

    ARG_CLIENT      = 'c',

    23

    ARG_GRAPHICS    = 'g',

    24

    ARG_FULLSCREEN  = 'F',

    25

    ARG_RESOLUTION  = 'R',

    26

    27

    ARG_LIST_MODES      = 0xff01,

    28

    ARG_VERSION         = 0xff02,

    29

    ARG_TERRAIN_SEED    = 0xff03,

    30

    ARG_TERRAIN_SIZE    = 0xff04,

    31

    ARG_LOG_LEVEL       = 0xff05,

    32

    33

};

    34

    35

    36

Main::Main (void) :

    37

    graphics_enabled(false),

    38

    net_port(NETWORK_PORT_STR),

    39

    net_server(false),

    40

    net_connect("")

    41

{

    42

    43

}

    44

    45

/**

    46

 * Set the arg_* members

    47

 */

    48

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

    49

    50

    // set up the options

    51

    args.add_usage("[OPTIONS]");

    52

    args.set_help_indent(30);

    53

    54

    if (NETWORK_ENABLED) {

    55

        args.add_group("Network");

    56

    57

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

    58

                "set network port used");

    59

    60

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

    61

                "act as a network server");

    62

    63

        // require graphics for network-client

    64

        if (GRAPHICS_ENABLED)

    65

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

    66

                    "act as a network client");

    67

    }

    68

    69

    if (GRAPHICS_ENABLED) {

    70

        args.add_group("Graphics");

    71

    72

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

    73

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

    74

    75

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

    76

                "run graphics in fullscreen mode");

    77

    78

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

    79

                "set graphics resolution");

    80

    81

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

    82

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

    83

    }

    84

    85

    args.add_group("Game");

    86

    args.add_option(ARG_TERRAIN_SEED, "terrain-seed", "SEED",

    87

            "set seed for terrain random generator");

    88

    89

    args.add_option(ARG_TERRAIN_SIZE, "terrain-size", "WIDTHxHEIGHT",

    90

            "set terrain size for random generator");

    91

    92

    93

    args.add_group("General");

    94

    args.add_option(ARG_LOG_LEVEL, "log-level", "LEVEL",

    95

            "set maximum log level to one of FATAL/ERROR/WARN/INFO/DEBUG");

    96

    97

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

    98

            "display argument help and exit");

    99

   100

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

   101

            "output application version plus configuration and exit");

   102

   103

#if GRAPHICS_ENABLED    

   104

    // extra state

   105

    bool resolution_default = true;

   106

   107

#endif    

   108

   109

    try {

   110

        // parse args

   111

        args.parse_args(argc, argv);

   112

   113

    } catch (CL_Error &e) {

   114

        throw ArgumentError(e.message);

   115

    }

   116

   117

    while (args.next()) {

   118

        switch (args.get_key()) {

   119

            case ARG_HELP:

   120

                args.print_help();

   121

                return false;

   122

   123

            case ARG_LOG_LEVEL:

   124

                engine.log_level = parse_arg_loglevel(args.get_argument(), "--log-level");

   125

                break;

   126

   127

#if NETWORK_ENABLED                

   128

            case ARG_PORT:

   129

                net_port = args.get_argument();

   130

                break;

   131

   132

            case ARG_SERVER:

   133

                net_server = true;

   134

                break;

   135

   136

            case ARG_CLIENT:

   137

                net_connect = args.get_argument();

   138

                break;

   139

   140

#endif                

   141

   142

#if GRAPHICS_ENABLED                

   143

            case ARG_GRAPHICS:

   144

                graphics_enabled = true;

   145

                break;

   146

   147

            case ARG_FULLSCREEN:

   148

                display.fullscreen = true;

   149

   150

                // choose best resolution unless explicitly set

   151

                if (resolution_default) {

   152

                    const CL_DisplayMode best_mode = graphics::Display::getBestMode();

   153

                    const CL_Size best_resolution = best_mode.get_resolution();

   154

   155

                    display.resolution = PixelDimensions(best_resolution.width, best_resolution.height);

   156

                }

   157

   158

                break;

   159

   160

            case ARG_RESOLUTION:

   161

                display.resolution = parse_arg_dimensions(args.get_argument(), "--resolution");

   162

                resolution_default = false;

   163

                break;

   164

   165

            case ARG_LIST_MODES:

   166

                dump_display_modes();

   167

                return false;

   168

#endif

   169

   170

            case ARG_VERSION:

   171

                dump_version();

   172

                return false;

   173

   174

            case ARG_TERRAIN_SEED:

   175

                terrain.random_seed = parse_arg_int(args.get_argument(), "--terrain-seed");

   176

                break;

   177

   178

            case ARG_TERRAIN_SIZE:

   179

                terrain.dimensions = parse_arg_dimensions(args.get_argument(), "--terrain-size");

   180

                break;

   181

   182

            case CL_CommandLine::REST_ARG:

   183

                throw ArgumentError("Trailing arguments: " + args.get_argument());

   184

   185

            default:

   186

                throw ArgumentError(std::string() + "Unknown argument key: " + (char) args.get_key());

   187

   188

        }

   189

    }

   190

   191

#if NETWORK_ENABLED    

   192

    // check for invalid combinations of arugments

   193

    if (net_server and !net_connect.empty())

   194

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

   195

#endif

   196

   197

#if GRAPHICS_ENABLED    

   198

    // enable graphics by default unless server

   199

    if (!net_server)

   200

        graphics_enabled = true;

   201

#endif    

   202

   203

    // continue

   204

    return true;

   205

}

   206

   207

int Main::parse_arg_int (const std::string &arg_val, const char *arg_name) {

   208

    int int_val;

   209

   210

    // read using istringstream

   211

    std::istringstream ss(arg_val);

   212

   213

    if (!(ss >> int_val))

   214

        throw ArgumentError(std::string() + "invalid integer arugment for " + arg_name + ": " + arg_val);

   215

   216

    return int_val;

   217

}

   218

   219

PixelDimensions Main::parse_arg_dimensions (const std::string &arg_val, const char *arg_name) {

   220

    unsigned int w, h;

   221

   222

    // sccanf as unsigned

   223

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

   224

        throw ArgumentError(std::string() + "invalid format for " + arg_name + ": " + arg_val);

   225

   226

    return PixelDimensions(w, h);

   227

}

   228

   229

LogLevel Main::parse_arg_loglevel (const std::string &arg_val, const char *arg_name) {

   230

    // brute-force if-elseif

   231

    if (arg_val == "FATAL")

   232

        return FATAL;

   233

   234

    else if (arg_val == "ERROR")

   235

        return ERROR;

   236

   237

    else if (arg_val == "WARN")

   238

        return WARN;

   239

   240

    else if (arg_val == "INFO")

   241

        return INFO;

   242

   243

    else if (arg_val == "DEBUG")

   244

        return DEBUG;

   245

   246

    else

   247

        throw ArgumentError(std::string() + "invalid log level for " + arg_name + ": " + arg_val);

   248

}

   249

   250

#if GRAPHICS_ENABLED

   251

void Main::dump_display_modes (void) {

   252

    // get the list of display modes from graphics

   253

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

   254

    PixelCoordinate last_resolution;

   255

   256

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

   257

   258

    // iterate over the list of available display modes

   259

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

   260

        PixelCoordinate resolution(it->get_resolution().width, it->get_resolution().height);

   261

   262

        // filter out those that haven't changed

   263

        if (resolution != last_resolution)

   264

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

   265

   266

        // update for next item

   267

        last_resolution = resolution;

   268

    }

   269

}

   270

#endif

   271

   272

void Main::dump_version (void) {

   273

    std::cout 

   274

        << PROJECT_LONG_NAME << " version " << PROJECT_VERSION << " built [" << PROJECT_BUILD_TIMESTAMP << "]" << std::endl;

   275

   276

    // then some additional stuff about what's enabled

   277

    std::cout

   278

        << std::endl

   279

        << "Enabled components:" << std::endl

   280

        << "\tGraphics:\t" << (GRAPHICS_ENABLED ? "Yes" : "No") << std::endl

   281

        << "\tNetwork:\t" << (NETWORK_ENABLED ? "Yes" : "No") << std::endl;

   282

}

   283

   284

/**

   285

 * IT BEGAN IN AFRIKA

   286

 */

   287

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

   288

    // initialize the ClanLib components that we use

   289

    CL_SetupCore setup_core;

   290

   291

#if GRAPHICS_ENABLED    

   292

    // XXX: move to Graphics/Graphics.hh?

   293

    CL_SetupDisplay setup_disp;

   294

    CL_SetupGL setup_gl;

   295

#endif

   296

   297

    try {

   298

        // parse arugments, exit if false

   299

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

   300

            return EXIT_SUCCESS;

   301

   302

        // our engine

   303

        Engine engine(this->engine);

   304

   305

        // setup game unless client

   306

        if (net_connect.empty())

   307

            engine.setupGame(terrain);

   308

   309

        // setup graphics

   310

        if (graphics_enabled)

   311

            engine.setupGraphics(display);

   312

   313

        // setup either network server, client or singleplayer

   314

        if (net_server) {

   315

            engine.setupNetworkServer(net_port);

   316

   317

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

   318

            engine.setupNetworkClient(net_connect, net_port);

   319

   320

        } else if (graphics_enabled) {

   321

            engine.setupSinglePlayer();

   322

   323

        } else {

   324

            throw ArgumentError("Nothing to do");

   325

   326

        }

   327

   328

        // run the main loop

   329

        engine.run();

   330

   331

        // succesful return

   332

        return EXIT_SUCCESS;

   333

   334

    } catch (ArgumentError &e) {

   335

        std::cerr 

   336

            << "Error: " << e.what() << std::endl

   337

            << std::endl;

   338

   339

        args.print_help();

   340

   341

    } catch (CL_Error &e) {

   342

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

   343

   344

    } catch (std::exception &e) {

   345

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

   346

   347

    }

   348

   349

    // fallthrough from catch's

   350

    return EXIT_FAILURE;

   351

}

   352