1

#ifndef NETWORK_OBJECT_HH

     2

#define NETWORK_OBJECT_HH

     3

     4

#include "Session.hh"

     5

#include "Node.hh"

     6

#include "../Logger.hh"

     7

     8

#include <map>

     9

    10

/**

    11

 * A NetworkObject's ID is a 32-bit integer

    12

 */

    13

typedef uint32_t NetworkObjectID;

    14

    15

/**

    16

 * A NetworkObject's message type is a 16-bit integer

    17

 */

    18

typedef uint16_t NetworkMessageID;

    19

    20

// forward-declare

    21

class NetworkObject;

    22

class NetworkObject_Client;

    23

class NetworkObject_Server;

    24

    25

/**

    26

 * A NetworkObjectController contains a mapping of NetworkObjectID -> NetworkObject, and handles the

    27

 * messages received on our channel from the NetworkSession.

    28

 *

    29

 * Additionally, this provides methods to read/write NetworkObject references from/to a NetworkPacket

    30

 */

    31

class NetworkObjectController {

    32

    friend class NetworkObject;

    33

    friend class NetworkObject_Server;

    34

    friend class NetworkObject_Client;

    35

    36

    private:

    37

        /**

    38

         * The NetworkSession that we use

    39

         */

    40

        NetworkSession &session;

    41

    42

        /**

    43

         * The NetworkChannelID that we use to communicate

    44

         */

    45

        NetworkChannelID channel_id;

    46

    47

        /**

    48

         * Our map of NetworkObjectID -> NetworkObject

    49

         */

    50

        std::map<NetworkObjectID, NetworkObject*> objects;

    51

    52

        CL_Slot slot_message;

    53

    54

    protected:

    55

        /**

    56

         * Construct a NetworkObjectController to use the given NetworkSession and NetworkChannelID

    57

         */

    58

        NetworkObjectController (NetworkSession &session, NetworkChannelID channel_id);

    59

    60

    private:

    61

        /**

    62

         * Our NetworkSession::sig_chan_message handler

    63

         *

    64

         * Reads the NetworkObjectID and NetworkMessageID from the packet, and then either calls handle_create or

    65

         * NetworkObject::handle_packet.

    66

         */

    67

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

    68

    69

    protected:

    70

        /**

    71

         * Abstract method called by on_message if we recieve a message for an unknown NetworkObjectID

    72

         *

    73

         * @param obj_id the unknown NetworkObjectID

    74

         * @param msg_id the packet's NetworkMessageID

    75

         * @param pkt the packet itself, with the header read

    76

         * @param node the node that we got this packet from

    77

         */

    78

        virtual void handle_create (NetworkObjectID obj_id, NetworkMessageID msg_id, NetworkPacketInput &pkt, NetworkNode *node) = 0; 

    79

    80

    public:

    81

        /**

    82

         * Read an NetworkObjectID from the given packet, and return the corresponding NetworkObject, or NULL if:

    83

         *  * it was zero

    84

         *  * we don't know the object (should this thrown an exception instead?)

    85

         *

    86

         * @return the NetworkObject* corresponding to the NetworkObjectID in the packet, or NULL if zero/not found

    87

         */

    88

        NetworkObject* read_object (NetworkPacketInput &pkt);

    89

    90

        /**

    91

         * Write the given Object's NetworkObjectID (or 0, if the obj is NULL) to the given packet

    92

         *

    93

         * @param the NetworkObject* whose NetworkObjectID to write to the packet, or NULL to write zero

    94

         */

    95

        void write_object (NetworkPacketOutput &pkt, NetworkObject *obj);

    96

};

    97

    98

/**

    99

 * A NetworkObjectController intended for use with a server.

   100

 *

   101

 * This has an id_pool that new NetworkObjectIDs can be generated from, and this doesn't accept unknown

   102

 * NetworkObjectIDs from clients.

   103

 */

   104

class NetworkObject_ServerController : public NetworkObjectController {

   105

    friend class NetworkObject_Server;

   106

   107

    private:

   108

        /**

   109

         * The id_pool that we use to generate NetworkObjectIDs for new NetworkObject's

   110

         */

   111

        NetworkObjectID id_pool;

   112

   113

    public:

   114

        /**

   115

         * @see NetworkObjectController

   116

         */

   117

        NetworkObject_ServerController (NetworkSession &session, NetworkChannelID channel_id);

   118

   119

    protected:

   120

        /**

   121

         * Get a new NetworkObjectID

   122

         */

   123

        NetworkObjectID getObjectID (void);

   124

   125

        /**

   126

         * Throw an error, as we don't accept unknown NetworkObjects from clients

   127

         */

