Fsm debug window

src/.bazelrc

@@ -48,6 +48,9 @@ build --incompatible_enable_proto_toolchain_resolution # protoc caching
 common --per_file_copt=external/.*grpc.*@--GRPC_WAS_NOT_SUPPOSED_TO_BE_BUILT
 common --host_per_file_copt=external/.*grpc.*@--GRPC_WAS_NOT_SUPPOSED_TO_BE_BUILT
 
+build --experimental_disk_cache_gc_max_size=32G
+build  --experimental_disk_cache_gc_max_age=28d
+
 ################# Build Configurations #################
 # Lock C++ version
 build --cxxopt="-std=c++2a"

src/proto/play_info_msg.proto

@@ -7,12 +7,16 @@ message PlayInfo
     message Play
     {
         repeated string play_state = 1;
+        string last_transition = 2;
+        string last_guard = 3;
     }
 
     message Tactic
     {
         string tactic_name      = 1;
         string tactic_fsm_state = 2;
+        string last_transition = 3;
+        string last_guard = 4;
     }
 
     map<uint32, Tactic> robot_tactic_assignment = 1;

src/software/ai/ai.cpp

@@ -7,14 +7,15 @@
 #include "software/tracy/tracy_constants.h"
 
 
-Ai::Ai(const TbotsProto::AiConfig& ai_config)
-    : ai_config_(ai_config),
-      fsm(std::make_unique<FSM<PlaySelectionFSM>>(PlaySelectionFSM{ai_config})),
+Ai::Ai(std::shared_ptr<const TbotsProto::AiConfig> ai_config_ptr)
+    : logger(),
+      ai_config_ptr(ai_config_ptr),
+      fsm(std::make_unique<FSM<PlaySelectionFSM>>(PlaySelectionFSM{ai_config_ptr}, logger)),
       override_play(nullptr),
