defender_assignment.h

#pragma once
 
#include "proto/parameters.pb.h"
#include "software/ai/evaluation/enemy_threat.h"
#include "software/geom/point.h"
#include "software/geom/segment.h"
#include "software/world/field.h"
 
// Indicates the type of defender for a DefenderAssignment
enum DefenderAssignmentType
{
    CREASE_DEFENDER,
    PASS_DEFENDER
};
 
// This struct stores the concept of a defender assignment, which describes
// the location on the field that a defender could target to block a potential
// enemy pass or shot on net
struct DefenderAssignment
{
    // The type of defender for this assignment
    DefenderAssignmentType type;
 
    // The location on the field that the defender should target
    Point target;
 
    // The coverage rating of the assignment, which scores the defender's ability
    // to block high-danger enemy scoring chances or passes
    double coverage_rating;
 
    // Equality operator for unit testing.
    bool operator==(const DefenderAssignment &other) const
    {
        return this->type == other.type && this->target == other.target &&
               this->coverage_rating == other.coverage_rating;
    }
};
 
// This struct stores the concept of a shooting lane, which describes
// a potential passing or shooting lane an enemy robot could shoot the
// ball along
struct ShootingLane
{
    // The segment representing the lane on the field, starting from
    // the position of the enemy robot and ending at the intended point
    // where the ball will be received or enter the net
    Segment lane;
 
    // The threat rating of the lane, which scores the dangerousness
    // of the lane relative to other lanes (i.e. how likely a pass or shot
    // along the lane will eventually result in the enemy team scoring)
    double threat_rating;
 
    // Equality operator for unit testing.
    bool operator==(const ShootingLane &other) const
    {
        return this->lane == other.lane && this->threat_rating == other.threat_rating;
    }
};
 
// A goal lane describes a shooting lane from an enemy robot to the goal
struct GoalLane : ShootingLane
{
    // The angle in radians from the enemy robot to the goal that the goal lane describes
    Angle angle_to_goal;
 
    // Equality operator for unit testing.
    bool operator==(const GoalLane &other) const
    {
        return this->lane == other.lane && this->threat_rating == other.threat_rating &&
               this->angle_to_goal == other.angle_to_goal;
    }
};
 
std::vector<DefenderAssignment> getAllDefenderAssignments(
    const std::vector<EnemyThreat> &threats, const Field &field, const Ball &ball,
    const TbotsProto::DefensePlayConfig::DefenderAssignmentConfig &config);
 
std::vector<EnemyThreat> filterOutSimilarThreats(const std::vector<EnemyThreat> &threats,
                                                 double min_distance,
                                                 const Angle &min_angle);
 
std::vector<std::vector<GoalLane>> groupGoalLanesByDensity(
    std::vector<GoalLane> &goal_lanes, double density_threshold);