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
6 // Copyright (C) 2008 Daniyar Atadjanov (ground clearance, gear check, weather, etc.)
8 // This program is free software; you can redistribute it and/or
9 // modify it under the terms of the GNU General Public License as
10 // published by the Free Software Foundation; either version 2 of the
11 // License, or (at your option) any later version.
13 // This program is distributed in the hope that it will be useful, but
14 // WITHOUT ANY WARRANTY; without even the implied warranty of
15 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
16 // General Public License for more details.
18 // You should have received a copy of the GNU General Public License
19 // along with this program; if not, write to the Free Software
20 // Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
27 # include <strings.h> // bcopy()
29 # include <string.h> // MSVC doesn't have strings.h
36 #include <simgear/debug/logstream.hxx>
37 #include <simgear/math/sg_geodesy.hxx>
38 #include <simgear/math/sg_random.h>
39 #include <simgear/misc/sg_path.hxx>
41 #include <Main/globals.hxx>
42 #include <Airports/runways.hxx>
46 #include "ATCutils.hxx"
47 #include "ATCDialog.hxx"
48 #include "commlist.hxx"
49 #include "AILocalTraffic.hxx"
56 TowerPlaneRec::TowerPlaneRec() :
61 clearedToLineUp(false),
62 clearedToTakeOff(false),
63 holdShortReported(false),
64 lineUpReported(false),
65 downwindReported(false),
66 longFinalReported(false),
67 longFinalAcknowledged(false),
69 finalAcknowledged(false),
70 rwyVacatedReported(false),
71 rwyVacatedAcknowledged(false),
72 goAroundReported(false),
73 instructedToGoAround(false),
77 gearUpReported(false),
78 vfrArrivalReported(false),
79 vfrArrivalAcknowledged(false),
82 landingType(AIP_LT_UNKNOWN),
85 plane.callsign = "UNKNOWN";
88 TowerPlaneRec::TowerPlaneRec(const PlaneRec& p) :
93 clearedToLineUp(false),
94 clearedToTakeOff(false),
95 holdShortReported(false),
96 lineUpReported(false),
97 downwindReported(false),
98 longFinalReported(false),
99 longFinalAcknowledged(false),
100 finalReported(false),
101 finalAcknowledged(false),
102 rwyVacatedReported(false),
103 rwyVacatedAcknowledged(false),
104 goAroundReported(false),
105 instructedToGoAround(false),
109 gearUpReported(false),
110 vfrArrivalReported(false),
111 vfrArrivalAcknowledged(false),
114 landingType(AIP_LT_UNKNOWN),
120 TowerPlaneRec::TowerPlaneRec(const SGGeod& pt) :
124 clearedToLand(false),
125 clearedToLineUp(false),
126 clearedToTakeOff(false),
127 holdShortReported(false),
128 lineUpReported(false),
129 downwindReported(false),
130 longFinalReported(false),
131 longFinalAcknowledged(false),
132 finalReported(false),
133 finalAcknowledged(false),
134 rwyVacatedReported(false),
135 rwyVacatedAcknowledged(false),
136 goAroundReported(false),
137 instructedToGoAround(false),
141 gearUpReported(false),
142 vfrArrivalReported(false),
143 vfrArrivalAcknowledged(false),
146 landingType(AIP_LT_UNKNOWN),
149 plane.callsign = "UNKNOWN";
153 TowerPlaneRec::TowerPlaneRec(const PlaneRec& p, const SGGeod& pt) :
157 clearedToLand(false),
158 clearedToLineUp(false),
159 clearedToTakeOff(false),
160 holdShortReported(false),
161 lineUpReported(false),
162 downwindReported(false),
163 longFinalReported(false),
164 longFinalAcknowledged(false),
165 finalReported(false),
166 finalAcknowledged(false),
167 rwyVacatedReported(false),
168 rwyVacatedAcknowledged(false),
169 goAroundReported(false),
170 instructedToGoAround(false),
174 gearUpReported(false),
175 vfrArrivalReported(false),
176 vfrArrivalAcknowledged(false),
179 landingType(AIP_LT_UNKNOWN),
189 /*******************************************
192 Currently user is assumed to have taken off again when leaving the runway - check speed/elev for taxiing-in. (MAJOR)
194 Use track instead of heading to determine what leg of the circuit the user is flying. (MINOR)
196 Use altitude as well as position to try to determine if the user has left the circuit. (MEDIUM - other issues as well).
198 Currently HoldShortReported code assumes there will be only one plane holding for the runway at once and
199 will break when planes start queueing. (CRITICAL)
201 Report-Runway-Vacated is left as only user ATC option following a go-around. (MAJOR)
203 Report-Downwind is not added as ATC option when user takes off to fly a circuit. (MAJOR)
205 eta of USER can be calculated very wrongly in circuit if flying straight out and turn4 etc are with +ve ortho y.
206 This can then screw up circuit ordering for other planes (MEDIUM)
208 USER leaving circuit needs to be more robustly considered when intentions unknown
209 Currently only considered during climbout and breaks when user turns (MEDIUM).
211 GetPos() of the AI planes is called erratically - either too much or not enough. (MINOR)
213 GO-AROUND is instructed very late at < 12s to landing - possibly make more dependent on chance of rwy clearing before landing (FEATURE)
215 Need to make clear when TowerPlaneRecs do or don't get deleted in RemoveFromCircuitList etc. (MINOR until I misuse it - then CRITICAL!)
217 FGTower::RemoveAllUserDialogOptions() really ought to be replaced by an ATCDialog::clear_entries() function. (MINOR - efficiency).
219 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).
220 *******************************************/
223 separateGround(true),
226 ATCmgr = globals->get_ATC_mgr();
230 // Init the property nodes - TODO - need to make sure we're getting surface winds.
231 wind_from_hdg = fgGetNode("/environment/wind-from-heading-deg", true);
232 wind_speed_knots = fgGetNode("/environment/wind-speed-kt", true);
235 update_count_max = 15;
237 holdListItr = holdList.begin();
238 appListItr = appList.begin();
239 depListItr = depList.begin();
240 rwyListItr = rwyList.begin();
241 circuitListItr = circuitList.begin();
242 trafficListItr = trafficList.begin();
243 vacatedListItr = vacatedList.begin();
247 timeSinceLastDeparture = 9999;
250 nominal_downwind_leg_pos = 1000.0;
251 nominal_base_leg_pos = -1000.0;
252 // TODO - set nominal crosswind leg pos based on minimum distance from takeoff end of rwy.
254 _departureControlled = false;
257 FGTower::~FGTower() {
258 if(!separateGround) {
263 void FGTower::Init() {
264 //cout << "Initialising tower " << ident << '\n';
266 // Pointers to user's position
267 user_lon_node = fgGetNode("/position/longitude-deg", true);
268 user_lat_node = fgGetNode("/position/latitude-deg", true);
269 user_elev_node = fgGetNode("/position/altitude-ft", true);
270 user_hdg_node = fgGetNode("/orientation/heading-deg", true);
272 // Need some way to initialise rwyOccupied flag correctly if the user is on the runway and to know its the user.
273 // I'll punt the startup issue for now though!!!
276 // Setup the ground control at this airport
278 //cout << "Tower ident = " << ident << '\n';
279 if(ATCmgr->GetAirportATCDetails(ident, &a)) {
280 if(a.ground_freq) { // Ground control
281 ground = (FGGround*)ATCmgr->GetATCPointer(ident, GROUND);
282 separateGround = true;
284 // Something has gone wrong :-(
285 SG_LOG(SG_ATC, SG_WARN, "ERROR - ground has frequency but can't get ground pointer :-(");
286 ground = new FGGround(ident);
287 separateGround = false;
290 ground->SetDisplay();
292 ground->SetNoDisplay();
296 // Initialise ground anyway to do the shortest path stuff!
297 // Note that we're now responsible for updating and deleting this - NOT the ATCMgr.
298 ground = new FGGround(ident);
299 separateGround = false;
302 ground->SetDisplay();
304 ground->SetNoDisplay();
308 SG_LOG(SG_ATC, SG_ALERT, "Unable to find airport details for " << ident << " in FGTower::Init()");
309 // Initialise ground anyway to avoid segfault later
310 ground = new FGGround(ident);
311 separateGround = false;
314 ground->SetDisplay();
316 ground->SetNoDisplay();
320 RemoveAllUserDialogOptions();
322 // TODO - attempt to get a departure control pointer to see if we need to hand off departing traffic to departure.
324 // Get the airport elevation
325 aptElev = fgGetAirportElev(ident.c_str());
327 // TODO - this function only assumes one active rwy.
330 // TODO - this currently assumes only one active runway.
331 rwyOccupied = OnActiveRunway(SGGeod::fromDegM(user_lon_node->getDoubleValue(), user_lat_node->getDoubleValue(), 0.0));
333 if(!OnAnyRunway(SGGeod::fromDegM(user_lon_node->getDoubleValue(), user_lat_node->getDoubleValue(), 0.0), false)) {
334 //cout << ident << " ADD 0\n";
335 current_atcdialog->add_entry(ident, "@AP Tower, @CS @MI miles @CD of the airport for full stop@AT",
336 "Contact tower for VFR arrival (full stop)", TOWER,
337 (int)USER_REQUEST_VFR_ARRIVAL_FULL_STOP);
339 //cout << "User found on active runway\n";
340 // Assume the user is started at the threshold ready to take-off
341 TowerPlaneRec* t = new TowerPlaneRec;
342 t->plane.callsign = fgGetString("/sim/user/callsign");
343 t->plane.type = GA_SINGLE; // FIXME - hardwired!!
344 t->opType = TTT_UNKNOWN; // We don't know if the user wants to do circuits or a departure...
345 t->landingType = AIP_LT_UNKNOWN;
346 t->leg = TAKEOFF_ROLL;
349 t->clearedToTakeOff = false;
350 rwyList.push_back(t);
351 rwyListItr = rwyList.begin();
353 current_atcdialog->add_entry(ident, "@CS @TO", "Request departure / take-off clearance",
354 TOWER, (int)USER_REQUEST_TAKE_OFF);
358 void FGTower::Update(double dt) {
359 //cout << "T" << endl;
360 // Each time step, what do we need to do?
361 // We need to go through the list of outstanding requests and acknowedgements
362 // and process at least one of them.
363 // We need to go through the list of planes under our control and check if
364 // any need to be addressed.
365 // We need to check for planes not under our control coming within our
366 // control area and address if necessary.
368 // TODO - a lot of the below probably doesn't need to be called every frame and should be staggered.
370 // Sort the arriving planes
373 if(ident == "KEMT") {
374 cout << update_count << "\ttL: " << trafficList.size() << " cL: " << circuitList.size() << " hL: " << holdList.size() << " aL: " << appList.size() << '\n';
377 //if(ident == "EGNX") cout << display << '\n';
379 if(departed != false) {
380 timeSinceLastDeparture += dt;
381 //if(ident == "KEMT")
382 // cout << " dt = " << dt << " timeSinceLastDeparture = " << timeSinceLastDeparture << '\n';
385 //cout << ident << " respond = " << respond << " responseReqd = " << responseReqd << '\n';
387 if(!responseReqd) SG_LOG(SG_ATC, SG_ALERT, "ERROR - respond is true and responseReqd is false in FGTower::Update(...)");
390 responseReqd = false;
393 // Calculate the eta of each plane to the threshold.
394 // For ground traffic this is the fastest they can get there.
395 // For air traffic this is the middle approximation.
396 if(update_count == 1) {
397 doThresholdETACalc();
400 // Order the list of traffic as per expected threshold use and flag any conflicts
401 if(update_count == 2) {
402 //bool conflicts = doThresholdUseOrder();
403 doThresholdUseOrder();
406 // sortConficts() !!!
408 if(update_count == 4) {
412 // Uggh - HACK - why have we got rwyOccupied - wouldn't simply testing rwyList.size() do?
419 if(update_count == 5 && rwyOccupied) {
423 if(update_count == 6) {
424 CheckCircuitList(dt);
427 if(update_count == 7) {
428 CheckApproachList(dt);
431 if(update_count == 8) {
432 CheckDepartureList(dt);
435 // TODO - do one plane from the departure list and set departed = false when out of consideration
439 if(!separateGround) {
440 // The display stuff might have to get more clever than this when not separate
441 // since the tower and ground might try communicating simultaneously even though
442 // they're mean't to be the same contoller/frequency!!
443 // We could also get rid of this by overloading FGATC's Set(No)Display() functions.
445 ground->SetDisplay();
447 ground->SetNoDisplay();
453 // How big should ii get - ie how long should the update cycle interval stretch?
454 if(update_count >= update_count_max) {
458 // Call the base class update for the response time handling.
462 void FGTower::ReceiveUserCallback(int code) {
463 if(code == (int)USER_REQUEST_VFR_DEPARTURE) {
464 RequestDepartureClearance("USER");
465 } else if(code == (int)USER_REQUEST_VFR_ARRIVAL) {
466 VFRArrivalContact("USER");
467 } else if(code == (int)USER_REQUEST_VFR_ARRIVAL_FULL_STOP) {
468 VFRArrivalContact("USER", FULL_STOP);
469 } else if(code == (int)USER_REQUEST_VFR_ARRIVAL_TOUCH_AND_GO) {
470 VFRArrivalContact("USER", TOUCH_AND_GO);
471 } else if(code == (int)USER_REPORT_DOWNWIND) {
472 ReportDownwind("USER");
473 } else if(code == (int)USER_REPORT_3_MILE_FINAL) {
474 // For now we'll just call report final instead of report long final to avoid having to alter the response code
476 } else if(code == (int)USER_REPORT_RWY_VACATED) {
477 ReportRunwayVacated("USER");
478 } else if(code == (int)USER_REPORT_GOING_AROUND) {
479 ReportGoingAround("USER");
480 } else if(code == (int)USER_REQUEST_TAKE_OFF) {
481 RequestTakeOffClearance("USER");
485 // **************** RESPONSE FUNCTIONS ****************
487 void FGTower::Respond() {
488 //cout << "\nEntering Respond, responseID = " << responseID << endl;
489 TowerPlaneRec* t = FindPlane(responseID);
492 if(t->vfrArrivalReported && !t->vfrArrivalAcknowledged) {
493 //cout << "Tower " << ident << " is responding to VFR arrival reported...\n";
494 // Testing - hardwire straight in for now
495 string trns = t->plane.callsign;
499 // Should we clear staight in or for downwind entry?
500 // For now we'll clear straight in if greater than 1km from a line drawn through the threshold perpendicular to the rwy.
501 // Later on we might check the actual heading and direct some of those to enter on downwind or base.
502 SGVec3d op = ortho.ConvertToLocal(t->pos);
503 float gp = fgGetFloat("/gear/gear/position-norm");
505 t->gearWasUp = true; // This will be needed on final to tell "Gear down, ready to land."
507 trns += " Report three mile straight-in runway ";
508 t->opType = STRAIGHT_IN;
510 current_atcdialog->add_entry(ident, "@CS @MI mile final runway @RW@GR", "Report Final", TOWER, (int)USER_REPORT_3_MILE_FINAL);
512 t->planePtr->RegisterTransmission(14);
515 // For now we'll just request reporting downwind.
516 // TODO - In real life something like 'report 2 miles southwest right downwind rwy 19R' might be used
517 // but I'm not sure how to handle all permutations of which direction to tell to report from yet.
519 //cout << "Responding, rwy.patterDirection is " << rwy.patternDirection << '\n';
520 trns += ((rwy.patternDirection == 1) ? "right " : "left ");
521 trns += "downwind runway ";
523 // leave it in the app list until it gets into pattern though.
525 current_atcdialog->add_entry(ident, "@AP Tower, @CS Downwind @RW", "Report Downwind", TOWER, (int)USER_REPORT_DOWNWIND);
527 t->planePtr->RegisterTransmission(15);
530 trns += ConvertRwyNumToSpokenString(activeRwy);
532 pending_transmission = trns;
535 //cout << "Not displaying, trns was " << trns << '\n';
537 t->vfrArrivalAcknowledged = true;
538 } else if(t->downwindReported) {
539 //cout << "Tower " << ident << " is responding to downwind reported...\n";
540 ProcessDownwindReport(t);
541 t->downwindReported = false;
542 } else if(t->lineUpReported) {
543 string trns = t->plane.callsign;
545 double f = globals->get_ATC_mgr()->GetFrequency(ident, ATIS) / 100.0;
548 wtr = ", " + GetWeather();
550 trns += " Cleared for take-off" + wtr;
551 t->clearedToTakeOff = true;
553 if(!OnAnyRunway(SGGeod::fromDegM(user_lon_node->getDoubleValue(), user_lat_node->getDoubleValue(), 0.0), true)) {
554 // TODO: Check if any AI Planes on final and tell something like: "After the landing CALLSIGN line up runway two eight right"
555 trns += " Line up runway " + ConvertRwyNumToSpokenString(activeRwy);
556 t->clearedToTakeOff = false;
557 current_atcdialog->add_entry(ident, "@CS @TO", "Report ready for take-off", TOWER, (int)USER_REQUEST_TAKE_OFF);
561 if((int(sg_random() * 10) + 1) != 3) {
562 t->clearedToTakeOff = true;
563 trns += " Cleared immediate take-off ";
565 t->clearedToTakeOff = false;
566 trns += " Negative, departure runway " + ConvertRwyNumToSpokenString(activeRwy);
571 pending_transmission = trns;
574 //cout << "Not displaying, trns was " << trns << '\n';
576 t->lineUpReported = false;
577 } else if(t->holdShortReported) {
578 //cout << "Tower " << ident << " is reponding to holdShortReported...\n";
580 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!!)
581 // Do nothing for now - consider acknowloging hold short eventually
583 ClearHoldingPlane(t);
584 t->leg = TAKEOFF_ROLL;
585 rwyList.push_back(t);
586 rwyListItr = rwyList.begin();
588 // WARNING - WE ARE ASSUMING ONLY ONE PLANE REPORTING HOLD AT A TIME BELOW
589 // FIXME TODO - FIX THIS!!!
590 if(!holdList.empty()) {
591 if(holdListItr == holdList.end()) {
592 holdListItr = holdList.begin();
594 holdList.erase(holdListItr);
595 holdListItr = holdList.begin();
599 // Tell him to hold and what position he is.
600 // Not currently sure under which circumstances we do or don't bother transmitting this.
601 string trns = t->plane.callsign;
602 trns += " hold position";
604 pending_transmission = trns;
607 // TODO - add some idea of what traffic is blocking him.
609 t->holdShortReported = false;
610 } else if(t->finalReported && !(t->finalAcknowledged)) {
611 //cout << "Tower " << ident << " is responding to finalReported...\n";
613 string trns = t->plane.callsign;
614 //cout << (t->nextOnRwy ? "Next on rwy " : "Not next!! ");
615 //cout << (rwyOccupied ? "RWY OCCUPIED!!\n" : "Rwy not occupied\n");
616 if(t->nextOnRwy && !rwyOccupied && !(t->instructedToGoAround)) {
617 if(t->landingType == FULL_STOP) {
618 trns += " cleared to land ";
620 double f = globals->get_ATC_mgr()->GetFrequency(ident, ATIS) / 100.0;
623 wtr = ", " + GetWeather();
625 wtr = ", runway " + ConvertRwyNumToSpokenString(activeRwy);
627 trns += " cleared to land" + wtr;
630 t->clearedToLand = true;
631 // Maybe remove report downwind from menu here as well incase user didn't bother to?
633 //cout << "ADD VACATED B\n";
634 // Put going around at the top (and hence default) since that'll be more desperate,
635 // or put rwy vacated at the top since that'll be more common?
636 current_atcdialog->add_entry(ident, "@CS Going Around", "Report going around", TOWER, USER_REPORT_GOING_AROUND);
637 current_atcdialog->add_entry(ident, "@CS Clear of the runway", "Report runway vacated", TOWER, USER_REPORT_RWY_VACATED);
639 t->planePtr->RegisterTransmission(7);
641 } else if(t->eta < 20) {
642 // Do nothing - we'll be telling it to go around in less than 10 seconds if the
643 // runway doesn't clear so no point in calling "continue approach".
646 trns += " continue approach";
647 trns += " and report ";
648 trns += ((rwy.patternDirection == 1) ? "right " : "left ");
649 trns += "downwind runway " + ConvertRwyNumToSpokenString(activeRwy);
652 current_atcdialog->add_entry(ident, "@AP Tower, @CS Downwind @RW", "Report Downwind", TOWER, (int)USER_REPORT_DOWNWIND);
654 t->planePtr->RegisterTransmission(15);
656 t->clearedToLand = false;
658 if(_display && disp) {
659 pending_transmission = trns;
662 t->finalAcknowledged = true;
663 } else if(t->rwyVacatedReported && !(t->rwyVacatedAcknowledged)) {
664 ProcessRunwayVacatedReport(t);
665 t->rwyVacatedAcknowledged = true;
668 //freqClear = true; // FIXME - set this to come true after enough time to render the message
669 _releaseCounter = 0.0;
671 _runReleaseCounter = true;
672 //cout << "Done Respond\n" << endl;
675 void FGTower::ProcessDownwindReport(TowerPlaneRec* t) {
677 int a = 0; // Count of preceding planes on approach
678 bool cf = false; // conflicting traffic on final
679 bool cc = false; // preceding traffic in circuit
680 TowerPlaneRec* tc = NULL;
681 for(tower_plane_rec_list_iterator twrItr = circuitList.begin(); twrItr != circuitList.end(); twrItr++) {
682 if((*twrItr)->plane.callsign == responseID) break;
686 if(i > 1) { cc = true; }
687 doThresholdETACalc();
688 TowerPlaneRec* tf = NULL;
689 for(tower_plane_rec_list_iterator twrItr = appList.begin(); twrItr != appList.end(); twrItr++) {
690 if((*twrItr)->eta < (t->eta + 45) && strcmp((*twrItr)->plane.callsign.c_str(), t->plane.callsign.c_str()) != 0) { // don't let ATC ask you to follow yourself
694 // This should set the flagged plane to be the last conflicting one, and hence the one to follow.
695 // It ignores the fact that we might have problems slotting into the approach traffic behind it -
696 // eventually we'll need some fancy algorithms for that!
699 string trns = t->plane.callsign;
701 trns += ConvertNumToSpokenDigits(i + a);
702 // This assumes that the number spoken is landing position, not circuit position, since some of the traffic might be on straight-in final.
704 TowerPlaneRec* tt = NULL;
705 if((i == 1) && rwyList.empty() && (t->nextOnRwy) && (!cf)) { // Unfortunately nextOnRwy currently doesn't handle circuit/straight-in ordering properly at present, hence the cf check below.
706 trns += "Cleared to land"; // TODO - clear for the option if appropriate
707 t->clearedToLand = true;
708 if(!t->isUser) t->planePtr->RegisterTransmission(7);
709 } else if((i+a) > 1) {
710 //First set tt to point to the correct preceding plane - final or circuit
712 tt = (tf->eta < tc->eta ? tf : tc);
718 // We should never get here!
719 SG_LOG(SG_ATC, SG_ALERT, "ALERT - Logic error in FGTower::ProcessDownwindReport");
722 trns += "Follow the ";
723 string s = tt->plane.callsign;
727 if((tt->opType) == CIRCUIT) {
732 leg = tt->planePtr->GetLeg();
736 } else if(leg == TURN4) {
737 trns += " turning final";
738 } else if(leg == BASE) {
740 } else if(leg == TURN3) {
741 trns += " turning base";
744 double miles_out = CalcDistOutMiles(tt);
746 trns += " on short final";
749 trns += ConvertNumToSpokenDigits((int)miles_out);
750 trns += " mile final";
755 pending_transmission = trns;
759 if(t->opType == TTT_UNKNOWN) t->opType = CIRCUIT;
760 //cout << "ADD VACATED A\n";
761 // Put going around at the top (and hence default) since that'll be more desperate,
762 // or put rwy vacated at the top since that'll be more common?
763 //cout << "ident = " << ident << ", adding go-around option\n";
764 current_atcdialog->add_entry(ident, "@CS Going Around", "Report going around", TOWER, USER_REPORT_GOING_AROUND);
765 current_atcdialog->add_entry(ident, "@CS Clear of the runway", "Report runway vacated", TOWER, USER_REPORT_RWY_VACATED);
769 void FGTower::ProcessRunwayVacatedReport(TowerPlaneRec* t) {
770 //cout << "Processing rwy vacated...\n";
771 if(t->isUser) current_atcdialog->remove_entry(ident, USER_REPORT_GOING_AROUND, TOWER);
772 string trns = t->plane.callsign;
774 trns += " Contact ground on ";
775 double f = globals->get_ATC_mgr()->GetFrequency(ident, GROUND) / 100.0;
777 sprintf(buf, "%.2f", f);
780 if(!t->isUser) t->planePtr->RegisterTransmission(5);
783 trns += " cleared for taxi to general aviation parking";
784 if(!t->isUser) t->planePtr->RegisterTransmission(6); // TODO - this is a mega-hack!!
786 //cout << "trns = " << trns << '\n';
788 pending_transmission = trns;
791 RemoveFromRwyList(t->plane.callsign);
793 // Maybe we should check that the plane really *has* vacated the runway!
796 // *********** END RESPONSE FUNCTIONS *****************
798 // Currently this assumes we *are* next on the runway and doesn't check for planes about to land -
799 // this should be done prior to calling this function.
800 void FGTower::ClearHoldingPlane(TowerPlaneRec* t) {
801 //cout << "Entering ClearHoldingPlane..." << endl;
803 string trns = t->plane.callsign;
804 //if(departed plane < some threshold in time away) {
806 //if(timeSinceLastDeparture <= 60.0 && departed == true) {
807 trns += " line up runway " + ConvertRwyNumToSpokenString(activeRwy);
808 t->clearedToLineUp = true;
809 t->planePtr->RegisterTransmission(3); // cleared to line-up
810 //} else if(arriving plane < some threshold away) {
811 } else if(GetTrafficETA(2) < 150.0 && (timeSinceLastDeparture > 60.0 || departed == false)) { // Hack - hardwired time
812 trns += " cleared immediate take-off";
813 if(trafficList.size()) {
814 tower_plane_rec_list_iterator trfcItr = trafficList.begin();
815 trfcItr++; // At the moment the holding plane should be first in trafficList.
816 // Note though that this will break if holding planes aren't put in trafficList in the future.
817 TowerPlaneRec* trfc = *trfcItr;
818 trns += "... traffic is";
819 switch(trfc->plane.type) {
823 trns += " a Cessna"; // TODO - add ability to specify actual plane type somewhere
829 trns += " a King-air";
832 trns += " a Learjet";
835 trns += " a Regional";
844 //if(trfc->opType == STRAIGHT_IN || trfc->opType == TTT_UNKNOWN) {
845 if(trfc->opType == STRAIGHT_IN) {
846 double miles_out = CalcDistOutMiles(trfc);
851 trns += ConvertNumToSpokenDigits((int)miles_out);
852 trns += " mile final";
854 } else if(trfc->opType == CIRCUIT) {
855 //cout << "Getting leg of " << trfc->plane.callsign << '\n';
861 trns += " turning final";
867 trns += " turning base";
870 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.
872 // And to eliminate compiler warnings...
873 case TAKEOFF_ROLL: break;
874 case CLIMBOUT: break;
876 case CROSSWIND: break;
878 case LANDING_ROLL: break;
879 case LEG_UNKNOWN: break;
883 // By definition there should be some arriving traffic if we're cleared for immediate takeoff
884 SG_LOG(SG_ATC, SG_WARN, "Warning: Departing traffic cleared for *immediate* take-off despite no arriving traffic in FGTower");
886 t->clearedToTakeOff = true;
887 t->planePtr->RegisterTransmission(4); // cleared to take-off - TODO differentiate between immediate and normal take-off
889 timeSinceLastDeparture = 0.0;
891 //} else if(timeSinceLastDeparture > 60.0 || departed == false) { // Hack - test for timeSinceLastDeparture should be in lineup block eventually
892 trns += " cleared for take-off";
893 // TODO - add traffic is... ?
894 t->clearedToTakeOff = true;
895 t->planePtr->RegisterTransmission(4); // cleared to take-off
897 timeSinceLastDeparture = 0.0;
900 pending_transmission = trns;
903 //cout << "Done ClearHoldingPlane " << endl;
907 // ***************************************************************************************
908 // ********** Functions to periodically check what the various traffic is doing **********
910 // Do one plane from the hold list
911 void FGTower::CheckHoldList(double dt) {
912 //cout << "Entering CheckHoldList..." << endl;
913 if(!holdList.empty()) {
914 //cout << "*holdListItr = " << *holdListItr << endl;
915 if(holdListItr == holdList.end()) {
916 holdListItr = holdList.begin();
918 //cout << "*holdListItr = " << *holdListItr << endl;
919 //Process(*holdListItr);
920 TowerPlaneRec* t = *holdListItr;
921 //cout << "t = " << t << endl;
922 if(t->holdShortReported) {
923 // NO-OP - leave it to the response handler.
924 } else { // not responding to report, but still need to clear if clear
926 //cout << "departed = " << departed << '\n';
927 //cout << "timeSinceLastDeparture = " << timeSinceLastDeparture << '\n';
929 RemoveAllUserDialogOptions();
930 current_atcdialog->add_entry(ident, "@CS Ready for take-off", "Request take-off clearance", TOWER, (int)USER_REQUEST_TAKE_OFF);
931 } else if(timeSinceLastDeparture <= 60.0 && departed == true) {
932 // Do nothing - this is a bit of a hack - should maybe do line up be ready here
934 ClearHoldingPlane(t);
935 t->leg = TAKEOFF_ROLL;
936 rwyList.push_back(t);
937 rwyListItr = rwyList.begin();
939 holdList.erase(holdListItr);
940 holdListItr = holdList.begin();
941 if (holdList.empty())
945 // TODO - rationalise the considerable code duplication above!
949 //cout << "Done CheckHoldList" << endl;
952 // do the ciruit list
953 void FGTower::CheckCircuitList(double dt) {
954 //cout << "Entering CheckCircuitList..." << endl;
955 // Clear the constraints - we recalculate here.
957 downwind_leg_pos = 0.0;
958 crosswind_leg_pos = 0.0;
960 if(!circuitList.empty()) { // Do one plane from the circuit
961 if(circuitListItr == circuitList.end()) {
962 circuitListItr = circuitList.begin();
964 TowerPlaneRec* t = *circuitListItr;
965 //cout << ident << ' ' << circuitList.size() << ' ' << t->plane.callsign << " " << t->leg << " eta " << t->eta << '\n';
967 t->pos.setLongitudeDeg(user_lon_node->getDoubleValue());
968 t->pos.setLatitudeDeg(user_lat_node->getDoubleValue());
969 t->pos.setElevationM(user_elev_node->getDoubleValue());
970 //cout << ident << ' ' << circuitList.size() << ' ' << t->plane.callsign << " " << t->leg << " eta " << t->eta << '\n';
972 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.
973 t->landingType = t->planePtr->GetLandingOption();
974 //cout << "AI plane landing option is " << t->landingType << '\n';
976 SGVec3d tortho = ortho.ConvertToLocal(t->pos);
978 // Need to figure out which leg he's on
979 //cout << "rwy.hdg = " << rwy.hdg << " user hdg = " << user_hdg_node->getDoubleValue();
980 double ho = GetAngleDiff_deg(user_hdg_node->getDoubleValue(), rwy.hdg);
981 //cout << " ho = " << ho << " abs(ho = " << abs(ho) << '\n';
982 // TODO FIXME - get the wind and convert this to track, or otherwise use track somehow!!!
983 // If it's gusty might need to filter the value, although we are leaving 30 degrees each way leeway!
985 // could be either takeoff, climbout or landing - check orthopos.y
986 //cout << "tortho.y = " << tortho.y() << '\n';
987 if((tortho.y() < 0) || (t->leg == TURN4) || (t->leg == FINAL)) {
991 t->leg = CLIMBOUT; // TODO - check elev wrt. apt elev to differentiate takeoff roll and climbout
992 //cout << "Climbout\n";
993 // If it's the user we may be unsure of his/her intentions.
994 // (Hopefully the AI planes won't try confusing the sim!!!)
995 //cout << "tortho.y = " << tortho.y() << '\n';
996 if(t->opType == TTT_UNKNOWN) {
997 if(tortho.y() > 5000) {
998 // 5 km out from threshold - assume it's a departure
999 t->opType = OUTBOUND; // TODO - could check if the user has climbed significantly above circuit altitude as well.
1000 // Since we are unknown operation we should be in depList already.
1001 //cout << ident << " Removing user from circuitList (TTT_UNKNOWN)\n";
1002 circuitListItr = circuitList.erase(circuitListItr);
1003 RemoveFromTrafficList(t->plane.callsign);
1004 if (circuitList.empty())
1007 } else if(t->opType == CIRCUIT) {
1008 if(tortho.y() > 10000) {
1009 // 10 km out - assume the user has abandoned the circuit!!
1010 t->opType = OUTBOUND;
1011 depList.push_back(t);
1012 depListItr = depList.begin();
1013 //cout << ident << " removing user from circuitList (CIRCUIT)\n";
1014 circuitListItr = circuitList.erase(circuitListItr);
1015 if (circuitList.empty())
1020 } else if(fabs(ho) < 60) {
1022 // TODO - either fix or doublecheck this hack by looking at heading and pattern direction
1023 if((t->leg == CLIMBOUT) || (t->leg == TURN1)) {
1025 //cout << "Turn1\n";
1028 //cout << "Turn4\n";
1030 } else if(fabs(ho) < 120) {
1031 // crosswind or base
1032 // TODO - either fix or doublecheck this hack by looking at heading and pattern direction
1033 if((t->leg == TURN1) || (t->leg == CROSSWIND)) {
1035 //cout << "Crosswind\n";
1040 } else if(fabs(ho) < 150) {
1042 // TODO - either fix or doublecheck this hack by looking at heading and pattern direction
1043 if((t->leg == CROSSWIND) || (t->leg == TURN2)) {
1045 //cout << "Turn2\n";
1048 // Probably safe now to assume the user is flying a circuit
1049 t->opType = CIRCUIT;
1050 //cout << "Turn3\n";
1055 //cout << "Downwind\n";
1057 if(t->leg == FINAL) {
1058 if(OnActiveRunway(t->pos)) {
1059 t->leg = LANDING_ROLL;
1063 t->leg = t->planePtr->GetLeg();
1066 // Set the constraints IF this is the first plane in the circuit
1067 // 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!!
1068 if(circuitListItr == circuitList.begin()) {
1071 // 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.
1072 base_leg_pos = tortho.y();
1073 //cout << "base_leg_pos = " << base_leg_pos << '\n';
1076 // Fall through to base
1078 base_leg_pos = tortho.y();
1079 //cout << "base_leg_pos = " << base_leg_pos << '\n';
1082 // Fall through to downwind
1084 // Only have the downwind leg pos as turn-to-base constraint if more negative than we already have.
1085 base_leg_pos = (tortho.y() < base_leg_pos ? tortho.y() : base_leg_pos);
1086 //cout << "base_leg_pos = " << base_leg_pos;
1087 downwind_leg_pos = tortho.x(); // Assume that a following plane can simply be constrained by the immediately in front downwind plane
1088 //cout << " downwind_leg_pos = " << downwind_leg_pos << '\n';
1091 // Fall through to crosswind
1093 crosswind_leg_pos = tortho.y();
1094 //cout << "crosswind_leg_pos = " << crosswind_leg_pos << '\n';
1095 t->instructedToGoAround = false;
1098 // Fall through to climbout
1100 // Only use current by constraint as largest
1101 crosswind_leg_pos = (tortho.y() > crosswind_leg_pos ? tortho.y() : crosswind_leg_pos);
1102 //cout << "crosswind_leg_pos = " << crosswind_leg_pos << '\n';
1115 if(t->leg == FINAL && !(t->instructedToGoAround)) {
1116 doThresholdETACalc();
1117 doThresholdUseOrder();
1120 cout << "Checking USER on final... ";
1121 cout << "eta " << t->eta;
1122 if(t->clearedToLand) cout << " cleared to land\n";
1125 //cout << "YES FINAL, t->eta = " << t->eta << ", rwyList.size() = " << rwyList.size() << '\n';
1126 if(t->landingType == FULL_STOP) {
1127 t->opType = INBOUND;
1128 //cout << "\n******** SWITCHING TO INBOUND AT POINT AAA *********\n\n";
1130 if(t->eta < 12 && rwyList.size()) {
1131 // TODO - need to make this more sophisticated
1132 // eg. is the plane accelerating down the runway taking off [OK],
1133 // or stationary near the start [V. BAD!!].
1134 // For now this should stop the AI plane landing on top of the user.
1135 tower_plane_rec_list_iterator twrItr;
1136 twrItr = rwyList.begin();
1137 TowerPlaneRec* tpr = *twrItr;
1138 if(strcmp(tpr->plane.callsign.c_str(), t->plane.callsign.c_str()) == 0
1139 && rwyList.size() == 1) {
1140 // Fixing bug when ATC says that we must go around because of traffic on rwy
1141 // but that traffic is our plane! In future we can use this expression
1142 // for other ATC-messages like "On ground at 46, vacate left."
1145 string trns = t->plane.callsign;
1146 trns += " GO AROUND TRAFFIC ON RUNWAY I REPEAT GO AROUND";
1147 pending_transmission = trns;
1148 ImmediateTransmit();
1149 t->instructedToGoAround = true;
1150 t->clearedToLand = false;
1151 // Assume it complies!!!
1152 t->opType = CIRCUIT;
1155 //cout << "Registering Go-around transmission with AI plane\n";
1156 t->planePtr->RegisterTransmission(13);
1159 } else if(!t->clearedToLand) {
1160 // The whip through the appList is a hack since currently t->nextOnRwy doesn't always work
1163 for(tower_plane_rec_list_iterator twrItr = appList.begin(); twrItr != appList.end(); twrItr++) {
1164 if((*twrItr)->eta < t->eta) {
1168 if(t->nextOnRwy && !cf) {
1169 if(!rwyList.size()) {
1170 string trns = t->plane.callsign;
1171 trns += " Cleared to land";
1172 pending_transmission = trns;
1174 //if(t->isUser) cout << "Transmitting cleared to Land!!!\n";
1175 t->clearedToLand = true;
1177 t->planePtr->RegisterTransmission(7);
1181 //if(t->isUser) cout << "Not next\n";
1184 } else if(t->leg == LANDING_ROLL) {
1185 //cout << t->plane.callsign << " has landed - adding to rwyList\n";
1186 rwyList.push_front(t);
1187 // TODO - if(!clearedToLand) shout something!!
1188 t->clearedToLand = false;
1189 RemoveFromTrafficList(t->plane.callsign);
1191 t->opType = TTT_UNKNOWN;
1192 } // TODO - allow the user to specify opType via ATC menu
1193 //cout << ident << " Removing " << t->plane.callsign << " from circuitList..." << endl;
1194 circuitListItr = circuitList.erase(circuitListItr);
1195 if(circuitListItr == circuitList.end() ) {
1196 circuitListItr = circuitList.begin();
1197 // avoid increment of circuitListItr (would increment to second element, or crash if no element left)
1203 //cout << "Done CheckCircuitList" << endl;
1206 // 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!!
1207 // FIXME - at the moment it looks like we're only doing the first plane from the rwy list.
1208 // (However, at the moment there should only be one airplane on the rwy at once, until we
1209 // start allowing planes to line up whilst previous arrival clears the rwy.)
1210 void FGTower::CheckRunwayList(double dt) {
1211 //cout << "Entering CheckRunwayList..." << endl;
1213 if(!rwyList.size()) {
1214 rwyOccupied = false;
1216 rwyListItr = rwyList.begin();
1217 TowerPlaneRec* t = *rwyListItr;
1219 t->pos.setLongitudeDeg(user_lon_node->getDoubleValue());
1220 t->pos.setLatitudeDeg(user_lat_node->getDoubleValue());
1221 t->pos.setElevationM(user_elev_node->getDoubleValue());
1223 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.
1225 bool on_rwy = OnActiveRunway(t->pos);
1227 // TODO - for all of these we need to check what the user is *actually* doing!
1228 if((t->opType == INBOUND) || (t->opType == STRAIGHT_IN)) {
1229 //cout << "Tower " << ident << " is removing plane " << t->plane.callsign << " from rwy list (vacated)\n";
1230 //cout << "Size of rwylist was " << rwyList.size() << '\n';
1231 //cout << "Size of vacatedList was " << vacatedList.size() << '\n';
1232 RemoveFromRwyList(t->plane.callsign);
1233 AddToVacatedList(t);
1234 //cout << "Size of rwylist is " << rwyList.size() << '\n';
1235 //cout << "Size of vacatedList is " << vacatedList.size() << '\n';
1236 // At the moment we wait until Runway Vacated is reported by the plane before telling to contact ground etc.
1237 // It's possible we could be a bit more proactive about this.
1238 } else if(t->opType == OUTBOUND) {
1239 depList.push_back(t);
1240 depListItr = depList.begin();
1241 rwyList.pop_front();
1243 timeSinceLastDeparture = 0.0;
1244 } else if(t->opType == CIRCUIT) {
1245 //cout << ident << " adding " << t->plane.callsign << " to circuitList" << endl;
1246 circuitList.push_back(t);
1247 circuitListItr = circuitList.begin();
1248 AddToTrafficList(t);
1249 rwyList.pop_front();
1251 timeSinceLastDeparture = 0.0;
1252 } else if(t->opType == TTT_UNKNOWN) {
1253 depList.push_back(t);
1254 depListItr = depList.begin();
1255 //cout << ident << " adding " << t->plane.callsign << " to circuitList" << endl;
1256 circuitList.push_back(t);
1257 circuitListItr = circuitList.begin();
1258 AddToTrafficList(t);
1259 rwyList.pop_front();
1261 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.
1263 // HELP - we shouldn't ever get here!!!
1268 //cout << "Done CheckRunwayList" << endl;
1271 // Do one plane from the approach list
1272 void FGTower::CheckApproachList(double dt) {
1273 //cout << "CheckApproachList called for " << ident << endl;
1274 //cout << "AppList.size is " << appList.size() << endl;
1275 if(!appList.empty()) {
1276 if(appListItr == appList.end()) {
1277 appListItr = appList.begin();
1279 TowerPlaneRec* t = *appListItr;
1280 //cout << "t = " << t << endl;
1281 //cout << "Checking " << t->plane.callsign << endl;
1283 t->pos.setLongitudeDeg(user_lon_node->getDoubleValue());
1284 t->pos.setLatitudeDeg(user_lat_node->getDoubleValue());
1285 t->pos.setElevationM(user_elev_node->getDoubleValue());
1287 // TODO - set/update the position if it's an AI plane
1289 doThresholdETACalc(); // We need this here because planes in the lists are not guaranteed to *always* have the correct ETA
1290 //cout << "eta is " << t->eta << ", rwy is " << (rwyList.size() ? "occupied " : "clear ") << '\n';
1291 SGVec3d tortho = ortho.ConvertToLocal(t->pos);
1292 if(t->eta < 12 && rwyList.size() && !(t->instructedToGoAround)) {
1293 // TODO - need to make this more sophisticated
1294 // eg. is the plane accelerating down the runway taking off [OK],
1295 // or stationary near the start [V. BAD!!].
1296 // For now this should stop the AI plane landing on top of the user.
1297 tower_plane_rec_list_iterator twrItr;
1298 twrItr = rwyList.begin();
1299 TowerPlaneRec* tpr = *twrItr;
1300 if(strcmp ( tpr->plane.callsign.c_str(), t->plane.callsign.c_str() ) == 0 && rwyList.size() == 1) {
1301 // Fixing bug when ATC says that we must go around because of traffic on rwy
1302 // but that traffic is we! In future we can use this expression
1303 // for other ATC-messages like "On ground at 46, vacate left."
1306 string trns = t->plane.callsign;
1307 trns += " GO AROUND TRAFFIC ON RUNWAY I REPEAT GO AROUND";
1308 pending_transmission = trns;
1309 ImmediateTransmit();
1310 t->instructedToGoAround = true;
1311 t->clearedToLand = false;
1312 t->nextOnRwy = false; // But note this is recalculated so don't rely on it
1313 // Assume it complies!!!
1314 t->opType = CIRCUIT;
1318 //cout << "Registering Go-around transmission with AI plane\n";
1319 t->planePtr->RegisterTransmission(13);
1322 // TODO - add Go-around ack to comm options,
1323 // remove report rwy vacated. (possibly).
1326 } else if(t->isUser && t->eta < 90 && tortho.y() > -2500 && t->clearedToLand && t->gearUpReported == false) {
1327 // Check if gear up or down
1328 double gp = fgGetFloat("/gear/gear/position-norm");
1330 string trnsm = t->plane.callsign;
1332 int rnd = int(sg_random() * 2) + 1;
1333 if(rnd == 2) { // Random message for more realistic ATC ;)
1334 trnsm += ", LANDING GEAR APPEARS UP!";
1336 trnsm += ", Check wheels down and locked.";
1338 pending_transmission = trnsm;
1339 ImmediateTransmit();
1340 t->gearUpReported = true;
1342 } else if(t->eta < 90 && !t->clearedToLand) {
1343 //doThresholdETACalc();
1344 doThresholdUseOrder();
1345 // The whip through the appList is a hack since currently t->nextOnRwy doesn't always work
1348 for(tower_plane_rec_list_iterator twrItr = appList.begin(); twrItr != appList.end(); twrItr++) {
1349 if((*twrItr)->eta < t->eta) {
1353 if(t->nextOnRwy && !cf) {
1354 if(!rwyList.size()) {
1355 string trns = t->plane.callsign;
1356 trns += " Cleared to land";
1357 pending_transmission = trns;
1359 //if(t->isUser) cout << "Transmitting cleared to Land!!!\n";
1360 t->clearedToLand = true;
1362 t->planePtr->RegisterTransmission(7);
1366 //if(t->isUser) cout << "Not next\n";
1370 // Check for landing...
1371 bool landed = false;
1374 if(t->planePtr->GetLeg() == LANDING_ROLL) {
1378 SG_LOG(SG_ATC, SG_ALERT, "WARNING - not user and null planePtr in CheckApproachList!");
1381 if(OnActiveRunway(t->pos)) {
1387 // Duplicated in CheckCircuitList - must be able to rationalise this somehow!
1388 //cout << "A " << t->plane.callsign << " has landed, adding to rwyList...\n";
1389 rwyList.push_front(t);
1390 // TODO - if(!clearedToLand) shout something!!
1391 t->clearedToLand = false;
1392 RemoveFromTrafficList(t->plane.callsign);
1394 // t->opType = TTT_UNKNOWN;
1395 //} // TODO - allow the user to specify opType via ATC menu
1396 appListItr = appList.erase(appListItr);
1397 if(appListItr == appList.end() ) {
1398 appListItr = appList.begin();
1400 if (appList.empty())
1407 //cout << "Done" << endl;
1410 // Do one plane from the departure list
1411 void FGTower::CheckDepartureList(double dt) {
1412 if(!depList.empty()) {
1413 if(depListItr == depList.end()) {
1414 depListItr = depList.begin();
1416 TowerPlaneRec* t = *depListItr;
1417 //cout << "Dep list, checking " << t->plane.callsign;
1419 double distout; // meters
1420 if(t->isUser) distout = dclGetHorizontalSeparation(_geod,
1421 SGGeod::fromDegM(user_lon_node->getDoubleValue(), user_lat_node->getDoubleValue(), user_elev_node->getDoubleValue()));
1422 else distout = dclGetHorizontalSeparation(_geod, t->planePtr->getPos());
1423 //cout << " distout = " << distout << '\n';
1424 if(t->isUser && !(t->clearedToTakeOff)) { // HACK - we use clearedToTakeOff to check if ATC already contacted with plane (and cleared take-off) or not
1425 if(!OnAnyRunway(SGGeod::fromDegM(user_lon_node->getDoubleValue(), user_lat_node->getDoubleValue(), 0.0), false)) {
1426 current_atcdialog->remove_entry(ident, USER_REQUEST_TAKE_OFF, TOWER);
1427 t->clearedToTakeOff = true; // FIXME
1430 if(distout > 10000) {
1431 string trns = t->plane.callsign;
1432 trns += " You are now clear of my airspace, good day";
1433 pending_transmission = trns;
1436 // Change the communication options
1437 RemoveAllUserDialogOptions();
1438 //cout << "ADD A\n";
1439 current_atcdialog->add_entry(ident, "@AP Tower, @CS @MI miles @CD of the airport for full stop@AT", "Contact tower for VFR arrival (full stop)", TOWER, (int)USER_REQUEST_VFR_ARRIVAL_FULL_STOP);
1441 // Send a clear-of-airspace signal
1442 // TODO - implement this once we actually have departing AI traffic (currently all circuits or arrivals).
1444 RemovePlane(t->plane.callsign);
1451 // ********** End periodic check functions ***********************************************
1452 // ***************************************************************************************
1455 // Remove all dialog options for this tower.
1456 void FGTower::RemoveAllUserDialogOptions() {
1457 current_atcdialog->remove_entry(ident, USER_REQUEST_VFR_DEPARTURE, TOWER);
1458 current_atcdialog->remove_entry(ident, USER_REQUEST_VFR_ARRIVAL, TOWER);
1459 current_atcdialog->remove_entry(ident, USER_REQUEST_VFR_ARRIVAL_FULL_STOP, TOWER);
1460 current_atcdialog->remove_entry(ident, USER_REQUEST_VFR_ARRIVAL_TOUCH_AND_GO, TOWER);
1461 current_atcdialog->remove_entry(ident, USER_REPORT_3_MILE_FINAL, TOWER);
1462 current_atcdialog->remove_entry(ident, USER_REPORT_DOWNWIND, TOWER);
1463 current_atcdialog->remove_entry(ident, USER_REPORT_RWY_VACATED, TOWER);
1464 current_atcdialog->remove_entry(ident, USER_REPORT_GOING_AROUND, TOWER);
1465 current_atcdialog->remove_entry(ident, USER_REQUEST_TAKE_OFF, TOWER);
1468 // Returns true if positions of crosswind/downwind/base leg turns should be constrained by previous traffic
1469 // plus the constraint position as a rwy orientated orthopos (meters)
1470 bool FGTower::GetCrosswindConstraint(double& cpos) {
1471 if(crosswind_leg_pos != 0.0) {
1472 cpos = crosswind_leg_pos;
1479 bool FGTower::GetDownwindConstraint(double& dpos) {
1480 if(fabs(downwind_leg_pos) > nominal_downwind_leg_pos) {
1481 dpos = downwind_leg_pos;
1488 bool FGTower::GetBaseConstraint(double& bpos) {
1489 if(base_leg_pos < nominal_base_leg_pos) {
1490 bpos = base_leg_pos;
1493 bpos = nominal_base_leg_pos;
1499 // Figure out which runways are active.
1500 // For now we'll just be simple and do one active runway - eventually this will get much more complex
1501 // This is a private function - public interface to the results of this is through GetActiveRunway
1502 void FGTower::DoRwyDetails() {
1503 //cout << "GetRwyDetails called" << endl;
1505 // Based on the airport-id and wind get the active runway
1507 const FGAirport* apt = fgFindAirportID(ident);
1509 SG_LOG(SG_ATC, SG_WARN, "FGTower::DoRwyDetails: unknown ICAO:" << ident);
1513 FGRunway* runway = apt->getActiveRunwayForUsage();
1515 activeRwy = runway->ident();
1516 rwy.rwyID = runway->ident();
1517 SG_LOG(SG_ATC, SG_INFO, "In FGGround, active runway for airport " << ident << " is " << activeRwy);
1519 // Get the threshold position
1520 double other_way = runway->headingDeg() - 180.0;
1521 while(other_way <= 0.0) {
1524 // move to the +l end/center of the runway
1525 //cout << "Runway center is at " << runway._lon << ", " << runway._lat << '\n';
1526 double tshlon = 0.0, tshlat = 0.0, tshr = 0.0;
1527 double tolon = 0.0, tolat = 0.0, tor = 0.0;
1528 rwy.length = runway->lengthM();
1529 geo_direct_wgs_84 ( aptElev, runway->latitude(), runway->longitude(), other_way,
1530 rwy.length / 2.0 - 25.0, &tshlat, &tshlon, &tshr );
1531 geo_direct_wgs_84 ( aptElev, runway->latitude(), runway->longitude(), runway->headingDeg(),
1532 rwy.length / 2.0 - 25.0, &tolat, &tolon, &tor );
1534 // Note - 25 meters in from the runway end is a bit of a hack to put the plane ahead of the user.
1535 // now copy what we need out of runway into rwy
1536 rwy.threshold_pos = SGGeod::fromDegM(tshlon, tshlat, aptElev);
1537 SGGeod takeoff_end = SGGeod::fromDegM(tolon, tolat, aptElev);
1538 //cout << "Threshold position = " << tshlon << ", " << tshlat << ", " << aptElev << '\n';
1539 //cout << "Takeoff position = " << tolon << ", " << tolat << ", " << aptElev << '\n';
1540 rwy.hdg = runway->headingDeg();
1541 // Set the projection for the local area based on this active runway
1542 ortho.Init(rwy.threshold_pos, rwy.hdg);
1543 rwy.end1ortho = ortho.ConvertToLocal(rwy.threshold_pos); // should come out as zero
1544 rwy.end2ortho = ortho.ConvertToLocal(takeoff_end);
1546 // Set the pattern direction
1547 // TODO - we'll check for a facilities file with this in eventually - for now assume left traffic except
1548 // for certain circumstances (RH parallel rwy).
1549 rwy.patternDirection = -1; // Left
1550 if(rwy.rwyID.size() == 3) {
1551 rwy.patternDirection = (rwy.rwyID.substr(2,1) == "R" ? 1 : -1);
1553 //cout << "Doing details, rwy.patterDirection is " << rwy.patternDirection << '\n';
1557 // Figure out if a given position lies on the active runway
1558 // Might have to change when we consider more than one active rwy.
1559 bool FGTower::OnActiveRunway(const SGGeod& pt) {
1560 // TODO - check that the centre calculation below isn't confused by displaced thesholds etc.
1561 SGVec3d xyc((rwy.end1ortho.x() + rwy.end2ortho.x())/2.0, (rwy.end1ortho.y() + rwy.end2ortho.y())/2.0, 0.0);
1562 SGVec3d xyp = ortho.ConvertToLocal(pt);
1564 //cout << "Length offset = " << fabs(xyp.y() - xyc.y()) << '\n';
1565 //cout << "Width offset = " << fabs(xyp.x() - xyc.x()) << '\n';
1567 double rlen = rwy.length/2.0 + 5.0;
1568 double rwidth = rwy.width/2.0;
1569 double ldiff = fabs(xyp.y() - xyc.y());
1570 double wdiff = fabs(xyp.x() - xyc.x());
1572 return((ldiff < rlen) && (wdiff < rwidth));
1575 // Figure out if a given position lies on any runway or not
1576 // Only call this at startup - reading the runways database is expensive and needs to be fixed!
1577 bool FGTower::OnAnyRunway(const SGGeod& pt, bool onGround) {
1579 double dist = current_commlist->FindClosest(_geod, ad, TOWER, 7.0);
1584 // Based on the airport-id, go through all the runways and check for a point in them
1586 const FGAirport* apt = fgFindAirportID(ad.ident);
1589 for (unsigned int i=0; i<apt->numRunways(); ++i) {
1590 if (OnRunway(pt, apt->getRunwayByIndex(i))) {
1595 // if onGround is true, we only match real runways, so we're done
1596 if (onGround) return false;
1598 // try taxiways as well
1599 for (unsigned int i=0; i<apt->numTaxiways(); ++i) {
1600 if (OnRunway(pt, apt->getTaxiwayByIndex(i))) {
1609 // Returns true if successful
1610 bool FGTower::RemoveFromTrafficList(const string& id) {
1611 tower_plane_rec_list_iterator twrItr;
1612 for(twrItr = trafficList.begin(); twrItr != trafficList.end(); twrItr++) {
1613 TowerPlaneRec* tpr = *twrItr;
1614 if(tpr->plane.callsign == id) {
1615 trafficList.erase(twrItr);
1616 trafficListItr = trafficList.begin();
1620 SG_LOG(SG_ATC, SG_WARN, "Warning - unable to remove aircraft " << id << " from trafficList in FGTower");
1625 // Returns true if successful
1626 bool FGTower::RemoveFromAppList(const string& id) {
1627 tower_plane_rec_list_iterator twrItr;
1628 for(twrItr = appList.begin(); twrItr != appList.end(); twrItr++) {
1629 TowerPlaneRec* tpr = *twrItr;
1630 if(tpr->plane.callsign == id) {
1631 appList.erase(twrItr);
1632 appListItr = appList.begin();
1636 //SG_LOG(SG_ATC, SG_WARN, "Warning - unable to remove aircraft " << id << " from appList in FGTower");
1640 // Returns true if successful
1641 bool FGTower::RemoveFromRwyList(const string& id) {
1642 tower_plane_rec_list_iterator twrItr;
1643 for(twrItr = rwyList.begin(); twrItr != rwyList.end(); twrItr++) {
1644 TowerPlaneRec* tpr = *twrItr;
1645 if(tpr->plane.callsign == id) {
1646 rwyList.erase(twrItr);
1647 rwyListItr = rwyList.begin();
1651 //SG_LOG(SG_ATC, SG_WARN, "Warning - unable to remove aircraft " << id << " from rwyList in FGTower");
1656 // Add a tower plane rec with ETA to the traffic list in the correct position ETA-wise
1657 // and set nextOnRwy if so.
1658 // Returns true if this could cause a threshold ETA conflict with other traffic, false otherwise.
1659 // For planes holding they are put in the first position with time to go, and the return value is
1660 // true if in the first position (nextOnRwy) and false otherwise.
1661 // See the comments in FGTower::doThresholdUseOrder for notes on the ordering
1662 bool FGTower::AddToTrafficList(TowerPlaneRec* t, bool holding) {
1663 //cout << "ADD: " << trafficList.size();
1664 //cout << "AddToTrafficList called, currently size = " << trafficList.size() << ", holding = " << holding << endl;
1665 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.
1666 double departure_sep_time = 60.0; // Separation time behind departing airplanes. Comments above also apply.
1667 bool conflict = false;
1668 double lastETA = 0.0;
1669 bool firstTime = true;
1670 // FIXME - make this more robust for different plane types eg. light following heavy.
1671 tower_plane_rec_list_iterator twrItr;
1672 //twrItr = trafficList.begin();
1674 for(twrItr = trafficList.begin(); twrItr != trafficList.end(); twrItr++) {
1675 //if(twrItr == trafficList.end()) {
1677 // trafficList.push_back(t);
1678 // return(holding ? firstTime : conflict);
1680 TowerPlaneRec* tpr = *twrItr;
1682 //cout << (tpr->isUser ? "USER!\n" : "NOT user\n");
1683 //cout << "tpr->eta - lastETA = " << tpr->eta - lastETA << '\n';
1684 double dep_allowance = (timeSinceLastDeparture < departure_sep_time ? departure_sep_time - timeSinceLastDeparture : 0.0);
1685 double slot_time = (firstTime ? separation_time + dep_allowance : separation_time + departure_sep_time);
1686 // separation_time + departure_sep_time in the above accounts for the fact that the arrival could be touch and go,
1687 // and if not needs time to clear the rwy anyway.
1688 if(tpr->eta - lastETA > slot_time) {
1689 t->nextOnRwy = firstTime;
1690 trafficList.insert(twrItr, t);
1691 //cout << "\tH\t" << trafficList.size() << '\n';
1696 if(t->eta < tpr->eta) {
1697 // Ugg - this one's tricky.
1698 // It depends on what the two planes are doing and whether there's a conflict what we do.
1699 if(tpr->eta - t->eta > separation_time) { // No probs, plane 2 can squeeze in before plane 1 with no apparent conflict
1700 if(tpr->nextOnRwy) {
1701 tpr->nextOnRwy = false;
1702 t->nextOnRwy = true;
1704 trafficList.insert(twrItr, t);
1705 } else { // Ooops - this ones tricky - we have a potential conflict!
1707 // HACK - just add anyway for now and flag conflict - TODO - FIX THIS using CIRCUIT/STRAIGHT_IN and VFR/IFR precedence rules.
1708 if(tpr->nextOnRwy) {
1709 tpr->nextOnRwy = false;
1710 t->nextOnRwy = true;
1712 trafficList.insert(twrItr, t);
1714 //cout << "\tC\t" << trafficList.size() << '\n';
1721 // If we get here we must be at the end of the list, or maybe the list is empty.
1722 if(!trafficList.size()) {
1723 t->nextOnRwy = true;
1724 // conflict and firstTime should be false and true respectively in this case anyway.
1726 t->nextOnRwy = false;
1728 trafficList.push_back(t);
1729 //cout << "\tE\t" << trafficList.size() << endl;
1730 return(holding ? firstTime : conflict);
1733 // Add a tower plane rec with ETA to the circuit list in the correct position ETA-wise
1734 // Returns true if this might cause a separation conflict (based on ETA) with other traffic, false otherwise.
1735 // Safe to add a plane that is already in - planes with the same callsign are not added.
1736 bool FGTower::AddToCircuitList(TowerPlaneRec* t) {
1738 //cout << "**********************************************\n";
1739 //cout << "AddToCircuitList called with NULL pointer!!!!!\n";
1740 //cout << "**********************************************\n";
1743 //cout << "ADD: " << circuitList.size();
1744 //cout << ident << " AddToCircuitList called for " << t->plane.callsign << ", currently size = " << circuitList.size() << endl;
1745 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.
1746 bool conflict = false;
1747 tower_plane_rec_list_iterator twrItr;
1748 // First check if the plane is already in the list
1749 //cout << "A" << endl;
1750 //cout << "Checking whether " << t->plane.callsign << " is already in circuit list..." << endl;
1751 //cout << "B" << endl;
1752 for(twrItr = circuitList.begin(); twrItr != circuitList.end(); twrItr++) {
1753 if((*twrItr)->plane.callsign == t->plane.callsign) {
1754 //cout << "In list - returning...\n";
1758 //cout << "Not in list - adding..." << endl;
1760 for(twrItr = circuitList.begin(); twrItr != circuitList.end(); twrItr++) {
1761 TowerPlaneRec* tpr = *twrItr;
1762 //cout << tpr->plane.callsign << " eta is " << tpr->eta << '\n';
1763 //cout << "New eta is " << t->eta << '\n';
1764 if(t->eta < tpr->eta) {
1765 // Ugg - this one's tricky.
1766 // It depends on what the two planes are doing and whether there's a conflict what we do.
1767 if(tpr->eta - t->eta > separation_time) { // No probs, plane 2 can squeeze in before plane 1 with no apparent conflict
1768 circuitList.insert(twrItr, t);
1769 circuitListItr = circuitList.begin();
1770 } else { // Ooops - this ones tricky - we have a potential conflict!
1772 // HACK - just add anyway for now and flag conflict.
1773 circuitList.insert(twrItr, t);
1774 circuitListItr = circuitList.begin();
1776 //cout << "\tC\t" << circuitList.size() << '\n';
1780 // If we get here we must be at the end of the list, or maybe the list is empty.
1781 //cout << ident << " adding " << t->plane.callsign << " to circuitList" << endl;
1782 circuitList.push_back(t); // TODO - check the separation with the preceding plane for the conflict flag.
1783 circuitListItr = circuitList.begin();
1784 //cout << "\tE\t" << circuitList.size() << endl;
1788 // Add to vacated list only if not already present
1789 void FGTower::AddToVacatedList(TowerPlaneRec* t) {
1790 tower_plane_rec_list_iterator twrItr;
1792 for(twrItr = vacatedList.begin(); twrItr != vacatedList.end(); twrItr++) {
1793 if((*twrItr)->plane.callsign == t->plane.callsign) {
1798 vacatedList.push_back(t);
1801 void FGTower::AddToHoldingList(TowerPlaneRec* t) {
1802 tower_plane_rec_list_iterator it, end = holdList.end();
1803 for (it = holdList.begin(); it != end; ++it) {
1804 if ((*it)->plane.callsign == t->plane.callsign)
1807 holdList.push_back(t);
1811 // Calculate the eta of a plane to the threshold.
1812 // For ground traffic this is the fastest they can get there.
1813 // For air traffic this is the middle approximation.
1814 void FGTower::CalcETA(TowerPlaneRec* tpr, bool printout) {
1815 // For now we'll be very crude and hardwire expected speeds to C172-like values
1816 // The speeds below are specified in knots IAS and then converted to m/s
1817 double app_ias = 100.0 * 0.514444; // Speed during straight-in approach
1818 double circuit_ias = 80.0 * 0.514444; // Speed around circuit
1819 double final_ias = 70.0 * 0.514444; // Speed during final approach
1822 //cout << "In CalcETA, airplane ident = " << tpr->plane.callsign << '\n';
1823 //cout << (tpr->isUser ? "USER\n" : "AI\n");
1827 // Sign convention - dist_out is -ve for approaching planes and +ve for departing planes
1828 // dist_across is +ve in the pattern direction - ie a plane correctly on downwind will have a +ve dist_across
1830 SGVec3d op = ortho.ConvertToLocal(tpr->pos);
1832 //if(!tpr->isUser) cout << "Orthopos is " << op.x() << ", " << op.y() << ' ';
1833 //cout << "opType is " << tpr->opType << '\n';
1835 double dist_out_m = op.y();
1836 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
1837 //cout << "Doing ETA calc for " << tpr->plane.callsign << '\n';
1839 if(tpr->opType == STRAIGHT_IN || tpr->opType == INBOUND) {
1840 //cout << "CASE 1\n";
1841 double dist_to_go_m = sqrt((dist_out_m * dist_out_m) + (dist_across_m * dist_across_m));
1842 if(dist_to_go_m < 1000) {
1843 tpr->eta = dist_to_go_m / final_ias;
1845 tpr->eta = (1000.0 / final_ias) + ((dist_to_go_m - 1000.0) / app_ias);
1847 } else if(tpr->opType == CIRCUIT || tpr->opType == TTT_UNKNOWN) { // Hack alert - UNKNOWN has sort of been added here as a temporary hack.
1848 //cout << "CASE 2\n";
1849 // It's complicated - depends on if base leg is delayed or not
1851 //cout << "Leg = " << tpr->leg << '\n';
1853 if(tpr->leg == LANDING_ROLL) {
1855 } else if((tpr->leg == FINAL) || (tpr->leg == TURN4)) {
1856 //cout << "dist_out_m = " << dist_out_m << '\n';
1857 tpr->eta = fabs(dist_out_m) / final_ias;
1858 } else if((tpr->leg == BASE) || (tpr->leg == TURN3)) {
1859 tpr->eta = (fabs(dist_out_m) / final_ias) + (dist_across_m / circuit_ias);
1861 // Need to calculate where base leg is likely to be
1862 // FIXME - for now I'll hardwire it to 1000m which is what AILocalTraffic uses!!!
1863 // 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
1864 double nominal_base_dist_out_m = -1000;
1865 double current_base_dist_out_m;
1866 if(!GetBaseConstraint(current_base_dist_out_m)) {
1867 current_base_dist_out_m = nominal_base_dist_out_m;
1869 //cout << "current_base_dist_out_m = " << current_base_dist_out_m << '\n';
1870 double nominal_dist_across_m = 1000; // Hardwired value from AILocalTraffic
1871 double current_dist_across_m;
1872 if(!GetDownwindConstraint(current_dist_across_m)) {
1873 current_dist_across_m = nominal_dist_across_m;
1875 double nominal_cross_dist_out_m = 2000; // Bit of a guess - AI plane turns to crosswind at 700ft agl.
1876 tpr->eta = fabs(current_base_dist_out_m) / final_ias; // final
1877 //cout << "a = " << tpr->eta << '\n';
1878 if((tpr->leg == DOWNWIND) || (tpr->leg == TURN2)) {
1879 tpr->eta += dist_across_m / circuit_ias;
1880 //cout << "b = " << tpr->eta << '\n';
1881 tpr->eta += fabs(current_base_dist_out_m - dist_out_m) / circuit_ias;
1882 //cout << "c = " << tpr->eta << '\n';
1883 } else if((tpr->leg == CROSSWIND) || (tpr->leg == TURN1)) {
1884 //cout << "CROSSWIND calc: ";
1885 //cout << tpr->eta << ' ';
1886 if(dist_across_m > nominal_dist_across_m) {
1887 tpr->eta += dist_across_m / circuit_ias;
1890 tpr->eta += nominal_dist_across_m / circuit_ias;
1893 //cout << tpr->eta << ' ';
1894 // should we use the dist across of the previous plane if there is previous still on downwind?
1895 //if(printout) cout << "bb = " << tpr->eta << '\n';
1896 if(dist_out_m > nominal_cross_dist_out_m) {
1897 tpr->eta += fabs(current_base_dist_out_m - dist_out_m) / circuit_ias;
1900 tpr->eta += fabs(current_base_dist_out_m - nominal_cross_dist_out_m) / circuit_ias;
1903 //cout << tpr->eta << ' ';
1904 //if(printout) cout << "cc = " << tpr->eta << '\n';
1905 if(nominal_dist_across_m > dist_across_m) {
1906 tpr->eta += (nominal_dist_across_m - dist_across_m) / circuit_ias;
1912 //cout << tpr->eta << '\n';
1913 //if(printout) cout << "dd = " << tpr->eta << '\n';
1915 // We've only just started - why not use a generic estimate?
1920 // cout << "ETA = " << tpr->eta << '\n';
1922 //if(!tpr->isUser) cout << tpr->plane.callsign << '\t' << tpr->eta << '\n';
1929 // Calculate the distance of a plane to the threshold in meters
1930 // TODO - Modify to calculate flying distance of a plane in the circuit
1931 double FGTower::CalcDistOutM(TowerPlaneRec* tpr) {
1932 return(dclGetHorizontalSeparation(rwy.threshold_pos, tpr->pos));
1936 // Calculate the distance of a plane to the threshold in miles
1937 // TODO - Modify to calculate flying distance of a plane in the circuit
1938 double FGTower::CalcDistOutMiles(TowerPlaneRec* tpr) {
1939 return(CalcDistOutM(tpr) / 1600.0); // FIXME - use a proper constant if possible.
1943 // Iterate through all the lists, update the position of, and call CalcETA for all the planes.
1944 void FGTower::doThresholdETACalc() {
1945 //cout << "Entering doThresholdETACalc..." << endl;
1946 tower_plane_rec_list_iterator twrItr;
1947 // Do the approach list first
1948 for(twrItr = appList.begin(); twrItr != appList.end(); twrItr++) {
1949 TowerPlaneRec* tpr = *twrItr;
1950 if(!(tpr->isUser)) tpr->pos = tpr->planePtr->getPos();
1954 // Then the circuit list
1955 //cout << "Circuit list size is " << circuitList.size() << '\n';
1956 for(twrItr = circuitList.begin(); twrItr != circuitList.end(); twrItr++) {
1957 TowerPlaneRec* tpr = *twrItr;
1958 if(!(tpr->isUser)) tpr->pos = tpr->planePtr->getPos();
1962 //cout << "Done doThresholdETCCalc" << endl;
1966 // Check that the planes in traffic list are correctly ordered,
1967 // that the nearest (timewise) is flagged next on rwy, and return
1968 // true if any threshold use conflicts are detected, false otherwise.
1969 bool FGTower::doThresholdUseOrder() {
1970 //cout << "Entering doThresholdUseOrder..." << endl;
1971 bool conflict = false;
1973 // Wipe out traffic list, go through circuit, app and hold list, and reorder them in traffic list.
1974 // Here's the rather simplistic assumptions we're using:
1975 // Currently all planes are assumed to be GA light singles with corresponding speeds and separation times.
1976 // In order of priority for runway use:
1977 // STRAIGHT_IN > CIRCUIT > HOLDING_FOR_DEPARTURE
1978 // No modification of planes speeds occurs - conflicts are resolved by delaying turn for base,
1979 // and holding planes until a space.
1980 // When calculating if a holding plane can use the runway, time clearance from last departure
1981 // as well as time clearance to next arrival must be considered.
1983 trafficList.clear();
1985 tower_plane_rec_list_iterator twrItr;
1986 // Do the approach list first
1987 //if(ident == "KRHV") cout << "A" << flush;
1988 for(twrItr = appList.begin(); twrItr != appList.end(); twrItr++) {
1989 TowerPlaneRec* tpr = *twrItr;
1990 //if(ident == "KRHV") cout << tpr->plane.callsign << '\n';
1991 conflict = AddToTrafficList(tpr);
1993 // Then the circuit list
1994 //if(ident == "KRHV") cout << "C" << flush;
1995 for(twrItr = circuitList.begin(); twrItr != circuitList.end(); twrItr++) {
1996 TowerPlaneRec* tpr = *twrItr;
1997 //if(ident == "KRHV") cout << tpr->plane.callsign << '\n';
1998 conflict = AddToTrafficList(tpr);
2000 // And finally the hold list
2001 //cout << "H" << endl;
2002 for(twrItr = holdList.begin(); twrItr != holdList.end(); twrItr++) {
2003 TowerPlaneRec* tpr = *twrItr;
2004 AddToTrafficList(tpr, true);
2009 //if(ident == "KRHV") {
2011 for(twrItr = trafficList.begin(); twrItr != trafficList.end(); twrItr++) {
2012 TowerPlaneRec* tpr = *twrItr;
2013 cout << tpr->plane.callsign << '\t' << tpr->eta << '\t';
2018 //cout << "Done doThresholdUseOrder" << endl;
2023 // Return the ETA of plane no. list_pos (1-based) in the traffic list.
2024 // i.e. list_pos = 1 implies next to use runway.
2025 double FGTower::GetTrafficETA(unsigned int list_pos, bool printout) {
2026 if(trafficList.size() < list_pos) {
2030 tower_plane_rec_list_iterator twrItr;
2031 twrItr = trafficList.begin();
2032 for(unsigned int i = 1; i < list_pos; i++, twrItr++);
2033 TowerPlaneRec* tpr = *twrItr;
2034 CalcETA(tpr, printout);
2035 //cout << "ETA returned = " << tpr->eta << '\n';
2040 void FGTower::ContactAtHoldShort(const PlaneRec& plane, FGAIPlane* requestee, tower_traffic_type operation) {
2041 // HACK - assume that anything contacting at hold short is new for now - FIXME LATER
2042 TowerPlaneRec* t = new TowerPlaneRec;
2044 t->planePtr = requestee;
2045 t->holdShortReported = true;
2046 t->clearedToLineUp = false;
2047 t->clearedToTakeOff = false;
2048 t->opType = operation;
2049 t->pos = requestee->getPos();
2051 //cout << "Hold Short reported by " << plane.callsign << '\n';
2052 SG_LOG(SG_ATC, SG_BULK, "Hold Short reported by " << plane.callsign);
2055 bool next = AddToTrafficList(t, true);
2057 double teta = GetTrafficETA(2);
2059 t->clearanceCounter = 7.0; // This reduces the delay before response to 3 secs if an immediate takeoff is reqd
2060 //cout << "Reducing response time to request due imminent traffic\n";
2065 // TODO - possibly add the reduced interval to clearance when immediate back in under the new scheme
2067 holdList.push_back(t);
2069 responseReqd = true;
2072 // Register the presence of an AI plane at a point where contact would already have been made in real life
2073 // CAUTION - currently it is assumed that this plane's callsign is unique - it is up to AIMgr to generate unique callsigns.
2074 void FGTower::RegisterAIPlane(const PlaneRec& plane, FGAIPlane* ai, const tower_traffic_type& op, const PatternLeg& lg) {
2075 // At the moment this is only going to be tested with inserting an AI plane on downwind
2076 TowerPlaneRec* t = new TowerPlaneRec;
2081 t->pos = ai->getPos();
2085 if(op == CIRCUIT && lg != LEG_UNKNOWN) {
2086 AddToCircuitList(t);
2091 doThresholdUseOrder();
2094 void FGTower::DeregisterAIPlane(const string& id) {
2098 // Contact tower for VFR approach
2099 // eg "Cessna Charlie Foxtrot Golf Foxtrot Sierra eight miles South of the airport for full stop with Bravo"
2100 // This function probably only called via user interaction - AI planes will have an overloaded function taking a planerec.
2101 // opt defaults to AIP_LT_UNKNOWN
2102 void FGTower::VFRArrivalContact(const string& ID, const LandingType& opt) {
2103 //cout << "USER Request Landing Clearance called for ID " << ID << '\n';
2105 // For now we'll assume that the user is a light plane and can get him/her to join the circuit if necessary.
2108 string usercall = fgGetString("/sim/user/callsign");
2109 if(ID == "USER" || ID == usercall) {
2110 t = FindPlane(usercall);
2112 //cout << "NOT t\n";
2113 t = new TowerPlaneRec;
2115 t->pos.setLongitudeDeg(user_lon_node->getDoubleValue());
2116 t->pos.setLatitudeDeg(user_lat_node->getDoubleValue());
2117 t->pos.setElevationM(user_elev_node->getDoubleValue());
2120 // Oops - the plane is already registered with this tower - maybe we took off and flew a giant circuit without
2121 // quite getting out of tower airspace - just ignore for now and treat as new arrival.
2122 // TODO - Maybe should remove from departure and circuit list if in there though!!
2125 // Oops - something has gone wrong - put out a warning
2126 cout << "WARNING - FGTower::VFRContact(string ID, LandingType lt) called with ID " << ID << " which does not appear to be the user.\n";
2132 // Calculate where the plane is in relation to the active runway and it's circuit
2133 // and set the op-type as appropriate.
2135 // HACK - to get up and running I'm going to assume that the user contacts tower on a staight-in final for now.
2136 t->opType = STRAIGHT_IN;
2138 t->plane.type = GA_SINGLE; // FIXME - Another assumption!
2139 t->plane.callsign = usercall;
2142 t->vfrArrivalReported = true;
2143 responseReqd = true;
2145 appList.push_back(t); // Not necessarily permanent
2146 appListItr = appList.begin();
2147 AddToTrafficList(t);
2149 current_atcdialog->remove_entry(ident, USER_REQUEST_VFR_ARRIVAL, TOWER);
2150 current_atcdialog->remove_entry(ident, USER_REQUEST_VFR_ARRIVAL_FULL_STOP, TOWER);
2151 current_atcdialog->remove_entry(ident, USER_REQUEST_VFR_ARRIVAL_TOUCH_AND_GO, TOWER);
2154 // landingType defaults to AIP_LT_UNKNOWN
2155 void FGTower::VFRArrivalContact(const PlaneRec& plane, FGAIPlane* requestee, const LandingType& lt) {
2156 //cout << "VFRArrivalContact called for plane " << plane.callsign << " at " << ident << '\n';
2157 // Possible hack - assume this plane is new for now - TODO - should check really
2158 TowerPlaneRec* t = new TowerPlaneRec;
2160 t->planePtr = requestee;
2161 t->landingType = lt;
2162 t->pos = requestee->getPos();
2164 //cout << "Hold Short reported by " << plane.callsign << '\n';
2165 SG_LOG(SG_ATC, SG_BULK, "VFR arrival contact made by " << plane.callsign);
2166 //cout << "VFR arrival contact made by " << plane.callsign << '\n';
2168 // HACK - to get up and running I'm going to assume a staight-in final for now.
2169 t->opType = STRAIGHT_IN;
2171 t->vfrArrivalReported = true;
2172 responseReqd = true;
2174 //cout << "Before adding, appList.size = " << appList.size() << " at " << ident << '\n';
2175 appList.push_back(t); // Not necessarily permanent
2176 appListItr = appList.begin();
2177 //cout << "After adding, appList.size = " << appList.size() << " at " << ident << '\n';
2178 AddToTrafficList(t);
2181 void FGTower::RequestDepartureClearance(const string& ID) {
2182 //cout << "Request Departure Clearance called...\n";
2185 void FGTower::RequestTakeOffClearance(const string& ID) {
2188 uid = fgGetString("/sim/user/callsign");
2189 current_atcdialog->remove_entry(ident, USER_REQUEST_TAKE_OFF, TOWER);
2191 TowerPlaneRec* t = FindPlane(uid);
2193 if(!(t->clearedToTakeOff)) {
2195 t->lineUpReported=true;
2196 responseReqd = true;
2200 SG_LOG(SG_ATC, SG_WARN, "WARNING: Unable to find plane " << ID << " in FGTower::RequestTakeOffClearance(...)");
2204 void FGTower::ReportFinal(const string& ID) {
2205 //cout << "Report Final Called at tower " << ident << " by plane " << ID << '\n';
2208 uid = fgGetString("/sim/user/callsign");
2209 current_atcdialog->remove_entry(ident, USER_REPORT_3_MILE_FINAL, TOWER);
2211 TowerPlaneRec* t = FindPlane(uid);
2213 t->finalReported = true;
2214 t->finalAcknowledged = false;
2215 if(!(t->clearedToLand)) {
2216 responseReqd = true;
2218 // possibly respond with wind even if already cleared to land?
2219 t->finalReported = false;
2220 t->finalAcknowledged = true;
2221 // HACK!! - prevents next reporting being misinterpreted as this one.
2224 SG_LOG(SG_ATC, SG_WARN, "WARNING: Unable to find plane " << ID << " in FGTower::ReportFinal(...)");
2228 void FGTower::ReportLongFinal(const string& ID) {
2231 uid = fgGetString("/sim/user/callsign");
2232 current_atcdialog->remove_entry(ident, USER_REPORT_3_MILE_FINAL, TOWER);
2234 TowerPlaneRec* t = FindPlane(uid);
2236 t->longFinalReported = true;
2237 t->longFinalAcknowledged = false;
2238 if(!(t->clearedToLand)) {
2239 responseReqd = true;
2240 } // possibly respond with wind even if already cleared to land?
2242 SG_LOG(SG_ATC, SG_WARN, "WARNING: Unable to find plane " << ID << " in FGTower::ReportLongFinal(...)");
2246 //void FGTower::ReportOuterMarker(string ID);
2247 //void FGTower::ReportMiddleMarker(string ID);
2248 //void FGTower::ReportInnerMarker(string ID);
2250 void FGTower::ReportRunwayVacated(const string& ID) {
2251 //cout << "Report Runway Vacated Called at tower " << ident << " by plane " << ID << '\n';
2254 uid = fgGetString("/sim/user/callsign");
2255 current_atcdialog->remove_entry(ident, USER_REPORT_RWY_VACATED, TOWER);
2257 TowerPlaneRec* t = FindPlane(uid);
2259 //cout << "Found it...\n";
2260 t->rwyVacatedReported = true;
2261 responseReqd = true;
2263 SG_LOG(SG_ATC, SG_WARN, "WARNING: Unable to find plane " << ID << " in FGTower::ReportRunwayVacated(...)");
2264 SG_LOG(SG_ATC, SG_ALERT, "A WARNING: Unable to find plane " << ID << " in FGTower::ReportRunwayVacated(...)");
2265 //cout << "WARNING: Unable to find plane " << ID << " in FGTower::ReportRunwayVacated(...)\n";
2269 TowerPlaneRec* FGTower::FindPlane(const string& ID) {
2270 //cout << "FindPlane called for " << ID << "...\n";
2271 tower_plane_rec_list_iterator twrItr;
2272 // Do the approach list first
2273 for(twrItr = appList.begin(); twrItr != appList.end(); twrItr++) {
2274 //cout << "appList callsign is " << (*twrItr)->plane.callsign << '\n';
2275 if((*twrItr)->plane.callsign == ID) return(*twrItr);
2277 // Then the circuit list
2278 for(twrItr = circuitList.begin(); twrItr != circuitList.end(); twrItr++) {
2279 //cout << "circuitList callsign is " << (*twrItr)->plane.callsign << '\n';
2280 if((*twrItr)->plane.callsign == ID) return(*twrItr);
2282 // Then the runway list
2283 //cout << "rwyList.size() is " << rwyList.size() << '\n';
2284 for(twrItr = rwyList.begin(); twrItr != rwyList.end(); twrItr++) {
2285 //cout << "rwyList callsign is " << (*twrItr)->plane.callsign << '\n';
2286 if((*twrItr)->plane.callsign == ID) return(*twrItr);
2289 for(twrItr = holdList.begin(); twrItr != holdList.end(); twrItr++) {
2290 if((*twrItr)->plane.callsign == ID) return(*twrItr);
2292 // And finally the vacated list
2293 for(twrItr = vacatedList.begin(); twrItr != vacatedList.end(); twrItr++) {
2294 //cout << "vacatedList callsign is " << (*twrItr)->plane.callsign << '\n';
2295 if((*twrItr)->plane.callsign == ID) return(*twrItr);
2297 SG_LOG(SG_ATC, SG_WARN, "Unable to find " << ID << " in FGTower::FindPlane(...)");
2302 void FGTower::RemovePlane(const string& ID) {
2303 //cout << ident << " RemovePlane called for " << ID << '\n';
2304 // We have to be careful here - we want to erase the plane from all lists it is in,
2305 // but we can only delete it once, AT THE END.
2306 TowerPlaneRec* t = NULL;
2307 tower_plane_rec_list_iterator twrItr;
2308 for(twrItr = appList.begin(); twrItr != appList.end();) {
2309 if((*twrItr)->plane.callsign == ID) {
2311 twrItr = appList.erase(twrItr);
2312 appListItr = appList.begin();
2313 // HACK: aircraft are sometimes more than once in a list, so we need to
2314 // remove them all before we can delete the TowerPlaneRec class
2319 for(twrItr = depList.begin(); twrItr != depList.end();) {
2320 if((*twrItr)->plane.callsign == ID) {
2322 twrItr = depList.erase(twrItr);
2323 depListItr = depList.begin();
2327 for(twrItr = circuitList.begin(); twrItr != circuitList.end();) {
2328 if((*twrItr)->plane.callsign == ID) {
2330 twrItr = circuitList.erase(twrItr);
2331 circuitListItr = circuitList.begin();
2335 for(twrItr = holdList.begin(); twrItr != holdList.end();) {
2336 if((*twrItr)->plane.callsign == ID) {
2338 twrItr = holdList.erase(twrItr);
2339 holdListItr = holdList.begin();
2343 for(twrItr = rwyList.begin(); twrItr != rwyList.end();) {
2344 if((*twrItr)->plane.callsign == ID) {
2346 twrItr = rwyList.erase(twrItr);
2347 rwyListItr = rwyList.begin();
2351 for(twrItr = vacatedList.begin(); twrItr != vacatedList.end();) {
2352 if((*twrItr)->plane.callsign == ID) {
2354 twrItr = vacatedList.erase(twrItr);
2355 vacatedListItr = vacatedList.begin();
2359 for(twrItr = trafficList.begin(); twrItr != trafficList.end();) {
2360 if((*twrItr)->plane.callsign == ID) {
2362 twrItr = trafficList.erase(twrItr);
2363 trafficListItr = trafficList.begin();
2367 // And finally, delete the record.
2371 void FGTower::ReportDownwind(const string& ID) {
2372 //cout << "ReportDownwind(...) called\n";
2375 uid = fgGetString("/sim/user/callsign");
2376 current_atcdialog->remove_entry(ident, USER_REPORT_DOWNWIND, TOWER);
2378 TowerPlaneRec* t = FindPlane(uid);
2380 t->downwindReported = true;
2381 responseReqd = true;
2382 // If the plane is in the app list, remove it and put it in the circuit list instead.
2383 // Ideally we might want to do this at the 2 mile report prior to 45 deg entry, but at
2384 // the moment that would b&gg?r up the constraint position calculations.
2385 RemoveFromAppList(ID);
2388 t->pos.setLongitudeDeg(user_lon_node->getDoubleValue());
2389 t->pos.setLatitudeDeg(user_lat_node->getDoubleValue());
2390 t->pos.setElevationM(user_elev_node->getDoubleValue());
2392 // ASSERT(t->planePtr != NULL);
2393 t->pos = t->planePtr->getPos();
2396 AddToCircuitList(t);
2398 SG_LOG(SG_ATC, SG_WARN, "WARNING: Unable to find plane " << ID << " in FGTower::ReportDownwind(...)");
2402 void FGTower::ReportGoingAround(const string& ID) {
2405 uid = fgGetString("/sim/user/callsign");
2406 RemoveAllUserDialogOptions(); // TODO - it would be much more efficient if ATCDialog simply had a clear() function!!!
2407 current_atcdialog->add_entry(ident, "@AP Tower, @CS Downwind @RW", "Report Downwind", TOWER, (int)USER_REPORT_DOWNWIND);
2409 TowerPlaneRec* t = FindPlane(uid);
2411 //t->goAroundReported = true; // No need to set this until we start responding to it.
2412 responseReqd = false; // might change in the future but for now we'll not distract them during the go-around.
2413 // If the plane is in the app list, remove it and put it in the circuit list instead.
2414 RemoveFromAppList(ID);
2417 t->pos.setLongitudeDeg(user_lon_node->getDoubleValue());
2418 t->pos.setLatitudeDeg(user_lat_node->getDoubleValue());
2419 t->pos.setElevationM(user_elev_node->getDoubleValue());
2421 // ASSERT(t->planePtr != NULL);
2422 t->pos = t->planePtr->getPos();
2425 AddToCircuitList(t);
2427 SG_LOG(SG_ATC, SG_WARN, "WARNING: Unable to find plane " << ID << " in FGTower::ReportDownwind(...)");
2431 string FGTower::GenText(const string& m, int c) {
2432 const int cmax = 300;
2442 string usercall = fgGetString("/sim/user/callsign");
2443 TowerPlaneRec* t = FindPlane(responseID);
2445 //transmission_list_type tmissions = transmissionlist_station[station];
2446 //transmission_list_iterator current = tmissions.begin();
2447 //transmission_list_iterator last = tmissions.end();
2449 //for ( ; current != last ; ++current ) {
2450 // if ( current->get_code().c1 == code.c1 &&
2451 // current->get_code().c2 == code.c2 &&
2452 // current->get_code().c3 == code.c3 ) {
2454 //if ( ttext ) message = current->get_transtext();
2455 //else message = current->get_menutext();
2456 strcpy( &mes[0], m.c_str() );
2458 // Replace all the '@' parameters with the actual text.
2459 int check = 0; // If mes gets overflowed the while loop can go infinite
2460 double gp = fgGetFloat("/gear/gear/position-norm");
2461 while ( strchr(&mes[0], crej) != NULL ) { // ie. loop until no more occurances of crej ('@') found
2462 pos = strchr( &mes[0], crej );
2463 memmove(&tag[0], pos, 3);
2467 for ( i=0; i<cmax; i++ ) {
2468 if ( mes[i] == crej ) {
2473 strncpy( &dum[0], &mes[0], len );
2476 if ( strcmp ( tag, "@ST" ) == 0 )
2477 //strcat( &dum[0], tpars.station.c_str() );
2478 strcat(&dum[0], ident.c_str());
2479 else if ( strcmp ( tag, "@AP" ) == 0 )
2480 //strcat( &dum[0], tpars.airport.c_str() );
2481 strcat(&dum[0], name.c_str());
2482 else if ( strcmp ( tag, "@CS" ) == 0 )
2483 //strcat( &dum[0], tpars.callsign.c_str() );
2484 strcat(&dum[0], usercall.c_str());
2485 else if ( strcmp ( tag, "@TD" ) == 0 ) {
2487 if ( tpars.tdir == 1 ) {
2488 char buf[] = "left";
2489 strcat( &dum[0], &buf[0] );
2492 char buf[] = "right";
2493 strcat( &dum[0], &buf[0] );
2497 else if ( strcmp ( tag, "@HE" ) == 0 ) {
2500 sprintf( buf, "%i", (int)(tpars.heading) );
2501 strcat( &dum[0], &buf[0] );
2504 else if ( strcmp ( tag, "@AT" ) == 0 ) { // ATIS ID
2507 sprintf( buf, "%i", (int)(tpars.heading) );
2508 strcat( &dum[0], &buf[0] );
2510 double f = globals->get_ATC_mgr()->GetFrequency(ident, ATIS) / 100.0;
2513 atis_id = ", information " + GetATISID();
2514 strcat( &dum[0], atis_id.c_str() );
2517 else if ( strcmp ( tag, "@VD" ) == 0 ) {
2519 if ( tpars.VDir == 1 ) {
2520 char buf[] = "Descend and maintain";
2521 strcat( &dum[0], &buf[0] );
2523 else if ( tpars.VDir == 2 ) {
2524 char buf[] = "Maintain";
2525 strcat( &dum[0], &buf[0] );
2527 else if ( tpars.VDir == 3 ) {
2528 char buf[] = "Climb and maintain";
2529 strcat( &dum[0], &buf[0] );
2533 else if ( strcmp ( tag, "@AL" ) == 0 ) {
2536 sprintf( buf, "%i", (int)(tpars.alt) );
2537 strcat( &dum[0], &buf[0] );
2540 else if ( strcmp ( tag, "@TO" ) == 0 ) { // Requesting take-off or departure clearance
2543 tmp = "Ready for take-off";
2545 if (OnAnyRunway(SGGeod::fromDegM(user_lon_node->getDoubleValue(),
2546 user_lat_node->getDoubleValue(), 0.0),true)) {
2547 tmp = "Request take-off clearance";
2549 tmp = "Request departure clearance";
2552 strcat(&dum[0], tmp.c_str());
2554 else if ( strcmp ( tag, "@MI" ) == 0 ) {
2556 //sprintf( buf, "%3.1f", tpars.miles );
2557 int dist_miles = (int)dclGetHorizontalSeparation(_geod, SGGeod::fromDegM(user_lon_node->getDoubleValue(), user_lat_node->getDoubleValue(), user_elev_node->getDoubleValue())) / 1600;
2558 sprintf(buf, "%i", dist_miles);
2559 strcat( &dum[0], &buf[0] );
2561 else if ( strcmp ( tag, "@FR" ) == 0 ) {
2564 sprintf( buf, "%6.2f", tpars.freq );
2565 strcat( &dum[0], &buf[0] );
2568 else if ( strcmp ( tag, "@RW" ) == 0 ) {
2569 strcat(&dum[0], ConvertRwyNumToSpokenString(activeRwy).c_str());
2571 else if ( strcmp ( tag, "@GR" ) == 0 ) { // Gear position (on final)
2572 if(t->gearWasUp && gp > 0.99) {
2573 strcat(&dum[0], ", gear down, ready to land.");
2576 else if(strcmp(tag, "@CD") == 0) { // @CD = compass direction
2577 double h = GetHeadingFromTo(_geod, SGGeod::fromDegM(user_lon_node->getDoubleValue(), user_lat_node->getDoubleValue(), user_elev_node->getDoubleValue()));
2578 while(h < 0.0) h += 360.0;
2579 while(h > 360.0) h -= 360.0;
2580 if(h < 22.5 || h > 337.5) {
2581 strcat(&dum[0], "North");
2582 } else if(h < 67.5) {
2583 strcat(&dum[0], "North-East");
2584 } else if(h < 112.5) {
2585 strcat(&dum[0], "East");
2586 } else if(h < 157.5) {
2587 strcat(&dum[0], "South-East");
2588 } else if(h < 202.5) {
2589 strcat(&dum[0], "South");
2590 } else if(h < 247.5) {
2591 strcat(&dum[0], "South-West");
2592 } else if(h < 292.5) {
2593 strcat(&dum[0], "West");
2595 strcat(&dum[0], "North-West");
2598 cout << "Tag " << tag << " not found" << endl;
2601 strcat( &dum[0], &mes[len+3] );
2602 strcpy( &mes[0], &dum[0] );
2606 SG_LOG(SG_ATC, SG_WARN, "WARNING: Possibly endless loop terminated in FGTransmissionlist::gen_text(...)");
2611 //cout << mes << endl;
2615 return mes[0] ? mes : "No transmission found";
2618 string FGTower::GetWeather() {
2619 std::ostringstream msg;
2622 double hdg = wind_from_hdg->getDoubleValue();
2623 double speed = wind_speed_knots->getDoubleValue();
2627 msg << "wind " << int(hdg) << " degrees at " << int(speed) << " knots";
2630 double visibility = fgGetDouble("/environment/visibility-m");
2631 if (visibility < 10000)
2632 msg << ", visibility " << int(visibility / 1609) << " miles";
2634 // pressure / altimeter
2635 double pressure = fgGetDouble("/environment/pressure-sea-level-inhg");
2636 msg << ", QFE " << fixed << setprecision(2) << pressure << ".";
2641 string FGTower::GetATISID() {
2642 double tstamp = atof(fgGetString("sim/time/elapsed-sec"));
2643 const int minute(60); // in SI units
2644 int interval = ATIS ? 60*minute : 2*minute; // AWOS updated frequently
2645 int sequence = current_commlist->GetAtisSequence(ident,
2648 return GetPhoneticLetter(sequence); // the sequence letter
2651 ostream& operator << (ostream& os, tower_traffic_type ttt) {
2653 case(CIRCUIT): return(os << "CIRCUIT");
2654 case(INBOUND): return(os << "INBOUND");
2655 case(OUTBOUND): return(os << "OUTBOUND");
2656 case(TTT_UNKNOWN): return(os << "UNKNOWN");
2657 case(STRAIGHT_IN): return(os << "STRAIGHT_IN");
2659 return(os << "ERROR - Unknown switch in tower_traffic_type operator << ");