const AbstractPlayerObject * player_;

int number_;

double score_;

ObjectScore()

: player_( static_cast< AbstractPlayerObject * >( 0 ) ),

number_( -1 ),

score_( -65535.0 )

{ }

struct Compare {

bool operator()( const ObjectScore & lhs,

const ObjectScore & rhs ) const

{

return lhs.score_ > rhs.score_;

}

};

struct IllegalChecker {

bool operator()( const ObjectScore & val ) const

{

return val.score_ <= 0.1;

}

};

bool operator()( const AbstractPlayerObject * lhs,

const AbstractPlayerObject * rhs ) const

{

return lhs->distFromSelf() < rhs->distFromSelf();

}

bool operator()( const AbstractPlayerObject * lhs,

const AbstractPlayerObject * rhs ) const

{

return lhs->distFromBall() < rhs->distFromBall();

}

AbstractPlayerBallXDiffCmp();

const double ball_x_;

AbstractPlayerBallXDiffCmp( const double & ball_x )

: ball_x_( ball_x )

{ }

bool operator()( const AbstractPlayerObject * lhs,

const AbstractPlayerObject * rhs ) const

{

return std::fabs( lhs->pos().x - ball_x_ )

< std::fabs( rhs->pos().x - ball_x_ );

}

bool operator()( const AbstractPlayerObject * lhs,

const AbstractPlayerObject * rhs ) const

{

return lhs->pos().x < rhs->pos().x;

}

const double & variance )

{

return std::exp( - std::pow( val, 2 ) / ( 2.0 * std::pow( variance, 2 ) ) );

const Vector2D & ball_pos,

const double & x_rate,

const double & y_rate )

