nav

package
v0.14.3 Latest Latest
Warning

This package is not in the latest version of its module.

 Go to latest Published: May 8, 2026 License: GPL-3.0 Imports: 15 Imported by: 0

Documentation

Index

Constants

View Source 
const (
	NavLogState    = "state"
	NavLogWaypoint = "waypoint"
	NavLogAltitude = "altitude"
	NavLogSpeed    = "speed"
	NavLogHeading  = "heading"
	NavLogApproach = "approach"
	NavLogCommand  = "command"
	NavLogRoute    = "route"
	NavLogHold     = "hold"
)

Available logging categories

View Source 
const MaxIAS = 290
View Source 
const MaximumRate = 100000
View Source 
const StandardTurnRate = 3

Variables

View Source 
var (
	ErrClearedForUnexpectedApproach = errors.New("Cleared for unexpected approach")
	ErrFixIsTooFarAway              = errors.New("Fix is too far away")
	ErrFixNotInRoute                = errors.New("Fix not in aircraft's route")
	ErrInvalidApproach              = errors.New("Invalid approach")
	ErrInvalidFix                   = errors.New("Invalid fix")
	ErrNotClearedForApproach        = errors.New("Aircraft has not been cleared for an approach")
	ErrNotFlyingRoute               = errors.New("Aircraft is not currently flying its assigned route")
	ErrUnableCommand                = errors.New("Unable")
	ErrUnknownApproach              = errors.New("Unknown approach")
)

Errors used by the nav package

Functions

func InitNavLog 

func InitNavLog(enabled bool, categories string, callsign string)

InitNavLog is a no-op in release builds

func LogRoute 

func LogRoute(callsign string, simTime Time, waypoints av.WaypointArray)

LogRoute is a no-op in release builds 

func NavLog(callsign string, simTime Time, category string, format string, args ...any)

NavLog is a no-op in release builds 

func NavLogEnabled(category string) bool

NavLogEnabled always returns false in release builds

func TurnAngle 

func TurnAngle(from, to math.MagneticHeading, turn av.TurnDirection) float32

Types

type DeferredNavHeading 

type DeferredNavHeading struct {
	Time    Time
	Heading *math.MagneticHeading
	Turn    *av.TurnDirection
	Hold    *FlyHold
	// For direct fix, this will be the updated set of waypoints.
	Waypoints []av.Waypoint
}

DeferredNavHeading stores a heading assignment from the controller and the time at which to start executing it; this time is set to be a few seconds after the controller issues it in order to model the delay before pilots start to follow assignments.

type DepartureHeadingState added in v0.14.0 

type DepartureHeadingState int

DepartureHeadingState describes the state of a departure's heading assignment. 

const (
	// NoHeading indicates no heading is assigned or upcoming
	NoHeading DepartureHeadingState = iota
	// OnHeading indicates the aircraft is currently flying an assigned heading
	OnHeading
	// TurningToHeading indicates the aircraft is about to turn to a heading
	TurningToHeading
)

type FlightState 

type FlightState struct {
	InitialDepartureClimb     bool
	DepartureAirportLocation  math.Point2LL
	DepartureAirportElevation float32
	ArrivalAirport            av.Waypoint
	ArrivalAirportLocation    math.Point2LL
	ArrivalAirportElevation   float32

	MagneticVariation float32
	NmPerLongitude    float32

	Position     math.Point2LL
	Heading      math.MagneticHeading
	Altitude     float32
	PrevAltitude float32
	IAS, GS      float32 // speeds...
	BankAngle    float32 // degrees
	AltitudeRate float32 // + -> climb, - -> descent
}

func (FlightState) LogValue 

func (fs FlightState) LogValue() slog.Value

func (*FlightState) Summary 

func (fs *FlightState) Summary() string

type FlyHold 

type FlyHold struct {
	Hold        av.Hold
	FixLocation math.Point2LL
	Entry       av.HoldEntry
	Maneuvers   []LateralManeuver
	Cancel      bool // when set, we end the hold after the last leg
}

