--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/src/proto2/NetworkObject.cc	Mon Nov 10 21:58:38 2008 +0000
@@ -0,0 +1,103 @@
+
+#include "NetworkObject.hh"
+
+NetworkObjectController::NetworkObjectController (NetworkSession &session, NetworkChannelID channel_id) :
+    session(session), channel_id(channel_id), id_pool(0) {
+    
+    // setup signals
+    slot_message = session.sig_chan_message(channel_id).connect(this, &NetworkObjectController::on_message);
+}
+
+
+void NetworkObjectController::on_message (const NetworkPacket &pkt, NetworkNode *node) {
+    uint32_t obj_id = pkt.read_uint32();
+    uint16_t msg_id = pkt.read_uint16();
+    
+    // lookup object
+    NetworkObject *obj = objects[obj_id];
+
+    if (obj) {
+        obj->_map_sig_message[msg_id](node, pkt);
+
+    } else {
+        handle_create(obj_id, msg_id, pkt, node);
+    }
+}
+
+NetworkObject_ServerController::NetworkObject_ServerController (NetworkSession &session, NetworkChannelID channel_id) :
+    NetworkObjectController(session, channel_id), id_pool(0) {
+
+}
+
+NetworkObjectID NetworkObject_ServerController::getObjectID (void) {
+    return ++id_pool;
+}
+        
+void NetworkObject_ServerController::handle_create (NetworkObjectID obj_id, NetworkMessageID msg_id, const NetworkPacket &pkt, NetworkNode *node) {
+    // XXX: fail
+    throw CL_Error("clients cannot create objects");
+}
+        
+NetworkObject_ClientController::NetworkObject_ClientController (NetworkSession &session, NetworkChannelID channel_id, NetworkNode *server) :
+    NetworkObjectController(session, channel_id), server(server) {
+
+
+}
+        
+void NetworkObject_ClientController::handle_create (NetworkObjectID obj_id, NetworkMessageID msg_id, const NetworkPacket &pkt, NetworkNode *node) {
+    assert(node == server);
+    
+    // create new object
+    NetworkObject_Client *obj = new NetworkObject_Client(*this, node, obj_id);
+    
+    // signal
+   _sig_create(obj, msg_id, pkt); 
+}
+
+NetworkObject::NetworkObject (NetworkObjectID obj_id) :
+    obj_id(obj_id) {
+    
+    assert(obj_id);
+
+    controller.objects[obj_id] = this;
+}
+        
+void NetworkObject::buildPacket (NetworkPacket &pkt, NetworkMessageID msg_id, const NetworkPacket &payload) {
+    pkt.write_uint32(obj_id);
+    pkt.write_uint16(msg_id);
+    pkt.write_packet(payload);
+}
+
+NetworkObject_Server::NetworkObject_Server (NetworkObject_ServerController &controller) :
+    NetworkObject(controller.getObjectID()), controller(controller) {
+    
+}
+
+void NetworkObject_Server::send_to (NetworkNode *dst, NetworkMessageID msg_id, const NetworkPacket &pkt, bool reliable) {
+    NetworkPacket pkt;
+
+    buildPacket(pkt, msg_id, pkt);
+
+    dst->send(controller.channel_id, pkt, reliable);
+}
+
+void NetworkObject_Server::send_all (NetworkMessageID msg_id, const NetworkPacket &pkt, bool reliable) {
+    send_all_except(msg_id, pkt, NULL, reliable);
+}
+
+void NetworkObject_Server::send_all_except (NetworkMessageID msg_id, const NetworkPacket &pkt, NetworkNode *black_sheep, bool reliable) {
+    NetworkPacket pkt;
+
+    buildPacket(pkt, msg_id, pkt);
+    
+    controller.session.send_all_except(controller.channel_id, pkt, black_sheep, reliable);
+}
+        
+void NetworkObject_Client::send (NetworkMessageID msg_id, const NetworkPacket &pkt, bool reliable) {
+    NetworkPacket pkt;
+
+    buildPacket(pkt, msg_id, pkt);
+
+    node->send(controller.channel_id, pkt, reliable);
+}
+

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/src/proto2/NetworkObject.hh	Mon Nov 10 21:58:38 2008 +0000
@@ -0,0 +1,106 @@
+#ifndef NETWORK_OBJECT_HH
+#define NETWORK_OBJECT_HH
+
+#include <map>
+
+typedef uint32_t NetworkObjectID;
+typedef uint16_t NetworkMessageID;
+
+class NetworkObjectController {
+    friend class NetworkObject;
+
+    private:
+        NetworkSession &session;
+        NetworkChannelID channel_id;
+
+        std::map<NetworkObjectID, NetworkObject*> objects;
+
+        CL_Slot slot_message;
+    
+    protected:
+        NetworkObjectController (NetworkSession &session, NetworkChannelID channel_id);
+    
+    private:
+        void on_message (const NetworkPacket &pkt, NetworkNode *node);
+
+    protected:
+        virtual void handle_create (NetworkObjectID obj_id, NetworkMessageID msg_id, const NetworkPacket &pkt, NetworkNode *node) = 0; 
+};
+
+class NetworkObject_ServerController : NetworkObjectController {
+    friend class NetworkObject_Server;
+
+    private:
+        NetworkObjectID id_pool;
+    
+    public:
+        NetworkObject_ServerController (NetworkSession &session, NetworkChannelID channel_id);
+
+    protected:
+        NetworkObjectID getObjectId (void);
+
+        virtual void handle_create (NetworkObjectID obj_id, NetworkMessageID msg_id, const NetworkPacket &pkt, NetworkNode *node);
+};
+
+class NetworkObject_ClientController : NetworkObjectController {
+    friend class NetworkObject_Client;
+
+    private:
+        NetworkNode *server;
+
+        CL_Signal_v3<NetworkObject_Client*, NetworkMessageID, const NetworkPacket&> _sig_create;
+    
+    protected:
+        virtual void handle_create (NetworkObjectID obj_id, NetworkMessageID msg_id, const NetworkPacket &pkt, NetworkNode *node);
+
+    public:
+        NetworkObject_ClientController (NetworkSession &session, NetworkChannelID channel_id, NetworkNode *server);
+        
+        CL_Signal_v3<NetworkObject_Client*, NetworkMessageID, const NetworkPacket&>& sig_create (void) { return _sig_create; }
+};
+
+class NetworkObject {
+    friend class NetworkObjectController;
+
+    private:
+        NetworkObjectID obj_id;
+
+        std::map<NetworkMessageID, CL_Signal_v2<NetworkNode*, const NetworkPacket&>> _map_sig_message;
+        
+    protected:
+        NetworkObject (NetworkObjectID obj_id, NetworkObjectController &controller);
+
+        void buildPacket (NetworkPacket &pkt, NetworkMessageID msg_id, const NetworkPacket &payload);
+
+    public:
+        CL_Signal_v2<NetworkNode*, const NetworkPacket&>& sig_message (NetworkMessageID msg_id) { return _map_sig_message[msg_id]; }
+};
+
+class NetworkObject_Server : public NetworkObject {
+    friend class NetworkObject_ServerController;
+
+    private:
+        NetworkObject_ServerController &controller;
+
+    public:
+        NetworkObject_Server (NetworkObjectController &controller);
+
+        void send_to (NetworkNode *dst, NetworkMessageID msg_id, const NetworkPacket &pkt, bool reliable = true);
+        void send_all (NetworkMessageID msg_id, const NetworkPacket &pkt, bool reliable = true);
+        void send_all_except (NetworkMessageID msg_id, const NetworkPacket &pkt, NetworkNode *black_sheep, bool reliable = true);
+};
+
+class NetworkObject_Client : public NetworkObject {
+    friend class NetworkObject_ClientController;
+
+    private:
+        NetworkObject_ClientController &controller;
+
+    protected:
+        NetworkObject_Client (NetworkObject_ClientController &controller, NetworkNode *server, NetworkObjectID id);
+
+    public:
+        void send (NetworkMessageID msg_id, const NetworkPacket &pkt, bool reliable = true);
+}
+
+#endif /* NETWORK_OBJECT_HH */

