fullstatesender.cc

在LINUX下运行的仿真机器人服务器源代码

// -*-c++-*-

/***************************************************************************
                                fullstatesender.cc 
                  Classes for sending full state messages
                             -------------------
    begin                : 22-AUG-2002
    copyright            : (C) 2002 by The RoboCup Soccer Simulator 
                           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.                                                        *
 *                                                                         *
 ***************************************************************************/

#include "fullstatesender.h"
#include "player.h"
#include "serializer.h"
#include "field.h"

static char *PlayModeString[] = PLAYMODE_STRINGS;


namespace rcss
{

/*!
//===================================================================
//
//  CLASS: FullStateSender
//
//  DESC: Base class for the full state protocol.
//
//===================================================================
*/

    FullStateSender::FullStateSender( std::ostream& transport )
        : M_transport( transport )
    {}

    FullStateSender::~FullStateSender()
    {}

/*!
//===================================================================
//
//  CLASS: FullStateObserver
//
//  DESC: Interface for an object that receives full state information.
//
//===================================================================
*/

    FullStateObserver::FullStateObserver()
        : M_sender( NULL ),
          M_owns_sender( false )
    {}

    FullStateObserver::FullStateObserver( FullStateSender& sender )
        : M_sender( &sender ),
          M_owns_sender( false )
    {}

    FullStateObserver::FullStateObserver( std::auto_ptr< FullStateSender > sender )
        : M_sender( sender.release() ),
          M_owns_sender( true )
    {}

    FullStateObserver::~FullStateObserver()
    { clear(); }

    void
    FullStateObserver::setFullStateSender( FullStateSender& sender )
    {
        clear();
        M_sender = &sender;
        M_owns_sender = false;
    }

    void
    FullStateObserver::setFullStateSender( std::auto_ptr< FullStateSender > sender )
    {
        clear();
        M_sender = sender.release();
        M_owns_sender = true;
    }

    void
    FullStateObserver::sendFullState()
    { M_sender->sendFullState(); }
 
    void
    FullStateObserver::clear()
    {
        if( M_owns_sender )
        {
            delete M_sender;
            M_sender = NULL;
        }
    } 

/*!
//===================================================================
//
//  CLASS: FullStateSenderPlayer
//
//  DESC: Base class for the full state protocol for players.
//
//===================================================================
*/

    FullStateSenderPlayer::Factory&
    FullStateSenderPlayer::factory()
    { static Factory rval; return rval; }

    FullStateSenderPlayer::FullStateSenderPlayer( const Params& params )
        : FullStateSender( params.m_transport ),
          M_serializer( params.m_serializer ),
          M_self( params.m_self ),
          M_stadium( params.m_stadium )
    {}

    FullStateSenderPlayer::~FullStateSenderPlayer()
    {}


/*!
//===================================================================
//
//  CLASS: FullStateSenderPlayerV1
//
//  DESC: version 1 of the full state protocol. No actual information
//        is sent in this version as the protocol did not exist until
//        version 5
//
//===================================================================
*/


    FullStateSenderPlayerV1::FullStateSenderPlayerV1( const Params& params )
        : FullStateSenderPlayer( params )
    {}

    FullStateSenderPlayerV1::~FullStateSenderPlayerV1()
    {}

    void
    FullStateSenderPlayerV1::sendFullState()
    {}

/*!
//===================================================================
//
//  CLASS: FullStateSenderPlayerV5
//
//  DESC: version 5 of the full state protocol. This is the first
//        version in which full state information may be sent to
//        players.
//
//===================================================================
*/

    FullStateSenderPlayerV5::FullStateSenderPlayerV5( const Params& params )
        : FullStateSenderPlayerV1( params )
    {}

    FullStateSenderPlayerV5::~FullStateSenderPlayerV5()
    {}

