include <mynetwork.h>
  include <packets.h>
  include <osg/io_utils>
  include <dtUtil/stringutils.h>
  include <dtCore/transform.h>
  
  using namespace dtUtil;
  using namespace dtCore;
  
  MyNetwork::MyNetwork( dtCore::Scene* scene )
     : mScene(scene)
  {
  }
  
  
One or more GNE::Packets was received, let's do something with them
  void MyNetwork::OnReceive( GNE::Connection &conn )
  {
     mMutex.acquire();
  
     GNE::Packet* next = conn.stream().getNextPacket();
  
     while (next != 0)
     {
        int type = next->getType();
  
        if (type == GNE::PingPacket::ID)
        {
           //it's a PingPacket so lets process it.
           GNE::PingPacket& ping = *static_cast<GNE::PingPacket*>(next);
           if (ping.isRequest())
           {
              ping.makeReply();
              conn.stream().writePacket(ping, true);
           }
           else
           {
              LOG_INFO("Ping: " + ping.getPingInformation().pingTime.toString());
           }
        }
        else if (type == PositionPacket::ID)
        {
           //aha, this is one of our custom packets.  Decompose it and move our remote
           //player representation.
           PositionPacket* pos = static_cast<PositionPacket*>(next);
           osg::Vec3 newXYZ = pos->mXYZ;
           osg::Vec3 newHPR = pos->mHPR;
           std::string ownerID = pos->mOwnerID;
  
           Transform xform;
           xform.SetTranslation(newXYZ);
           xform.SetRotation(newHPR);
  
           StringObjectMap::iterator iter = mOtherPlayerMap.find(ownerID);
  
           if (iter != mOtherPlayerMap.end())
           {
              //the player ID is already in our list so lets update it's position
              iter->second->SetTransform(xform, Transformable::ABS_CS);
           }
           else
           {
              //this player isn't in our list, so let's create him
              MakePlayer(ownerID);
           }
  
           if (GetIsServer())
           {
              //rebroadcast the packet to all connections except for the
              //one who sent the packet in the first place
              ConnectionIterator conns = mConnections.begin();
              while (conns != mConnections.end())
              {
                 if (conns->first != conn.getRemoteAddress(true).toString())
                 {
                    SendPacket(conns->first, *next);
                 }
                 ++conns;
              }
           }
        }
        else if (type == PlayerQuitPacket::ID)
        {
           PlayerQuitPacket* playerQuitPacket = static_cast<PlayerQuitPacket*>(next);
           mIDsToRemove.push(playerQuitPacket->mPlayerID);
        }
  
        delete next;
        next = conn.stream().getNextPacket();
     }
  
     mMutex.release();
  }
  
  
Create a new player to represent the remote guy
  void MyNetwork::MakePlayer(const std::string& ownerID)
  {
     mMutex.acquire();
  
     LOG_INFO("Making a new remote player named: " + ownerID)
  
     dtCore::RefPtr<dtCore::Object> object = new dtCore::Object(ownerID);
     object->LoadFile("models/uh-1n.ive");
  
     Transform transform(0.0f, 0.0f, 5.0f);
     object->SetTransform(transform);
  
     // Insert the new Objects into our map of IDs->Objects
     StringObjectMap::value_type value(ownerID,  object);
     mOtherPlayerMap.insert(value);
  
     mObjectsToAdd.push(object);
  
     mMutex.release();
  }
  
  void MyNetwork::OnExit(GNE::Connection& conn)
  {
     // do the default NetMgr behavior too
     NetMgr::OnExit(conn);
  }
  
  void MyNetwork::OnDisconnect(GNE::Connection& conn)
  {
     RemoveConnection(&conn);
  }
  
  void MyNetwork::PreFrame(const double deltaFrameTime)
  {
     // Process the Objects we wish to add to the scene
     while (!mObjectsToAdd.empty())
     {
        mScene->AddDrawable(mObjectsToAdd.front().get());
  
        // Convert the address to a string for logging.
        std::ostringstream oss;
        oss << mObjectsToAdd.front();
        LOG_INFO("Added player " + oss.str() + " to the scene.")
  
        mObjectsToAdd.pop();
     }
  
     // Process the Objects we wish to remove from the scene
     while (!mIDsToRemove.empty())
     {
        StringObjectMap::iterator iter = mOtherPlayerMap.find(mIDsToRemove.front());
  
        if (iter != mOtherPlayerMap.end())
        {
           mScene->RemoveDrawable((iter->second).get());
           LOG_INFO("Removed player " + iter->first + " from the scene.")
  
           mOtherPlayerMap.erase(iter);
        }
        else
        {
           LOG_WARNING("Attempt to remove player " + iter->first + " failed.")
        }
  
        mIDsToRemove.pop();
     }
  }