robot.h

#pragma once
 
#include <optional>
 
#include "proto/team.pb.h"
#include "software/constants.h"
#include "software/geom/polygon.h"
#include "software/time/timestamp.h"
#include "software/world/robot_capabilities.h"
#include "software/world/robot_state.h"
 
class Robot
{
   public:
    explicit Robot(RobotId id, const Point &position, const Vector &velocity,
                   const Angle &orientation, const AngularVelocity &angular_velocity,
                   const Timestamp &timestamp,
                   const std::set<RobotCapability> &unavailable_capabilities =
                       std::set<RobotCapability>(),
                   const RobotConstants_t &robot_constants = DEFAULT_ROBOT_CONSTANTS);
 
    explicit Robot(RobotId id, const RobotState &initial_state,
                   const Timestamp &timestamp,
                   const std::set<RobotCapability> &unavailable_capabilities =
                       std::set<RobotCapability>(),
                   const RobotConstants_t &robot_constants = DEFAULT_ROBOT_CONSTANTS);
 
 
    explicit Robot(const TbotsProto::Robot &robot_proto);
 
    void updateState(const RobotState &state, const Timestamp &timestamp);
 
    RobotState currentState() const;
 
    Timestamp timestamp() const;
 
    RobotId id() const;
 
    Point position() const;
 
    Vector velocity() const;
 
    Angle orientation() const;
 
    AngularVelocity angularVelocity() const;
 
    const std::set<RobotCapability> &getUnavailableCapabilities() const;
 
    Polygon dribblerArea() const;
 
    std::set<RobotCapability> getAvailableCapabilities() const;
 
    std::set<RobotCapability> &getMutableRobotCapabilities();
 
    const RobotConstants_t &robotConstants() const;
 
    bool isNearDribbler(
        const Point &test_point,
        double TOLERANCE = BALL_TO_FRONT_OF_ROBOT_DISTANCE_WHEN_DRIBBLING) const;
 
    Duration getTimeToOrientation(
        const Angle &desired_orientation,
        const AngularVelocity &final_angular_velocity = AngularVelocity::zero()) const;
 
    Duration getTimeToPosition(const Point &destination,
                               const Vector &final_velocity = Vector()) const;
 
    bool operator==(const Robot &other) const;
 
    bool operator!=(const Robot &other) const;
 
    // A comparator for the Robot class that compares Robots by ID. This is equivalent
    // to the "less-than" operator.
    // This comparator is necessary for the Robot class to be used as a key in maps. See
    // https://stackoverflow.com/questions/6573225/what-requirements-must-stdmap-key-classes-meet-to-be-valid-keys
    // and
    // https://stackoverflow.com/questions/5733254/how-can-i-create-my-own-comparator-for-a-map
    //
    // We define this "custom" comparator rather than define the '<' operator for this
    // class because there are many possible ways to order robots, so it doesn't make
    // sense to define a single "normal" way with the '<' operator. Defining this
    // comparator struct lets us use it explicitly when necessary and maintain multiple
    // ways of comparing robots
    struct cmpRobotByID
    {
        bool operator()(const Robot &r1, const Robot &r2) const
        {
            return r1.id() < r2.id();
        }
    };
 
   private:
    // The id of this robot
    RobotId id_;
    RobotState current_state_;
    Timestamp timestamp_;
    // The hardware capabilities of the robot, generated from
    // RobotCapabilityFlags::broken_dribblers/chippers/kickers dynamic parameters
    std::set<RobotCapability> unavailable_capabilities_;
    RobotConstants_t robot_constants_;
 
    // Default robot constants that should be used for all robots
    inline static const RobotConstants DEFAULT_ROBOT_CONSTANTS =
        create2021RobotConstants();
};