receiver_fsm.h

#pragma once
 
#include "shared/constants.h"
#include "software/ai/evaluation/calc_best_shot.h"
#include "software/ai/hl/stp/tactic/dribble/dribble_fsm.h"
#include "software/ai/hl/stp/tactic/kick/kick_fsm.h"
#include "software/ai/hl/stp/tactic/move/move_fsm.h"
#include "software/ai/hl/stp/tactic/tactic.h"
#include "software/ai/passing/pass.h"
#include "software/geom/algorithms/closest_point.h"
#include "software/logger/logger.h"
 
struct ReceiverFSM
{
    explicit ReceiverFSM(TbotsProto::ReceiverTacticConfig receiver_tactic_config)
        : receiver_tactic_config(receiver_tactic_config)
    {
    }
 
    class OneTouchShotState;
    class ReceiveAndDribbleState;
    class WaitingForPassState;
 
    struct ControlParams
    {
        // The pass to receive
        std::optional<Pass> pass = std::nullopt;
 
        // If set to true, we will only receive and dribble
        bool disable_one_touch_shot = false;
    };
 
    DEFINE_TACTIC_UPDATE_STRUCT_WITH_CONTROL_AND_COMMON_PARAMS
 
    static constexpr double MIN_PASS_START_SPEED_M_PER_SEC    = 0.02;
    static constexpr double BALL_MIN_MOVEMENT_SPEED_M_PER_SEC = 0.04;
 
    // The minimum angle between a ball's trajectory and the ball-receiver_point vector
    // for which we can consider a pass to be stray (i.e it won't make it to the receiver)
    static constexpr Angle MIN_STRAY_PASS_ANGLE = Angle::fromDegrees(60);
 
    // the minimum speed required for a pass to be considered stray
    static constexpr double MIN_STRAY_PASS_SPEED = 0.3;
 
    static Angle getOneTouchShotDirection(const Ray& shot, const Ball& ball);
 
    static Shot getOneTouchShotPositionAndOrientation(const Robot& robot,
                                                      const Ball& ball,
                                                      const Point& best_shot_target);
 
    /*
     * Finds a shot that is greater than min_open_angle_for_one_touch_deg and
     * respects max_deflection_for_one_touch_deg for the highest chance
     * of scoring with a one-touch shot. If neither of those are true, return a nullopt
     *
     * @param world The world to find a feasible shot on
     * @param assigned_robot The robot that will be performing the one-touch
     */
    std::optional<Shot> findFeasibleShot(const World& world, const Robot& assigned_robot);
 
    bool onetouchPossible(const Update& event);
 
    void updateOnetouch(const Update& event);
 
    void updateReceive(const Update& event);
 
    void adjustReceive(const Update& event);
 
    bool passStarted(const Update& event);
 
    bool passFinished(const Update& event);
 
    bool strayPass(const Update& event);
 
    auto operator()()
    {
        using namespace boost::sml;
 
        DEFINE_SML_STATE(ReceiveAndDribbleState)
        DEFINE_SML_STATE(OneTouchShotState)
        DEFINE_SML_STATE(WaitingForPassState)
        DEFINE_SML_EVENT(Update)
 
        DEFINE_SML_GUARD(onetouchPossible)
        DEFINE_SML_GUARD(passStarted)
        DEFINE_SML_GUARD(passFinished)
        DEFINE_SML_GUARD(strayPass)
 
        DEFINE_SML_ACTION(updateOnetouch)
        DEFINE_SML_ACTION(updateReceive)
        DEFINE_SML_ACTION(adjustReceive)
 
        return make_transition_table(
            // src_state + event [guard] / action = dest_state
            *WaitingForPassState_S + Update_E[!passStarted_G] / updateReceive_A,
            WaitingForPassState_S + Update_E[passStarted_G && onetouchPossible_G] /
                                        updateOnetouch_A = OneTouchShotState_S,
            WaitingForPassState_S + Update_E[passStarted_G && !onetouchPossible_G] /
                                        updateReceive_A = ReceiveAndDribbleState_S,
            ReceiveAndDribbleState_S + Update_E[!passFinished_G] / adjustReceive_A,
            OneTouchShotState_S +
                Update_E[!passFinished_G && !strayPass_G] / updateOnetouch_A,
            OneTouchShotState_S + Update_E[!passFinished_G && strayPass_G] /
                                      adjustReceive_A = ReceiveAndDribbleState_S,
            ReceiveAndDribbleState_S + Update_E[passFinished_G] / adjustReceive_A = X,
            OneTouchShotState_S + Update_E[passFinished_G] / updateOnetouch_A     = X,
            X + Update_E / SET_STOP_PRIMITIVE_ACTION                              = X);
    }
 
   private:
    // the receiver tactic config
    TbotsProto::ReceiverTacticConfig receiver_tactic_config;
};