shoot_or_pass_play_fsm.h

#pragma once
 
#include "proto/parameters.pb.h"
#include "shared/constants.h"
#include "software/ai/hl/stp/play/play_fsm.h"
#include "software/ai/hl/stp/tactic/attacker/attacker_tactic.h"
#include "software/ai/hl/stp/tactic/move/move_tactic.h"
#include "software/ai/hl/stp/tactic/receiver/receiver_tactic.h"
#include "software/ai/navigator/obstacle/robot_navigation_obstacle_factory.h"
#include "software/ai/passing/eighteen_zone_pitch_division.h"
#include "software/ai/passing/pass_generator.h"
#include "software/ai/passing/receiver_position_generator.hpp"
#include "software/geom/algorithms/intersects.h"
#include "software/logger/logger.h"
 
using Zones = std::unordered_set<EighteenZoneId>;
 
struct ShootOrPassPlayFSM
{
    class AttemptShotState;
    class TakePassState;
    class StartState;
 
    struct ControlParams
    {
    };
 
    DEFINE_PLAY_UPDATE_STRUCT_WITH_CONTROL_AND_COMMON_PARAMS
 
 
    explicit ShootOrPassPlayFSM(const TbotsProto::AiConfig& ai_config);
 
    void updateOffensivePositioningTactics(
        const WorldPtr world, unsigned int num_tactics,
        const std::vector<Point>& existing_receiver_positions = {},
        const std::optional<Point>& pass_origin_override      = std::nullopt);
 
    void lookForPass(const Update& event);
 
    void startLookingForPass(const Update& event);
 
    void takePass(const Update& event);
 
    bool passFound(const Update& event);
 
    bool shouldAbortPass(const Update& event);
 
    bool passCompleted(const Update& event);
 
    bool tookShot(const Update& event);
 
    auto operator()()
    {
        using namespace boost::sml;
 
        DEFINE_SML_STATE(AttemptShotState)
        DEFINE_SML_STATE(TakePassState)
        DEFINE_SML_STATE(StartState)
        DEFINE_SML_EVENT(Update)
 
        DEFINE_SML_ACTION(lookForPass)
        DEFINE_SML_ACTION(startLookingForPass)
        DEFINE_SML_ACTION(takePass)
 
        DEFINE_SML_GUARD(passFound)
        DEFINE_SML_GUARD(shouldAbortPass)
        DEFINE_SML_GUARD(passCompleted)
        DEFINE_SML_GUARD(tookShot)
 
        return make_transition_table(
            // src_state + event [guard] / action = dest_state
            *StartState_S + Update_E / startLookingForPass_A        = AttemptShotState_S,
            AttemptShotState_S + Update_E[passFound_G] / takePass_A = TakePassState_S,
            AttemptShotState_S + Update_E[tookShot_G]               = X,
            AttemptShotState_S + Update_E[!passFound_G] / lookForPass_A =
                AttemptShotState_S,
            TakePassState_S + Update_E[shouldAbortPass_G] / startLookingForPass_A =
                AttemptShotState_S,
            TakePassState_S + Update_E[!passCompleted_G] / takePass_A = TakePassState_S,
            TakePassState_S + Update_E[passCompleted_G] / takePass_A  = X,
            X + Update_E / startLookingForPass_A = AttemptShotState_S);
    }
 
   private:
    TbotsProto::AiConfig ai_config;
    std::shared_ptr<AttackerTactic> attacker_tactic;
    std::shared_ptr<ReceiverTactic> receiver_tactic;
    std::vector<std::shared_ptr<MoveTactic>> offensive_positioning_tactics;
    ReceiverPositionGenerator<EighteenZoneId> receiver_position_generator;
    PassGenerator pass_generator;
    Timestamp pass_optimization_start_time;
    PassWithRating best_pass_and_score_so_far;
    Duration time_since_commit_stage_start;
    double min_pass_score_threshold;
};