field.h

#pragma once
 
#include "proto/world.pb.h"
#include "software/geom/circle.h"
#include "software/geom/point.h"
#include "software/geom/rectangle.h"
#include "software/util/make_enum/make_enum.hpp"
 
typedef enum
{
    POS_X,  // positive X side according to vision
    NEG_X   // negative X side
} FieldSide;
 
class Field
{
   public:
    static Field createSSLDivisionBField();
 
    static Field createSSLDivisionAField();
 
    static Field createField(TbotsProto::FieldType field_type);
 
    Field() = delete;
 
    explicit Field(double field_x_length, double field_y_length, double defense_x_length,
                   double defense_y_length, double goal_x_length, double goal_y_length,
                   double boundary_buffer_size, double center_circle_radius);
 
    explicit Field(const TbotsProto::Field &field_proto);
 
    double xLength() const;
 
    double totalXLength() const;
 
    double yLength() const;
 
    double totalYLength() const;
 
    double goalYLength() const;
 
    double goalXLength() const;
 
    double centerCircleRadius() const;
 
    Circle centerCircle() const;
 
    Point centerPoint() const;
 
    Segment halfwayLine() const;
 
    double defenseAreaYLength() const;
 
    double defenseAreaXLength() const;
 
    const Rectangle &friendlyDefenseArea() const;
 
    const Rectangle &enemyDefenseArea() const;
 
    Rectangle friendlyHalf() const;
 
    Rectangle friendlyPositiveYQuadrant() const;
 
    Rectangle friendlyNegativeYQuadrant() const;
 
    Rectangle enemyHalf() const;
 
    Rectangle enemyPositiveYQuadrant() const;
 
    Rectangle enemyNegativeYQuadrant() const;
 
    const Rectangle &fieldLines() const;
 
    Rectangle fieldBoundary() const;
 
    Point friendlyGoalCenter() const;
 
    Point enemyGoalCenter() const;
 
    const Rectangle &friendlyGoal() const;
 
    const Rectangle &enemyGoal() const;
 
    Point friendlyPenaltyMark() const;
 
    Point enemyPenaltyMark() const;
 
    Point friendlyCornerPos() const;
 
    Point friendlyCornerNeg() const;
 
    Point enemyCornerPos() const;
 
    Point enemyCornerNeg() const;
 
    Point friendlyGoalpostPos() const;
 
    Point friendlyGoalpostNeg() const;
 
    Point enemyGoalpostPos() const;
 
    Point enemyGoalpostNeg() const;
 
    double boundaryMargin() const;
 
    bool pointInFriendlyDefenseArea(const Point &p) const;
 
    bool pointInEnemyDefenseArea(const Point &p) const;
 
    bool pointInFriendlyHalf(const Point &p) const;
 
    bool pointInEnemyHalf(const Point &p) const;
 
    bool pointInFriendlyCorner(const Point &p, double radius) const;
 
    bool pointInEnemyCorner(const Point &p, double radius) const;
 
    bool operator==(const Field &other) const;
 
    bool operator!=(const Field &other) const;
 
   private:
    // The length of the playable field (between the goal lines) in metres
    double field_x_length_;
    // The width of the playable field (between the sidelines) in metres
    double field_y_length_;
    // The length of the defense area in metres
    double defense_x_length_;
    // The width of the defense area in metres
    double defense_y_length_;
    // How "deep" the goal is along the x-axis in metres
    double goal_x_length_;
    // The width of the goal (between the goalposts) in metres
    double goal_y_length_;
    // The width of the boundary (between the edge of the marked field lines and the
    // physical border around the field) in metres
    double boundary_buffer_size_;
    // The radius of the center circle in metres
    double center_circle_radius_;
    // The x-coordinate distance from the goal centre to the penalty mark
    double goal_centre_to_penalty_mark_;
    // The following are used for caching to improve performance
    Rectangle enemy_defense_area_;
    Rectangle friendly_defense_area_;
    Rectangle field_lines_;
    Rectangle enemy_goal_;
    Rectangle friendly_goal_;
};
 
namespace std
{
    // Implements the std::less function so Field can be used as the key in data
    // structures, such as std::map. See:
    // https://stackoverflow.com/questions/42762633/why-is-stdless-better-than and
    // https://en.cppreference.com/w/cpp/utility/functional/less
    template <>
    struct less<Field>
    {
        bool operator()(const Field &lhs, const Field &rhs) const
        {
            return lhs.friendlyDefenseArea().halfPerimeter() +
                       lhs.enemyDefenseArea().halfPerimeter() +
                       lhs.fieldLines().halfPerimeter() +
                       lhs.fieldBoundary().halfPerimeter() <
                   rhs.friendlyDefenseArea().halfPerimeter() +
                       rhs.enemyDefenseArea().halfPerimeter() +
                       rhs.fieldLines().halfPerimeter() +
                       rhs.fieldBoundary().halfPerimeter();
        }
    };
}  // namespace std