score_bms.c

Brainstormers(头脑风暴)队是05年robocup冠军,这是05年Brainstormers公布的源代码,Brainstormers是robocup老牌的德国强队

    //LOG_DEB(0, << "don't shoot, wrong angle");
    return 0;
  }
  
  Vector test_targets[9];
  Value test_dirs[9];
  Value test_vels_1step[9];
  Value test_vels_multi[9];
  int one_step_kick_possible[9];
  int multi_kick_possible[9];
  int secure_1step_kick_possible[9];
  int secure_multi_kick_possible[9];
  int ball_steps_to_goal[9];
  int ret = 0;

  Vector ball_pos = WSinfo::ball->pos;

#if 0 // ridi 22.6.03 : replaced by new access to goalie
  WSpset alive_opps = WSinfo::alive_opponents;
  PPlayer goalie = alive_opps.get_player_by_number(WSinfo::ws->his_goalie_number);
#endif

  PPlayer goalie =WSinfo::his_goalie;

  if (goalie == NULL) {
    ret = 5;
    WSpset valid_opps = WSinfo::valid_opponents;
    valid_opps.keep_and_sort_closest_players_to_point(1, mdpInfo::opponent_goalpos());
    if (valid_opps.num <= 0) {
      return 6;
    }
    goalie = valid_opps[0];
  }

  Vector goalie_pos = goalie->pos;
  int goalie_age = goalie->age;
  Vector goalie_vel = goalie->vel;
  int goalie_vel_age = goalie->age_vel;
  
  Value goalie_initial_size = goalshot_param1;//0.4


  if (((ball_pos-goalie_pos).norm() > 20.0) &&
      (Tools::get_angle_between_null_2PI(((ServerOptions::their_left_goal_corner-ball_pos).arg() - 
					  (goalie_pos-ball_pos).arg())) < M_PI) &&
      (Tools::get_angle_between_null_2PI(((goalie_pos-ball_pos).arg() - 
					  (ServerOptions::their_right_goal_corner-ball_pos).arg()))<M_PI)) {
    LOG_DAN(0, << "don't consider shooting, goalie is on place and I'm too far away!");
    return 0;
  }

  consider_special_cases(goalie_age, goalie_vel_age, goalie_vel, goalie_initial_size, goalie_pos, goalie);

  fill_target_arrays(test_targets, test_dirs, 9, ball_pos);

  //fill_velocity_arrays(test_vels_1step, test_vels_multi, test_dirs, 9);
  fill_velocity_arrays(test_vels_1step, test_vels_multi, test_targets, 9);

  Vector kick_vel;
  int goalie_intercepts = 0;
  int player_intercepts = 0;
  int best_kick = -1;
  int kick_found = 0;

  Value goalie_size = goalie_initial_size;

  //test for multi-step-kicks, use current goalie-pos(even if old)
  for (int i = 0; i < 9; i++) {
    kick_vel.init_polar(test_vels_multi[i], test_dirs[i]);
    goalie_intercepts = intercept_goalie(ball_pos, kick_vel, goalie_pos, goalie_size + 0.3);
    if (goalie_intercepts <= 0) {
      multi_kick_possible[i] = 1;
      kick_found = 1;
    } else {
      multi_kick_possible[i] = 0;
    }
    /*
    LOG_DAN(0, << _2D << L2D( ball_pos.x, ball_pos.y, ball_pos.x + kick_vel.x * 3.0, 
			      ball_pos.y + kick_vel.y * 3.0, "#ff0000" ));
    */
  }

  //no multi-kick found => no single kick is possible, return!
  //if (!kick_found) return 0;
  
  for (int i = 0; i < 9; i++) {
    //only test for 1step-kick if multi-step-kick could be succesful
    /*
    if (!multi_kick_possible[i]) {
      one_step_kick_possible[i] = 0;
      continue;
      }*/

    kick_vel.init_polar(test_vels_1step[i], test_dirs[i]);
    goalie_intercepts = intercept_goalie(ball_pos, kick_vel, goalie_pos, goalie_size);
    ball_steps_to_goal[i] = goalie_intercepts;
    if (goalie_intercepts <= 0) {
      one_step_kick_possible[i] = 1;
      kick_found = 1;
    } else {
      one_step_kick_possible[i] = 0;
    }
  }

  //no kick found => return!
  if (!kick_found) return 0;

  if ((goalie_age <= 4) &&
      (goalie_age >= 1)) {
    Value goalie_dir = (goalie->pos - ball_pos).arg();
    int top_of_goalie_shots = 0, bottom_of_goalie_shots = 0;
    for (int i = 0; i < 9; ++i) {
      if (multi_kick_possible[i]) {
	if (Tools::get_angle_between_null_2PI(test_dirs[i]-goalie_dir) < M_PI) {
	  ++top_of_goalie_shots;
	} else {
	  ++bottom_of_goalie_shots;
	}
      }
    }
    //shots on both sides of goalie are possible => goalie can't cover the whole goal, even if he
    //moved, declare the shots with old goalie-pos as secure!
    if ((top_of_goalie_shots > 0) && (bottom_of_goalie_shots > 0)) {
      LOG_DAN(0, << "goalie is old, but shots on both sides of goalie are possible, use old goalie-pos");
      for (int i = 0; i < 9; ++i) {
	secure_multi_kick_possible[i] = multi_kick_possible[i];
	secure_1step_kick_possible[i] = one_step_kick_possible[i];
      }
      //hack: don't consider the other shots below
      goalie_age = 0;
    }
  }

  if (goalie_age <= 4) {
    goalie_size = goalie_initial_size + 0.8 * goalie_age;
  } else {
    //no special case here
    goalie_size = goalie_initial_size + 0.8 * goalie_age;
  }

  LOG_DAN(0, << "goalie_age ist " << goalie_age);
  LOG_DAN(0, << "goalie_size ist " << goalie_size);

  if (goalie_age >= 1) {

    for (int i = 0; i < 9; ++i) {
      kick_vel.init_polar(test_vels_multi[i], test_dirs[i]);
      goalie_intercepts = intercept_goalie(ball_pos, kick_vel, goalie_pos, goalie_size);
      if (goalie_intercepts <= 0) {
	secure_multi_kick_possible[i] = 1;
      } else {
	secure_multi_kick_possible[i] = 0;
      }
    }

    for (int i = 0; i < 9; ++i) {
      if (!secure_multi_kick_possible[i]) {
	secure_1step_kick_possible[i] = 0;
	continue;
      }
      kick_vel.init_polar(test_vels_1step[i], test_dirs[i]);
      goalie_intercepts = intercept_goalie(ball_pos, kick_vel, goalie_pos, goalie_size);
      if (goalie_intercepts <= 0) {
	secure_1step_kick_possible[i] = 1;
      } else {
	secure_1step_kick_possible[i] = 0;
      }
    }

  } else {
    for (int i = 0; i < 9; ++i) {
      secure_multi_kick_possible[i] = multi_kick_possible[i];
      secure_1step_kick_possible[i] = one_step_kick_possible[i];
    }
  }

  //test if opponent could intercept
  for (int i = 0; i < 9; ++i) {
    //if (!multi_kick_possible[i]) continue;
    
    player_intercepts = intercept_opponents(test_dirs[i], test_vels_multi[i], -ball_steps_to_goal[i]);
    if (player_intercepts) {
      LOG_DAN(0, << "opponent number " << player_intercepts 
	      << " intercepts ball before goalline, don't shoot!");
      multi_kick_possible[i] = 0;
      secure_multi_kick_possible[i] = 0;
      one_step_kick_possible[i] = 0;
      secure_1step_kick_possible[i] = 0;
    }
  }


  int one_step_kick_found = 0, multi_kick_found = 0;
  int secure_1step_kick_found = 0, secure_multi_kick_found = 0;


  for (int i = 0; i < 9; ++i) {
    if (secure_multi_kick_possible[i]) ++secure_multi_kick_found;
    if (secure_1step_kick_possible[i]) ++secure_1step_kick_found;
    if (multi_kick_possible[i]) ++multi_kick_found;
    if (one_step_kick_possible[i]) ++one_step_kick_found;
  }

  //select best kick
  if (secure_multi_kick_found != 0) {

    if ((secure_multi_kick_found > secure_1step_kick_found) ||
	(secure_1step_kick_found == 0)) {
      //if ((mdpInfo::opponents_within_range(WSinfo::me->pos, 2.0) == 0) || 
      //(secure_1step_kick_found == 0) ||
      //(secure_multi_kick_found > secure_1step_kick_found)) {

      best_kick = select_best_kick(secure_multi_kick_possible, 9);
      multi_step = 1;
      velocity = test_vels_multi[best_kick];
      direction = test_dirs[best_kick];
      target = test_targets[best_kick];
      if (ret == 0) {
	if (best_kick >= 7) {
	  ret = 4;
	} else {
	  ret = 1;
	}
      }
    } else {
      best_kick = select_best_kick(secure_1step_kick_possible, 9);
      multi_step = 0;
      velocity = test_vels_1step[best_kick];
      direction = test_dirs[best_kick];
      target = test_targets[best_kick];
      if (ret == 0) {
	if (best_kick >= 7) {
	  ret = 4;
	} else {
	  ret = 1;
	}
      }
    }

  } else if (secure_1step_kick_found != 0) {

    best_kick = select_best_kick(secure_1step_kick_possible, 9);
    multi_step = 0;
    velocity = test_vels_1step[best_kick];
    direction = test_dirs[best_kick];
    target = test_targets[best_kick];
    if (ret == 0) {
      if (best_kick >= 7) {
	ret = 4;
      } else {
	ret = 1;
      }
    }

  } else if (multi_kick_found != 0) {

    if ((multi_kick_found-1 > one_step_kick_found) ||
	(one_step_kick_found == 0)) {
      best_kick = select_best_kick(multi_kick_possible, 9);
      multi_step = 1;
      velocity = test_vels_multi[best_kick];
      direction = test_dirs[best_kick];
      target = test_targets[best_kick];
      if (ret == 0) {
	ret = 2;
      }
    } else {
      best_kick = select_best_kick(one_step_kick_possible, 9);
      multi_step = 0;
      velocity = test_vels_1step[best_kick];
      direction = test_dirs[best_kick];
      target = test_targets[best_kick];
      if (ret == 0) {
	ret = 2;
      }
    }

  } else if (one_step_kick_found != 0) {

    best_kick = select_best_kick(one_step_kick_possible, 9);
    multi_step = 0;
    velocity = test_vels_1step[best_kick];
    direction = test_dirs[best_kick];
    target = test_targets[best_kick];
    if (ret == 0) {
      ret = 2;
    }

  }

  kick_vel.init_polar(test_vels_multi[best_kick], test_dirs[best_kick]);
  LOG_DAN(0, << "selected kick nr. " << best_kick << " as best kick");

  LOG_DAN(0, << _2D << L2D( ball_pos.x, ball_pos.y, ball_pos.x + kick_vel.x * 3.0, 
			    ball_pos.y + kick_vel.y * 3.0, "ffffff" ));    
  LOG_DAN(0, << "return value is " << ret);
  best_index = best_kick;
  return ret;
}