func (*FlyHold) GetHeading 

func (fh *FlyHold) GetHeading(callsign string, nav *Nav, wxs wx.Sample, simTime Time) (math.MagneticHeading, av.TurnDirection, float32)

type FollowTraffic added in v0.14.3 

type FollowTraffic struct {
	Position math.Point2LL
	Route    av.WaypointArray
}

FollowTraffic describes a leader aircraft to sequence behind on a visual approach. Route (when non-empty) is the leader's own waypoints, used for tight in-trail spacing; Position alone is used as a join-point override on the reference approach.

type InterceptState 

type InterceptState int
const (
	NotIntercepting InterceptState = iota
	InitialHeading
	TurningToJoin
	OnApproachCourse
)

type LateralManeuver added in v0.14.2 

type LateralManeuver struct {
	Heading              math.MagneticHeading // heading to fly
	Track                math.MagneticHeading // if non-zero, wind-corrected heading via headingForTrack
	FlyToward            math.Point2LL        // if non-zero, heading = bearing to this point each tick
	Turn                 av.TurnDirection
	Until                ManeuverComplete
	AssignAltitude       *float32 // if non-nil, set nav.Altitude when this maneuver becomes active
	ClearAltitudeOnFinal bool
	Fix                  string
	Actions              av.WaypointActions
}

LateralManeuver describes a single phase of flight: fly a heading, track, or dynamically selected point until a condition is met. A sequence of LateralManeuvers forms a procedure turn, hold circuit, or ordered heading-leg instruction.

func (*LateralManeuver) String added in v0.14.2 

func (m *LateralManeuver) String() string

type ManeuverComplete added in v0.14.2 

type ManeuverComplete struct {
	Type     ManeuverCompleteType
	Heading  math.MagneticHeading // target heading (UntilHeading)
	Seconds  float32              // duration in seconds (UntilTime)
	Dist     float32              // distance in nm (UntilDist)
	Fix      math.Point2LL        // target fix (UntilFix, UntilIntercept)
	Altitude int                  // target altitude (UntilAltitude)

	// UntilIntercept: inbound course to intercept and turn direction for the intercept turn.
	InterceptCourse math.MagneticHeading
	InterceptTurn   av.TurnDirection

	// UntilDME: DME distance from a fix.
	DMEDistance     float32
	DMEFix          math.Point2LL
	DMEFixElevation int

	// Lazy-init start state for time/distance conditions.
	Start    Time          // captured on first Done() call (UntilTime)
	StartPos math.Point2LL // captured on first Done() call (UntilDist)
}

ManeuverComplete encapsulates the completion condition for a lateral maneuver. Type selects the condition; the relevant field(s) provide its parameters. Time and distance conditions capture their start state lazily on first check.

func (*ManeuverComplete) Done added in v0.14.2 

func (mc *ManeuverComplete) Done(nav *Nav, simTime Time, wxs wx.Sample, targetHdg math.MagneticHeading) bool

type ManeuverCompleteType added in v0.14.2 

type ManeuverCompleteType int

ManeuverCompleteType discriminates maneuver completion conditions. 

