--- 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);
 }