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 = "";

    38

    39

            try {

    40

                // parse args

    41

                args.parse_args(argc, argv);

    42

    43

            } catch (CL_Error &e) {

    44

                throw ArgumentError(e.message);

    45

            }

    46

    47

            while (args.next()) {

    48

                switch (args.get_key()) {

    49

                    case 'p':

    50

                        arg_port = args.get_argument();

    51

                        break;

    52

    53

                    case 's':

    54

                        arg_server = true;

    55

                        break;

    56

    57

                    case 'c':

    58

                        arg_connect = args.get_argument();

    59

                        arg_graphics = true;

    60

                        break;

    61

    62

                    case 'g':

    63

                        arg_graphics = true;

    64

                        break;

    65

    66

                    case CL_CommandLine::REST_ARG:

    67

                        throw ArgumentError(args.get_argument());

    68

    69

                    default:

    70

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

    71

    72

                }

    73

            }

    74

    75

            // check for invalid combinations of arugments

    76

            if (arg_server and !arg_connect.empty())

    77

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

    78

        }

    79

    80

    public:

    81

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

    82

            // initialize the ClanLib components that we use

    83

            CL_SetupCore setup_core;

    84

            CL_SetupNetwork setup_network;

    85

            CL_SetupDisplay setup_disp;

    86

            CL_SetupGL setup_gl;

    87

    88

            try {

    89

                // parse arugments

    90

                parse_args(argc, argv);

    91

    92

                // our engine

    93

                Engine engine;

    94

    95

                // setup graphics

    96

                if (arg_graphics)

    97

                    engine.setupGraphics();

    98

    99

                // setup either network server, client or singleplayer

   100

                if (arg_server) {

   101

                    engine.setupNetworkServer(arg_port);

   102

   103

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

   104

                    engine.setupNetworkClient(arg_connect, arg_port);

   105

   106

                } else {

   107

                    engine.setupSinglePlayer();

   108

                }

   109

   110

                // run the main loop

   111

                engine.run();

   112

   113

                // succesful return

   114

                return 0;

   115

   116

            } catch (ArgumentError &e) {

   117

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

   118

                args.print_help();

   119

   120

                // XXX: handle --help

   121

                return 1;

   126

   127

            } catch (std::exception &e) {

   129

   130

                return 1;

   131

            }

   132

        }

   133

} app;

   134