| /* |
| * Copyright (C) 2017 Apple Inc. All rights reserved. |
| * Copyright (C) 2016-2017 Michael Saboff. All rights reserved. |
| * |
| * Redistribution and use in source and binary forms, with or without |
| * modification, are permitted provided that the following conditions |
| * are met: |
| * 1. Redistributions of source code must retain the above copyright |
| * notice, this list of conditions and the following disclaimer. |
| * 2. Redistributions in binary form must reproduce the above copyright |
| * notice, this list of conditions and the following disclaimer in the |
| * documentation and/or other materials provided with the distribution. |
| * |
| * THIS SOFTWARE IS PROVIDED BY APPLE INC. ``AS IS'' AND ANY |
| * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE |
| * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR |
| * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE INC. OR |
| * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, |
| * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, |
| * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR |
| * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY |
| * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |
| * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE |
| * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
| */ |
| "use strict"; |
| |
| let earthRadius = 3440; // In nautical miles. |
| let TwoPI = Math.PI * 2; |
| let degreeCharacter = "\u00b0"; |
| |
| let regExpOptionalUnicodeFlag; |
| var keywords; |
| |
| if (this.useUnicode) { |
| regExpOptionalUnicodeFlag = "u"; |
| keywords = UnicodeStrings; |
| } else { |
| regExpOptionalUnicodeFlag = ""; |
| keywords = { get: function(str) { return str; } }; |
| } |
| |
| function status(text) |
| { |
| console.debug("Status: " + text); |
| } |
| |
| function error(text) |
| { |
| console.error("Error: " + text); |
| } |
| |
| if (typeof(Number.prototype.toRadians) === "undefined") { |
| Number.prototype.toRadians = function() { |
| return this * Math.PI / 180; |
| } |
| } |
| |
| if (typeof(Number.prototype.toDegrees) === "undefined") { |
| Number.prototype.toDegrees = function() { |
| return this * 180 / Math.PI; |
| } |
| } |
| |
| function distanceFromSpeedAndTime(speed, time) |
| { |
| return speed * time.hours(); |
| } |
| |
| let LatRE = new RegExp("^([NS\\-])?(90|[0-8]?\\d)(?:( [0-5]?\\d\\.\\d{0,3})'?|(\\.\\d{0,6})|( ([0-5]?\\d)\" ?([0-5]?\\d)'?))?", "i" + regExpOptionalUnicodeFlag); |
| |
| function decimalLatitudeFromString(latitudeString) |
| { |
| if (typeof latitudeString != "string") |
| return 0; |
| |
| let match = latitudeString.match(LatRE); |
| |
| if (!match) |
| return 0; |
| |
| let result = 0; |
| let sign = 1; |
| |
| if (match[1] && (match[1].toUpperCase() == "S" || match[1] == "-")) |
| sign = -1; |
| |
| result = Number(match[2]); |
| |
| if (result != 90) { |
| if (match[3]) { |
| // e.g. N37 42.874 |
| let minutes = Number(match[3]); |
| result = result + (minutes / 60); |
| } else if (match[4]) { |
| // e.g. N37.30697 |
| let decimalDegrees = Number(match[4]); |
| result = result + decimalDegrees; |
| } else if (match[5]) { |
| // e.g. N37 18" 27' |
| let degrees = Number(match[6]); |
| let minutes = Number(match[7]); |
| result = result + (degrees + minutes / 60) / 60; |
| } |
| } |
| |
| return result * sign; |
| } |
| |
| let LongRE = new RegExp("^([EW\\-]?)(180|(?:1[0-7]|\\d)?\\d)(?:( [0-5]?\\d\\.\\d{0,3})|(\\.\\d{0,6})|( ([0-5]?\\d)\" ?([0-5]?\\d)'?)?)", "i" + regExpOptionalUnicodeFlag); |
| |
| function decimalLongitudeFromString(longitudeString) |
| { |
| if (typeof longitudeString != "string") |
| return 0; |
| |
| let match = longitudeString.match(LongRE); |
| |
| if (!match) |
| return 0; |
| |
| let result = 0; |
| let sign = 1; |
| |
| if (match[1] && (match[1].toUpperCase() == "W" || match[1] == "-")) |
| sign = -1; |
| |
| result = Number(match[2]); |
| |
| if (result != 180) { |
| if (match[3]) { |
| // e.g. W121 53.254 |
| let minutes = Number(match[3]); |
| result = result + (minutes / 60); |
| } else if (match[4]) { |
| // e.g. W121.8876 |
| let decimalDegrees = Number(match[4]); |
| result = result + decimalDegrees; |
| } else if (match[5]) { |
| // e.g. W121 53" 15' |
| let degrees = Number(match[6]); |
| let minutes = Number(match[7]); |
| result = result + (degrees + minutes / 60) / 60; |
| } |
| } |
| |
| return result * sign; |
| } |
| |
| let TimeRE = new RegExp("^([0-9][0-9]?)(?:\:([0-5][0-9]))?(?:\:([0-5][0-9]))?$"); |
| |
| class Time |
| { |
| constructor(time) |
| { |
| if (time instanceof Date) { |
| this._seconds = Math.Round(time.valueOf() / 1000); |
| return; |
| } |
| |
| if (typeof time == "string") { |
| let match = time.match(TimeRE); |
| |
| if (!match) { |
| this._seconds = 0; |
| return; |
| } |
| |
| if (match[3]) { |
| let hours = parseInt(match[1].toString()); |
| let minutes = parseInt(match[2].toString()); |
| let seconds = parseInt(match[3].toString()); |
| |
| this._seconds = (hours * 60 + minutes) * 60 + seconds; |
| } else if (match[2]) { |
| let minutes = parseInt(match[1].toString()); |
| let seconds = parseInt(match[2].toString()); |
| |
| this._seconds = minutes * 60 + seconds; |
| } else |
| this._seconds = parseInt(match[1].toString()); |
| return; |
| } |
| |
| if (typeof time == "number") { |
| this._seconds = Math.round(time); |
| return; |
| } |
| |
| this._seconds = 0; |
| } |
| |
| add(otherTime) |
| { |
| return new Time(this._seconds + otherTime._seconds); |
| } |
| |
| addDate(otherDate) |
| { |
| return new Date(this._seconds * 1000 + otherDate.valueOf()); |
| } |
| |
| static differenceBetween(time2, time1) |
| { |
| let seconds1; |
| let seconds2; |
| if (time1 instanceof Time) |
| seconds1 = time1.seconds(); |
| else |
| seconds1 = Math.Round(time1.valueOf() / 1000); |
| |
| if (time2 instanceof Time) |
| seconds2 = time2.seconds(); |
| else |
| seconds2 = Math.Round(time2.valueOf() / 1000); |
| |
| return new Time(seconds2 - seconds1); |
| } |
| |
| seconds() |
| { |
| return this._seconds; |
| } |
| |
| minutes() |
| { |
| return this._seconds / 60; |
| } |
| |
| hours() |
| { |
| return this._seconds / 3600; |
| } |
| |
| toString() |
| { |
| let result = ""; |
| let seconds = this._seconds % 60; |
| if (seconds < 0) { |
| result = "-"; |
| seconds = -seconds; |
| } |
| let minutes = this._seconds / 60 | 0; |
| let hours = minutes / 60 | 0; |
| minutes = minutes % 60; |
| |
| if (hours) |
| result = result + hours + ":"; |
| if (minutes < 10 && hours) |
| result = result + "0"; |
| result = result + minutes + ":"; |
| if (seconds < 10) |
| result = result + "0"; |
| result = result + seconds; |
| |
| return result; |
| } |
| } |
| |
| class GeoLocation |
| { |
| constructor(latitude, longitude) |
| { |
| this.latitude = latitude; |
| this.longitude = longitude; |
| } |
| |
| latitudeString() |
| { |
| let latitude = this.latitude; |
| let latitudePrefix = "N"; |
| if (latitude < 0) { |
| latitude = -latitude; |
| latitudePrefix = "S" |
| } |
| let latitudeDegrees = Math.floor(latitude); |
| let latitudeMinutes = ((latitude - latitudeDegrees) * 60).toFixed(3); |
| let latitudeMinutesFiller = latitudeMinutes < 10 ? " " : ""; |
| return latitudePrefix + latitudeDegrees + degreeCharacter + latitudeMinutesFiller + latitudeMinutes + "'"; |
| } |
| |
| longitudeString() |
| { |
| let longitude = this.longitude; |
| let longitudePrefix = "E"; |
| if (longitude < 0) { |
| longitude = -longitude; |
| longitudePrefix = "W" |
| } |
| |
| let longitudeDegrees = Math.floor(longitude); |
| let longitudeMinutes = ((longitude - longitudeDegrees) * 60).toFixed(3); |
| let longitudeMinutesFiller = longitudeMinutes < 10 ? " " : ""; |
| return longitudePrefix + longitudeDegrees + degreeCharacter + longitudeMinutesFiller + longitudeMinutes + "'"; |
| } |
| |
| distanceTo(otherLocation) |
| { |
| let dLat = (otherLocation.latitude - this.latitude).toRadians(); |
| let dLon = (otherLocation.longitude - this.longitude).toRadians(); |
| let a = Math.sin(dLat/2) * Math.sin(dLat/2) + |
| Math.cos(this.latitude.toRadians()) * Math.cos(otherLocation.latitude.toRadians()) * |
| Math.sin(dLon/2) * Math.sin(dLon/2); |
| let c = 2 * Math.atan2(Math.sqrt(a), Math.sqrt(1 - a)); |
| return earthRadius * c; |
| } |
| |
| bearingFrom(otherLocation, magneticVariation) |
| { |
| if (magneticVariation == undefined) |
| magneticVariation = 0; |
| |
| let dLon = (this.longitude - otherLocation.longitude).toRadians(); |
| let thisLatitudeRadians = this.latitude.toRadians(); |
| let otherLatitudeRadians = otherLocation.latitude.toRadians(); |
| let y = Math.sin(dLon) * Math.cos(this.latitude.toRadians()); |
| let x = Math.cos(otherLatitudeRadians) * Math.sin(thisLatitudeRadians) - |
| Math.sin(otherLatitudeRadians) * Math.cos(thisLatitudeRadians) * Math.cos(dLon); |
| return (Math.atan2(y, x).toDegrees() + 720 + magneticVariation) % 360; |
| } |
| |
| bearingTo(otherLocation, magneticVariation) |
| { |
| if (magneticVariation == undefined) |
| magneticVariation = 0; |
| |
| let dLon = (otherLocation.longitude - this.longitude).toRadians(); |
| let thisLatitudeRadians = this.latitude.toRadians(); |
| let otherLatitudeRadians = otherLocation.latitude.toRadians(); |
| let y = Math.sin(dLon) * Math.cos(otherLocation.latitude.toRadians()); |
| let x = Math.cos(thisLatitudeRadians) * Math.sin(otherLatitudeRadians) - |
| Math.sin(thisLatitudeRadians) * Math.cos(otherLatitudeRadians) * Math.cos(dLon); |
| return (Math.atan2(y, x).toDegrees() + 720 + magneticVariation) % 360 |
| } |
| |
| locationFrom(bearing, distance, magneticVariation) |
| { |
| if (magneticVariation == undefined) |
| magneticVariation = 0; |
| |
| let bearingRadians = (bearing - magneticVariation).toRadians(); |
| let thisLatitudeRadians = this.latitude.toRadians(); |
| let angularDistance = distance / earthRadius; |
| let latitudeRadians = Math.asin(Math.sin(thisLatitudeRadians) * Math.cos(angularDistance) + |
| Math.cos(thisLatitudeRadians) * Math.sin(angularDistance) * Math.cos(bearingRadians)); |
| let longitudeRadians = this.longitude.toRadians() + |
| Math.atan2(Math.sin(bearingRadians) * Math.sin(angularDistance) * Math.cos(thisLatitudeRadians), |
| Math.cos(angularDistance) - Math.sin(thisLatitudeRadians) * Math.sin(latitudeRadians)); |
| |
| return new GeoLocation(latitudeRadians.toDegrees(), longitudeRadians.toDegrees()); |
| } |
| |
| toString() |
| { |
| return "(" + this.latitudeString() + ", " + this.longitudeString() + ")"; |
| } |
| } |
| |
| function findFaaWaypoint(waypoint) |
| { |
| return faaWaypoints[waypoint]; |
| } |
| |
| class FaaWaypoints |
| { |
| constructor() |
| { |
| if (!FaaWaypoints.instance) { |
| FaaWaypoints.instance = this; |
| this.waypoints = _faaWaypoints; |
| } |
| |
| return FaaWaypoints.instance; |
| } |
| |
| find(waypoint) |
| { |
| return this.waypoints[waypoint]; |
| } |
| } |
| |
| FaaWaypoints.instance = undefined; |
| |
| let faaWaypoints = new FaaWaypoints(); |
| |
| class FaaAirways |
| { |
| constructor() |
| { |
| if (!FaaAirways.instance) { |
| FaaAirways.instance = this; |
| this.airways = _faaAirways; |
| } |
| |
| return FaaAirways.instance; |
| } |
| |
| isAirway(identifier) |
| { |
| return !!this.airways[identifier]; |
| } |
| |
| resolveAirway(airwayID, entryPoint, exitPoint) |
| { |
| let airway = this.airways[airwayID]; |
| |
| if (!airway) |
| return ""; |
| |
| let entryIndex = airway.fixes.indexOf(entryPoint); |
| let exitIndex = airway.fixes.indexOf(exitPoint); |
| |
| if (entryIndex == -1 || exitIndex == -1) |
| return ""; |
| |
| let stride = (entryIndex <= exitIndex) ? 1 : -1; |
| |
| let route = []; |
| |
| for (let idx = entryIndex; idx != exitIndex; idx = idx + stride) |
| route.push(airway.fixes[idx]); |
| |
| route.push(airway.fixes[exitIndex]); |
| |
| return route; |
| } |
| } |
| |
| FaaAirways.instance = undefined; |
| |
| let faaAirways = new FaaAirways(); |
| |
| class UserWaypoints |
| { |
| constructor() |
| { |
| if (!UserWaypoints.instance) { |
| UserWaypoints.instance = this; |
| this.waypoints = {}; |
| } |
| |
| return UserWaypoints.instance; |
| } |
| |
| clear() |
| { |
| this.waypoints = {}; |
| } |
| |
| find(waypoint) |
| { |
| return this.waypoints[waypoint]; |
| } |
| |
| update(name, description, latitude, longitude) |
| { |
| if (typeof latitude == "string") |
| latitude = decimalLatitudeFromString(latitude); |
| |
| if (typeof longitude == "string") |
| longitude = decimalLongitudeFromString(longitude); |
| |
| this.waypoints[name.toUpperCase()] = { |
| "name": name, |
| "description": description, |
| "latitude": latitude, |
| "longitude": longitude |
| }; |
| } |
| } |
| |
| UserWaypoints.instance = undefined; |
| |
| let userWaypoints = new UserWaypoints(); |
| |
| |
| class EngineConfig |
| { |
| constructor(type, fuelFlow, trueAirspeed) |
| { |
| this.type = type; |
| this._fuelFlow = fuelFlow; |
| this._trueAirspeed = trueAirspeed; |
| } |
| |
| trueAirspeed() |
| { |
| return this._trueAirspeed; |
| } |
| |
| fuelFlow() |
| { |
| return this._fuelFlow; |
| } |
| |
| static appendConfig(type, fuelFlow, trueAirspeed) |
| { |
| if (this.allConfigsByType[type]) { |
| status("Duplicate Engine configuration: " + type); |
| return; |
| } |
| |
| var newConfig = new EngineConfig(type, fuelFlow, trueAirspeed); |
| this.allConfigs.push(newConfig); |
| this.allConfigsByType[type] = newConfig; |
| } |
| |
| static getConfig(n) |
| { |
| if (n >= this.allConfigs.length) |
| return undefined; |
| |
| return this.allConfigs[n]; |
| } |
| } |
| |
| EngineConfig.allConfigs = []; |
| EngineConfig.allConfigsByType = {}; |
| EngineConfig.Taxi = 0; |
| EngineConfig.Runup = 1; |
| EngineConfig.Takeoff = 2; |
| EngineConfig.Climb = 3; |
| EngineConfig.Cruise = 4; |
| EngineConfig.Pattern= 5; |
| |
| class Waypoint |
| { |
| constructor(name, type, description, latitude, longitude) |
| { |
| this.name = name; |
| this.type = type; |
| this.description = description; |
| this.latitude = latitude; |
| this.longitude = longitude; |
| } |
| } |
| |
| class Leg |
| { |
| constructor(fix, location) |
| { |
| this.previous = undefined; |
| this.next = undefined; |
| this.fix = fix; |
| this.location = location; |
| this.course = 0; |
| this.distance = 0; |
| this.trueAirspeed = 0; |
| this.windDirection = 0; |
| this.windSpeed = 0; |
| this.heading = 0; |
| this.estGS = 0; |
| this.startFlightTiming = false; |
| this.stopFlightTiming = false; |
| this.engineConfig = EngineConfig.Cruise; |
| this.fuelFlow = 0; |
| this.distanceRemaining = 0; |
| this.estimatedTimeEnroute = undefined; |
| this.estTimeRemaining = 0; |
| this.estFuel = 0; |
| } |
| |
| fixName() |
| { |
| return this.fix; |
| } |
| |
| toString() |
| { |
| return this.fix; |
| } |
| |
| setPrevious(leg) |
| { |
| this.previous = leg; |
| } |
| |
| previousLeg() |
| { |
| return this.previous; |
| } |
| |
| setNext(leg) |
| { |
| this.next = leg; |
| } |
| |
| nextLeg() |
| { |
| return this.next; |
| } |
| |
| setWind(windDirection, windSpeed) |
| { |
| this.windDirection = windDirection; |
| this.windSpeed = windSpeed; |
| } |
| |
| isSameWind(windDirection, windSpeed) |
| { |
| return this.windDirection == windDirection && this.windSpeed == windSpeed; |
| } |
| |
| windToString() |
| { |
| if (!this.windSpeed) |
| return ""; |
| |
| return (this.windDirection ? this.windDirection : "360") + "@" + this.windSpeed; |
| } |
| |
| setTrueAirspeed(trueAirspeed) |
| { |
| this.trueAirspeed = trueAirspeed; |
| } |
| |
| isStandardTrueAirspeed() |
| { |
| |
| let engineConfig = EngineConfig.getConfig(this.engineConfig); |
| |
| return (this.trueAirspeed == engineConfig.trueAirspeed()); |
| } |
| |
| trueAirspeedToString() |
| { |
| return this.trueAirspeed + "kts"; |
| } |
| |
| updateDistanceAndBearing(other) |
| { |
| this.distance = this.location.distanceTo(other); |
| this.course = Math.round(this.location.bearingFrom(other)); |
| if (this.estimatedTimeEnroute == undefined && this.estGS != 0) { |
| let estimatedTimeEnrouteInSeconds = Math.round(this.distance * 3600 / this.estGS); |
| this.estimatedTimeEnroute = new Time(estimatedTimeEnrouteInSeconds); |
| } |
| |
| if (this.estimatedTimeEnroute.seconds()) |
| this.estFuel = this.fuelFlow * this.estimatedTimeEnroute.hours(); |
| } |
| |
| propagateWind() |
| { |
| let windDirection = this.windDirection; |
| let windSpeed = this.windSpeed; |
| |
| windDirection = (windDirection + 360) % 360; |
| if (!windDirection) |
| windDirection = 360; |
| |
| for (let currLeg = this; currLeg; currLeg = currLeg.nextLeg()) { |
| currLeg.windDirection = windDirection; |
| currLeg.windSpeed = windSpeed; |
| if (currLeg.stopFlightTiming) |
| break; |
| } |
| } |
| |
| updateForWind() |
| { |
| if (!this.windSpeed || !this.trueAirspeed) { |
| this.heading = this.course; |
| this.estGS = this.trueAirspeed; |
| return; |
| } |
| |
| let windDirectionRadians = this.windDirection.toRadians(); |
| let courseRadians = this.course.toRadians(); |
| let swc = (this.windSpeed / this.trueAirspeed) * Math.sin(windDirectionRadians - courseRadians); |
| if (Math.abs(swc) > 1) { |
| status("Wind to strong to fly!"); |
| return; |
| } |
| |
| let headingRadians = courseRadians + Math.asin(swc); |
| if (headingRadians < 0) |
| headingRadians += TwoPI; |
| if (headingRadians > TwoPI) |
| headingRadians -= TwoPI |
| let groundSpeed = this.trueAirspeed * Math.sqrt(1 - swc * swc) - |
| this.windSpeed * Math.cos(windDirectionRadians - courseRadians); |
| if (groundSpeed < 0) { |
| status("Wind to strong to fly!"); |
| return; |
| } |
| |
| this.estGS = groundSpeed; |
| this.heading = Math.round(headingRadians.toDegrees()); |
| } |
| |
| calculate() |
| { |
| let engineConfig = EngineConfig.getConfig(this.engineConfig); |
| |
| if (!this.trueAirspeed) |
| this.trueAirspeed = engineConfig.trueAirspeed(); |
| this.fuelFlow = engineConfig.fuelFlow(); |
| |
| this.updateForWind(); |
| } |
| |
| updateForward() |
| { |
| if (this.specialUpdateForward) |
| this.specialUpdateForward(); |
| |
| let previousLeg = this.previousLeg(); |
| let havePrevious = true; |
| if (!previousLeg) { |
| havePrevious = false; |
| previousLeg = this; |
| if (!this.estimatedTimeEnroute) |
| this.estimatedTimeEnroute = new Time(0); |
| } |
| |
| let thisLegType = this.type; |
| if (thisLegType == "Climb" && havePrevious) |
| this.location = previousLeg.location; |
| else { |
| this.updateDistanceAndBearing(previousLeg.location); |
| this.updateForWind(); |
| let nextLeg = this.nextLeg(); |
| let previousLegType = previousLeg.type; |
| if (havePrevious) { |
| if (previousLegType == "Climb") { |
| let climbDistance = distanceFromSpeedAndTime(previousLeg.estGS, previousLeg.climbTime); |
| if (climbDistance < this.distance) { |
| let climbStartLocation = previousLeg.location; |
| let climbEndLocation = climbStartLocation.locationFrom(this.course, climbDistance); |
| previousLeg.location = climbEndLocation; |
| previousLeg.updateDistanceAndBearing(climbStartLocation); |
| this.estimatedTimeEnroute = undefined; |
| this.updateDistanceAndBearing(climbEndLocation); |
| } else { |
| status("Not enough distance to climb in leg #" + previousLeg.index); |
| } |
| } else if ((thisLegType == "Left" || thisLegType == "Right") && nextLeg && nextLeg.location) { |
| let standardRateCircumference = this.trueAirspeed / 30; |
| let standardRateRadius = standardRateCircumference / TwoPI; |
| let offsetInboundBearing = 360 + previousLeg.course + (thisLegType == "Left" ? -90 : 90); |
| offsetInboundBearing = Math.round((offsetInboundBearing + 360) % 360); |
| // Save original location |
| if (!previousLeg.originalLocation) |
| previousLeg.originalLocation = previousLeg.location; |
| let previousLocation = previousLeg.originalLocation; |
| let inboundLocation = previousLocation.locationFrom(offsetInboundBearing, standardRateRadius); |
| let bearingToNext = Math.round(nextLeg.location.bearingFrom(previousLocation)); |
| let offsetOutboundBearing = bearingToNext + (thisLegType == "Left" ? 90 : -90); |
| offsetOutboundBearing = (offsetOutboundBearing + 360) % 360; |
| let outboundLocation = previousLocation.locationFrom(offsetOutboundBearing, standardRateRadius); |
| let turnAngle = thisLegType == "Left" ? (360 + bearingToNext - previousLeg.course) : (360 + previousLeg.course - bearingToNext); |
| turnAngle = (turnAngle + 360) % 360; |
| let totalDegrees = turnAngle + 360 * this.extraTurns; |
| let secondsInTurn = Math.round(totalDegrees / 3); |
| this.estimatedTimeEnroute = new Time(Math.round((turnAngle + 360 * this.extraTurns) / 3)); |
| this.estFuel = this.fuelFlow * this.estimatedTimeEnroute.hours(); |
| this.location = outboundLocation; |
| this.distance = distanceFromSpeedAndTime(this.trueAirspeed, this.estimatedTimeEnroute); |
| previousLeg.location = inboundLocation; |
| let prevPrevLeg = previousLeg.previousLeg(); |
| if (prevPrevLeg && prevPrevLeg.location) { |
| previousLeg.estimatedTimeEnroute = undefined; |
| previousLeg.updateDistanceAndBearing(prevPrevLeg.location); |
| } |
| } |
| } |
| } |
| } |
| |
| updateBackward() |
| { |
| let nextLeg = this.nextLeg(); |
| |
| let distanceRemaining; |
| let timeRemaining; |
| |
| if (nextLeg) { |
| distanceRemaining = nextLeg.distanceRemaining; |
| timeRemaining = nextLeg.estTimeRemaining; |
| } else { |
| distanceRemaining = 0; |
| timeRemaining = new Time(0); |
| } |
| |
| if (this.stopFlightTiming || timeRemaining.seconds()) { |
| this.distanceRemaining = distanceRemaining + this.distance;; |
| this.estTimeRemaining = timeRemaining.add(this.estimatedTimeEnroute); |
| } else |
| this.estTimeRemaining = new Time(0); |
| } |
| } |
| |
| let RallyLegWithFixRE = new RegExp("^([0-9a-z\.]{3,16})\\|(" + keywords.get("START") + "|" + keywords.get("TIMING") + ")", "i" + regExpOptionalUnicodeFlag); |
| |
| class RallyLeg extends Leg |
| { |
| constructor(type, fix, location, engineConfig) |
| { |
| super(fix, location); |
| this.type = type; |
| this.engineConfig = engineConfig; |
| } |
| |
| fixName() |
| { |
| return this.type; |
| } |
| |
| toString() |
| { |
| return this.fixName(); |
| } |
| |
| static reset() |
| { |
| RallyLeg.startLocation = undefined; |
| RallyLeg.startFix = ""; |
| RallyLeg.totalTaxiTime = new Time(0); |
| RallyLeg.taxiSegments = []; |
| } |
| |
| static fixNeeded(fix) |
| { |
| let match = fix.match(RallyLegWithFixRE); |
| |
| if (!match) |
| return ""; |
| |
| return match[1].toString(); |
| } |
| |
| static getLegWithFix(waypointText, fix, location) |
| { |
| let match = waypointText.match(RallyLegWithFixRE); |
| |
| if (!match) |
| return undefined; |
| |
| let legType = match[2].toString(); |
| |
| if (legType == keywords.get("START")) { |
| if (this.startLocation) { |
| status("Trying to create second start leg"); |
| return undefined; |
| } |
| |
| this.startLocation = location; |
| this.startFix = fix; |
| this.totalTaxiTime = new Time(0); |
| this.taxiSegments = []; |
| |
| return new StartLeg(waypointText, fix, location); |
| } |
| |
| if (legType == keywords.get("TIMING")) |
| return new TimingLeg(waypointText, fix, location); |
| |
| |
| error("Unhandled Rally Leg type " + legType); |
| return undefined; |
| } |
| } |
| |
| RallyLeg.startLocation = undefined; |
| RallyLeg.startFix = ""; |
| RallyLeg.totalTaxiTime = new Time(0); |
| RallyLeg.taxiSegments = []; |
| |
| class StartLeg extends RallyLeg |
| { |
| constructor(fixText, fix, location) |
| { |
| super("Start", fix, location, EngineConfig.Taxi); |
| } |
| |
| fixName() |
| { |
| return this.fix + "|Start"; |
| } |
| } |
| |
| class TimingLeg extends RallyLeg |
| { |
| constructor(fixText, fix, location) |
| { |
| super("Timing", fix, location, EngineConfig.Cruise); |
| this.stopFlightTiming = true; |
| } |
| |
| fixName() |
| { |
| return this.fix + "|Timing"; |
| } |
| } |
| |
| let RallyLegNoFixRE = new RegExp(keywords.get("TAXI") + "|" + keywords.get("RUNUP") + "|" + keywords.get("TAKEOFF") + "|" + keywords.get("CLIMB") + "|" + keywords.get("PATTERN") + "|" + keywords.get("LEFT") + "|" + keywords.get("RIGHT"), "i" + regExpOptionalUnicodeFlag); |
| |
| class RallyLegWithoutFix extends RallyLeg |
| { |
| constructor(type, CommentsAsFix, location, engineConfig) |
| { |
| super(type, CommentsAsFix, location, engineConfig); |
| } |
| |
| setPrevious(previous) |
| { |
| if (this.setLocationFromPrevious() && previous) |
| this.location = previous.location; |
| |
| super.setPrevious(previous); |
| } |
| |
| setLocationFromPrevious() |
| { |
| return false; |
| } |
| |
| static isRallyLegWithoutFix(fix) |
| { |
| let barPosition = fix.indexOf("|"); |
| let firstPart = barPosition < 0 ? fix : fix.substring(0, barPosition); |
| |
| return RallyLegNoFixRE.test(firstPart); |
| } |
| |
| static getLegNoFix(waypointText) |
| { |
| let barPosition = waypointText.indexOf("|"); |
| let firstPart = barPosition < 0 ? waypointText : waypointText.substring(0, barPosition); |
| firstPart = firstPart.toUpperCase(); |
| |
| let match = firstPart.match(RallyLegNoFixRE); |
| |
| if (!match) |
| return undefined; |
| |
| let legType = match[0].toString(); |
| |
| if (legType == keywords.get("TAXI")) |
| return new TaxiLeg(waypointText); |
| |
| if (legType == keywords.get("RUNUP")) |
| return new RunupLeg(waypointText); |
| |
| if (legType == keywords.get("TAKEOFF")) { |
| if (!this.startLocation) { |
| status("Trying to create a Takeoff leg without start leg"); |
| return undefined; |
| } |
| |
| return new TakeoffLeg(waypointText); |
| } |
| |
| if (legType == keywords.get("CLIMB")) |
| return new ClimbLeg(waypointText); |
| |
| if (legType == keywords.get("PATTERN")) |
| return new PatternLeg(waypointText); |
| |
| if (legType == keywords.get("LEFT") || legType == keywords.get("RIGHT")) |
| return new TurnLeg(waypointText, legType == keywords.get("RIGHT")); |
| |
| error("Unhandled Rally Leg type " + legType); |
| return undefined; |
| } |
| } |
| |
| // TAXI[|<time>] e.g. TAXI|2:30 |
| let TaxiLegRE = new RegExp("^" + keywords.get("TAXI") + "(?:\\|([0-9][0-9]?(?:\:[0-5][0-9])?))?$", "i" + regExpOptionalUnicodeFlag); |
| |
| class TaxiLeg extends RallyLegWithoutFix |
| { |
| constructor(fixText) |
| { |
| let match = fixText.match(TaxiLegRE); |
| |
| super("Taxi", "", new GeoLocation(-1, -1), EngineConfig.Taxi); |
| |
| let taxiTimeString = "5:00"; |
| if (match[1]) |
| taxiTimeString = match[1].toString(); |
| |
| this.estimatedTimeEnroute = new Time(taxiTimeString); |
| } |
| |
| setLocationFromPrevious() |
| { |
| return true; |
| } |
| |
| fixName() |
| { |
| return "Taxi|" + this.estimatedTimeEnroute.toString(); |
| } |
| } |
| |
| // RUNUP[|<time>] e.g. RUNUP|0:30 |
| let RunupLegRE = new RegExp("^" + keywords.get("RUNUP") + "(?:\\|([0-9][0-9]?(?:\:[0-5][0-9])?))?$", "i" + regExpOptionalUnicodeFlag); |
| |
| class RunupLeg extends RallyLegWithoutFix |
| { |
| constructor(fixText) |
| { |
| let match = fixText.match(RunupLegRE); |
| |
| super("Runup", "", new GeoLocation(-1, -1), EngineConfig.Runup); |
| |
| let runupTimeString = "30"; |
| if (match[1]) |
| runupTimeString = match[1].toString(); |
| |
| this.estimatedTimeEnroute = new Time(runupTimeString); |
| } |
| |
| setLocationFromPrevious() |
| { |
| return true; |
| } |
| |
| fixName() |
| { |
| return "Runup|" + this.estimatedTimeEnroute.toString(); |
| } |
| } |
| |
| // TAKEOFF[|<time>][|<bearing>|<distance>] e.g. TAKEOFF|2:00|270@3.5 |
| let TakeoffLegRE = new RegExp("^" + keywords.get("TAKEOFF") + "(?:\\|([0-9][0-9]?(?:\:[0-5][0-9])?))?(?:\\|([0-9]{1,2}|[0-2][0-9][0-9]|3[0-5][0-9]|360)(?:@)(\\d{1,2}(?:\\.\\d{1,4})?))?$", "i" + regExpOptionalUnicodeFlag); |
| |
| class TakeoffLeg extends RallyLegWithoutFix |
| { |
| constructor(fixText) |
| { |
| let match = fixText.match(TakeoffLegRE); |
| |
| let bearingFromStart = 0; |
| let distanceFromStart = 0; |
| let takeoffEndLocation = RallyLeg.startLocation; |
| if (match && match[2] && match[3]) { |
| bearingFromStart = parseInt(match[2].toString()) % 360; |
| distanceFromStart = parseFloat(match[3].toString()); |
| takeoffEndLocation = RallyLeg.startLocation.locationFrom(bearingFromStart, distanceFromStart); |
| } |
| |
| super("Takeoff", "", takeoffEndLocation, EngineConfig.Takeoff); |
| |
| this.bearingFromStart = bearingFromStart; |
| this.distanceFromStart = distanceFromStart; |
| |
| let takeoffTimeString = "2:00"; |
| if (match[1]) |
| takeoffTimeString = match[1].toString(); |
| |
| this.estimatedTimeEnroute = new Time(takeoffTimeString); |
| this.startFlightTiming = true; |
| } |
| |
| fixName() |
| { |
| let result = "Takeoff"; |
| |
| if (this.estimatedTimeEnroute.seconds() != 120) |
| result += "|" + this.estimatedTimeEnroute.toString(); |
| if (this.distanceFromStart) |
| result += "|" + this.bearingFromStart + "@" + this.distanceFromStart; |
| |
| return result; |
| } |
| } |
| |
| // CLIMB|<alt>|<time> e.g. CLIMB|5000|7:00 |
| let ClimbLegRE = new RegExp("^" + keywords.get("CLIMB") + "(?:\\|)(\\d{3,5})(?:\\|([0-9][0-9]?(?:\:[0-5][0-9])?))$", "i" + regExpOptionalUnicodeFlag); |
| |
| class ClimbLeg extends RallyLegWithoutFix |
| { |
| constructor(fixText) |
| { |
| let match = fixText.match(ClimbLegRE); |
| |
| let altitude = 5500; |
| if (match && match[1]) |
| altitude = match[1].toString(); |
| |
| super("Climb", altitude + "\"", undefined, EngineConfig.Climb); |
| |
| let timeToClimb = "8:00"; |
| if (match && match[2]) |
| timeToClimb = match[2].toString(); |
| |
| this.altitude = altitude; |
| this.climbTime = this.estimatedTimeEnroute = new Time(timeToClimb); |
| } |
| |
| setLocationFromPrevious() |
| { |
| return true; |
| } |
| |
| fixName() |
| { |
| return "Climb|" + this.altitude + "|" + this.estimatedTimeEnroute.toString(); |
| } |
| } |
| |
| // PATTERN|<time> e.g. PATTERN|0:30 |
| let PatternLegRE = new RegExp("^" + keywords.get("PATTERN") + "(?:\\|([0-9][0-9]?(?:\:[0-5][0-9])?))$", "i" + regExpOptionalUnicodeFlag); |
| |
| class PatternLeg extends RallyLegWithoutFix |
| { |
| constructor(fixText) |
| { |
| super("Pattern", "", undefined, EngineConfig.Pattern); |
| |
| let match = fixText.match(PatternLegRE); |
| let patternTimeString = match[1].toString(); |
| this.estimatedTimeEnroute = new Time(patternTimeString); |
| } |
| |
| setLocationFromPrevious() |
| { |
| return true; |
| } |
| |
| fixName() |
| { |
| return "Pattern|" + this.estimatedTimeEnroute.toString(); |
| } |
| } |
| |
| // {LEFT,RIGHT}[|+<extra_turns>] e.g. LEFT|2 |
| let TurnLegRE = new RegExp("^(" + keywords.get("LEFT") + "|" + keywords.get("RIGHT") + ")(?:\\|\\+(\\d))?$", "i"); |
| |
| class TurnLeg extends RallyLegWithoutFix |
| { |
| constructor(fixText, isRightTurn) |
| { |
| let match = fixText.match(TurnLegRE); |
| |
| let direction = "Left"; |
| if (match && match[1]) |
| direction = match[1].toString().toUpperCase() == keywords.get("LEFT") ? "Left" : "Right"; |
| |
| let engineConfig = EngineConfig.Cruise; |
| |
| super(direction, "", new GeoLocation(-1, -1), engineConfig); |
| |
| this.extraTurns = (match && match[2]) ? parseInt(match[2]) : 0; |
| } |
| |
| fixName() |
| { |
| let result = this.type; |
| if (this.extraTurns) |
| result += ("|+" + this.extraTurns); |
| |
| return result; |
| } |
| } |
| |
| let LegModifier = new RegExp("(360|3[0-5][0-9]|[0-2][0-9]{2}|[0-9]{1,2})@([0-9]{1,3})|([1-9][0-9]{1,2}|0)kts", "i"); |
| |
| class FlightPlan |
| { |
| constructor(name, route) |
| { |
| this._name = name; |
| this._route = route; |
| this._firstLeg = undefined; |
| this._lastLeg = undefined; |
| this._legCount = 0; |
| this._defaultWindDirection = 0; |
| this._defaultWindSpeed = 0; |
| this._trueAirspeedOverride = 0; |
| this._timeToGate = undefined; |
| this._estimatedTimeEnroute = undefined; |
| this._totalFuel = 0; |
| this._totalTime = new Time(); |
| this._gateTime = new Time(); |
| |
| RallyLeg.reset(); // Refactor to make this more OO |
| } |
| |
| clear() |
| { |
| } |
| |
| appendLeg(leg) |
| { |
| if (!this._firstLeg) |
| this._firstLeg = leg; |
| if (this._lastLeg) |
| this._lastLeg.setNext(leg); |
| leg.setPrevious(this._lastLeg); |
| leg.setNext(undefined); |
| |
| if (this._trueAirspeedOverride) { |
| leg.setTrueAirspeed(this._trueAirspeedOverride); |
| this.clearTrueAirspeedOverride(0); |
| } |
| |
| if (this._defaultWindSpeed) |
| leg.setWind(this._defaultWindDirection, this._defaultWindSpeed); |
| |
| this._lastLeg = leg; |
| this._legCount++; |
| } |
| |
| setDefaultWind(windDirection, windSpeed) |
| { |
| this._defaultWindDirection = windDirection; |
| this._defaultWindSpeed = windSpeed; |
| } |
| |
| clearTrueAirspeedOverride() |
| { |
| this._trueAirspeedOverride = 0; |
| } |
| |
| setTrueAirspeedOverride(trueAirspeed) |
| { |
| this._trueAirspeedOverride = trueAirspeed; |
| } |
| |
| isLegModifier(fix) |
| { |
| return LegModifier.test(fix); |
| } |
| |
| processLegModifier(fix) |
| { |
| let match = fix.match(LegModifier); |
| |
| if (match) { |
| if (match[1] && match[2]) { |
| let windDirection = parseInt(match[1].toString()) % 360; |
| let windSpeed = parseInt(match[2].toString()); |
| |
| this.setDefaultWind(windDirection, windSpeed); |
| } else if (match[3]) { |
| let trueAirspeed = parseInt(match[3].toString()); |
| this.setTrueAirspeedOverride(trueAirspeed); |
| } |
| } |
| } |
| |
| resolveWaypoint(waypointText) |
| { |
| if (this.isLegModifier(waypointText)) |
| this.processLegModifier(waypointText); |
| else if (RallyLegWithoutFix.isRallyLegWithoutFix(waypointText)) { |
| let rallyLeg = RallyLegWithoutFix.getLegNoFix(waypointText); |
| if (rallyLeg) |
| this.appendLeg(rallyLeg); |
| } else { |
| let fixName = RallyLeg.fixNeeded(waypointText); |
| let isRallyWaypoint = false; |
| |
| if (fixName) |
| isRallyWaypoint = true; |
| else |
| fixName = waypointText; |
| |
| let waypoint = userWaypoints.find(fixName); |
| if (!waypoint) |
| waypoint = faaWaypoints.find(fixName); |
| if (!waypoint) { |
| error("Couldn't find waypoint \"" + waypointText + "\""); |
| return; |
| } |
| |
| let location = new GeoLocation(waypoint.latitude, waypoint.longitude); |
| |
| if (isRallyWaypoint) { |
| let rallyLeg = RallyLeg.getLegWithFix(waypointText, fixName, location); |
| this.appendLeg(rallyLeg); |
| } else |
| this.appendLeg(new Leg(waypoint.name, location)); |
| } |
| } |
| |
| parseRoute() |
| { |
| let waypointsToLookup = this._route.split(/ +/); |
| let priorWaypoint = ""; |
| |
| for (let waypointIndex = 0; waypointIndex < waypointsToLookup.length; waypointIndex++) { |
| let currentWaypoint = waypointsToLookup[waypointIndex].toUpperCase(); |
| if (faaAirways.isAirway(currentWaypoint) && (waypointIndex + 1) < waypointsToLookup.length) { |
| let exitWaypointFix = waypointsToLookup[waypointIndex + 1]; |
| let airwayFixes = faaAirways.resolveAirway(currentWaypoint, priorWaypoint, exitWaypointFix); |
| |
| // We skip the entry and exit fixes, because they are handled in the prior / next |
| // iterations of the outer loop. |
| for (let airwayFixIndex = 1; airwayFixIndex < airwayFixes.length - 1; airwayFixIndex++) |
| this.resolveWaypoint(airwayFixes[airwayFixIndex]); |
| } else |
| this.resolveWaypoint(currentWaypoint); |
| |
| priorWaypoint = currentWaypoint; |
| } |
| } |
| |
| calculate() |
| { |
| if (!this._firstLeg) |
| return; |
| |
| let haveStartTiming = false; |
| let haveStopTiming = false; |
| for (let thisLeg = this._firstLeg; thisLeg; thisLeg = thisLeg.nextLeg()) { |
| thisLeg.calculate(); |
| if (thisLeg.startFlightTiming) { |
| if (haveStartTiming) |
| status("Have duplicate Start timing leg in row " + thisLeg.toString()); |
| haveStartTiming = true; |
| } |
| if (thisLeg.stopFlightTiming) { |
| if (haveStopTiming) |
| status("Have duplicate Timing leg in row " + thisLeg.toString()); |
| haveStopTiming = true; |
| } |
| } |
| |
| if (!haveStartTiming) |
| this._firstLeg.startFlightTiming = true; |
| if (!haveStopTiming) |
| this._lastLeg.stopFlightTiming = true; |
| |
| for (let thisLeg = this._firstLeg; thisLeg; thisLeg = thisLeg.nextLeg()) |
| thisLeg.updateForward(); |
| |
| for (let thisLeg = this._lastLeg; thisLeg; thisLeg = thisLeg.previousLeg()) |
| thisLeg.updateBackward(); |
| |
| for (let thisLeg = this._firstLeg; thisLeg; thisLeg = thisLeg.nextLeg()) { |
| if (thisLeg.startFlightTiming) |
| this._gateTime = thisLeg.estTimeRemaining; |
| } |
| |
| this._totalTime = this._firstLeg.estTimeRemaining; |
| } |
| |
| resolvedRoute() |
| { |
| let result = ""; |
| let lastWindDirection = 0; |
| let lastWindSpeed = 0; |
| |
| let legIndex = 0; |
| let currentLeg = this._firstLeg; |
| |
| for (; currentLeg; currentLeg = currentLeg.nextLeg(), legIndex++) { |
| |
| if (legIndex) |
| result = result + " "; |
| |
| if (!currentLeg.isSameWind(lastWindDirection, lastWindSpeed)) { |
| result = result + currentLeg.windToString() + " "; |
| lastWindDirection = currentLeg.windDirection; |
| lastWindSpeed = currentLeg.windSpeed; |
| } |
| |
| if (!currentLeg.isStandardTrueAirspeed()) |
| result = result + currentLeg.trueAirspeedToString() + " "; |
| |
| result = result + currentLeg.toString(); |
| } |
| |
| return result; |
| } |
| |
| name() |
| { |
| return this._name; |
| } |
| |
| totalTime() |
| { |
| return this._totalTime; |
| } |
| |
| gateTime() |
| { |
| return this._gateTime; |
| } |
| |
| toString() |
| { |
| let result = ""; |
| let lastWindDirection = 0; |
| let lastWindSpeed = 0; |
| |
| let legIndex = 0; |
| let currentLeg = this._firstLeg; |
| |
| for (; currentLeg; currentLeg = currentLeg.nextLeg(), legIndex++) { |
| |
| if (legIndex) |
| result = result + " "; |
| |
| if (!currentLeg.isSameWind(lastWindDirection, lastWindSpeed)) { |
| result = result + currentLeg.windToString() + " "; |
| lastWindDirection = currentLeg.windDirection; |
| lastWindSpeed = currentLeg.windSpeed; |
| } |
| |
| if (!currentLeg.isStandardTrueAirspeed()) |
| result = result + currentLeg.trueAirspeedToString() + " "; |
| |
| result = result + currentLeg.toString(); |
| result = result + " " + currentLeg.location + " " + currentLeg.distance.toFixed(2) + "nm " + currentLeg.estGS.toFixed(2) + "kts " + currentLeg.estimatedTimeEnroute + " "; |
| } |
| |
| if (this._gateTime) |
| result = result + " gate time " + this._gateTime; |
| |
| result = result + " total time " + this._firstLeg.estTimeRemaining; |
| return result; |
| } |
| } |
| |
| EngineConfig.appendConfig("Taxi", 2, 0); |
| EngineConfig.appendConfig("Runup", 8, 0); |
| EngineConfig.appendConfig("Takeoff", 27, 105); |
| EngineConfig.appendConfig("Climb", 22, 125); |
| EngineConfig.appendConfig("Cruise", 15, 142); |
| EngineConfig.appendConfig("Pattern", 11, 95); |
| |
| class ExpectedFlightPlan |
| { |
| constructor(name, route, expectedRoute, expectedTotalTime, expectedGateTime) |
| { |
| this._name = name; |
| this._route = route; |
| this._expectedRoute = expectedRoute; |
| this._expectedTotalTime = expectedTotalTime; |
| this._expectedGateTime = expectedGateTime; |
| } |
| |
| reset() |
| { |
| this._flightPlan = new FlightPlan(this._name, this._route); |
| } |
| |
| resolveRoute() |
| { |
| this._flightPlan.parseRoute(); |
| } |
| |
| calculate() |
| { |
| this._flightPlan.calculate(); |
| } |
| |
| checkExpectations() |
| { |
| if (this._expectedRoute) { |
| let computedRoute = this._flightPlan.resolvedRoute(); |
| if (this._expectedRoute != computedRoute) |
| error("Flight plan " + this._flightPlan.name() + " route different than expected (\"" + |
| this._expectedRoute + "\"), got (\"" + computedRoute + "\")"); |
| } |
| |
| if (this._expectedTotalTime) { |
| let computedTotalTime = this._flightPlan.totalTime(); |
| let deltaTime = Math.abs(Time.differenceBetween(this._expectedTotalTime, computedTotalTime).seconds()); |
| if (deltaTime > 5) |
| error("Flight plan " + this._flightPlan.name() + " total time different than expected (" + |
| this._expectedTotalTime + "), got (" + computedTotalTime + ")"); |
| } |
| |
| if (this._expectedGateTime) { |
| let computedGateTime = this._flightPlan.gateTime(); |
| let deltaTime = Math.abs(Time.differenceBetween(this._expectedGateTime, computedGateTime).seconds()); |
| if (deltaTime > 5) |
| error("Flight plan " + this._flightPlan.name() + " gate time different than expected (" + |
| this._expectedGateTime + "), got (" + computedGateTime + ")"); |
| } |
| } |
| } |
| |
| function setupUserWaypoints() |
| { |
| userWaypoints.clear(); |
| userWaypoints.update("Oilcamp", "Oil storage in the middle of no where", "36.68471", "-120.50277"); |
| userWaypoints.update("I5.Westshields", "I5 & West Shields", "36.77774", "-120.72426"); |
| userWaypoints.update("I5.165", "Intersection of I5 and CA165", "36.93022", "-120.84068"); |
| userWaypoints.update("I5.VOLTA", "I5 & Volta Road", "37.01419", "-120.92878"); |
| userWaypoints.update("PT.ALPHA", "Intersection of I5 and CA152", "37.05665", "-120.96990"); |
| userWaypoints.update("Jellysferry", "Jelly's Ferry bridge across Sacramento River", "N40 19.037", "W122 11.359"); |
| userWaypoints.update("Howie", "RDD Timing Point", "N40 21.893", "W122 13.042"); |
| userWaypoints.update("Hale", "2014 Leg 1 Timing", "N39 33.621", "W119 14.438"); |
| userWaypoints.update("Winnie", "2014 Leg 2 Timing", "N40 50.499", "W114 12.595"); |
| userWaypoints.update("WindRiver", "2014 Leg 3 Timing", "N42 43.733", "W108 38.800"); |
| userWaypoints.update("Buff", "2014 Leg 4 Timing", "N43 59.455", "W103 16.171"); |
| userWaypoints.update("Omega", "2014 Leg 5 Timing", "N44 53.388", "W95 38.935"); |
| userWaypoints.update("Paul", "2014 Leg 6 Timing", "N43 22.027", "W89 37.111"); |
| userWaypoints.update("MicrowaveSt", "2014 Microwave Station", "N40 24.89", "W117 12.37"); |
| userWaypoints.update("RanchTower", "2014 Ranch/Tower", "N41 6.16", "W115 5.43"); |
| userWaypoints.update("FremontIsland", "2014 Fremont Island", "N41 10.49", "W112 20.64"); |
| userWaypoints.update("Tremonton", "2014 Tremonton", "N41 42.86", "W112 11.05"); |
| userWaypoints.update("RandomPoint", "2014 Random Point", "N42", "W111 03"); |
| userWaypoints.update("Farson", "2014 Farson", "N42 6.40", "W109 26.95"); |
| userWaypoints.update("Midwest", "2014 Midwest", "N43 24.49", "W109 16.68"); |
| userWaypoints.update("Bill", "2014 Bill", "N43 13.96", "W105 15.60"); |
| userWaypoints.update("MMNHS", "2014 MMNHS", "N43 52.67", "W101 57.65"); |
| userWaypoints.update("Tracks", "2014 Tracks", "N44 21", "W100 22"); |
| userWaypoints.update("Towers", "2014 Towers", "N43 34.25", "W92 25.64"); |
| userWaypoints.update("IsletonBridge", "Isleton Bridge", "N38 10.32", "W121 35.62"); |
| userWaypoints.update("Mystery15", "2015 Mystery", "N38 46.22", "W122 34.25"); |
| userWaypoints.update("Paskenta", "Paskenta Town", "N39 53.13", "W122 32.36"); |
| userWaypoints.update("Bonanza", "Bonanza Town", "N42 12.15", "W121 24.53"); |
| userWaypoints.update("Silverlake", "Silverlake", "N43 07.41", "W121 03.74"); |
| userWaypoints.update("Millican", "Bend Timing Start", "N43 52.75", "W120 55.13"); |
| userWaypoints.update("Goering", "Bend Timing", "N44 05.751", "W120 56.834"); |
| userWaypoints.update("Constantia2", "Our Constantia Wpt", "N39 56.068", "W120 0.831"); |
| userWaypoints.update("Hallelujah2", "Reno Timing", "N39 46.509", "W120 2.336"); |
| userWaypoints.update("Redding.Pond", "Pond 6nm North of KRDD", "N40 36", "W122 17"); |
| userWaypoints.update("Thunderhill", "Thunder Hill Race Track", "N39 32.36", "W122 19.83"); |
| userWaypoints.update("CascadeHighway", "Cascade Wonderland Highway", "N40 46.63", "W122 19.12"); |
| userWaypoints.update("Eagleville", "Eagleville closed airport", "N41 18.73", "W120 3.00"); |
| userWaypoints.update("DuckLakePass", "Saddle near Duck Lake", "N41 3.00", "W120 3.00"); |
| } |
| |
| function createTestRoutes() |
| { |
| let flightPlans = [ |
| { name: "Rally Practice 1", route: "C83|Start Taxi|6:00 Runup|0:30 Taxi|1:00 Takeoff Climb|5500|5:00 CA67 0CN1 28CA 126kts I5.165 PT.ALPHA KLSN|Timing Pattern|0:45 Taxi|2:00" }, |
| { name: "Rally Practice 2", route: "C83|Start Taxi|6:00 Runup|0:30 Taxi|1:00 Takeoff Climb|5500|5:00 ECA 343@4 5CL3 67CA 314@12 126kts I5.165 126kts PT.ALPHA|Timing 126kts KLSN Pattern|0:45 Taxi|2:00" }, |
| { name: "Rally Practice 3", route: "KTCY|Start Taxi|6:00 Runup|0:30 Taxi|1:00 Takeoff Climb|3500|5:00 O27 67CA OILCAMP I5.WESTSHIELDS I5.165 I5.VOLTA PT.ALPHA|Timing KLSN Pattern|0:45 Taxi|2:00" }, |
| { name: "Rally Practice 4", route: "C83|Start Taxi|6:00 Runup|0:30 Taxi|1:00 Takeoff Climb|5500|5:00 62@3 9CL0 342@9 CL84 28CA 315@10 126kts I5.165 126kts PT.ALPHA|Timing 126kts KLSN Pattern|0:45 Taxi|2:00" }, |
| { name: "Rally Practice 5", route: "C83|Start Taxi|6:00 Runup|0:30 Taxi|1:00 Takeoff Climb|5500|7:00 O27 9CL0 CL01 I5.165 PT.ALPHA KLSN Pattern|0:45 Taxi|2:00" }, |
| { name: "2014 HWD Rally Leg 1", route: "KHWD|Start Taxi|6:00 Runup|0:30 Taxi|1:00 Takeoff Climb|5500|4:35 VPDUB Climb|8500|6:25 2CL9 Left|+1 09CL Left|+1 O02 Left|+1 77NV Left 126kts HALE|Timing KSPZ Pattern|0:45 Taxi|2:00"}, |
| { name: "2014 HWD Rally Leg 2", route: "KSPZ|Start Taxi|4:00 Runup|0:30 Taxi|1:00 Takeoff Climb|7500|9:00 NV30 Left MicrowaveSt Left DOBYS Left RanchTower Left 126kts Winnie|Timing KENV Pattern|0:45 Taxi|2:00"}, |
| { name: "2014 HWD Rally Leg 3", route: "KENV|Start Taxi|5:00 Runup|0:30 Taxi|1:00 Takeoff Climb|7500|8:30 FremontIsland Left|+1 Tremonton Left|+1 RandomPoint Left|+1 Farson Left 126kts WindRiver|Timing KLND Pattern|0:45 Taxi|2:00"}, |
| { name: "2014 HWD Rally Leg 4", route: "KLND|Start Taxi|6:00 Runup|0:30 Taxi|1:00 Takeoff Climb|7500|10:00 Midwest Left Bill Right|+1 WY09 Left KCUT Left 126kts BUFF|Timing KRAP Pattern|0:45 Taxi|2:00"}, |
| { name: "2014 HWD Rally Leg 5", route: "KRAP|Start Taxi|5:00 Runup|0:30 Taxi|3:00 Takeoff Climb|7500|9:00 MMNHS Left|+1 Tracks Left|+1 8D7 Left 5H3 Left 126kts Omega KMVE Pattern|0:45 Taxi|2:00"}, |
| { name: "2014 HWD Rally Leg 6", route: "KMVE|Start Taxi|6:00 Runup|0:30 Taxi|2:00 Takeoff Climb|5500|6:00 1D6 Left 68Y Right|+1 Towers Left KCHU Left 126kts Paul|Timing KMSN Pattern|0:45 Taxi|2:00"}, |
| { name: "2015 HWD Rally Leg 1", route: "KHWD|Start Taxi|6:00 Runup|0:30 Taxi|1:00 Takeoff Climb|5500|4:35 VPDUB Climb|5500|3:25 IsletonBridge Mystery15 Left|+1 71CL Left|+1 Paskenta Left|+1 O37 Left|+1 JELLYSFERRY HOWIE|Timing KRDD Pattern|0:45 Taxi|2:00"}, |
| { name: "2015 HWD Rally Leg 2", route: "KRDD|Start Taxi|6:00 Runup|0:30 Taxi|2:00 Takeoff Climb|8500|1:20 REDDING.POND Climb|8500|7:40 A26 O81 Left 340@6 Bonanza Left|+1 Silverlake Left|+1 Millican 126kts Goering|Timing KBDN pattern|30 taxi|2:00"}, |
| { name: "2016 HWD Rally Leg 1", route: "KHWD|Start Taxi|6:00 Runup|0:30 Taxi|1:00 Takeoff Climb|5500|4:35 VPDUB Climb|5500|3:25 65CN 3CN7 57CN Left|+1 2CL1 Left|+1 O37 Left|+1 JELLYSFERRY HOWIE|Timing KRDD Pattern|0:45 Taxi|2:00"}, |
| { name: "2016 HWD Rally Leg 2", route: "KRDD|Start Taxi|6:00 Runup|0:30 Taxi|2:00 Takeoff Climb|8500|1:20 REDDING.POND Climb|8500|7:40 O89 KAAT Left 1Q2 KSVE Left H37 Left CONSTANTIA2 HALLELUJAH2|Timing KRTS pattern|30 taxi|2:00"}, |
| { name: "2017 HWD Rally Leg 1", route: "KHWD|Start Taxi|6:00 Runup|0:30 Taxi|1:00 Takeoff Climb|4500|8:00 10@6 9CL9 63CL THUNDERHILL 60@10 90CL 0O4 350@10 126kts JELLYSFERRY 126kts HOWIE|Timing KRDD Pattern|0:45 Taxi|4:00" }, |
| { name: "2017 HWD Rally Leg 2", route: "KRDD|Start Taxi|6:00 Runup|0:30 Taxi|2:00 Takeoff Climb|8500|6:40 CASCADEHIGHWAY Climb|8500|8:20 KLKV 210@2 EAGLEVILLE DUCKLAKEPASS 210@5 O39 209@8 AHC 148@6 126kts CONSTANTIA2 126kts Hallelujah2|Timing KRTS Pattern|0:30 Taxi|2:00" }, |
| { name: "San Jose to San Diego", route: "KSJC LICKE SNS V25 REDIN KMYF" }, |
| { name: "San Diego to San Jose", route: "KMYF JOPDO CARIF V23 LAX V299 VTU V25 PRB SARDO RANCK V485 LICKE KSJC" }, |
| { name: "San Jose to Renton", route: "KSJC SUNOL RBL V23 SEA KRNT" }, |
| { name: "Renton to Willows", route: "KRNT SEA V495 BTG V23 RBL KWLW" }, |
| { name: "SJC to SEA #1", route: "ksjc sunol 135kts 300@12 rdd 0kts pdx ksea" }, |
| { name: "SJC to SEA #2", route: "KSJC SJC V334 SAC V23 BTG V495 SEA KSEA" }, |
| { name: "SJC to SEA #3", route: "KSJC SJC V334 SAC V23 FJS V495 SEA KSEA" }, |
| { name: "Roseburg to San Jose", route: "KRBG RBG KOLER V495 FJS V23 RBL SUNOL KSJC" }, |
| { name: "SAN to DEN", route: "KSAN HAILE V514 LYNSY V8 JNC V134 BINBE KDEN" }, |
| { name: "Denver to Minneapolis", route: "KDEN DVV V8 AKO V80 FSD V148 RWF V412 FCM KMSP" }, |
| { name: "Reno to Chicago", route: "KRNO FMG V6 LLC V32 CEVAR V200 STACO V32 FBR V6 MBW V100 RFD V171 SIMMN V172 DPA KORD" }, |
| { name: "Denver to Oklahoma City", route: "KDEN AVNEW V366 HGO V263 LAA V304 LBL V507 MMB V17 IRW KOKC" }, |
| { name: "Stockton to Hawthorne 1", route: "KSCK MOD V113 PXN V107 AVE V137 GMN V23 LAX KHHR" }, |
| { name: "Stockton to Hawthorne 2", route: "ksck patyy v113 rom v485 exert v25 lax khhr" }, |
| { name: "Long View to Corpus Christi", route: "KGGG PIPES V289 LFK V13 WORRY KCRP" }, |
| { name: "Austin Exec to Beaumont 1", route: "KEDC HOOKK V306 TNV V574 IAH V222 SHINA KBPT" }, |
| { name: "Austin Exec to Beaumont 2", route: "KEDC HOOKK V306 DAS KBPT" }, |
| { name: "Austin Exec to Beaumont 3", route: "KEDC HOOKK V306 TNV DAS KBPT" }, |
| { name: "Savannah to Daytona Beach", route: "KSAV KELER V437 COKES KDAB" }, |
| { name: "Philly to Hartford 1", route: "KPNE ARD V276 DIXIE V16 JFK V229 SNIVL KHFD" }, |
| { name: "Philly to Hartford 2", route: "KPNE ARD V276 MANTA V139 RICED MAD KHFD" }, |
| { name: "Philly to Hartford 3", route: "KPNE DITCH V312 DRIFT V139 SARDI V308 ORW KHFD" }, |
| { name: "Philly to Hartford 4", route: "KPNE ZIDET V479 ARD V433 LGA V99 YALER KHFD" }, |
| { name: "West Georgie Regional to Frankfort, KY 1", route: "kctj noone nello v5 gqo kfft" }, |
| { name: "West Georgie Regional to Frankfort, KY 2", route: "kctj felto v243 gqo v333 hyk v512 clegg kfft" }, |
| { name: "West Georgie Regional to Frankfort, KY 3", route: "kctj rmg v333 hyk v512 clegg kfft" }, |
| { name: "West Georgie Regional to Frankfort, KY 4", route: "kctj rmg v333 hch v51 lvt v493 hyk kfft" }, |
| { name: "Raleigh / Durham to Baltimore Martin State 1", route: "KRDU aimhi KMTN" }, |
| { name: "Raleigh / Durham to Baltimore Martin State 2", route: "KRDU rdu v155 lvl ric ott KMTN" }, |
| { name: "Raleigh / Durham to Baltimore Martin State 3", route: "KRDU rdu v155 mange v157 colin v33 ott v433 paleo KMTN" }, |
| { name: "Raleigh / Durham to Baltimore Martin State 4", route: "KRDU rdu v155 LVL V157 RIC V16 PXT V93 GRACO KMTN" }, |
| { name: "Roswell, NM to Longview, TX", route: "KROW Climb|9500|6:00 070@14 HOB V68 PIZON 050@16 V16 ABI V62 JEN V94 OTTIF KGGG" }, |
| { name: "Lubbock to Longview 1", route: "KLBB JEN CQY KGGG" }, |
| { name: "Lubbock to Longview 2", route: "KLBB ralls v102 gth v278 byp v114 awlar KGGG" }, |
| { name: "Lubbock to Longview 3", route: "KLBB hydro v62 jen v94 ottif KGGG" }, |
| { name: "Stockton, CA to North Las Vegas 1", route: "KSCK ECA V244 OAL V105 LUCKY KVGT" }, |
| { name: "Stockton, CA to North Las Vegas 2", route: "KSCK ehf v197 pmd v12 basal v394 oasys KVGT" }, |
| { name: "Bakersfield to Santa Rosa 1", route: "KBFL EHF V248 AVE OAK SAU KSTS" }, |
| { name: "Bakersfield to Santa Rosa 2", route: "KBFL EHF V248 AVE PXN V301 SUNOL KSTS" }, |
| { name: "Bakersfield to Santa Rosa 3", route: "KBFL SCRAP V248 AVE V107 OAK V195 CROIT V108 STS KSTS" }, |
| { name: "Bakersfield to Santa Rosa 4", route: "KBFL EHF V23 SAC V494 SNUPY KSTS" }, |
| { name: "Bakersfield to Santa Rosa 5", route: "KBFL EHF V248 AVE V137 SNS V230 SHOEY V27 PYE KSTS" }, |
| { name: "Bakersfield to Santa Rosa 6", route: "KBFL EHF V23 CZQ MOD OAKEY KSTS" }, |
| { name: "Bakersfield to Santa Rosa 7", route: "KBFL EHF V23 LIN CCR CROIT SGD KSTS" }, |
| { name: "Bakersfield to Santa Rosa 8", route: "KBFL EHF V248 AVE V107 PXN SGD KSTS" }, |
| { name: "Great Falls to Boeing King Field 1", route: "KGTF GTF V120 MLP V2 GEG V120 NORMY KBFI" }, |
| { name: "Great Falls to Boeing King Field 2", route: "KGTF GTF V120 MLP J70 SEA KBFI" }, |
| { name: "Great Falls to Boeing King Field 3", route: "KGTF GTF V187 ELN V2 SEA KBFI" }, |
| { name: "Great Falls to Boeing King Field 4", route: "KGTF KEETA Q144 ZIRAN KBFI" }, |
| { name: "Boise to Centenial 1", route: "KBOI BOI V4 LAR RAMMS NIWOT KAPA" }, |
| { name: "Boise to Centenial 2", route: "KBOI ROARR PIH J20 OCS J154 AVVVS KAPA" }, |
| { name: "Boise to Centenial 3", route: "KBOI CANEK V4 OCS V328 DOBEE V356 ELORE KAPA" }, |
| { name: "Boise to Centenial 4", route: "KBOI BOI J54 PIH J20 OCS J52 FQF KAPA" }, |
| { name: "St. Louis to Birmingham 1", route: "KSTL SPUDZ V125 DUEAS V540 CNG V67 SYI V321 BOAZE V115 COLIG KBHM" }, |
| { name: "St. Louis to Birmingham 2", route: "KSTL ODUJY FAM CGI JKS MSL VUZ KBHM" }, |
| { name: "Chattanoga to Augusta 1", route: "KCHA ODF AHN V417 MSTRS KAGS" }, |
| { name: "Chattanoga to Augusta 2", route: "KCHA GQO NELLO CCATT T292 JACET KAGS" }, |
| { name: "Chattanoga to Augusta 3", route: "KCHA GQO ATL ANNAN KAGS" }, |
| { name: "Chattanoga to Augusta 4", route: "KCHA HOCHE V5 AHN V417 IRQ KAGS" }, |
| { name: "Concord, NC to Richmond, VA 1", route: "KJQF SBV V20 RIC KRIC" }, |
| { name: "Concord, NC to Richmond, VA 2", route: "KJQF GIZMO V143 GSO V266 SBV V20 RIC KRIC" }, |
| { name: "Concord, NC to Richmond, VA 3", route: "KJQF GSO SBV V20 RIC KRIC" }, |
| { name: "Concord, NC to Richmond, VA 4", route: "KJQF GIZMO V454 LVL V157 RIC KRIC" }, |
| { name: "Buffalo, NY to Portland, ME 1", route: "KBUF BUF V2 UCA V496 NEETS V39 LIMER KPWM" }, |
| { name: "Buffalo, NY to Portland, ME 2", route: "KBUF HANKK AUDIL PUPPY GFL KPWM" }, |
| { name: "Buffalo, NY to Portland, ME 3", route: "KBUF BUF V14 GGT V428 UCA V496 ENE KPWM" }, |
| { name: "Buffalo, NY to Portland, ME 4", route: "KBUF JOSSY Q935 PONCT ARIME CDOGG ENE KPWM" }, |
| { name: "Moline, IL to Battle Creek, MI 1", route: "KMLI GENSO V8 NOMES V156 AZO KBTL" }, |
| { name: "Moline, IL to Battle Creek, MI 2", route: "KMLI OBK J547 PMM KBTL" }, |
| { name: "Moline, IL to Battle Creek, MI 3", route: "KMLI PLL OBK ELX KBTL" }, |
| { name: "Moline, IL to Battle Creek, MI 4", route: "KMLI PLL RFD V100 ELX AZO KBTL" }, |
| { name: "Green Bay, WI to Indianapolis, IN 1", route: "KGRB OKK V305 WELDO KIND" }, |
| { name: "Green Bay, WI to Indianapolis, IN 2", route: "KGRB GRB J101 BAE J89 OBK EON V24 VHP KIND" }, |
| { name: "Green Bay, WI to Indianapolis, IN 3", route: "KGRB WAFLE V7 BVT V399 ADVAY KIND" }, |
| { name: "Green Bay, WI to Indianapolis, IN 4", route: "KGRB WAFLE V7 BVT VHP KIND" }, |
| { name: "Anoka County, MN to Springfield, IL 1", route: "KANE KANAC V97 ODI V129 GROWL KSPI" }, |
| { name: "Anoka County, MN to Springfield, IL 2", route: "KANE GEP PRIOR FGT V411 RST V67 ULAXY KSPI" }, |
| { name: "Anoka County, MN to Springfield, IL 3", route: "KANE GEP PRIOR FGT V411 RST V503 CID V67 ULAXY KSPI" }, |
| { name: "Anoka County, MN to Springfield, IL 4", route: "KANE WAGNR V510 ODI V129 SPI KSPI" }, |
| { name: "Little Rock to Souix City 1", route: "KLIT MCI J41 OVR KSUX" }, |
| { name: "Little Rock to Souix City 2", route: "KLIT ROLAN V534 HAAWK V71 SGF V159 SUX KSUX" }, |
| { name: "Little Rock to Souix City 3 ", route: "KLIT ROLAN V534 SCRAN V527 RZC V13 BUM V71 PANNY KSUX" }, |
| { name: "Little Rock to Souix City 4", route: "KLIT ROLAN V534 SCRAN V527 RZC V13 EOS V307 CNU V131 TOP PWE SUX KSUX" } |
| ]; |
| |
| setupUserWaypoints(); |
| |
| print("let expectedFlightPlans = ["); |
| |
| for (let i = 0; i < flightPlans.length; ++i) { |
| let flightPlanName = flightPlans[i].name; |
| let flightPlanRoute = flightPlans[i].route; |
| let flightPlan = new FlightPlan(flightPlanName, flightPlanRoute); |
| flightPlan.parseRoute(); |
| flightPlan.calculate(); |
| let totalTime = flightPlan.totalTime(); |
| let gateTime = flightPlan.gateTime(); |
| let expectedGateTimeString; |
| if (Math.abs(Time.differenceBetween(totalTime, gateTime).seconds()) == 0) |
| expectedGateTimeString = "undefined"; |
| else |
| expectedGateTimeString = "new Time(\"" + gateTime + "\")"; |
| |
| print(" new ExpectedFlightPlan(\"" + flightPlanName + "\", \"" + flightPlanRoute + "\", \"" + |
| flightPlan.resolvedRoute() + "\", new Time(\"" + totalTime + "\"), " + expectedGateTimeString + "),"); |
| } |
| |
| print("];"); |
| |
| print("# Created " + flightPlans.length + " flight plans"); |
| } |
| |
| // createTestRoutes(); |