--- a/src/proto2/NetworkSession.cc	Mon Nov 10 19:57:57 2008 +0000
+++ b/src/proto2/NetworkSession.cc	Mon Nov 10 21:58:38 2008 +0000
@@ -15,7 +15,7 @@
     udp_srv = new NetworkUDP(addr);
     
     // connect signals
-    slots.connect(tcp->sig_client, this, &NetworkSession::on_tcp_client);
+    slots.connect(tcp->sig_client(), this, &NetworkSession::on_tcp_client);
 }
         
 NetworkNode* NetworkSession::connect (const NetworkAddress &addr) {
@@ -33,7 +33,7 @@
     nodes[addr] = client_node;
 
     // bind signals
-    slots.connect(tcp_client->sig_disconnected, this, &NetworkSession::on_disconnect, client_node);
+    slots.connect(tcp_client->sig_disconnect(), this, &NetworkSession::on_disconnect, client_node);
 }
         
 void NetworkSession::on_tcp_client (const NetworkTCPTransport *tcp_client) {
@@ -47,10 +47,10 @@
     nodes[addr] = client_node;
 
     // bind signals
-    slots.connect(tcp_client->sig_disconnected, this, &NetworkSession::on_disconnect, client_node);
+    slots.connect(tcp_client->sig_disconnect(), this, &NetworkSession::on_disconnect, client_node);
 
     // fire signals
-    sig_node_connected(node);
+    _sig_node_connected(node);
 }
         
 void NetworkSession::on_disconnect (NetworkNode *node) {
@@ -58,7 +58,7 @@
     nodes.erase(node->getRemoteAddress());
 
     // fire signal
-    sig_node_disconnected(node);
+    _sig_node_disconnected(node);
     
     // delete
     delete node;

--- a/src/proto2/NetworkSession.hh	Mon Nov 10 19:57:57 2008 +0000
+++ b/src/proto2/NetworkSession.hh	Mon Nov 10 21:58:38 2008 +0000
@@ -25,6 +25,7 @@
         CL_SlotContainer slots;
 
         std::map<NetworkAddress, NetworkNode*> nodes;
+        std::map<NetworkChannelID, CL_Signal_v2<const NetworkPacket&, NetworkNode *>> _map_sig_chan_message;
     
     public:
         NetworkSession (NetworkSessionMagic magic);
@@ -36,12 +37,16 @@
         void on_tcp_client (const NetworkTCPTransport *client);
         void on_disconnect (NetworkNode *node);
 
+         CL_Signal_v1<NetworkNode*> _sig_node_connected;
+         CL_Signal_v1<NetworkNode*> _sig_node_disconnected;
+
     public:
         void send_all (NetworkChannelID channel_id, const NetworkPacket &pkt, bool reliable = true);
         void send_all_except (NetworkChannelID channel_id, const NetworkPacket &pkt, const NetworkNode *node, bool reliable = true);
 
-        CL_Signal_v1<NetworkNode*> sig_node_connected;
-        CL_Signal_v1<NetworkNode*> sig_node_disconnected;
+        CL_Signal_v1<NetworkNode*> sig_node_connected (void) { return _sig_node_connected; }
+        CL_Signal_v1<NetworkNode*> sig_node_disconnected (void) { return _sig_node_disconnected; }
+        CL_Signal_v2<const NetworkPacket&, NetworkNode *>& sig_chan_message (NetworkChannelID cid) { return _map_sig_chan_message(cid); }
 };
 
 #endif /* NETWORK_SESSION_HH */

