1

     2

#include <cassert>

     3

     4

#include "Object.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 (NetworkPacketInput &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

NetworkObject* NetworkObjectController::read_object (NetworkPacketInput &pkt) {

    32

    uint32_t obj_id = pkt.read_uint32();

    33

    34

    // lookup object

    35

    NetworkObject *obj = obj_id ? objects[obj_id] : NULL;

    36

    37

    // return

    38

    return obj;

    39

}

    40

    41

void NetworkObjectController::write_object (NetworkPacketOutput &pkt, NetworkObject *obj) {

    42

    pkt.write_uint32(obj ? obj->obj_id : 0);

    43

}

    44

    45

/* 

    46

 * NetworkObject_ServerController 

    47

 */

    48

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

    49

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

    50

    51

}

    52

    53

NetworkObjectID NetworkObject_ServerController::getObjectID (void) {

    54

    return ++id_pool;

    55

}

    56

    57

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

    58

    (void) obj_id;

    59

    (void) msg_id;

    60

    (void) pkt;

    61

    (void) node;

    62

    63

    // XXX: fail

    64

    throw CL_Error("clients cannot create objects");

    65

}

    66

    67

/* 

    68

 * NetworkObject_ClientController *

    69

 */

    70

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

    71

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

    72

    73

    74

}

    75

    76

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

    77

    // we only communicate with the server

    80

    81

    // create new object

    82

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

    83

    84

    // signal

    85

    // XXX: this leaks if it's not handled

    86

   _map_sig_create[msg_id](obj, pkt); 

    87

}

    88

    89

/* 

    90

 * NetworkObject 

    91

 */

    92

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

    93

    controller(controller), obj_id(obj_id) {

    94

    95

    assert(obj_id);

    96

    97

    controller.objects[obj_id] = this;

    98

}

    99

   100

NetworkObject::~NetworkObject (void) {

   101

    controller.objects.erase(obj_id);

   102

}

   103

   104

void NetworkObject::buildPacket (NetworkPacketOutput &pkt, NetworkMessageID msg_id, const NetworkPacketBuffer &payload) {

   105

    pkt.write_uint32(obj_id);

   106

    pkt.write_uint16(msg_id);

   107

    pkt.write_packet(payload);

   108

}

   109

   110

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

   111

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

   112

}

   113

   114

/* 

   115

 * NetworkObject_Server 

   116

 */

   117

NetworkObject_Server::NetworkObject_Server (NetworkObject_ServerController &controller) :

   118

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

   119

   120

}

   121

   122

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

   123

    _map_sig_message[msg_id](node, pkt);

   124

}

   125

   126

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

   127

    NetworkPacket pkt_out;

   128

   129

    buildPacket(pkt_out, msg_id, pkt);

   130

   131

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

   132

}

   133

   134

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

   135

    send_all_except(msg_id, pkt, NULL, reliable);

   136

}

   137

   138

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

   139

    NetworkPacket pkt_out;

   140

   141

    buildPacket(pkt_out, msg_id, pkt);

   142

   143

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

   144

}

   145

   146

/* 

   147

 * NetworkObject_Client 

   148

 */

   149

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

   150

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

   151

   152

    // nothing

   153

}

   154

   155

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

   158

   159

    _map_sig_message[msg_id](pkt);

   160

}

   161

   162

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

   163

    NetworkPacket pkt_out;

   164

   165

    buildPacket(pkt_out, msg_id, pkt);

   166

   167

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

   168

}

   169