tactic.h

#pragma once
 
#include "software/ai/hl/stp/tactic/primitive.h"
#include "software/ai/hl/stp/tactic/tactic_fsm.h"
#include "software/ai/hl/stp/tactic/tactic_visitor.h"
#include "software/ai/hl/stp/tactic/transition_conditions.h"
#include "software/world/world.h"
 
#define COPY_TACTIC(new_class, parent_class)                                             \
    class new_class : public parent_class                                                \
    {                                                                                    \
        using parent_class::parent_class;                                                \
                                                                                         \
        void accept(TacticVisitor &visitor) const                                        \
        {                                                                                \
            visitor.visit(*this);                                                        \
        }                                                                                \
    };
 
class Tactic
{
   public:
    explicit Tactic(const std::set<RobotCapability> &capability_reqs_);
 
    Tactic() = delete;
 
    virtual bool done() const = 0;
 
    virtual std::string getFSMState() const = 0;
 
    const std::set<RobotCapability> &robotCapabilityRequirements() const;
 
    std::set<RobotCapability> &mutableRobotCapabilityRequirements();
 
    void setLastExecutionRobot(std::optional<RobotId> last_execution_robot);
 
    std::map<RobotId, std::shared_ptr<Primitive>> get(const WorldPtr &world_ptr);
 
    virtual void accept(TacticVisitor &visitor) const = 0;
 
    virtual ~Tactic() = default;
 
   protected:
    std::optional<RobotId> last_execution_robot;
 
   private:
    std::shared_ptr<Primitive> primitive;
 
    virtual void updatePrimitive(const TacticUpdate &tactic_update, bool reset_fsm) = 0;
 
    // robot capability requirements
    std::set<RobotCapability> capability_reqs;
};