--- a/src/proto2/NetworkTCP.cc	Mon Nov 10 19:57:57 2008 +0000
+++ b/src/proto2/NetworkTCP.cc	Mon Nov 10 21:58:38 2008 +0000
@@ -235,7 +235,7 @@
     // let the in stream read length-prefixed packets and pass them on to handle_packet
     while ((prefix = in.read_prefix(packet.get_buf(), packet.get_buf_size)) > 0) {
         packet.set_data_size(prefix);
-        sig_packet(packet);
+        _sig_packet(packet);
     }
 }
 
@@ -246,13 +246,9 @@
 
 void NetworkTCPTransport::on_disconnected (void) {
     // pass right through
-    sig_disconnect();
+    _sig_disconnect();
 }
         
-NetworkAddress NetworkTCPTransport::getRemoteAddress (void) {
-    return socket.get_dest_address();
-}
-
 void NetworkTCPTransport::write_packet (const NetworkPacket &packet) {
     uint16_t prefix = packet.get_data_size();
     
@@ -285,7 +281,7 @@
     NetworkTCPTransport *client = buildTransport(client_sock);
         
     // let our user handle it
-    sig_client(client);
+    _sig_client(client);
 }
         
 virtual NetworkTCPTransport NetworkTCPServer::buildTransport (CL_Socket &socket) {

--- a/src/proto2/NetworkTCP.hh	Mon Nov 10 19:57:57 2008 +0000
+++ b/src/proto2/NetworkTCP.hh	Mon Nov 10 21:58:38 2008 +0000
@@ -58,13 +58,16 @@
         void on_write (void);
         void on_disconnected (void);
 
+        CL_Signal_v1<const NetworkPacket&> _sig_packet;
+        CL_Signal_v0 _sig_disconnect;
+
     public:
-        NetworkAddress getRemoteAddress (void);
+        NetworkAddress getRemoteAddress (void) { return socket.get_dest_address(); }
 
         void write_packet (const NetworkPacket &packet);
         
-        CL_Signal_v1<const NetworkPacket&> sig_packet;
-        CL_Signal_v0 sig_disconnect;
+        CL_Signal_v1<const NetworkPacket&> sig_packet (void) { return _sig_packet; }
+        CL_Signal_v0 sig_disconnect (void) { return _sig_disconnect; }
 };
 
 class NetworkTCPServer {
@@ -77,11 +80,13 @@
     private:
         void on_accept (void);
 
+        CL_Signal_v1<NetworkTCPTransport *> _sig_client;
+
     protected:
         virtual NetworkTCPTransport buildTransport (CL_Socket &socket);
 
     public:
-        CL_Signal_v1<NetworkTCPTransport *> sig_client;
+        CL_Signal_v1<NetworkTCPTransport *> sig_client (void) { return _sig_client; }
 };
 
 class NetworkTCPClient : public NetworkTCPTransport {

--- a/src/proto2/NetworkUDP.hh	Mon Nov 10 19:57:57 2008 +0000
+++ b/src/proto2/NetworkUDP.hh	Mon Nov 10 21:58:38 2008 +0000
@@ -16,10 +16,12 @@
     private:
         void on_recv (void);
 
+        CL_Signal_v2<const NetworkPacket &, const NetworkAddress> _sig_packet;
+
     public:
         bool sendto (const NetworkPacket &packet, const NetworkAddress &dst);
         
-        CL_Signal_v2<const NetworkPacket &, const NetworkAddress> sig_packet;
+        CL_Signal_v2<const NetworkPacket &, const NetworkAddress> sig_packet (void) { return _sig_packet; }
 };
 
 #endif /* NETWORK_UDP_HH */