1

     2

#include <cassert>

     3

     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