team.h

#pragma once
 
#include <cstdlib>
#include <map>
#include <optional>
#include <vector>
 
#include "software/time/timestamp.h"
#include "software/world/robot.h"
 
class Team
{
   public:
    explicit Team(
        const Duration& robot_expiry_buffer_duration = Duration::fromMilliseconds(50));
 
    explicit Team(
        const std::vector<Robot>& team_robots,
        const Duration& robot_expiry_buffer_duration = Duration::fromMilliseconds(50));
 
    explicit Team(
        const TbotsProto::Team& team_proto,
        const Duration& robot_expiry_buffer_duration = Duration::fromMilliseconds(50));
 
    void updateRobots(const std::vector<Robot>& team_robots);
 
    void updateState(const Team& new_team_data);
 
    void removeExpiredRobots(const Timestamp& timestamp);
 
    void removeRobotWithId(unsigned int robot_id);
 
    void assignGoalie(RobotId new_goalie_id);
 
    void clearGoalie();
 
    size_t numRobots() const;
 
    const Duration& getRobotExpiryBufferDuration() const;
 
    void setRobotExpiryBuffer(const Duration& new_robot_expiry_buffer_duration);
 
    void setUnavailableRobotCapabilities(
        RobotId id, const std::set<RobotCapability>& new_unavailable_robot_capabilities);
 
    std::optional<Robot> getRobotById(const unsigned int id) const;
 
    std::optional<Robot> goalie() const;
 
    std::optional<unsigned int> getGoalieId() const;
 
    const std::vector<Robot>& getAllRobots() const;
 
    std::vector<Robot> getAllRobotsExceptGoalie() const;
 
    std::optional<Robot> getNearestRobot(const Point& ref_point) const;
 
    static std::optional<Robot> getNearestRobot(const std::vector<Robot>& robots,
                                                const Point& ref_point);
 
    void clearAllRobots();
 
    std::optional<Timestamp> timestamp() const;
 
    bool operator==(const Team& other) const;
 
    bool operator!=(const Team& other) const;
 
    Timestamp getMostRecentTimestamp() const;
 
   private:
    void updateTimestamp(Timestamp timestamp);
 
    Timestamp getMostRecentTimestampFromRobots();
 
    // The robots on this team
    std::vector<Robot> team_robots_;
 
    // The robot id of the goalie for this team
    std::optional<unsigned int> goalie_id_;
 
    // The duration for which a Robot must not have been updated for before
    // being removed from this team.
    Duration robot_expiry_buffer_duration_;
 
    Timestamp last_update_timestamp_;
};
 
enum class TeamType
{
    FRIENDLY,
    ENEMY,
};