player.cpp

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

// -*-c++-*-

/***************************************************************************
                             player.cpp
               A class for field players and goalies
                          -------------------
    begin                : 26-NOV-2001
    copyright            : (C) 2001, 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 "player.h"

#include "coach.h"
#include "field.h"
#include "team.h"
#include "types.h"
#include "random.h"
#include "referee.h"
#include "heteroplayer.h"
#include "serverparam.h"
#include "playerparam.h"
#include "utility.h"

#include "serializer.h"
#include "initsenderplayer.h"
#include "bodysender.h"
#include "fullstatesender.h"
#include "visualsenderplayer.h"

#include <algorithm>
#include <cassert>

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

namespace {

inline
double
NormalizeDashPower( const double & p )
{
//     return rcss::bound( ServerParam::instance().minPower(),
//                         p,
//                         ServerParam::instance().maxPower() );
    return rcss::bound( ServerParam::instance().minDashPower(),
                        p,
                        ServerParam::instance().maxDashPower() );
}

inline
double
NormalizeDashAngle( const double & p )
{
    return rcss::bound( ServerParam::instance().minDashAngle(),
                        p,
                        ServerParam::instance().maxDashAngle() );
}

inline
double
NormalizeKickPower( const double & p )
{
    return rcss::bound( ServerParam::instance().minPower(),
                        p,
                        ServerParam::instance().maxPower() );
}

// For v11 or older version
inline
double
NormalizeTacklePower( const double & p )
{
    return rcss::bound( - ServerParam::instance().maxBackTacklePower(),
                        p,
                        ServerParam::instance().maxTacklePower() );
}

inline
double
NormalizeMoment( const double & p )
{
    return Deg2Rad( rcss::bound( ServerParam::instance().minMoment(),
                                 p,
                                 ServerParam::instance().maxMoment() ) );
}

inline
double
NormalizeNeckMoment( const double & p )
{
    return Deg2Rad( rcss::bound( ServerParam::instance().minNeckMoment(),
                                 p,
                                 ServerParam::instance().maxNeckMoment() ) );
}

inline
double
NormalizeNeckAngle( const double & p )
{
    return rcss::bound( Deg2Rad( ServerParam::instance().minNeckAngle() ),
                        p,
                        Deg2Rad( ServerParam::instance().maxNeckAngle() ) );
}

} // end of no-name namespace


Player::Player( Stadium & stadium,
                Team * team,
                int number )
    : MPObject( stadium,
                "", "",
                O_TYPE_PLAYER_NAME, O_TYPE_PLAYER_NAME_SHORT ),
      M_init_observer( new rcss::InitObserverPlayer ),
      M_observer( new rcss::ObserverPlayer ),
      M_body_observer( new rcss::BodyObserverPlayer ),
      M_fullstate_observer( new rcss::FullStateObserver ),
      M_team( team ),
      M_side( team->side() ),
      M_unum( number ),
      M_stamina( ServerParam::instance().staminaMax() ),
      M_recovery( ServerParam::instance().recoverInit() ),
      M_stamina_capacity( ServerParam::instance().staminaCapacity() ),
      M_consumed_stamina( 0.0 ),
      M_vis_angle( ServerParam::instance().visibleAngle() ),
      M_view_width( rcss::pcom::NORMAL ),
      defangle( ServerParam::instance().visibleAngle() ),
      vis_distance( ServerParam::instance().visibleDistance() ),
      vis_distance2( vis_distance * vis_distance ),
      M_version( 3.0 ),
      M_unum_far_length( 20.0 ),
      M_unum_too_far_length( 40.0 ),
      M_team_far_length( 40.0 ),
      M_team_too_far_length( 60.0 ),
      M_angle_body( 0.0 ),
      M_angle_body_committed( 0.0 ),
      M_angle_neck( 0.0 ),
      M_angle_neck_committed( 0.0 ),
      M_synch_see( false ),
      M_vis_send( 4 ),
      M_highquality( true ),
      M_state( DISABLE ),
      M_ball_collide( false ),
      M_player_collide( false ),
      M_post_collide( false ),
      M_command_done( false ),
      M_turn_neck_done( false ),
      M_done_received( false ),
      M_hear_capacity_from_teammate( ServerParam::instance().hearMax() ),
      M_hear_capacity_from_opponent( ServerParam::instance().hearMax() ),
      M_goalie( false ),
      M_goalie_catch_ban( 0 ),
      M_goalie_moves_since_catch( 0 ),
      M_kick_cycles( 0 ),
      M_kick_count( 0 ),
      M_dash_count( 0 ),
      M_turn_count( 0 ),
      M_catch_count( 0 ),
      M_move_count( 0 ),
      M_turn_neck_count( 0 ),
      M_change_view_count( 0 ),
      M_say_count( 0 ),
      M_arm( ServerParam::instance().pointToBan(),
             ServerParam::instance().pointToDuration() ),
      M_attentionto_count( 0 ),
      M_tackle_cycles( 0 ),
      M_tackle_count( 0 ),
      M_clang_min_ver( 0 ),
      M_clang_max_ver( 0 ),
      M_offside_mark( false ),
      M_parser( *this )
{
    assert( team );

    M_enable = false;

    M_weight = ServerParam::instance().playerWeight();
    M_max_speed = ServerParam::instance().playerSpeedMax();
    M_max_accel = ServerParam::instance().playerAccelMax();

    M_pos.x = -( unum() * 3 * team->side() );
    M_pos.y = - ServerParam::PITCH_WIDTH/2.0 - 3.0;

    // pfr 8/14/00: for RC2000 evaluation
    M_kick_rand = ServerParam::instance().kickRand();

    setPlayerType( 0 );

    M_effort = M_player_type->effortMax();
}

Player::~Player()
{
#if 0
    if ( ! isGoalie() )
    {
        std::cerr << M_team->name() << ','
                  << unum() << ','
                  << M_player_type->staminaIncMax() << ','
                  << M_player_type->staminaIncMax() * 3000 << ','
                  << M_consumed_stamina;
//               << " dash_count = " << M_dash_count;
//     if ( M_dash_count > 0 )
//     {
//         std::cerr << " consumed_stamina/dash =  " << M_consumed_stamina / M_dash_count;
//     }
            std::cerr << std::endl;
    }
#endif
    delete M_init_observer;
    M_init_observer = NULL;
    delete M_observer;
    M_observer = NULL;
    delete M_body_observer;
    M_body_observer = NULL;
    delete M_fullstate_observer;
    M_fullstate_observer = NULL;
}

bool
Player::init( const double & ver,
              const bool goalie )
{
    M_version = ver;
    M_goalie = goalie;

    setEnable();

    M_goalie_catch_ban = 0;
    M_goalie_moves_since_catch = 0;

    {
        char lname[128], sname[128];
        snprintf( lname, 128, PLAYER_NAME_FORMAT, team()->name().c_str(), unum() );
        snprintf( sname, 128, PLAYER_NAME_FORMAT_SHORT, team()->name().c_str(), unum(),
                  isGoalie() ? GOALIE_VISUAL_STRING : "" );
        setName( lname, sname );
    }

    char buf[128];
    snprintf( buf, 128, PLAYER_NAME_FAR_FORMAT, team()->name().c_str() );
    M_name_far = buf;
    snprintf( buf, 128, PLAYER_NAME_TOOFAR_FORMAT );
    M_name_toofar = buf;

    snprintf( buf, 128, PLAYER_NAME_FAR_FORMAT_SHORT, team()->name().c_str() );
    M_short_name_far = buf;
    snprintf( buf, 128, PLAYER_NAME_TOOFAR_FORMAT_SHORT );
    M_short_name_toofar = buf;

    M_angle_body_committed = SideDirection( side() );

    // pfr 8/14/00: for RC2000 evaluation
    double my_prand = ServerParam::instance().playerRand();
    if ( ServerParam::instance().teamActuatorNoise() )
    {
        my_prand *= team()->prandFactorTeam();
        M_kick_rand *= team()->kickRandFactorTeam();
    }

    M_randp = my_prand;

#ifdef NEW_QSTEP
    dist_qstep_player = team->distQstepTeam();
    land_qstep_player = team->landQstepTeam();
    dir_qstep_player  = team->dirQstepTeam();
#endif

    if ( ! setSenders() )
    {
        disable();
        std::cerr << "Error: Could not find serializer or sender for version "
                  << version() << std::endl;
        return false;
    }

    return true;
}

void
Player::setPlayerType( const int id )
{
    const HeteroPlayer * type = M_stadium.playerType( id );
    if ( ! type )
    {
        return;
    }

    M_player_type_id = id;
    M_player_type = type;
    M_max_speed = M_player_type->playerSpeedMax();
    M_inertia_moment = M_player_type->inertiaMoment();
    M_decay = M_player_type->playerDecay();
    M_size = M_player_type->playerSize();
    M_kick_rand = M_player_type->kickRand();

    if ( ServerParam::instance().teamActuatorNoise() )
    {
        M_kick_rand *= team()->kickRandFactorTeam();
    }
}

void
Player::substitute( const int type )
{
    setPlayerType( type );

    // reset stamina etc.
    M_stamina = ServerParam::instance().staminaMax();
    M_recovery = 1.0;
    M_effort = M_player_type->effortMax();
    M_stamina_capacity = ServerParam::instance().staminaCapacity();
    M_consumed_stamina = 0.0;

    M_hear_capacity_from_teammate = ServerParam::instance().hearMax();
    M_hear_capacity_from_opponent = ServerParam::instance().hearMax();
}

void
Player::setEnable()
{
    M_state = STAND;
    M_enable = true;
    if ( isGoalie() )
    {
        M_state |= GOALIE;
    }
}


void
Player::resetState()
{
    if ( tackleCycles() > 0 )
    {
        M_state &= ( STAND | GOALIE | DISCARD | TACKLE | TACKLE_FAULT );
    }
    else
    {
        M_state &= ( STAND | GOALIE | DISCARD );
    }
}

void
Player::disable()
{
    if ( M_enable )
    {
        std::cout << "A player disconnected : ("
                  << team()->name() << " " << unum()
                  << ")\n";
    }

    if ( isGoalie()
         && this == M_stadium.ballCatcher() )
    {
        M_stadium.clearBallCatcher();
    }

    M_enable = false;
    M_state = DISABLE;
    M_pos.x = -( unum() * 3 * side() );
    M_pos.y = - ServerParam::PITCH_WIDTH/2.0 - 3.0;
    M_vel.x = 0.0;
    M_vel.y = 0.0;
    M_accel.x = 0.0;
    M_accel.y = 0.0;

    if ( connected() )
    {
        RemoteClient::close();
    }
}

void
Player::discard()
{
    if ( M_state & STAND )
    {
        disable();
        if ( ! ( M_state & DISCARD ) )
        {
            M_state |= DISCARD;
        }
        else
        {
            M_state &= ~DISCARD;
        }
    }
}

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

    /** Call the PlayerCommandParser */
    if ( M_parser.parse( command ) != 0 )
    //if ( ! parseCommand( command ) )
    {
        send( "(error illegal_command_form)" );
        std::cerr << "Error parsing >" << command << "<\n";
    }
}

bool
Player::parseCommand( const char * command )
{
    const char * buf = command;
    int n_read = 0;