play.h

#pragma once
 
#include <boost/bind.hpp>
#include <boost/coroutine2/all.hpp>
#include <vector>
 
#include "proto/parameters.pb.h"
#include "software/ai/hl/stp/play/play_fsm.h"
#include "software/ai/hl/stp/tactic/goalie/goalie_tactic.h"
#include "software/ai/hl/stp/tactic/tactic.h"
#include "software/ai/navigator/trajectory/trajectory_planner.h"
 
// This coroutine returns a list of list of shared_ptrs to Tactic objects
using TacticCoroutine = boost::coroutines2::coroutine<PriorityTacticVector>;
 
class Play
{
   public:
    explicit Play(TbotsProto::AiConfig ai_config, bool requires_goalie);
 
    virtual std::unique_ptr<TbotsProto::PrimitiveSet> get(
        const WorldPtr& world_ptr, const InterPlayCommunication& inter_play_communication,
        const SetInterPlayCommunicationCallback& set_inter_play_communication_fun);
 
    const std::map<std::shared_ptr<const Tactic>, RobotId>& getTacticRobotIdAssignment()
        const;
 
    virtual ~Play() = default;
 
    virtual std::vector<std::string> getState();
 
   protected:
    // The Play configuration
    TbotsProto::AiConfig ai_config;
 
    // Goalie tactic common to all plays
    std::shared_ptr<GoalieTactic> goalie_tactic;
 
    std::map<std::shared_ptr<const Tactic>, RobotId> tactic_robot_id_assignment;
 
    // Cached robot trajectories
    std::map<RobotId, TrajectoryPath> robot_trajectories;
 
    // List of all obstacles in the world at the current iteration
    // and all robot paths. Used for visualization
    TbotsProto::ObstacleList obstacle_list;
    TbotsProto::PathVisualization path_visualization;
 
    // TODO (#2359): make pure virtual once all plays are not coroutines
    virtual void updateTactics(const PlayUpdate& play_update);
 
   private:
    std::tuple<std::vector<Robot>, std::unique_ptr<TbotsProto::PrimitiveSet>,
               std::map<std::shared_ptr<const Tactic>, RobotId>>
    assignTactics(const WorldPtr& world_ptr, TacticVector tactic_vector,
                  const std::vector<Robot>& robots_to_assign);
 
    PriorityTacticVector getTactics(const WorldPtr& world_ptr);
 
    void getNextTacticsWrapper(TacticCoroutine::push_type& yield);
 
    virtual void getNextTactics(TacticCoroutine::push_type& yield,
                                const WorldPtr& world_ptr) = 0;
 
    // HaltTactics common to all plays for robots that don't have tactics assigned
    TacticVector halt_tactics;
 
    // Whether this play requires a goalie
    const bool requires_goalie;
 
    // TODO (#2359): remove this
    // The coroutine that sequentially returns the Tactics the Play wants to run
    TacticCoroutine::pull_type tactic_sequence;
 
    // TODO (#2359): remove this
    // The Play's knowledge of the most up-to-date World
    std::optional<WorldPtr> world_ptr_;
 
    // TODO (#2359): remove this
    PriorityTacticVector priority_tactics;
 
    uint64_t sequence_number = 0;
 
    RobotNavigationObstacleFactory obstacle_factory;
};