const (
	UntilHeading                ManeuverCompleteType = iota // done when aircraft heading ≈ Until.Heading
	UntilTime                                               // done after Until.Seconds elapsed (lazy start)
	UntilDist                                               // done after Until.Dist nm flown (lazy start)
	UntilFix                                                // done when ETA to Until.Fix < 2s
	UntilIntercept                                          // done when shouldTurnToIntercept fires for course through Fix
	UntilControllerIntervention                             // never completes; lasts until controller issues a new instruction
	UntilAltitude                                           // done when reaching Until.Altitude
	UntilDME                                                // done when crossing Until.DMEDistance from Until.DMEFix
)
type Nav struct {
	FlightState FlightState
	Perf        av.AircraftPerformance
	Altitude    NavAltitude
	Speed       NavSpeed
	Heading     NavHeading
	Approach    NavApproach
	Airwork     *NavAirwork
	Prespawn    bool

	FixAssignments map[string]NavFixAssignment

	// DeferredNavHeading stores a heading/direct fix assignment from the
	// controller that the pilot has not yet started to follow.  Note that
	// only a single such assignment is stored; for example, if the
	// controller issues a first heading and then a second shortly
	// afterward, before the first has been followed, it's fine for the
	// second to override it.
	DeferredNavHeading *DeferredNavHeading

	// ExpectedDirectFix records a fix the pilot has been told to expect
	// direct to; when the actual direct instruction comes, there is less
	// delay since the pilot is prepared.
	ExpectedDirectFix string

	FinalAltitude float32
	Waypoints     av.WaypointArray

	PendingWaypointActionEvents []av.WaypointActionEvent

	Rand *rand.Rand
}

State related to navigation. Pointers are used for optional values; nil -> unset/unspecified.

func MakeArrivalNav 

func MakeArrivalNav(callsign av.ADSBCallsign, arr *av.Arrival, fp av.FlightPlan, perf av.AircraftPerformance,
	nmPerLongitude float32, magneticVariation float32, model *wx.Model, simTime Time, lg *log.Logger) *Nav

func MakeDepartureNav 

func MakeDepartureNav(callsign av.ADSBCallsign, fp av.FlightPlan, perf av.AircraftPerformance,
	assignedAlt, clearedAlt int, wp []av.Waypoint, randomizeAltitudeRange bool,
	nmPerLongitude float32, magneticVariation float32, model *wx.Model, simTime Time, lg *log.Logger) *Nav

func MakeOverflightNav 

func MakeOverflightNav(callsign av.ADSBCallsign, of *av.Overflight, fp av.FlightPlan, perf av.AircraftPerformance,
	nmPerLongitude float32, magneticVariation float32, model *wx.Model, simTime Time, lg *log.Logger) *Nav
func (nav *Nav) AfterFixAltitude(fix string, alt float32) av.CommandIntent
func (nav *Nav) AfterFixSpeed(fix string, sr *av.SpeedRestriction) av.CommandIntent
func (nav *Nav) AltitudeOurDiscretion() av.CommandIntent
func (nav *Nav) ApproachHeading(callsign string, wxs wx.Sample, simTime Time) (heading math.MagneticHeading, turn av.TurnDirection)
func (nav *Nav) AssignAltitude(alt float32, afterSpeed bool, simTime Time, delayReduction time.Duration) av.CommandIntent
func (nav *Nav) AssignCompoundSpeed(segments []av.CompoundSpeedSegment) av.CommandIntent
func (nav *Nav) AssignHeading(hdg math.MagneticHeading, turn av.TurnDirection, simTime Time, delayReduction time.Duration) av.CommandIntent
func (nav *Nav) AssignMach(mach float32, afterAltitude bool, temp av.Temperature) av.CommandIntent
func (nav *Nav) AssignSpeed(sr *av.SpeedRestriction, afterAltitude bool) av.CommandIntent
func (nav *Nav) AssignSpeedUntil(sr *av.SpeedRestriction, until *av.SpeedUntil) av.CommandIntent
func (nav *Nav) AssignedHeading() (math.MagneticHeading, bool)

AssignedHeading returns the aircraft's current heading assignment, if any, regardless of whether the pilot has yet started following it. 

func (nav *Nav) AssignedWaypoints() []av.Waypoint

AssignedWaypoints returns the route that should be flown following a controller instruction. If an instruction has been issued but the delay hasn't passed, these are different than the waypoints currently being used for navigation. 

