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

    28

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

    30

{

    33

}

    34

    35

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

    36

    // ensure this isn't called in inappropriate ways

    37

    assert(!net_server);

    38

    39

    // remember the terrain

    40

    this->terrain = terrain;

    41

    42

    // create the GameState

    43

    game_state = new GameState(*terrain);

    44

    45

    // XXX: NetworkClient + GameView?

    46

    47

    return *game_state;

    48

}

    49

    50

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

    51

    // proxy off to setupGame(Terrain *)

    52

    setupGame(new Terrain(config));

    53

}

    54

    55

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

    56

    57

#if GRAPHICS_ENABLED    

    58

    assert(!graphics);

    59

    60

    // create the graphics

    61

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

    62

    63

#else

    64

    (void) config;

    65

    66

    throw Error("No Graphics support available");

    67

    68

#endif

    69

    70

}

    71

    72

void Engine::startGameView (LocalPlayer *player) {

    73

    74

#if GRAPHICS_ENABLED    

    75

    assert(graphics);

    76

    77

    graphics->displayGameView(*game_state, player);

    78

    79

#else

    80

    (void) player;

    81

    82

    throw Error("No Graphics support available");

    83

    84

#endif

    85

    86

}

    87

    88

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

    89

    91

    NetworkEndpoint listen_addr(listen_port);

    92

    93

    assert(terrain && game_state);

    94

    95

    // create the server

    96

    net_server = new NetworkServer(*game_state, listen_addr);

    97

    98

    // put graphics into GameView mode

    99

    if (graphics)

   100

        startGameView(NULL);

   101

   102

#else

   103

    (void) listen_port;

   104

   105

    throw Error("No Network support available");

   106

   107

#endif    

   108

}

   109

   110

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

   111

   113

    // connect_to

   114

    NetworkEndpoint connect_addr(connect_host, connect_port);

   115

   116

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

   117

    net_client_connect = new NetworkClientConnect(*this, connect_addr);

   118

   119

#else

   120

    (void) connect_host;

   121

    (void) connect_port;

   122

   123

    throw Error("No Network support available");

   124

   125

#endif    

   126

   127

}

   128

   129

void Engine::setupSinglePlayer (void) {

   130

    assert(terrain && game_state);

   131

   132

    // create player directly

   133

 	LocalPlayer* lp = new SinglePlayer(*game_state);

   134

   135

    // add to gamestate

   136

	game_state->setLocalPlayer(lp);

   137

   138

    // put graphics into GameView mode

   139

    if (graphics)

   140

        startGameView(lp);

   141

   142

}

   143

   144

void Engine::stop (void) {

   145

    is_running = false;

   146

}

   147

   148

void Engine::run (void) {

   152

    while (is_running) {

   153

        /*

   154

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

   155

         */

   156

        CL_System::keep_alive(ENGINE_TIMEOUT_MS);

   157

   163

        /*

   164

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

   165

         *

   166

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

   167

         * CL_System::keep_alive)

   168

         */

   170

#endif        

   171

    }

   172

}

   173