1

     2

#include "Engine.hh"

     3

#include "SinglePlayer.hh"

     4

#include "Config.hh"

     5

     6

// XXX: how does this work if we don't have NETWORK_ENABLED?

     7

#include "Network/Reactor.hh"

     8

     9

// include the real component definitions

    10

#if NETWORK_ENABLED

    11

    #include "Network/Client.hh"

    12

    #include "Network/Server.hh"

    13

#endif

    14

    15

#if GRAPHICS_ENABLED

    16

    #include "Graphics/Graphics.hh"

    17

#endif

    18

    19

#include <iostream>

    20

#include <cassert>

    21

    22

/*

    23

 * Initialize static Engine global state

    24

 */

    25

LogLevel Engine::log_level = DEBUG;

    26

    27

Engine::Engine (const EngineConfig &config) : 

    28

    terrain(NULL), game_state(NULL), graphics(NULL), net_server(NULL), net_client_connect(NULL),

    30

    is_running(true), resources(config.resource_path)

    31

{

    32

    // update global log_level

    33

    Engine::log_level = config.log_level;

    34

}

    35

    37

    // ensure this isn't called in inappropriate ways

    38

    assert(!net_server);

    39

    40

    // remember the terrain

    41

    this->terrain = terrain;

    42

    43

    // create the GameState

    44

    game_state = new GameState(*terrain);

    45

}

    46

    47

void Engine::setupGame (const TerrainConfig &config) {

    48

    // proxy off to setupGame(Terrain *)

    49

    setupGame(new Terrain(config));

    50

}

    51

    52

void Engine::setupGraphics (const DisplayConfig &config) {

    53

    54

#if GRAPHICS_ENABLED    

    55

    assert(!graphics);

    56

    57

    // create the graphics

    58

    graphics = new graphics::Graphics(*this, resources, config);

    59

    60

#else

    61

    (void) config;

    62

    63

    throw Error("No Graphics support available");

    64

    65

#endif

    66

    67

}

    68

    69

void Engine::startGameView (LocalPlayer *player) {

    70

    71

#if GRAPHICS_ENABLED    

    73

    75

    76

#else

    77

    (void) player;

    78

    79

    throw Error("No Graphics support available");

    80

    81

#endif

    82

    83

}

    84

    85

void Engine::setupNetworkServer (const std::string &listen_port) {

    86

    87

#if NETWORK_ENABLED    

    88

    NetworkEndpoint listen_addr(listen_port);

    89

    90

    assert(terrain && game_state);

    91

    92

    // create the server

    93

    net_server = new NetworkServer(*game_state, listen_addr);

    94

    95

    // put graphics into GameView mode

    96

    if (graphics)

    97

        startGameView(NULL);

    98

    99

#else

   100

    (void) listen_port;

   101

   102

    throw Error("No Network support available");

   103

   104

#endif    

   105

}

   106

   107

void Engine::setupNetworkClient (const std::string &connect_host, const std::string &connect_port) {

   108

   109

#if NETWORK_ENABLED 

   110

    // connect_to

   111

    NetworkEndpoint connect_addr(connect_host, connect_port);

   112

   113

    // begin connecting, the client will callback us with setupGame once it's connected

   114

    net_client_connect = new NetworkClientConnect(*this, connect_addr);

   115

   116

#else

   117

    (void) connect_host;

   118

    (void) connect_port;

   119

   120

    throw Error("No Network support available");

   121

   122

#endif    

   123

   124

}

   125

   126

void Engine::setupSinglePlayer (void) {

   127

    assert(terrain && game_state);

   128

   129

    // create player directly

   130

 	LocalPlayer* lp = new SinglePlayer(*game_state);

   131

   132

    // add to gamestate

   133

	game_state->setLocalPlayer(lp);

   134

   135

    // put graphics into GameView mode

   136

    if (graphics)

   137

        startGameView(lp);

   157

}

   158

   159

void Engine::stop (void) {

   160

    is_running = false;

   161

}

   162

   163

void Engine::run (void) {

   164

    // timeout for NetworkReactor

   165

    timeval timeout;

   166

   167

    while (is_running) {

   168

        /*

   169

         * Run internal ClanLib stuff (also includes our timers) until our timeout has elapsed

   170

         */

   171

        CL_System::keep_alive(ENGINE_TIMEOUT_MS);

   172

   173

#if NETWORK_ENABLED 

   174

        // setup timeout to zero

   175

        timeout.tv_sec = 0;

   176

        timeout.tv_usec = 0;

   177

   178

        /*

   179

         * Thursday came and went, I re-wrote clan-event.

   180

         *

   181

         * (actually, we only use it for zero-timeout polling now... not sure if this is better than using the above

   182

         * CL_System::keep_alive)

   183

         */

   184

        NetworkReactor::current->poll(&timeout);

   185

#endif        

   186

    }

   187

}

   188