Merge branch 'robocup_2019' of github.com:UBC-Thunderbots/Software into robocup_2019

Author: MathewMacDougall

src/thunderbots/software/ai/hl/stp/play/defense_play.cpp

@@ -50,7 +50,7 @@ void DefensePlay::getNextTactics(TacticCoroutine::push_type &yield)
 
     std::shared_ptr<ShadowEnemyTactic> shadow_enemy_tactic =
         std::make_shared<ShadowEnemyTactic>(world.field(), world.friendlyTeam(),
-                                            world.enemyTeam(), true, true);
+                                            world.enemyTeam(), true, world.ball(), true);
 
 
     std::array<std::shared_ptr<CreaseDefenderTactic>, 2> crease_defender_tactics = {
@@ -153,7 +153,8 @@ void DefensePlay::getNextTactics(TacticCoroutine::push_type &yield)
         if (enemy_threats.size() > 1) {
             shadow_enemy_tactic->updateParams(
                     enemy_threats.at(1), world.field(), world.friendlyTeam(),
-                    world.enemyTeam(), ROBOT_MAX_RADIUS_METERS * 3, enemy_team_can_pass);
+                    world.enemyTeam(), ROBOT_MAX_RADIUS_METERS * 3,
+                    enemy_team_can_pass, world.ball());
             result.emplace_back(shadow_enemy_tactic);
         } else {
             Robot nearest_enemy_robot = *std::min_element(

src/thunderbots/software/ai/hl/stp/play/enemy_freekick_play.cpp

@@ -53,9 +53,9 @@ void EnemyFreekickPlay::getNextTactics(TacticCoroutine::push_type &yield)
 
     // Init Shadow Enemy Tactics for extra robots
     auto shadow_tactic_main = std::make_shared<ShadowEnemyTactic>(
-        world.field(), world.friendlyTeam(), world.enemyTeam(), true, true);
+        world.field(), world.friendlyTeam(), world.enemyTeam(), true, world.ball(), true);
     auto shadow_tactic_secondary = std::make_shared<ShadowEnemyTactic>(
-        world.field(), world.friendlyTeam(), world.enemyTeam(), true, true);
+        world.field(), world.friendlyTeam(), world.enemyTeam(), true, world.ball(), true);
 
     // Init Move Tactics for extra robots (These will be used if there are no robots to
     // shadow)
@@ -114,7 +114,7 @@ void EnemyFreekickPlay::getNextTactics(TacticCoroutine::push_type &yield)
         {
             shadow_tactic_main->updateParams(
                 enemy_threats.at(1), world.field(), world.friendlyTeam(),
-                world.enemyTeam(), ROBOT_MAX_RADIUS_METERS * 3, enemy_team_can_pass);
+                world.enemyTeam(), ROBOT_MAX_RADIUS_METERS * 3, enemy_team_can_pass, world.ball());
             move_tactic_main->updateParams(
                 world.field().friendlyGoal() + Point(0, 2 * ROBOT_MAX_RADIUS_METERS),
                 (world.ball().position() - world.field().friendlyGoal()).orientation(),
@@ -127,10 +127,10 @@ void EnemyFreekickPlay::getNextTactics(TacticCoroutine::push_type &yield)
         {
             shadow_tactic_main->updateParams(
                 enemy_threats.at(1), world.field(), world.friendlyTeam(),
-                world.enemyTeam(), ROBOT_MAX_RADIUS_METERS * 3, enemy_team_can_pass);
+                world.enemyTeam(), ROBOT_MAX_RADIUS_METERS * 3, enemy_team_can_pass, world.ball());
             shadow_tactic_secondary->updateParams(
                 enemy_threats.at(2), world.field(), world.friendlyTeam(),
-                world.enemyTeam(), ROBOT_MAX_RADIUS_METERS * 3, enemy_team_can_pass);
+                world.enemyTeam(), ROBOT_MAX_RADIUS_METERS * 3, enemy_team_can_pass, world.ball());
 
             tactics_to_run.emplace_back(shadow_tactic_main);
             tactics_to_run.emplace_back(shadow_tactic_secondary);

src/thunderbots/software/ai/hl/stp/play/kickoff_enemy_play.cpp

@@ -35,11 +35,11 @@ void KickoffEnemyPlay::getNextTactics(TacticCoroutine::push_type &yield)
     // on the field to be evenly spread out
     std::vector<std::shared_ptr<ShadowEnemyTactic>> shadow_enemy_tactics = {
         std::make_shared<ShadowEnemyTactic>(world.field(), world.friendlyTeam(),
-                                            world.enemyTeam(), true, true),
+                                            world.enemyTeam(), true, world.ball(), true),
         std::make_shared<ShadowEnemyTactic>(world.field(), world.friendlyTeam(),
-                                            world.enemyTeam(), true, true),
+                                            world.enemyTeam(), true, world.ball(), true),
         std::make_shared<ShadowEnemyTactic>(world.field(), world.friendlyTeam(),
-                                            world.enemyTeam(), true, true)};
+                                            world.enemyTeam(), true, world.ball(), true)};
 
     // these positions are picked according to the following slide
     // https://images.slideplayer.com/32/9922349/slides/slide_2.jpg
@@ -118,7 +118,7 @@ void KickoffEnemyPlay::getNextTactics(TacticCoroutine::push_type &yield)
                 // anyway
                 shadow_enemy_tactics.at(i)->updateParams(
                     enemy_threat, world.field(), world.friendlyTeam(), world.enemyTeam(),
-                    shadow_dist, false);
+                    shadow_dist, false, world.ball());
                 result.emplace_back(shadow_enemy_tactics.at(i));
             }
             else