{

//return p->distFromBall();

return std::sqrt( std::pow( ( p->pos().x - ball_pos.x ) * x_rate, 2 )

+ std::pow( ( p->pos().y - ball_pos.y ) * y_rate, 2 ) ); // Magic Number

: M_current_sender_unum( Unum_Unknown ),

M_next_sender_unum( Unum_Unknown ),

M_ball_send_time( 0, 0 )

{

for ( int i = 0; i < 12; ++i )

{

M_teammate_send_time[i].assign( 0, 0 );

M_opponent_send_time[i].assign( 0, 0 );

}

{

if ( ! agent->config().useCommunication() )

{

return false;

}

updateCurrentSender( agent );

const WorldModel & wm = agent->world();

const bool penalty_shootout = wm.gameMode().isPenaltyKickMode();

bool say_recovery = false;

if ( wm.gameMode().type() != GameMode::PlayOn

&& ! penalty_shootout

&& currentSenderUnum() == wm.self().unum()

&& wm.self().recovery() < ServerParam::i().recoverInit() - 0.002 )

{

say_recovery = true;

sayRecovery( agent );

}

if ( wm.gameMode().type() == GameMode::BeforeKickOff

|| wm.gameMode().type() == GameMode::AfterGoal_

|| penalty_shootout )

{

return say_recovery;

}

#ifdef DEBUG_PRINT_PLAYER_RECORD

const AudioMemory::PlayerRecord::const_iterator end = agent->world().audioMemory().playerRecord().end();

for ( AudioMemory::PlayerRecord::const_iterator p = agent->world().audioMemory().playerRecord().begin();

p != end;

++p )

{

dlog.addText( Logger::COMMUNICATION,

__FILE__": PlayerRecord: time=[%d,%d] %s %d from %d",

p->first.cycle(), p->first.stopped(),

p->second.unum_ <= 11 ? "teammate" : "opponent",

p->second.unum_ <= 11 ? p->second.unum_ : p->second.unum_ - 11,

p->second.sender_ );

}

#endif

#if 1

sayBallAndPlayers( agent );

sayStamina( agent );

#else

#endif

attentiontoSomeone( agent );

return true;

{

const WorldModel & wm = agent->world();

if ( agent->effector().getSayMessageLength() > 0 )

{

M_current_sender_unum = wm.self().unum();

return;

}

// if ( wm.self().distFromBall() > ServerParam::i().audioCutDist() + 30.0 )

// {

// M_current_sender_unum = wm.self().unum();

// return;

// }

M_current_sender_unum = Unum_Unknown;

std::vector< int > candidate_unum;

candidate_unum.reserve( 11 );

if ( wm.ball().pos().x < -10.0

|| wm.gameMode().type() != GameMode::PlayOn )

{

//

// all players

//

for ( int unum = 1; unum <= 11; ++unum )

{

candidate_unum.push_back( unum );

}

}

else

{

//

// exclude goalie

//

const int goalie_unum = ( wm.ourGoalieUnum() != Unum_Unknown

? wm.ourGoalieUnum()

: Strategy::i().goalieUnum() );

for ( int unum = 1; unum <= 11; ++unum )

{

if ( unum != goalie_unum )

{

candidate_unum.push_back( unum );

#if 0

dlog.addText( Logger::COMMUNICATION,

__FILE__": (updateCurrentSender) field_player unum=%d",

candidate_unum.back() );

#endif

}

}

}

int val = ( wm.time().stopped() > 0

? wm.time().cycle() + wm.time().stopped()

: wm.time().cycle() );

int current = val % candidate_unum.size();

int next = ( val + 1 ) % candidate_unum.size();

M_current_sender_unum = candidate_unum[current];

M_next_sender_unum = candidate_unum[next];

#ifdef DEBUG_PRINT

dlog.addText( Logger::COMMUNICATION,

__FILE__": (updateCurrentSender) time=%d size=%d index=%d current=%d next=%d",

wm.time().cycle(),

candidate_unum.size(),

current,

M_current_sender_unum,

M_next_sender_unum );

#endif

const SideID side,

const int unum )

{

if ( unum < 1 || 11 < unum )

{

std::cerr << __FILE__ << ':' << __LINE__

<< ": Illegal player number. " << unum

<< std::endl;

return;

}

if ( side == wm.ourSide() )

{

M_teammate_send_time[unum] = wm.time();

}

else

{

M_opponent_send_time[unum] = wm.time();

}

{

const WorldModel & wm = agent->world();

if ( wm.ball().seenPosCount() > 0

|| wm.ball().seenVelCount() > 2 )

{

return false;

}

if ( wm.gameMode().type() != GameMode::PlayOn )

{

if ( agent->effector().queuedNextBallVel().r2() < std::pow( 0.5, 2 ) )

{

return false;

}

}

if ( wm.existKickableTeammate() )

{

return false;

}

bool ball_vel_changed = false;

const double cur_ball_speed = wm.ball().vel().r();

const BallObject::State * prev_ball_state = wm.ball().getState( 1 );

if ( prev_ball_state )

{

const double prev_ball_speed = prev_ball_state->vel_.r();

double angle_diff = ( wm.ball().vel().th() - prev_ball_state->vel_.th() ).abs();

dlog.addText( Logger::COMMUNICATION,

__FILE__": (shouldSayBall) check ball vel" );

dlog.addText( Logger::COMMUNICATION,

"prev_vel=(%.2f %.2f) r=%.3f",

prev_ball_state->vel_.x, prev_ball_state->vel_.y,

prev_ball_speed );

dlog.addText( Logger::COMMUNICATION,

"cur_vel=(%.2f %.2f) r=%.3f",

wm.ball().vel().x, wm.ball().vel().y,

cur_ball_speed );

if ( cur_ball_speed > prev_ball_speed + 0.1

|| ( prev_ball_speed > 0.5

&& cur_ball_speed < prev_ball_speed * ServerParam::i().ballDecay() * 0.5 )

|| ( prev_ball_speed > 0.5 // Magic Number

&& angle_diff > 20.0 ) ) // Magic Number

{

dlog.addText( Logger::COMMUNICATION,

__FILE__": (shouldSayBall) ball vel changed." );

ball_vel_changed = true;

}

}

if ( ball_vel_changed

&& wm.lastKickerSide() != wm.ourSide()

&& ! wm.existKickableOpponent() )

{

dlog.addText( Logger::COMMUNICATION,

__FILE__": (shouldSayBall) ball vel changed. opponent kicked. no opponent kicker" );

return true;

}

if ( wm.self().isKickable() )

{

if ( agent->effector().queuedNextBallKickable() )

{

if ( cur_ball_speed < 1.0 )

{

return false;

}

}

if ( ball_vel_changed

&& agent->effector().queuedNextBallVel().r() > 1.0 )

{

dlog.addText( Logger::COMMUNICATION,

__FILE__": (shouldSayBall) kickable. ball vel changed" );

return true;

}

dlog.addText( Logger::COMMUNICATION,

__FILE__": (shouldSayBall) kickable, but no say" );

return false;

}

const PlayerObject * ball_nearest_teammate = NULL;

const PlayerObject * second_ball_nearest_teammate = NULL;

const PlayerPtrCont::const_iterator t_end = wm.teammatesFromBall().end();

for ( PlayerPtrCont::const_iterator t = wm.teammatesFromBall().begin();

t != t_end;

++t )

{

if ( (*t)->isGhost() || (*t)->posCount() >= 10 ) continue;

if ( ! ball_nearest_teammate )

{

ball_nearest_teammate = *t;

}

else if ( ! second_ball_nearest_teammate )

{

second_ball_nearest_teammate = *t;

break;

}

}

int our_min = std::min( wm.interceptTable()->selfReachCycle(),

wm.interceptTable()->teammateReachCycle() );

int opp_min = wm.interceptTable()->opponentReachCycle();

//

// I am the nearest player to ball

//

if ( ! ball_nearest_teammate

|| ( ball_nearest_teammate->distFromBall() > wm.ball().distFromSelf() - 3.0 ) )

{

dlog.addText( Logger::COMMUNICATION,

__FILE__": (shouldSayBall) maybe nearest to ball" );

//return true;

if ( ball_vel_changed

|| ( opp_min <= 1 && cur_ball_speed > 1.0 ) )

{

dlog.addText( Logger::COMMUNICATION,

__FILE__": (shouldSayBall) nearest to ball. ball vel changed?" );

return true;

}

}

if ( ball_nearest_teammate

&& wm.ball().distFromSelf() < 20.0

&& 1.0 < ball_nearest_teammate->distFromBall()

&& ball_nearest_teammate->distFromBall() < 6.0

&& ( opp_min <= our_min + 1

|| ball_vel_changed ) )

{

dlog.addText( Logger::COMMUNICATION,

__FILE__": (shouldSayBall) support nearest player" );

return true;

}

#if 0

if ( ball_nearest_teammate

&& second_ball_nearest_teammate

&& ( ball_nearest_teammate->distFromBall() // the ball nearest player

> ServerParam::i().visibleDistance() - 0.5 ) // over vis dist

&& ( second_ball_nearest_teammate->distFromBall() > wm.ball().distFromSelf() - 5.0 ) // I am second

)

{

dlog.addText( Logger::COMMUNICATION,

__FILE__": (shouldSayBall) second nearest to ball" );

return true;

}

#endif

return false;

{

const WorldModel & wm = agent->world();

const PlayerObject * goalie = wm.getOpponentGoalie();

if ( ! goalie )

{

return false;

}

if ( goalie->seenPosCount() == 0

&& goalie->bodyCount() == 0

&& goalie->unum() != Unum_Unknown

&& goalie->unumCount() == 0

&& goalie->distFromSelf() < 25.0

&& 53.0 - 16.0 < goalie->pos().x

&& goalie->pos().x < 52.5

&& goalie->pos().absY() < 20.0 )

{

Vector2D goal_pos = ServerParam::i().theirTeamGoalPos();

Vector2D ball_next = wm.ball().pos() + wm.ball().vel();

if ( ball_next.dist2( goal_pos ) < std::pow( 18.0, 2 ) )

{

return true;

}

}

return false;

{

const WorldModel & wm = agent->world();

if ( ! wm.self().goalie() )

{

return false;

}

int player_count = 0;

const AbstractPlayerCont::const_iterator end = wm.allPlayers().end();

for ( AbstractPlayerCont::const_iterator p = wm.allPlayers().begin();

p != end;

++p )

{

if ( (*p)->unumCount() == 0 )

{

++player_count;

}

}

if ( player_count >= 5 )

{

return true;

}

return false;

{

const WorldModel & wm = agent->world();

const int current_len = agent->effector().getSayMessageLength();

const bool should_say_ball = shouldSayBall( agent );

const bool should_say_goalie = shouldSayOpponentGoalie( agent );

const bool goalie_say_situation = false; //goalieSaySituation( agent );

if ( ! should_say_ball

&& ! should_say_goalie

&& ! goalie_say_situation

&& currentSenderUnum() != wm.self().unum()

&& current_len == 0 )

{

dlog.addText( Logger::COMMUNICATION,

__FILE__": (sayBallAndPlayers) no send situation" );

return false;

}

const int available_len = ServerParam::i().playerSayMsgSize() - current_len;

const AudioMemory & am = wm.audioMemory();

//

// initialize object priority score with fixed value 1000

//

std::vector< ObjectScore > objects( 23 ); // 0: ball, 1-11: teammate, 12-23: opponent

for ( int i = 0; i < 23; ++i )

{

objects[i].number_ = i;

objects[i].score_ = 1000.0;

}

//

// as a base score, set time difference since last hear

//

objects[0].score_ = wm.time().cycle() - am.ballTime().cycle();

{

const AudioMemory::PlayerRecord::const_iterator end = am.playerRecord().end();

for ( AudioMemory::PlayerRecord::const_iterator p = am.playerRecord().begin();

p != end;

++p )

{

int num = p->second.unum_;

if ( num < 1 || 22 < num )

{

continue;

}

objects[num].score_ = wm.time().cycle() - p->first.cycle();

}

}

//

// opponent goalie

//

if ( 1 <= wm.theirGoalieUnum()

&& wm.theirGoalieUnum() <= 11 )

{

int num = wm.theirGoalieUnum() + 11;

double diff = wm.time().cycle() - am.goalieTime().cycle();

objects[num].score_ = std::min( objects[num].score_, diff );

}

#ifdef DEBUG_PRINT

for ( int i = 0; i < 23; ++i )

{

dlog.addText( Logger::COMMUNICATION,

__FILE__": base score: %s %d = %f",

( i == 0 ? "ball" : i <= 11 ? "teammate" : "opponent" ),

( i <= 11 ? i : i - 11 ),

objects[i].score_ );

}

#endif

//

// ball

//

if ( wm.self().isKickable() )

{

if ( agent->effector().queuedNextBallKickable() )

{

objects[0].score_ = -65535.0;

}

else

{

objects[0].score_ = 1000.0;

}

}

else if ( wm.ball().seenPosCount() > 0

|| wm.ball().seenVelCount() > 1

|| wm.existKickableTeammate() )

{

objects[0].score_ = -65535.0;

}

else if ( should_say_ball )

{

objects[0].score_ = 1000.0;

}

else if ( objects[0].score_ > 0.0 )

{

const BallObject::State & prev_state = wm.ball().stateRecord().front();

double angle_diff = ( wm.ball().vel().th() - prev_state.vel_.th() ).abs();

double prev_speed = prev_state.vel_.r();

double cur_speed = wm.ball().vel().r();

if ( cur_speed > prev_speed + 0.1

|| ( prev_speed > 0.5

&& cur_speed < prev_speed * ServerParam::i().ballDecay() * 0.5 )

|| ( prev_speed > 0.5 // Magic Number

&& angle_diff > 20.0 ) ) // Magic Number

{

objects[0].score_ = 1000.0;

}

else

{

objects[0].score_ *= 0.5;

}

}

//

// players:

// 1. set illegal value if player's uniform number has not been seen directry.

// 2. reduced the priority based on the distance from ball

//

{

const double variance = 30.0; // Magic Number

const double x_rate = 1.0; // Magic Number

const double y_rate = 0.5; // Magic Number

const int min_step = std::min( std::min( wm.interceptTable()->opponentReachCycle(),

wm.interceptTable()->teammateReachCycle() ),

wm.interceptTable()->selfReachCycle() );

const Vector2D ball_pos = wm.ball().inertiaPoint( min_step );

for ( int unum = 1; unum <= 11; ++unum )

{

{

const AbstractPlayerObject * t = wm.ourPlayer( unum );

if ( ! t

|| t->unumCount() >= 2 )

{

objects[unum].score_ = -65535.0;

}

else

{

double d = distance_from_ball( t, ball_pos, x_rate, y_rate );

objects[unum].score_ *= distance_rate( d, variance );

objects[unum].score_ *= std::pow( 0.3, t->unumCount() );

objects[unum].player_ = t;

}

}

{

const AbstractPlayerObject * o = wm.theirPlayer( unum );

if ( ! o

|| o->unumCount() >= 2 )

{

objects[unum + 11].score_ = -65535.0;

}

else

{

double d = distance_from_ball( o, ball_pos, x_rate, y_rate );

objects[unum + 11].score_ *= distance_rate( d, variance );

objects[unum].score_ *= std::pow( 0.3, o->unumCount() );

objects[unum + 11].player_ = o;

}

}

}

}

//

// erase illegal(unseen) objects

//

objects.erase( std::remove_if( objects.begin(),

objects.end(),

ObjectScore::IllegalChecker() ),

objects.end() );

//

// sorted by priority score

//

std::sort( objects.begin(), objects.end(),

ObjectScore::Compare() );

#ifdef DEBUG_PRINT

for ( std::vector< ObjectScore >::const_iterator it = objects.begin();

it != objects.end();

++it )

{

// if ( it->score_ < 0.0 ) break;

dlog.addText( Logger::COMMUNICATION,

__FILE__": rated score: %s %d = %f",

( it->number_ == 0 ? "ball" : it->number_ <= 11 ? "teammate" : "opponent" ),

( it->number_ <= 11 ? it->number_ : it->number_ - 11 ),

it->score_ );

}

#endif

bool can_send_ball = false;

bool send_ball_and_player = false;

std::vector< ObjectScore > send_players;

for ( std::vector< ObjectScore >::iterator it = objects.begin();

it != objects.end();

++it )

{

if ( it->number_ == 0 )

{

can_send_ball = true;

if ( send_players.size() == 1 )

{

send_ball_and_player = true;

break;

}

}

else

{

send_players.push_back( *it );

if ( can_send_ball )

{

send_ball_and_player = true;

break;

}

if ( send_players.size() >= 3 )

{

break;

}

}

}

if ( should_say_ball )

{

can_send_ball = true;

}

Vector2D ball_vel = agent->effector().queuedNextBallVel();

if ( wm.self().isKickable()

&& agent->effector().queuedNextBallKickable() )

{

// invalidate ball velocity

ball_vel.assign( 0.0, 0.0 );

dlog.addText( Logger::COMMUNICATION,

__FILE__": (sayBallAndPlayers) next cycle kickable." );

}

if ( wm.existKickableOpponent()

|| wm.existKickableTeammate() )

{

ball_vel.assign( 0.0, 0.0 );

}

//

// send ball only

//

if ( can_send_ball

&& ! send_ball_and_player

&& available_len >= BallMessage::slength() )

{

if ( available_len >= BallPlayerMessage::slength() )

{

agent->addSayMessage( new BallPlayerMessage( agent->effector().queuedNextBallPos(),

ball_vel,

wm.self().unum(),

agent->effector().queuedNextSelfPos(),

agent->effector().queuedNextSelfBody() ) );

updatePlayerSendTime( wm, wm.ourSide(), wm.self().unum() );

}

else

{

agent->addSayMessage( new BallMessage( agent->effector().queuedNextBallPos(),

ball_vel ) );

}

M_ball_send_time = wm.time();

dlog.addText( Logger::COMMUNICATION,

__FILE__": (sayBallAndPlayers) only ball" );

return true;

}

//

// send ball and player

//

if ( send_ball_and_player )

{

if ( should_say_goalie

&& available_len >= BallGoalieMessage::slength() )

{

const PlayerObject * goalie = wm.getOpponentGoalie();

agent->addSayMessage( new BallGoalieMessage( agent->effector().queuedNextBallPos(),

ball_vel,

goalie->pos() + goalie->vel(),

goalie->body() ) );

M_ball_send_time = wm.time();

updatePlayerSendTime( wm, goalie->side(), goalie->unum() );

dlog.addText( Logger::COMMUNICATION,

__FILE__": (sayBallAndPlayers) ball and goalie" );

return true;

}

if ( available_len >= BallPlayerMessage::slength() )

{

const AbstractPlayerObject * p0 = send_players[0].player_;

if ( p0->unum() == wm.self().unum() )

{

agent->addSayMessage( new BallPlayerMessage( agent->effector().queuedNextBallPos(),

ball_vel,

wm.self().unum(),

agent->effector().queuedNextSelfPos(),

agent->effector().queuedNextSelfBody() ) );

}

else

{

agent->addSayMessage( new BallPlayerMessage( agent->effector().queuedNextBallPos(),

ball_vel,

send_players[0].number_,

p0->pos() + p0->vel(),

p0->body() ) );

}

M_ball_send_time = wm.time();

updatePlayerSendTime( wm, p0->side(), p0->unum() );

dlog.addText( Logger::COMMUNICATION,

__FILE__": (sayBallAndPlayers) ball and player %c%d",

p0->side() == wm.ourSide() ? 'T' : 'O', p0->unum() );

return true;

}

}

//

// send players

//

if ( wm.ball().pos().x > 34.0

&& wm.ball().pos().absY() < 20.0 )

{

const PlayerObject * goalie = wm.getOpponentGoalie();

if ( goalie

&& goalie->seenPosCount() == 0

&& goalie->bodyCount() == 0

&& goalie->pos().x > 53.0 - 16.0

&& goalie->pos().absY() < 20.0

&& goalie->unum() != Unum_Unknown

&& goalie->distFromSelf() < 25.0 )

{

if ( available_len >= GoalieAndPlayerMessage::slength() )

{

const AbstractPlayerObject * player = static_cast< AbstractPlayerObject * >( 0 );

for ( std::vector< ObjectScore >::const_iterator it = send_players.begin();

it != send_players.end();

++it )

{

if ( it->player_->unum() != goalie->unum()

&& it->player_->side() != goalie->side() )

{

player = it->player_;

break;

}

}

if ( player )

{

Vector2D goalie_pos = goalie->pos() + goalie->vel();

goalie_pos.x = bound( 53.0 - 16.0, goalie_pos.x, 52.9 );

goalie_pos.y = bound( -19.9, goalie_pos.y, +19.9 );

agent->addSayMessage( new GoalieAndPlayerMessage( goalie->unum(),

goalie_pos,

goalie->body(),

( player->side() == wm.ourSide()

? player->unum()

: player->unum() + 11 ),

player->pos() + player->vel() ) );

updatePlayerSendTime( wm, goalie->side(), goalie->unum() );

updatePlayerSendTime( wm, player->side(), player->unum() );

dlog.addText( Logger::COMMUNICATION,

__FILE__": say goalie and player: goalie=%d (%.2f %.2f) body=%.1f,"

" player=%s[%d] (%.2f %.2f)",

goalie->unum(),

goalie->pos().x,

goalie->pos().y,

goalie->body().degree(),

( player->side() == wm.ourSide() ? "teammate" : "opponent" ),

player->unum() );

return true;

}

}

if ( available_len >= GoalieMessage::slength() )