1

#ifndef NETWORKSERVER_HH

     2

#define NETWORKSERVER_HH

     3

     4

/**

     5

 * @file

     6

 *

     7

 * Game server implementation

     8

 */

     9

    10

#include "../GameState.hh"

    11

#include "Session.hh"

    12

#include "Object.hh"

    13

    14

#include <list>

    15

#include <map>

    16

#include <ClanLib/core.h>

    17

    18

// forward-declare

    19

class NetworkServerPlayer;

    20

    21

/**

    22

 * Our game's NetworkServer... this has the GameState, NetworkSession, etc

    23

 */

    24

class NetworkServer {

    25

    friend class NetworkServerObject;

    26

    friend class NetworkServerPlayer;

    27

    friend class NetworkServerProjectile;

    28

    29

    protected:

    30

        /**

    31

         * The GameState

    32

         */ 

    33

        GameState &state;

    34

        CL_SlotContainer slots;

    35

    36

        /**

    37

         * The server-mode NetworkSession

    38

         */

    39

        NetworkSession netsession;

    40

    41

        /**

    42

         * The NetworkObject_ServerController that we use

    43

         */

    44

        NetworkObject_ServerController controller;

    45

    46

        /**

    47

         * A list of NetworkServerPlayer's, used when a new player connects to send it information about existing

    48

         * NetworkServerPlayer objects

    49

         */

    50

        std::list<NetworkServerPlayer *> players;

    51

    52

    public:

    53

        /**

    54

         * Construct a NetworkServer, using the given GameState and listening on the given address

    55

         */

    56

        NetworkServer (GameState &state, const NetworkEndpoint &listen_addr);

    57

    58

    protected:

    59

        /**

    60

         * Called by NetworkServerPlayer when it disconnects, this removes it from our list

    61

         */

    62

        void handle_disconnect (NetworkServerPlayer *player);

    63

    64

    private:

    65

        /**

    66

         * Our NetworkSession::sig_node_connected handler, this creates a new NetworkServerPlayer and adds it to

    67

         * our list of players

    68

         */

    69

        void on_node_connected (NetworkNode *node);

    76

};

    77

    78

/**

    79

 * Our base NetworkObject_Server class, that also holds the NetworkServer reference and a CL_SlotContainer for

    80

 * conveniance.

    81

 */

    82

class NetworkServerObject : public NetworkObject_Server {

    83

    protected:

    84

        /**

    85

         * Our NetworkServer

    86

         */

    87

        NetworkServer &server;

    88

        CL_SlotContainer slots;

    89

    90

        /**

    91

         * Constructs this NetworkServerObject, passing the server's controller to the NetworkObject_Server constructor

    92

         */

    93

        NetworkServerObject (NetworkServer &server);

    94

};

    95

    96

/**

    97

 * A remote player on this server, this is both a LocalPlayer and a NetworkServerObject

    98

 */

    99

class NetworkServerPlayer : public LocalPlayer, public NetworkServerObject {

   100

    protected:

   101

        /**

   102

         * The remote node that represents this actual player

   103

         */

   104

        NetworkNode *node;

   105

   106

    public:

   107

        /**

   108

         * Construct this using the given server (for NetworkServerObject) and node (for node).

   109

         *

   110

         * We send the initial NETMSG_SERVER_HELLO to the client, then a set of NETMSG_PLAYER_INFOs

   111

         * for all the other players, a NETMSG_PLAYER_JOIN to all the other clients, and then calls

   112

         * send_terrain_data to sync the initial terrain.

   113

         *

   114

         * @see NetworkServerObject

   115

         */

   116

        NetworkServerPlayer (NetworkServer &server, NetworkNode *node);

   117

   118

    protected:    

   119

        // @{

   120

        /**

   121

         * These methods are overriden from Player to replicate events to our clients

   122

         */

   123

        virtual void handleDig (Vector position, float radius);

   124

        virtual void handleFireWeapon (Weapon *weapon, Vector position, Vector velocity);

   125

        virtual void handleChangeWeapon (unsigned int weaponIndex);

   126

        virtual void handleRopeState (RopeState state);

   127

        virtual void handleRopeLength (float length);

   128

   129

        virtual void spawn (Vector position);

   130

        virtual void die (bool start_timer = true);

   131

        // @}

   132

        //

   133

   134

    private:

   135

        /**

   136

         * Our NetworkNode::sig_disconnected handler. This calls NetworkServer::handle_disconnect, sends a 

   137

         * NETMSG_PLAYER_QUIT message to all remaining clients, and destroys this player.

   138

         */

   139

        void on_disconnected (void);

   140

   141

        /*

   142

         * Our NETMSG_PLAYER_INPUT handler. This calls our superclass LocalPlayer::handleInput, which may then call

   143

         * the various handle* methods. After this, we call send_position_update

   144

         */

   145

        void on_input (NetworkNode *node, NetworkPacketInput &pkt);

   146

   147

        /**

   148

         * Called from on_input to broadcast an unreliable position update with this player's physics state

   149

         */

   150

        void send_position_update (void);

   151

};

   152

   153

/**

   154

 * A Projectile, replicated across the network.

   155

 *

   156

 * These are created by NetworkServerPlayer::handleFireWeapon

   157

 */

   158

class NetworkServerProjectile : public Projectile, public NetworkServerObject {

   159

    public:

   160

        /**

   161

         * Call the Projectile construtor, and then send NETMSG_PROJECTILE_PLAYER_FIRED

   162

         *

   163

         * @param server the NetworkServer

   164

         * @param player the NetworkServerPlayer that fired the weapon

   165

         * @param position the Projectile's initial position

   166

         * @param velocity the Projectile's initial velocity

   167

         * @param weapon the Player's Weapon that was fired

   168

         */

   169

        NetworkServerProjectile (NetworkServer &server, NetworkServerPlayer *player, Vector position, Vector velocity, Weapon *weapon);

   170

   171

    protected:

   172

        /**

   173

         * Overriden from Projectile to send a NETMSG_PROJECTILE_DESTROY with the given position and flags

   174

         *

   175

         * @param position the Projectile's final position, where the ground gets removed

   176

         * @param removeGround controls the NETWORK_PROJECTILE_REMOVE_GROUND flag

   177

         */

   178

        virtual void onDestroy (Vector position, bool removeGround);

   179

   180

        /**

   181

         * Overriden from Projectile to send a NETMSG_PROJECTILE_HIT_PLAYER with the given player

   182

         *

   183

         * @param player the NetworkServerPlayer that got hit

   184

         */

   185

        virtual void onHitPlayer (Player *player_ptr);

   186

};

   187

   188

#endif