MercuryNetClient.cpp

Go to the documentation of this file.

#include "MercuryNetClient.h"
#include "MercuryLog.h"
#include "MercuryObject.h"
#include "MercuryODE.h"

#define MSG_SYNCNETTIME 1

MercuryNetClient::MercuryNetClient()
{
    m_pSocket = new ezSockets;
    m_pNetClass = NULL;
}

MercuryNetClient::~MercuryNetClient()
{
    m_thdMain.Halt();
    m_thdMain.Close();
    delete m_pSocket;
}

bool MercuryNetClient::Connect( const MString & sHost, int iPort )
{
    bool bSucess;
    m_pSocket->Create();
    bSucess = m_pSocket->Connect( sHost, iPort );

    if( bSucess )
    {
        m_thdMain.Create( CoreThreadCaller, this );
        RegisterMessage( MSG_SYNCNETTIME, "syncnettime" );
        m_delTimeID = 0;
        PStack s;
        MESSAGEMAN->BroadcastMessage( "syncnettime", s );
        return true;
    } 
    else
        return false;
}

void MercuryNetClient::Update( const float fDTime )
{
}

void MercuryNetClient::SendCommand( const MString & sCommandName, const PStack & kParameters )
{
    ezSocketsPacket p;
    p.ClearPacket();
    p.Write4( 3 );
    p.WriteNT( sCommandName );
    NetEncodePStack( p, kParameters );
    m_pSocket->SendPack( p );
}

void * MercuryNetClient::CoreThreadCaller( void * NetClient)
{
    ((MercuryNetClient*)(NetClient))->CoreThread();
    return NULL;
}

void MercuryNetClient::CoreThread( )
{
    ezSocketsPacket pack;

    m_pSocket->mode = ezSockets::skPackets;
    m_pSocket->bBlocking = true;
    m_tmrSync.Touch();

    while( !m_pSocket->IsError() )
    {
        if( !m_pSocket->ReadPack( pack ) )
            break;

        unsigned char cCode = pack.Read4();
        switch( cCode )
        {
        case 0:
            break;
        case 1:
            break;
        case 2: //Message
        case 3: //Command
            {
            MString sName = pack.ReadNT();
            unsigned long iParameters = pack.Read1();
            PStack t;
            NetDecodePStack( pack, t );
            if( cCode == 2 )
                MESSAGEMAN->PostSystemMessage( sName, t );
            else if( cCode == 3 )
                if( m_pNetClass )
                {
                    PStack ret;
                    m_pNetClass->Command( ret, sName.c_str(), t );
                }
            }
            break;
        case 4: //Time sync
            {
            double dCurTime = m_tmrSync.Age();
            double dOrigTime;
            double dSrvTime;
            long delTimeID = pack.Read4();

            pack.ReadData( 8, (char*)&dOrigTime );
            pack.ReadData( 8, (char*)&dSrvTime );

            //Round-trip-packet-time
            double dPingTime = ( dCurTime - dOrigTime );

            //Ok, this looks a little weird, but here's the reasoning:
            //  We know the time it was on the client
            //  We know what time it was on the server when the server received it
            //  We know that ping times are rougly symmetric
            //  Therefore, the time now on the server is the ping time/2 + the server time.

            double thisDelTime = ( ( dSrvTime + (dPingTime/2) ) - dCurTime);

            //If we're one of the first two sync's just set the time, otherwise
            //factor it in statistically with diminishing importance.
            if( delTimeID < 2 )
                m_delTime = thisDelTime;
            else
                m_delTime = m_delTime * .9f + thisDelTime * .1f;

            LOG.Info( ssprintf( "Time Synchronization: %f %f", dPingTime, m_delTime ) );
            }
            break;
        case 5:
            {
            if( !m_pWorld )
                break;
            ODEUnitInfo t;
            double dServerTime;
            unsigned iNumToReceive;

            pack.ReadData( 8, (char*)&dServerTime );
            iNumToReceive = pack.Read4();

            double dDeltaTime = m_tmrSync.Age() - dServerTime + m_delTime;

            MHash<MercuryODEObject *> & AllObjects = m_pWorld->GetAllObjectMap();

            for( unsigned i = 0; i < iNumToReceive; i++ )
            {
                MString sPackName = pack.ReadNT();
                pack.ReadData( sizeof(ODEUnitInfo), (char*)&t );
                if( !AllObjects.get( sPackName ) )
                    continue;
                dBodyID b = (*AllObjects.get( sPackName ))->m_oBody;
                if( !b )
                    continue;

                t.pos = t.pos + t.linvel * dDeltaTime;

                dBodySetPosition( b, t.pos.x, t.pos.y, t.pos.z );

                dBodyEnable( b );
                dQuaternion q;
                q[0] = t.rot.w; q[1] = t.rot.x; q[2] = t.rot.y; q[3] = t.rot.z;
                dBodySetQuaternion( b, q );
                dBodySetLinearVel( b, t.linvel.x, t.linvel.y, t.linvel.z );
                dBodySetAngularVel( b, t.angvel.x, t.angvel.y, t.angvel.z );
            }
            }
            break;
        }
    }
    m_pSocket->Close();

}

void MercuryNetClient::Message( int Message, PStack & data, const MString & name )
{
    switch( Message )
    {
    case MSG_SYNCNETTIME:
        double dCurrentTime = m_tmrSync.Age();
        ezSocketsPacket p;
        p.ClearPacket();
        p.Write4( 4 );
        p.Write4( m_delTimeID++ );  //Must be post-increment

        p.WriteData( (char*)&dCurrentTime, 8 );
        m_pSocket->SendPack( p );

        PStack s;
        MESSAGEMAN->PostSystemMessage( "syncnettime", s, 1 );
        break;
    }
}

---

Hosted by