    void
    FullStateSenderPlayerV5::sendFullState()
    {
        // send begining of FS
        serializer().serializeFSBegin( transport(), stadium().time );

        if( stadium().mode == PM_FreeKick_Left 
            && stadium().M_caught_ball )
            serializer().serializeFSPlayMode( transport(),
                                              "goalie_catch_ball_l" );
        else if( stadium().mode == PM_FreeKick_Right 
                 && stadium().M_caught_ball )
            serializer().serializeFSPlayMode( transport(),
                                              "goalie_catch_ball_r" );
        else
            serializer().serializeFSPlayMode( transport(),
                                              PlayModeString[stadium().mode] );
        
        serializer().serializeFSViewMode( transport(),
                                          ( self().highquality 
                                            ? "high" 
                                            : "low" ),
                                          ( self().vis_angle 
                                            == self().defangle/2 
                                            ? "narrow"
                                            : ( self().vis_angle 
                                                == self().defangle*2
                                                ? "wide"
                                                : "normal" ) ) );

        sendSelf();
        
        sendScore();

        sendBall();

        for( int k = 0;  k < MAX_PLAYER * 2; k++ )
        {
            Player& p = *( stadium().player[k] );
            
            if( p.alive == DISABLE )
                continue;

            sendPlayer( p );
        }

        // send end of FS
        serializer().serializeFSEnd( transport() );

        transport() << std::ends << std::flush;
    }

    void
    FullStateSenderPlayerV5::sendSelf()
    {        
    }

    void
    FullStateSenderPlayerV5::sendScore()
    {        
        int left = 0, right = 0;
        if( stadium().team_l )
            left = stadium().team_l->point;
        if( stadium().team_l )
            left = stadium().team_r->point;
        
        serializer().serializeFSScore( transport(), 
                                       left,  
                                       right ); 
   }   

    void
    FullStateSenderPlayerV5::sendBall()
    {
        const float quantize_step = .001;
        serializer().serializeFSBall( transport(),
                                      Quantize( stadium().ball->pos.x, 
                                                quantize_step ),
                                      Quantize( stadium().ball->pos.y,
                                                quantize_step ),
                                      Quantize( stadium().ball->vel.x,
                                                quantize_step ),
                                      Quantize( stadium().ball->vel.y,
                                                quantize_step ) );
    }

    void
    FullStateSenderPlayerV5::sendPlayer( const Player& p )
    {
        const float quantize_step = .001;
        char side = (p.team->side == LEFT) ? 'l' : 'r';
        serializer().serializeFSPlayerBegin( transport(),
                                             side,
                                             p.unum,
                                             false, // goalie info not sent
                                             0, // player type info not sent
                                             Quantize( p.pos.x,
                                                       quantize_step ), //pos_x
                                             Quantize( p.pos.y, 
                                                       quantize_step ), //pos_y
                                             Quantize( p.vel.x,
                                                       quantize_step ), //vel_x
                                             Quantize( p.vel.y,
                                                       quantize_step ), //vel_y
                                             Quantize( Rad2Deg( p.angle_body),
                                                       quantize_step ),
                                             Quantize( Rad2Deg( p.angle_neck_committed ),
                                                       quantize_step) ); //neck_angle 
        serializer().serializeFSPlayerEnd( transport(),
                                           int(p.stamina),
                                           Quantize( p.effort, .0001 ),
                                           Quantize( p.recovery, .0001) );
    }

/*!
//===================================================================
//
//  CLASS: FullStateSenderPlayerV8
//
//  DESC: version 8 of the full state protocol. 
//
//===================================================================
*/

    FullStateSenderPlayerV8::FullStateSenderPlayerV8( const Params& params )
        : FullStateSenderPlayerV5( params )
    {}

    FullStateSenderPlayerV8::~FullStateSenderPlayerV8()
    {}

