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

    12

    uint32_t obj_id = pkt.read_uint32();

    13

    uint16_t msg_id = pkt.read_uint16();

    14

    15

    // lookup object

    16

    NetworkObject *obj = objects[obj_id];

    17

    18

    if (obj) {

    19

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

    20

    21

    } else {

    22

        handle_create(obj_id, msg_id, pkt, node);

    23

    }

    24

}

    25

    26

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

    27

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

    28

    29

}

    30

    31

NetworkObjectID NetworkObject_ServerController::getObjectID (void) {

    32

    return ++id_pool;

    33

}

    34

    36

    // XXX: fail

    37

    throw CL_Error("clients cannot create objects");

    38

}

    39

    40

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

    41

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

    42

    43

    44

}

    45

    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

   102

}

   103