func (nav *Nav) AtFixCleared(fix, id string, simTime Time, delayReduction time.Duration, straightIn bool) av.CommandIntent
func (nav *Nav) AtFixIntercept(fix string, simTime Time, delayReduction time.Duration) av.CommandIntent
func (nav *Nav) CancelApproachClearance() av.CommandIntent
func (nav *Nav) Check(lg *log.Logger)
func (nav *Nav) ClearedApproach(approach string, traffic *FollowTraffic, simTime Time, straightIn bool) av.CommandIntent
func (nav *Nav) ClearedVisualApproach(follow *FollowTraffic, lahsoRunway string) av.CommandIntent

ClearedVisualApproach finalizes a non-charted visual approach clearance for the runway named on Nav.Approach.Assigned (a synthesized VisualApproach). It picks the route the aircraft will fly:

  • If the aircraft has been committed to an ILS/Localizer reference (via "direct {fix}" or "at {fix} intercept the localizer"), the reference's own routes are installed so the localizer altitudes/centerline take effect.
  • Otherwise, when a leader's route is supplied via follow.Route, tight in-trail sequencing along that route is attempted first.
  • Otherwise, a synthetic descent profile (TOD/_3NM_FINAL anchors) is constructed from the visual references.
func (nav *Nav) ClimbViaSID(simTime Time) av.CommandIntent
func (nav *Nav) ContactMessage(reportingPoints []av.ReportingPoint, star string, runway string,
	reportHeading bool, isDeparture bool) *av.RadioTransmission
func (nav *Nav) CrossDMEAt(dist float32, ar *av.AltitudeRestriction, sr *av.SpeedRestriction) av.CommandIntent

CrossDMEAt inserts a synthetic crossing restriction at a given DME from the runway threshold of the currently cleared visual approach. The synthetic waypoint is placed along the approach route by walking backwards from the threshold accumulating track miles; if dist exceeds the total route length, the point is extrapolated backwards along the first leg. 

func (nav *Nav) CrossDistanceFromFixAt(fix string, dist float32, dir math.CardinalOrdinalDirection,
	ar *av.AltitudeRestriction, sr *av.SpeedRestriction) av.CommandIntent
func (nav *Nav) CrossFixAt(fix string, ar *av.AltitudeRestriction, sr *av.SpeedRestriction) av.CommandIntent
func (nav *Nav) DepartFixDirect(fixa string, fixb string) av.CommandIntent
func (nav *Nav) DepartFixHeading(fix string, hdg math.MagneticHeading) av.CommandIntent
func (nav *Nav) DepartOnCourse(alt float32, exit string, simTime Time)
func (nav *Nav) DepartureHeading() (int, DepartureHeadingState)

DepartureHeading returns the heading a departure will fly and its state. Returns the heading and state based on: - OnHeading: aircraft has an assigned heading - TurningToHeading: first waypoint has a heading (about to turn) - NoHeading: no assigned heading and first waypoint has no heading 

func (nav *Nav) DepartureMessage(sid string, reportHeading bool) *av.RadioTransmission
func (nav *Nav) DescendViaSTAR(simTime Time) av.CommandIntent
func (nav *Nav) DirectFix(fix string, turn av.TurnDirection, simTime Time, delayReduction time.Duration) av.CommandIntent
func (nav *Nav) DistanceAlongRoute(fix string) (float32, error)
func (nav *Nav) DistanceToEndOfApproach() (float32, error)

distanceToEndOfApproach returns the remaining distance to the last waypoint (usually runway threshold) of the currently assigned approach. 

func (nav *Nav) DivertToAirport(airport string)
func (nav *Nav) ETA(p math.Point2LL) float32

ETA returns the estimated time in seconds until the aircraft will arrive at `p`, assuming it is flying direct. 

func (nav *Nav) EnqueueDirectFix(wps []av.Waypoint, turn av.TurnDirection, simTime Time, delayReduction time.Duration)
func (nav *Nav) EnqueueHeading(hdg math.MagneticHeading, turn av.TurnDirection, approachCleared bool, simTime Time, delayReduction time.Duration)

