--- a/src/proto2/Application.cc	Tue Nov 18 22:58:50 2008 +0000
+++ b/src/proto2/Application.cc	Thu Nov 20 19:25:56 2008 +0000
@@ -1,5 +1,6 @@
 
 #include "Engine.hh"
+#include "Error.hh"
 
 #include <stdexcept>
 #include <cassert>
@@ -7,16 +8,9 @@
 #include <ClanLib/core.h>
 #include <ClanLib/application.h>
 
-class ArgumentError : public std::exception {
-    private:
-        const char *message;
-    
+class ArgumentError : public Error {
     public:
-        ArgumentError (const std::string &message) : message(message.c_str()) { }
-
-        virtual const char* what() const throw() {
-            return message;
-        }
+        ArgumentError (const std::string &message) : Error(message) { }
 };
 
 class Main : public CL_ClanApplication {

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/src/proto2/Error.hh	Thu Nov 20 19:25:56 2008 +0000
@@ -0,0 +1,16 @@
+#ifndef ERROR_HH
+#define ERROR_HH
+
+class Error : public std::exception {
+    private:
+        const char *message;
+    
+    public:
+        Error (const std::string &message) : message(message.c_str()) { }
+
+        virtual const char* what() const throw() {
+            return message;
+        }
+};
+
+#endif /* ERROR_HH */

--- a/src/proto2/Network.cc	Tue Nov 18 22:58:50 2008 +0000
+++ b/src/proto2/Network.cc	Thu Nov 20 19:25:56 2008 +0000
@@ -1,5 +1,6 @@
 
 #include "Network.hh"
+#include "NetworkAddress.hh"
 #include "Engine.hh"
 
 void writeVector (CL_NetPacket &pkt, const Vector &vec) {
@@ -39,3 +40,9 @@
     return vec;
 }
 
+std::ostream& operator<< (std::ostream &s, const NetworkAddress &addr) {
+    s << "[" << addr.get_address() << ":" << addr.get_port() << "]";
+
+    return s;
+
+}

--- a/src/proto2/Network.hh	Tue Nov 18 22:58:50 2008 +0000
+++ b/src/proto2/Network.hh	Thu Nov 20 19:25:56 2008 +0000
@@ -20,9 +20,12 @@
 
 };
 
-// XXX: util methods
-void writeVector (CL_NetPacket &pkt, const Vector &vec);
-Vector readVector (CL_NetPacket &pkt);
+enum NetworkChannel {
+    /*
+     * Core channel used for NetworkSession
+     */
+    NETCHAN_CORE            = 0x01,
+};
 
 enum NetworkMessage {
     NETMSG_PACKET_INVALID   = 0x00,

--- a/src/proto2/NetworkAddress.hh	Tue Nov 18 22:58:50 2008 +0000
+++ b/src/proto2/NetworkAddress.hh	Thu Nov 20 19:25:56 2008 +0000
@@ -5,4 +5,7 @@
 
 typedef CL_IPAddress NetworkAddress;
 
+// Network.cc
+std::ostream& operator<< (std::ostream &s, const NetworkAddress &addr);
+
 #endif /* NETWORK_ADDRESS_HH */

--- a/src/proto2/NetworkClient.cc	Tue Nov 18 22:58:50 2008 +0000
+++ b/src/proto2/NetworkClient.cc	Thu Nov 20 19:25:56 2008 +0000
@@ -5,17 +5,17 @@
 
 #include <cassert>
 
-NetworkClient::NetworkClient (GameState &state, const CL_IPAddress &connect_to) : 
-    NetworkCore(state), server(netsession.connect(connect_to)) {
+NetworkClient::NetworkClient (GameState &state, const NetworkAddress &connect_to) : 
+    NetworkCore(state), netsession(NETWORK_MAGIC_ID), server(netsession.connect(connect_to)), netobjs(netsession, NETCHAN_CORE, server) {
     
     // connect slots
-    slots.connect(netobjs.sig_create_object(), this, &NetworkClient::on_create_object);
+    slots.connect(netobjs.sig_create(), this, &NetworkClient::on_create);
 
     // XXX: sig_disconnected
 }
 
-void NetworkClient::on_create_object (CL_NetObject_Client &obj, int msg_type, CL_NetPacket &pkt) {
-    switch (msg_type) {
+void NetworkClient::on_create (NetworkObject_Client *obj, NetworkMessageID msg_id, NetworkPacket &pkt) {
+    switch (msg_id) {
         case NETMSG_SERVER_HELLO:
             on_server_hello(obj, pkt);
 
@@ -32,13 +32,13 @@
             break;
 
         default:
-            Engine::log(WARN, "client.on_create_object") << "unknown msg_type=" << msg_type << " for obj=" << obj;
+            Engine::log(WARN, "client.on_create_object") << "unknown msg_id=" << msg_id << " for obj=" << obj;
     }
 }
         
-void NetworkClient::on_server_hello (CL_NetObject_Client &obj, CL_NetPacket &pkt) {
+void NetworkClient::on_server_hello (NetworkObject_Client *obj, NetworkPacket &pkt) {
     // read the packet
-    Vector position = readVector(pkt);
+    Vector position = pkt.read_vector();
     
     Engine::log(INFO, "client.on_server_hello") << "obj=" << obj << ", pos=" << position;
 
@@ -49,9 +49,9 @@
     state.newLocalPlayer(player);
 }
         
-void NetworkClient::on_player_info (CL_NetObject_Client &obj, CL_NetPacket &pkt) {
+void NetworkClient::on_player_info (NetworkObject_Client *obj, NetworkPacket &pkt) {
     // read the packet
-    Vector position = readVector(pkt);
+    Vector position = pkt.read_vector();
     
     Engine::log(INFO, "client.on_player_info") << "obj=" << obj << ", pos=" << position;
 
@@ -63,9 +63,9 @@
 
 }
         
-void NetworkClient::on_player_join (CL_NetObject_Client &obj, CL_NetPacket &pkt) {
+void NetworkClient::on_player_join (NetworkObject_Client *obj, NetworkPacket &pkt) {
     // read the packet
-    Vector position = readVector(pkt);
+    Vector position = pkt.read_vector();
     
     Engine::log(INFO, "client.on_player_join") << "obj=" << obj << ", pos=" << position;
     
@@ -85,57 +85,58 @@
     //  delete player;
 }
 
-NetworkClientLocalPlayer::NetworkClientLocalPlayer (NetworkClient &client, CL_NetObject_Client &obj, Vector position) :
+NetworkClientLocalPlayer::NetworkClientLocalPlayer (NetworkClient &client, NetworkObject_Client *obj, Vector position) :
     LocalPlayer(client.state, position, true), client(client), obj(obj) {
     
     // receive messages
-    slots.connect(obj.sig_received_message(NETMSG_PLAYER_POSITION), this, &NetworkClientLocalPlayer::on_position);
+    slots.connect(obj->sig_message(NETMSG_PLAYER_POSITION), this, &NetworkClientLocalPlayer::on_position);
 }
         
 void NetworkClientLocalPlayer::applyForce (Vector force, uint16_t dt) {
     // always send move, in all cases
-    CL_NetPacket pkt;
-    writeVector(pkt, force);
-    pkt.output.write_uint16(dt);
+    NetworkPacket pkt;
+    pkt.write_vector(force);
+    pkt.write_uint16(dt);
 
-    obj.send(NETMSG_CLIENT_MOVE, pkt, false);
+    obj->send(NETMSG_CLIENT_MOVE, pkt, false);
     
     // do not handle locally
 }
         
-void NetworkClientLocalPlayer::on_position (CL_NetPacket &pkt) {
-    Vector position = readVector(pkt);
-    Vector velocity = readVector(pkt);
+void NetworkClientLocalPlayer::on_position (NetworkPacket &pkt) {
+    Vector position = pkt.read_vector();
+    Vector velocity = pkt.read_vector();
 
-    Engine::log(INFO, "client_player.on_position") << "obj=" << obj << ", position=" << position << ", velocity=" << velocity;
+    Engine::log(INFO, "client_player.on_position") /* << "obj=" << obj */ << ", position=" << position << ", velocity=" << velocity;
     
     // just update... 
     updatePhysics(position, velocity);
 }
         
-NetworkClientRemotePlayer::NetworkClientRemotePlayer (NetworkClient &client, CL_NetObject_Client &obj, Vector position) :
+NetworkClientRemotePlayer::NetworkClientRemotePlayer (NetworkClient &client, NetworkObject_Client *obj, Vector position) :
     RemotePlayer(client.state, position, true), client(client), obj(obj) {
     
     // receive messages
-    slots.connect(obj.sig_received_message(NETMSG_PLAYER_POSITION), this, &NetworkClientRemotePlayer::on_position);
-    slots.connect(obj.sig_received_message(NETMSG_PLAYER_QUIT), this, &NetworkClientRemotePlayer::on_quit);
+    slots.connect(obj->sig_message(NETMSG_PLAYER_POSITION), this, &NetworkClientRemotePlayer::on_position);
+    slots.connect(obj->sig_message(NETMSG_PLAYER_QUIT), this, &NetworkClientRemotePlayer::on_quit);
 }
 
-void NetworkClientRemotePlayer::on_position (CL_NetPacket &pkt) {
-    Vector position = readVector(pkt);
-    Vector velocity = readVector(pkt);
+void NetworkClientRemotePlayer::on_position (NetworkPacket &pkt) {
+    Vector position = pkt.read_vector();
+    Vector velocity = pkt.read_vector();
 
-    Engine::log(INFO, "client_player.on_position") << "obj=" << obj << ", position=" << position << ", velocity=" << velocity;
+    Engine::log(INFO, "client_player.on_position") /* << "obj=" << obj */ << ", position=" << position << ", velocity=" << velocity;
     
     // just update... 
     updatePhysics(position, velocity);
 }
 
-void NetworkClientRemotePlayer::on_quit (CL_NetPacket &pkt) {
+void NetworkClientRemotePlayer::on_quit (NetworkPacket &pkt) {
     // pkt is empty
     (void) pkt;
 
-    Engine::log(INFO, "client_player.on_quit") << "obj=" << obj;
+    Engine::log(INFO, "client_player.on_quit") /* << "obj=" << obj */;
 
     client.player_quit(this);
 }
+

--- a/src/proto2/NetworkClient.hh	Tue Nov 18 22:58:50 2008 +0000
+++ b/src/proto2/NetworkClient.hh	Thu Nov 20 19:25:56 2008 +0000
@@ -3,6 +3,8 @@
 
 #include "Network.hh"
 #include "GameState.hh"
+#include "NetworkSession.hh"
+#include "NetworkObject.hh"
 
 // forward-declare
 class NetworkClientLocalPlayer;
@@ -13,17 +15,20 @@
     friend class NetworkClientRemotePlayer;
 
     private:
-        CL_NetComputer server;
+        NetworkSession netsession;
+        NetworkNode *server;
+
+        NetworkObject_ClientController netobjs;
         
     public:
-        NetworkClient (GameState &state, const CL_IPAddress &connect_to);
+        NetworkClient (GameState &state, const NetworkAddress &connect_to);
 
     private:
-        void on_create_object (CL_NetObject_Client &obj, int msg_type, CL_NetPacket &pkt);
+        void on_create (NetworkObject_Client *obj, NetworkMessageID msg_id, NetworkPacket &pkt);
 
-        void on_server_hello (CL_NetObject_Client &obj, CL_NetPacket &pkt);
-        void on_player_info (CL_NetObject_Client &obj, CL_NetPacket &pkt);
-        void on_player_join (CL_NetObject_Client &obj, CL_NetPacket &pkt);
+        void on_server_hello (NetworkObject_Client *obj, NetworkPacket &pkt);
+        void on_player_info (NetworkObject_Client *obj, NetworkPacket &pkt);
+        void on_player_join (NetworkObject_Client *obj, NetworkPacket &pkt);
     
     public:
         void player_quit (NetworkClientRemotePlayer *player);
@@ -34,16 +39,16 @@
         NetworkClient &client;
 
         CL_SlotContainer slots;
-
-        CL_NetObject_Client obj;
+        
+        NetworkObject_Client *obj;
 
     public:
-        NetworkClientLocalPlayer (NetworkClient &client, CL_NetObject_Client &obj, Vector initial_position);
+        NetworkClientLocalPlayer (NetworkClient &client, NetworkObject_Client *obj, Vector position);
         
         virtual void applyForce (Vector force, uint16_t dt);
     
     private:
-        void on_position (CL_NetPacket &pkt);
+        void on_position (NetworkPacket &pkt);
 };
 
 class NetworkClientRemotePlayer : public RemotePlayer {
@@ -52,15 +57,15 @@
         
         CL_SlotContainer slots;
 
-        CL_NetObject_Client obj;
+        NetworkObject_Client *obj;
 
     public:
-        NetworkClientRemotePlayer (NetworkClient &client, CL_NetObject_Client &obj, Vector initial_position);
+        NetworkClientRemotePlayer (NetworkClient &client, NetworkObject_Client *obj, Vector position);
     
     private:
-        void on_position (CL_NetPacket &pkt);
+        void on_position (NetworkPacket &pkt);
 
-        void on_quit (CL_NetPacket &pkt);
+        void on_quit (NetworkPacket &pkt);
 };
 
 #endif

--- a/src/proto2/NetworkConfig.hh	Tue Nov 18 22:58:50 2008 +0000
+++ b/src/proto2/NetworkConfig.hh	Thu Nov 20 19:25:56 2008 +0000
@@ -23,4 +23,7 @@
 const size_t NETWORK_PACKET_SIZE = 1280;
 const int NETWORK_LISTEN_BACKLOG = 5;
 
+const char NETWORK_MAGIC_STR[8+1] = "KISNGLIS";
+const uint64_t NETWORK_MAGIC_ID = * ((const uint64_t *) NETWORK_MAGIC_STR);
+
 #endif /* NETWORK_CONFIG_HH */

--- a/src/proto2/NetworkNode.cc	Tue Nov 18 22:58:50 2008 +0000
+++ b/src/proto2/NetworkNode.cc	Thu Nov 20 19:25:56 2008 +0000
@@ -5,13 +5,25 @@
     session(session), tcp(tcp), udp(udp), address(address) {
     
     // connect signals
+    slots.connect(tcp->sig_disconnect(), this, &NetworkNode::on_disconnect);
     
 }
 
 NetworkNode::~NetworkNode (void) {
     delete tcp;
 }
-        
+
+void on_disconnect (void) {
+    // tell session
+    session.handle_disconnect(this);
+
+    // fire signal
+    _sig_disconnected();
+    
+    // delete
+    delete this;
+}
+
 void NetworkNode::send (NetworkChannelID channel_id, const NetworkPacket &pkt, bool reliable = true) {
     assert(channel_id > 0);
     

--- a/src/proto2/NetworkNode.hh	Tue Nov 18 22:58:50 2008 +0000
+++ b/src/proto2/NetworkNode.hh	Thu Nov 20 19:25:56 2008 +0000
@@ -1,7 +1,17 @@
 #ifndef NETWORK_NODE_HH
 #define NETWORK_NODE_HH
 
+// forward-declare
+class NetworkNode;
+
 #include "NetworkTCP.hh"
+#include "NetworkUDP.hh"
+#include "NetworkSession.hh"
+
+enum NetworkNodeType {
+    NETWORK_NODE_SERVER_CLIENT,
+    NETWORK_NODE_CLIENT_SERVER
+};
 
 class NetworkNode {
     private:
@@ -15,14 +25,20 @@
     private:
         NetworkNode (NetworkSession &session, NetworkTCPTransport *tcp, NetworkUDP &udp, const NetworkAddress &address);
         
-        NetworkNode (const NetworkNode &copy) { }
+        NetworkNode (const NetworkNode &copy);
         ~NetworkNode (void);
-        NetworkNode& operator= (const NetworkNode &copy) { }
+        NetworkNode& operator= (const NetworkNode &copy);
+        
+        void on_disconnect (void);
+         
+        CL_Signal_v0 _sig_disconnected;
 
     public:
         void send (NetworkChannelID channel_id, const NetworkPacket &pkt, bool reliable = true);
 
         const NetworkAddress& getRemoteAddress (void);
+        
+        CL_Signal_v0& sig_disconnected (void) { return _sig_disconnected; }
 };
 
 #endif /* NETWORK_NODE_HH */

--- a/src/proto2/NetworkObject.cc	Tue Nov 18 22:58:50 2008 +0000
+++ b/src/proto2/NetworkObject.cc	Thu Nov 20 19:25:56 2008 +0000
@@ -8,8 +8,7 @@
     slot_message = session.sig_chan_message(channel_id).connect(this, &NetworkObjectController::on_message);
 }
 
-
-void NetworkObjectController::on_message (const NetworkPacket &pkt, NetworkNode *node) {
+void NetworkObjectController::on_message (NetworkPacket &pkt, NetworkNode *node) {
     uint32_t obj_id = pkt.read_uint32();
     uint16_t msg_id = pkt.read_uint16();
     
@@ -33,7 +32,7 @@
     return ++id_pool;
 }
         
-void NetworkObject_ServerController::handle_create (NetworkObjectID obj_id, NetworkMessageID msg_id, const NetworkPacket &pkt, NetworkNode *node) {
+void NetworkObject_ServerController::handle_create (NetworkObjectID obj_id, NetworkMessageID msg_id, NetworkPacket &pkt, NetworkNode *node) {
     // XXX: fail
     throw CL_Error("clients cannot create objects");
 }
@@ -44,7 +43,8 @@
 
 }
         
-void NetworkObject_ClientController::handle_create (NetworkObjectID obj_id, NetworkMessageID msg_id, const NetworkPacket &pkt, NetworkNode *node) {
+void NetworkObject_ClientController::handle_create (NetworkObjectID obj_id, NetworkMessageID msg_id, NetworkPacket &pkt, NetworkNode *node) {
+    // we only communicate with the server
     assert(node == server);
     
     // create new object
@@ -98,6 +98,6 @@
 
     buildPacket(pkt, msg_id, pkt);
 
-    node->send(controller.channel_id, pkt, reliable);
+    controller.server->send(controller.channel_id, pkt, reliable);
 }
 

--- a/src/proto2/NetworkObject.hh	Tue Nov 18 22:58:50 2008 +0000
+++ b/src/proto2/NetworkObject.hh	Thu Nov 20 19:25:56 2008 +0000
@@ -1,11 +1,20 @@
 #ifndef NETWORK_OBJECT_HH
 #define NETWORK_OBJECT_HH
 
+#include "NetworkSession.hh"
+#include "NetworkNode.hh"
+#include "Logger.hh"
+
 #include <map>
 
 typedef uint32_t NetworkObjectID;
 typedef uint16_t NetworkMessageID;
 
+// forward-declare
+class NetworkObject;
+class NetworkObject_Client;
+class NetworkObject_Server;
+
 class NetworkObjectController {
     friend class NetworkObject;
 
@@ -21,13 +30,13 @@
         NetworkObjectController (NetworkSession &session, NetworkChannelID channel_id);
     
     private:
-        void on_message (const NetworkPacket &pkt, NetworkNode *node);
+        void on_message (NetworkPacket &pkt, NetworkNode *node);
 
     protected:
-        virtual void handle_create (NetworkObjectID obj_id, NetworkMessageID msg_id, const NetworkPacket &pkt, NetworkNode *node) = 0; 
+        virtual void handle_create (NetworkObjectID obj_id, NetworkMessageID msg_id, NetworkPacket &pkt, NetworkNode *node) = 0; 
 };
 
-class NetworkObject_ServerController : NetworkObjectController {
+class NetworkObject_ServerController : public NetworkObjectController {
     friend class NetworkObject_Server;
 
     private:
@@ -39,24 +48,25 @@
     protected:
         NetworkObjectID getObjectId (void);
 
-        virtual void handle_create (NetworkObjectID obj_id, NetworkMessageID msg_id, const NetworkPacket &pkt, NetworkNode *node);
+        virtual void handle_create (NetworkObjectID obj_id, NetworkMessageID msg_id, NetworkPacket &pkt, NetworkNode *node);
 };
 
-class NetworkObject_ClientController : NetworkObjectController {
+class NetworkObject_ClientController : public NetworkObjectController {
     friend class NetworkObject_Client;
 
     private:
         NetworkNode *server;
 
-        CL_Signal_v3<NetworkObject_Client*, NetworkMessageID, const NetworkPacket&> _sig_create;
+        CL_Signal_v3<NetworkObject_Client*, NetworkMessageID, 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; }
+
+    protected:
+        virtual void handle_create (NetworkObjectID obj_id, NetworkMessageID msg_id, NetworkPacket &pkt, NetworkNode *node);
+    
+    public:  
+        CL_Signal_v3<NetworkObject_Client*, NetworkMessageID, NetworkPacket&>& sig_create (void) { return _sig_create; }
 };
 
 class NetworkObject {
@@ -65,7 +75,7 @@
     private:
         NetworkObjectID obj_id;
 
-        std::map<NetworkMessageID, CL_Signal_v2<NetworkNode*, const NetworkPacket&>> _map_sig_message;
+        std::map<NetworkMessageID, CL_Signal_v2<NetworkNode*, NetworkPacket&> > _map_sig_message;
         
     protected:
         NetworkObject (NetworkObjectID obj_id, NetworkObjectController &controller);
@@ -73,9 +83,11 @@
         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]; }
+        CL_Signal_v2<NetworkNode*, NetworkPacket&>& sig_message (NetworkMessageID msg_id) { return _map_sig_message[msg_id]; }
 };
 
+std::ostream& operator<< (std::ostream &s, const NetworkObject &obj);
+
 class NetworkObject_Server : public NetworkObject {
     friend class NetworkObject_ServerController;
 
@@ -83,7 +95,7 @@
         NetworkObject_ServerController &controller;
 
     public:
-        NetworkObject_Server (NetworkObjectController &controller);
+        NetworkObject_Server (NetworkObject_ServerController &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);
@@ -101,6 +113,6 @@
 
     public:
         void send (NetworkMessageID msg_id, const NetworkPacket &pkt, bool reliable = true);
-}
+};
 
 #endif /* NETWORK_OBJECT_HH */

--- a/src/proto2/NetworkPacket.cc	Tue Nov 18 22:58:50 2008 +0000
+++ b/src/proto2/NetworkPacket.cc	Thu Nov 20 19:25:56 2008 +0000
@@ -10,13 +10,13 @@
 
 void NetworkPacket::check_write_size (size_t item_size) {
      if (offset + item_size > buf_size)
-        throw CL_Error("not enough space to write");
+        throw NetworkPacketError("not enough space to write");
 
 }
         
 void NetworkPacket::check_read_size (size_t item_size) {
     if (offset + item_size > data_size)
-        throw CL_Error("not enough data to read");
+        throw NetworkPacketError("not enough data to read");
 }
 
 template <typename T> T NetworkPacket::read_val (void) {
@@ -47,29 +47,40 @@
     data_size += sizeof(T);
 }
 
-uint32_t NetworkPacket::read_uint32 (void) const {
+uint32_t NetworkPacket::read_uint32 (void) {
     return ntohl(read_val<uint32_t>());
 }
 
-uint16_t NetworkPacket::read_uint16 (void) const {
+uint16_t NetworkPacket::read_uint16 (void) {
     return ntohs(read_val<uint16_t>());
 }
 
-uint8_t NetworkPacket::read_uint8 (void) const {
+uint8_t NetworkPacket::read_uint8 (void) {
     return read_val<uint8_t>();
 }
 
-int32_t NetworkPacket::read_int32 (void) const {
+int32_t NetworkPacket::read_int32 (void) {
     return ntohl(read_val<int32_t>());
 }
 
-int16_t NetworkPacket::read_int16 (void) const {
+int16_t NetworkPacket::read_int16 (void) {
     return ntohs(read_val<int16_t>());
 }
 
-int8_t NetworkPacket::read_int8 (void) const {
+int8_t NetworkPacket::read_int8 (void) {
     return read_val<int8_t>();
 }
+        
+float NetworkPacket::read_float32 (void) {
+    /* XXX */
+}
+
+Vector NetworkPacket::read_vector (void) {
+    float fx = read_float32();
+    float fy = read_float32();
+
+    return Vector(fx, fy);
+}
 
 void NetworkPacket::write_uint32 (uint32_t val) {
     write_val<uint32_t>(htonl(val));
@@ -94,8 +105,17 @@
 void NetworkPacket::write_int8 (int8_t val) {
     write_val<int8_t>(val);
 }
+        
+void write_float32 (float val) {
+    /* XXX: */
+}
 
-void write_packet (const NetworkPacket &pkt) {
+void NetworkPacket::write_vector (const Vector &vec) {
+    write_float32(vec.x);
+    write_float32(vec.y);
+}
+
+void NetworkPacket::write_packet (const NetworkPacket &pkt) {
     // check buffer size
     check_write_size(pkt.get_data_size());
 
@@ -106,3 +126,4 @@
     offset += pkt.get_data_size();
     data_size += pkt.get_data_size();
 }
+

--- a/src/proto2/NetworkPacket.hh	Tue Nov 18 22:58:50 2008 +0000
+++ b/src/proto2/NetworkPacket.hh	Thu Nov 20 19:25:56 2008 +0000
@@ -2,6 +2,13 @@
 #define NETWORK_PACKET_HH
 
 #include "NetworkConfig.hh"
+#include "Vector.hh"
+#include "Error.hh"
+
+class NetworkPacketError : public Error {
+    public:
+        NetworkPacketError (const std::string &message) : Error(message) { }
+};
 
 class NetworkPacket {
     private:
@@ -25,13 +32,17 @@
         void set_data_size (size_t size) { offset = 0; data_size = size; }
        
         // type-reads, handle network-endianlness
-        uint32_t read_uint32 (void) const;
-        uint16_t read_uint16 (void) const;
-        uint8_t read_uint8 (void) const;
+        uint32_t read_uint32 (void);
+        uint16_t read_uint16 (void);
+        uint8_t read_uint8 (void);
 
-        int32_t read_int32 (void) const;
-        int16_t read_int16 (void) const;
-        int8_t read_int8 (void) const;
+        int32_t read_int32 (void);
+        int16_t read_int16 (void);
+        int8_t read_int8 (void);
+        
+        float read_float32 (void);
+
+        Vector read_vector (void);
 
         void write_uint32 (uint32_t val);
         void write_uint16 (uint16_t val);
@@ -40,7 +51,10 @@
         void write_int32 (int32_t val);
         void write_int16 (int16_t val);
         void write_int8 (int8_t val);
+        
+        void write_float32 (float val);
 
+        void write_vector (const Vector &vec);
         void write_packet (const NetworkPacket &pkt);
 };
 

--- a/src/proto2/NetworkServer.cc	Tue Nov 18 22:58:50 2008 +0000
+++ b/src/proto2/NetworkServer.cc	Thu Nov 20 19:25:56 2008 +0000
@@ -4,99 +4,94 @@
 
 #include <cassert>
 
-NetworkServer::NetworkServer (GameState &state, const std::string &listen_port) : 
-    NetworkCore(state), pid_pool(0) {
+NetworkServer::NetworkServer (GameState &state, const NetworkAddress &listen_addr) : 
+    NetworkCore(state), netsession(NETWORK_MAGIC_ID), netobjs(netsession, NETCHAN_CORE) {
     
     // connect slots
-    slots.connect(netsession.sig_computer_connected(), this, &NetworkServer::on_connect);
-    slots.connect(netsession.sig_computer_disconnected(), this, &NetworkServer::on_disconnect);
+    slots.connect(netsession.sig_node_connected(), this, &NetworkServer::on_node_connected);
     
     // and then we listen
-    netsession.start_listen(listen_port);
+    netsession.listen(listen_addr);
 
-    Engine::log(INFO, "server") << "running, listen_port=" << listen_port;
+    Engine::log(INFO, "server") << "running, listen_addr=" << listen_addr;
 }
 
-void NetworkServer::on_connect (CL_NetComputer &computer) {
-    // assign a pid
-    uint16_t pid = ++pid_pool;
-    
+void NetworkServer::on_node_connected (NetworkNode *node) {
     // create the player object (it logs it)
-    NetworkServerPlayer *player = new NetworkServerPlayer(*this, computer, pid);
+    NetworkServerPlayer *player = new NetworkServerPlayer(*this, node);
+
+    // add to players
+    players.push_back(player);
     
-    // map computer to it
-    players[computer] = player;
-
     // add to GameState
     state.newRemotePlayer(player);
 }
-
-void NetworkServer::on_disconnect (CL_NetComputer &computer) {
-    NetworkServerPlayer *player = players[computer];
-    
-    // remove from players
-    players.erase(computer);
-
+        
+void NetworkServer::handle_disconnect (NetworkServerPlayer *player) {
     // remove from state
     state.removePlayer(player);
 
-    // remove from game
-    player->disconnected();
-
-    // delete
-    delete player;
+    // remove from list
+    players.remove(player);
 }
         
-NetworkServerPlayer::NetworkServerPlayer (NetworkServer &server, CL_NetComputer &computer, uint16_t pid) : 
-    RemotePlayer(server.state, Vector(PLAYER_INITIAL_X, PLAYER_INITIAL_Y), true), server(server), computer(computer), obj(&server.netobjs), pid(pid) {
+NetworkServerPlayer::NetworkServerPlayer (NetworkServer &server, NetworkNode *node) : 
+    RemotePlayer(server.state, Vector(PLAYER_INITIAL_X, PLAYER_INITIAL_Y), true), server(server), obj(server.netobjs), node(node) {
     
     // log
-    Engine::log(INFO, "server_player.connected") << "computer=" << computer << ", obj=" << obj;
+    Engine::log(INFO, "server_player.connected") << "node=" << node << ", obj=" << obj;
 
     // messages
-    slots.connect(obj.sig_received_message(NETMSG_CLIENT_MOVE), this, &NetworkServerPlayer::on_move);   
+    slots.connect(node->sig_disconnected(), this, &NetworkServerPlayer::on_disconnected);
+    slots.connect(obj.sig_message(NETMSG_CLIENT_MOVE), this, &NetworkServerPlayer::on_move);
 
     // the initial NETMSG_PLAYER_HELLO
-    CL_NetPacket hello_pkt;
-    writeVector(hello_pkt, position);
+    NetworkPacket hello_pkt;
+    hello_pkt.write_vector(position);
 
-    obj.send(computer, NETMSG_SERVER_HELLO, hello_pkt, true);
+    obj.send_to(node, NETMSG_SERVER_HELLO, hello_pkt, true);
 
     // send other player objects
-    for (std::map<CL_NetComputer, NetworkServerPlayer*>::iterator it = server.players.begin(); it != server.players.end(); it++) {
-        NetworkServerPlayer *player = it->second;
-        CL_NetPacket player_pkt;
+    for (std::list<NetworkServerPlayer*>::iterator it = server.players.begin(); it != server.players.end(); it++) {
+        NetworkServerPlayer *player = *it;
+        NetworkPacket player_pkt;
         
         // player is not in players list yet
         assert(player != this);
+        
+        player_pkt.write_vector(player->position);
 
-        writeVector(player_pkt, player->position);
-
-        player->obj.send(computer, NETMSG_PLAYER_INFO, player_pkt, true);
+        player->obj.send_to(node, NETMSG_PLAYER_INFO, player_pkt, true);
     }
 
-
-    // broadcast NETMSG_PLAYER_JOIN to all clients
-    obj.send(server.netsession.get_all(), NETMSG_PLAYER_JOIN, hello_pkt, true);
+    // broadcast NETMSG_PLAYER_JOIN to all clients except current
+    obj.send_all_except(NETMSG_PLAYER_JOIN, hello_pkt, node, true);
 }
 
-void NetworkServerPlayer::disconnected (void) {
-    CL_NetPacket pkt;
+void NetworkServerPlayer::on_disconnected (void) {
+    NetworkPacket pkt;
     
-    Engine::log(INFO, "server_player.disconnected") << "computer=" << computer << ", obj=" << obj;
+    Engine::log(INFO, "server_player.disconnected") << "node=" << node << ", obj=" << obj;
+    
+    // remove from server
+    server.handle_disconnect(this);
+    
+    // tell other clients
+    obj.send_all(NETMSG_PLAYER_QUIT, pkt, true);
 
-    obj.send(server.netsession.get_all(), NETMSG_PLAYER_QUIT, pkt, true);
+    // free
+    delete this;
 }
 
-void NetworkServerPlayer::on_move (CL_NetComputer &from, CL_NetPacket &pkt) {
+void NetworkServerPlayer::on_move (NetworkNode *src, NetworkPacket &pkt) {
     // sanity-check
-    if (!(from == computer))
+    if (src != node)
         return;
     
-    Vector impulse_force = readVector(pkt);    
-    uint16_t impulse_ms = pkt.input.read_uint16();
+    Vector impulse_force = pkt.read_vector();
+    uint16_t impulse_ms = pkt.read_uint16();
 
-    Engine::log(INFO, "server_player.on_move") << "obj=" << obj << ", old_pos=" << position << ", impulse=" << impulse_force << "@" << impulse_ms << "ms";
+    Engine::log(INFO, "server_player.on_move") << "player=" << obj << ", old_pos=" << position << ", impulse=" << impulse_force << "@" << impulse_ms << "ms";
     
     // apply force
     applyForce(impulse_force, impulse_ms);
@@ -106,12 +101,12 @@
 }
         
 void NetworkServerPlayer::send_position_update (void) {
-    CL_NetPacket pkt;
-    writeVector(pkt, position);
-    writeVector(pkt, velocity);
+    NetworkPacket pkt;
+    pkt.write_vector(position);
+    pkt.write_vector(velocity);
 
     Engine::log(INFO, "server_player.send_position_update") << "obj=" << obj << " -> " << position << "+" << velocity;
 
-    obj.send(server.netsession.get_all(), NETMSG_PLAYER_POSITION, pkt, false);
+    obj.send_all(NETMSG_PLAYER_POSITION, pkt, false);
 }
 

--- a/src/proto2/NetworkServer.hh	Tue Nov 18 22:58:50 2008 +0000
+++ b/src/proto2/NetworkServer.hh	Thu Nov 20 19:25:56 2008 +0000
@@ -3,8 +3,8 @@
 
 #include "Network.hh"
 #include "GameState.hh"
-#include "NetworkTCP.hh"
-#include "NetworkUDP.hh"
+#include "NetworkSession.hh"
+#include "NetworkObject.hh"
 
 #include <list>
 #include <map>
@@ -16,39 +16,35 @@
 class NetworkServer : public NetworkCore {
     friend class NetworkServerPlayer;
 
-    private:
-        NetworkTCPServer tcp_server;
-        NetworkUDP udp;
-
-        uint16_t pid_pool;
-        
-        std::map<NetworkAddress, NetworkServerPlayer*> players;
+    protected:
+        NetworkSession netsession;
+        NetworkObject_ServerController netobjs;
+        std::list<NetworkServerPlayer *> players;
 
     public:
         NetworkServer (GameState &state, const NetworkAddress &listen_addr);
+    
+    protected:
+        void handle_disconnect (NetworkServerPlayer *player);
 
     private:
-        void on_client (NetworkTCPTransport *client);
-        void on_packet_udp (const NetworkPacket &pkt, const NetworkAddress &src);
+        void on_node_connected (NetworkNode *node);
 };
 
 class NetworkServerPlayer : public RemotePlayer {
     private:
         NetworkServer &server;
-        NetworkTCPTransport *tcp;
+        NetworkObject_Server obj;
+        NetworkNode *node;
 
         CL_SlotContainer slots;
-
-        uint16_t pid;
         
     public:
-        NetworkServerPlayer (NetworkServer &server, NetworkTCPTransport *tcp, uint16_t pid);
+        NetworkServerPlayer (NetworkServer &server, NetworkNode *node);
 
     private:
         void on_disconnected (void);
-        void on_packet_tcp (const NetworkPacket &pkt);
-
-        void on_move (const NetworkPacket &pkt);
+        void on_move (NetworkNode *node, NetworkPacket &pkt);
 
         void send_position_update (void);
 };

--- a/src/proto2/NetworkSession.cc	Tue Nov 18 22:58:50 2008 +0000
+++ b/src/proto2/NetworkSession.cc	Thu Nov 20 19:25:56 2008 +0000
@@ -18,6 +18,14 @@
     slots.connect(tcp->sig_client(), this, &NetworkSession::on_tcp_client);
 }
         
+NetworkNode *NetworkSession::build_node (NetworkTCPTransport *tcp_client, NetworkUDP *udp, const NetworkAddress &addr, , enum NetworkNodeType type) {
+    // XXX: unused
+    (void) type;
+
+    // create node
+    return new NetworkNode(*this, tcp_client, addr);
+}
+
 NetworkNode* NetworkSession::connect (const NetworkAddress &addr) {
     // create new UDP client if needed
     if (udp_client == NULL)
@@ -25,9 +33,9 @@
 
     // connect
     NetworkTCPClient *tcp_client = new NetworkTCPClient(addr);
-
-    // create node
-    NetworkNode *client_node = new NetworkNode(*this, tcp_client, udp_client, addr);
+    
+    // build client
+    NetworkNode *client_node = build_node(tcp_client, udp_client, addr, NETWORK_NODE_CLIENT_SERVER);
 
     // add to nodes
     nodes[addr] = client_node;
@@ -36,32 +44,23 @@
     slots.connect(tcp_client->sig_disconnect(), this, &NetworkSession::on_disconnect, client_node);
 }
         
-void NetworkSession::on_tcp_client (const NetworkTCPTransport *tcp_client) {
+void NetworkSession::on_tcp_client (NetworkTCPTransport *tcp_client) {
     // get remote address manually, because NetworkTCPServer doesn't pass it in to us
     NetworkAddress addr = tcp_client->getRemoteAddress();
 
-    // create node
-    NetworkNode *client_node = new NetworkNode(*this, tcp_client, udp_server, addr);
+    // build client
+    NetworkNode *client_node = build_node(tcp_client, udp_server, addr, NETWORK_NODE_SERVER_CLIENT);
 
     // add to nodes
     nodes[addr] = client_node;
 
-    // bind signals
-    slots.connect(tcp_client->sig_disconnect(), this, &NetworkSession::on_disconnect, client_node);
-
     // fire signals
     _sig_node_connected(node);
 }
         
-void NetworkSession::on_disconnect (NetworkNode *node) {
+void NetworkSession::handle_disconnect (NetworkNode *node) {
     // remove from nodes
     nodes.erase(node->getRemoteAddress());
-
-    // fire signal
-    _sig_node_disconnected(node);
-    
-    // delete
-    delete node;
 }
         
 void NetworkSession::send_all (NetworkChannelID channel_id, const NetworkPacket &pkt, bool reliable) {

--- a/src/proto2/NetworkSession.hh	Tue Nov 18 22:58:50 2008 +0000
+++ b/src/proto2/NetworkSession.hh	Thu Nov 20 19:25:56 2008 +0000
@@ -1,52 +1,52 @@
 #ifndef NETWORK_SESSION_HH
 #define NETWORK_SESSION_HH
 
-#include "NetworkTCP.hh"
-#include "NetworkUDP.hh"
-
-#include <map>
-
-/*
- * Should be set to some 8-char magic value to identify the application
- */
-typedef char[8] NetworkSessionMagic;
+// forward-declare
+class NetworkSession;
 
 /*
  * Used to separate packets, ID zero is reserved for NetworkSession use
  */
 typedef uint16_t NetworkChannelID;
 
+#include "NetworkTCP.hh"
+#include "NetworkUDP.hh"
+#include "NetworkNode.hh"
+
+#include <map>
+
 class NetworkSession {
     private:
-        NetworkSessionMagic magic;
+        uint64_t magic;
         NetworkTCPServer *tcp_srv;
         NetworkUDP *udp_srv, *udp_client;
 
         CL_SlotContainer slots;
 
         std::map<NetworkAddress, NetworkNode*> nodes;
-        std::map<NetworkChannelID, CL_Signal_v2<const NetworkPacket&, NetworkNode *>> _map_sig_chan_message;
+        std::map<NetworkChannelID, CL_Signal_v2<NetworkPacket&, NetworkNode *> > _map_sig_chan_message;
     
     public:
-        NetworkSession (NetworkSessionMagic magic);
+        NetworkSession (uint64_t magic);
 
         void listen (const NetworkAddress &addr);
         NetworkNode* connect (const NetworkAddress &addr);
+    
+    protected:
+        virtual NetworkNode *build_node (NetworkTCPTransport *tcp, NetworkUDP *udp, const NetworkAddress &addr, enum NetworkNodeType type);
 
     private:
-        void on_tcp_client (const NetworkTCPTransport *client);
-        void on_disconnect (NetworkNode *node);
+        void on_tcp_client (NetworkTCPTransport *client);
+        void handle_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 (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); }
+        CL_Signal_v1<NetworkNode*>& sig_node_connected (void) { return _sig_node_connected; }
+        CL_Signal_v2<NetworkPacket&, NetworkNode *>& sig_chan_message (NetworkChannelID cid) { return _map_sig_chan_message[cid]; }
 };
 
 #endif /* NETWORK_SESSION_HH */

--- a/src/proto2/NetworkTCP.hh	Tue Nov 18 22:58:50 2008 +0000
+++ b/src/proto2/NetworkTCP.hh	Thu Nov 20 19:25:56 2008 +0000
@@ -3,13 +3,16 @@
 
 #include "NetworkSocket.hh"
 #include "NetworkAddress.hh"
+#include "NetworkPacket.hh"
+#include "Error.hh"
 
 const size_t NETWORK_TCP_CHUNK_SIZE = 1024;
 const size_t NETWORK_TCP_INITIAL_IN_BUF = 4096;
 const size_t NETWORK_TCP_INITIAL_OUT_BUF = 0;
 
-class NetworkDisconnectError : public exception {
-
+class NetworkDisconnectError : public Error {
+    public:
+        NetworkDisconnectError (const std::string &message) : Error(message) { }
 };
 
 class NetworkBuffer {
@@ -21,11 +24,11 @@
     
     public:
         NetworkBuffer (NetworkSocket &socket, size_t size_hint);
- 
+    
     private:
-        NetworkBuffer (const NetworkBuffer &copy) { };
+        NetworkBuffer (const NetworkBuffer &copy);
         ~NetworkBuffer (void);
-        NetworkBuffer& operator= (const NetworkBuffer &copy) { };
+        NetworkBuffer& operator= (const NetworkBuffer &copy);
 
         void resize (size_t suffix_size);
         void trim (size_t prefix_size);
@@ -58,7 +61,7 @@
         void on_write (void);
         void on_disconnected (void);
 
-        CL_Signal_v1<const NetworkPacket&> _sig_packet;
+        CL_Signal_v1<const NetworkPacket &> _sig_packet;
         CL_Signal_v0 _sig_disconnect;
 
     public: