Mercurial Mercurial > kg / comparison
summary | shortlog | changelog | graph | tags | bookmarks | branches | files | changeset | file | latest | revisions | annotate | diff | comparison | raw | help
src/proto2/NetworkObject.hh
branchno-netsession
changeset 36 785d220fc6b7
parent 34 1ea6554d703e
child 37 ed2957490bbf
equal deleted inserted replaced
35:e21cfda0edde 36:785d220fc6b7 
     1 #ifndef NETWORK_OBJECT_HH
 
     1 #ifndef NETWORK_OBJECT_HH
 
     2 #define NETWORK_OBJECT_HH
 
     2 #define NETWORK_OBJECT_HH
 
       
     3 
       
     4 #include "NetworkSession.hh"
 
       
     5 #include "NetworkNode.hh"
 
       
     6 #include "Logger.hh"
 
     3 
     7 
     4 #include <map>
 
     8 #include <map>
 
     5 
     9 
     6 typedef uint32_t NetworkObjectID;
 
    10 typedef uint32_t NetworkObjectID;
 
     7 typedef uint16_t NetworkMessageID;
 
    11 typedef uint16_t NetworkMessageID;
 
       
    12 
       
    13 // forward-declare
 
       
    14 class NetworkObject;
 
       
    15 class NetworkObject_Client;
 
       
    16 class NetworkObject_Server;
 
     8 
    17 
     9 class NetworkObjectController {
 
    18 class NetworkObjectController {
 
    10     friend class NetworkObject;
 
    19     friend class NetworkObject;
 
    11 
    20 
    12     private:
 
    21     private:
 
    19     
    28     
    20     protected:
 
    29     protected:
 
    21         NetworkObjectController (NetworkSession &session, NetworkChannelID channel_id);
 
    30         NetworkObjectController (NetworkSession &session, NetworkChannelID channel_id);
 
    22     
    31     
    23     private:
 
    32     private:
 
    24         void on_message (const NetworkPacket &pkt, NetworkNode *node);
 
    33         void on_message (NetworkPacket &pkt, NetworkNode *node);
 
    25 
    34 
    26     protected:
 
    35     protected:
 
    27         virtual void handle_create (NetworkObjectID obj_id, NetworkMessageID msg_id, const NetworkPacket &pkt, NetworkNode *node) = 0; 
    36         virtual void handle_create (NetworkObjectID obj_id, NetworkMessageID msg_id, NetworkPacket &pkt, NetworkNode *node) = 0; 
    28 };
 
    37 };
 
    29 
    38 
    30 class NetworkObject_ServerController : NetworkObjectController {
 
    39 class NetworkObject_ServerController : public NetworkObjectController {
 
    31     friend class NetworkObject_Server;
 
    40     friend class NetworkObject_Server;
 
    32 
    41 
    33     private:
 
    42     private:
 
    34         NetworkObjectID id_pool;
 
    43         NetworkObjectID id_pool;
 
    35     
    44     
    37         NetworkObject_ServerController (NetworkSession &session, NetworkChannelID channel_id);
 
    46         NetworkObject_ServerController (NetworkSession &session, NetworkChannelID channel_id);
 
    38 
    47 
    39     protected:
 
    48     protected:
 
    40         NetworkObjectID getObjectId (void);
 
    49         NetworkObjectID getObjectId (void);
 
    41 
    50 
    42         virtual void handle_create (NetworkObjectID obj_id, NetworkMessageID msg_id, const NetworkPacket &pkt, NetworkNode *node);
 
    51         virtual void handle_create (NetworkObjectID obj_id, NetworkMessageID msg_id, NetworkPacket &pkt, NetworkNode *node);
 
    43 };
 
    52 };
 
    44 
    53 
    45 class NetworkObject_ClientController : NetworkObjectController {
 
    54 class NetworkObject_ClientController : public NetworkObjectController {
 
    46     friend class NetworkObject_Client;
 
    55     friend class NetworkObject_Client;
 
    47 
    56 
    48     private:
 
    57     private:
 
    49         NetworkNode *server;
 
    58         NetworkNode *server;
 
    50 
    59 
    51         CL_Signal_v3<NetworkObject_Client*, NetworkMessageID, const NetworkPacket&> _sig_create;
 
    60         CL_Signal_v3<NetworkObject_Client*, NetworkMessageID, NetworkPacket&> _sig_create;
 
    52     
    61     
    53     protected:
 
       
    54         virtual void handle_create (NetworkObjectID obj_id, NetworkMessageID msg_id, const NetworkPacket &pkt, NetworkNode *node);
 
       
    55 
       
    56     public:
 
    62     public:
 
    57         NetworkObject_ClientController (NetworkSession &session, NetworkChannelID channel_id, NetworkNode *server);
 
    63         NetworkObject_ClientController (NetworkSession &session, NetworkChannelID channel_id, NetworkNode *server);
 
    58         
    64 
    59         CL_Signal_v3<NetworkObject_Client*, NetworkMessageID, const NetworkPacket&>& sig_create (void) { return _sig_create; }
 
    65     protected:
 
       
    66         virtual void handle_create (NetworkObjectID obj_id, NetworkMessageID msg_id, NetworkPacket &pkt, NetworkNode *node);
 
       
    67     
       
    68     public:  
       
    69         CL_Signal_v3<NetworkObject_Client*, NetworkMessageID, NetworkPacket&>& sig_create (void) { return _sig_create; }
 
    60 };
 
    70 };
 
    61 
    71 
    62 class NetworkObject {
 
    72 class NetworkObject {
 
    63     friend class NetworkObjectController;
 
    73     friend class NetworkObjectController;
 
    64 
    74 
    65     private:
 
    75     private:
 
    66         NetworkObjectID obj_id;
 
    76         NetworkObjectID obj_id;
 
    67 
    77 
    68         std::map<NetworkMessageID, CL_Signal_v2<NetworkNode*, const NetworkPacket&>> _map_sig_message;
 
    78         std::map<NetworkMessageID, CL_Signal_v2<NetworkNode*, NetworkPacket&> > _map_sig_message;
 
    69         
    79         
    70     protected:
 
    80     protected:
 
    71         NetworkObject (NetworkObjectID obj_id, NetworkObjectController &controller);
 
    81         NetworkObject (NetworkObjectID obj_id, NetworkObjectController &controller);
 
    72 
    82 
    73         void buildPacket (NetworkPacket &pkt, NetworkMessageID msg_id, const NetworkPacket &payload);
 
    83         void buildPacket (NetworkPacket &pkt, NetworkMessageID msg_id, const NetworkPacket &payload);
 
    74 
    84 
    75     public:
 
    85     public:
 
    76         CL_Signal_v2<NetworkNode*, const NetworkPacket&>& sig_message (NetworkMessageID msg_id) { return _map_sig_message[msg_id]; }
 
    86         CL_Signal_v2<NetworkNode*, NetworkPacket&>& sig_message (NetworkMessageID msg_id) { return _map_sig_message[msg_id]; }
 
    77 };
 
    87 };
 
       
    88 
       
    89 std::ostream& operator<< (std::ostream &s, const NetworkObject &obj);
 
    78 
    90 
    79 class NetworkObject_Server : public NetworkObject {
 
    91 class NetworkObject_Server : public NetworkObject {
 
    80     friend class NetworkObject_ServerController;
 
    92     friend class NetworkObject_ServerController;
 
    81 
    93 
    82     private:
 
    94     private:
 
    83         NetworkObject_ServerController &controller;
 
    95         NetworkObject_ServerController &controller;
 
    84 
    96 
    85     public:
 
    97     public:
 
    86         NetworkObject_Server (NetworkObjectController &controller);
 
    98         NetworkObject_Server (NetworkObject_ServerController &controller);
 
    87 
    99 
    88         void send_to (NetworkNode *dst, NetworkMessageID msg_id, const NetworkPacket &pkt, bool reliable = true);
 
   100         void send_to (NetworkNode *dst, NetworkMessageID msg_id, const NetworkPacket &pkt, bool reliable = true);
 
    89         void send_all (NetworkMessageID msg_id, const NetworkPacket &pkt, bool reliable = true);
 
   101         void send_all (NetworkMessageID msg_id, const NetworkPacket &pkt, bool reliable = true);
 
    90         void send_all_except (NetworkMessageID msg_id, const NetworkPacket &pkt, NetworkNode *black_sheep, bool reliable = true);
 
   102         void send_all_except (NetworkMessageID msg_id, const NetworkPacket &pkt, NetworkNode *black_sheep, bool reliable = true);
 
    91 };
 
   103 };
 
    99     protected:
 
   111     protected:
 
   100         NetworkObject_Client (NetworkObject_ClientController &controller, NetworkNode *server, NetworkObjectID id);
 
   112         NetworkObject_Client (NetworkObject_ClientController &controller, NetworkNode *server, NetworkObjectID id);
 
   101 
   113 
   102     public:
 
   114     public:
 
   103         void send (NetworkMessageID msg_id, const NetworkPacket &pkt, bool reliable = true);
 
   115         void send (NetworkMessageID msg_id, const NetworkPacket &pkt, bool reliable = true);
 
   104 }
 
   116 };
 
   105 
   117 
   106 #endif /* NETWORK_OBJECT_HH */
 
   118 #endif /* NETWORK_OBJECT_HH */
kg