1 #ifndef NETWORK_OBJECT_HH

     2 #define NETWORK_OBJECT_HH

     3 

     4 #include "NetworkSession.hh"

     5 #include "NetworkNode.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 (NetworkPacket &pkt, NetworkNode *node);

    36 

    37     protected:

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

    39 };

    40 

    41 class NetworkObject_ServerController : public NetworkObjectController {

    42     friend class NetworkObject_Server;

    43 

    44     private:

    45         NetworkObjectID id_pool;

    46     

    47     public:

    48         NetworkObject_ServerController (NetworkSession &session, NetworkChannelID channel_id);

    49 

    50     protected:

    51         NetworkObjectID getObjectID (void);

    52 

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

    54 };

    55 

    56 class NetworkObject_ClientController : public NetworkObjectController {

    57     friend class NetworkObject_Client;

    58 

    59     private:

    60         NetworkNode *server;

    61 

    62         CL_Signal_v3<NetworkObject_Client*, NetworkMessageID, NetworkPacket&> _sig_create;

    63     

    64     public:

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

    66 

    67     protected:

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

    69     

    70     public:  

    71         CL_Signal_v3<NetworkObject_Client*, NetworkMessageID, NetworkPacket&>& sig_create (void) { return _sig_create; }

    72 };

    73 

    74 class NetworkObject {

    75     friend class NetworkObjectController;

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

    77 

    78     protected:

    79         NetworkObjectID obj_id;

    80 

    81     protected:

    82         NetworkObject (NetworkObjectController &controller, NetworkObjectID obj_id);

    83         

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

    85 

    86         void buildPacket (NetworkPacket &pkt, NetworkMessageID msg_id, const NetworkPacket &payload);

    87 };

    88 

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

    90 

    91 class NetworkObject_Server : public NetworkObject {

    92     friend class NetworkObject_ServerController;

    93 

    94     private:

    95         NetworkObject_ServerController &controller;

    96 

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

    98 

    99     public:

   100         NetworkObject_Server (NetworkObject_ServerController &controller);

   101     

   102     protected:

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

   104 

   105     public:

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

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

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

   109     

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

   111 };

   112 

   113 class NetworkObject_Client : public NetworkObject {

   114     friend class NetworkObject_ClientController;

   115 

   116     private:

   117         NetworkObject_ClientController &controller;

   118 

   119         std::map<NetworkMessageID, CL_Signal_v1<NetworkPacket&> > _map_sig_message;

   120 

   121     protected:

   122         NetworkObject_Client (NetworkObject_ClientController &controller, NetworkObjectID id);

   123         

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

   125 

   126     public:

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

   128         

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

   130 };

   131 

   132 #endif /* NETWORK_OBJECT_HH */