fullstatesender.cpp

2009 ROBOCUP 仿真2DSERVER 源码

// -*-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.                                                        *
 *                                                                         *
 ***************************************************************************/

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

#include "fullstatesender.h"

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

namespace rcss {

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

FullStateSender::FullStateSender( std::ostream & transport )
    : Sender( transport )
{

}

FullStateSender::~FullStateSender()
{

}

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

FullStateSenderPlayer::FactoryHolder &
FullStateSenderPlayer::factory()
{
    static FactoryHolder 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 )
{
    //std::cerr << "create FullStateSenderPlayer" << std::endl;
}

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


/*!
//===================================================================
//
//  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()
{
    static const char * playmode_string[] = PLAYMODE_STRINGS;

    // send begining of FS
    serializer().serializeFSBegin( transport(), stadium().time() );

    if ( stadium().playmode() == PM_FreeKick_Left
         && stadium().ballCatcher() )
    {
        serializer().serializeFSPlayMode( transport(),
                                          "goalie_catch_ball_l" );
    }
    else if ( stadium().playmode() == PM_FreeKick_Right
              && stadium().ballCatcher() )
    {
        serializer().serializeFSPlayMode( transport(),
                                          "goalie_catch_ball_r" );
    }
    else
    {
        serializer().serializeFSPlayMode( transport(),
                                          playmode_string[stadium().playmode()] );
    }

    serializer().serializeFSViewMode( transport(),
                                      ( self().highquality()
                                        ? "high"
                                        : "low" ),
                                      ( self().viewWidth() == rcss::pcom::NARROW
                                        ? "narrow"
                                        : self().viewWidth() == rcss::pcom::WIDE
                                        ? "wide"
                                        : "normal" ) );

    sendSelf();

    sendScore();

    sendBall();

    const Stadium::PlayerCont::const_iterator end = stadium().players().end();
    for ( Stadium::PlayerCont::const_iterator p = stadium().players().begin();
          p != end;
          ++p )
    {
        if ( (*p)->state() == 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().teamLeft().enabled() )
    {
        left = stadium().teamLeft().point();
    }

    if ( stadium().teamLeft().enabled() )
    {
        left = stadium().teamRight().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 )
{