MercuryNetServer.cpp

Go to the documentation of this file.

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

MercuryNetServerConnection::~MercuryNetServerConnection()
{
    delete m_pConnection;
    m_thdMain.Halt();
    m_thdMain.Close();
}

MercuryNetServerConnection::MercuryNetServerConnection( ezSockets * pAccepted )
{
    m_pNetClass = NULL;
    m_bIsActive = false;
    m_pConnection = pAccepted;

    //Do any IP-based black listing here.
    if( pAccepted->GetAddress() == "88.55.123.44" )
        return;

    m_bIsActive = true;
    m_thdMain.Create( CoreThreadCaller, this );
}

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

void MercuryNetServerConnection::BroadcastToClient( const MString & sMessage, const PStack & pParameters )
{
    ezSocketsPacket pack;
    pack.ClearPacket();
    pack.Write4( 2 );
    pack.WriteNT( sMessage );
    NetEncodePStack( pack, pParameters );
    m_pConnection->SendPack( pack );
}

void * MercuryNetServerConnection::CoreThreadCaller( void * NetClient)
{
    ((MercuryNetServerConnection *)NetClient)->CoreThread();
    return 0;
}

void MercuryNetServerConnection::CoreThread( void)
{
    ezSocketsPacket tmp;
    m_pConnection->bBlocking = true;
    m_pConnection->mode = ezSockets::skPackets;
    while( !m_pConnection->IsError() )
    {
        if( !m_pConnection->ReadPack( tmp ) )
            break;
        unsigned char cCode = tmp.Read4();
        switch( cCode )
        {
        case 0:
            break;
        case 1:
            break;
        case 2: //Message
            break;
        case 3: //Command
            {
            MString sName = tmp.ReadNT();
            PStack t;
            NetDecodePStack( tmp, t );
            if( m_pNetClass )
            {
                PStack ret;
                m_pNetClass->Command( ret, sName.c_str(), t );
            }
            }
            break;
        case 4:
            {
            double dCurTime = m_pParent->m_tmrSync.Age();
            double dClientTime;
            long delTimeID;
            delTimeID = tmp.Read4();

            tmp.ReadData( 8, (char*)&dClientTime );

            //Reply packet back to client + our current time.
            ezSocketsPacket p;
            p.ClearPacket();
            p.Write4( 4 );
            p.Write4( delTimeID );  //Must be post-increment
            p.WriteData( (char*)&dClientTime, 8 );
            p.WriteData( (char*)&dCurTime, 8 );

            m_pConnection->SendPack( p );
            break;
            }
        }
    }
    m_pConnection->Close();
    m_bIsActive = false;
}


//SERVER SOCKET

MercuryNetServer::MercuryNetServer()
{
    m_pListener = new ezSockets;
    m_fTimeSinceLastODE = 0;
}

MercuryNetServer::~MercuryNetServer()
{
    m_thdMain.Halt( true );
    m_thdMain.Close();
    m_thdUDPMain.Halt( true );
    m_thdUDPMain.Close();
    for( MDequeIterator< MercuryNetServerConnection * > i = m_vClients.begin(); i != m_vClients.end(); ++i )
    {
        i.Data()->m_thdMain.Close();
        SAFE_DELETE( i.Data()->m_pConnection );
        SAFE_DELETE( i.Data() );
    }
    SAFE_DELETE( m_pListener );
    SAFE_DELETE( m_pUDPListener );
}

void MercuryNetServer::BroadcastToAllClients( const MString & sMessage, const PStack & pParameters )
{
    for( MDequeIterator< MercuryNetServerConnection * > i = m_vClients.begin(); i != m_vClients.end(); ++i )
        i.Data()->BroadcastToClient( sMessage, pParameters );
}

bool MercuryNetServer::BindAndListen( int iPort, GenClientFunction cbFunction )
{
    m_tmrSync.Touch();
    m_cbGenFunction = cbFunction;
    if( !m_pListener->Create() )
        return false;
    m_pListener->bBlocking = true;
    if( !m_pListener->Bind( iPort ) )
        return false;
    if( !m_pListener->Listen() )
        return false;

    m_pUDPListener = new ezSockets;
    m_pUDPListener->mode = ezSockets::skUDP;
    m_pUDPListener->bBlocking = true;
    m_pUDPListener->Create( IPPROTO_UDP, SOCK_DGRAM );
    if( !m_pUDPListener->Bind( iPort ) )
        return false;

    m_thdUDPMain.Close();
    m_thdUDPMain.Create( CoreUDPThreadCaller, this );

    m_thdMain.Close();
    m_thdMain.Create( CoreThreadCaller, this );
    return true;
}

void MercuryNetServer::Update( const float dTime )
{
    m_fTimeSinceLastODE += dTime;

    if( m_fTimeSinceLastODE > .5f )
    {
        UpdateODE();
        m_fTimeSinceLastODE=0;
    }
}

