1

#ifndef NETWORK_OBJECT_HH

     2

#define NETWORK_OBJECT_HH

     3

    10

#include "Session.hh"

    11

#include "Node.hh"

    12

#include "../Logger.hh"

    13

    14

#include <map>

    15

    16

/**

    17

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

    18

 */

    19

typedef uint32_t NetworkObjectID;

    20

    21

/**

    22

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

    23

 */

    24

typedef uint16_t NetworkMessageID;

    25

    26

// forward-declare

    27

class NetworkObject;

    28

class NetworkObject_Client;

    29

class NetworkObject_Server;

    30

    31

/**

    32

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

    33

 * messages received on our channel from the NetworkSession.

    34

 *

    35

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

    36

 */

    37

class NetworkObjectController {

    38

    friend class NetworkObject;

    39

    friend class NetworkObject_Server;

    40

    friend class NetworkObject_Client;

    41

    42

    private:

    43

        /**

    44

         * The NetworkSession that we use

    45

         */

    46

        NetworkSession &session;

    47

    48

        /**

    49

         * The NetworkChannelID that we use to communicate

    50

         */

    51

        NetworkChannelID channel_id;

    52

    53

        /**

    54

         * Our map of NetworkObjectID -> NetworkObject

    55

         */

    56

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

    57

    58

        CL_Slot slot_message;

    59

    60

    protected:

    61

        /**

    62

         * Construct a NetworkObjectController to use the given NetworkSession and NetworkChannelID

    63

         */

    64

        NetworkObjectController (NetworkSession &session, NetworkChannelID channel_id);

    65

    66

    private:

    67

        /**

    68

         * Our NetworkSession::sig_chan_message handler

    69

         *

    70

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

    71

         * NetworkObject::handle_packet.

    72

         */

    73

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

    74

    75

    protected:

    76

        /**

    77

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

    78

         *

    79

         * @param obj_id the unknown NetworkObjectID

    80

         * @param msg_id the packet's NetworkMessageID

    81

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

    82

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

    83

         */

    84

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

    85

    86

    public:

    87

        /**

    88

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

    89

         *  * it was zero

    90

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

    91

         *

    92

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

    93

         */

    94

        NetworkObject* read_object (NetworkPacketInput &pkt);

    95

    96

        /**

    97

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

    98

         *

    99

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

   100

         */

   101

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

   102

};

   103

   104

/**

   105

 * A NetworkObjectController intended for use with a server.

   106

 *

   107

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

   108

 * NetworkObjectIDs from clients.

   109

 */

   110

class NetworkObject_ServerController : public NetworkObjectController {

   111

    friend class NetworkObject_Server;

   112

   113

    private:

   114

        /**

   115

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

   116

         */

   117

        NetworkObjectID id_pool;

   118

   119

    public:

   120

        /**

   121

         * @see NetworkObjectController

   122

         */

   123

        NetworkObject_ServerController (NetworkSession &session, NetworkChannelID channel_id);

   124

   125

    protected:

   126

        /**

   127

         * Get a new NetworkObjectID

   128

         */

   129

        NetworkObjectID getObjectID (void);

   130

   131

        /**

   132

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

   133

         */

   134

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

   135

};

   136

   137

/**

   138

 * A NetworkObjectController intended for use with a client.

   139

 *

   140

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

   141

 */

   142

class NetworkObject_ClientController : public NetworkObjectController {

   143

    friend class NetworkObject_Client;

   144

   145

    protected:

   146

        /**

   147

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

   148

         */

   149

        NetworkNode *server;

   150

   151

        /**

   152

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

   153

         */

   154

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

   155

   156

    public:

   157

        /**

   158

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

   159

         * a server.

   160

         *

   161

         * @see NetworkObjectController

   162

         */

   163

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

   164

   165

    protected:

   166

        /**

   167

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

   168

         * 

   169

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

   170

         * subclass instead.

   171

         */

   172

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

   173

   174

    public:  

   175

        /**

   176

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

   177

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

   178

         *

   179

         * @param msg_id the NetworkMessageID to handle creates for

   180

         */

   181

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

   182

};

   183

   184

/**

   185

 * Base class of NetworkObject_(Client/Server)

   186

 *

   187

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

   188

 */

   189

class NetworkObject {

   190

    friend class NetworkObjectController;

   191

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

   192

   193

    protected:

   194

        /**

   195

         * Generic controller

   196

         */

   197

        NetworkObjectController &controller;

   198

   199

        /**

   200

         * This object's object id

   201

         */

   202

        NetworkObjectID obj_id;

   203

   204

    protected:

   205

        /**

   206

         * Construct a NetworkObject using the given controller and object id

   207

         *

   208

         * @param controller the NetworkObjectController (subclass)

   209

         * @param obj_id our NetworkObjectID

   210

         */

   211

        NetworkObject (NetworkObjectController &controller, NetworkObjectID obj_id);

   212

   213

        /**

   214

         * Removes this object from the controller's objects list

   215

         */

   216

        ~NetworkObject (void);

   217

   218

        /**

   219

         * Abstract method to handle packets sent to this object

   220

         *

   221

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

   222

         * @param msg_id the packet's NetworkMessageID

   223

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

   224

         */

   225

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

   226

   227

        /**

   228

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

   229

         *

   230

         * @param pkt the packet to prepare

   231

         * @param msg_id the packet's message id

   232

         * @param payload the packet's payload

   233

         */

   234

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

   235

};

   236

   237

/**

   238

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

   239

 */

   240

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

   241

   242

/**

   243

 * A server-side NetworkObject

   244

 */

   245

class NetworkObject_Server : public NetworkObject {

   246

    friend class NetworkObject_ServerController;

   247

   248

    protected:

   249

        /**

   250

         * The NetworkObject_ServerController

   251

         */

   252

        NetworkObject_ServerController &controller;

   253

   254

        /**

   255

         * Mapping of NetworkMessageID -> sig_message used for received messages

   256

         */

   257

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

   258

   259

    public:

   260

        /**

   261

         * @see NetworkObject

   262

         */

   263

        NetworkObject_Server (NetworkObject_ServerController &controller);

   264

   265

    protected:

   266

        /**

   267

         * Handle an incoming packet by invoking the appopriate sig_message

   268

         *

   269

         * @see NetworkObject::handlePacket

   270

         */

   271

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

   272

   273

    public:

   274

        /**

   275

         * Send a message on this object to the given node

   276

         *

   277

         * @param dst the NetworkNode to send the message to

   278

         * @param msg_id the type of message to send

   279

         * @param pkt the packet payload

   280

         * @param reliable Whether to use TCP or UDP

   281

         */

   282

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

   283

   284

        /**

   285

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

   286

         *

   287

         * @param msg_id the type of message to send

   288

         * @param pkt the packet payload

   289

         * @param reliable Whether to use TCP or UDP

   290

         */

   291

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

   292

   293

        /**

   294

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

   295

         *

   296

         * @param msg_id the type of message to send

   297

         * @param pkt the packet payload

   298

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

   299

         * @param reliable Whether to use TCP or UDP

   300

         */

   301

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

   302

   303

        /**

   304

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

   305

         * packet itself

   306

         *

   307

         * @param msg_id the NetworkMessageID to handle

   308

         */

   309

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

   310

};

   311

   312

/**

   313

 * A client-side NetworkObject

   314

 */

   315

class NetworkObject_Client : public NetworkObject {

   316

    friend class NetworkObject_ClientController;

   317

   318

    protected:

   319

        /**

   320

         * Our NetworkObject_ClientController

   321

         */

   322

        NetworkObject_ClientController &controller;

   323

   324

        /**

   325

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

   326

         */

   327

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

   328

   329

    protected:

   330

        /**

   331

         * @see NetworkObject

   332

         */

   333

        NetworkObject_Client (NetworkObject_ClientController &controller, NetworkObjectID id);

   334

   335

        /**

   336

         * Handle an incoming packet by invoking the appropriate sig_message.

   337

         *

   338

         * This assumes that packets only come from the server

   339

         *

   340

         * @see NetworkObject::handlePacket

   341

         */

   342

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

   343

   344

    public:

   345

        /**

   346

         * Send a message on this object to the server

   347

         *

   348

         * @param msg_id the type of message to send

   349

         * @param pkt the packet payload

   350

         * @param reliable Whether to use TCP or UDP

   351

         */

   352

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

   353

   354

        /**

   355

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

   356

         *

   357

         * @param msg_id the NetworkMessageID to handle

   358

         */

   359

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

   360

};

   361

   362

#endif /* NETWORK_OBJECT_HH */