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

typedef uint32_t NetworkObjectID;

    11

typedef uint16_t NetworkMessageID;

    12

    13

// forward-declare

    14

class NetworkObject;

    15

class NetworkObject_Client;

    16

class NetworkObject_Server;

    17

    18

class NetworkObjectController {

    19

    friend class NetworkObject;

    20

    friend class NetworkObject_Server;

    21

    friend class NetworkObject_Client;

    22

    23

    private:

    24

        NetworkSession &session;

    25

        NetworkChannelID channel_id;

    26

    27

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

    28

    29

        CL_Slot slot_message;

    30

    31

    protected:

    32

        NetworkObjectController (NetworkSession &session, NetworkChannelID channel_id);

    33

    34

    private:

    35

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

    36

    37

    protected:

    38

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

    39

    40

    public:

    41

        /**

    42

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

    43

         * don't know it

    44

         */

    45

        NetworkObject* read_object (NetworkPacketInput &pkt);

    46

    47

        /**

    48

         * Write the given Object's NetworkObjectID to the given packet

    49

         */

    50

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

    51

};

    52

    53

class NetworkObject_ServerController : public NetworkObjectController {

    54

    friend class NetworkObject_Server;

    55

    56

    private:

    57

        NetworkObjectID id_pool;

    58

    59

    public:

    60

        NetworkObject_ServerController (NetworkSession &session, NetworkChannelID channel_id);

    61

    62

    protected:

    63

        NetworkObjectID getObjectID (void);

    64

    65

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

    66

};

    67

    68

class NetworkObject_ClientController : public NetworkObjectController {

    69

    friend class NetworkObject_Client;

    70

    71

    private:

    72

        NetworkNode *server;

    73

    74

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

    75

    76

    public:

    77

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

    78

    79

    protected:

    80

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

    81

    82

    public:  

    83

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

    84

};

    85

    86

class NetworkObject {

    87

    friend class NetworkObjectController;

    88

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

    89

    90

    protected:

    91

        NetworkObjectID obj_id;

    92

    93

    protected:

    94

        NetworkObject (NetworkObjectController &controller, NetworkObjectID obj_id);

    95

    96

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

    97

    98

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

    99

};

   100

   101

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

   102

   103

class NetworkObject_Server : public NetworkObject {

   104

    friend class NetworkObject_ServerController;

   105

   106

    private:

   107

        NetworkObject_ServerController &controller;

   108

   109

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

   110

   111

    public:

   112

        NetworkObject_Server (NetworkObject_ServerController &controller);

   113

   114

    protected:

   115

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

   116

   117

    public:

   118

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

   119

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

   120

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

   121

   122

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

   123

};

   124

   125

class NetworkObject_Client : public NetworkObject {

   126

    friend class NetworkObject_ClientController;

   127

   128

    private:

   129

        NetworkObject_ClientController &controller;

   130

   131

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

   132

   133

    protected:

   134

        NetworkObject_Client (NetworkObject_ClientController &controller, NetworkObjectID id);

   135

   136

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

   137

   138

    public:

   139

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

   140

   141

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

   142

};

   143

   144

#endif /* NETWORK_OBJECT_HH */