1 // FGTower - a class to provide tower control at towered airports.
3 // Written by David Luff, started March 2002.
5 // Copyright (C) 2002 David C. Luff - david.luff@nottingham.ac.uk
7 // This program is free software; you can redistribute it and/or
8 // modify it under the terms of the GNU General Public License as
9 // published by the Free Software Foundation; either version 2 of the
10 // License, or (at your option) any later version.
12 // This program is distributed in the hope that it will be useful, but
13 // WITHOUT ANY WARRANTY; without even the implied warranty of
14 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15 // General Public License for more details.
17 // You should have received a copy of the GNU General Public License
18 // along with this program; if not, write to the Free Software
19 // Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
26 # include <strings.h> // bcopy()
28 # include <string.h> // MSVC doesn't have strings.h
31 #include <Main/globals.hxx>
32 #include <Airports/runways.hxx>
33 #include <simgear/math/sg_geodesy.hxx>
34 #include <simgear/debug/logstream.hxx>
37 #include "ATCdisplay.hxx"
39 #include "ATCutils.hxx"
40 #include "ATCDialog.hxx"
41 #include "commlist.hxx"
42 #include "AILocalTraffic.hxx"
48 TowerPlaneRec::TowerPlaneRec() :
51 clearedToLineUp(false),
52 clearedToTakeOff(false),
53 holdShortReported(false),
54 downwindReported(false),
55 longFinalReported(false),
56 longFinalAcknowledged(false),
58 finalAcknowledged(false),
59 rwyVacatedReported(false),
60 rwyVacatedAcknowledged(false),
61 goAroundReported(false),
62 instructedToGoAround(false),
65 vfrArrivalReported(false),
66 vfrArrivalAcknowledged(false),
69 landingType(AIP_LT_UNKNOWN),
72 plane.callsign = "UNKNOWN";
75 TowerPlaneRec::TowerPlaneRec(PlaneRec p) :
78 clearedToLineUp(false),
79 clearedToTakeOff(false),
80 holdShortReported(false),
81 downwindReported(false),
82 longFinalReported(false),
83 longFinalAcknowledged(false),
85 finalAcknowledged(false),
86 rwyVacatedReported(false),
87 rwyVacatedAcknowledged(false),
88 goAroundReported(false),
89 instructedToGoAround(false),
92 vfrArrivalReported(false),
93 vfrArrivalAcknowledged(false),
96 landingType(AIP_LT_UNKNOWN),
102 TowerPlaneRec::TowerPlaneRec(Point3D pt) :
104 clearedToLand(false),
105 clearedToLineUp(false),
106 clearedToTakeOff(false),
107 holdShortReported(false),
108 downwindReported(false),
109 longFinalReported(false),
110 longFinalAcknowledged(false),
111 finalReported(false),
112 finalAcknowledged(false),
113 rwyVacatedReported(false),
114 rwyVacatedAcknowledged(false),
115 goAroundReported(false),
116 instructedToGoAround(false),
119 vfrArrivalReported(false),
120 vfrArrivalAcknowledged(false),
123 landingType(AIP_LT_UNKNOWN),
126 plane.callsign = "UNKNOWN";
130 TowerPlaneRec::TowerPlaneRec(PlaneRec p, Point3D pt) :
132 clearedToLand(false),
133 clearedToLineUp(false),
134 clearedToTakeOff(false),
135 holdShortReported(false),
136 downwindReported(false),
137 longFinalReported(false),
138 longFinalAcknowledged(false),
139 finalReported(false),
140 finalAcknowledged(false),
141 rwyVacatedReported(false),
142 rwyVacatedAcknowledged(false),
143 goAroundReported(false),
144 instructedToGoAround(false),
147 vfrArrivalReported(false),
148 vfrArrivalAcknowledged(false),
151 landingType(AIP_LT_UNKNOWN),
161 /*******************************************
164 Currently user is assumed to have taken off again when leaving the runway - check speed/elev for taxiing-in. (MAJOR)
166 Use track instead of heading to determine what leg of the circuit the user is flying. (MINOR)
168 Use altitude as well as position to try to determine if the user has left the circuit. (MEDIUM - other issues as well).
170 Currently HoldShortReported code assumes there will be only one plane holding for the runway at once and
171 will break when planes start queueing. (CRITICAL)
173 Report-Runway-Vacated is left as only user ATC option following a go-around. (MAJOR)
175 Report-Downwind is not added as ATC option when user takes off to fly a circuit. (MAJOR)
177 eta of USER can be calculated very wrongly in circuit if flying straight out and turn4 etc are with +ve ortho y.
178 This can then screw up circuit ordering for other planes (MEDIUM)
180 USER leaving circuit needs to be more robustly considered when intentions unknown
181 Currently only considered during climbout and breaks when user turns (MEDIUM).
183 GetPos() of the AI planes is called erratically - either too much or not enough. (MINOR)
185 GO-AROUND is instructed very late at < 12s to landing - possibly make more dependent on chance of rwy clearing before landing (FEATURE)
187 Need to make clear when TowerPlaneRecs do or don't get deleted in RemoveFromCircuitList etc. (MINOR until I misuse it - then CRITICAL!)
189 FGTower::RemoveAllUserDialogOptions() really ought to be replaced by an ATCDialog::clear_entries() function. (MINOR - efficiency).
191 At the moment planes in the lists are not guaranteed to always have a sensible ETA - it should be set as part of AddList functions, and lists should only be accessed this way. (FAIRLY MAJOR).
192 *******************************************/
195 ATCmgr = globals->get_ATC_mgr();
199 // Init the property nodes - TODO - need to make sure we're getting surface winds.
200 wind_from_hdg = fgGetNode("/environment/wind-from-heading-deg", true);
201 wind_speed_knots = fgGetNode("/environment/wind-speed-kt", true);
204 update_count_max = 15;
206 holdListItr = holdList.begin();
208 appListItr = appList.begin();
209 depListItr = depList.begin();
210 rwyListItr = rwyList.begin();
211 circuitListItr = circuitList.begin();
212 trafficListItr = trafficList.begin();
214 vacatedListItr = vacatedList.begin();
218 timeSinceLastDeparture = 9999;
221 nominal_downwind_leg_pos = 1000.0;
222 nominal_base_leg_pos = -1000.0;
223 // TODO - set nominal crosswind leg pos based on minimum distance from takeoff end of rwy.
225 _departureControlled = false;
228 FGTower::~FGTower() {
229 if(!separateGround) {
234 void FGTower::Init() {
235 //cout << "Initialising tower " << ident << '\n';
237 // Pointers to user's position
238 user_lon_node = fgGetNode("/position/longitude-deg", true);
239 user_lat_node = fgGetNode("/position/latitude-deg", true);
240 user_elev_node = fgGetNode("/position/altitude-ft", true);
241 user_hdg_node = fgGetNode("/orientation/heading-deg", true);
243 // Need some way to initialise rwyOccupied flag correctly if the user is on the runway and to know its the user.
244 // I'll punt the startup issue for now though!!!
247 // Setup the ground control at this airport
249 //cout << "Tower ident = " << ident << '\n';
250 if(ATCmgr->GetAirportATCDetails(ident, &a)) {
251 if(a.ground_freq) { // Ground control
252 ground = (FGGround*)ATCmgr->GetATCPointer(ident, GROUND);
253 separateGround = true;
255 // Something has gone wrong :-(
256 SG_LOG(SG_ATC, SG_WARN, "ERROR - ground has frequency but can't get ground pointer :-(");
257 ground = new FGGround(ident);
258 separateGround = false;
261 ground->SetDisplay();
263 ground->SetNoDisplay();
267 // Initialise ground anyway to do the shortest path stuff!
268 // Note that we're now responsible for updating and deleting this - NOT the ATCMgr.
269 ground = new FGGround(ident);
270 separateGround = false;
273 ground->SetDisplay();
275 ground->SetNoDisplay();
279 SG_LOG(SG_ATC, SG_ALERT, "Unable to find airport details for " << ident << " in FGTower::Init()");
280 // Initialise ground anyway to avoid segfault later
281 ground = new FGGround(ident);
282 separateGround = false;
285 ground->SetDisplay();
287 ground->SetNoDisplay();
291 // TODO - attempt to get a departure control pointer to see if we need to hand off departing traffic to departure.
293 // Get the airport elevation
294 aptElev = dclGetAirportElev(ident.c_str());
296 // TODO - this function only assumes one active rwy.
299 // TODO - this currently assumes only one active runway.
300 rwyOccupied = OnActiveRunway(Point3D(user_lon_node->getDoubleValue(), user_lat_node->getDoubleValue(), 0.0));
302 //cout << "User found on active runway\n";
303 // Assume the user is started at the threshold ready to take-off
304 TowerPlaneRec* t = new TowerPlaneRec;
305 t->plane.callsign = fgGetString("/sim/user/callsign");
306 t->plane.type = GA_SINGLE; // FIXME - hardwired!!
307 t->opType = TTT_UNKNOWN; // We don't know if the user wants to do circuits or a departure...
308 t->landingType = AIP_LT_UNKNOWN;
309 t->leg = TAKEOFF_ROLL;
312 t->clearedToTakeOff = true;
313 rwyList.push_back(t);
316 //cout << "User not on active runway\n";
317 // For now assume that this means the user is not at the airport and is in the air.
318 // TODO FIXME - this will break when user starts on apron, at hold short, etc.
319 if(!OnAnyRunway(Point3D(user_lon_node->getDoubleValue(), user_lat_node->getDoubleValue(), 0.0))) {
320 //cout << ident << " ADD 0\n";
321 current_atcdialog->add_entry(ident, "@AP Tower @CS @MI miles @CD of the airport for full stop with the ATIS", "Contact tower for VFR arrival (full stop)", TOWER, (int)USER_REQUEST_VFR_ARRIVAL_FULL_STOP);
326 void FGTower::Update(double dt) {
327 //cout << "T" << endl;
328 // Each time step, what do we need to do?
329 // We need to go through the list of outstanding requests and acknowedgements
330 // and process at least one of them.
331 // We need to go through the list of planes under our control and check if
332 // any need to be addressed.
333 // We need to check for planes not under our control coming within our
334 // control area and address if necessary.
336 // TODO - a lot of the below probably doesn't need to be called every frame and should be staggered.
338 // Sort the arriving planes
341 if(ident == "KEMT") {
342 cout << update_count << "\ttL: " << trafficList.size() << " cL: " << circuitList.size() << " hL: " << holdList.size() << " aL: " << appList.size() << '\n';
345 //if(ident == "EGNX") cout << display << '\n';
347 if(departed != false) {
348 timeSinceLastDeparture += dt;
349 //if(ident == "KEMT")
350 // cout << " dt = " << dt << " timeSinceLastDeparture = " << timeSinceLastDeparture << '\n';
353 //cout << ident << " respond = " << respond << " responseReqd = " << responseReqd << '\n';
355 if(!responseReqd) SG_LOG(SG_ATC, SG_ALERT, "ERROR - respond is true and responseReqd is false in FGTower::Update(...)");
358 responseReqd = false;
361 // Calculate the eta of each plane to the threshold.
362 // For ground traffic this is the fastest they can get there.
363 // For air traffic this is the middle approximation.
364 if(update_count == 1) {
365 doThresholdETACalc();
368 // Order the list of traffic as per expected threshold use and flag any conflicts
369 if(update_count == 2) {
370 //bool conflicts = doThresholdUseOrder();
371 doThresholdUseOrder();
374 // sortConficts() !!!
376 if(update_count == 4) {
380 // Uggh - HACK - why have we got rwyOccupied - wouldn't simply testing rwyList.size() do?
387 if(update_count == 5 && rwyOccupied) {
391 if(update_count == 6) {
392 CheckCircuitList(dt);
395 if(update_count == 7) {
396 CheckApproachList(dt);
399 if(update_count == 8) {
400 CheckDepartureList(dt);
403 // TODO - do one plane from the departure list and set departed = false when out of consideration
407 if(!separateGround) {
408 // The display stuff might have to get more clever than this when not separate
409 // since the tower and ground might try communicating simultaneously even though
410 // they're mean't to be the same contoller/frequency!!
411 // We could also get rid of this by overloading FGATC's Set(No)Display() functions.
413 ground->SetDisplay();
415 ground->SetNoDisplay();
421 // How big should ii get - ie how long should the update cycle interval stretch?
422 if(update_count >= update_count_max) {
426 // Call the base class update for the response time handling.
430 if(ident == "KEMT") {
431 // For AI debugging convienience - may be removed
433 user_pos.setlon(user_lon_node->getDoubleValue());
434 user_pos.setlat(user_lat_node->getDoubleValue());
435 user_pos.setelev(user_elev_node->getDoubleValue());
436 Point3D user_ortho_pos = ortho.ConvertToLocal(user_pos);
437 fgSetDouble("/AI/user/ortho-x", user_ortho_pos.x());
438 fgSetDouble("/AI/user/ortho-y", user_ortho_pos.y());
439 fgSetDouble("/AI/user/elev", user_elev_node->getDoubleValue());
443 //cout << "Done T" << endl;
446 void FGTower::ReceiveUserCallback(int code) {
447 if(code == (int)USER_REQUEST_VFR_DEPARTURE) {
448 //cout << "User requested departure\n";
449 } else if(code == (int)USER_REQUEST_VFR_ARRIVAL) {
450 VFRArrivalContact("USER");
451 } else if(code == (int)USER_REQUEST_VFR_ARRIVAL_FULL_STOP) {
452 VFRArrivalContact("USER", FULL_STOP);
453 } else if(code == (int)USER_REQUEST_VFR_ARRIVAL_TOUCH_AND_GO) {
454 VFRArrivalContact("USER", TOUCH_AND_GO);
455 } else if(code == (int)USER_REPORT_DOWNWIND) {
456 ReportDownwind("USER");
457 } else if(code == (int)USER_REPORT_3_MILE_FINAL) {
458 // For now we'll just call report final instead of report long final to avoid having to alter the response code
460 } else if(code == (int)USER_REPORT_RWY_VACATED) {
461 ReportRunwayVacated("USER");
462 } else if(code == (int)USER_REPORT_GOING_AROUND) {
463 ReportGoingAround("USER");
467 // **************** RESPONSE FUNCTIONS ****************
469 void FGTower::Respond() {
470 //cout << "\nEntering Respond, responseID = " << responseID << endl;
471 TowerPlaneRec* t = FindPlane(responseID);
474 if(t->vfrArrivalReported && !t->vfrArrivalAcknowledged) {
475 //cout << "Tower " << ident << " is responding to VFR arrival reported...\n";
476 // Testing - hardwire straight in for now
477 string trns = t->plane.callsign;
481 // Should we clear staight in or for downwind entry?
482 // For now we'll clear straight in if greater than 1km from a line drawn through the threshold perpendicular to the rwy.
483 // Later on we might check the actual heading and direct some of those to enter on downwind or base.
484 Point3D op = ortho.ConvertToLocal(t->pos);
486 trns += " Report three mile straight-in runway ";
487 t->opType = STRAIGHT_IN;
489 current_atcdialog->add_entry(ident, "@AP Tower @CS @MI mile final Runway @RW", "Report Final", TOWER, (int)USER_REPORT_3_MILE_FINAL);
491 t->planePtr->RegisterTransmission(14);
494 // For now we'll just request reporting downwind.
495 // TODO - In real life something like 'report 2 miles southwest right downwind rwy 19R' might be used
496 // but I'm not sure how to handle all permutations of which direction to tell to report from yet.
498 //cout << "Responding, rwy.patterDirection is " << rwy.patternDirection << '\n';
499 trns += ((rwy.patternDirection == 1) ? "right " : "left ");
500 trns += "downwind runway ";
502 // leave it in the app list until it gets into pattern though.
504 current_atcdialog->add_entry(ident, "@AP Tower @CS Downwind @RW", "Report Downwind", TOWER, (int)USER_REPORT_DOWNWIND);
506 t->planePtr->RegisterTransmission(15);
509 trns += ConvertRwyNumToSpokenString(activeRwy);
511 globals->get_ATC_display()->RegisterSingleMessage(trns, 0);
513 //cout << "Not displaying, trns was " << trns << '\n';
515 t->vfrArrivalAcknowledged = true;
516 } else if(t->downwindReported) {
517 //cout << "Tower " << ident << " is responding to downwind reported...\n";
518 ProcessDownwindReport(t);
519 t->downwindReported = false;
520 } else if(t->holdShortReported) {
521 //cout << "Tower " << ident << " is reponding to holdShortReported...\n";
523 if(rwyOccupied) { // TODO - ought to add a sanity check that it isn't this plane only on the runway (even though it shouldn't be!!)
524 // Do nothing for now - consider acknowloging hold short eventually
526 ClearHoldingPlane(t);
527 t->leg = TAKEOFF_ROLL;
528 rwyList.push_back(t);
530 // WARNING - WE ARE ASSUMING ONLY ONE PLANE REPORTING HOLD AT A TIME BELOW
531 // FIXME TODO - FIX THIS!!!
532 if(holdList.size()) {
533 if(holdListItr == holdList.end()) {
534 holdListItr = holdList.begin();
536 holdList.erase(holdListItr);
537 holdListItr = holdList.begin();
541 // Tell him to hold and what position he is.
542 // Not currently sure under which circumstances we do or don't bother transmitting this.
543 string trns = t->plane.callsign;
544 trns += " hold position";
546 globals->get_ATC_display()->RegisterSingleMessage(trns, 0);
548 // TODO - add some idea of what traffic is blocking him.
550 t->holdShortReported = false;
551 } else if(t->finalReported && !(t->finalAcknowledged)) {
552 //cout << "Tower " << ident << " is responding to finalReported...\n";
554 string trns = t->plane.callsign;
555 //cout << (t->nextOnRwy ? "Next on rwy " : "Not next!! ");
556 //cout << (rwyOccupied ? "RWY OCCUPIED!!\n" : "Rwy not occupied\n");
557 if(t->nextOnRwy && !rwyOccupied && !(t->instructedToGoAround)) {
558 if(t->landingType == FULL_STOP) {
559 trns += " cleared to land ";
561 trns += " cleared for the option ";
564 t->clearedToLand = true;
565 // Maybe remove report downwind from menu here as well incase user didn't bother to?
567 //cout << "ADD VACATED B\n";
568 // Put going around at the top (and hence default) since that'll be more desperate,
569 // or put rwy vacated at the top since that'll be more common?
570 current_atcdialog->add_entry(ident, "@CS Going Around", "Report going around", TOWER, USER_REPORT_GOING_AROUND);
571 current_atcdialog->add_entry(ident, "@CS Clear of the runway", "Report runway vacated", TOWER, USER_REPORT_RWY_VACATED);
573 t->planePtr->RegisterTransmission(7);
575 } else if(t->eta < 20) {
576 // Do nothing - we'll be telling it to go around in less than 10 seconds if the
577 // runway doesn't clear so no point in calling "continue approach".
580 trns += " continue approach";
581 t->clearedToLand = false;
583 if(_display && disp) {
584 globals->get_ATC_display()->RegisterSingleMessage(trns);
586 t->finalAcknowledged = true;
587 } else if(t->rwyVacatedReported && !(t->rwyVacatedAcknowledged)) {
588 ProcessRunwayVacatedReport(t);
589 t->rwyVacatedAcknowledged = true;
592 //freqClear = true; // FIXME - set this to come true after enough time to render the message
593 _releaseCounter = 0.0;
595 _runReleaseCounter = true;
596 //cout << "Done Respond\n" << endl;
599 void FGTower::ProcessDownwindReport(TowerPlaneRec* t) {
601 int a = 0; // Count of preceding planes on approach
602 bool cf = false; // conflicting traffic on final
603 bool cc = false; // preceding traffic in circuit
604 TowerPlaneRec* tc = NULL;
605 for(tower_plane_rec_list_iterator twrItr = circuitList.begin(); twrItr != circuitList.end(); twrItr++) {
606 if((*twrItr)->plane.callsign == responseID) break;
610 if(i > 1) { cc = true; }
611 doThresholdETACalc();
612 TowerPlaneRec* tf = NULL;
613 for(tower_plane_rec_list_iterator twrItr = appList.begin(); twrItr != appList.end(); twrItr++) {
614 if((*twrItr)->eta < (t->eta + 45)) {
618 // This should set the flagged plane to be the last conflicting one, and hence the one to follow.
619 // It ignores the fact that we might have problems slotting into the approach traffic behind it -
620 // eventually we'll need some fancy algorithms for that!
623 string trns = t->plane.callsign;
625 trns += ConvertNumToSpokenDigits(i + a);
626 // This assumes that the number spoken is landing position, not circuit position, since some of the traffic might be on straight-in final.
628 TowerPlaneRec* tt = NULL;
629 if((i == 1) && (!rwyList.size()) && (t->nextOnRwy) && (!cf)) { // Unfortunately nextOnRwy currently doesn't handle circuit/straight-in ordering properly at present, hence the cf check below.
630 trns += "Cleared to land"; // TODO - clear for the option if appropriate
631 t->clearedToLand = true;
632 if(!t->isUser) t->planePtr->RegisterTransmission(7);
633 } else if((i+a) > 1) {
634 //First set tt to point to the correct preceding plane - final or circuit
636 tt = (tf->eta < tc->eta ? tf : tc);
642 // We should never get here!
643 SG_LOG(SG_ATC, SG_ALERT, "ALERT - Logic error in FGTower::ProcessDownwindReport");
646 trns += "Follow the ";
647 string s = tt->plane.callsign;
651 if((tt->opType) == CIRCUIT) {
652 if(tt->planePtr->GetLeg() == FINAL) {
654 } else if(tt->planePtr->GetLeg() == TURN4) {
655 trns += " turning final";
656 } else if(tt->planePtr->GetLeg() == BASE) {
658 } else if(tt->planePtr->GetLeg() == TURN3) {
659 trns += " turning base";
662 double miles_out = CalcDistOutMiles(tt);
664 trns += " on short final";
667 trns += ConvertNumToSpokenDigits((int)miles_out);
668 trns += " mile final";
673 globals->get_ATC_display()->RegisterSingleMessage(trns);
676 if(t->opType == TTT_UNKNOWN) t->opType = CIRCUIT;
677 //cout << "ADD VACATED A\n";
678 // Put going around at the top (and hence default) since that'll be more desperate,
679 // or put rwy vacated at the top since that'll be more common?
680 //cout << "ident = " << ident << ", adding go-around option\n";
681 current_atcdialog->add_entry(ident, "@CS Going Around", "Report going around", TOWER, USER_REPORT_GOING_AROUND);
682 current_atcdialog->add_entry(ident, "@CS Clear of the runway", "Report runway vacated", TOWER, USER_REPORT_RWY_VACATED);
686 void FGTower::ProcessRunwayVacatedReport(TowerPlaneRec* t) {
687 //cout << "Processing rwy vacated...\n";
688 if(t->isUser) current_atcdialog->remove_entry(ident, USER_REPORT_GOING_AROUND, TOWER);
689 string trns = t->plane.callsign;
691 trns += " Contact ground on ";
692 double f = globals->get_ATC_mgr()->GetFrequency(ident, GROUND) / 100.0;
694 sprintf(buf, "%.2f", f);
697 if(!t->isUser) t->planePtr->RegisterTransmission(5);
700 trns += " cleared for taxi to the GA parking";
701 if(!t->isUser) t->planePtr->RegisterTransmission(6); // TODO - this is a mega-hack!!
703 //cout << "trns = " << trns << '\n';
705 globals->get_ATC_display()->RegisterSingleMessage(trns);
707 RemoveFromRwyList(t->plane.callsign);
709 // Maybe we should check that the plane really *has* vacated the runway!
712 // *********** END RESPONSE FUNCTIONS *****************
714 // Currently this assumes we *are* next on the runway and doesn't check for planes about to land -
715 // this should be done prior to calling this function.
716 void FGTower::ClearHoldingPlane(TowerPlaneRec* t) {
717 //cout << "Entering ClearHoldingPlane..." << endl;
719 string trns = t->plane.callsign;
720 //if(departed plane < some threshold in time away) {
722 //if(timeSinceLastDeparture <= 60.0 && departed == true) {
724 t->clearedToLineUp = true;
725 t->planePtr->RegisterTransmission(3); // cleared to line-up
726 //} else if(arriving plane < some threshold away) {
727 } else if(GetTrafficETA(2) < 150.0 && (timeSinceLastDeparture > 60.0 || departed == false)) { // Hack - hardwired time
728 trns += " cleared immediate take-off";
729 if(trafficList.size()) {
730 tower_plane_rec_list_iterator trfcItr = trafficList.begin();
731 trfcItr++; // At the moment the holding plane should be first in trafficList.
732 // Note though that this will break if holding planes aren't put in trafficList in the future.
733 TowerPlaneRec* trfc = *trfcItr;
734 trns += "... traffic is";
735 switch(trfc->plane.type) {
739 trns += " a Cessna"; // TODO - add ability to specify actual plane type somewhere
745 trns += " a King-air";
748 trns += " a Learjet";
751 trns += " a Regional";
760 //if(trfc->opType == STRAIGHT_IN || trfc->opType == TTT_UNKNOWN) {
761 if(trfc->opType == STRAIGHT_IN) {
762 double miles_out = CalcDistOutMiles(trfc);
767 trns += ConvertNumToSpokenDigits((int)miles_out);
768 trns += " mile final";
770 } else if(trfc->opType == CIRCUIT) {
771 //cout << "Getting leg of " << trfc->plane.callsign << '\n';
777 trns += " turning final";
783 trns += " turning base";
786 trns += " in circuit"; // At the moment the user plane is generally flagged as unknown opType when downwind incase its a downwind departure which means we won't get here.
788 // And to eliminate compiler warnings...
789 case TAKEOFF_ROLL: break;
790 case CLIMBOUT: break;
792 case CROSSWIND: break;
794 case LANDING_ROLL: break;
795 case LEG_UNKNOWN: break;
799 // By definition there should be some arriving traffic if we're cleared for immediate takeoff
800 SG_LOG(SG_ATC, SG_WARN, "Warning: Departing traffic cleared for *immediate* take-off despite no arriving traffic in FGTower");
802 t->clearedToTakeOff = true;
803 t->planePtr->RegisterTransmission(4); // cleared to take-off - TODO differentiate between immediate and normal take-off
805 timeSinceLastDeparture = 0.0;
807 //} else if(timeSinceLastDeparture > 60.0 || departed == false) { // Hack - test for timeSinceLastDeparture should be in lineup block eventually
808 trns += " cleared for take-off";
809 // TODO - add traffic is... ?
810 t->clearedToTakeOff = true;
811 t->planePtr->RegisterTransmission(4); // cleared to take-off
813 timeSinceLastDeparture = 0.0;
816 globals->get_ATC_display()->RegisterSingleMessage(trns, 0);
818 //cout << "Done ClearHoldingPlane " << endl;
822 // ***************************************************************************************
823 // ********** Functions to periodically check what the various traffic is doing **********
825 // Do one plane from the hold list
826 void FGTower::CheckHoldList(double dt) {
827 //cout << "Entering CheckHoldList..." << endl;
828 if(holdList.size()) {
829 //cout << "*holdListItr = " << *holdListItr << endl;
830 if(holdListItr == holdList.end()) {
831 holdListItr = holdList.begin();
833 //cout << "*holdListItr = " << *holdListItr << endl;
834 //Process(*holdListItr);
835 TowerPlaneRec* t = *holdListItr;
836 //cout << "t = " << t << endl;
837 if(t->holdShortReported) {
838 // NO-OP - leave it to the response handler.
839 } else { // not responding to report, but still need to clear if clear
841 //cout << "departed = " << departed << '\n';
842 //cout << "timeSinceLastDeparture = " << timeSinceLastDeparture << '\n';
845 } else if(timeSinceLastDeparture <= 60.0 && departed == true) {
846 // Do nothing - this is a bit of a hack - should maybe do line up be ready here
848 ClearHoldingPlane(t);
849 t->leg = TAKEOFF_ROLL;
850 rwyList.push_back(t);
852 holdList.erase(holdListItr);
853 holdListItr = holdList.begin();
856 // TODO - rationalise the considerable code duplication above!
860 //cout << "Done CheckHoldList" << endl;
863 // do the ciruit list
864 void FGTower::CheckCircuitList(double dt) {
865 //cout << "Entering CheckCircuitList..." << endl;
866 // Clear the constraints - we recalculate here.
868 downwind_leg_pos = 0.0;
869 crosswind_leg_pos = 0.0;
871 if(circuitList.size()) { // Do one plane from the circuit
872 if(circuitListItr == circuitList.end()) {
873 circuitListItr = circuitList.begin();
875 TowerPlaneRec* t = *circuitListItr;
876 //cout << ident << ' ' << circuitList.size() << ' ' << t->plane.callsign << " " << t->leg << " eta " << t->eta << '\n';
878 t->pos.setlon(user_lon_node->getDoubleValue());
879 t->pos.setlat(user_lat_node->getDoubleValue());
880 t->pos.setelev(user_elev_node->getDoubleValue());
881 //cout << ident << ' ' << circuitList.size() << ' ' << t->plane.callsign << " " << t->leg << " eta " << t->eta << '\n';
883 t->pos = t->planePtr->GetPos(); // We should probably only set the pos's on one walk through the traffic list in the update function, to save a few CPU should we end up duplicating this.
884 t->landingType = t->planePtr->GetLandingOption();
885 //cout << "AI plane landing option is " << t->landingType << '\n';
887 Point3D tortho = ortho.ConvertToLocal(t->pos);
889 // Need to figure out which leg he's on
890 //cout << "rwy.hdg = " << rwy.hdg << " user hdg = " << user_hdg_node->getDoubleValue();
891 double ho = GetAngleDiff_deg(user_hdg_node->getDoubleValue(), rwy.hdg);
892 //cout << " ho = " << ho << " abs(ho = " << abs(ho) << '\n';
893 // TODO FIXME - get the wind and convert this to track, or otherwise use track somehow!!!
894 // If it's gusty might need to filter the value, although we are leaving 30 degrees each way leeway!
896 // could be either takeoff, climbout or landing - check orthopos.y
897 //cout << "tortho.y = " << tortho.y() << '\n';
898 if((tortho.y() < 0) || (t->leg == TURN4) || (t->leg == FINAL)) {
902 t->leg = CLIMBOUT; // TODO - check elev wrt. apt elev to differentiate takeoff roll and climbout
903 //cout << "Climbout\n";
904 // If it's the user we may be unsure of his/her intentions.
905 // (Hopefully the AI planes won't try confusing the sim!!!)
906 //cout << "tortho.y = " << tortho.y() << '\n';
907 if(t->opType == TTT_UNKNOWN) {
908 if(tortho.y() > 5000) {
909 // 5 km out from threshold - assume it's a departure
910 t->opType = OUTBOUND; // TODO - could check if the user has climbed significantly above circuit altitude as well.
911 // Since we are unknown operation we should be in depList already.
912 //cout << ident << " Removing user from circuitList (TTT_UNKNOWN)\n";
913 circuitList.erase(circuitListItr);
914 RemoveFromTrafficList(t->plane.callsign);
915 circuitListItr = circuitList.begin();
917 } else if(t->opType == CIRCUIT) {
918 if(tortho.y() > 10000) {
919 // 10 km out - assume the user has abandoned the circuit!!
920 t->opType = OUTBOUND;
921 depList.push_back(t);
922 //cout << ident << " removing user from circuitList (CIRCUIT)\n";
923 circuitList.erase(circuitListItr);
924 circuitListItr = circuitList.begin();
928 } else if(abs(ho) < 60) {
930 // TODO - either fix or doublecheck this hack by looking at heading and pattern direction
931 if((t->leg == CLIMBOUT) || (t->leg == TURN1)) {
938 } else if(abs(ho) < 120) {
940 // TODO - either fix or doublecheck this hack by looking at heading and pattern direction
941 if((t->leg == TURN1) || (t->leg == CROSSWIND)) {
943 //cout << "Crosswind\n";
948 } else if(abs(ho) < 150) {
950 // TODO - either fix or doublecheck this hack by looking at heading and pattern direction
951 if((t->leg == CROSSWIND) || (t->leg == TURN2)) {
956 // Probably safe now to assume the user is flying a circuit
963 //cout << "Downwind\n";
965 if(t->leg == FINAL) {
966 if(OnActiveRunway(t->pos)) {
967 t->leg = LANDING_ROLL;
971 t->leg = t->planePtr->GetLeg();
974 // Set the constraints IF this is the first plane in the circuit
975 // TODO - at the moment we're constraining plane 2 based on plane 1 - this won't (or might not) work for 3 planes in the circuit!!
976 if(circuitListItr == circuitList.begin()) {
979 // Base leg must be at least as far out as the plane is - actually possibly not necessary for separation, but we'll use that for now.
980 base_leg_pos = tortho.y();
981 //cout << "base_leg_pos = " << base_leg_pos << '\n';
984 // Fall through to base
986 base_leg_pos = tortho.y();
987 //cout << "base_leg_pos = " << base_leg_pos << '\n';
990 // Fall through to downwind
992 // Only have the downwind leg pos as turn-to-base constraint if more negative than we already have.
993 base_leg_pos = (tortho.y() < base_leg_pos ? tortho.y() : base_leg_pos);
994 //cout << "base_leg_pos = " << base_leg_pos;
995 downwind_leg_pos = tortho.x(); // Assume that a following plane can simply be constrained by the immediately in front downwind plane
996 //cout << " downwind_leg_pos = " << downwind_leg_pos << '\n';
999 // Fall through to crosswind
1001 crosswind_leg_pos = tortho.y();
1002 //cout << "crosswind_leg_pos = " << crosswind_leg_pos << '\n';
1003 t->instructedToGoAround = false;
1006 // Fall through to climbout
1008 // Only use current by constraint as largest
1009 crosswind_leg_pos = (tortho.y() > crosswind_leg_pos ? tortho.y() : crosswind_leg_pos);
1010 //cout << "crosswind_leg_pos = " << crosswind_leg_pos << '\n';
1023 if(t->leg == FINAL && !(t->instructedToGoAround)) {
1024 doThresholdETACalc();
1025 doThresholdUseOrder();
1028 cout << "Checking USER on final... ";
1029 cout << "eta " << t->eta;
1030 if(t->clearedToLand) cout << " cleared to land\n";
1033 //cout << "YES FINAL, t->eta = " << t->eta << ", rwyList.size() = " << rwyList.size() << '\n';
1034 if(t->landingType == FULL_STOP) {
1035 t->opType = INBOUND;
1036 //cout << "\n******** SWITCHING TO INBOUND AT POINT AAA *********\n\n";
1038 if(t->eta < 12 && rwyList.size()) {
1039 // TODO - need to make this more sophisticated
1040 // eg. is the plane accelerating down the runway taking off [OK],
1041 // or stationary near the start [V. BAD!!].
1042 // For now this should stop the AI plane landing on top of the user.
1043 string trns = t->plane.callsign;
1044 trns += " GO AROUND TRAFFIC ON RUNWAY I REPEAT GO AROUND";
1045 pending_transmission = trns;
1046 ImmediateTransmit();
1047 t->instructedToGoAround = true;
1048 t->clearedToLand = false;
1049 // Assume it complies!!!
1050 t->opType = CIRCUIT;
1053 //cout << "Registering Go-around transmission with AI plane\n";
1054 t->planePtr->RegisterTransmission(13);
1056 } else if(!t->clearedToLand) {
1057 // The whip through the appList is a hack since currently t->nextOnRwy doesn't always work
1060 for(tower_plane_rec_list_iterator twrItr = appList.begin(); twrItr != appList.end(); twrItr++) {
1061 if((*twrItr)->eta < t->eta) {
1065 if(t->nextOnRwy && !cf) {
1066 if(!rwyList.size()) {
1067 string trns = t->plane.callsign;
1068 trns += " Cleared to land";
1069 pending_transmission = trns;
1071 //if(t->isUser) cout << "Transmitting cleared to Land!!!\n";
1072 t->clearedToLand = true;
1074 t->planePtr->RegisterTransmission(7);
1078 //if(t->isUser) cout << "Not next\n";
1081 } else if(t->leg == LANDING_ROLL) {
1082 //cout << t->plane.callsign << " has landed - adding to rwyList\n";
1083 rwyList.push_front(t);
1084 // TODO - if(!clearedToLand) shout something!!
1085 t->clearedToLand = false;
1086 RemoveFromTrafficList(t->plane.callsign);
1088 t->opType = TTT_UNKNOWN;
1089 } // TODO - allow the user to specify opType via ATC menu
1090 //cout << ident << " Removing " << t->plane.callsign << " from circuitList..." << endl;
1091 circuitListItr = circuitList.erase(circuitListItr);
1092 if(circuitListItr == circuitList.end() ) {
1093 circuitListItr = circuitList.begin();
1098 //cout << "Done CheckCircuitList" << endl;
1101 // Do the runway list - we'll do the whole runway list since it's important and there'll never be many planes on the rwy at once!!
1102 // FIXME - at the moment it looks like we're only doing the first plane from the rwy list.
1103 // (However, at the moment there should only be one airplane on the rwy at once, until we
1104 // start allowing planes to line up whilst previous arrival clears the rwy.)
1105 void FGTower::CheckRunwayList(double dt) {
1106 //cout << "Entering CheckRunwayList..." << endl;
1108 if(!rwyList.size()) {
1109 rwyOccupied = false;
1111 rwyListItr = rwyList.begin();
1112 TowerPlaneRec* t = *rwyListItr;
1114 t->pos.setlon(user_lon_node->getDoubleValue());
1115 t->pos.setlat(user_lat_node->getDoubleValue());
1116 t->pos.setelev(user_elev_node->getDoubleValue());
1118 t->pos = t->planePtr->GetPos(); // We should probably only set the pos's on one walk through the traffic list in the update function, to save a few CPU should we end up duplicating this.
1120 bool on_rwy = OnActiveRunway(t->pos);
1122 // TODO - for all of these we need to check what the user is *actually* doing!
1123 if((t->opType == INBOUND) || (t->opType == STRAIGHT_IN)) {
1124 //cout << "Tower " << ident << " is removing plane " << t->plane.callsign << " from rwy list (vacated)\n";
1125 //cout << "Size of rwylist was " << rwyList.size() << '\n';
1126 //cout << "Size of vacatedList was " << vacatedList.size() << '\n';
1127 RemoveFromRwyList(t->plane.callsign);
1128 AddToVacatedList(t);
1129 //cout << "Size of rwylist is " << rwyList.size() << '\n';
1130 //cout << "Size of vacatedList is " << vacatedList.size() << '\n';
1131 // At the moment we wait until Runway Vacated is reported by the plane before telling to contact ground etc.
1132 // It's possible we could be a bit more proactive about this.
1133 } else if(t->opType == OUTBOUND) {
1134 depList.push_back(t);
1135 rwyList.pop_front();
1137 timeSinceLastDeparture = 0.0;
1138 } else if(t->opType == CIRCUIT) {
1139 //cout << ident << " adding " << t->plane.callsign << " to circuitList" << endl;
1140 circuitList.push_back(t);
1141 AddToTrafficList(t);
1142 rwyList.pop_front();
1144 timeSinceLastDeparture = 0.0;
1145 } else if(t->opType == TTT_UNKNOWN) {
1146 depList.push_back(t);
1147 //cout << ident << " adding " << t->plane.callsign << " to circuitList" << endl;
1148 circuitList.push_back(t);
1149 AddToTrafficList(t);
1150 rwyList.pop_front();
1152 timeSinceLastDeparture = 0.0; // TODO - we need to take into account that the user might taxi-in when flagged opType UNKNOWN - check speed/altitude etc to make decision as to what user is up to.
1154 // HELP - we shouldn't ever get here!!!
1159 //cout << "Done CheckRunwayList" << endl;
1162 // Do one plane from the approach list
1163 void FGTower::CheckApproachList(double dt) {
1164 //cout << "CheckApproachList called for " << ident << endl;
1165 //cout << "AppList.size is " << appList.size() << endl;
1166 if(appList.size()) {
1167 if(appListItr == appList.end()) {
1168 appListItr = appList.begin();
1170 TowerPlaneRec* t = *appListItr;
1171 //cout << "t = " << t << endl;
1172 //cout << "Checking " << t->plane.callsign << endl;
1174 t->pos.setlon(user_lon_node->getDoubleValue());
1175 t->pos.setlat(user_lat_node->getDoubleValue());
1176 t->pos.setelev(user_elev_node->getDoubleValue());
1178 // TODO - set/update the position if it's an AI plane
1180 doThresholdETACalc(); // We need this here because planes in the lists are not guaranteed to *always* have the correct ETA
1181 //cout << "eta is " << t->eta << ", rwy is " << (rwyList.size() ? "occupied " : "clear ") << '\n';
1182 if(t->eta < 12 && rwyList.size() && !(t->instructedToGoAround)) {
1183 // TODO - need to make this more sophisticated
1184 // eg. is the plane accelerating down the runway taking off [OK],
1185 // or stationary near the start [V. BAD!!].
1186 // For now this should stop the AI plane landing on top of the user.
1187 string trns = t->plane.callsign;
1188 trns += " GO AROUND TRAFFIC ON RUNWAY I REPEAT GO AROUND";
1189 pending_transmission = trns;
1190 ImmediateTransmit();
1191 t->instructedToGoAround = true;
1192 t->clearedToLand = false;
1193 t->nextOnRwy = false; // But note this is recalculated so don't rely on it
1194 // Assume it complies!!!
1195 t->opType = CIRCUIT;
1199 //cout << "Registering Go-around transmission with AI plane\n";
1200 t->planePtr->RegisterTransmission(13);
1203 // TODO - add Go-around ack to comm options,
1204 // remove report rwy vacated. (possibly).
1206 } else if(t->eta < 90 && !t->clearedToLand) {
1207 //doThresholdETACalc();
1208 doThresholdUseOrder();
1209 // The whip through the appList is a hack since currently t->nextOnRwy doesn't always work
1212 for(tower_plane_rec_list_iterator twrItr = appList.begin(); twrItr != appList.end(); twrItr++) {
1213 if((*twrItr)->eta < t->eta) {
1217 if(t->nextOnRwy && !cf) {
1218 if(!rwyList.size()) {
1219 string trns = t->plane.callsign;
1220 trns += " Cleared to land";
1221 pending_transmission = trns;
1223 //if(t->isUser) cout << "Transmitting cleared to Land!!!\n";
1224 t->clearedToLand = true;
1226 t->planePtr->RegisterTransmission(7);
1230 //if(t->isUser) cout << "Not next\n";
1234 // Check for landing...
1235 bool landed = false;
1238 if(t->planePtr->GetLeg() == LANDING_ROLL) {
1242 SG_LOG(SG_ATC, SG_ALERT, "WARNING - not user and null planePtr in CheckApproachList!");
1245 if(OnActiveRunway(t->pos)) {
1251 // Duplicated in CheckCircuitList - must be able to rationalise this somehow!
1252 //cout << "A " << t->plane.callsign << " has landed, adding to rwyList...\n";
1253 rwyList.push_front(t);
1254 // TODO - if(!clearedToLand) shout something!!
1255 t->clearedToLand = false;
1256 RemoveFromTrafficList(t->plane.callsign);
1258 // t->opType = TTT_UNKNOWN;
1259 //} // TODO - allow the user to specify opType via ATC menu
1260 appListItr = appList.erase(appListItr);
1261 if(appListItr == appList.end() ) {
1262 appListItr = appList.begin();
1268 //cout << "Done" << endl;
1271 // Do one plane from the departure list
1272 void FGTower::CheckDepartureList(double dt) {
1273 if(depList.size()) {
1274 if(depListItr == depList.end()) {
1275 depListItr = depList.begin();
1277 TowerPlaneRec* t = *depListItr;
1278 //cout << "Dep list, checking " << t->plane.callsign;
1280 double distout; // meters
1281 if(t->isUser) distout = dclGetHorizontalSeparation(Point3D(lon, lat, elev), Point3D(user_lon_node->getDoubleValue(), user_lat_node->getDoubleValue(), user_elev_node->getDoubleValue()));
1282 else distout = dclGetHorizontalSeparation(Point3D(lon, lat, elev), t->planePtr->GetPos());
1283 //cout << " distout = " << distout << '\n';
1284 if(distout > 10000) {
1285 string trns = t->plane.callsign;
1286 trns += " You are now clear of my airspace, good day";
1287 pending_transmission = trns;
1290 // Change the communication options
1291 RemoveAllUserDialogOptions();
1292 //cout << "ADD A\n";
1293 current_atcdialog->add_entry(ident, "@AP Tower @CS @MI miles @CD of the airport for full stop with the ATIS", "Contact tower for VFR arrival (full stop)", TOWER, (int)USER_REQUEST_VFR_ARRIVAL_FULL_STOP);
1295 // Send a clear-of-airspace signal
1296 // TODO - implement this once we actually have departing AI traffic (currently all circuits or arrivals).
1298 RemovePlane(t->plane.callsign);
1305 // ********** End periodic check functions ***********************************************
1306 // ***************************************************************************************
1309 // Remove all dialog options for this tower.
1310 void FGTower::RemoveAllUserDialogOptions() {
1311 current_atcdialog->remove_entry(ident, USER_REQUEST_VFR_DEPARTURE, TOWER);
1312 current_atcdialog->remove_entry(ident, USER_REQUEST_VFR_ARRIVAL, TOWER);
1313 current_atcdialog->remove_entry(ident, USER_REQUEST_VFR_ARRIVAL_FULL_STOP, TOWER);
1314 current_atcdialog->remove_entry(ident, USER_REQUEST_VFR_ARRIVAL_TOUCH_AND_GO, TOWER);
1315 current_atcdialog->remove_entry(ident, USER_REPORT_3_MILE_FINAL, TOWER);
1316 current_atcdialog->remove_entry(ident, USER_REPORT_DOWNWIND, TOWER);
1317 current_atcdialog->remove_entry(ident, USER_REPORT_RWY_VACATED, TOWER);
1318 current_atcdialog->remove_entry(ident, USER_REPORT_GOING_AROUND, TOWER);
1321 // Returns true if positions of crosswind/downwind/base leg turns should be constrained by previous traffic
1322 // plus the constraint position as a rwy orientated orthopos (meters)
1323 bool FGTower::GetCrosswindConstraint(double& cpos) {
1324 if(crosswind_leg_pos != 0.0) {
1325 cpos = crosswind_leg_pos;
1332 bool FGTower::GetDownwindConstraint(double& dpos) {
1333 if(fabs(downwind_leg_pos) > nominal_downwind_leg_pos) {
1334 dpos = downwind_leg_pos;
1341 bool FGTower::GetBaseConstraint(double& bpos) {
1342 if(base_leg_pos < nominal_base_leg_pos) {
1343 bpos = base_leg_pos;
1346 bpos = nominal_base_leg_pos;
1352 // Figure out which runways are active.
1353 // For now we'll just be simple and do one active runway - eventually this will get much more complex
1354 // This is a private function - public interface to the results of this is through GetActiveRunway
1355 void FGTower::DoRwyDetails() {
1356 //cout << "GetRwyDetails called" << endl;
1358 // Based on the airport-id and wind get the active runway
1361 double hdg = wind_from_hdg->getDoubleValue();
1362 double speed = wind_speed_knots->getDoubleValue();
1363 hdg = (speed == 0.0 ? 270.0 : hdg);
1364 //cout << "Heading = " << hdg << '\n';
1367 bool rwyGood = globals->get_runways()->search(ident, int(hdg), &runway);
1369 //cout << "RUNWAY GOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOD\n";
1370 activeRwy = runway.rwy_no;
1371 rwy.rwyID = runway.rwy_no;
1372 SG_LOG(SG_ATC, SG_INFO, "Active runway for airport " << ident << " is " << activeRwy);
1374 // Get the threshold position
1375 double other_way = runway.heading - 180.0;
1376 while(other_way <= 0.0) {
1379 // move to the +l end/center of the runway
1380 //cout << "Runway center is at " << runway.lon << ", " << runway.lat << '\n';
1381 Point3D origin = Point3D(runway.lon, runway.lat, aptElev);
1382 Point3D ref = origin;
1383 double tshlon, tshlat, tshr;
1384 double tolon, tolat, tor;
1385 rwy.length = runway.length * SG_FEET_TO_METER;
1386 rwy.width = runway.width * SG_FEET_TO_METER;
1387 geo_direct_wgs_84 ( aptElev, ref.lat(), ref.lon(), other_way,
1388 rwy.length / 2.0 - 25.0, &tshlat, &tshlon, &tshr );
1389 geo_direct_wgs_84 ( aptElev, ref.lat(), ref.lon(), runway.heading,
1390 rwy.length / 2.0 - 25.0, &tolat, &tolon, &tor );
1391 // Note - 25 meters in from the runway end is a bit of a hack to put the plane ahead of the user.
1392 // now copy what we need out of runway into rwy
1393 rwy.threshold_pos = Point3D(tshlon, tshlat, aptElev);
1394 Point3D takeoff_end = Point3D(tolon, tolat, aptElev);
1395 //cout << "Threshold position = " << tshlon << ", " << tshlat << ", " << aptElev << '\n';
1396 //cout << "Takeoff position = " << tolon << ", " << tolat << ", " << aptElev << '\n';
1397 rwy.hdg = runway.heading;
1398 // Set the projection for the local area based on this active runway
1399 ortho.Init(rwy.threshold_pos, rwy.hdg);
1400 rwy.end1ortho = ortho.ConvertToLocal(rwy.threshold_pos); // should come out as zero
1401 rwy.end2ortho = ortho.ConvertToLocal(takeoff_end);
1403 // Set the pattern direction
1404 // TODO - we'll check for a facilities file with this in eventually - for now assume left traffic except
1405 // for certain circumstances (RH parallel rwy).
1406 rwy.patternDirection = -1; // Left
1407 if(rwy.rwyID.size() == 3) {
1408 rwy.patternDirection = (rwy.rwyID.substr(2,1) == "R" ? 1 : -1);
1410 //cout << "Doing details, rwy.patterDirection is " << rwy.patternDirection << '\n';
1412 SG_LOG(SG_ATC, SG_ALERT, "Help - can't get good runway in FGTower!!");
1418 // Figure out if a given position lies on the active runway
1419 // Might have to change when we consider more than one active rwy.
1420 bool FGTower::OnActiveRunway(Point3D pt) {
1421 // TODO - check that the centre calculation below isn't confused by displaced thesholds etc.
1422 Point3D xyc((rwy.end1ortho.x() + rwy.end2ortho.x())/2.0, (rwy.end1ortho.y() + rwy.end2ortho.y())/2.0, 0.0);
1423 Point3D xyp = ortho.ConvertToLocal(pt);
1425 //cout << "Length offset = " << fabs(xyp.y() - xyc.y()) << '\n';
1426 //cout << "Width offset = " << fabs(xyp.x() - xyc.x()) << '\n';
1428 double rlen = rwy.length/2.0 + 5.0;
1429 double rwidth = rwy.width/2.0;
1430 double ldiff = fabs(xyp.y() - xyc.y());
1431 double wdiff = fabs(xyp.x() - xyc.x());
1433 return((ldiff < rlen) && (wdiff < rwidth));
1437 // Figure out if a given position lies on any runway or not
1438 // Only call this at startup - reading the runways database is expensive and needs to be fixed!
1439 bool FGTower::OnAnyRunway(Point3D pt) {
1441 double dist = current_commlist->FindClosest(lon, lat, elev, ad, TOWER, 10.0);
1445 // Based on the airport-id, go through all the runways and check for a point in them
1447 // TODO - do we actually need to search for the airport - surely we already know our ident and
1448 // can just search runways of our airport???
1449 //cout << "Airport ident is " << ad.ident << '\n';
1451 bool rwyGood = globals->get_runways()->search(ad.ident, &runway);
1453 SG_LOG(SG_ATC, SG_WARN, "Unable to find any runways for airport ID " << ad.ident << " in FGTower");
1456 while(runway.id == ad.ident) {
1457 on = OnRunway(pt, runway);
1458 //cout << "Runway " << runway.rwy_no << ": On = " << (on ? "true\n" : "false\n");
1459 if(on) return(true);
1460 globals->get_runways()->next(&runway);
1466 // Returns true if successful
1467 bool FGTower::RemoveFromTrafficList(string id) {
1468 tower_plane_rec_list_iterator twrItr;
1469 for(twrItr = trafficList.begin(); twrItr != trafficList.end(); twrItr++) {
1470 TowerPlaneRec* tpr = *twrItr;
1471 if(tpr->plane.callsign == id) {
1472 trafficList.erase(twrItr);
1473 trafficListItr = trafficList.begin();
1477 SG_LOG(SG_ATC, SG_WARN, "Warning - unable to remove aircraft " << id << " from trafficList in FGTower");
1482 // Returns true if successful
1483 bool FGTower::RemoveFromAppList(string id) {
1484 tower_plane_rec_list_iterator twrItr;
1485 for(twrItr = appList.begin(); twrItr != appList.end(); twrItr++) {
1486 TowerPlaneRec* tpr = *twrItr;
1487 if(tpr->plane.callsign == id) {
1488 appList.erase(twrItr);
1489 appListItr = appList.begin();
1493 //SG_LOG(SG_ATC, SG_WARN, "Warning - unable to remove aircraft " << id << " from appList in FGTower");
1497 // Returns true if successful
1498 bool FGTower::RemoveFromRwyList(string id) {
1499 tower_plane_rec_list_iterator twrItr;
1500 for(twrItr = rwyList.begin(); twrItr != rwyList.end(); twrItr++) {
1501 TowerPlaneRec* tpr = *twrItr;
1502 if(tpr->plane.callsign == id) {
1503 rwyList.erase(twrItr);
1504 rwyListItr = rwyList.begin();
1508 //SG_LOG(SG_ATC, SG_WARN, "Warning - unable to remove aircraft " << id << " from rwyList in FGTower");
1513 // Add a tower plane rec with ETA to the traffic list in the correct position ETA-wise
1514 // and set nextOnRwy if so.
1515 // Returns true if this could cause a threshold ETA conflict with other traffic, false otherwise.
1516 // For planes holding they are put in the first position with time to go, and the return value is
1517 // true if in the first position (nextOnRwy) and false otherwise.
1518 // See the comments in FGTower::doThresholdUseOrder for notes on the ordering
1519 bool FGTower::AddToTrafficList(TowerPlaneRec* t, bool holding) {
1520 //cout << "ADD: " << trafficList.size();
1521 //cout << "AddToTrafficList called, currently size = " << trafficList.size() << ", holding = " << holding << endl;
1522 double separation_time = 90.0; // seconds - this is currently a guess for light plane separation, and includes a few seconds for a holding plane to taxi onto the rwy.
1523 double departure_sep_time = 60.0; // Separation time behind departing airplanes. Comments above also apply.
1524 bool conflict = false;
1525 double lastETA = 0.0;
1526 bool firstTime = true;
1527 // FIXME - make this more robust for different plane types eg. light following heavy.
1528 tower_plane_rec_list_iterator twrItr;
1529 //twrItr = trafficList.begin();
1531 for(twrItr = trafficList.begin(); twrItr != trafficList.end(); twrItr++) {
1532 //if(twrItr == trafficList.end()) {
1534 // trafficList.push_back(t);
1535 // return(holding ? firstTime : conflict);
1537 TowerPlaneRec* tpr = *twrItr;
1539 //cout << (tpr->isUser ? "USER!\n" : "NOT user\n");
1540 //cout << "tpr->eta - lastETA = " << tpr->eta - lastETA << '\n';
1541 double dep_allowance = (timeSinceLastDeparture < departure_sep_time ? departure_sep_time - timeSinceLastDeparture : 0.0);
1542 double slot_time = (firstTime ? separation_time + dep_allowance : separation_time + departure_sep_time);
1543 // separation_time + departure_sep_time in the above accounts for the fact that the arrival could be touch and go,
1544 // and if not needs time to clear the rwy anyway.
1545 if(tpr->eta - lastETA > slot_time) {
1546 t->nextOnRwy = firstTime;
1547 trafficList.insert(twrItr, t);
1548 //cout << "\tH\t" << trafficList.size() << '\n';
1553 if(t->eta < tpr->eta) {
1554 // Ugg - this one's tricky.
1555 // It depends on what the two planes are doing and whether there's a conflict what we do.
1556 if(tpr->eta - t->eta > separation_time) { // No probs, plane 2 can squeeze in before plane 1 with no apparent conflict
1557 if(tpr->nextOnRwy) {
1558 tpr->nextOnRwy = false;
1559 t->nextOnRwy = true;
1561 trafficList.insert(twrItr, t);
1562 } else { // Ooops - this ones tricky - we have a potential conflict!
1564 // HACK - just add anyway for now and flag conflict - TODO - FIX THIS using CIRCUIT/STRAIGHT_IN and VFR/IFR precedence rules.
1565 if(tpr->nextOnRwy) {
1566 tpr->nextOnRwy = false;
1567 t->nextOnRwy = true;
1569 trafficList.insert(twrItr, t);
1571 //cout << "\tC\t" << trafficList.size() << '\n';
1578 // If we get here we must be at the end of the list, or maybe the list is empty.
1579 if(!trafficList.size()) {
1580 t->nextOnRwy = true;
1581 // conflict and firstTime should be false and true respectively in this case anyway.
1583 t->nextOnRwy = false;
1585 trafficList.push_back(t);
1586 //cout << "\tE\t" << trafficList.size() << endl;
1587 return(holding ? firstTime : conflict);
1590 // Add a tower plane rec with ETA to the circuit list in the correct position ETA-wise
1591 // Returns true if this might cause a separation conflict (based on ETA) with other traffic, false otherwise.
1592 // Safe to add a plane that is already in - planes with the same callsign are not added.
1593 bool FGTower::AddToCircuitList(TowerPlaneRec* t) {
1595 //cout << "**********************************************\n";
1596 //cout << "AddToCircuitList called with NULL pointer!!!!!\n";
1597 //cout << "**********************************************\n";
1600 //cout << "ADD: " << circuitList.size();
1601 //cout << ident << " AddToCircuitList called for " << t->plane.callsign << ", currently size = " << circuitList.size() << endl;
1602 double separation_time = 60.0; // seconds - this is currently a guess for light plane separation, and includes a few seconds for a holding plane to taxi onto the rwy.
1603 bool conflict = false;
1604 tower_plane_rec_list_iterator twrItr;
1605 // First check if the plane is already in the list
1606 //cout << "A" << endl;
1607 //cout << "Checking whether " << t->plane.callsign << " is already in circuit list..." << endl;
1608 //cout << "B" << endl;
1609 for(twrItr = circuitList.begin(); twrItr != circuitList.end(); twrItr++) {
1610 if((*twrItr)->plane.callsign == t->plane.callsign) {
1611 //cout << "In list - returning...\n";
1615 //cout << "Not in list - adding..." << endl;
1617 for(twrItr = circuitList.begin(); twrItr != circuitList.end(); twrItr++) {
1618 TowerPlaneRec* tpr = *twrItr;
1619 //cout << tpr->plane.callsign << " eta is " << tpr->eta << '\n';
1620 //cout << "New eta is " << t->eta << '\n';
1621 if(t->eta < tpr->eta) {
1622 // Ugg - this one's tricky.
1623 // It depends on what the two planes are doing and whether there's a conflict what we do.
1624 if(tpr->eta - t->eta > separation_time) { // No probs, plane 2 can squeeze in before plane 1 with no apparent conflict
1625 circuitList.insert(twrItr, t);
1626 } else { // Ooops - this ones tricky - we have a potential conflict!
1628 // HACK - just add anyway for now and flag conflict.
1629 circuitList.insert(twrItr, t);
1631 //cout << "\tC\t" << circuitList.size() << '\n';
1635 // If we get here we must be at the end of the list, or maybe the list is empty.
1636 //cout << ident << " adding " << t->plane.callsign << " to circuitList" << endl;
1637 circuitList.push_back(t); // TODO - check the separation with the preceding plane for the conflict flag.
1638 //cout << "\tE\t" << circuitList.size() << endl;
1642 // Add to vacated list only if not already present
1643 void FGTower::AddToVacatedList(TowerPlaneRec* t) {
1644 tower_plane_rec_list_iterator twrItr;
1646 for(twrItr = vacatedList.begin(); twrItr != vacatedList.end(); twrItr++) {
1647 if((*twrItr)->plane.callsign == t->plane.callsign) {
1652 vacatedList.push_back(t);
1656 // Calculate the eta of a plane to the threshold.
1657 // For ground traffic this is the fastest they can get there.
1658 // For air traffic this is the middle approximation.
1659 void FGTower::CalcETA(TowerPlaneRec* tpr, bool printout) {
1660 // For now we'll be very crude and hardwire expected speeds to C172-like values
1661 // The speeds below are specified in knots IAS and then converted to m/s
1662 double app_ias = 100.0 * 0.514444; // Speed during straight-in approach
1663 double circuit_ias = 80.0 * 0.514444; // Speed around circuit
1664 double final_ias = 70.0 * 0.514444; // Speed during final approach
1667 //cout << "In CalcETA, airplane ident = " << tpr->plane.callsign << '\n';
1668 //cout << (tpr->isUser ? "USER\n" : "AI\n");
1672 // Sign convention - dist_out is -ve for approaching planes and +ve for departing planes
1673 // dist_across is +ve in the pattern direction - ie a plane correctly on downwind will have a +ve dist_across
1675 Point3D op = ortho.ConvertToLocal(tpr->pos);
1677 //if(!tpr->isUser) cout << "Orthopos is " << op.x() << ", " << op.y() << ' ';
1678 //cout << "opType is " << tpr->opType << '\n';
1680 double dist_out_m = op.y();
1681 double dist_across_m = fabs(op.x()); // The fabs is a hack to cope with the fact that we don't know the circuit direction yet
1682 //cout << "Doing ETA calc for " << tpr->plane.callsign << '\n';
1684 if(tpr->opType == STRAIGHT_IN || tpr->opType == INBOUND) {
1685 //cout << "CASE 1\n";
1686 double dist_to_go_m = sqrt((dist_out_m * dist_out_m) + (dist_across_m * dist_across_m));
1687 if(dist_to_go_m < 1000) {
1688 tpr->eta = dist_to_go_m / final_ias;
1690 tpr->eta = (1000.0 / final_ias) + ((dist_to_go_m - 1000.0) / app_ias);
1692 } else if(tpr->opType == CIRCUIT || tpr->opType == TTT_UNKNOWN) { // Hack alert - UNKNOWN has sort of been added here as a temporary hack.
1693 //cout << "CASE 2\n";
1694 // It's complicated - depends on if base leg is delayed or not
1696 //cout << "Leg = " << tpr->leg << '\n';
1698 if(tpr->leg == LANDING_ROLL) {
1700 } else if((tpr->leg == FINAL) || (tpr->leg == TURN4)) {
1701 //cout << "dist_out_m = " << dist_out_m << '\n';
1702 tpr->eta = fabs(dist_out_m) / final_ias;
1703 } else if((tpr->leg == BASE) || (tpr->leg == TURN3)) {
1704 tpr->eta = (fabs(dist_out_m) / final_ias) + (dist_across_m / circuit_ias);
1706 // Need to calculate where base leg is likely to be
1707 // FIXME - for now I'll hardwire it to 1000m which is what AILocalTraffic uses!!!
1708 // TODO - as a matter of design - AILocalTraffic should get the nominal no-traffic base turn distance from Tower, since in real life the published pattern might differ from airport to airport
1709 double nominal_base_dist_out_m = -1000;
1710 double current_base_dist_out_m;
1711 if(!GetBaseConstraint(current_base_dist_out_m)) {
1712 current_base_dist_out_m = nominal_base_dist_out_m;
1714 //cout << "current_base_dist_out_m = " << current_base_dist_out_m << '\n';
1715 double nominal_dist_across_m = 1000; // Hardwired value from AILocalTraffic
1716 double current_dist_across_m;
1717 if(!GetDownwindConstraint(current_dist_across_m)) {
1718 current_dist_across_m = nominal_dist_across_m;
1720 double nominal_cross_dist_out_m = 2000; // Bit of a guess - AI plane turns to crosswind at 700ft agl.
1721 tpr->eta = fabs(current_base_dist_out_m) / final_ias; // final
1722 //cout << "a = " << tpr->eta << '\n';
1723 if((tpr->leg == DOWNWIND) || (tpr->leg == TURN2)) {
1724 tpr->eta += dist_across_m / circuit_ias;
1725 //cout << "b = " << tpr->eta << '\n';
1726 tpr->eta += fabs(current_base_dist_out_m - dist_out_m) / circuit_ias;
1727 //cout << "c = " << tpr->eta << '\n';
1728 } else if((tpr->leg == CROSSWIND) || (tpr->leg == TURN1)) {
1729 //cout << "CROSSWIND calc: ";
1730 //cout << tpr->eta << ' ';
1731 if(dist_across_m > nominal_dist_across_m) {
1732 tpr->eta += dist_across_m / circuit_ias;
1735 tpr->eta += nominal_dist_across_m / circuit_ias;
1738 //cout << tpr->eta << ' ';
1739 // should we use the dist across of the previous plane if there is previous still on downwind?
1740 //if(printout) cout << "bb = " << tpr->eta << '\n';
1741 if(dist_out_m > nominal_cross_dist_out_m) {
1742 tpr->eta += fabs(current_base_dist_out_m - dist_out_m) / circuit_ias;
1745 tpr->eta += fabs(current_base_dist_out_m - nominal_cross_dist_out_m) / circuit_ias;
1748 //cout << tpr->eta << ' ';
1749 //if(printout) cout << "cc = " << tpr->eta << '\n';
1750 if(nominal_dist_across_m > dist_across_m) {
1751 tpr->eta += (nominal_dist_across_m - dist_across_m) / circuit_ias;
1757 //cout << tpr->eta << '\n';
1758 //if(printout) cout << "dd = " << tpr->eta << '\n';
1760 // We've only just started - why not use a generic estimate?
1765 // cout << "ETA = " << tpr->eta << '\n';
1767 //if(!tpr->isUser) cout << tpr->plane.callsign << '\t' << tpr->eta << '\n';
1774 // Calculate the distance of a plane to the threshold in meters
1775 // TODO - Modify to calculate flying distance of a plane in the circuit
1776 double FGTower::CalcDistOutM(TowerPlaneRec* tpr) {
1777 return(dclGetHorizontalSeparation(rwy.threshold_pos, tpr->pos));
1781 // Calculate the distance of a plane to the threshold in miles
1782 // TODO - Modify to calculate flying distance of a plane in the circuit
1783 double FGTower::CalcDistOutMiles(TowerPlaneRec* tpr) {
1784 return(CalcDistOutM(tpr) / 1600.0); // FIXME - use a proper constant if possible.
1788 // Iterate through all the lists, update the position of, and call CalcETA for all the planes.
1789 void FGTower::doThresholdETACalc() {
1790 //cout << "Entering doThresholdETACalc..." << endl;
1791 tower_plane_rec_list_iterator twrItr;
1792 // Do the approach list first
1793 for(twrItr = appList.begin(); twrItr != appList.end(); twrItr++) {
1794 TowerPlaneRec* tpr = *twrItr;
1795 if(!(tpr->isUser)) tpr->pos = tpr->planePtr->GetPos();
1799 // Then the circuit list
1800 //cout << "Circuit list size is " << circuitList.size() << '\n';
1801 for(twrItr = circuitList.begin(); twrItr != circuitList.end(); twrItr++) {
1802 TowerPlaneRec* tpr = *twrItr;
1803 if(!(tpr->isUser)) tpr->pos = tpr->planePtr->GetPos();
1807 //cout << "Done doThresholdETCCalc" << endl;
1811 // Check that the planes in traffic list are correctly ordered,
1812 // that the nearest (timewise) is flagged next on rwy, and return
1813 // true if any threshold use conflicts are detected, false otherwise.
1814 bool FGTower::doThresholdUseOrder() {
1815 //cout << "Entering doThresholdUseOrder..." << endl;
1816 bool conflict = false;
1818 // Wipe out traffic list, go through circuit, app and hold list, and reorder them in traffic list.
1819 // Here's the rather simplistic assumptions we're using:
1820 // Currently all planes are assumed to be GA light singles with corresponding speeds and separation times.
1821 // In order of priority for runway use:
1822 // STRAIGHT_IN > CIRCUIT > HOLDING_FOR_DEPARTURE
1823 // No modification of planes speeds occurs - conflicts are resolved by delaying turn for base,
1824 // and holding planes until a space.
1825 // When calculating if a holding plane can use the runway, time clearance from last departure
1826 // as well as time clearance to next arrival must be considered.
1828 trafficList.clear();
1830 tower_plane_rec_list_iterator twrItr;
1831 // Do the approach list first
1832 //if(ident == "KRHV") cout << "A" << flush;
1833 for(twrItr = appList.begin(); twrItr != appList.end(); twrItr++) {
1834 TowerPlaneRec* tpr = *twrItr;
1835 //if(ident == "KRHV") cout << tpr->plane.callsign << '\n';
1836 conflict = AddToTrafficList(tpr);
1838 // Then the circuit list
1839 //if(ident == "KRHV") cout << "C" << flush;
1840 for(twrItr = circuitList.begin(); twrItr != circuitList.end(); twrItr++) {
1841 TowerPlaneRec* tpr = *twrItr;
1842 //if(ident == "KRHV") cout << tpr->plane.callsign << '\n';
1843 conflict = AddToTrafficList(tpr);
1845 // And finally the hold list
1846 //cout << "H" << endl;
1847 for(twrItr = holdList.begin(); twrItr != holdList.end(); twrItr++) {
1848 TowerPlaneRec* tpr = *twrItr;
1849 AddToTrafficList(tpr, true);
1854 //if(ident == "KRHV") {
1856 for(twrItr = trafficList.begin(); twrItr != trafficList.end(); twrItr++) {
1857 TowerPlaneRec* tpr = *twrItr;
1858 cout << tpr->plane.callsign << '\t' << tpr->eta << '\t';
1863 //cout << "Done doThresholdUseOrder" << endl;
1868 // Return the ETA of plane no. list_pos (1-based) in the traffic list.
1869 // i.e. list_pos = 1 implies next to use runway.
1870 double FGTower::GetTrafficETA(unsigned int list_pos, bool printout) {
1871 if(trafficList.size() < list_pos) {
1875 tower_plane_rec_list_iterator twrItr;
1876 twrItr = trafficList.begin();
1877 for(unsigned int i = 1; i < list_pos; i++, twrItr++);
1878 TowerPlaneRec* tpr = *twrItr;
1879 CalcETA(tpr, printout);
1880 //cout << "ETA returned = " << tpr->eta << '\n';
1885 void FGTower::ContactAtHoldShort(PlaneRec plane, FGAIPlane* requestee, tower_traffic_type operation) {
1886 // HACK - assume that anything contacting at hold short is new for now - FIXME LATER
1887 TowerPlaneRec* t = new TowerPlaneRec;
1889 t->planePtr = requestee;
1890 t->holdShortReported = true;
1891 t->clearedToLineUp = false;
1892 t->clearedToTakeOff = false;
1893 t->opType = operation;
1894 t->pos = requestee->GetPos();
1896 //cout << "Hold Short reported by " << plane.callsign << '\n';
1897 SG_LOG(SG_ATC, SG_BULK, "Hold Short reported by " << plane.callsign);
1900 bool next = AddToTrafficList(t, true);
1902 double teta = GetTrafficETA(2);
1904 t->clearanceCounter = 7.0; // This reduces the delay before response to 3 secs if an immediate takeoff is reqd
1905 //cout << "Reducing response time to request due imminent traffic\n";
1910 // TODO - possibly add the reduced interval to clearance when immediate back in under the new scheme
1912 holdList.push_back(t);
1914 responseReqd = true;
1917 // Register the presence of an AI plane at a point where contact would already have been made in real life
1918 // CAUTION - currently it is assumed that this plane's callsign is unique - it is up to AIMgr to generate unique callsigns.
1919 void FGTower::RegisterAIPlane(PlaneRec plane, FGAIPlane* ai, tower_traffic_type op, PatternLeg lg) {
1920 // At the moment this is only going to be tested with inserting an AI plane on downwind
1921 TowerPlaneRec* t = new TowerPlaneRec;
1926 t->pos = ai->GetPos();
1930 if(op == CIRCUIT && lg != LEG_UNKNOWN) {
1931 AddToCircuitList(t);
1936 doThresholdUseOrder();
1939 void FGTower::DeregisterAIPlane(string id) {
1943 // Contact tower for VFR approach
1944 // eg "Cessna Charlie Foxtrot Golf Foxtrot Sierra eight miles South of the airport for full stop with Bravo"
1945 // This function probably only called via user interaction - AI planes will have an overloaded function taking a planerec.
1946 // opt defaults to AIP_LT_UNKNOWN
1947 void FGTower::VFRArrivalContact(string ID, LandingType opt) {
1948 //cout << "USER Request Landing Clearance called for ID " << ID << '\n';
1950 // For now we'll assume that the user is a light plane and can get him/her to join the circuit if necessary.
1953 string usercall = fgGetString("/sim/user/callsign");
1954 if(ID == "USER" || ID == usercall) {
1955 t = FindPlane(usercall);
1957 //cout << "NOT t\n";
1958 t = new TowerPlaneRec;
1960 t->pos.setlon(user_lon_node->getDoubleValue());
1961 t->pos.setlat(user_lat_node->getDoubleValue());
1962 t->pos.setelev(user_elev_node->getDoubleValue());
1965 // Oops - the plane is already registered with this tower - maybe we took off and flew a giant circuit without
1966 // quite getting out of tower airspace - just ignore for now and treat as new arrival.
1967 // TODO - Maybe should remove from departure and circuit list if in there though!!
1970 // Oops - something has gone wrong - put out a warning
1971 cout << "WARNING - FGTower::VFRContact(string ID, LandingType lt) called with ID " << ID << " which does not appear to be the user.\n";
1977 // Calculate where the plane is in relation to the active runway and it's circuit
1978 // and set the op-type as appropriate.
1980 // HACK - to get up and running I'm going to assume that the user contacts tower on a staight-in final for now.
1981 t->opType = STRAIGHT_IN;
1983 t->plane.type = GA_SINGLE; // FIXME - Another assumption!
1984 t->plane.callsign = usercall;
1986 t->vfrArrivalReported = true;
1987 responseReqd = true;
1989 appList.push_back(t); // Not necessarily permanent
1990 AddToTrafficList(t);
1992 current_atcdialog->remove_entry(ident, USER_REQUEST_VFR_ARRIVAL, TOWER);
1993 current_atcdialog->remove_entry(ident, USER_REQUEST_VFR_ARRIVAL_FULL_STOP, TOWER);
1994 current_atcdialog->remove_entry(ident, USER_REQUEST_VFR_ARRIVAL_TOUCH_AND_GO, TOWER);
1997 // landingType defaults to AIP_LT_UNKNOWN
1998 void FGTower::VFRArrivalContact(PlaneRec plane, FGAIPlane* requestee, LandingType lt) {
1999 //cout << "VFRArrivalContact called for plane " << plane.callsign << " at " << ident << '\n';
2000 // Possible hack - assume this plane is new for now - TODO - should check really
2001 TowerPlaneRec* t = new TowerPlaneRec;
2003 t->planePtr = requestee;
2004 t->landingType = lt;
2005 t->pos = requestee->GetPos();
2007 //cout << "Hold Short reported by " << plane.callsign << '\n';
2008 SG_LOG(SG_ATC, SG_BULK, "VFR arrival contact made by " << plane.callsign);
2009 //cout << "VFR arrival contact made by " << plane.callsign << '\n';
2011 // HACK - to get up and running I'm going to assume a staight-in final for now.
2012 t->opType = STRAIGHT_IN;
2014 t->vfrArrivalReported = true;
2015 responseReqd = true;
2017 //cout << "Before adding, appList.size = " << appList.size() << " at " << ident << '\n';
2018 appList.push_back(t); // Not necessarily permanent
2019 //cout << "After adding, appList.size = " << appList.size() << " at " << ident << '\n';
2020 AddToTrafficList(t);
2023 void FGTower::RequestDepartureClearance(string ID) {
2024 //cout << "Request Departure Clearance called...\n";
2027 void FGTower::ReportFinal(string ID) {
2028 //cout << "Report Final Called at tower " << ident << " by plane " << ID << '\n';
2030 ID = fgGetString("/sim/user/callsign");
2031 current_atcdialog->remove_entry(ident, USER_REPORT_3_MILE_FINAL, TOWER);
2033 TowerPlaneRec* t = FindPlane(ID);
2035 t->finalReported = true;
2036 t->finalAcknowledged = false;
2037 if(!(t->clearedToLand)) {
2038 responseReqd = true;
2040 // possibly respond with wind even if already cleared to land?
2041 t->finalReported = false;
2042 t->finalAcknowledged = true;
2043 // HACK!! - prevents next reporting being misinterpreted as this one.
2046 SG_LOG(SG_ATC, SG_WARN, "WARNING: Unable to find plane " << ID << " in FGTower::ReportFinal(...)");
2050 void FGTower::ReportLongFinal(string ID) {
2052 ID = fgGetString("/sim/user/callsign");
2053 current_atcdialog->remove_entry(ident, USER_REPORT_3_MILE_FINAL, TOWER);
2055 TowerPlaneRec* t = FindPlane(ID);
2057 t->longFinalReported = true;
2058 t->longFinalAcknowledged = false;
2059 if(!(t->clearedToLand)) {
2060 responseReqd = true;
2061 } // possibly respond with wind even if already cleared to land?
2063 SG_LOG(SG_ATC, SG_WARN, "WARNING: Unable to find plane " << ID << " in FGTower::ReportLongFinal(...)");
2067 //void FGTower::ReportOuterMarker(string ID);
2068 //void FGTower::ReportMiddleMarker(string ID);
2069 //void FGTower::ReportInnerMarker(string ID);
2071 void FGTower::ReportRunwayVacated(string ID) {
2072 //cout << "Report Runway Vacated Called at tower " << ident << " by plane " << ID << '\n';
2074 ID = fgGetString("/sim/user/callsign");
2075 current_atcdialog->remove_entry(ident, USER_REPORT_RWY_VACATED, TOWER);
2077 TowerPlaneRec* t = FindPlane(ID);
2079 //cout << "Found it...\n";
2080 t->rwyVacatedReported = true;
2081 responseReqd = true;
2083 SG_LOG(SG_ATC, SG_WARN, "WARNING: Unable to find plane " << ID << " in FGTower::ReportRunwayVacated(...)");
2084 SG_LOG(SG_ATC, SG_ALERT, "A WARNING: Unable to find plane " << ID << " in FGTower::ReportRunwayVacated(...)");
2085 //cout << "WARNING: Unable to find plane " << ID << " in FGTower::ReportRunwayVacated(...)\n";
2089 TowerPlaneRec* FGTower::FindPlane(string ID) {
2090 //cout << "FindPlane called for " << ID << "...\n";
2091 tower_plane_rec_list_iterator twrItr;
2092 // Do the approach list first
2093 for(twrItr = appList.begin(); twrItr != appList.end(); twrItr++) {
2094 //cout << "appList callsign is " << (*twrItr)->plane.callsign << '\n';
2095 if((*twrItr)->plane.callsign == ID) return(*twrItr);
2097 // Then the circuit list
2098 for(twrItr = circuitList.begin(); twrItr != circuitList.end(); twrItr++) {
2099 //cout << "circuitList callsign is " << (*twrItr)->plane.callsign << '\n';
2100 if((*twrItr)->plane.callsign == ID) return(*twrItr);
2102 // Then the runway list
2103 //cout << "rwyList.size() is " << rwyList.size() << '\n';
2104 for(twrItr = rwyList.begin(); twrItr != rwyList.end(); twrItr++) {
2105 //cout << "rwyList callsign is " << (*twrItr)->plane.callsign << '\n';
2106 if((*twrItr)->plane.callsign == ID) return(*twrItr);
2109 for(twrItr = holdList.begin(); twrItr != holdList.end(); twrItr++) {
2110 if((*twrItr)->plane.callsign == ID) return(*twrItr);
2112 // And finally the vacated list
2113 for(twrItr = vacatedList.begin(); twrItr != vacatedList.end(); twrItr++) {
2114 //cout << "vacatedList callsign is " << (*twrItr)->plane.callsign << '\n';
2115 if((*twrItr)->plane.callsign == ID) return(*twrItr);
2117 SG_LOG(SG_ATC, SG_WARN, "Unable to find " << ID << " in FGTower::FindPlane(...)");
2122 void FGTower::RemovePlane(string ID) {
2123 //cout << ident << " RemovePlane called for " << ID << '\n';
2124 // We have to be careful here - we want to erase the plane from all lists it is in,
2125 // but we can only delete it once, AT THE END.
2126 TowerPlaneRec* t = NULL;
2127 tower_plane_rec_list_iterator twrItr;
2128 for(twrItr = appList.begin(); twrItr != appList.end(); twrItr++) {
2129 if((*twrItr)->plane.callsign == ID) {
2131 twrItr = appList.erase(twrItr);
2132 appListItr = appList.begin();
2135 for(twrItr = depList.begin(); twrItr != depList.end(); twrItr++) {
2136 if((*twrItr)->plane.callsign == ID) {
2138 twrItr = depList.erase(twrItr);
2139 depListItr = depList.begin();
2142 for(twrItr = circuitList.begin(); twrItr != circuitList.end(); twrItr++) {
2143 if((*twrItr)->plane.callsign == ID) {
2145 twrItr = circuitList.erase(twrItr);
2146 circuitListItr = circuitList.begin();
2149 for(twrItr = holdList.begin(); twrItr != holdList.end(); twrItr++) {
2150 if((*twrItr)->plane.callsign == ID) {
2152 twrItr = holdList.erase(twrItr);
2153 holdListItr = holdList.begin();
2156 for(twrItr = rwyList.begin(); twrItr != rwyList.end(); twrItr++) {
2157 if((*twrItr)->plane.callsign == ID) {
2159 twrItr = rwyList.erase(twrItr);
2160 rwyListItr = rwyList.begin();
2163 for(twrItr = vacatedList.begin(); twrItr != vacatedList.end(); twrItr++) {
2164 if((*twrItr)->plane.callsign == ID) {
2166 twrItr = vacatedList.erase(twrItr);
2167 vacatedListItr = vacatedList.begin();
2170 for(twrItr = trafficList.begin(); twrItr != trafficList.end(); twrItr++) {
2171 if((*twrItr)->plane.callsign == ID) {
2173 twrItr = trafficList.erase(twrItr);
2174 trafficListItr = trafficList.begin();
2177 // And finally, delete the record if we found it.
2181 void FGTower::ReportDownwind(string ID) {
2182 //cout << "ReportDownwind(...) called\n";
2184 ID = fgGetString("/sim/user/callsign");
2185 current_atcdialog->remove_entry(ident, USER_REPORT_DOWNWIND, TOWER);
2187 TowerPlaneRec* t = FindPlane(ID);
2189 t->downwindReported = true;
2190 responseReqd = true;
2191 // If the plane is in the app list, remove it and put it in the circuit list instead.
2192 // Ideally we might want to do this at the 2 mile report prior to 45 deg entry, but at
2193 // the moment that would b&gg?r up the constraint position calculations.
2194 RemoveFromAppList(ID);
2197 t->pos.setlon(user_lon_node->getDoubleValue());
2198 t->pos.setlat(user_lat_node->getDoubleValue());
2199 t->pos.setelev(user_elev_node->getDoubleValue());
2201 // ASSERT(t->planePtr != NULL);
2202 t->pos = t->planePtr->GetPos();
2205 AddToCircuitList(t);
2207 SG_LOG(SG_ATC, SG_WARN, "WARNING: Unable to find plane " << ID << " in FGTower::ReportDownwind(...)");
2211 void FGTower::ReportGoingAround(string ID) {
2213 ID = fgGetString("/sim/user/callsign");
2214 RemoveAllUserDialogOptions(); // TODO - it would be much more efficient if ATCDialog simply had a clear() function!!!
2215 current_atcdialog->add_entry(ident, "@AP Tower @CS Downwind @RW", "Report Downwind", TOWER, (int)USER_REPORT_DOWNWIND);
2217 TowerPlaneRec* t = FindPlane(ID);
2219 //t->goAroundReported = true; // No need to set this until we start responding to it.
2220 responseReqd = false; // might change in the future but for now we'll not distract them during the go-around.
2221 // If the plane is in the app list, remove it and put it in the circuit list instead.
2222 RemoveFromAppList(ID);
2225 t->pos.setlon(user_lon_node->getDoubleValue());
2226 t->pos.setlat(user_lat_node->getDoubleValue());
2227 t->pos.setelev(user_elev_node->getDoubleValue());
2229 // ASSERT(t->planePtr != NULL);
2230 t->pos = t->planePtr->GetPos();
2233 AddToCircuitList(t);
2235 SG_LOG(SG_ATC, SG_WARN, "WARNING: Unable to find plane " << ID << " in FGTower::ReportDownwind(...)");
2239 string FGTower::GenText(const string& m, int c) {
2240 const int cmax = 300;
2250 string usercall = fgGetString("/sim/user/callsign");
2252 //transmission_list_type tmissions = transmissionlist_station[station];
2253 //transmission_list_iterator current = tmissions.begin();
2254 //transmission_list_iterator last = tmissions.end();
2256 //for ( ; current != last ; ++current ) {
2257 // if ( current->get_code().c1 == code.c1 &&
2258 // current->get_code().c2 == code.c2 &&
2259 // current->get_code().c3 == code.c3 ) {
2261 //if ( ttext ) message = current->get_transtext();
2262 //else message = current->get_menutext();
2263 strcpy( &mes[0], m.c_str() );
2265 // Replace all the '@' parameters with the actual text.
2266 int check = 0; // If mes gets overflowed the while loop can go infinite
2267 while ( strchr(&mes[0], crej) != NULL ) { // ie. loop until no more occurances of crej ('@') found
2268 pos = strchr( &mes[0], crej );
2269 bcopy(pos, &tag[0], 3);
2273 for ( i=0; i<cmax; i++ ) {
2274 if ( mes[i] == crej ) {
2279 strncpy( &dum[0], &mes[0], len );
2282 if ( strcmp ( tag, "@ST" ) == 0 )
2283 //strcat( &dum[0], tpars.station.c_str() );
2284 strcat(&dum[0], ident.c_str());
2285 else if ( strcmp ( tag, "@AP" ) == 0 )
2286 //strcat( &dum[0], tpars.airport.c_str() );
2287 strcat(&dum[0], name.c_str());
2288 else if ( strcmp ( tag, "@CS" ) == 0 )
2289 //strcat( &dum[0], tpars.callsign.c_str() );
2290 strcat(&dum[0], usercall.c_str());
2291 else if ( strcmp ( tag, "@TD" ) == 0 ) {
2293 if ( tpars.tdir == 1 ) {
2294 char buf[] = "left";
2295 strcat( &dum[0], &buf[0] );
2298 char buf[] = "right";
2299 strcat( &dum[0], &buf[0] );
2303 else if ( strcmp ( tag, "@HE" ) == 0 ) {
2306 sprintf( buf, "%i", (int)(tpars.heading) );
2307 strcat( &dum[0], &buf[0] );
2310 else if ( strcmp ( tag, "@VD" ) == 0 ) {
2312 if ( tpars.VDir == 1 ) {
2313 char buf[] = "Descend and maintain";
2314 strcat( &dum[0], &buf[0] );
2316 else if ( tpars.VDir == 2 ) {
2317 char buf[] = "Maintain";
2318 strcat( &dum[0], &buf[0] );
2320 else if ( tpars.VDir == 3 ) {
2321 char buf[] = "Climb and maintain";
2322 strcat( &dum[0], &buf[0] );
2326 else if ( strcmp ( tag, "@AL" ) == 0 ) {
2329 sprintf( buf, "%i", (int)(tpars.alt) );
2330 strcat( &dum[0], &buf[0] );
2333 else if ( strcmp ( tag, "@MI" ) == 0 ) {
2335 //sprintf( buf, "%3.1f", tpars.miles );
2336 int dist_miles = (int)dclGetHorizontalSeparation(Point3D(lon, lat, elev), Point3D(user_lon_node->getDoubleValue(), user_lat_node->getDoubleValue(), user_elev_node->getDoubleValue())) / 1600;
2337 sprintf(buf, "%i", dist_miles);
2338 strcat( &dum[0], &buf[0] );
2340 else if ( strcmp ( tag, "@FR" ) == 0 ) {
2343 sprintf( buf, "%6.2f", tpars.freq );
2344 strcat( &dum[0], &buf[0] );
2347 else if ( strcmp ( tag, "@RW" ) == 0 ) {
2348 strcat(&dum[0], ConvertRwyNumToSpokenString(activeRwy).c_str());
2349 } else if(strcmp(tag, "@CD") == 0) { // @CD = compass direction
2350 double h = GetHeadingFromTo(Point3D(lon, lat, elev), Point3D(user_lon_node->getDoubleValue(), user_lat_node->getDoubleValue(), user_elev_node->getDoubleValue()));
2351 while(h < 0.0) h += 360.0;
2352 while(h > 360.0) h -= 360.0;
2353 if(h < 22.5 || h > 337.5) {
2354 strcat(&dum[0], "North");
2355 } else if(h < 67.5) {
2356 strcat(&dum[0], "North-East");
2357 } else if(h < 112.5) {
2358 strcat(&dum[0], "East");
2359 } else if(h < 157.5) {
2360 strcat(&dum[0], "South-East");
2361 } else if(h < 202.5) {
2362 strcat(&dum[0], "South");
2363 } else if(h < 247.5) {
2364 strcat(&dum[0], "South-West");
2365 } else if(h < 292.5) {
2366 strcat(&dum[0], "West");
2368 strcat(&dum[0], "North-West");
2371 cout << "Tag " << tag << " not found" << endl;
2374 strcat( &dum[0], &mes[len+3] );
2375 strcpy( &mes[0], &dum[0] );
2379 SG_LOG(SG_ATC, SG_WARN, "WARNING: Possibly endless loop terminated in FGTransmissionlist::gen_text(...)");
2384 //cout << mes << endl;
2388 if ( mes != "" ) return mes;
2389 else return "No transmission found";
2392 ostream& operator << (ostream& os, tower_traffic_type ttt) {
2394 case(CIRCUIT): return(os << "CIRCUIT");
2395 case(INBOUND): return(os << "INBOUND");
2396 case(OUTBOUND): return(os << "OUTBOUND");
2397 case(TTT_UNKNOWN): return(os << "UNKNOWN");
2398 case(STRAIGHT_IN): return(os << "STRAIGHT_IN");
2400 return(os << "ERROR - Unknown switch in tower_traffic_type operator << ");
projects / flightgear.git / blob