EnqueueHeading enqueues the given heading assignment to be followed a few seconds in the future. It should only be called for heading changes due to controller instructions to the pilot and never in cases where the autopilot is changing the heading assignment. delayReduction is subtracted from the pilot-reaction delay (floored at zero) to offset latency already spent receiving the voice transmission. 

func (nav *Nav) EnqueueOnCourse(simTime Time)
func (nav *Nav) ExpectApproach(airport *av.Airport, approach string, runwayWaypoints map[string]av.WaypointArray) av.CommandIntent
func (nav *Nav) ExpectDirect(fix string) av.CommandIntent
func (nav *Nav) ExpediteClimb() av.CommandIntent
func (nav *Nav) ExpediteClimbThrough(throughAlt float32) av.CommandIntent
func (nav *Nav) ExpediteDescent() av.CommandIntent
func (nav *Nav) ExpediteDescentThrough(throughAlt float32) av.CommandIntent
func (nav *Nav) FlyPresentHeading(simTime Time, delayReduction time.Duration) av.CommandIntent
func (nav *Nav) GoAroundWithProcedure(altitude float32, runwayEndWP av.Waypoint)

GoAroundWithProcedure initiates a go-around with a defined procedure. The runwayEndWP waypoint should have Location (opposite threshold), FlyOver, Heading (outbound), AltitudeRestriction, and GoAroundContactController set. 

func (nav *Nav) GoodRateClimb() av.CommandIntent
func (nav *Nav) GoodRateDescent() av.CommandIntent
func (nav *Nav) GoodRateThrough(throughAlt float32) av.CommandIntent
func (nav *Nav) HoldAtFix(callsign string, fix string, hold *av.Hold) av.CommandIntent
func (nav *Nav) InterceptApproach(airport string, lg *log.Logger) av.CommandIntent
func (nav *Nav) InterceptedButNotCleared() bool
func (nav *Nav) IsAirborne() bool
func (nav *Nav) Mach(temp av.Temperature) float32
func (nav *Nav) MaintainMaximumForward() av.CommandIntent
func (nav *Nav) MaintainPresentSpeed() av.CommandIntent
func (nav *Nav) MaintainSlowestPractical() av.CommandIntent
func (nav *Nav) OnApproach(checkAltitude bool) bool
func (nav *Nav) OnExtendedCenterline(maxNmDeviation float32) bool

OnExtendedCenterline checks if the flight position is less than maxNmDeviation from the infinite line defined by the assigned approach localizer 

func (nav *Nav) RestoreSnapshot(snap NavSnapshot)

RestoreSnapshot restores nav state from a previously captured snapshot. The aircraft's physical state (FlightState) is NOT restored - only control assignments. 

func (nav *Nav) ResumeOwnNavigation() av.CommandIntent
func (nav *Nav) SayAltitude() av.CommandIntent
func (nav *Nav) SayHeading() av.CommandIntent
func (nav *Nav) SayIndicatedSpeed() av.CommandIntent
func (nav *Nav) SayMach(temp av.Temperature) av.CommandIntent
func (nav *Nav) SaySpeed(temp av.Temperature) av.CommandIntent
func (nav *Nav) Summary(fp av.FlightPlan, model *wx.Model, simTime Time, lg *log.Logger) string

Full human-readable summary of nav state for use when paused and mouse hover on the scope 

func (nav *Nav) TAS(temp av.Temperature) float32
func (nav *Nav) TakeSnapshot() NavSnapshot

TakeSnapshot captures the current controller-modifiable nav state for later rollback. 

func (nav *Nav) TargetAltitude() (float32, float32, bool)

TargetAltitude returns the target altitude, the rate to use (ft/min), and whether the descent is geometric (following a computed glidepath to a fix). 