    void
    FullStateSenderPlayerV8::sendSelf()
    {
      rcss::geom::Vector2D arm_vec;
      self().getArm().getRelDest ( rcss::geom::Vector2D ( self().pos.x,
                                                          self().pos.y ),
                                   self().angle_body 
                                   + self().angle_neck_committed,
                                   arm_vec );
      serializer().serializeFSCounts( transport(),
                                        self().count_kick, 
                                        self().count_dash,
                                        self().count_turn,
                                        self().count_catch,
                                        self().count_move,
                                        self().count_turn_neck,
                                        self().count_change_view,
                                        self().count_say );
      serializer().serializeArm( transport(), 
                                   self().getArm().getCyclesTillMovable(),
                                   self().getArm().getCyclesTillExpiry(),
                                   arm_vec.getMag(), Rad2IDegRound( arm_vec.getHead () ),
                                   self().getArm().getCounter() ); 
     }

    void
    FullStateSenderPlayerV8::sendScore()
    {        
        int left = 0, right = 0;
        if( stadium().team_l )
            left = stadium().team_l->point;
        if( stadium().team_l )
            left = stadium().team_r->point;

        if( self().team == stadium().team_r )
            std::swap( left, right );

        serializer().serializeFSScore( transport(), 
                                       left,  
                                       right ); 
    }   

    void
    FullStateSenderPlayerV8::sendBall()
    {
        serializer().serializeFSBall( transport(),
                                      stadium().ball->pos.x,
                                      stadium().ball->pos.y,
                                      stadium().ball->vel.x,
                                      stadium().ball->vel.y );
    }

    void
    FullStateSenderPlayerV8::sendPlayer( const Player& p )
    {
        char side = (p.team->side == LEFT) ? 'l' : 'r';
        serializer().serializeFSPlayerBegin( transport(),
                                             side,
                                             p.unum,
                                             p.goalie,
                                             p.player_type_id,
                                             p.pos.x,
                                             p.pos.y,
                                             p.vel.x,
                                             p.vel.y,
                                             Rad2Deg( p.angle_body ),
                                             Rad2Deg( p.angle_neck_committed ) );

        if( p.getArm().isPointing() )
        {
            rcss::geom::Vector2D arm_vec;
            p.getArm().getRelDest( rcss::geom::Vector2D ( p.pos.x, p.pos.y ),
                                p.angle_body + p.angle_neck_committed,
                                arm_vec );
            serializer().serializeFSPlayerArm( transport(),
                                               arm_vec.getMag(),
                                               arm_vec.getHead() );
        }
        
        serializer().serializeFSPlayerEnd( transport(),
                                           p.stamina,
                                           p.effort,
                                           p.recovery );
    }
/*!
//===================================================================
//
//  Register senders for different versions
//
//===================================================================
*/

    namespace fullstatesender
    {
        template< typename Sender >
        FullStateSender::Ptr
        create( const FullStateSenderPlayer::Params& params )
        { return FullStateSender::Ptr( new Sender( params ) ); }
       
        lib::RegHolder vp1 = FullStateSenderPlayer::factory().autoReg( &create< FullStateSenderPlayerV1 >, 1 );
        lib::RegHolder vp2 = FullStateSenderPlayer::factory().autoReg( &create< FullStateSenderPlayerV1 >, 2 );
        lib::RegHolder vp3 = FullStateSenderPlayer::factory().autoReg( &create< FullStateSenderPlayerV1 >, 3 );
        lib::RegHolder vp4 = FullStateSenderPlayer::factory().autoReg( &create< FullStateSenderPlayerV1 >, 4 );
        lib::RegHolder vp5 = FullStateSenderPlayer::factory().autoReg( &create< FullStateSenderPlayerV5 >, 5 );
        lib::RegHolder vp6 = FullStateSenderPlayer::factory().autoReg( &create< FullStateSenderPlayerV5 >, 6 );
        lib::RegHolder vp7 = FullStateSenderPlayer::factory().autoReg( &create< FullStateSenderPlayerV5 >, 7 );
        lib::RegHolder vp8 = FullStateSenderPlayer::factory().autoReg( &create< FullStateSenderPlayerV8 >, 8 );
        lib::RegHolder vp9 = FullStateSenderPlayer::factory().autoReg( &create< FullStateSenderPlayerV8 >, 9 );
    }
}