// Experimental direct leg only; the original point envelope is unchanged.
class ERR_AircraftRouteRules
{
 static bool Length(float distance) { return distance >= 18 && distance <= 20.05; }
 // Candidate route-only gain. Desired speed and cyclic magnitude remain bounded
 // exactly as in the short-translation controller; landing keeps its old gain.
 static vector Demand(vector target, vector position, vector velocity)
 {
  vector error = target - position; error[1] = 0;
  vector desired = error * 0.25;
  float speed = desired.Length();
  if (speed > 0.5) desired = desired * (0.5 / speed);
  velocity[1] = 0;
  vector demand = (desired - velocity) * 0.10;
  float magnitude = demand.Length();
  if (magnitude > 0.03) demand = demand * (0.03 / magnitude);
  return demand;
 }
 static vector Nearest(vector start, vector end, vector point)
 {
  vector leg = end - start; leg[1] = 0;
  vector offset = point - start; offset[1] = 0;
  float squared = vector.Dot(leg, leg);
  if (!(squared > 0)) return start;
  return start + leg * Math.Clamp(vector.Dot(offset, leg) / squared, 0, 1);
 }
 static bool Contains(vector start, vector end, vector point, float upright)
 {
  if (!Length(vector.DistanceXZ(start, end))) return false;
  float height = point[1] - start[1];
  return height >= -3 && height <= 18 && upright >= 0.85 && vector.DistanceXZ(point, Nearest(start, end, point)) < 8;
 }
 static bool Held(bool contact, float height, float speed, float vertical, float upright, float horizontal, float error)
 {
  return !contact && ERR_AircraftFlightRules.Hover(height, speed, vertical, upright) && horizontal >= 0 && horizontal < 0.25 && error >= 0 && error <= 0.75;
 }
}

// Inherits the exact single-claim identity/clock guard, not caller-supplied validity.
class ERR_AircraftRouteEnvelope : ERR_AircraftFlightEnvelope
{
 protected vector m_Destination;
 vector Destination() { return m_Destination; }
 bool Contains(vector position, float upright) { return ERR_AircraftRouteRules.Contains(m_Home, m_Destination, position, upright); }
 // This deliberately qualifies a larger enclosing rectangle, not just endpoints.
 // Whole-model/rotor radius+8m deviation+1m margin already fits the 40m half-width.
 static bool Survey(vector start, vector end, array<IEntity> excluded = null)
 {
  if (!GetGame() || !GetGame().GetWorld() || !ERR_AircraftRouteRules.Length(vector.DistanceXZ(start, end))) return false;
  vector lower, upper;
  for (int axis = 0; axis < 3; axis++)
  {
   lower[axis] = Math.Min(start[axis], end[axis]);
   upper[axis] = Math.Max(start[axis], end[axis]);
  }
  // Near-level bare-ground route. Grid covers both pads and every possible
  // corridor landing centre plus the native gear footprint, at <=2m spacing.
  float spanX = upper[0] - lower[0] + 44, spanZ = upper[2] - lower[2] + 44;
  int columns = Math.Ceil(spanX / 2), rows = Math.Ceil(spanZ / 2);
  if (columns > 34 || rows > 34) return false;
  for (int x = 0; x <= columns; x++)
   for (int z = 0; z <= rows; z++)
   {
    vector sample = Vector(lower[0] - 22 + spanX * x / columns, 0, lower[2] - 22 + spanZ * z / rows);
    if (!(Math.AbsFloat(SCR_TerrainHelper.GetTerrainY(sample) - start[1]) <= 0.3)) return false;
   }
  vector centre = (lower + upper) * 0.5; centre[1] = start[1];
  vector half = (upper - lower) * 0.5; half[0] = half[0] + 40; half[2] = half[2] + 40;
  TraceBox corridor = new TraceBox();
  corridor.Start = centre + "0 3 0"; corridor.End = centre + "0 60 0";
  corridor.Mins = Vector(-half[0], -1, -half[2]); corridor.Maxs = Vector(half[0], 1, half[2]);
  corridor.Flags = TraceFlags.ENTS | TraceFlags.WORLD; corridor.ExcludeArray = excluded;
  if (!(GetGame().GetWorld().TraceMove(corridor, null) >= 1)) return false;
  // Separate low object sweep makes intermediate emergency landing ground as
  // conservative as both endpoints; WORLD is above because the ground is wanted.
  TraceBox low = new TraceBox(); low.Start = centre + "0 0.5 0"; low.End = centre + "0 3 0";
  low.Mins = Vector(-half[0], -0.2, -half[2]); low.Maxs = Vector(half[0], 0.2, half[2]);
  low.Flags = TraceFlags.ENTS; low.ExcludeArray = excluded;
  return GetGame().GetWorld().TraceMove(low, null) >= 1;
 }
 static ERR_AircraftRouteEnvelope QualifyRoute(ERR_GameMode mode, Vehicle aircraft, IEntity pilot, vector destination)
 {
  // Existing native qualification supplies health, seat, complete rotor/model
  // footprint, near-ground and exact original-airframe checks; no bypass.
  ERR_AircraftFlightEnvelope point = ERR_AircraftFlightEnvelope.Qualify(mode, aircraft, pilot);
  if (!point) return null;
  vector start = ERR_Actors.Ground(point.Home());
  vector end = ERR_Actors.Ground(destination);
  if (!ERR_AircraftRouteRules.Length(vector.DistanceXZ(start, end)) || !(end[1] >= 2) || !(Math.AbsFloat(end[1] - start[1]) <= 0.3)) return null;
  array<IEntity> excluded = {};
  if (!Hierarchy(aircraft, excluded) || !Hierarchy(pilot, excluded)) return null;
  if (!ClearColumn(aircraft, pilot, end) || !Survey(start, end, excluded)) return null;
  ERR_AircraftRouteEnvelope record = new ERR_AircraftRouteEnvelope();
  record.m_Mode = mode; record.m_Aircraft = aircraft; record.m_Pilot = pilot;
  record.m_Home = point.Home(); record.m_Radius = point.Radius();
  record.m_Destination = end; record.m_Destination[1] = record.m_Home[1];
  record.m_QualifiedAt = GetGame().GetWorld().GetWorldTime();
  return record;
 }
}