func (nav *Nav) TargetHeading(callsign string, wxs wx.Sample, simTime Time) (heading math.MagneticHeading, turn av.TurnDirection, rate float32)
func (nav *Nav) TargetSpeed(targetAltitude float32, fp *av.FlightPlan, wxs wx.Sample, bravo *av.AirspaceGrid) (float32, float32)
func (nav *Nav) Update(callsign string, model *wx.Model, fp *av.FlightPlan, simTime Time, bravo *av.AirspaceGrid) UpdateResult
func (nav *Nav) UpdateWithWeather(callsign string, wxs wx.Sample, fp *av.FlightPlan, simTime Time, bravo *av.AirspaceGrid) UpdateResult

UpdateWithWeather is a helper for simulations that use pre-fetched weather 

type NavAirwork struct {
	Radius   float32
	Center   math.Point2LL
	AltRange [2]float32

	RemainingSteps  int
	NextMoveCounter int
	Heading         math.MagneticHeading
	TurnRate        float32
	TurnDirection   av.TurnDirection
	IAS             float32
	Altitude        float32
	Dive            bool
	ToCenter        bool
}

func StartAirwork 

func StartAirwork(wp av.Waypoint, nav Nav) *NavAirwork
func (aw *NavAirwork) Start360(nav Nav)
func (aw *NavAirwork) TargetAltitude() (float32, float32, bool)
func (aw *NavAirwork) TargetHeading() (math.MagneticHeading, av.TurnDirection, float32)
func (aw *NavAirwork) TargetSpeed() (float32, float32, bool)
func (aw *NavAirwork) Update(nav *Nav) bool
type NavAltitude struct {
	Assigned        *float32 // controller-assigned altitude (not yet in autopilot)
	ActiveAssigned  *float32 // assigned altitude currently used for vertical guidance
	ActivateAt      Time     // non-zero while Assigned is pending activation
	Cleared         *float32 // from initial clearance
	AfterSpeed      *float32
	AfterSpeedSpeed *float32
	Rate            RateQualifier
	RateThrough     *float32      // revert to RateNormal after passing this altitude; nil = all the way
	RateAfterSpeed  RateQualifier // preserved across speed transitions

	// Carried after passing a waypoint if we were unable to meet the
	// restriction at the way point; we keep trying until we get there (or
	// are given another instruction..)
	Restriction *av.AltitudeRestriction
}
type NavApproach struct {
	Assigned                    *av.Approach
	AssignedId                  string
	ATPAVolume                  *av.ATPAVolume
	Cleared                     bool
	StandbyApproach             bool // suppress repeated approach clearance requests
	RequestApproachClearance    bool // pilot should radio for approach clearance
	GoAroundNoApproachClearance bool // pilot should go around (reached FAF without clearance)
	RequestVectors              bool // pilot should request vectors (overshot localizer)
	RequestAltitude             bool // pilot should request altitude after being vectored off STAR/approach
	InterceptState              InterceptState
	PassedApproachFix           bool // have we passed a fix on the approach yet?
	PassedFAF                   bool
	NoPT                        bool
	AtFixClearedRoute           []av.Waypoint
	AtFixInterceptFix           string           // fix where aircraft should intercept the localizer
	InterceptCourseLine         [2]math.Point2LL // cached course line for non-ILS intercepts
	InterceptWaypoints          []av.Waypoint    // cached remaining waypoints for non-ILS intercepts

	VisualReferences     []*av.Approach // Reference approaches for non-charted visual approach
	InterceptedReference *av.Approach   // Approach giving the committed-to route for a non-charted visual approach
}
func (na *NavApproach) HasLocalizer() bool

HasLocalizer reports whether the aircraft is currently flying localizer-style course geometry. 

