hetroplayer.c

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

/* -*- Mode: C++ -*- */

/*
 *Copyright:

    Copyright (C) 1996-2000 Electrotechnical Laboratory. 
    	Itsuki Noda, Yasuo Kuniyoshi and Hitoshi Matsubara.
    Copyright (C) 2000, 2001 RoboCup Soccer Server Maintainance Group.
    	Patrick Riley, Tom Howard, Daniel Polani, Itsuki Noda,
	Mikhail Prokopenko, Jan Wendler 

    This file is a part of SoccerServer.

    This code is free software; you can redistribute it and/or
    modify it under the terms of the GNU Lesser General Public
    License as published by the Free Software Foundation; either
    version 2.1 of the License, or (at your option) any later version.

    This library is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
    Lesser General Public License for more details.

    You should have received a copy of the GNU Lesser General Public
    License along with this library; if not, write to the Free Software
    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA

 *EndCopyright:
 */

#include "hetroplayer.h"
#include "random.h"

bool HetroPlayer::seeded = false;

void HetroPlayer::seed()
{
  if ( !HetroPlayer::seeded )
    {
      if (PlayerParam::instance().randomSeed() >= 0) {
        std::cout << "Using given Hetero Player Seed: " 
             << PlayerParam::instance().randomSeed() << std::endl;
        srand ( PlayerParam::instance().randomSeed() );
      } else {
        timeval now;
        gettimeofday ( &now, NULL );
        std::cout << "Hetero Player Seed: " << now.tv_usec << std::endl;
        srand ( now.tv_usec );
      }
      HetroPlayer::seeded = true;
    }
}

Value HetroPlayer::delta ( Value min, Value max )
{
    return drand ( min, max );
}

HetroPlayer::HetroPlayer()
{
    HetroPlayer::seed();

    bool reject;
    do
    {
        Value tmp_delta = HetroPlayer::delta ( PlayerParam::instance().playerSpeedMaxDeltaMin (), 
                                               PlayerParam::instance().playerSpeedMaxDeltaMax () );
        player_speed_max = ServerParam::instance().pspeed_max + tmp_delta;
        stamina_inc_max = ServerParam::instance().stamina_inc + tmp_delta 
            * PlayerParam::instance().staminaIncMaxDeltaFactor ();
        
        tmp_delta = HetroPlayer::delta ( PlayerParam::instance().playerDecayDeltaMin (), 
                                         PlayerParam::instance().playerDecayDeltaMax () );
        player_decay = ServerParam::instance().pdecay + tmp_delta;
        inertia_moment = ServerParam::instance().inertia_moment + tmp_delta 
            * PlayerParam::instance().inertiaMomentDeltaFactor ();
        
        tmp_delta = HetroPlayer::delta ( PlayerParam::instance().dashPowerRateDeltaMin (), 
                                         PlayerParam::instance().dashPowerRateDeltaMax () );
        dash_power_rate = ServerParam::instance().dprate + tmp_delta;
        player_size = ServerParam::instance().psize + tmp_delta 
            * PlayerParam::instance().playerSizeDeltaFactor ();
        
        // trade-off stamina_inc_max with dash_power_rate
        tmp_delta = HetroPlayer::delta(PlayerParam::instance().newDashPowerRateDeltaMin(),  
                                       PlayerParam::instance().newDashPowerRateDeltaMax());
        dash_power_rate = ServerParam::instance().dprate + tmp_delta;
        stamina_inc_max = ServerParam::instance().stamina_inc + tmp_delta *
            PlayerParam::instance().newStaminaIncMaxDeltaFactor();
        
        tmp_delta = HetroPlayer::delta ( PlayerParam::instance().kickableMarginDeltaMin (), 
                                         PlayerParam::instance().kickableMarginDeltaMax () );
        kickable_margin = ServerParam::instance().kmargin + tmp_delta;
        kick_rand = ServerParam::instance().kick_rand + tmp_delta 
            * PlayerParam::instance().kickRandDeltaFactor ();
        
        tmp_delta = HetroPlayer::delta ( PlayerParam::instance().extraStaminaDeltaMin (), 
                                         PlayerParam::instance().extraStaminaDeltaMax () );
        extra_stamina = tmp_delta;
        effort_max = ServerParam::instance().effort_init + tmp_delta 
            * PlayerParam::instance().effortMaxDeltaFactor ();
        effort_min = ServerParam::instance().effort_min + tmp_delta 
            * PlayerParam::instance().effortMinDeltaFactor ();

        // the amount of power consumed by a default player while running at max speed
        static double homo_power_cons_at_max_vel 
            = ( ( ServerParam::instance().pspeed_max
                  * ( 1 - ServerParam::instance().pdecay ) ) 
                / ServerParam::instance().dprate )
            - ServerParam::instance().stamina_inc;

        // the amount of power consumend by this player while running at max speed
        double hetero_power_cons_at_max_vel 
            = ( ( player_speed_max
                  * ( 1 - player_decay ) )
                / dash_power_rate )
            - stamina_inc_max;

        // if the generated player can run faster than default and consume less power, then reject this player type and select a new one.
        reject = ( player_speed_max > ServerParam::instance().pspeed_max
                   && hetero_power_cons_at_max_vel < homo_power_cons_at_max_vel );
    }
    while( reject );
}

