1 

     2 #include <cassert>

     3 

     4 #include "NetworkObject.hh"

     5 

     6 /* 

     7  * NetworkObject_Controller 

     8  */

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

    10     session(session), channel_id(channel_id) {

    11     

    12     // setup signals

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

    14 }

    15 

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

    17     uint32_t obj_id = pkt.read_uint32();

    18     uint16_t msg_id = pkt.read_uint16();

    19     

    20     // lookup object

    21     NetworkObject *obj = objects[obj_id];

    22 

    23     if (obj) {

    24         obj->handle_packet(node, msg_id, pkt);

    25 

    26     } else {

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

    28     }

    29 }

    30 

    31 /* 

    32  * NetworkObject_ServerController 

    33  */

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

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

    36 

    37 }

    38 

    39 NetworkObjectID NetworkObject_ServerController::getObjectID (void) {

    40     return ++id_pool;

    41 }

    42         

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

    44     (void) obj_id;

    45     (void) msg_id;

    46     (void) pkt;

    47     (void) node;

    48 

    49     // XXX: fail

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

    51 }

    52         

    53 /* 

    54  * NetworkObject_ClientController *

    55  */

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

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

    58 

    59 

    60 }

    61         

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

    63     // we only communicate with the server

    64     assert(node == server);

    65     

    66     // create new object

    67     NetworkObject_Client *obj = new NetworkObject_Client(*this, obj_id);

    68     

    69     // signal

    70    _sig_create(obj, msg_id, pkt); 

    71 }

    72 

    73 /* 

    74  * NetworkObject 

    75  */

    76 NetworkObject::NetworkObject (NetworkObjectController &controller, NetworkObjectID obj_id) :

    77     obj_id(obj_id) {

    78     

    79     assert(obj_id);

    80 

    81     controller.objects[obj_id] = this;

    82 }

    83         

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

    85     pkt.write_uint32(obj_id);

    86     pkt.write_uint16(msg_id);

    87     pkt.write_packet(payload);

    88 }

    89 

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

    91     return s << "<NetworkObject #" << obj.obj_id << ">";

    92 }

    93 

    94 /* 

    95  * NetworkObject_Server 

    96  */

    97 NetworkObject_Server::NetworkObject_Server (NetworkObject_ServerController &controller) :

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

    99     

   100 }

   101 

   102 void NetworkObject_Server::handle_packet (NetworkNode *node, NetworkMessageID msg_id, NetworkPacket &pkt) {

   103     _map_sig_message[msg_id](node, pkt);

   104 }

   105 

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

   107     NetworkPacket pkt_out;

   108 

   109     buildPacket(pkt_out, msg_id, pkt);

   110 

   111     dst->send(controller.channel_id, pkt_out, reliable);

   112 }

   113 

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

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

   116 }

   117 

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

   119     NetworkPacket pkt_out;

   120 

   121     buildPacket(pkt_out, msg_id, pkt);

   122     

   123     controller.session.send_all_except(controller.channel_id, pkt_out, black_sheep, reliable);

   124 }

   125  

   126 /* 

   127  * NetworkObject_Client 

   128  */

   129 NetworkObject_Client::NetworkObject_Client (NetworkObject_ClientController &controller, NetworkObjectID id) :

   130     NetworkObject(controller, id), controller(controller) { 

   131     

   132     // nothing

   133 }

   134 

   135 void NetworkObject_Client::handle_packet (NetworkNode *node, NetworkMessageID msg_id, NetworkPacket &pkt) {

   136     assert(node == controller.server);

   137 

   138     _map_sig_message[msg_id](pkt);

   139 }

   140        

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

   142     NetworkPacket pkt_out;

   143 

   144     buildPacket(pkt_out, msg_id, pkt);

   145 

   146     controller.server->send(controller.channel_id, pkt_out, reliable);

   147 }

   148