type NavFixAssignment struct {
	Arrive struct {
		Altitude *av.AltitudeRestriction
		Speed    *av.SpeedRestriction
	}
	Depart struct {
		Fix         *av.Waypoint
		Heading     *math.MagneticHeading
		Turn        *av.TurnDirection
		Speed       *av.SpeedRestriction
		CancelSpeed bool // cancel speed restrictions when passing this fix
		Altitude    *float32
	}
	Hold *av.Hold
}
type NavHeading struct {
	Assigned   *math.MagneticHeading
	Turn       *av.TurnDirection
	Arc        *av.DMEArc
	JoiningArc bool
	Maneuvers  []LateralManeuver
	Hold       *FlyHold
}
type NavSnapshot struct {
	Altitude           NavAltitude
	Speed              NavSpeed
	Heading            NavHeading
	Approach           NavApproach
	Waypoints          av.WaypointArray
	DeferredNavHeading *DeferredNavHeading
	FixAssignments     map[string]NavFixAssignment
}

NavSnapshot captures all controller-modifiable state in Nav for rollback purposes. It does NOT include FlightState (aircraft physical position/heading/altitude) - only control assignments that can be rolled back. 

type NavSpeed struct {
	Assigned                 *av.SpeedRestriction // controller-assigned (exact or range)
	AfterAltitude            *av.SpeedRestriction // speed to apply after reaching assigned altitude
	AfterAltitudeAltitude    *float32
	MaintainSlowestPractical bool
	MaintainMaximumForward   bool
	// Carried after passing a waypoint
	Restriction *av.SpeedRestriction
}

type RateQualifier added in v0.14.3 

type RateQualifier int
const (
	RateNormal   RateQualifier = iota
	RateGood                   // faster than normal, not maximum
	RateExpedite               // maximum rate
)

type Time added in v0.14.3 

type Time struct {
	// contains filtered or unexported fields
}

Time represents simulation time in the nav package — the virtual clock that advances according to the sim rate, pauses, etc. It is a distinct type from time.Time so that sim-time and wall-clock time cannot be accidentally mixed.

func NewTime added in v0.14.3 

func NewTime(t time.Time) Time

NewTime wraps a time.Time as nav.Time.

func (Time) Add added in v0.14.3 

func (s Time) Add(d time.Duration) Time

func (Time) After added in v0.14.3 

func (s Time) After(o Time) bool

func (Time) Before added in v0.14.3 

func (s Time) Before(o Time) bool

func (Time) Compare added in v0.14.3 

func (s Time) Compare(o Time) int

func (Time) Equal added in v0.14.3 

func (s Time) Equal(o Time) bool

func (Time) Format added in v0.14.3 

func (s Time) Format(layout string) string

func (Time) Hour added in v0.14.3 

func (s Time) Hour() int

func (Time) IsZero added in v0.14.3 

func (s Time) IsZero() bool

func (Time) MarshalJSON added in v0.14.3 

func (s Time) MarshalJSON() ([]byte, error)

func (Time) MarshalMsgpack added in v0.14.3 

func (s Time) MarshalMsgpack() ([]byte, error)

func (Time) Minute added in v0.14.3 

func (s Time) Minute() int

func (Time) Second added in v0.14.3 

func (s Time) Second() int

func (Time) String added in v0.14.3 

func (s Time) String() string

func (Time) Sub added in v0.14.3 

func (s Time) Sub(o Time) time.Duration

func (Time) Time added in v0.14.3 

func (s Time) Time() time.Time

Time converts back to time.Time. Use when crossing out of the nav domain (e.g., weather lookups that need real timestamps).

func (Time) UTC added in v0.14.3 

func (s Time) UTC() Time

func (Time) UnixMilli added in v0.14.3 

func (s Time) UnixMilli() int64

func (*Time) UnmarshalJSON added in v0.14.3 

func (s *Time) UnmarshalJSON(b []byte) error

func (*Time) UnmarshalMsgpack added in v0.14.3 

func (s *Time) UnmarshalMsgpack(b []byte) error

type UpdateResult added in v0.14.3 

type UpdateResult struct {
	PassedWaypoint *av.Waypoint
	ActionEvents   []av.WaypointActionEvent
}

Source Files

View all Source files

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.