# A3XX FMGC Flightplan Driver # Copyright (c) 2022 Josh Davidson (Octal450) and Jonathan Redpath (legoboyvdlp) var wpDep = nil; var wpArr = nil; var pos = nil; var geoPosPrev = geo.Coord.new(); var currentLegCourseDist = nil; var courseDistanceFrom = nil; var sizeWP = nil; var magTrueError = 0; var storeCourse = nil; var DEBUG_DISCONT = 0; # Props.getNode var magHDG = props.globals.getNode("/orientation/heading-magnetic-deg", 1); var trueHDG = props.globals.getNode("/orientation/heading-deg", 1); var flightPlanController = { flightplans: [createFlightplan(), createFlightplan(), createFlightplan(), nil], temporaryFlag: [0, 0], # These flags are only for the main flgiht-plan active: props.globals.initNode("/autopilot/route-manager/active", 0, "BOOL"), changed: props.globals.initNode("/autopilot/route-manager/flightplan-changed", 0, "BOOL"), currentToWpt: nil, # container for the current TO waypoint ghost currentToWptIndex: props.globals.initNode("/autopilot/route-manager/current-wp", 1, "INT"), currentToWptIndexTemp: 0, currentToWptIndexTemp2: 0, currentToWptID: props.globals.initNode("/autopilot/route-manager/wp[0]/id", "", "STRING"), courseToWpt: props.globals.initNode("/autopilot/route-manager/wp[0]/true-bearing-deg", 0, "DOUBLE"), courseMagToWpt: props.globals.initNode("/autopilot/route-manager/wp[0]/bearing-deg", 0, "DOUBLE"), distToWpt: props.globals.initNode("/autopilot/route-manager/wp[0]/dist", 0, "DOUBLE"), wptType: nil, wptTypeNoAdvanceDelete: 0, # Temporary flightplan will use flightplan[0] and flightplan[1] num: [props.globals.initNode("/FMGC/flightplan[0]/num", 0, "INT"), props.globals.initNode("/FMGC/flightplan[1]/num", 0, "INT"), props.globals.initNode("/autopilot/route-manager/route/num", 0, "INT")], arrivalIndex: [0, 0, 0], arrivalDist: props.globals.getNode("/autopilot/route-manager/distance-remaining-nm"), fromWptTime: nil, fromWptAlt: nil, _timeTemp: nil, _altTemp: nil, decelPoint: nil, init: func() { me.resetFlightplan(2); me.insertPPOS(2); me.addDiscontinuity(1, 2, 1); me.flightPlanChanged(2); me.flightplans[2].activate(); }, reset: func() { me.temporaryFlag[0] = 0; me.temporaryFlag[1] = 0; me.resetFlightplan(0); me.resetFlightplan(1); me.resetFlightplan(2); me.decelPoint = nil; setprop("/instrumentation/nd/symbols/decel/show", 0); me.flightplans[2].activate(); }, resetFlightplan: func(n) { me.flightplans[n].cleanPlan(); me.flightplans[n].departure = nil; me.flightplans[n].destination = nil; mcdu.isNoTransArr[n] = 0; mcdu.isNoTransDep[n] = 0; mcdu.isNoSid[n] = 0; mcdu.isNoStar[n] = 0; mcdu.isNoVia[n] = 0; me.arrivalIndex[n] = 0; # reset arrival index calculations }, oldCurrentWp: 0, createTemporaryFlightPlan: func(n) { me.resetFlightplan(n); me.flightplans[n] = me.flightplans[2].clone(); me.temporaryFlag[n] = 1; if (canvas_mcdu.myDirTo[n] != nil) { canvas_mcdu.myDirTo[n].updateTmpy(); } if (canvas_mcdu.myHold[n] != nil) { canvas_mcdu.myHold[n].updateTmpy(); } if (canvas_mcdu.myAirways[n] != nil) { canvas_mcdu.myAirways[n].updateTmpy(); } fmgc.windController.createTemporaryWinds(n); me.oldCurrentWp = FPLN.currentWP.getValue(); me.flightPlanChanged(n); }, loadFlightPlan: func(path) { call(func { me.flightplans[3] = createFlightplan(path); }, nil, var err = []); if (size(err) or me.flightplans[3] == nil) { print(err[0]); print("Load failed."); } me.destroyTemporaryFlightPlan(3, 1); }, destroyTemporaryFlightPlan: func(n, a) { # a = 1 activate, a = 0 erase, s = 0 don't call flightplan changed if (a == 1) { flightPlanTimer.stop(); me.resetFlightplan(2); me.flightplans[2] = me.flightplans[n].clone(); me.flightplans[2].activate(); if (n != 3) { if (mcdu.isNoSid[n] == 1) { mcdu.isNoSid[2] = 1; } else { mcdu.isNoSid[2] = 0; } if (mcdu.isNoStar[n] == 1) { mcdu.isNoStar[2] = 1; } else { mcdu.isNoStar[2] = 0; } if (mcdu.isNoVia[n] == 1) { mcdu.isNoVia[2] = 1; } else { mcdu.isNoVia[2] = 0; } if (mcdu.isNoTransDep[n] == 1) { mcdu.isNoTransDep[2] = 1; } else { mcdu.isNoTransDep[2] = 0; } if (mcdu.isNoTransArr[n] == 1) { mcdu.isNoTransArr[2] = 1; } else { mcdu.isNoTransArr[2] = 0; } } me.flightPlanChanged(2); flightPlanTimer.start(); } if (n == 3) { me.flightPlanChanged(n); return; } me.temporaryFlag[n] = 0; me.flightPlanChanged(2); me.resetFlightplan(n); if (canvas_mcdu.myDirTo[n] != nil) { canvas_mcdu.myDirTo[n].updateTmpy(); } if (me.DirToIndex != nil) { me.currentToWptIndex.setValue(me.DirToIndex); me.DirToIndex = nil; } fmgc.windController.destroyTemporaryWinds(n, a); # TODO - handle changed wpt order if (FPLN.currentWP.getValue() != me.oldCurrentWp) { FPLN.currentWP.setValue(me.oldCurrentWp); } me.flightPlanChanged(n); }, updateAirports: func(dep, arr, plan) { me.resetFlightplan(plan); me.flightplans[plan].departure = airportinfo(dep); me.flightplans[plan].destination = airportinfo(arr); if (plan == 2) { if (me.temporaryFlag[0]) { me.destroyTemporaryFlightPlan(0, 0); } if (me.temporaryFlag[1]) { me.destroyTemporaryFlightPlan(1, 0); } me.arrivalIndex = [0, 0, 0]; # reset arrival index calculations } me.addDiscontinuity(1, plan); # reset mcdu if it exists if (canvas_mcdu.myFpln[0] != nil) { canvas_mcdu.myFpln[0].scroll = 0; } if (canvas_mcdu.myFpln[1] != nil) { canvas_mcdu.myFpln[1].scroll = 0; } if (canvas_mcdu.myArrival[0] != nil) { canvas_mcdu.myArrival[0].reset(); } if (canvas_mcdu.myArrival[1] != nil) { canvas_mcdu.myArrival[1].reset(); } if (canvas_mcdu.myDeparture[0] != nil) { canvas_mcdu.myDeparture[0].reset(); } if (canvas_mcdu.myDeparture[1] != nil) { canvas_mcdu.myDeparture[1].reset(); } me.flightPlanChanged(plan); }, calculateTimeAltitudeOnSequence: func() { me._timeTemp = math.round(getprop("/sim/time/utc/minute") + (getprop("/sim/time/utc/second") / 60)); if (me._timeTemp < 10) { me._timeTemp = "0" ~ me._timeTemp; } me.fromWptTime = getprop("/sim/time/utc/hour") ~ me._timeTemp; me._altTemp = getprop("/systems/navigation/adr/output/baro-alt-corrected-1-capt"); if (me._altTemp > fmgc.FMGCInternal.transAlt) { me.fromWptAlt = "FL" ~ math.round(me._altTemp / 100); } else { if (me._altTemp > 0) { me.fromWptAlt = math.round(me._altTemp); } else { me.fromWptAlt = "M" ~ math.round(me._altTemp); } } }, autoSequencing: func() { if (!me.active.getBoolValue()) { return; } me.calculateTimeAltitudeOnSequence(); # Advancing logic me.currentToWptIndexTemp = me.currentToWptIndex.getValue(); # TODO - after sequencing discontinuity, FPLN should show PPOS then DISCONTINUITY # Clearing that discontinuity is not allowed, you must exit using DIRTO, or else using NAV ARM and overfly # TODO - triple click - confirm, is it only with DES disengage, or also with the NAV loss? # TODO - I think that it only goes to VS when in DES mode if (me.flightplans[2].getWP(me.currentToWptIndexTemp + 1).wp_type == "discontinuity") { fmgc.Input.lat.setValue(3); } else { me.currentToWptIndex.setValue(me.currentToWptIndexTemp + 1); if (me.num[2].getValue() > 2 and me.currentToWptIndexTemp >= 1) { for (var i = 0; i <= 2; i += 1) { if (i == 2 or me.temporaryFlag[i]) { me.flightplans[i].getWP(me.currentToWptIndexTemp - 1).hidden = 1; } } } } }, # changeOverflyType - toggle flyby type of passed waypoint # args: index, plan, computer # index: index to toggle # plan: plan on which operation is performed # If the passed waypoint exists, toggle its flyover attribute changeOverFlyType: func(index, plan) { wp = me.flightplans[plan].getWP(index); if (wp == nil or wp.wp_name == "DISCONTINUITY" or wp.wp_name == "VECTORS") { return 1; }; wp.fly_type = (wp.fly_type == "flyBy") ? "flyOver" : "flyBy"; return 2; }, # for these two remember to call flightPlanChanged. We are assuming this is called from a function which will all flightPlanChanged itself. # addDiscontinuity - insert discontinuity at passed index # args: index, plan # index: index to add at # plan: plan to add to # Check if a discontinuity already exists either immediately before or at that index # If it does, don't add another one # Optional flag DEBUG_DISCONT to disable discontinuities totally addDiscontinuity: func(index, plan, force = 0) { if (DEBUG_DISCONT) { return; } if (force) { me.flightplans[plan].insertWP(createDiscontinuity(), index); } if (me.flightplans[plan].getWP(index) != nil) { # index is not nil if (me.flightplans[plan].getWP(index - 1) != nil) { # index -1 is also not nil if (me.flightplans[plan].getWP(index).wp_name != "DISCONTINUITY" and me.flightplans[plan].getWP(index - 1).wp_name != "DISCONTINUITY") { me.flightplans[plan].insertWP(createDiscontinuity(), index); } } else { # -1 is nil if (me.flightplans[plan].getWP(index).wp_name != "DISCONTINUITY") { me.flightplans[plan].insertWP(createDiscontinuity(), index); } } } elsif (me.flightplans[plan].getWP(index - 1) != nil) { # index is nil, -1 is not if (me.flightplans[plan].getWP(index - 1).wp_name != "DISCONTINUITY") { me.flightplans[plan].insertWP(createDiscontinuity(), index); } } else { # both are nil?? debug.dump("Error in discontinuities; won't try to add one"); } }, # insertTP - insert PPOS waypoint denoted "T-P" at specified index # args: n, index # n: flightplan to which the PPOS waypoint will be inserted # index: index which the waypoint will be at. insertTP: func(n, index) { me.flightplans[n].insertWP(createWP(geo.aircraft_position(), "T-P"), index); fmgc.windController.insertWind(n, index, 0, "T-P"); }, insertPPOS: func(n, index = 0) { me.flightplans[n].insertWP(createWP(geo.aircraft_position(), "PPOS"), index); fmgc.windController.insertWind(n, index, 0, "PPOS"); }, # childWPBearingDistance - return waypoint at bearing and distance from specified waypoint ghost # args: wpt, bearing, dist, name, typeStr # wpt: waypoint ghost # bearing: bearing of waypoint to be created from specified waypoint # distance: distance of waypoint to be created from specified waypoint, nautical miles # name: name of waypoint to be created # typeStr: optional argument to be passed to createWP, must be one of "sid", "star" "approach" "missed" or "pseudo" childWPBearingDistance: func(wpt, bearing, dist) { var coordinates = greatCircleMove(wpt.lat, wpt.lon, num(bearing), num(dist)); return coordinates; }, # insertNOSID - create default SID and add to flightplan # args: n: plan on which the SID will be created # The default SID is a leg from departure runway to a point 2.5 miles on the runway extended centreline # if NO SID has already been inserted, we will not insert another one. insertNOSID: func(n) { var wptStore = me.flightplans[n].getWP(0); if (wptStore.wp_type == "runway") { if (me.flightplans[n].getWP(1).id == "1500") { # check if we have NO SID already loaded me.deleteWP(1, n, 1); } # fudge the altitude since we cannot create a hdgtoAlt from nasal. Assume 600 feet per mile - 2.5 miles me.flightplans[n].insertWP(createWP(me.childWPBearingDistance(wptStore, me.flightplans[n].departure_runway.heading, 2.5 + (me.flightplans[n].departure_runway.length * M2NM)), "1500", "sid"), 1); me.flightplans[n].getWP(1).fly_type = "flyOver"; fmgc.windController.insertWind(n, 1, 0, "1500"); } me.flightPlanChanged(n); }, # insertNOSTAR - create default STAR and add to flightplan # args: n: plan on which the STAR will be created # The default STAR is a leg from departure runway to a point 5 miles on the runway extended centreline # if NO STAR has already been inserted, we will not insert another one. insertNOSTAR: func(n) { var wptStore = me.flightplans[n].getWP(me.arrivalIndex[n]); if (wptStore.wp_type == "runway") { if (me.flightplans[n].getWP(me.arrivalIndex[n] - 1).id == "CF") { # check if we have NO STAR already loaded me.deleteWP(me.arrivalIndex[n] - 1, n, 1); } var hdg = me.flightplans[n].destination_runway.heading + 180; if (hdg > 360) { hdg = hdg - 360; } me.flightplans[n].insertWP(createWP(me.childWPBearingDistance(wptStore, hdg, 5), "CF", "star"), me.arrivalIndex[n]); me.flightplans[n].getWP(me.arrivalIndex[n]).fly_type = "flyOver"; fmgc.windController.insertWind(n, me.arrivalIndex[n], 0, "CF"); } me.flightPlanChanged(n); }, # directTo - create leg direct from present position to a specified waypoint # args: waypointGhost, plan # waypointGost: waypoint ghost of the waypoint # plan: plan on which the direct to leg will be created # We first insert a PPOS waypoint at index 1 # We check if the flightplan already contains the waypoint passed to the function # If it exists, we delete intermediate waypoints # If it does not, we insert the waypoint at index 2 and add a discontinuity at index 3 # In either case, we delete the current FROM waypoint, index 0, and call flightPlanChanged to recalculate # We attempt to get the distance from the aircraft current position to the chosen waypoint and update mcdu with it DirToIndex: nil, directTo: func(waypointGhost, plan) { if (me.flightplans[plan].indexOfWP(waypointGhost) == -1) { me.insertTP(plan, me.currentToWptIndex.getValue()); # use createWP here as createWPFrom doesn't accept waypoints # createWPFrom worked before... but be sure! me.flightplans[plan].insertWP(createWP(waypointGhost, waypointGhost.id), me.currentToWptIndex.getValue() + 1); fmgc.windController.insertWind(plan, me.currentToWptIndex.getValue() + 1, 0, waypointGhost.id); me.addDiscontinuity(me.currentToWptIndex.getValue() + 2, plan); me.DirToIndex = me.currentToWptIndex.getValue() + 1; } else { var indexWP = me.flightplans[plan].indexOfWP(waypointGhost); me.insertTP(plan, indexWP); me.deleteTillIndex(waypointGhost, me.currentToWptIndex.getValue(), plan, 1); indexWP = me.flightplans[plan].indexOfWP(waypointGhost); me.hideTillIndex(indexWP - 2, plan); me.DirToIndex = indexWP; } var curAircraftPosDirTo = geo.aircraft_position(); canvas_mcdu.myDirTo[plan].updateDist(me.flightplans[plan].getWP(me.currentToWptIndex.getValue() + 1).courseAndDistanceFrom(curAircraftPosDirTo)[1]); }, deleteWP: func(index, n, a = 0) { # a = 1, means adding a waypoint via deleting intermediate var wp = me.flightplans[n].getWP(index); if ((left(wp.wp_name, 4) != FMGCInternal.depApt and left(wp.wp_name, 4) != FMGCInternal.arrApt) and me.flightplans[n].getPlanSize() > 2) { if (me.flightplans[n].getWP(index).id != "DISCONTINUITY" and a == 0) { # if it is a discont, don't make a new one me.flightplans[n].deleteWP(index); fmgc.windController.deleteWind(n, index); if (me.flightplans[n].getWP(index) != nil) { if (me.flightplans[n].getWP(index).id != "DISCONTINUITY") { # else, if the next one isn't a discont, add one me.addDiscontinuity(index, n); } } } else { if (me.flightplans[n].getWP(index).id == "DISCONTINUITY" and index > 0 and me.flightplans[n].getWP(index - 1).id == "PPOS") { return 1; } else { me.flightplans[n].deleteWP(index); fmgc.windController.deleteWind(n, index); } } me.flightPlanChanged(n); canvas_nd.A3XXRouteDriver.triggerSignal("fp-removed"); return 2; } else { return 1; } }, # deleteTillIndex - helper that deletes waypoints up to a passed waypoint already in flightplan # uses a while loop to delete a certain number of waypoints between passed index and # index of waypoint alredy in flightplan deleteTillIndex: func(wpGhost, index, plan, offset = 0) { var numToDel = me.flightplans[plan].indexOfWP(wpGhost) - index - offset; while (numToDel > 0) { me.deleteWP(index, plan, 1); numToDel -= 1; } return 2; }, hideTillIndex: func(index, plan) { var numToDel = index; while (numToDel >= 0) { me.flightplans[plan].getWP(index - numToDel).hidden = 1; numToDel -= 1; } return 2; }, # createDuplicateNames - helper to spawn DUPLICATENAMES page # args: ghostContainer, index, flag, plan # ghostContainer: vector of fgPositioned ghosts # index: index # flag: is it a navaids DUPLICATENAMES page or not? # plan: plan # flagPBD: do we return back to PBD handler or to default waypoint handler? # flagPROG: do we return back to PROG handler or to default waypoint handler (only if flagPBD false) createDuplicateNames: func(ghostContainer, index, flag, plan, flagPBD = 0, bearing = -999, distance = -99, flagPROG = 0) { if (canvas_mcdu.myDuplicate[plan] != nil) { canvas_mcdu.myDuplicate[plan].del(); } canvas_mcdu.myDuplicate[plan] = nil; canvas_mcdu.myDuplicate[plan] = mcdu.duplicateNamesPage.new(ghostContainer, index, flag, plan, flagPBD, bearing, distance, flagPROG); setprop("MCDU[" ~ plan ~ "]/page", "DUPLICATENAMES"); }, insertAirport: func(text, index, plan, override = 0, overrideIndex = -1) { if (index == 0) { return 1; } var airport = findAirportsByICAO(text); if (size(airport) == 0) { return 0; } if (size(airport) == 1 or override) { var indexToInsert = -1; if (override) { indexToInsert = overrideIndex; } else { indexToInsert = 0; } var indexPresent = me.flightplans[plan].indexOfWP(airport[indexToInsert]); if (indexPresent == -1 or indexPresent > me.arrivalIndex[plan]) { me.flightplans[plan].insertWP(createWPFrom(airport[indexToInsert]), index); fmgc.windController.insertWind(plan, index, 0, text); me.addDiscontinuity(index + 1, plan); me.flightPlanChanged(plan); return 2; } else { return me.deleteTillIndex(airport[indexToInsert], index, plan); } } elsif (size(airport) >= 1) { me.createDuplicateNames(airport, index, 0, plan); return 2; } }, insertFix: func(text, index, plan, override = 0, overrideIndex = -1) { if (index == 0) { return 1; } var fix = findFixesByID(text); if (size(fix) == 0) { return 0; } if (size(fix) == 1 or override) { var indexToInsert = -1; if (override) { indexToInsert = overrideIndex; } else { indexToInsert = 0; } var indexPresent = me.flightplans[plan].indexOfWP(fix[indexToInsert]); if (indexPresent == -1 or indexPresent > me.arrivalIndex[plan]) { me.flightplans[plan].insertWP(createWPFrom(fix[indexToInsert]), index); fmgc.windController.insertWind(plan, index, 1, text); me.addDiscontinuity(index + 1, plan); me.flightPlanChanged(plan); return 2; } else { return me.deleteTillIndex(fix[indexToInsert], index, plan); } } elsif (size(fix) >= 1) { me.createDuplicateNames(fix, index, 0, plan); return 2; } }, insertNavaid: func(text, index, plan, override = 0, overrideIndex = -1) { if (index == 0) { return 1; } var navaid = findNavaidsByID(text); if (size(navaid) == 0) { return 0; } if (size(navaid) == 1 or override) { var indexToInsert = -1; if (override) { indexToInsert = overrideIndex; } else { indexToInsert = 0; } var indexPresent = me.flightplans[plan].indexOfWP(navaid[indexToInsert]); if (indexPresent == -1 or indexPresent > me.arrivalIndex[plan]) { me.flightplans[plan].insertWP(createWPFrom(navaid[indexToInsert]), index); fmgc.windController.insertWind(plan, index, 1, text); me.addDiscontinuity(index + 1, plan); me.flightPlanChanged(plan); return 2; } else { return me.deleteTillIndex(navaid[indexToInsert], index, plan); } } elsif (size(navaid) >= 1) { me.createDuplicateNames(navaid, index, 1, plan); return 2; } }, insertDBWP: func(wpGhost, index, plan) { if (index == 0 or wpGhost == nil) { return 1; } var indexCurr = me.flightplans[plan].indexOfWP(wpGhost); if (indexCurr == -1 or indexCurr > me.arrivalIndex[plan]) { # use createWP here as createWPFrom doesn't accept waypoints me.flightplans[plan].insertWP(createWP(wpGhost, wpGhost.wp_name), index); fmgc.windController.insertWind(plan, index, 1, wpGhost.wp_name); me.addDiscontinuity(index + 1, plan); me.flightPlanChanged(plan); return 2; } else { return me.deleteTillIndex(wpGhost, index, plan); } }, insertLatLonFix: func(text, index, plan) { if (index == 0) { return 1; } var lat = split("/", text)[0]; var lon = split("/", text)[1]; var latDecimal = mcdu.stringToDegrees(lat, "lat"); var lonDecimal = mcdu.stringToDegrees(lon, "lon"); if (latDecimal > 90 or latDecimal < -90 or lonDecimal > 180 or lonDecimal < -180) { return 1; } var waypoint = pilotWaypoint.new({lat: latDecimal, lon: lonDecimal}, "LL"); var addDb = WaypointDatabase.addWP(waypoint); if (addDb != 2) { return addDb; } me.flightplans[plan].insertWP(waypoint.wpGhost, index); fmgc.windController.insertWind(plan, index, 1, "LL"); me.addDiscontinuity(index + 1, plan); me.flightPlanChanged(plan); return 2; }, # getWPforPBD - parse scratchpad text to find waypoint ghost for PBD # args: text, index, plan # text: scratchpad text # index: index at which waypoint will be inserted # plan: plan to which waypoint will be inserted # return: # 0: not in database # 1: notAllowed # 2: o.k. getWPforPBD: func(text, index, plan, override = 0, overrideIndex = -1) { if (index == 0) { return 1; } var textSplit = split("/", text); if (size(split(".", textSplit[2])) != 1 or size(textSplit[1]) < 2 or size(textSplit[1]) > 3) { return 1; } var wpGhost = nil; var wpGhostContainer = nil; var type = nil; if (size(textSplit[0]) == 5) { wpGhostContainer = findFixesByID(textSplit[0]); if (size(wpGhostContainer) == 0) { return 0; } type = "fix"; } elsif (size(textSplit[0]) == 4) { wpGhostContainer = findAirportsByICAO(textSplit[0]); if (size(wpGhostContainer) == 0) { return 0; } type = "airport"; } elsif (size(textSplit[0]) == 3 or size(textSplit[0]) == 2) { wpGhostContainer = findNavaidsByID(textSplit[0]); if (size(wpGhostContainer) == 0) { return 0; } type = "navaid"; } else { return 1; } if (size(wpGhostContainer) == 1 or override) { if (!override) { wpGhost = wpGhostContainer[0]; } else { wpGhost = wpGhostContainer[overrideIndex]; } } else { if (type == "navaid") { me.createDuplicateNames(wpGhostContainer, index, 1, plan, 1, num(textSplit[1]), num(textSplit[2]), 0); } else { me.createDuplicateNames(wpGhostContainer, index, 0, plan, 1, num(textSplit[1]), num(textSplit[2]), 0); } return 2; } var localMagvar = magvar(wpGhost.lat, wpGhost.lon); return me.insertPlaceBearingDistance(wpGhost, textSplit[1] + localMagvar, textSplit[2], index, plan); # magnetic to true? I don't know. But this works! }, getNavCount: func(plan) { var count = 0; for (var wpt = 0; wpt < me.flightplans[plan].getPlanSize(); wpt += 1) { if (me.flightplans[plan].getWP(wpt).wp_type == "navaid") { count += 1; } } return count; }, getDepartureCount: func(plan) { var count = 0; for (var wpt = 0; wpt < me.flightplans[plan].getPlanSize(); wpt += 1) { if (me.flightplans[plan].getWP(wpt).wp_role == "sid") { count += 1; } } return count; }, getArrivalCount: func(plan) { var count = 0; for (var wpt = 0; wpt < me.flightplans[plan].getPlanSize(); wpt += 1) { if (me.flightplans[plan].getWP(wpt).wp_role == "star" or me.flightplans[plan].getWP(wpt).wp_role == "approach" or me.flightplans[plan].getWP(wpt).wp_role == "missed") { count += 1; } } return count; }, getPlanSizeNoDiscont: func(plan) { var count = 0; for (var wpt = 0; wpt < me.flightplans[plan].getPlanSize(); wpt += 1) { if (me.flightplans[plan].getWP(wpt).wp_name != "DISCONTINUITY") { count += 1; } } return count; }, calculateDecelPoint: func() { if (me.getPlanSizeNoDiscont(2) <= 1 or fmgc.FMGCInternal.decel) { setprop("/instrumentation/nd/symbols/decel/show", 0); return; } me.indexDecel = 0; for (var wpt = 0; wpt < me.flightplans[2].getPlanSize(); wpt += 1) { if (me.flightplans[2].getWP(wpt).wp_role == "approach") { me.indexDecel = wpt; break; } if (wpt == me.flightplans[2].getPlanSize()) { me.indexDecel = me.arrivalIndex - 2; break; } } me.dist = me.flightplans[2].getWP(me.indexDecel).leg_distance - 7; if (me.dist < 0) { me.dist = 0.1; } me.decelPoint = me.flightplans[2].pathGeod(me.indexDecel - 1, me.dist); setprop("/instrumentation/nd/symbols/decel/latitude-deg", me.decelPoint.lat); setprop("/instrumentation/nd/symbols/decel/longitude-deg", me.decelPoint.lon); setprop("/instrumentation/nd/symbols/decel/show", 1); me.indexTemp = me.indexDecel; me.distTemp = 7; if (me.flightplans[2].getWP(me.indexTemp).leg_distance < 7) { while (me.distTemp > 0 and me.indexTemp > 0) { me.distTemp -= me.flightplans[2].getWP(me.indexTemp).leg_distance; me.indexTemp -= 1; } me.indexTemp += 1; } setprop("/instrumentation/nd/symbols/decel/index", me.indexTemp); }, # insertPlaceBearingDistance - insert PBD waypoint at specified index, # at some specified bearing, distance from a specified location # args: wp, index, plan # wpt: waypoint ghost # index: index to insert at in plan # plan: plan to insert to insertPlaceBearingDistance: func(wp, bearing, distance, index, plan) { var waypoint = pilotWaypoint.new(me.childWPBearingDistance(wp, bearing, distance), "PBD"); var addDb = WaypointDatabase.addWP(waypoint); if (addDb != 2) { return addDb; } me.flightplans[plan].insertWP(waypoint.wpGhost, index); fmgc.windController.insertWind(plan, index, 0, "PBD"); me.addDiscontinuity(index + 1, plan); me.flightPlanChanged(plan); return 2; }, scratchpad: func(text, index, plan) { # return 0 not in database, 1 not allowed, 2 success, 3 = not allowed due to dir to, 4 = database full if (mcdu.dirToFlag) { return 3; } if (index == me.currentToWptIndex.getValue()) { return 1; # TODO - implement the PPOS - DISCONT feature # me.insertPPOS(thePlan, index - 1); # me.addDiscontinuity(index - 1, thePlan, 1); } if (!me.temporaryFlag[plan]) { if (text == "CLR" and me.flightplans[2].getWP(index).wp_name == "DISCONTINUITY") { if (me.flightplans[2].getPlanSize() == 3 and me.flightplans[2].departure_runway == nil and me.flightplans[2].destination_runway == nil and index == 1) { return 1; } var thePlan = 2; } else { fmgc.flightPlanController.createTemporaryFlightPlan(plan); var thePlan = plan; } } else { var thePlan = plan; } # check waypoints database here var wpFromDB = WaypointDatabase.getWP(text); if (wpFromDB != nil) { return me.insertDBWP(wpFromDB, index, thePlan); } if (size(split("/", text)) == 3) { return me.getWPforPBD(text, index, thePlan); } elsif (text == "@") { return me.changeOverFlyType(index, thePlan); } elsif (text == "CLR") { return me.deleteWP(index, thePlan, 0); } elsif (size(text) > 12) { return me.insertLatLonFix(text, index, thePlan); } elsif (size(text) == 5) { return me.insertFix(text, index, thePlan); } elsif (size(text) == 4) { return me.insertAirport(text, index, thePlan); } elsif (size(text) == 3 or size(text) == 2) { return me.insertNavaid(text, index, thePlan); } else { return 1; } }, flightPlanChanged: func(n) { me.updatePlans(1); fmgc.windController.updatePlans(); # push update to fuel if (fmgc.FMGCInternal.blockConfirmed) { fmgc.FMGCInternal.fuelCalculating = 0; fmgc.fuelCalculating.setValue(0); fmgc.FMGCInternal.fuelCalculating = 1; fmgc.fuelCalculating.setValue(1); } if (n == 2) flightPlanController.changed.setBoolValue(1); canvas_nd.A3XXRouteDriver.triggerSignal("fp-added"); }, # runDecel - used to ensure that only flightplanchanged will update the decel point updatePlans: func(runDecel = 0) { if (fmgc.FMGCInternal.toFromSet and me.flightplans[2].departure != nil and me.flightplans[2].destination != nil) { # check if flightplan exists if (!me.active.getBoolValue()) { if (me.currentToWptIndex.getValue() < 1) { var errs = []; call(func { if (me.flightplans[2].getWP(1).id != "DISCONTINUITY") { me.currentToWptIndex.setValue(1); } }, nil, nil, nil, errs); if (size(errs) != 0) { debug.printerror(errs); } } me.active.setValue(1); } } elsif (me.active.getBoolValue()) { me.active.setValue(0); } for (var n = 0; n <= 2; n += 1) { for (var wpt = 0; wpt < me.flightplans[n].getPlanSize(); wpt += 1) { # Iterate through the waypoints and update their data var waypointHashStore = me.flightplans[n].getWP(wpt); if (left(waypointHashStore.wp_name, 4) == fmgc.FMGCInternal.arrApt and wpt != 0) { if (me.arrivalIndex[n] != wpt) { me.arrivalIndex[n] = wpt; if (canvas_mcdu.myFpln[0] != nil) { canvas_mcdu.myFpln[0].destInfo(); } if (canvas_mcdu.myFpln[1] != nil) { canvas_mcdu.myFpln[1].destInfo(); } } } } } if (runDecel) { me.calculateDecelPoint(); } for (var i = 0; i <= 1; i += 1) { if (canvas_mcdu.myFpln[i] != nil) { canvas_mcdu.myFpln[i].updatePlan(); } if (canvas_mcdu.myDirTo[i] != nil) { canvas_mcdu.myDirTo[i].updateFromFpln(); } } }, }; var flightPlanTimer = maketimer(0.1, flightPlanController, flightPlanController.updatePlans);