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

    #include "Graphics/GameView.hh"

    18

#endif

    19

    20

#include <iostream>

    21

#include <cassert>

    22

    23

/*

    24

 * Initialize static Engine global state

    25

 */

    26

LogLevel Engine::log_level = DEBUG;

    27

    28

Engine::Engine (const EngineConfig &config) : 

    29

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

    30

    game_view(NULL),

    31

    is_running(true), resources(config.resource_path)

    32

{

    33

    // update global log_level

    34

    Engine::log_level = config.log_level;

    35

}

    36

    37

void Engine::setupGame (Terrain *terrain) {

    38

    // ensure this isn't called in inappropriate ways

    39

    assert(!net_server);

    40

    41

    // remember the terrain

    42

    this->terrain = terrain;

    43

    44

    // create the GameState

    45

    game_state = new GameState(*terrain);

    46

}

    47

    48

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

    49

    // proxy off to setupGame(Terrain *)

    50

    setupGame(new Terrain(config));

    51

}

    52

    53

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

    54

    55

#if GRAPHICS_ENABLED    

    56

    assert(!graphics);

    57

    58

    // create the graphics

    59

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

    60

    61

#else

    62

    (void) config;

    63

    64

    throw Error("No Graphics support available");

    65

    66

#endif

    67

    68

}

    69

    70

void Engine::startGameView (LocalPlayer *player) {

    71

    72

#if GRAPHICS_ENABLED    

    73

    assert(graphics && !game_view);

    74

    75

    game_view = graphics->displayGameView(*game_state, player);

    76

    77

#else

    78

    (void) player;

    79

    80

    throw Error("No Graphics support available");

    81

    82

#endif

    83

    84

}

    85

    86

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

    87

    88

#if NETWORK_ENABLED    

    89

    NetworkEndpoint listen_addr(listen_port);

    90

    91

    assert(terrain && game_state);

    92

    93

    // create the server

    94

    net_server = new NetworkServer(*game_state, listen_addr);

    95

    96

    // put graphics into GameView mode

    97

    if (graphics)

    98

        startGameView(NULL);

    99

   100

#else

   101

    (void) listen_port;

   102

   103

    throw Error("No Network support available");

   104

   105

#endif    

   106

}

   107

   108

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

   109

   110

#if NETWORK_ENABLED 

   111

    // client operation requires graphics

   112

    if (!GRAPHICS_ENABLED)

   113

        throw Error("Network client mode requires graphics support");

   114

   115

    // connect_to

   116

    NetworkEndpoint connect_addr(connect_host, connect_port);

   117

   118

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

   119

    net_client_connect = new NetworkClientConnect(*this, connect_addr);

   120

   121

#else

   122

    (void) connect_host;

   123

    (void) connect_port;

   124

   125

    throw Error("No Network support available");

   126

   127

#endif    

   128

   129

}

   130

   131

void Engine::setupSinglePlayer (void) {

   132

    assert(terrain && game_state);

   133

   134

    // create player directly

   135

 	LocalPlayer* lp = new SinglePlayer(*game_state);

   136

   137

    // add to gamestate

   138

	game_state->setLocalPlayer(lp);

   139

   140

    // put graphics into GameView mode

   141

    if (graphics)

   142

        startGameView(lp);

   143

}

   144

   145

GameState& Engine::onNetworkClientConnected (Terrain *terrain) {

   146

    // sanity-check

   147

    assert(!this->terrain && !game_state && graphics);

   148

   149

    // setup the game

   150

    setupGame(terrain);

   151

   152

    // start the GameView, but no LocalPlayer yet

   153

    startGameView(NULL);

   154

   155

    // return GameState

   156

    return *game_state;

   157

}

   158

   159

void Engine::onNetworkClientPlayer (LocalPlayer *player) {

   160

   161

#if GRAPHICS_ENABLED

   162

    assert(game_view);

   163

   164

    // set the GameView's player

   165

    game_view->setPlayer(player);

   166

   167

#else

   168

    (void) player;

   169

   170

    assert(graphics);

   171

   172

#endif

   173

   174

}

   175

   176

void Engine::stop (void) {

   177

    is_running = false;

   178

}

   179

   180

void Engine::run (void) {

   181

#if NETWORK_ENABLED 

   182

    // timeout for NetworkReactor

   183

    timeval timeout;

   184

#endif        

   185

   186

    while (is_running) {

   187

        /*

   188

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

   189

         */

   190

        CL_System::keep_alive(ENGINE_TIMEOUT_MS);

   191

   192

#if NETWORK_ENABLED 

   193

        // setup timeout to zero

   194

        timeout.tv_sec = 0;

   195

        timeout.tv_usec = 0;

   196

   197

        /*

   198

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

   199

         *

   200

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

   201

         * CL_System::keep_alive)

   202

         */

   203

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

   204

#endif        

   205

    }

   206

}

   207