/*!
*/
bool
Bhv_SetPlayGoalKick::doKickToFarSide( PlayerAgent * agent )
{
const WorldModel & wm = agent->world();
Vector2D target_point( ServerParam::i().ourPenaltyAreaLineX() - 5.0,
ServerParam::i().penaltyAreaHalfWidth() );
if ( wm.ball().pos().y > 0.0 )
{
target_point.y *= -1.0;
}
double ball_move_dist = wm.ball().pos().dist( target_point );
double ball_first_speed = calc_first_term_geom_series_last( 0.7,
ball_move_dist,
ServerParam::i().ballDecay() );
ball_first_speed = std::min( ServerParam::i().ballSpeedMax(),
ball_first_speed );
ball_first_speed = std::min( wm.self().kickRate() * ServerParam::i().maxPower(),
ball_first_speed );
Vector2D accel = target_point - wm.ball().pos();
accel.setLength( ball_first_speed );
double kick_power = std::min( ServerParam::i().maxPower(),
accel.r() / wm.self().kickRate() );
AngleDeg kick_angle = accel.th();
dlog.addText( Logger::TEAM,
__FILE__" (doKickToFarSide) target=(%.2f %.2f) dist=%.3f ball_speed=%.3f",
target_point.x, target_point.y,
ball_move_dist,
ball_first_speed );
dlog.addText( Logger::TEAM,
__FILE__" (doKickToFarSide) kick_power=%f kick_angle=%.1f",
kick_power,
kick_angle.degree() );
agent->doKick( kick_power, kick_angle - wm.self().body() );
agent->setNeckAction( new Neck_ScanField() );
return true;
}
/*!
*/
void
SampleTrainer::sampleAction()
{
// sample training to test a ball interception.
static int s_state = 0;
static int s_wait_counter = 0;
static Vector2D s_last_player_move_pos;
if ( world().existKickablePlayer() )
{
s_state = 1;
}
switch ( s_state ) {
case 0:
// nothing to do
break;
case 1:
// exist kickable left player
// recover stamina
doRecover();
// move ball to center
doMoveBall( Vector2D( 0.0, 0.0 ),
Vector2D( 0.0, 0.0 ) );
// change playmode to play_on
doChangeMode( PM_PlayOn );
{
// move player to random point
UniformReal uni01( 0.0, 1.0 );
Vector2D move_pos
= Vector2D::polar2vector( 15.0, //20.0,
AngleDeg( 360.0 * uni01() ) );
s_last_player_move_pos = move_pos;
doMovePlayer( config().teamName(),
1, // uniform number
move_pos,
move_pos.th() - 180.0 );
}
// change player type
{
static int type = 0;
doChangePlayerType( world().teamNameLeft(), 1, type );
type = ( type + 1 ) % PlayerParam::i().playerTypes();
}
doSay( "move player" );
s_state = 2;
std::cout << "trainer: actionImpl init episode." << std::endl;
break;
case 2:
++s_wait_counter;
if ( s_wait_counter > 3
&& ! world().playersLeft().empty() )
{
// add velocity to the ball
//UniformReal uni_spd( 2.7, 3.0 );
//UniformReal uni_spd( 2.5, 3.0 );
UniformReal uni_spd( 2.3, 2.7 );
//UniformReal uni_ang( -50.0, 50.0 );
UniformReal uni_ang( -10.0, 10.0 );
Vector2D velocity
= Vector2D::polar2vector( uni_spd(),
s_last_player_move_pos.th()
+ uni_ang() );
doMoveBall( Vector2D( 0.0, 0.0 ),
velocity );
s_state = 0;
s_wait_counter = 0;
std::cout << "trainer: actionImpl start ball" << std::endl;
}
break;
}
}
/*!
*/
void
Bhv_GoalieChaseBall::doGoToCatchPoint( PlayerAgent * agent,
const Vector2D & target_point )
{
const ServerParam & SP = ServerParam::i();
const WorldModel & wm = agent->world();
double dash_power = 0.0;
Vector2D rel = target_point - wm.self().pos();
rel.rotate( - wm.self().body() );
AngleDeg rel_angle = rel.th();
const double angle_buf
= std::fabs( AngleDeg::atan2_deg( SP.catchableArea() * 0.9, rel.r() ) );
dlog.addText( Logger::TEAM,
__FILE__": GoToCatchPoint. (%.1f, %.1f). angle_diff=%.1f. angle_buf=%.1f",
target_point.x, target_point.y,
rel_angle.degree(), angle_buf );
agent->debugClient().setTarget( target_point );
// forward dash
if ( rel_angle.abs() < angle_buf )
{
dash_power = std::min( wm.self().stamina() + wm.self().playerType().extraStamina(),
SP.maxDashPower() );
dlog.addText( Logger::TEAM,
__FILE__": forward dash" );
agent->debugClient().addMessage( "GoToCatch:Forward" );
agent->doDash( dash_power );
}
// back dash
else if ( rel_angle.abs() > 180.0 - angle_buf )
{
dash_power = SP.minDashPower();
double required_stamina = ( SP.minDashPower() < 0.0
? SP.minDashPower() * -2.0
: SP.minDashPower() );
if ( wm.self().stamina() + wm.self().playerType().extraStamina()
< required_stamina )
{
dash_power = wm.self().stamina() + wm.self().playerType().extraStamina();
if ( SP.minDashPower() < 0.0 )
{
dash_power *= -0.5;
if ( dash_power < SP.minDashPower() )
{
dash_power = SP.minDashPower();
}
}
}
dlog.addText( Logger::TEAM,
__FILE__": back dash. power=%.1f",
dash_power );
agent->debugClient().addMessage( "GoToCatch:Back" );
agent->doDash( dash_power );
}
// forward dash turn
else if ( rel_angle.abs() < 90.0 )
{
dlog.addText( Logger::TEAM,
__FILE__": turn %.1f for forward dash",
rel_angle.degree() );
agent->debugClient().addMessage( "GoToCatch:F-Turn" );
agent->doTurn( rel_angle );
}
else
{
rel_angle -= 180.0;
dlog.addText( Logger::TEAM,
__FILE__": turn %.1f for back dash",
rel_angle.degree() );
agent->debugClient().addMessage( "GoToCatch:B-Turn" );
agent->doTurn( rel_angle );
}
agent->setNeckAction( new Neck_TurnToBall() );
}
/*!
*/
void
PlayerObject::updateBySee( const SideID side,
const Localization::PlayerT & p )
{
M_side = side;
M_ghost_count = 0;
// unum is updated only when unum is seen.
if ( p.unum_ != Unum_Unknown )
{
M_unum = p.unum_;
M_unum_count = 0;
if ( ! p.goalie_ )
{
// when unum is seen, goalie info is also seen
M_goalie = false;
}
}
if ( p.goalie_ )
{
M_goalie = true;
}
const Vector2D last_seen_move = p.pos_ - M_seen_pos;
const int last_seen_pos_count = M_seen_pos_count;
if ( p.hasVel() )
{
M_vel = p.vel_;
M_vel_count = 0;
M_seen_vel = p.vel_;
M_seen_vel_count = 0;
#ifdef DEBUG_PRINT
dlog.addText( Logger::WORLD,
__FILE__" (updateBySee) unum=%d. pos=(%.2f, %.2f) vel=(%.2f, %.2f)",
p.unum_, M_pos.x, M_pos.y, M_vel.x, M_vel.y );
#endif
}
else if ( 0 < M_pos_count
&& M_pos_count <= 2
&& p.rpos_.r() < 40.0 )
{
const double speed_max = ( M_player_type
? M_player_type->playerSpeedMax()
: ServerParam::i().defaultPlayerSpeedMax() );
const double decay = ( M_player_type
? M_player_type->playerDecay()
: ServerParam::i().defaultPlayerDecay() );
M_vel = last_seen_move / static_cast< double >( last_seen_pos_count );
double tmp = M_vel.r();
if ( tmp > speed_max )
{
M_vel *= speed_max / tmp;
}
M_vel *= decay;
M_vel_count = last_seen_pos_count;
M_seen_vel = M_vel;
M_seen_vel_count = 0;
#ifdef DEBUG_PRINT
dlog.addText( Logger::WORLD,
__FILE__" (updateBySee) unum=%d. update vel by pos diff."
"prev_pos=(%.2f, %.2f) old_pos=(%.2f, %.2f) -> vel=(%.3f, %.3f)",
p.unum_,
M_pos.x, M_pos.y, p.pos_.x, p.pos_.y, M_vel.x, M_vel.y );
#endif
}
else
{
M_vel.assign( 0.0, 0.0 );
M_vel_count = 1000;
}
M_pos = p.pos_;
M_rpos = p.rpos_;
M_seen_pos = p.pos_;
M_pos_count = 0;
M_rpos_count = 0;
M_seen_pos_count = 0;
if ( p.hasAngle() )
{
M_body = p.body_;
M_face = p.face_;
M_body_count = M_face_count = 0;
}
else if ( last_seen_pos_count <= 2
&& last_seen_move.r2() > std::pow( 0.2, 2 ) ) // Magic Number
{
M_body = last_seen_move.th();
M_body_count = std::max( 0, last_seen_pos_count - 1 );
M_face = 0.0;
M_face_count = 1000;
}
else if ( velValid()
&& vel().r2() > std::pow( 0.2, 2 ) ) // Magic Number
{
M_body = vel().th();
M_body_count = velCount();
M_face = 0.0;
M_face_count = 1000;
}
if ( p.isPointing()
&& M_pointto_count >= ServerParam::i().pointToBan() )
{
M_pointto_angle = p.arm_;
M_pointto_count = 0;
}
M_kicked = p.kicked();
if ( p.isTackling() )
{
if ( M_tackle_count > ServerParam::i().tackleCycles() ) // no tackling recently
{
M_tackle_count = 0;
}
}
else
{
M_tackle_count = 1000;
}
}