-      current_play(std::make_unique<HaltPlay>(ai_config)),
+      current_play(std::make_unique<HaltPlay>(ai_config_ptr)),
       ai_config_changed(false)
 {
-    auto current_override = ai_config_.ai_control_config().override_ai_play();
+    auto current_override = ai_config_ptr->ai_control_config().override_ai_play();
     if (current_override != TbotsProto::PlayName::UseAiSelection)
     {
         // Override to new play if we're not running Ai Selection
@@ -32,12 +33,11 @@ void Ai::overridePlay(std::unique_ptr<Play> play)
 void Ai::overridePlayFromProto(TbotsProto::Play play_proto)
 {
     current_override_play_proto = play_proto;
-    overridePlay(std::move(createPlay(play_proto, ai_config_)));
+    overridePlay(std::move(createPlay(play_proto, ai_config_ptr)));
 }
 
-void Ai::updateAiConfig(TbotsProto::AiConfig& ai_config)
+void Ai::updateAiConfig()
 {
-    ai_config_        = std::move(ai_config);
     ai_config_changed = true;
 }
 
@@ -47,9 +47,9 @@ void Ai::checkAiConfig()
     {
         ai_config_changed = false;
 
-        fsm = std::make_unique<FSM<PlaySelectionFSM>>(PlaySelectionFSM{ai_config_});
+        fsm = std::make_unique<FSM<PlaySelectionFSM>>(PlaySelectionFSM{ai_config_ptr}, logger);
 
-        auto current_override = ai_config_.ai_control_config().override_ai_play();
+        auto current_override = ai_config_ptr->ai_control_config().override_ai_play();
         if (current_override != TbotsProto::PlayName::UseAiSelection)
         {
             // Override to new play if we're not running Ai Selection
@@ -73,7 +73,7 @@ std::unique_ptr<TbotsProto::PrimitiveSet> Ai::getPrimitives(const WorldPtr& worl
 
     fsm->process_event(PlaySelectionFSM::Update([this](std::unique_ptr<Play> play)
                                                 { current_play = std::move(play); },
-                                                world_ptr->gameState(), ai_config_));
+                                                world_ptr->gameState(), *ai_config_ptr));
 
     std::unique_ptr<TbotsProto::PrimitiveSet> primitive_set;
     if (static_cast<bool>(override_play))
@@ -122,5 +122,7 @@ TbotsProto::PlayInfo Ai::getPlayInfo() const
         (*info.mutable_robot_tactic_assignment())[robot_id] = tactic_msg;
     }
 
+    FSMLogger::getTransitionAndGuard(info);
+
     return info;
 }

src/software/ai/ai.h

@@ -18,9 +18,9 @@ class Ai final
 
     /**
      * Create an AI with given configurations
-     * @param ai_config_ The AI configuration
+     * @param ai_config_ptr shared pointer to the ai configuration
      */
-    explicit Ai(const TbotsProto::AiConfig& ai_config);
+    explicit Ai(std::shared_ptr<const TbotsProto::AiConfig> ai_config_ptr);
 
     /**
      * Overrides the play
@@ -60,12 +60,13 @@ class Ai final
      *
      * @param ai_config The new AiConfig proto
      */
-    void updateAiConfig(TbotsProto::AiConfig& ai_config);
+    void updateAiConfig();
 
-   private:
+private:
     void checkAiConfig();
 
-    TbotsProto::AiConfig ai_config_;
+    FSMLogger logger;
+    std::shared_ptr<const TbotsProto::AiConfig> ai_config_ptr;
     std::unique_ptr<FSM<PlaySelectionFSM>> fsm;
     std::unique_ptr<Play> override_play;
     std::unique_ptr<Play> current_play;

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

@@ -86,7 +86,8 @@ cc_library(
     srcs = ["play.cpp"],
     hdrs = [
         "play.h",
-        "play_fsm.h",
+        "play_base.hpp",
+        "play_fsm.hpp",
     ],
     deps = [
         "//software/ai/hl/stp/tactic",

src/software/ai/hl/stp/play/assigned_tactics_play.cpp

@@ -6,11 +6,12 @@
 #include "software/logger/logger.h"
 #include "software/util/generic_factory/generic_factory.h"
 
-AssignedTacticsPlay::AssignedTacticsPlay(TbotsProto::AiConfig config)
-    : Play(config, false),
+AssignedTacticsPlay::AssignedTacticsPlay(
+    std::shared_ptr<const TbotsProto::AiConfig> ai_config_ptr)
+    : Play(ai_config_ptr, false),
       assigned_tactics(),
       override_motion_constraints(),
-      obstacle_factory(config.robot_navigation_obstacle_config())
+      obstacle_factory(ai_config_ptr->robot_navigation_obstacle_config())
 {
 }
 
@@ -89,5 +90,6 @@ std::unique_ptr<TbotsProto::PrimitiveSet> AssignedTacticsPlay::get(
 void AssignedTacticsPlay::updateTactics(const PlayUpdate &play_update) {}
 
 // Register this play in the genericFactory
-static TGenericFactory<std::string, Play, AssignedTacticsPlay, TbotsProto::AiConfig>
+static TGenericFactory<std::string, Play, AssignedTacticsPlay,
+                       std::shared_ptr<const TbotsProto::AiConfig>>
     factory;

src/software/ai/hl/stp/play/assigned_tactics_play.h

@@ -9,7 +9,12 @@
 class AssignedTacticsPlay : public Play
 {
    public:
-    AssignedTacticsPlay(TbotsProto::AiConfig config);
+    /**
+     * Constructor for AssignedTacticsPlay
+     *
+     * @param ai_config_ptr shared pointer to ai_config
+     */
+    AssignedTacticsPlay(std::shared_ptr<const TbotsProto::AiConfig> ai_config_ptr);
 
     void getNextTactics(TacticCoroutine::push_type &yield,
                         const WorldPtr &world_ptr) override;

src/software/ai/hl/stp/play/ball_placement/ball_placement_play.cpp

@@ -4,8 +4,9 @@
 #include "software/util/generic_factory/generic_factory.h"
 
 
-BallPlacementPlay::BallPlacementPlay(TbotsProto::AiConfig config)
-    : Play(config, true), fsm{BallPlacementPlayFSM{config}}, control_params{}
+BallPlacementPlay::BallPlacementPlay(
+    std::shared_ptr<const TbotsProto::AiConfig> ai_config_ptr)
+    : PlayBase<BallPlacementPlayFSM>(ai_config_ptr, true)
 {
 }
 
@@ -41,5 +42,6 @@ std::vector<std::string> BallPlacementPlay::getState()
 }
 
 // Register this play in the genericFactory
-static TGenericFactory<std::string, Play, BallPlacementPlay, TbotsProto::AiConfig>
+static TGenericFactory<std::string, Play, BallPlacementPlay,
+                       std::shared_ptr<const TbotsProto::AiConfig>>
     factory;

src/software/ai/hl/stp/play/ball_placement/ball_placement_play.h

@@ -3,22 +3,24 @@
 #include "proto/parameters.pb.h"
 #include "software/ai/hl/stp/play/ball_placement/ball_placement_play_fsm.h"
 #include "software/ai/hl/stp/play/play.h"
+#include "software/ai/hl/stp/play/play_base.hpp"
 
 /**
  * A Play that performs ball placement, i.e. placing the ball in a defined location
  * determined by the referee. This is used to obey the referee "Ball Placement Us" command
  */
-class BallPlacementPlay : public Play
+class BallPlacementPlay : public PlayBase<BallPlacementPlayFSM>
 {
    public:
-    BallPlacementPlay(TbotsProto::AiConfig config);
+    /**
+     * Constructor for BallPlacementPlay
+     *
+     * @param ai_config_ptr shared pointer to ai_config
+     */
+    BallPlacementPlay(std::shared_ptr<const TbotsProto::AiConfig> ai_config_ptr);
 
     void getNextTactics(TacticCoroutine::push_type &yield,
                         const WorldPtr &world_ptr) override;
     void updateTactics(const PlayUpdate &play_update) override;
     std::vector<std::string> getState() override;
-
-   private:
-    FSM<BallPlacementPlayFSM> fsm;
-    BallPlacementPlayFSM::ControlParams control_params;
 };

src/software/ai/hl/stp/play/ball_placement/ball_placement_play_fsm.cpp

@@ -1,11 +1,12 @@
 #include "software/ai/hl/stp/play/ball_placement/ball_placement_play_fsm.h"
 
-BallPlacementPlayFSM::BallPlacementPlayFSM(TbotsProto::AiConfig ai_config)
-    : ai_config(ai_config),
-      pivot_kick_tactic(std::make_shared<WallKickoffTactic>(ai_config)),
-      place_ball_tactic(std::make_shared<PlaceBallTactic>(ai_config)),
-      align_placement_tactic(std::make_shared<PlaceBallMoveTactic>()),
-      retreat_tactic(std::make_shared<MoveTactic>()),
+BallPlacementPlayFSM::BallPlacementPlayFSM(
+    std::shared_ptr<const TbotsProto::AiConfig> ai_config_ptr)
+    : PlayFSM<BallPlacementPlayFSM>(ai_config_ptr),
+      pivot_kick_tactic(std::make_shared<WallKickoffTactic>(ai_config_ptr)),
+      place_ball_tactic(std::make_shared<PlaceBallTactic>(ai_config_ptr)),
+      align_placement_tactic(std::make_shared<PlaceBallMoveTactic>(ai_config_ptr)),
+      retreat_tactic(std::make_shared<MoveTactic>(ai_config_ptr)),
       move_tactics(std::vector<std::shared_ptr<PlaceBallMoveTactic>>())
 {
 }
@@ -180,7 +181,7 @@ bool BallPlacementPlayFSM::kickDone(const Update &event)
 {
     const auto ball_velocity = event.common.world_ptr->ball().velocity().length();
     const auto ball_is_kicked_m_per_s_threshold =
-        this->ai_config.ai_parameter_config().ball_is_kicked_m_per_s_threshold();
+        this->ai_config_ptr->ai_parameter_config().ball_is_kicked_m_per_s_threshold();
     return ball_velocity > ball_is_kicked_m_per_s_threshold;
 }
 
@@ -197,7 +198,7 @@ bool BallPlacementPlayFSM::ballPlaced(const Update &event)
         return comparePoints(ball_pos, placement_point.value(),
                              PLACEMENT_DIST_THRESHOLD_METERS) &&
                event.common.world_ptr->ball().velocity().length() <
-                   this->ai_config.ai_parameter_config()
+                   this->ai_config_ptr->ai_parameter_config()
                        .ball_is_kicked_m_per_s_threshold();
     }
     else
@@ -283,7 +284,8 @@ void BallPlacementPlayFSM::setupMoveTactics(const Update &event)
 
     move_tactics = std::vector<std::shared_ptr<PlaceBallMoveTactic>>(num_move_tactics);
     std::generate(move_tactics.begin(), move_tactics.end(),
-                  [this]() { return std::make_shared<PlaceBallMoveTactic>(); });
+                  [this]()
+                  { return std::make_shared<PlaceBallMoveTactic>(this->ai_config_ptr); });
 
     // non goalie and non ball placing robots line up along a line just outside the
     // friendly defense area to wait for ball placement to finish

src/software/ai/hl/stp/play/ball_placement/ball_placement_play_fsm.h

@@ -2,36 +2,38 @@
 
 #include "proto/parameters.pb.h"
 #include "shared/constants.h"
-#include "software/ai/hl/stp/play/play_fsm.h"
+#include "software/ai/hl/stp/play/play_fsm.hpp"
 #include "software/ai/hl/stp/tactic/dribble/dribble_tactic.h"
 #include "software/ai/hl/stp/tactic/move/move_tactic.h"
 #include "software/ai/hl/stp/tactic/pivot_kick/pivot_kick_tactic.h"
 #include "software/ai/passing/eighteen_zone_pitch_division.h"
 
-
 using Zones = std::unordered_set<EighteenZoneId>;
 
-struct BallPlacementPlayFSM
+struct BallPlacementPlayFSM : public PlayFSM<BallPlacementPlayFSM>
 {
+    /**
+     *  The control parameters for a ball placement play
+     */
+    struct ControlParams
+    {
+    };
+
     class StartState;
     class KickOffWallState;
     class AlignPlacementState;
     class PlaceBallState;
     class WaitState;
     class RetreatState;
 
-    struct ControlParams
-    {
-    };
-
-    DEFINE_PLAY_UPDATE_STRUCT_WITH_CONTROL_AND_COMMON_PARAMS
 
     /**
      * Creates a ball placement play FSM
      *
-     * @param ai_config the play config for this play FSM
+     * @param ai_config_ptr shared pointer to ai_config
      */
-    explicit BallPlacementPlayFSM(TbotsProto::AiConfig ai_config);
+    explicit BallPlacementPlayFSM(
+        std::shared_ptr<const TbotsProto::AiConfig> ai_config_ptr);
 
     /**
      * Action that has the placing robot kick the ball off the wall to give more space to
@@ -141,6 +143,13 @@ struct BallPlacementPlayFSM
      */
     void setupMoveTactics(const Update& event);
 
+    DEFINE_SML_GUARD_CLASS(shouldKickOffWall, BallPlacementPlayFSM)
+    DEFINE_SML_GUARD_CLASS(alignDone, BallPlacementPlayFSM)
+    DEFINE_SML_GUARD_CLASS(kickDone, BallPlacementPlayFSM)
+    DEFINE_SML_GUARD_CLASS(ballPlaced, BallPlacementPlayFSM)
+    DEFINE_SML_GUARD_CLASS(waitDone, BallPlacementPlayFSM)
+    DEFINE_SML_GUARD_CLASS(retreatDone, BallPlacementPlayFSM)
+
     auto operator()()
     {
         using namespace boost::sml;
@@ -153,19 +162,20 @@ struct BallPlacementPlayFSM
         DEFINE_SML_STATE(RetreatState)
         DEFINE_SML_EVENT(Update)
 
-        DEFINE_SML_ACTION(alignPlacement)
-        DEFINE_SML_ACTION(placeBall)
-        DEFINE_SML_ACTION(kickOffWall)
-        DEFINE_SML_ACTION(startWait)
-        DEFINE_SML_ACTION(retreat)
-
         DEFINE_SML_GUARD(shouldKickOffWall)
         DEFINE_SML_GUARD(alignDone)
         DEFINE_SML_GUARD(kickDone)
         DEFINE_SML_GUARD(ballPlaced)
         DEFINE_SML_GUARD(waitDone)
         DEFINE_SML_GUARD(retreatDone)
 
+        DEFINE_SML_ACTION(alignPlacement)
+        DEFINE_SML_ACTION(placeBall)
+        DEFINE_SML_ACTION(kickOffWall)
+        DEFINE_SML_ACTION(startWait)
+        DEFINE_SML_ACTION(retreat)
+
+
         return make_transition_table(
             // src_state + event [guard] / action = dest_state
             *StartState_S + Update_E[!shouldKickOffWall_G] / alignPlacement_A =
@@ -188,7 +198,6 @@ struct BallPlacementPlayFSM
     }
 
    private:
-    TbotsProto::AiConfig ai_config;
     std::shared_ptr<WallKickoffTactic> pivot_kick_tactic;
     std::shared_ptr<PlaceBallTactic> place_ball_tactic;
     std::shared_ptr<MoveTactic> align_placement_tactic;

src/software/ai/hl/stp/play/ball_placement/ball_placement_play_fsm_test.cpp

@@ -20,8 +20,9 @@ TEST(BallPlacementPlayFSMTest, test_transitions)
     game_state.setBallPlacementPoint(ball_placement_point);
     world_ptr->updateGameState(game_state);
 
-    TbotsProto::AiConfig ai_config;
-    FSM<BallPlacementPlayFSM> fsm(BallPlacementPlayFSM{ai_config});
+    FSMLogger logger{};
+    FSM<BallPlacementPlayFSM> fsm(
+            BallPlacementPlayFSM{std::make_shared<TbotsProto::AiConfig>()}, logger);
 
     EXPECT_TRUE(fsm.is(boost::sml::state<BallPlacementPlayFSM::StartState>));
 
@@ -49,9 +50,9 @@ TEST(BallPlacementPlayFSMTest, test_kick_off_wall_transitions)
     Point ball_placement_point(0, 0);
     game_state.setBallPlacementPoint(ball_placement_point);
     world_ptr->updateGameState(game_state);
-
-    TbotsProto::AiConfig ai_config;
-    FSM<BallPlacementPlayFSM> fsm(BallPlacementPlayFSM{ai_config});
+    FSMLogger logger{};
+    FSM<BallPlacementPlayFSM> fsm(
+            BallPlacementPlayFSM{std::make_shared<TbotsProto::AiConfig>()}, logger);
 
     EXPECT_TRUE(fsm.is(boost::sml::state<BallPlacementPlayFSM::StartState>));
 
@@ -78,8 +79,7 @@ TEST(BallPlacementPlayFSMTest, test_kick_off_wall_transitions)
 
 TEST(BallPlacementPlayFSMTest, test_kick_off_wall_angle)
 {
-    TbotsProto::AiConfig ai_config;
-    BallPlacementPlayFSM fsm(ai_config);
+    BallPlacementPlayFSM fsm(std::make_shared<TbotsProto::AiConfig>());
 
     Field field           = Field::createField(TbotsProto::FieldType::DIV_B);
     Rectangle field_lines = field.fieldLines();