HetroPlayer::HetroPlayer ( int )
{
    player_speed_max = ServerParam::instance().pspeed_max;
    stamina_inc_max = ServerParam::instance().stamina_inc;

    player_decay = ServerParam::instance().pdecay;
    inertia_moment = ServerParam::instance().inertia_moment;

    dash_power_rate = ServerParam::instance().dprate;
    player_size = ServerParam::instance().psize;

    kickable_margin = ServerParam::instance().kmargin;
    kick_rand = ServerParam::instance().kick_rand;

    extra_stamina = PlayerParam::instance().extraStaminaDeltaMin ();
    effort_max = ServerParam::instance().effort_init;
    effort_min = ServerParam::instance().effort_min;
}

HetroPlayer::~HetroPlayer ()
{
}

std::ostream& operator<< ( std::ostream& o, const HetroPlayer& hp )
{
  o << "Hetro Player Type:" << std::endl;
  o << "\tPlayer speed max = " << hp.playerSpeedMax () << std::endl;
  o << "\tStamina inc = " << hp.staminaIncMax () << std::endl;
  o << "\tPlayer decay = " << hp.playerDecay () << std::endl;
  o << "\tInertia moment = " << hp.inertiaMoment () << std::endl;
  o << "\tDash power rate = " <<  hp.dashPowerRate () << std::endl;
  o << "\tPlayer size = " << hp.playerSize () << std::endl;
  o << "\tKickable margin = " << hp.kickableMargin () << std::endl;
  o << "\tKick rand = " << hp.kickRand () << std::endl;
  o << "\tExtra stamina = " << hp.extraStamina () << std::endl;
  o << "\tEffort max = " << hp.effortMax () << std::endl;
  o << "\tEffort min = " << hp.effortMin () << std::endl;
  double power_cons_at_max_vel 
      = ( ( hp.playerSpeedMax()
            * ( 1 - hp.playerDecay() ) )
          / hp.dashPowerRate() )
      - hp.staminaIncMax();
  o << "\tPower Cons @ max vel = " << power_cons_at_max_vel << std::endl;
  return o;
}

player_type_t HetroPlayer::convertToStruct ( int id )
{
    player_type_t tmp;

    tmp.id = htons ( id );
    tmp.player_speed_max = htonl ( (long)rint((player_speed_max * SHOWINFO_SCALE2) ));
    tmp.stamina_inc_max = htonl ( (long)rint((stamina_inc_max * SHOWINFO_SCALE2) ));
    tmp.player_decay = htonl ( (long)rint((player_decay * SHOWINFO_SCALE2) ));
    tmp.inertia_moment = htonl ( (long)rint((inertia_moment * SHOWINFO_SCALE2) ));
    tmp.dash_power_rate = htonl ( (long)rint((dash_power_rate * SHOWINFO_SCALE2) ));
    tmp.player_size = htonl ( (long)rint((player_size * SHOWINFO_SCALE2) ));
    tmp.kickable_margin = htonl ( (long)rint((kickable_margin * SHOWINFO_SCALE2) ));
    tmp.kick_rand = htonl ( (long)rint((kick_rand * SHOWINFO_SCALE2) ));
    tmp.extra_stamina = htonl ( (long)rint((extra_stamina * SHOWINFO_SCALE2) ));
    tmp.effort_max = htonl ( (long)rint((effort_max * SHOWINFO_SCALE2) ));
    tmp.effort_min = htonl ( (long)rint((effort_min * SHOWINFO_SCALE2) ));

    return tmp;
}

std::ostream& toStr ( std::ostream& o, const PlayerTypeSensor_v7::data_t& data )
{
  return o << "(player_type " << data.M_id << " "
					 << data.M_player_speed_max << " "
					 << data.M_stamina_inc_max << " "
					 << data.M_player_decay << " "
					 << data.M_inertia_moment << " "
					 << data.M_dash_power_rate << " "
					 << data.M_player_size << " "
					 << data.M_kickable_margin << " "
					 << data.M_kick_rand << " " 
					 << data.M_extra_stamina << " "
					 << data.M_effort_max << " "
					 << data.M_effort_min
					 << ")";
}

std::ostream& toStr ( std::ostream& o, const PlayerTypeSensor_v8::data_t& data )
{
		return o << "(player_type "
						 << "(id " << data.M_id 
						 << ") (player_speed_max " << data.M_player_speed_max 
						 << ") (stamina_inc_max " << data.M_stamina_inc_max 
						 << ") (player_decay " << data.M_player_decay 
						 << ") (inertia_moment " << data.M_inertia_moment 
						 << ") (dash_power_rate " << data.M_dash_power_rate 
						 << ") (player_size " << data.M_player_size 
						 << ") (kickable_margin " << data.M_kickable_margin 
						 << ") (kick_rand " << data.M_kick_rand  
						 << ") (extra_stamina " << data.M_extra_stamina 
						 << ") (effort_max " << data.M_effort_max 
						 << ") (effort_min " << data.M_effort_min
						 << "))";
}