void MercuryNetServer::UpdateODE( const MString & sNameOfObject )
{
    if( m_pWorld == NULL )
        return;

    unsigned i;
    double dCurTime = m_tmrSync.Age();
    ezSocketsPacket p;
    p.ClearPacket();
    
    //ODE Update command packet.
    p.Write4( 5 );

    //Server time
    p.WriteData( (char*)&dCurTime, 8 );


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

    if( sNameOfObject != "" )
    {
        p.Write4( 1 );
        MercuryODEObject * g = pAllObjects[sNameOfObject];
        ODEUnitInfo inf;
        if( g->m_oBody )
        {
            p.WriteNT( sNameOfObject );
            inf.pos = dBodyGetPosition( g->m_oBody );
            const float * f = dBodyGetQuaternion( g->m_oBody );
            inf.rot.w = f[0]; inf.rot.x = f[1]; inf.rot.y = f[2]; inf.rot.z = f[3];
            inf.linvel = dBodyGetLinearVel( g->m_oBody );
            inf.angvel = dBodyGetAngularVel( g->m_oBody );
            p.WriteData( (const char*) &inf, sizeof( ODEUnitInfo ) );
        }
    }
    else
    {
        MVector< MString > pAllIndicies;
        pAllObjects.VectorIndicies( pAllIndicies );

        //# of ODE Objects in this update
        p.Write4( pAllIndicies.size() );

        for( i = 0; i < pAllIndicies.size(); i++ )
        {
            MercuryODEObject * g = pAllObjects[pAllIndicies[i]];
            ODEUnitInfo inf;
            if( g->m_oBody )
            {
                p.WriteNT( pAllIndicies[i] );

                inf.pos = dBodyGetPosition( g->m_oBody );
                const float * f = dBodyGetQuaternion( g->m_oBody );
                inf.rot.w = f[0]; inf.rot.x = f[1]; inf.rot.y = f[2]; inf.rot.z = f[3];
                inf.linvel = dBodyGetLinearVel( g->m_oBody );
                inf.angvel = dBodyGetAngularVel( g->m_oBody );
                p.WriteData( (const char*) &inf, sizeof( ODEUnitInfo ) );
            }
        }
    }

    for( MDequeIterator< MercuryNetServerConnection * > j = m_vClients.begin(); j != m_vClients.end(); ++j )
        (*j)->m_pConnection->SendPack( p );
}

void * MercuryNetServer::CoreThreadCaller( void * NetClient)
{
    ((MercuryNetServer *)NetClient)->CoreThread();
    return 0;
}

void MercuryNetServer::CoreThread()
{
    while( !m_pListener->IsError() )
    {
        ezSockets * s = m_pListener->Accept();
        if( s )
        {
            m_vClients.push_back( m_cbGenFunction( s ) );
            m_vClients.back()->AttachParent( this );
        }
    }
}

void * MercuryNetServer::CoreUDPThreadCaller( void * NetClient )
{
    ((MercuryNetServer *)NetClient)->CoreUDPThread();
    return NULL;
}

void MercuryNetServer::CoreUDPThread()
{
    ezSocketsPacket g;
    while( !m_pUDPListener->IsError() )
    {
        g.ClearPacket();
        m_pUDPListener->ReadPack( g );

        Sleep( 1000.0f );
        ezSocketsPacket j;
        j.ClearPacket();
        j.Write4( 5 );
        j.Port = g.Port;
        j.PositionTAG = g.PositionTAG;
        j.Write4( 5 );
        m_pUDPListener->SendPack( j );
    }
}

MercuryNetServerConnection * DefaultSocketConnection(ezSockets * pAccepted)
{
    return new MercuryNetServerConnection( pAccepted );
}


//Utility functions
void NetEncodePStack( ezSocketsPacket & pPacket, const PStack & pParameters )
{
    pPacket.Write1( pParameters.GetSize() );
    for( unsigned i = 0; i < pParameters.GetSize(); i++ )
    {
        pPacket.Write1( pParameters.PeekItem( i ).GetType() );
        switch( pParameters.PeekItem( i ).GetType() )
        {
        case PSElement::BOOL:
            pPacket.Write1( pParameters.PeekItem( i ).GetValueB() );
            break;
        case PSElement::INTEGER:
            pPacket.Write4( pParameters.PeekItem( i ).GetValueI() );
            break;
        case PSElement::FLOAT:
            {
            float f = pParameters.PeekItem( i ).GetValueF();
            pPacket.Write4( *((unsigned long*)((float*)&f)) );
            break;
            }
        case PSElement::STRING:
            pPacket.WriteNT( pParameters.PeekItem( i ).GetValueS() );
            break;
        default:
            break;
        }
    }
}

void NetDecodePStack( ezSocketsPacket & pPacket, PStack & pParameters )
{
    unsigned long iParameters = pPacket.Read1();
    for( unsigned i = 0; i < iParameters; i++ )
    {
        switch( pPacket.Read1() )
        {
        case PSElement::BOOL:
            pParameters.PushItemBack( PSElement( (bool)(pPacket.Read1() != 0) ) );
            break;
        case PSElement::INTEGER:
            pParameters.PushItemBack( PSElement( (int)pPacket.Read4() ) );
            break;
        case PSElement::FLOAT:
            {
            unsigned long l = pPacket.Read4();
            pParameters.PushItemBack( PSElement( *((float*)((unsigned long*)&l))));
            break;
            }
        case PSElement::STRING:
            pParameters.PushItemBack( PSElement( pPacket.ReadNT() ) );
            break;
        default:
            break;
        }
    }
}

---

Hosted by