1

     2

#include "Engine.hh"

     3

#include "Error.hh"

     4

     5

#include <stdexcept>

     6

#include <cassert>

     7

     8

#include <ClanLib/core.h>

     9

#include <ClanLib/application.h>

    10

    11

class ArgumentError : public Error {

    12

    public:

    13

        ArgumentError (const std::string &message) : Error(message) { }

    14

};

    15

    16

class Main : public CL_ClanApplication {

    17

    private:

    18

        // arguments

    19

        CL_CommandLine args;

    20

    21

        bool arg_graphics;

    22

        std::string arg_port;

    23

        bool arg_server;

    24

        std::string arg_connect;

    25

    26

        void parse_args (int argc, char **argv) {

    27

            // set up the options

    28

            args.add_option('p', "port", "PORT", "set network port used", true);

    29

            args.add_option('s', "server", "", "act as a network server", true);

    30

            args.add_option('c', "client", "SERVERHOST", "act as a network client", true);

    31

            args.add_option('g', "graphics", "", "run graphics/local input. Implied with --connect", true);

    32

    33

            // set defaults

    34

            arg_graphics = false;

    35

            arg_port = NETWORK_PORT_STR;

    36

            arg_server = false;

    37

            arg_connect = "";

    41

    42

            try {

    43

                // parse args

    44

                args.parse_args(argc, argv);

    45

    46

            } catch (CL_Error &e) {

    47

                throw ArgumentError(e.message);

    48

            }

    49

    50

            while (args.next()) {

    51

                switch (args.get_key()) {

    52

                    case 'p':

    53

                        arg_port = args.get_argument();

    54

                        break;

    55

    56

                    case 's':

    57

                        arg_server = true;

    58

                        break;

    59

    60

                    case 'c':

    61

                        arg_connect = args.get_argument();

    62

                        break;

    63

    64

                    case 'g':

    65

                        arg_graphics = true;

    66

                        break;

    67

    68

                    case CL_CommandLine::REST_ARG:

    69

                        throw ArgumentError(args.get_argument());

    70

    71

                    default:

    72

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

    73

    74

                }

    75

            }

    77

            // check for invalid combinations of arugments

    78

            if (arg_server and !arg_connect.empty())

    79

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

    84

        }

    85

    86

    public:

    87

        virtual int main (int argc, char **argv) {

    88

            // initialize the ClanLib components that we use

    89

            CL_SetupCore setup_core;

    90

            CL_SetupNetwork setup_network;

    91

            CL_SetupDisplay setup_disp;

    92

            CL_SetupGL setup_gl;

    93

    94

            try {

    95

                // parse arugments

    96

                parse_args(argc, argv);

    97

    98

                // our engine

    99

                Engine engine;

   100

   101

                // setup graphics

   102

                if (arg_graphics)

   103

                    engine.setupGraphics();

   104

   105

                // setup either network server, client or singleplayer

   106

                if (arg_server) {

   107

                    engine.setupNetworkServer(arg_port);

   108

   109

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

   110

                    engine.setupNetworkClient(arg_connect, arg_port);

   111

   112

                } else {

   113

                    engine.setupSinglePlayer();

   114

                }

   115

   116

                // run the main loop

   117

                engine.run();

   118

   119

                // succesful return

   120

                return 0;

   121

   122

            } catch (ArgumentError &e) {

   123

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

   124

                args.print_help();

   125

   126

                // XXX: handle --help

   127

                return 1;

   128

            } catch (CL_Error &e) {

   129

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

   130

   131

                return 1;

   132

   133

            } catch (std::exception &e) {

   134

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

   135

   136

                return 1;

   137

            }

   138

        }

   139

} app;

   140