void Score::fill_velocity_arrays(Value *test_vels_1step, Value *test_vels_multi, 
						 Vector *test_targets, int nr_of_targets) {
  Value one_step_vel, multi_step_vel;

  for (int i = 0; i < nr_of_targets; ++i) {
    //Move_1or2_Step_Kick::get_vel_in_dir(3.0, test_dirs[i], one_step_vel, multi_step_vel);
    //oneortwo->get_vel_in_dir(3.0, test_dirs[i], one_step_vel, multi_step_vel);
    //oneortwo->get_vel_in_dir(3.0, test_dirs[i], one_step_vel, multi_step_vel);

    //oneortwo->kick_in_dir_with_max_vel(ANGLE(test_dirs[i]));
    oneortwo->kick_to_pos_with_max_vel(test_targets[i]);
    oneortwo->get_vel(one_step_vel, multi_step_vel);
    //oneortwo->get_vel(one_step_vel, multi_step_vel);


    //if (one_step_vel > ServerOptions::ball_speed_max * ServerOptions::ball_decay)
    if (one_step_vel > ServerOptions::ball_speed_max)
      one_step_vel = ServerOptions::ball_speed_max;
    //if (multi_step_vel > ServerOptions::ball_speed_max * ServerOptions::ball_decay)
    if (multi_step_vel > ServerOptions::ball_speed_max)
      multi_step_vel = ServerOptions::ball_speed_max;

    if (multi_step_vel < one_step_vel) {
      LOG_DAN(0, << "ERROR!!!! multi_step_vel smaller than one_step_vel!");
    }

    test_vels_1step[i] = one_step_vel;
    test_vels_multi[i] = multi_step_vel;  
    //test_vels_multi[i] = 2.5;
  }

}


void Score::fill_target_arrays(Vector *test_targets, Value *test_dirs, 
					       int nr_of_targets, Vector ball_pos) {

  Vector upper_corner = Vector(ServerOptions::pitch_length/2.0, ServerOptions::goal_width/2.0);
  Vector lower_corner = Vector(upper_corner.x, -upper_corner.y);


  Value ang_diff = Tools::get_angle_between_null_2PI( (upper_corner-WSinfo::ball->pos).arg() - 
						      (lower_corner-WSinfo::ball->pos).arg() );

  Value safety_threshold = DEG2RAD(3.0);
  LOG_DAN(0, "ang_diff ist " << RAD2DEG(ang_diff));
  if ((ball_pos.x > 25.0) && (ang_diff < DEG2RAD(10.0))) {
    safety_threshold = ang_diff / 6.0;
  } else if (ang_diff < DEG2RAD(8.0)) {
    safety_threshold = ang_diff/8.0;
  }

  Value delta_ang = Tools::get_angle_between_null_2PI(ang_diff - 2.0*safety_threshold) / 6.0; 
  
  Value upper_secure_arg = Tools::get_angle_between_null_2PI((upper_corner-WSinfo::ball->pos).arg() - 
							     safety_threshold);