visualsenderplayer.cpp

来自「2009 ROBOCUP 仿真2DSERVER 源码」· C++ 代码 · 共 1,081 行 · 第 1/3 页

// -*-c++-*-

/***************************************************************************
                            visualsenderplayer.cpp
                 Classes for building visual messages for players
                             -------------------
    begin                : 2008-02-17
    copyright            : (C) 2002 by The RoboCup Soccer Server
                           Maintenance Group.
    email                : [e-mail]
***************************************************************************/

/***************************************************************************
 *                                                                         *
 *   This program is free software; you can redistribute it and/or modify  *
 *   it under the terms of the GNU LGPL as published by the Free Software  *
 *   Foundation; either version 2 of the License, or (at your option) any  *
 *   later version.                                                        *
 *                                                                         *
 ***************************************************************************/

#ifdef HAVE_CONFIG_H
#include "config.h"
#endif

#include "visualsenderplayer.h"

#include "field.h"
#include "serializer.h"

namespace rcss {

/*!
//===================================================================
//
//  CLASS: VisualSenderPlayer
//
//  DESC: Base class for the visual protocol for players.
//
//===================================================================
*/

VisualSenderPlayer::FactoryHolder &
VisualSenderPlayer::factory()
{
    static FactoryHolder rval;
    return rval;
}

VisualSenderPlayer::VisualSenderPlayer( const Params & params )
    : VisualSender( params.M_transport ),
      M_serializer( params.M_serializer ),
      M_self( params.M_self ),
      M_stadium( params.M_stadium ),
      M_sendcnt( 0 )
{
    //std::cerr << "create VisualSenderPlayer" << std::endl;
}

VisualSenderPlayer::~VisualSenderPlayer()
{
    //std::cerr << "delete VisualSenderPlayer" << std::endl;
}

/*!
//===================================================================
//
//  CLASS: VisualSensorPlayerV1
//
//  DESC: Class for the version 1* visual protocol.  This version is
//        completely unused as far as I am aware of, but it is here
//        none the less, just in case there is someone somewhere
//        still using it.
//
//        * It's version 1 to the simualtor in it's current form.
//        From what I know the original simulator was written in
//        lisp and the first C++ version was actually version 3.  I
//        don't know if the protocol was compatible with previous
//        versions, so this may well be the version 3 protocol.
//
//===================================================================
*/

VisualSenderPlayerV1::VisualSenderPlayerV1( const Params & params )
    : VisualSenderPlayer( params )
{

}

VisualSenderPlayerV1::~VisualSenderPlayerV1()
{

}

void
VisualSenderPlayerV1::sendVisual()
{
    incSendCount();

    if ( sendCount() >= self().visSend() )
    {
        resetSendCount();
    }
    else
    {
        return;
    }

    serializer().serializeVisualBegin( transport(), stadium().time() );
    if ( self().highquality() )
    {
        M_send_flag = &VisualSenderPlayerV1::sendHighFlag;
        M_send_ball = &VisualSenderPlayerV1::sendHighBall;
        M_send_player = &VisualSenderPlayerV1::sendHighPlayer;
        M_serialize_line = &VisualSenderPlayerV1::serializeHighLine;
    }
    else
    {
        M_send_flag = &VisualSenderPlayerV1::sendLowFlag;
        M_send_ball = &VisualSenderPlayerV1::sendLowBall;
        M_send_player = &VisualSenderPlayerV1::sendLowPlayer;
        M_serialize_line = &VisualSenderPlayerV1::serializeLowLine;
    }
    sendFlags();
    sendBalls();
    sendPlayers();
    sendLines();
    serializer().serializeVisualEnd( transport() );
    transport() << std::ends << std::flush;
}

void
VisualSenderPlayerV1::sendFlags()
{
    const std::vector< PObject * >::const_iterator end = stadium().field().landmarks().end();
    for ( std::vector< PObject * >::const_iterator it = stadium().field().landmarks().begin();
          it != end;
          ++it )
    {
        if ( (*it)->objectVersion() <= self().version() )
        {
            sendFlag( **it );
        }
    }
}

void
VisualSenderPlayerV1::sendBalls()
{
    if ( stadium().ball().objectVersion() <= self().version() )
    {
        sendBall( stadium().ball() );
    }
}

void
VisualSenderPlayerV1::sendPlayers()
{
    const Stadium::PlayerCont::const_iterator end = stadium().players().end();
    for ( Stadium::PlayerCont::const_iterator p = stadium().players().begin();
          p != end;
          ++p )
    {
        if ( *p != &self()
             && (*p)->state() != DISABLE
             && (*p)->objectVersion() <= self().version() )
        {
            sendPlayer( *(*p) );
        }
    }
}


void
VisualSenderPlayerV1::sendLines()
{
    int line_count = 0;
    int max_line_count;
    int min_line_count;
    if ( std::fabs( self().pos().x ) < ServerParam::PITCH_LENGTH*0.5
         && std::fabs( self().pos().y ) < ServerParam::PITCH_WIDTH*0.5 )
    {
        min_line_count = max_line_count = 1;
    }
    else
    {
        max_line_count = 2;
        min_line_count = 0;
    }

    if ( line_count < max_line_count
         && stadium().field().line_l.objectVersion() <= self().version() )
    {
        if ( sendLine( stadium().field().line_l ) )
            ++line_count;
    }
    if ( line_count < max_line_count
         && stadium().field().line_r.objectVersion() <= self().version() )
    {
        if( sendLine( stadium().field().line_r ) )
            ++line_count;
    }
    if ( line_count < max_line_count
         && stadium().field().line_t.objectVersion() <= self().version() )
    {
        if ( sendLine( stadium().field().line_t ) )
            ++line_count;
    }
    if ( line_count < max_line_count
         && stadium().field().line_b.objectVersion() <= self().version() )
    {
        if ( sendLine( stadium().field().line_b ) )
            ++line_count;
    }
    if ( line_count < min_line_count )
    {
        std::cerr << __FILE__ << ": " << __LINE__
                  << ": Error rendering visual: not enough lines\n"
                  << "Player = " << self() << std::endl;
    }
}

void
VisualSenderPlayerV1::sendLowFlag( const PObject & flag )
{
    const double ang = calcRadDir( flag );

    if ( std::fabs( ang ) < self().visibleAngle() * 0.5 )
    {
        serializer().serializeVisualObject( transport(),
                                            calcName( flag ),
                                            calcDegDir( ang ) );
    }
    else if ( calcUnQuantDist( flag ) <= self().vis_distance )
    {
        serializer().serializeVisualObject( transport(),
                                            calcCloseName( flag ),
                                            calcDegDir( ang ) );
    }
}

void
VisualSenderPlayerV1::sendHighFlag( const PObject & flag )
{
    const double ang = calcRadDir( flag );
    //const double un_quant_dist = calcUnQuantDist( flag );
    double un_quant_dist = self().pos().distance2( flag.pos() );

    if ( std::fabs( ang ) < self().visibleAngle() * 0.5 )
    {
        un_quant_dist = std::sqrt( un_quant_dist );
        const double quant_dist
            = calcQuantDist( un_quant_dist, self().landDistQStep() );

        //const double prob = ( ( quant_dist - UNUM_FAR_LENGTH )
        //                      / ( UNUM_TOOFAR_LENGTH - UNUM_FAR_LENGTH ) );
        const double prob = ( ( quant_dist - self().unumFarLength() )
                              / ( self().unumTooFarLength() - self().unumFarLength() ) );

        if ( decide( prob ) )
        {
            serializer().serializeVisualObject( transport(),
                                                calcName( flag ),
                                                quant_dist,
                                                calcDegDir( ang ) );
        }
        else
        {
            double dist_chg, dir_chg;
            calcVel( PVector(), flag.pos(),
                     un_quant_dist, quant_dist,
                     dist_chg, dir_chg );
            serializer().serializeVisualObject( transport(),
                                                calcName( flag ),
                                                quant_dist,
                                                calcDegDir( ang ),
                                                dist_chg,
                                                dir_chg );
        }
    }
    else if ( un_quant_dist <= self().vis_distance2 )
    {
        //un_quant_dist = std::sqrt( un_quant_dist );
        serializer().serializeVisualObject( transport(),
                                            calcCloseName( flag ),
                                            calcQuantDist( std::sqrt( un_quant_dist ),
                                                           self().landDistQStep() ),
                                            calcDegDir( ang ) );
    }
}

void
VisualSenderPlayerV1::sendLowBall( const MPObject & ball )
{
    const double ang = calcRadDir( ball );

    if( std::fabs( ang ) < self().visibleAngle() * 0.5 )
    {
        serializer().serializeVisualObject( transport(),
                                            calcName( ball ),
                                            calcDegDir( ang ) );
    }
    else if( calcUnQuantDist( ball ) <= self().vis_distance )
    {
        serializer().serializeVisualObject( transport(),
                                            calcCloseName( ball ),
                                            calcDegDir( ang ) );
    }
}


void
VisualSenderPlayerV1::sendHighBall( const MPObject & ball )
{
    const double ang = calcRadDir( ball );
    //const double un_quant_dist = calcUnQuantDist( ball );
    double un_quant_dist = self().pos().distance2( ball.pos() );

    if ( std::fabs( ang ) < self().visibleAngle() * 0.5 )
    {
        un_quant_dist = std::sqrt( un_quant_dist );
        const double quant_dist = calcQuantDist( un_quant_dist,
                                                 self().distQStep() );

        //double prob = ( ( quant_dist - UNUM_FAR_LENGTH )
        //                / ( UNUM_TOOFAR_LENGTH - UNUM_FAR_LENGTH ) );
        double prob = ( ( quant_dist - self().unumFarLength() )
                        / ( self().unumTooFarLength() - self().unumFarLength() ) );

        if ( decide( prob ) )
        {
            serializer().serializeVisualObject( transport(),
                                                calcName( ball ),
                                                quant_dist,
                                                calcDegDir( ang ) );
        }
        else
        {
            double dist_chg, dir_chg;
            calcVel( ball.vel(), ball.pos(),
                     un_quant_dist, quant_dist,
                     dist_chg, dir_chg );
            serializer().serializeVisualObject( transport(),
                                                calcName( ball ),
                                                quant_dist,
                                                calcDegDir( ang ),
                                                dist_chg,
                                                dir_chg );
        }
    }
    else if ( un_quant_dist <= self().vis_distance2 )
    {
        serializer().serializeVisualObject( transport(),
                                            calcCloseName( ball ),
                                            calcQuantDist( std::sqrt( un_quant_dist ),
                                                           self().distQStep() ),
                                            calcDegDir( ang ) );
    }
}

void