   128

        virtual void handle_create (NetworkObjectID obj_id, NetworkMessageID msg_id, NetworkPacketInput &pkt, NetworkNode *node);

   129

};

   130

   131

/**

   132

 * A NetworkObjectController intended for use with a client.

   133

 *

   134

 * This provides two ways to handle unknown objects: override handle_create, or use sig_create

   135

 */

   136

class NetworkObject_ClientController : public NetworkObjectController {

   137

    friend class NetworkObject_Client;

   138

   139

    protected:

   140

        /**

   141

         * The server node, as returned by NetworkSession::connect

   142

         */

   143

        NetworkNode *server;

   144

   145

        /**

   146

         * A mapping of NetworkMessageID -> sig_create, used by the default handle_create

   147

         */

   148

        std::map<NetworkMessageID, CL_Signal_v2<NetworkObject_Client*, NetworkPacketInput&> > _map_sig_create;

   149

   150

    public:

   151

        /**

   152

         * Construct a NetworkObjectController using the given NetworkNode (as returned by NetworkSession::connect) as

   153

         * a server.

   154

         *

   155

         * @see NetworkObjectController

   156

         */

   157

        NetworkObject_ClientController (NetworkSession &session, NetworkChannelID channel_id, NetworkNode *server);

   158

   159

    protected:

   160

        /**

   161

         * Handle unknown NetworkObjectIDs by constructing a new NetworkObject_Client and calling sig_create.

   162

         * 

   163

         * This can be overriden to handle this differently, e.g. to create an instance of a NetworkObject_Client

   164

         * subclass instead.

   165

         */

   166

        virtual void handle_create (NetworkObjectID obj_id, NetworkMessageID msg_id, NetworkPacketInput &pkt, NetworkNode *node);

   167

   168

    public:  

   169

        /**

   170

         * Signal triggered by default handle_create when we get a message for an unknown NetworkObject.

   171

         * The signal gets the new NetworkObject_Client, and the packet itself.

   172

         *

   173

         * @param msg_id the NetworkMessageID to handle creates for

   174

         */

   175

        CL_Signal_v2<NetworkObject_Client*, NetworkPacketInput&>& sig_create (NetworkMessageID msg_id) { return _map_sig_create[msg_id]; }

   176

};

   177

   178

/**

   179

 * Base class of NetworkObject_(Client/Server)

   180

 *

   181

 * A NetworkObject has an NetworkObjectID, and can handle packets to/from this object

   182

 */

   183

class NetworkObject {

   184

    friend class NetworkObjectController;

   185

    friend std::ostream& operator<< (std::ostream &s, const NetworkObject &obj);

   186

   187

    protected:

   188

        /**

   189

         * Generic controller

   190

         */

   191

        NetworkObjectController &controller;

   192

   193

        /**

   194

         * This object's object id

   195

         */

   196

        NetworkObjectID obj_id;

   197

   198

    protected:

   199

        /**

   200

         * Construct a NetworkObject using the given controller and object id

   201

         *

   202

         * @param controller the NetworkObjectController (subclass)

   203

         * @param obj_id our NetworkObjectID

   204

         */

   205

        NetworkObject (NetworkObjectController &controller, NetworkObjectID obj_id);

   206

   207

        /**

   208

         * Removes this object from the controller's objects list

   209

         */

   210

        ~NetworkObject (void);

   211

   212

        /**

   213

         * Abstract method to handle packets sent to this object

   214

         *

   215

         * @param node the NetworkNode that sent this packet to us

   216

         * @param msg_id the packet's NetworkMessageID

   217

         * @param pkt the packet itself, with the headers read

   218

         */

   219

        virtual void handle_packet (NetworkNode *node, NetworkMessageID msg_id, NetworkPacketInput &pkt) = 0;

   220

   221

        /**

   222

         * Prepare an outgoing packet, writing the header and the payload

   223

         *

   224

         * @param pkt the packet to prepare

   225

         * @param msg_id the packet's message id

   226

         * @param payload the packet's payload

   227

         */

   228

        void buildPacket (NetworkPacketOutput &pkt, NetworkMessageID msg_id, const NetworkPacketBuffer &payload);

   229

};

   230

   231

/**

   232

 * Formats the object as "<NetworkObject #" <obj_id> ">"

   233

 */

   234

std::ostream& operator<< (std::ostream &s, const NetworkObject &obj);

   235

   236

/**

   237

 * A server-side NetworkObject

   238

 */

   239

class NetworkObject_Server : public NetworkObject {

   240

    friend class NetworkObject_ServerController;

   241

   242

    protected:

   243

        /**

   244

         * The NetworkObject_ServerController

   245

         */

   246

        NetworkObject_ServerController &controller;

   247

   248

        /**

   249

         * Mapping of NetworkMessageID -> sig_message used for received messages

   250

         */

   251

        std::map<NetworkMessageID, CL_Signal_v2<NetworkNode*, NetworkPacketInput&> > _map_sig_message;

   252

   253

    public:

   254

        /**

   255

         * @see NetworkObject

   256

         */

   257

        NetworkObject_Server (NetworkObject_ServerController &controller);

   258

   259

    protected:

   260

        /**

   261

         * Handle an incoming packet by invoking the appopriate sig_message

   262

         *

   263

         * @see NetworkObject::handlePacket

   264

         */

   265

        virtual void handle_packet (NetworkNode *node, NetworkMessageID msg_id, NetworkPacketInput &pkt);

   266

   267

    public:

   268

        /**

   269

         * Send a message on this object to the given node

   270

         *

   271

         * @param dst the NetworkNode to send the message to

   272

         * @param msg_id the type of message to send

   273

         * @param pkt the packet payload

   274

         * @param reliable Whether to use TCP or UDP

   275

         */

   276

        void send_to (NetworkNode *dst, NetworkMessageID msg_id, const NetworkPacketBuffer &pkt, bool reliable = true);

   277

   278

        /**

   279

         * Send a message on this object to all nodes on our controller's NetworkSession

   280

         *

   281

         * @param msg_id the type of message to send

   282

         * @param pkt the packet payload

   283

         * @param reliable Whether to use TCP or UDP

   284

         */

   285

        void send_all (NetworkMessageID msg_id, const NetworkPacketBuffer &pkt, bool reliable = true);

   286

   287

        /**

   288

         * Send a message on this object to all nodes on our controller's NetworkSession, except the given node

   289

         *

   290

         * @param msg_id the type of message to send

   291

         * @param pkt the packet payload

   292

         * @param black_sheep the node to *NOT* send the message to

   293

         * @param reliable Whether to use TCP or UDP

   294

         */

   295

        void send_all_except (NetworkMessageID msg_id, const NetworkPacketBuffer &pkt, NetworkNode *black_sheep, bool reliable = true);

   296

   297

        /**

   298

         * Triggered whenever we receive a message of the given type on this object, giving the node that sent it and the

   299

         * packet itself

   300

         *

   301

         * @param msg_id the NetworkMessageID to handle

   302

         */

   303

        CL_Signal_v2<NetworkNode*, NetworkPacketInput&>& sig_message (NetworkMessageID msg_id) { return _map_sig_message[msg_id]; }

   304

};

   305

   306

/**

   307

 * A client-side NetworkObject

   308

 */

   309

class NetworkObject_Client : public NetworkObject {

   310

    friend class NetworkObject_ClientController;

   311

   312

    protected:

   313

        /**

   314

         * Our NetworkObject_ClientController

   315

         */

   316

        NetworkObject_ClientController &controller;

   317

   318

        /**

   319

         * Our mapping of NetworkMessageID -> sig_message, used to handle received packets

   320

         */

   321

        std::map<NetworkMessageID, CL_Signal_v1<NetworkPacketInput&> > _map_sig_message;

   322

   323

    protected:

   324

        /**

   325

         * @see NetworkObject

   326

         */

   327

        NetworkObject_Client (NetworkObject_ClientController &controller, NetworkObjectID id);

   328

   329

        /**

   330

         * Handle an incoming packet by invoking the appropriate sig_message.

   331

         *

   332

         * This assumes that packets only come from the server

   333

         *

   334

         * @see NetworkObject::handlePacket

   335

         */

   336

        virtual void handle_packet (NetworkNode *node, NetworkMessageID msg_id, NetworkPacketInput &pkt);

   337

   338

    public:

   339

        /**

   340

         * Send a message on this object to the server

   341

         *

   342

         * @param msg_id the type of message to send

   343

         * @param pkt the packet payload

   344

         * @param reliable Whether to use TCP or UDP

   345

         */

   346

        void send (NetworkMessageID msg_id, const NetworkPacketBuffer &pkt, bool reliable = true);

   347

   348

        /**

   349

         * Triggered whenever we receive a message of the given type on this object from the server.

   350

         *

   351

         * @param msg_id the NetworkMessageID to handle

   352

         */

   353

        CL_Signal_v1<NetworkPacketInput&>& sig_message (NetworkMessageID msg_id) { return _map_sig_message[msg_id]; }

   354

};

   355

   356

#endif /* NETWORK_OBJECT_HH */