src/thunderbots/software/ai/hl/stp/tactic/penalty_kick_tactic.cpp

@@ -134,7 +134,7 @@ void PenaltyKickTactic::calculateNextIntent(IntentCoroutine::push_type& yield)
 
         auto [shot_location, extra] = raySegmentIntersection(shot_ray, Segment(field.enemyGoalpostPos(), field.enemyGoalpostNeg()));
 
-        if(!evaluate_penalty_shot() && !YEET_SHOOTING) {
+        if(!evaluate_penalty_shot() && !YEET_SHOOTING && !((robot->getMostRecentTimestamp() - start_of_shoot) > Duration::fromSeconds(7))) {
             printf("\nGetting to position");
             yield(get_behind_ball_act.updateStateAndGetNextIntent(*robot, behind_ball, robot->orientation(), 0, true, false, AutokickType::NONE));
             printf("evaluate shot %d", evaluate_penalty_shot());

src/thunderbots/software/ai/hl/stp/tactic/shadow_enemy_tactic.cpp

@@ -4,15 +4,18 @@
 #include "ai/hl/stp/action/stop_action.h"
 #include "ai/hl/stp/evaluation/calc_best_shot.h"
 #include "shadow_enemy_tactic.h"
+#include "ai/hl/stp/evaluation/robot.h"
+#include "util/parameter/dynamic_parameters.h"
 
 ShadowEnemyTactic::ShadowEnemyTactic(const Field &field, const Team &friendly_team,
-                                     const Team &enemy_team, bool ignore_goalie,
+                                     const Team &enemy_team, bool ignore_goalie, const Ball& ball,
                                      bool loop_forever)
     : field(field),
       friendly_team(friendly_team),
       enemy_team(enemy_team),
       shadow_distance(ROBOT_MAX_RADIUS_METERS * 3),
       ignore_goalie(ignore_goalie),
+      ball(ball),
       Tactic(loop_forever)
 {
 }
@@ -25,14 +28,15 @@ std::string ShadowEnemyTactic::getName() const
 void ShadowEnemyTactic::updateParams(const Evaluation::EnemyThreat &enemy_threat,
                                      const Field &field, const Team &friendly_team,
                                      const Team &enemy_team, double shadow_distance,
-                                     bool enemy_team_can_pass)
+                                     bool enemy_team_can_pass, const Ball& ball)
 {
     this->enemy_threat        = enemy_threat;
     this->field               = field;
     this->friendly_team       = friendly_team;
     this->enemy_team          = enemy_team;
     this->shadow_distance     = shadow_distance;
     this->enemy_team_can_pass = enemy_team_can_pass;
+    this->ball = ball;
 }
 
 double ShadowEnemyTactic::calculateRobotCost(const Robot &robot, const World &world)
@@ -94,11 +98,23 @@ void ShadowEnemyTactic::calculateNextIntent(IntentCoroutine::push_type &yield)
             {
                 enemy_shot_vector = field.friendlyGoal() - enemy_robot.position();
             }
+
             Point position_to_block_shot =
-                enemy_robot.position() + enemy_shot_vector.norm(this->shadow_distance);
-            yield(move_action.updateStateAndGetNextIntent(
-                *robot, position_to_block_shot,
-                enemy_shot_vector.orientation() + Angle::half(), 0));
+                    enemy_robot.position() + enemy_shot_vector.norm(this->shadow_distance);
+
+            // try to steal the ball and yeet it away if the enemy robot has already
+            // received the pass
+            if (Evaluation::robotHasPossession(ball, enemy_robot) && ball.velocity().len() <
+                                                                     Util::DynamicParameters::DefenseShadowEnemyTactic::ball_steal_speed.value()) {
+                yield(move_action.updateStateAndGetNextIntent(
+                        *robot, ball.position(),
+                        (ball.position() - robot->position()).orientation(), 0,
+                        true, false, AutokickType::AUTOCHIP));
+            } else {
+                yield(move_action.updateStateAndGetNextIntent(
+                        *robot, position_to_block_shot,
+                        enemy_shot_vector.orientation() + Angle::half(), 0));
+            }
         }
     } while (!move_action.done());
 }

src/thunderbots/software/ai/hl/stp/tactic/shadow_enemy_tactic.h

@@ -23,7 +23,7 @@ class ShadowEnemyTactic : public Tactic
      * tactic will be restarted every time it completes
      */
     explicit ShadowEnemyTactic(const Field &field, const Team &friendly_team,
-                               const Team &enemy_team, bool ignore_goalie,
+                               const Team &enemy_team, bool ignore_goalie, const Ball& ball,
                                bool loop_forever = false);
 
     std::string getName() const override;
@@ -45,7 +45,7 @@ class ShadowEnemyTactic : public Tactic
      */
     void updateParams(const Evaluation::EnemyThreat &enemy_threat, const Field &field,
                       const Team &friendly_team, const Team &enemy_team,
-                      double shadow_distance, bool enemy_team_can_pass);
+                      double shadow_distance, bool enemy_team_can_pass, const Ball& ball);
 
     /**
      * Calculates the cost of assigning the given robot to this Tactic. Prefers robots
@@ -77,4 +77,5 @@ class ShadowEnemyTactic : public Tactic
     // Whether or not to ignore the friendly goalie when calculating the enemy's best shot
     // to shadow
     bool ignore_goalie;
+    Ball ball;
 };