Shadow Defense Base (UBC-Thunderbots#3450)

Author: zuperzane

docs/fsm-diagrams.md

@@ -71,7 +71,10 @@ stateDiagram-v2
 classDef terminate fill:white,color:black,font-weight:bold
 direction LR
 [*] --> DefenseState
-DefenseState --> DefenseState : <i>defendAgainstThreats</i>
+DefenseState --> AggressiveDefenseState : [shouldDefendAggressively]\n<i>shadowAndBlockShots</i>
+DefenseState --> DefenseState : <i>blockShots</i>
+AggressiveDefenseState --> DefenseState : [!shouldDefendAggressively]\n<i>blockShots</i>
+AggressiveDefenseState --> AggressiveDefenseState : <i>shadowAndBlockShots</i>
 Terminate:::terminate --> Terminate:::terminate
 
 ```
@@ -487,12 +490,16 @@ classDef terminate fill:white,color:black,font-weight:bold
 direction LR
 [*] --> MoveFSM
 MoveFSM --> BlockPassState : [!enemyThreatHasBall]\n<i>blockPass</i>
+MoveFSM --> GoAndStealState : [blockedShot]\n<i>goAndSteal</i>
 MoveFSM --> MoveFSM : <i>blockShot</i>
-MoveFSM --> StealAndChipState
+MoveFSM --> GoAndStealState
 BlockPassState --> BlockPassState : [!enemyThreatHasBall]\n<i>blockPass</i>
 BlockPassState --> MoveFSM : [enemyThreatHasBall]\n<i>blockShot</i>
-StealAndChipState --> StealAndChipState : [enemyThreatHasBall]\n<i>stealAndChip</i>
-StealAndChipState --> Terminate:::terminate : [!enemyThreatHasBall]\n<i>blockPass</i>
+GoAndStealState --> GoAndStealState : [enemyThreatHasBall && !contestedBall]\n<i>goAndSteal</i>
+GoAndStealState --> StealAndPullState : [enemyThreatHasBall && contestedBall]\n<i>goAndSteal</i>
+GoAndStealState --> Terminate:::terminate : [!enemyThreatHasBall]\n<i>blockPass</i>
+StealAndPullState --> StealAndPullState : [enemyThreatHasBall]\n<i>stealAndPull</i>
+StealAndPullState --> Terminate:::terminate : [!enemyThreatHasBall]\n<i>blockPass</i>
 Terminate:::terminate --> BlockPassState : [!enemyThreatHasBall]\n<i>blockPass</i>
 Terminate:::terminate --> MoveFSM : [enemyThreatHasBall]\n<i>blockShot</i>
 Terminate:::terminate --> Terminate:::terminate : <i>SET_STOP_PRIMITIVE_ACTION</i>

src/proto/parameters.proto

@@ -528,7 +528,7 @@ message DefensePlayConfig
 
         // The max number of crease defender can be created at a moment
         required uint32 max_num_crease_defenders = 6
-            [default = 1, (bounds).min_int_value = 1, (bounds).max_int_value = 3];
+            [default = 2, (bounds).min_int_value = 1, (bounds).max_int_value = 3];
     }
 
     // The distance at which a threat is considered "immediate" if there is only 1

src/software/ai/evaluation/defender_assignment.h

@@ -10,7 +10,8 @@
 enum DefenderAssignmentType
 {
     CREASE_DEFENDER,
-    PASS_DEFENDER
+    PASS_DEFENDER,
+    SHADOW_ENEMY
 };
 
 // This struct stores the concept of a defender assignment, which describes

src/software/ai/hl/stp/play/defense/BUILD

@@ -23,6 +23,7 @@ cc_library(
         "//software/ai/hl/stp/play/defense:defense_play_base",
         "//software/ai/hl/stp/tactic/crease_defender:crease_defender_tactic",
         "//software/ai/hl/stp/tactic/pass_defender:pass_defender_tactic",
+        "//software/ai/hl/stp/tactic/shadow_enemy:shadow_enemy_tactic",
         "//software/logger",
         "//software/util/generic_factory",
         "@sml",

src/software/ai/hl/stp/play/defense/defense_play_base.cpp

@@ -4,7 +4,7 @@
 #include "software/ai/evaluation/enemy_threat.h"
 
 DefensePlayFSMBase::DefensePlayFSMBase(TbotsProto::AiConfig ai_config)
-    : ai_config(ai_config), crease_defenders({}), pass_defenders({})
+    : ai_config(ai_config), crease_defenders({}), pass_defenders({}), shadowers({})
 {
 }
 

src/software/ai/hl/stp/play/defense/defense_play_base.h

@@ -69,4 +69,5 @@ class DefensePlayFSMBase
     TbotsProto::AiConfig ai_config;
     std::vector<std::shared_ptr<CreaseDefenderTactic>> crease_defenders;
     std::vector<std::shared_ptr<PassDefenderTactic>> pass_defenders;
+    std::vector<std::shared_ptr<ShadowEnemyTactic>> shadowers;
 };

src/software/ai/hl/stp/play/defense/defense_play_fsm.cpp

@@ -2,24 +2,71 @@
 
 #include "software/ai/evaluation/defender_assignment.h"
 #include "software/ai/evaluation/enemy_threat.h"
+#include "software/logger/logger.h"
+
 
 DefensePlayFSM::DefensePlayFSM(TbotsProto::AiConfig ai_config)
     : DefensePlayFSMBase::DefensePlayFSMBase(ai_config)
 {
 }
 
-void DefensePlayFSM::defendAgainstThreats(const Update& event)
+bool DefensePlayFSM::shouldDefendAggressively(const Update& event)
+{
+    // If there is more attackers ahead of the ball than there
+    // are our own defenders we won't press
+
+    auto attackers = std::count_if(
+        event.common.world_ptr->enemyTeam().getAllRobots().begin(),
+        event.common.world_ptr->enemyTeam().getAllRobots().end(),
+        [event](const Robot& robot)
+        { return robot.position().x() < event.common.world_ptr->ball().position().x(); });
+
+    auto defenders = std::count_if(
+        event.common.world_ptr->friendlyTeam().getAllRobots().begin(),
+        event.common.world_ptr->friendlyTeam().getAllRobots().end(),
+        [event](const Robot& robot)
+        { return robot.position().x() < event.common.world_ptr->ball().position().x(); });
+
+    return defenders > attackers;
+}
+
+void DefensePlayFSM::blockShots(const Update& event)
 {
     auto enemy_threats = getAllEnemyThreats(
         event.common.world_ptr->field(), event.common.world_ptr->friendlyTeam(),
         event.common.world_ptr->enemyTeam(), event.common.world_ptr->ball(), false);
 
+    updateCreaseAndPassDefenders(event, enemy_threats);
+    updateShadowers(event, {});
+
+    setTactics(event);
+}
+
+void DefensePlayFSM::shadowAndBlockShots(const Update& event)
+{
+    auto enemy_threats = getAllEnemyThreats(
+        event.common.world_ptr->field(), event.common.world_ptr->friendlyTeam(),
+        event.common.world_ptr->enemyTeam(), event.common.world_ptr->ball(), false);
+
+    updateCreaseAndPassDefenders(event, enemy_threats);
+
+    if (pass_defenders.size() > 0)
+    {
+        pass_defenders.erase(pass_defenders.begin());
+        updateShadowers(event, {enemy_threats.front()});
+    }
+
+    setTactics(event);
+}
+
+void DefensePlayFSM::updateCreaseAndPassDefenders(
+    const Update& event, const std::vector<EnemyThreat>& enemy_threats)
+{
     auto defender_assignment_config =
         ai_config.defense_play_config().defender_assignment_config();
     auto assignments = getAllDefenderAssignments(
         enemy_threats, event.common.world_ptr->field(), event.common.world_ptr->ball(),
         defender_assignment_config);
-
     if (assignments.size() == 0)
     {
         return;
@@ -75,11 +122,43 @@ void DefensePlayFSM::defendAgainstThreats(const Update& event)
     setAlignment(event, crease_defender_assignments, TbotsProto::BallStealMode::STEAL);
     updatePassDefenderControlParams(pass_defender_assignments,
                                     TbotsProto::BallStealMode::STEAL);
+}
+
+void DefensePlayFSM::updateShadowers(const Update& event,
+                                     const std::vector<EnemyThreat>& threats_to_shadow)
+{
+    setUpShadowers(static_cast<unsigned int>(threats_to_shadow.size()));
+
+    for (unsigned int i = 0; i < shadowers.size(); i++)
+    {
+        shadowers.at(i)->updateControlParams(threats_to_shadow.at(i),
+                                             ROBOT_SHADOWING_DISTANCE_METERS);
+    }
+}
+
+
+void DefensePlayFSM::setUpShadowers(int num_shadowers)
+{
+    if (num_shadowers == static_cast<int>(shadowers.size()))
+    {
+        return;
+    }
+
+    shadowers = std::vector<std::shared_ptr<ShadowEnemyTactic>>(num_shadowers);
+    std::generate(shadowers.begin(), shadowers.end(),
+                  [this]() { return std::make_shared<ShadowEnemyTactic>(); });
+}
+
+void DefensePlayFSM::setTactics(const Update& event)
+{
+    PriorityTacticVector tactics_to_return = {{}, {}, {}};
 
-    PriorityTacticVector tactics_to_return = {{}, {}};
     tactics_to_return[0].insert(tactics_to_return[0].end(), crease_defenders.begin(),
                                 crease_defenders.end());
     tactics_to_return[1].insert(tactics_to_return[1].end(), pass_defenders.begin(),
                                 pass_defenders.end());
+    tactics_to_return[2].insert(tactics_to_return[2].end(), shadowers.begin(),
+                                shadowers.end());
+
     event.common.set_tactics(tactics_to_return);
 }

src/software/ai/hl/stp/play/defense/defense_play_fsm.h

@@ -6,40 +6,110 @@
 #include "software/ai/hl/stp/play/play_fsm.h"
 #include "software/ai/hl/stp/tactic/crease_defender/crease_defender_tactic.h"
 #include "software/ai/hl/stp/tactic/pass_defender/pass_defender_tactic.h"
+#include "software/ai/hl/stp/tactic/shadow_enemy/shadow_enemy_tactic.h"
 #include "software/logger/logger.h"
 
 struct DefensePlayFSM : public DefensePlayFSMBase
 {
     class DefenseState;
-
+    class AggressiveDefenseState;
     /**
      * Creates a defense play FSM
      *
      * @param ai_config the play config for this play FSM
      */
     explicit DefensePlayFSM(TbotsProto::AiConfig ai_config);
 
+    /**
+     * Guard to check whether we should be defending more aggressively
+     *
+     * @param event the FSM event
+     *
+     * @return whether we should be defending more aggressively
+     */
+    bool shouldDefendAggressively(const Update& event);
+
     /**
      * Action to identify all immediate enemy threats and assign
      * defenders to block enemy shots and passes
      *
      * @param event the FSM event
      */
-    void defendAgainstThreats(const Update& event);
+    void blockShots(const Update& event);
+
+    /**
+     * Action to shadow the primary enemy threat and assign
+     * extra defenders to block enemy shots and passes
+     *
+     * @param event the FSM event
+     */
+    void shadowAndBlockShots(const Update& event);
+
+    /**
+     * Helper function to update crease and pass defenders to defend
+     * against specified threats
+     *
+     * @param event the FSM event
+     * @param enemy_threats the enemy threats to defend against
+     */
+    void updateCreaseAndPassDefenders(const Update& event,
+                                      const std::vector<EnemyThreat>& enemy_threats);
+
+    /**
+     * Helper function to update shadowers to shadow specified threats
+     *
+     * @param event the FSM event
+     * @param threats_to_shadow the enemy threats to shadow
+     */
+    void updateShadowers(const Update& event,
+                         const std::vector<EnemyThreat>& threats_to_shadow);
+
+
+    /**
+     * Helper function to set up shadow enemy tactic vector members
+     *
+     * @param num_shadowers the number of shadow enemy tactics to set
+     */
+    void setUpShadowers(int num_shadowers);
+
+    /**
+     * Helper function to return the next tactics
+     *
+     * @param event the FSM event
+     */
+    void setTactics(const Update& event);
+
+
 
     auto operator()()
     {
         using namespace boost::sml;
 
         DEFINE_SML_STATE(DefenseState)
+        DEFINE_SML_STATE(AggressiveDefenseState)
 
         DEFINE_SML_EVENT(Update)
 
-        DEFINE_SML_ACTION(defendAgainstThreats)
+        DEFINE_SML_GUARD(shouldDefendAggressively)
+
+        DEFINE_SML_ACTION(blockShots)
+        DEFINE_SML_ACTION(shadowAndBlockShots)
 
         return make_transition_table(
             // src_state + event [guard] / action = dest_state
-            *DefenseState_S + Update_E / defendAgainstThreats_A = DefenseState_S,
-            X + Update_E                                        = X);
+
+            *DefenseState_S + Update_E[shouldDefendAggressively_G] /
+                                  shadowAndBlockShots_A = AggressiveDefenseState_S,
+            DefenseState_S + Update_E / blockShots_A    = DefenseState_S,
+            AggressiveDefenseState_S +
+                Update_E[!shouldDefendAggressively_G] / blockShots_A = DefenseState_S,
+            AggressiveDefenseState_S + Update_E / shadowAndBlockShots_A =
+                AggressiveDefenseState_S,
+            X + Update_E = X);
     }
+
+   private:
+    // Where to shadow, gathered experimentally after seeing
+    // how far is far enough that the robot couldn't get dribbled past
+    static constexpr double ROBOT_SHADOWING_DISTANCE_METERS = 0.36;
 };

src/software/ai/hl/stp/play/defense/defense_play_fsm_test.cpp

@@ -15,13 +15,31 @@ TEST(DefensePlayFSMTest, test_transitions)
     FSM<DefensePlayFSM> fsm(DefensePlayFSM{ai_config});
     EXPECT_TRUE(fsm.is(boost::sml::state<DefensePlayFSM::DefenseState>));
 
+    // Place enemy robots behind the ball implying there is a large attack
+    ::TestUtil::setEnemyRobotPositions(world, {Point(0, 0), Point(-1, 0), Point(-2, 0)},
+                                       Timestamp::fromSeconds(0));
+
     fsm.process_event(DefensePlayFSM::Update(
         DefensePlayFSM::ControlParams{
             .max_allowed_speed_mode = TbotsProto::MaxAllowedSpeedMode::PHYSICAL_LIMIT},
         PlayUpdate(
             world, 3, [](PriorityTacticVector new_tactics) {}, InterPlayCommunication{},
             [](InterPlayCommunication comm) {})));
 
-    // DefensePlayFSM always stays in the DefenseState
     EXPECT_TRUE(fsm.is(boost::sml::state<DefensePlayFSM::DefenseState>));
+
+
+    // Place more friendly robots behind the ball implying this is a safe time
+    // to aggressively defense
+    ::TestUtil::setFriendlyRobotPositions(
+        world, {Point(-1, 0), Point(-3, 0), Point(-2, 0)}, Timestamp::fromSeconds(0));
+
+    fsm.process_event(DefensePlayFSM::Update(
+        DefensePlayFSM::ControlParams{
+            .max_allowed_speed_mode = TbotsProto::MaxAllowedSpeedMode::PHYSICAL_LIMIT},
+        PlayUpdate(
+            world, 3, [](PriorityTacticVector new_tactics) {}, InterPlayCommunication{},
+            [](InterPlayCommunication comm) {})));
+
+    EXPECT_TRUE(fsm.is(boost::sml::state<DefensePlayFSM::AggressiveDefenseState>));
 }