free_kick_play_fsm.h

#pragma once
 
#include "proto/parameters.pb.h"
#include "shared/constants.h"
#include "software/ai/evaluation/calc_best_shot.h"
#include "software/ai/hl/stp/play/defense/defense_play.h"
#include "software/ai/hl/stp/play/play.h"
#include "software/ai/hl/stp/tactic/chip/chip_tactic.h"
#include "software/ai/hl/stp/tactic/crease_defender/crease_defender_tactic.h"
#include "software/ai/hl/stp/tactic/kick/kick_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/passing/eighteen_zone_pitch_division.h"
#include "software/ai/passing/pass_generator.h"
#include "software/ai/passing/receiver_position_generator.hpp"
#include "software/logger/logger.h"
 
struct FreeKickPlayFSM
{
    class SetupPositionState;
    class ShootState;
    class AttemptPassState;
    class PassState;
    class ChipState;
 
    struct ControlParams
    {
    };
 
    DEFINE_PLAY_UPDATE_STRUCT_WITH_CONTROL_AND_COMMON_PARAMS
 
    explicit FreeKickPlayFSM(const TbotsProto::AiConfig& ai_config);
 
    void setupPosition(const Update& event);
 
    bool setupDone(const Update& event);
 
    void updateReceiverPositioningTactics(
        const WorldPtr world, unsigned int num_tactics,
        const std::vector<Point>& existing_receiver_positions = {},
        const std::optional<Point>& pass_origin_override      = std::nullopt);
 
    void setReceiverAndDefenderTactics(
        PriorityTacticVector& tactics_to_run, const Update& event,
        int ideal_num_receivers, int num_tactics_already_assigned,
        const std::vector<Point>& existing_receiver_positions = {},
        const std::optional<Point>& pass_origin_override      = std::nullopt);
 
    void updateAlignToBallTactic(const WorldPtr& world_ptr);
 
    void startLookingForPass(const Update& event);
 
    void lookForPass(const Update& event);
 
    void shootBall(const Update& event);
 
    void passBall(const Update& event);
 
    void chipBall(const Update& event);
 
    bool shotFound(const Update& event);
 
    bool passFound(const Update& event);
 
    bool shouldAbortPass(const Update& event);
 
    bool timeExpired(const Update& event);
 
    bool shotDone(const Update& event);
 
    bool passDone(const Update& event);
 
    bool chipDone(const Update& event);
 
    auto operator()()
    {
        using namespace boost::sml;
 
        DEFINE_SML_STATE(SetupPositionState)
        DEFINE_SML_STATE(ShootState)
        DEFINE_SML_STATE(AttemptPassState)
        DEFINE_SML_STATE(PassState)
        DEFINE_SML_STATE(ChipState)
 
        DEFINE_SML_EVENT(Update)
 
        DEFINE_SML_ACTION(setupPosition)
        DEFINE_SML_ACTION(shootBall)
        DEFINE_SML_ACTION(startLookingForPass)
        DEFINE_SML_ACTION(lookForPass)
        DEFINE_SML_ACTION(passBall)
        DEFINE_SML_ACTION(chipBall)
 
        DEFINE_SML_GUARD(setupDone)
        DEFINE_SML_GUARD(shotFound)
        DEFINE_SML_GUARD(shotDone)
        DEFINE_SML_GUARD(shouldAbortPass)
        DEFINE_SML_GUARD(passFound)
        DEFINE_SML_GUARD(passDone)
        DEFINE_SML_GUARD(chipDone)
        DEFINE_SML_GUARD(timeExpired)
 
        return make_transition_table(
            // src_state + event [guard] / action = dest_state
            // Start with setting up the position of the kicker
            *SetupPositionState_S + Update_E[!setupDone_G] / setupPosition_A =
                SetupPositionState_S,
 
            // Shoot towards the enemy net directly if there is a clear shot
            SetupPositionState_S + Update_E[shotFound_G]       = ShootState_S,
            ShootState_S + Update_E[!shotDone_G] / shootBall_A = ShootState_S,
            ShootState_S + Update_E[shotDone_G]                = X,
 
            // Otherwise, start looking for a pass
            SetupPositionState_S + Update_E / startLookingForPass_A = AttemptPassState_S,
 
            // If the time to look for a pass is over, chip the ball towards the enemy net
            AttemptPassState_S + Update_E[timeExpired_G] = ChipState_S,
 
            // Keep looking for a pass
            AttemptPassState_S + Update_E[!passFound_G] / lookForPass_A =
                AttemptPassState_S,
            AttemptPassState_S + Update_E[passFound_G] = PassState_S,
 
            PassState_S + Update_E[shouldAbortPass_G]        = AttemptPassState_S,
            PassState_S + Update_E[!passDone_G] / passBall_A = PassState_S,
            PassState_S + Update_E[passDone_G]               = X,
 
            ChipState_S + Update_E[!chipDone_G] / chipBall_A = ChipState_S,
            ChipState_S + Update_E[chipDone_G]               = X);
    }
 
   private:
    TbotsProto::AiConfig ai_config;
    std::optional<Shot> shot;
    std::shared_ptr<MoveTactic> align_to_ball_tactic;
    std::shared_ptr<KickTactic> shoot_tactic;
    std::shared_ptr<ChipTactic> chip_tactic;
    std::shared_ptr<KickTactic> passer_tactic;
    std::shared_ptr<ReceiverTactic> receiver_tactic;
    std::vector<std::shared_ptr<MoveTactic>> receiver_positioning_tactics;
    std::shared_ptr<DefensePlay> defense_play;
 
    ReceiverPositionGenerator<EighteenZoneId> receiver_position_generator;
    PassGenerator pass_generator;
    PassWithRating best_pass_and_score_so_far;
    Timestamp pass_optimization_start_time;
};