coach.cpp

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

// -*-c++-*-

/***************************************************************************
                              coach.cpp
                  A classes for trainer and coaches.
                             -------------------
    begin                : 2007-04-18
    copyright            : (C) 20072 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 "coach.h"

#include "audio.h"
#include "clangparser.h"
#include "clangmsg.h"
#include "clangmsgbuilder.h"
#include "field.h"
#include "object.h"
#include "player.h"
#include "serializer.h"
#include "team.h"
#include "xpmholder.h"
#include "initsendercoach.h"
#include "initsenderonlinecoach.h"
#include "visualsendercoach.h"

#include <boost/lexical_cast.hpp>

#include <iostream>
#include <cstdio>
#include <cstring>
#include <cmath>

#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;
}

void
chop_last_parenthesis( char *str,
                       int max_size )
{
    int l = std::strlen( str );

    if ( l > max_size )
    {
        str[max_size] = '\0';
    }
    else
    {
        --l;
        if ( str[l] == ')' ) str[l] = '\0';
    }
}

}

Coach::Coach( Stadium & stadium )
    : M_init_observer_coach( NULL ),
      M_observer( new rcss::ObserverCoach ),
      M_stadium( stadium ),
      M_assigned( false ),
      M_eye( false ),
      M_hear( false ),
      M_version( 0.0 ),
      M_side( NEUTRAL ),
      M_done_received( false )
{

}

void
Coach::disable()
{
    M_assigned = false;
    RemoteClient::close();
    std::cout << "An offline coach disconnected\n";
}

bool
Coach::setSenders( const double & client_version )
{
    M_version = client_version;

    rcss::SerializerCoach::Creator ser_cre;
    if ( ! rcss::SerializerCoach::factory().getCreator( ser_cre,
                                                        (int)client_version ) )
    {
        return false;
    }

    const rcss::SerializerCoach* ser = ser_cre();
    if( ! ser )
    {
        return false;
    }

    // visual
    rcss::VisualSenderCoach::Params visual_params( getTransport(),
                                                   *this,
                                                   *ser,
                                                   M_stadium );
    rcss::VisualSenderCoach::Creator visual_cre;
    if ( ! rcss::VisualSenderCoach::factory().getCreator( visual_cre,
                                                          (int)client_version ) )
    {
        return false;
    }
    M_observer->setVisualSender( visual_cre( visual_params ) );

    // audio
    rcss::AudioSenderCoach::Params audio_params( getTransport(),
                                                 *this,
                                                 *ser,
                                                 M_stadium );

    rcss::AudioSenderCoach::Creator audio_cre;
    if( ! rcss::AudioSenderCoach::factory().getCreator( audio_cre,
                                                        (int)client_version ) )
    {
        return false;
    }
    setAudioSender( audio_cre( audio_params ) );

    // init
    rcss::InitSenderOfflineCoach::Params init_params( getTransport(),
                                                      *this,
                                                      *ser,
                                                      M_stadium );
    rcss::InitSenderOfflineCoach::Creator init_cre;
    if ( ! rcss::InitSenderOfflineCoach::factory().getCreator( init_cre,
                                                               (int)client_version ) )
    {
        return false;
    }

    M_init_observer_coach = new rcss::InitObserverOfflineCoach;

    //rcss::InitSenderOfflineCoach::Ptr isoc = init_cre( init_params );
    //rcss::InitObserver<rcss::InitSenderOfflineCoach>::setInitSender( isoc );
    M_init_observer_coach->setInitSender( init_cre( init_params ) );

    M_assigned = true;
    return true;
}

void
Coach::sendInit()
{
    M_init_observer_coach->sendInit();

    M_init_observer_coach->sendServerParams();
    M_init_observer_coach->sendPlayerParams();
    M_init_observer_coach->sendPlayerTypes();
    M_init_observer_coach->sendChangedPlayers();
}

void
Coach::sendOKEye()
{
    if ( M_assigned )
    {
        M_observer->sendOKEye();
    }
}


void
Coach::send( const char* msg )
{
    if ( RemoteClient::send( msg, std::strlen( msg ) + 1 ) != -1 )
    {
        M_stadium.logger().writeCoachLog( msg, SEND );
    }
}

void
Coach::parseMsg( const char * msg,
                 const size_t & len )
{
    char * str = const_cast< char * >( msg );
    if ( str[ len - 1 ] != 0 )
    {
        if ( version() >= 8.0 )
        {
            send( "(warning message_not_null_terminated)" );
        }
        str[ len ] = 0;
    }
    M_stadium.logger().writeCoachLog( str, RECV );
    parse_command( str );
}


void
Coach::parse_command( const char *command )
{
    char com[128];

    if ( std::sscanf( command, "(%127[-0-9a-zA-Z.+*/?<>_]", com ) != 1 )
    {
        send( "(error illegal_command_form)" );
        return;
    }

    if ( ! std::strcmp( com, "start" ) )
    {
        Stadium::_Start( M_stadium );
        send( "(ok start)" );
    }
    else if ( ! std::strcmp( com, "change_mode" ) )
    {
        parse_change_mode( command );
    }
    else if ( ! std::strcmp( com, "move" ) )
    {
        parse_move( command );
    }
    else if ( ! std::strcmp( com, "look" ) )
    {
        look();
    }
    else if ( ! std::strcmp( com,"team_names" ) )
    {
        team_names();
    }
    else if ( ! std::strcmp( com, "recover" ) )
    {
        recover();
    }
    else if ( ! std::strcmp( com, "check_ball" ) )
    {
        check_ball();
    }
    else if( ! std::strcmp( com, "say" ) )
    {
        static char msg[MaxMesg] ;
        if ( std::sscanf( command, SAY_MESSAGE_SCAN_FORMAT, com, msg ) != 2 )
        {
            send( "(error illegal_command_form)" );
            return;
        }
        chop_last_parenthesis( msg, ServerParam::instance().freeformMsgSize() );
        M_stadium.sendCoachAudio( *this, msg );
        send( "(ok say)" );
    }
    else if ( ! std::strcmp( com,"ear" ) )
    {
        char mode[16] ;
        if ( std::sscanf( command,"(ear %15[^ ()])", mode ) != 1 )
        {
            send( "(error illegal_command_form)" );
            return;
        }

        ear( mode );
        return;
    }
    else if ( ! std::strcmp( com, "eye" ) )
    {
        char mode[16] ;
        if ( std::sscanf( command, "(eye %15[^ ()])", mode ) != 1 )
        {
            send( "(error illegal_command_form)" );
            return;
        }

        eye( mode );
        return;
    }
    else if ( ! std::strcmp( com, "change_player_type" ) )
    {
        char name[128];
        int unum, player_type;
        if ( std::sscanf( command, "(%s %s %d %d)",
                          com, name, &unum, &player_type ) < 4 )
        {
            send( "(error illegal_command_form)" );
            return;
        }

        change_player_type( name, unum, player_type );
        return;
    }
    //pfr:SYNCH
    else if ( ! std::strcmp( com, "done" ) )
    {
        //std::cerr << "Recv trainer done" << std::endl;
        M_done_received = true;
        return;
    }
    else if ( ! std::strcmp( com, "compression" ) )
    {
        int level;
        if ( std::sscanf( command, "(%s %d)", com, &level ) < 2 )
        {
            send( "(error illegal_command_form)" );
            return;
        }

        compression( level );
        return;
    }
    else
    {
        send( "(error unknown_command)" );
        return;
    }
}


