1

#ifndef NETWORKSERVER_HH

     2

#define NETWORKSERVER_HH

     3

     4

#include "../GameState.hh"

     5

#include "Session.hh"

     6

#include "Object.hh"

     7

     8

#include <list>

     9

#include <map>

    10

#include <ClanLib/core.h>

    11

    12

// forward-declare

    13

class NetworkServerPlayer;

    14

    15

/**

    16

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

    17

 */

    18

class NetworkServer {

    19

    friend class NetworkServerObject;

    20

    friend class NetworkServerPlayer;

    21

    friend class NetworkServerProjectile;

    22

    23

    protected:

    24

        /**

    25

         * The GameState

    26

         */ 

    27

        GameState &state;

    28

        CL_SlotContainer slots;

    29

    30

        /**

    31

         * The server-mode NetworkSession

    32

         */

    33

        NetworkSession netsession;

    34

    35

        /**

    36

         * The NetworkObject_ServerController that we use

    37

         */

    38

        NetworkObject_ServerController controller;

    39

    40

        /**

    41

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

    42

         * NetworkServerPlayer objects

    43

         */

    44

        std::list<NetworkServerPlayer *> players;

    45

    46

    public:

    47

        /**

    48

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

    49

         */

    51

    52

    protected:

    53

        /**

    54

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

    55

         */

    56

        void handle_disconnect (NetworkServerPlayer *player);

    57

    58

    private:

    59

        /**

    60

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

    61

         * our list of players

    62

         */

    63

        void on_node_connected (NetworkNode *node);

    64

};

    65

    66

/**

    67

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

    68

 * conveniance.

    69

 */

    70

class NetworkServerObject : public NetworkObject_Server {

    71

    protected:

    72

        /**

    73

         * Our NetworkServer

    74

         */

    75

        NetworkServer &server;

    76

        CL_SlotContainer slots;

    77

    78

        /**

    79

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

    80

         */

    81

        NetworkServerObject (NetworkServer &server);

    82

};

    83

    84

/**

    85

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

    86

 */

    87

class NetworkServerPlayer : public LocalPlayer, public NetworkServerObject {

    88

    protected:

    89

        /**

    90

         * The remote node that represents this actual player

    91

         */

    92

        NetworkNode *node;

    93

    94

    public:

    95

        /**

    96

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

    97

         *

    98

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

    99

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

   100

         * send_terrain_data to sync the initial terrain.

   101

         *

   102

         * @see NetworkServerObject

   103

         */

   104

        NetworkServerPlayer (NetworkServer &server, NetworkNode *node);

   105

   106

    protected:    

   107

        // @{

   108

        /**

   109

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

   110

         */

   111

        virtual void handleDig (Vector position, float radius);

   112

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

   113

        virtual void handleChangeWeapon (unsigned int weaponIndex);

   114

        virtual void handleRopeState (RopeState state);

   115

        virtual void handleRopeLength (float length);

   116

   117

        virtual void spawn (Vector position);

   118

        virtual void die (bool start_timer = true);

   119

        // @}

   120

        //

   121

   122

    private:

   123

        /**

   124

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

   125

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

   126

         */

   127

        void on_disconnected (void);

   128

   129

        /*

   130

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

   131

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

   132

         */

   133

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

   134

   135

        /**

   136

         * Called from the constructor to send the initial Terrain data using the NETCHAN_TERRAIN_ARRAY channel.

   137

         */

   138

        void send_terrain_data (void);

   139

   140

        /**

   141

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

   142

         */

   143

        void send_position_update (void);

   144

};

   145

   146

/**

   147

 * A Projectile, replicated across the network.

   148

 *

   149

 * These are created by NetworkServerPlayer::handleFireWeapon

   150

 */

   151

class NetworkServerProjectile : public Projectile, public NetworkServerObject {

   152

    public:

   153

        /**

   154

         * Call the Projectile construtor, and then send NETMSG_PROJECTILE_PLAYER_FIRED

   155

         *

   156

         * @param server the NetworkServer

   157

         * @param player the NetworkServerPlayer that fired the weapon

   158

         * @param position the Projectile's initial position

   159

         * @param velocity the Projectile's initial velocity

   160

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

   161

         */

   162

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

   163

   164

    protected:

   165

        /**

   166

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

   167

         *

   168

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

   169

         * @param removeGround controls the NETWORK_PROJECTILE_REMOVE_GROUND flag

   170

         */

   171

        virtual void onDestroy (Vector position, bool removeGround);

   172

   173

        /**

   174

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

   175

         *

   176

         * @param player the NetworkServerPlayer that got hit

   177

         */

   178

        virtual void onHitPlayer (Player *player_ptr);

   179

};

   180

   181

#endif