crease_defender_fsm.h

#pragma once
 
#include "proto/parameters.pb.h"
#include "proto/tactic.pb.h"
#include "software/ai/hl/stp/tactic/defender/defender_fsm_base.h"
#include "software/ai/hl/stp/tactic/dribble/dribble_fsm.h"
#include "software/ai/hl/stp/tactic/move/move_fsm.h"
#include "software/ai/hl/stp/tactic/tactic.h"
#include "software/ai/hl/stp/tactic/transition_conditions.h"
#include "software/geom/algorithms/contains.h"
#include "software/geom/algorithms/convex_angle.h"
#include "software/geom/algorithms/intersection.h"
#include "software/geom/ray.h"
#include "software/logger/logger.h"
 
struct CreaseDefenderFSM : public DefenderFSMBase
{
   public:
    // this struct defines the unique control parameters that the CreaseDefenderFSM
    // requires in its update
    struct ControlParams
    {
        // The origin point of the enemy threat
        Point enemy_threat_origin;
        // The crease defender alignment with respect to the enemy threat
        TbotsProto::CreaseDefenderAlignment crease_defender_alignment;
        // The maximum allowed speed mode
        TbotsProto::MaxAllowedSpeedMode max_allowed_speed_mode;
        // The crease defender's aggressiveness towards the ball
        TbotsProto::BallStealMode ball_steal_mode;
    };
 
    // this struct defines the only event that the CreaseDefenderFSM responds to
    DEFINE_TACTIC_UPDATE_STRUCT_WITH_CONTROL_AND_COMMON_PARAMS
 
    static std::optional<Point> findBlockThreatPoint(
        const Field& field, const Point& enemy_threat_origin,
        const TbotsProto::CreaseDefenderAlignment& crease_defender_alignment,
        double robot_obstacle_inflation_factor);
 
    explicit CreaseDefenderFSM(const TbotsProto::AiConfig& ai_config)
        : robot_navigation_obstacle_config(ai_config.robot_navigation_obstacle_config()),
          crease_defender_config(ai_config.crease_defender_config())
    {
    }
 
    bool ballNearbyWithoutThreat(const Update& event);
 
    void prepareGetPossession(const Update& event,
                              boost::sml::back::process<DribbleFSM::Update> processEvent);
 
    void blockThreat(const Update& event,
                     boost::sml::back::process<MoveFSM::Update> processEvent);
 
    auto operator()()
    {
        using namespace boost::sml;
 
        DEFINE_SML_STATE(MoveFSM)
        DEFINE_SML_EVENT(Update)
        DEFINE_SML_SUB_FSM_UPDATE_ACTION(blockThreat, MoveFSM)
        DEFINE_SML_STATE(DribbleFSM)
        DEFINE_SML_GUARD(ballNearbyWithoutThreat)
        DEFINE_SML_SUB_FSM_UPDATE_ACTION(prepareGetPossession, DribbleFSM)
 
        return make_transition_table(
            // src_state + event [guard] / action = dest_state
            *MoveFSM_S + Update_E[ballNearbyWithoutThreat_G] / prepareGetPossession_A =
                DribbleFSM_S,
            MoveFSM_S + Update_E / blockThreat_A, MoveFSM_S = X,
            DribbleFSM_S + Update_E[!ballNearbyWithoutThreat_G] / blockThreat_A =
                MoveFSM_S,
            DribbleFSM_S + Update_E / prepareGetPossession_A,
            X + Update_E[ballNearbyWithoutThreat_G] / prepareGetPossession_A =
                DribbleFSM_S,
            X + Update_E / blockThreat_A = MoveFSM_S);
    }
 
   private:
    static constexpr double DETECT_THREAT_AHEAD_SHAPE_LENGTH_M = 1;
    static constexpr double DETECT_THREAT_AHEAD_SHAPE_RADIUS_M = 0.25;
    static std::optional<Point> findDefenseAreaIntersection(
        const Field& field, const Ray& ray, double robot_obstacle_inflation_factor);
 
    static bool isAnyEnemyInZone(const Update& event, const Stadium& zone);
 
    TbotsProto::RobotNavigationObstacleConfig robot_navigation_obstacle_config;
    TbotsProto::CreaseDefenderConfig crease_defender_config;
};