void
Coach::sendExternalMsg()
{
    //std::cerr << "sendExternalMsg" << std::endl;
    if ( ServerParam::instance().coachMsgFile().empty() )
    {
        //std::cerr << "sendExternalMsg no input file" << std::endl;
        return;
    }

    std::ifstream fin( ServerParam::instance().coachMsgFile().c_str() );
    if ( ! fin.is_open() )
    {
        std::cerr << "Error: Could not open the file ["
                  << ServerParam::instance().coachMsgFile()
                  << "]" << std::endl;
        return;
    }

    std::vector< char > buf;
    std::copy( std::istreambuf_iterator< char >( fin ),
               std::istreambuf_iterator< char >(),
               std::back_inserter( buf ) );

    if ( buf.empty() )
    {
        std::cerr << "Error: coach_msg_file is empty."
                  << std::endl;
        return;
    }

    if ( buf.size() >= MaxMesg - std::strlen( "(include 8192 )" ) )
    {
        std::cerr << "Too large messages in ["
                  << ServerParam::instance().coachMsgFile()
                  << "]"
                  << std::endl;
        return;
    }

    std::string msg = "(include ";
    msg += boost::lexical_cast< std::string >( buf.size() );
    msg += ' ';
    msg.append( buf.begin(), buf.end() );
    msg += ')';

    std::cout << "send external message in ["
              << ServerParam::instance().coachMsgFile()
              << "]"
              << std::endl;

    send( msg.c_str() );
}

void
Coach::parse_change_mode( const char * command )
{
    char new_mode[128];
    if ( std::sscanf( command,
                      "(change_mode %127[-0-9a-zA-Z.+*/?<>_])",
                      new_mode ) != 1 )
    {
        send( "(error illegal_command_form)" );
        return;
    }

    change_mode( new_mode );
}

void
Coach::change_mode( std::string mode )
{
    PlayMode mode_id = play_mode_id( mode.c_str() );

    if ( mode_id == PM_Null )
    {
        send( "(error illegal_mode)" );
        return;
    }

    M_stadium.change_play_mode( mode_id );
    send( "(ok change_mode)" );
}

void
Coach::parse_move( const char * command )
{
    char obj[128];
    double x = 0.0, y = 0.0, ang = 0.0, velx = 0.0, vely = 0.0;

    int n = std::sscanf( command,
                         " (move (%127[^)]) %lf %lf %lf %lf %lf ) ",
                         obj, &x, &y, &ang, &velx, &vely );

    if ( n < 3
         || std::isnan( x ) != 0
         || std::isnan( y ) != 0
         || std::isnan( ang ) != 0
         || std::isnan( velx ) != 0
         || std::isnan( vely ) != 0 )
    {
        send( "(error illegal_object_form)" );
        return;
    }

    std::string obj_name = "(";
    obj_name += obj;
    obj_name += ')';

    if ( obj_name == BALL_NAME )
    {
        M_stadium.clearBallCatcher();

        if ( n == 3 || n == 4 )
        {
            M_stadium.set_ball( LEFT, PVector( x, y ) );
        }
        else if ( n == 6 )