File target.h

File List > target.h

Go to the documentation of this file

#pragma once

#ifdef ARDUINO
    #include <Arduino.h>
#endif

#include <cstdint>
#include <memory>

#include "aproximate_math.hpp"
#include "fpm_adapter.hpp"
#include "spatial.h"
#include "utilities.h"
#include "vector.hpp"

using fixed = fixed_16_16;

class Target;

class Target {
public:
    // -- Constructors --
    Target() = default;
    Target(const Target& other) = default;
    Target(PositionVector P, VelocityVector V = VelocityVector(0, 0, 0));
    Target(
        uint8_t        index,
        bool           valid = false,
        PositionVector P = PositionVector(0, 0, 0),
        VelocityVector V = VelocityVector(0, 0, 0)
    );

    // -- Public Methods --
    void                 Update(PositionVector P);
    fixed                Pitch();
    fixed                Yaw();
    fixed                Distance();
    const VelocityVector Velocity() const;
    const PositionVector Position() const;
    TimeInterval         timeSinceLastAction() const;
    TimeInterval         timeSinceLastSeen() const;
    bool                 actionIdleExceeds(const ChronoDuration auto limit) const;
    bool                 idleExceeds(const ChronoDuration auto limit) const;
    bool                 actionable() const;
    void                 IncrementAction();
    PositionVector       PredictedPositionAtTime(ChronoDuration auto interval);
    const PositionVector InterceptAimpoint();

    // -- Public Attributes --
    bool      valid = false;
    uint8_t   index = 0;
    uint32_t  id = 0;
    TimePoint seen;
    TimePoint last_action;

private:
    std::shared_ptr<const PositionVector> interceptPosition() const;

    std::shared_ptr<const PositionVector> last_aimpoint = nullptr;
    // -- Private Attributes --
    TimePoint      last_seen;
    PositionVector position;
    PositionVector last_position;
    VelocityVector velocity;
};

// ======================================================================================
// --- Inline-Defined Methods ---
// ======================================================================================

// -- Target --

inline const PositionVector Target::InterceptAimpoint() {
    if (last_aimpoint == nullptr) {
        last_aimpoint = interceptPosition();
    }
    return *last_aimpoint;
}

inline Target::Target(PositionVector P, VelocityVector V): position(P), velocity(V) {}

inline Target::Target(uint8_t initial_index, bool initial_valid, PositionVector P, VelocityVector V):
    valid(initial_valid), index(initial_index), position(P), velocity(V) {}

inline PositionVector Target::PredictedPositionAtTime(ChronoDuration auto interval) {
    return PositionVector(position, velocity, interval);
}

inline bool Target::actionIdleExceeds(const ChronoDuration auto limit) const {
    return timeSinceLastAction() > limit;
}

inline bool Target::idleExceeds(const ChronoDuration auto limit) const {
    return timeSinceLastSeen() > limit;
}

inline const VelocityVector Target::Velocity() const {
    return velocity;
}

inline const PositionVector Target::Position() const {
    return position;
}

inline fixed Target::Distance() {
    return position.Distance();
}

inline TimeInterval Target::timeSinceLastAction() const {
    return TimeInterval(Clock::now() - last_action);
}

inline TimeInterval Target::timeSinceLastSeen() const {
    return TimeInterval(Clock::now() - seen);
}

inline void Target::IncrementAction() {
    last_action = Clock::now();
}

inline bool Target::actionable() const {
    return valid && actionIdleExceeds(fireActionInterval);
}