1 

     2 #include "NetworkObject.hh"

     3 

     4 NetworkObjectController::NetworkObjectController (NetworkSession &session, NetworkChannelID channel_id) :

     5     session(session), channel_id(channel_id), id_pool(0) {

     6     

     7     // setup signals

     8     slot_message = session.sig_chan_message(channel_id).connect(this, &NetworkObjectController::on_message);

     9 }

    10 

    11 

    12 void NetworkObjectController::on_message (const NetworkPacket &pkt, NetworkNode *node) {

    13     uint32_t obj_id = pkt.read_uint32();

    14     uint16_t msg_id = pkt.read_uint16();

    15     

    16     // lookup object

    17     NetworkObject *obj = objects[obj_id];

    18 

    19     if (obj) {

    20         obj->_map_sig_message[msg_id](node, pkt);

    21 

    22     } else {

    23         handle_create(obj_id, msg_id, pkt, node);

    24     }

    25 }

    26 

    27 NetworkObject_ServerController::NetworkObject_ServerController (NetworkSession &session, NetworkChannelID channel_id) :

    28     NetworkObjectController(session, channel_id), id_pool(0) {

    29 

    30 }

    31 

    32 NetworkObjectID NetworkObject_ServerController::getObjectID (void) {

    33     return ++id_pool;

    34 }

    35         

    36 void NetworkObject_ServerController::handle_create (NetworkObjectID obj_id, NetworkMessageID msg_id, const NetworkPacket &pkt, NetworkNode *node) {

    37     // XXX: fail

    38     throw CL_Error("clients cannot create objects");

    39 }

    40         

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

    42     NetworkObjectController(session, channel_id), server(server) {

    43 

    44 

    45 }

    46         

    47 void NetworkObject_ClientController::handle_create (NetworkObjectID obj_id, NetworkMessageID msg_id, const NetworkPacket &pkt, NetworkNode *node) {

    48     assert(node == server);

    49     

    50     // create new object

    51     NetworkObject_Client *obj = new NetworkObject_Client(*this, node, obj_id);

    52     

    53     // signal

    54    _sig_create(obj, msg_id, pkt); 

    55 }

    56 

    57 NetworkObject::NetworkObject (NetworkObjectID obj_id) :

    58     obj_id(obj_id) {

    59     

    60     assert(obj_id);

    61 

    62     controller.objects[obj_id] = this;

    63 }

    64         

    65 void NetworkObject::buildPacket (NetworkPacket &pkt, NetworkMessageID msg_id, const NetworkPacket &payload) {

    66     pkt.write_uint32(obj_id);

    67     pkt.write_uint16(msg_id);

    68     pkt.write_packet(payload);

    69 }

    70 

    71 NetworkObject_Server::NetworkObject_Server (NetworkObject_ServerController &controller) :

    72     NetworkObject(controller.getObjectID()), controller(controller) {

    73     

    74 }

    75 

    76 void NetworkObject_Server::send_to (NetworkNode *dst, NetworkMessageID msg_id, const NetworkPacket &pkt, bool reliable) {

    77     NetworkPacket pkt;

    78 

    79     buildPacket(pkt, msg_id, pkt);

    80 

    81     dst->send(controller.channel_id, pkt, reliable);

    82 }

    83 

    84 void NetworkObject_Server::send_all (NetworkMessageID msg_id, const NetworkPacket &pkt, bool reliable) {

    85     send_all_except(msg_id, pkt, NULL, reliable);

    86 }

    87 

    88 void NetworkObject_Server::send_all_except (NetworkMessageID msg_id, const NetworkPacket &pkt, NetworkNode *black_sheep, bool reliable) {

    89     NetworkPacket pkt;

    90 

    91     buildPacket(pkt, msg_id, pkt);

    92     

    93     controller.session.send_all_except(controller.channel_id, pkt, black_sheep, reliable);

    94 }

    95         

    96 void NetworkObject_Client::send (NetworkMessageID msg_id, const NetworkPacket &pkt, bool reliable) {

    97     NetworkPacket pkt;

    98 

    99     buildPacket(pkt, msg_id, pkt);

   100 

   101     node->send(controller.channel_id, pkt, reliable);

   102 }

   103