bool
AATPoint::SetRange(const fixed p, const bool force_if_current)
{
if (target_locked)
return false;
switch (GetActiveState()) {
case CURRENT_ACTIVE:
if (!HasEntered() || force_if_current) {
target_location = GetLocationMin().Interpolate(GetLocationMax(),p);
return true;
}
return false;
case AFTER_ACTIVE:
if (GetActiveState() == AFTER_ACTIVE) {
target_location = GetLocationMin().Interpolate(GetLocationMax(),p);
return true;
}
return false;
default:
return false;
}
}
void
AATPoint::SetTarget(const fixed range, const fixed radial,
const TaskProjection &proj)
{
fixed oldrange = fixed_zero;
fixed oldradial = fixed_zero;
GetTargetRangeRadial(oldrange, oldradial);
const FlatPoint fprev =
proj.ProjectFloat(GetPrevious()->GetLocationRemaining());
const FlatPoint floc = proj.ProjectFloat(GetLocation());
const FlatLine flb (fprev,floc);
const FlatLine fradius (floc,proj.ProjectFloat(GetLocationMin()));
const fixed bearing = fixed_minus_one * flb.angle().Degrees();
const fixed radius = fradius.d();
fixed swapquadrants = fixed_zero;
if (positive(range) != positive(oldrange))
swapquadrants = fixed(180);
const FlatPoint ftarget1 (fabs(range) * radius *
cos((bearing + radial + swapquadrants)
/ fixed(360) * fixed_two_pi),
fabs(range) * radius *
sin( fixed_minus_one * (bearing + radial + swapquadrants)
/ fixed(360) * fixed_two_pi));
const FlatPoint ftarget2 = floc + ftarget1;
const GeoPoint targetG = proj.Unproject(ftarget2);
SetTarget(targetG, true);
}
const GeoPoint &
ScoredTaskPoint::GetLocationScored() const
{
if (IsBoundaryScored() || !HasEntered())
return GetLocationMin();
return GetLocation();
}
const GeoPoint&
AATPoint::GetLocationRemaining() const
{
if (!IsPast())
return target_location;
if (HasSampled())
return GetLocationMax();
return GetLocationMin();
}
const GeoPoint&
AATPoint::GetLocationRemaining() const
{
if (GetActiveState() != BEFORE_ACTIVE)
return target_location;
if (HasSampled())
return GetLocationMax();
return GetLocationMin();
}
void
AATPoint::GetTargetRangeRadial(fixed &range, fixed &radial) const
{
const fixed oldrange = range;
const GeoPoint fprev = GetPrevious()->GetLocationRemaining();
const GeoPoint floc = GetLocation();
const Angle radialraw = (floc.Bearing(GetTargetLocation()) -
fprev.Bearing(floc)).AsBearing();
const fixed d = floc.Distance(GetTargetLocation());
const fixed radius = floc.Distance(GetLocationMin());
const fixed rangeraw = min(fixed_one, d / radius);
radial = radialraw.AsDelta().Degrees();
const fixed rangesign = (fabs(radial) > fixed(90)) ?
fixed_minus_one : fixed_one;
range = rangeraw * rangesign;
if ((oldrange == fixed_zero) && (range == fixed_zero))
radial = fixed_zero;
}
RangeAndRadial
AATPoint::GetTargetRangeRadial(fixed oldrange) const
{
const auto fprev = GetPrevious()->GetLocationRemaining();
const auto floc = GetLocation();
const auto radialraw = (floc.Bearing(GetTargetLocation()) -
fprev.Bearing(floc)).AsBearing();
auto radial = radialraw.AsDelta();
auto d = floc.Distance(GetTargetLocation());
if (radial < -Angle::QuarterCircle() || radial > Angle::QuarterCircle())
d = -d;
const auto radius = negative(d)
? floc.Distance(GetLocationMin())
: floc.Distance(GetLocationMax());
const auto range = Clamp(d / radius, fixed(-1), fixed(1));
if (oldrange == fixed(0) && range == fixed(0))
radial = Angle::Zero();
return RangeAndRadial{ range, radial };
}
void
AATPoint::SetTarget(RangeAndRadial rar, const FlatProjection &proj)
{
const auto fprev =
proj.ProjectFloat(GetPrevious()->GetLocationRemaining());
const auto floc = proj.ProjectFloat(GetLocation());
const FlatLine flb (fprev,floc);
const FlatLine fradius(floc,
proj.ProjectFloat(negative(rar.range)
? GetLocationMin()
: GetLocationMax()));
const auto radius = fradius.d() * fabs(rar.range);
const auto angle = rar.radial - flb.angle();
const FlatPoint ftarget1(radius * angle.cos(),
radius * -(angle).sin());
const auto ftarget2 = floc + ftarget1;
const auto targetG = proj.Unproject(ftarget2);
SetTarget(targetG, true);
}
const GeoPoint &GetLocationRemaining() const {
return GetLocationMin();
}
const GeoPoint &
ScoredTaskPoint::GetLocationRemaining() const
{
return GetLocationMin();
}
const GeoPoint &
ScoredTaskPoint::GetLocationTravelled() const
{
return GetLocationMin();
}
gcc_pure
GeoPoint InterpolateLocationMinMax(fixed p) const {
return GetLocationMin().Interpolate(GetLocationMax(), p);
}
/**
* Retrieve location to be used for the task already travelled.
* This is always the scored best location for prior-active task points.
*/
gcc_pure
const GeoPoint &GetLocationTravelled() const {
return GetLocationMin();
}
