monitor.cpp

2009 ROBOCUP 仿真2DSERVER 源码

// -*-c++-*-

/***************************************************************************
                                 monitor.cc
    A class providing the communication interface for remote monitors that
    connect to the server
                             -------------------
    begin                : 27-DEC-2001
    copyright            : (C) 2001 by The RoboCup Soccer Server
                           Maintainance 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 "monitor.h"

#include "dispsender.h"
#include "initsendermonitor.h"
#include "serializermonitor.h"

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

#ifdef HAVE_SSTREAM
#include <sstream>
#else
#include <strstream>
#endif

#ifdef HAVE_NETINET_IN_H
#include <netinet/in.h>
#endif
#ifdef HAVE_WINDOWS_H
#include <windows.h>
#endif

namespace {

PlayMode
play_mode_id( const char * mode )
{
    static const char * playmode_strings[] = PLAYMODE_STRINGS;

    for ( int n = 0; n < PM_MAX; ++n )
    {
        if ( ! std::strcmp( playmode_strings[n], mode ) )
        {
            return static_cast< PlayMode >( n );
        }
    }
    return PM_Null;
}

}


Monitor::Monitor( Stadium & stadium,
                  const double & version )
    : M_init_observer( new rcss::InitObserverMonitor ),
      M_observer( new rcss::ObserverMonitor ),
      M_stadium( stadium ),
      M_version ( version ),
      M_playmode( PM_Null ),
      M_team_l_name( "" ),
      M_team_r_name( "" ),
      M_team_l_score( 0 ),
      M_team_r_score( 0 ),
      M_team_l_pen_taken( 0 ),
      M_team_r_pen_taken( 0 )
{

}

Monitor::~Monitor()
{
    delete M_init_observer;
    M_init_observer = NULL;
}

void
Monitor::parseMsg( const char * msg,
                   const size_t & len )
{
    char * str = const_cast< char * >( msg );
    if ( str[ len - 1 ] != 0 )
    {
        if ( version() >= 2.0 )
        {
            sendMsg( MSG_BOARD,
                     "(warning message_not_null_terminated)" );
        }
        str[ len ] = 0;
    }
    parseCommand( str );
}


bool
Monitor::setSenders()
{
    std::cerr << "Monitor::setSenders() version=" << version() << std::endl;

    rcss::SerializerMonitor::Creator ser_cre;
    if ( ! rcss::SerializerMonitor::factory().getCreator( ser_cre,
                                                          (int)version() ) )
    {
        std::cout << "Unsupported monitor protocol version. version=" << version()
                  << std::endl;
        return false;
    }

    const rcss::SerializerMonitor * ser = ser_cre();
    if ( ! ser )
    {
        std::cout << "Could not create monitor serializer. " << std::endl;
        return false;
    }

    //
    // disp sender
    //
    {
        rcss::DispSenderMonitor::Params disp_params( getTransport(),
                                                     *this,
                                                     *ser,
                                                     M_stadium );
        rcss::DispSenderMonitor::Creator disp_cre;
        if ( ! rcss::DispSenderMonitor::factory().getCreator( disp_cre,
                                                              (int)version() ) )
        {
            std::cerr << "failed to create DispSenderMonitor" << std::endl;
            return false;
        }
        M_observer->setDispSender( disp_cre( disp_params ) );
    }

    //
    // init sender
    //
    {
        rcss::InitSenderMonitor::Params init_params( getTransport(),
                                                     *this,
                                                     *ser,
                                                     M_stadium );
        rcss::InitSenderMonitor::Creator init_cre;
        if ( ! rcss::InitSenderMonitor::factory().getCreator( init_cre,
                                                              (int)version() ) )
        {
            std::cerr << "failed to create InitSenderMonitor" << std::endl;
            return false;
        }
        M_init_observer->setInitSender( init_cre( init_params ) );
    }

    return true;
}

void
Monitor::sendInit()
{
    M_init_observer->sendServerParams();
    M_init_observer->sendPlayerParams();
    M_init_observer->sendPlayerTypes();
}


void
Monitor::sendPlayMode()
{
    if ( M_playmode == M_stadium.playmode() )
    {
        return;
    }

    M_playmode = M_stadium.playmode();

    M_init_observer->sendPlayMode();
}

void
Monitor::sendScore()
{
    if ( M_team_l_score != M_stadium.teamLeft().point()
         || M_team_l_pen_taken != M_stadium.teamLeft().penaltyTaken()
         || M_team_r_score != M_stadium.teamRight().point()
         || M_team_r_pen_taken != M_stadium.teamRight().penaltyTaken()
         || M_team_l_name != M_stadium.teamLeft().name()
         || M_team_r_name != M_stadium.teamRight().name()
         )
    {
        M_team_l_name = M_stadium.teamLeft().name();
        M_team_r_name = M_stadium.teamRight().name();
        M_team_l_score = M_stadium.teamLeft().point();
        M_team_r_score = M_stadium.teamRight().point();
        M_team_l_pen_taken = M_stadium.teamLeft().penaltyTaken();
        M_team_r_pen_taken = M_stadium.teamRight().penaltyTaken();

        M_init_observer->sendScore();
    }
}

void
Monitor::sendTeamGraphic( const Side,
                          const unsigned int,
                          const unsigned int,
                          const XPMHolder * )
{
    // M_init_observer->sendTeamGraphic( side, x, y, holder );
}

void
Monitor::sendShow()
{
    M_observer->sendShow();
}

int
Monitor::sendMsg( const BoardType board,
                  const char * msg )
{
    if ( version() >= 3.0 )
    {
        char buf[MaxMesg];
        snprintf( buf, MaxMesg,
                  "(msg %d %d \"%s\")",
                  M_stadium.time(), board, msg );
        return RemoteClient::send( buf, std::strlen( buf ) + 1 );
    }
    else if ( version() >= 2.0 )
    {
        dispinfo_t2 minfo;
        minfo.mode = htons( MSG_MODE );
        minfo.body.msg.board = htons( board );
        std::strncpy( minfo.body.msg.message, msg, max_message_length_for_display );
        return RemoteClient::send( reinterpret_cast< char * >( &minfo ),
                                   sizeof( dispinfo_t2 ) );
    }
    else if ( version() >= 1.0 )
    {
        dispinfo_t minfo;
        minfo.mode = htons( MSG_MODE );
        minfo.body.msg.board = htons( board );
        std::strncpy( minfo.body.msg.message, msg, max_message_length_for_display );
        return RemoteClient::send( reinterpret_cast< const char * >( &minfo ),
                                   sizeof( dispinfo_t ) );
    }

    return 0;
}

bool
Monitor::parseCommand( const char * message )
{
    if ( ! std::strcmp( message, "(dispbye)" ) )
    {
        disable();
        return true;
    }
    else if ( ! std::strcmp( message, "(dispstart)" ) )
    {
        // kick off
        Stadium::_Start( M_stadium );
        return true;
    }
    else if ( ! std::strncmp( message, "(dispplayer", 11 ) )
    {
        return dispplayer( message );
    }
    else if ( ! std::strncmp( message, "(dispdiscard", 12 ) )
    {
        return dispdiscard( message );
    }
    else if ( ! std::strncmp( message, "(compression", 12 ) )
    {
        return compression( message );
    }
    else if ( ! std::strncmp( message, "(dispfoul", 9 ) )
    {
        return dispfoul( message );
    }
    else if ( ServerParam::instance().coachMode()
              || ServerParam::instance().coachWithRefereeMode() )
    {
        if ( ! std::strncmp( message, "(start)", 7 ) )
        {
            Stadium::_Start( M_stadium );
            sendMsg( MSG_BOARD, "(ok start)" );
            return true;
        }
        else if ( ! std::strncmp( message, "(change_mode", 12 ) )
        {
            return coach_change_mode( message );
        }
        else if ( ! std::strncmp( message, "(move", 5 ) )
        {
            return coach_move( message );
        }
        else if ( ! std::strncmp( message, "(recover", 8 ) )
        {
            return coach_recover();
        }
        else if ( ! std::strcmp( message, "change_player_type" ) )
        {
            return coach_change_player_type( message );
        }
        else if ( ! std::strncmp( message, "(check_ball", 11 ) )
        {
            return coach_check_ball();
        }
        else
        {
            sendMsg( MSG_BOARD, "(error illegal_command_form)" );
            return false;
        }
    }
    else
    {
        sendMsg( MSG_BOARD, "(error illegal_command_form)" );
        return false;