src/ATC/AIMgr.cxx

   1 // AIMgr.cxx - implementation of FGAIMgr
   2 // - a global management class for FlightGear generated AI traffic
   3 //
   4 // Written by David Luff, started March 2002.
   5 //
   6 // Copyright (C) 2002  David C Luff - david.luff@nottingham.ac.uk
   7 //
   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.
  12 //
  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.
  17 //
  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., 675 Mass Ave, Cambridge, MA 02139, USA.
  21
  22 #include <simgear/misc/sg_path.hxx>
  23
  24 #include <Main/fg_props.hxx>
  25 #include <Main/globals.hxx>
  26 #include <simgear/math/sg_random.h>
  27 #include <list>
  28
  29 #ifdef _MSC_VER
  30 #  include <io.h>
  31 #else
  32 #  include <sys/types.h>        // for directory reading
  33 #  include <dirent.h>           // for directory reading
  34 #endif
  35
  36 #include <Environment/environment_mgr.hxx>
  37 #include <Environment/environment.hxx>
  38
  39 #include "AIMgr.hxx"
  40 #include "AILocalTraffic.hxx"
  41 #include "AIGAVFRTraffic.hxx"
  42 #include "ATCutils.hxx"
  43 #include "commlist.hxx"
  44
  45 SG_USING_STD(list);
  46 SG_USING_STD(cout);
  47
  48 FGAIMgr::FGAIMgr() {
  49         ATC = globals->get_ATC_mgr();
  50         initDone = false;
  51         ai_callsigns_used["CFGFS"] = 1; // so we don't inadvertently use this
  52         // TODO - use the proper user callsign when it becomes user settable.
  53         removalList.clear();
  54         activated.clear();
  55         _havePiperModel = true;
  56 }
  57
  58 FGAIMgr::~FGAIMgr() {
  59         ssgDeRefDelete(_defaultModel);
  60         if(_havePiperModel) ssgDeRefDelete(_piperModel);
  61 }
  62
  63 void FGAIMgr::init() {
  64         //cout << "AIMgr::init called..." << endl;
  65
  66         // Pointers to user's position
  67         lon_node = fgGetNode("/position/longitude-deg", true);
  68         lat_node = fgGetNode("/position/latitude-deg", true);
  69         elev_node = fgGetNode("/position/altitude-ft", true);
  70
  71         lon = lon_node->getDoubleValue();
  72         lat = lat_node->getDoubleValue();
  73         elev = elev_node->getDoubleValue();
  74
  75         // Load up models at the start to avoid pausing later
  76         // Hack alert - Hardwired paths!!
  77         string planepath = "Aircraft/c172p/Models/c172p.xml";
  78         bool _loadedDefaultOK = true;
  79         try {
  80                 _defaultModel = sgLoad3DModel( globals->get_fg_root(),
  81                                            planepath.c_str(),
  82                                                                            globals->get_props(),
  83                                                                            globals->get_sim_time_sec() );
  84         } catch(sg_exception&) {
  85                 _loadedDefaultOK = false;
  86         }
  87
  88         if(!_loadedDefaultOK ) {
  89                 // Just load the same 3D model as the default user plane - that's *bound* to exist!
  90                 // TODO - implement robust determination of availability of GA AI aircraft models
  91                 planepath = "Aircraft/c172p/Models/c172p.ac";
  92                 _defaultModel = sgLoad3DModel( globals->get_fg_root(),
  93                                            planepath.c_str(),
  94                                                                            globals->get_props(),
  95                                                                            globals->get_sim_time_sec() );
  96         }
  97
  98         planepath = "Aircraft/pa28-161/Models/pa28-161.ac";
  99         try {
 100                 _piperModel = sgLoad3DModel( globals->get_fg_root(),
 101                                          planepath.c_str(),
 102                                                                          globals->get_props(),
 103                                                                          globals->get_sim_time_sec() );
 104         } catch(sg_exception&) {
 105                 _havePiperModel = false;
 106         }
 107
 108         // We need to keep one ref of the models open to stop ssg deleting them behind our back!
 109         _defaultModel->ref();
 110         if(_havePiperModel) _piperModel->ref();
 111
 112         // go through the $FG_ROOT/ATC directory and find all *.taxi files
 113         SGPath path(globals->get_fg_root());
 114         path.append("ATC/");
 115         string dir = path.dir();
 116         string ext;
 117         string file, f_ident;
 118         int pos;
 119
 120         ulDir *d;
 121         struct ulDirEnt *de;
 122
 123         if ( (d = ulOpenDir( dir.c_str() )) == NULL ) {
 124                 SG_LOG(SG_ATC, SG_WARN, "cannot open directory " << dir);
 125         } else {
 126                 // load all .taxi files
 127                 while ( (de = ulReadDir(d)) != NULL ) {
 128                         file = de->d_name;
 129                         pos = file.find(".");
 130                         ext = file.substr(pos + 1);
 131                         if(ext == "taxi") {
 132                                 f_ident = file.substr(0, pos);
 133                                 const FGAirport *a = fgFindAirportID( f_ident);
 134                                 if(a){
 135                                         SGBucket sgb(a->getLongitude(), a->getLatitude());
 136                                         int idx = sgb.gen_index();
 137                                         if(facilities.find(idx) != facilities.end()) {
 138                                                 facilities[idx]->push_back(f_ident);
 139                                         } else {
 140                                                 ID_list_type* apts = new ID_list_type;
 141                                                 apts->push_back(f_ident);
 142                                                 facilities[idx] = apts;
 143                                         }
 144                                         SG_LOG(SG_ATC, SG_BULK, "Mapping " << f_ident << " to bucket " << idx);
 145                                 }
 146                         }
 147                 }
 148                 ulCloseDir(d);
 149         }
 150
 151         // See if are in range at startup and activate if necessary
 152         SearchByPos(15.0);
 153
 154         initDone = true;
 155
 156         //cout << "AIMgr::init done..." << endl;
 157
 158         /*
 159         // TESTING
 160         FGATCAlignedProjection ortho;
 161         ortho.Init(fgGetAirportPos("KEMT"), 205.0);     // Guess of rwy19 heading
 162         //Point3D ip = ortho.ConvertFromLocal(Point3D(6000, 1000, 1000));       // 90 deg entry
 163         //Point3D ip = ortho.ConvertFromLocal(Point3D(-7000, 3000, 1000));      // 45 deg entry
 164         Point3D ip = ortho.ConvertFromLocal(Point3D(1000, -7000, 1000));        // straight-in
 165         ATC->AIRegisterAirport("KEMT");
 166         FGAIGAVFRTraffic* p = new FGAIGAVFRTraffic();
 167         p->SetModel(_defaultModel);
 168         p->Init(ip, "KEMT", GenerateShortForm(GenerateUniqueCallsign()));
 169         ai_list.push_back(p);
 170         traffic[ident].push_back(p);
 171         activated["KEMT"] = 1;
 172         */
 173 }
 174
 175 void FGAIMgr::bind() {
 176 }
 177
 178 void FGAIMgr::unbind() {
 179 }
 180
 181 void FGAIMgr::update(double dt) {
 182         if(!initDone) {
 183                 init();
 184                 SG_LOG(SG_ATC, SG_WARN, "Warning - AIMgr::update(...) called before AIMgr::init()");
 185         }
 186
 187         //cout << activated.size() << '\n';
 188
 189         Point3D userPos = Point3D(lon_node->getDoubleValue(), lat_node->getDoubleValue(), elev_node->getDoubleValue());
 190
 191         // TODO - make these class variables!!
 192         static int i = 0;
 193         static int j = 0;
 194
 195         // Don't update any planes for first 50 runs through - this avoids some possible initialisation anomalies
 196         // Might not need it now we have fade-in though?
 197         if(i < 50) {
 198                 ++i;
 199                 return;
 200         }
 201
 202         if(j == 215) {
 203                 SearchByPos(25.0);
 204                 j = 0;
 205         } else if(j == 200) {
 206                 // Go through the list of activated airports and remove those out of range
 207                 //cout << "The following airports have been activated by the AI system:\n";
 208                 ai_activated_map_iterator apt_itr = activated.begin();
 209                 while(apt_itr != activated.end()) {
 210                         //cout << "FIRST IS " << (*apt_itr).first << '\n';
 211                         if(dclGetHorizontalSeparation(userPos, fgGetAirportPos((*apt_itr).first)) > (35.0 * 1600.0)) {
 212                                 // Then get rid of it and make sure the iterator is left pointing to the next one!
 213                                 string s = (*apt_itr).first;
 214                                 if(traffic.find(s) != traffic.end()) {
 215                                         //cout << "s = " << s << ", traffic[s].size() = " << traffic[s].size() << '\n';
 216                                         if(traffic[s].size()) {
 217                                                 apt_itr++;
 218                                         } else {
 219                                                 //cout << "Erasing " << (*apt_itr).first << " and traffic" << '\n';
 220                                                 activated.erase(apt_itr++);
 221                                                 traffic.erase(s);
 222                                         }
 223                                 } else {
 224                                                 //cout << "Erasing " << (*apt_itr).first << ' ' << (*apt_itr).second << '\n';
 225                                                 activated.erase(apt_itr++);
 226                                 }
 227                         } else {
 228                                 apt_itr++;
 229                         }
 230                 }
 231         } else if(j == 180) {
 232                 // Go through the list of activated airports and do the random airplane generation
 233                 ai_traffic_map_iterator it = traffic.begin();
 234                 while(it != traffic.end()) {
 235                         string s = (*it).first;
 236                         //cout << "s = " << s << " size = " << (*it).second.size() << '\n';
 237                         // Only generate extra traffic if within a certain distance of the user,
 238                         // TODO - maybe take users's tuned freq into account as well.
 239                         double d = dclGetHorizontalSeparation(userPos, fgGetAirportPos(s));
 240                         if(d < (15.0 * 1600.0)) {
 241                                 double cd = 0.0;
 242                                 bool gen = false;
 243                                 //cout << "Size of list is " << (*it).second.size() << " at " << s << '\n';
 244                                 if((*it).second.size()) {
 245                                         FGAIEntity* e = *((*it).second.rbegin());       // Get the last airplane currently scheduled to arrive at this airport.
 246                                         cd = dclGetHorizontalSeparation(e->GetPos(), fgGetAirportPos(s));
 247                                         if(cd < (d < 5000 ? 10000 : d + 5000)) {
 248                                                 gen = true;
 249                                         }
 250                                 } else {
 251                                         gen = true;
 252                                         cd = 0.0;
 253                                 }
 254                                 if(gen) {
 255                                         //cout << "Generating extra traffic at airport " << s << ", at least " << cd << " meters out\n";
 256                                         //GenerateSimpleAirportTraffic(s, cd);
 257                                         GenerateSimpleAirportTraffic(s, cd + 3000.0);   // The random seems a bit wierd - traffic could get far too bunched without the +3000.
 258                                         // TODO - make the anti-random constant variable depending on the ai-traffic level.
 259                                 }
 260                         }
 261                         ++it;
 262                 }
 263         }
 264
 265         ++j;
 266
 267         //cout << "Size of AI list is " << ai_list.size() << '\n';
 268
 269         // TODO - need to add a check of if any activated airports have gone out of range
 270
 271         string rs;      // plane to be removed, if one.
 272         if(removalList.size()) {
 273                 rs = *(removalList.begin());
 274                 removalList.pop_front();
 275         } else {
 276                 rs = "";
 277         }
 278
 279         // Traverse the list of active planes and run all their update methods
 280         // TODO - spread the load - not all planes should need updating every frame.
 281         // Note that this will require dt to be calculated for each plane though
 282         // since they rely on it to calculate distance travelled.
 283         ai_list_itr = ai_list.begin();
 284         while(ai_list_itr != ai_list.end()) {
 285                 FGAIEntity *e = *ai_list_itr;
 286                 if(rs.size() && e->GetCallsign() == rs) {
 287                         //cout << "Removing " << rs << " from ai_list\n";
 288                         ai_list_itr = ai_list.erase(ai_list_itr);
 289                         delete e;
 290                         // This is a hack - we should deref this plane from the airport count!
 291                 } else {
 292                         e->Update(dt);
 293                         ++ai_list_itr;
 294                 }
 295         }
 296
 297         //cout << "Size of AI list is " << ai_list.size() << '\n';
 298 }
 299
 300 void FGAIMgr::ScheduleRemoval(const string& s) {
 301         //cout << "Scheduling removal of plane " << s << " from AIMgr\n";
 302         removalList.push_back(s);
 303 }
 304
 305 // Activate AI traffic at an airport
 306 void FGAIMgr::ActivateAirport(const string& ident) {
 307         ATC->AIRegisterAirport(ident);
 308         // TODO - need to start the traffic more randomly
 309         FGAILocalTraffic* local_traffic = new FGAILocalTraffic;
 310         local_traffic->SetModel(_defaultModel); // currently hardwired to cessna.
 311         //local_traffic->Init(ident, IN_PATTERN, TAKEOFF_ROLL);
 312         local_traffic->Init(GenerateShortForm(GenerateUniqueCallsign()), ident);
 313         local_traffic->FlyCircuits(1, true);    // Fly 2 circuits with touch & go in between
 314         ai_list.push_back(local_traffic);
 315         traffic[ident].push_back(local_traffic);
 316         //cout << "******** ACTIVATING AIRPORT, ident = " << ident << '\n';
 317         activated[ident] = 1;
 318 }
 319
 320 // Hack - Generate AI traffic at an airport with no facilities file
 321 void FGAIMgr::GenerateSimpleAirportTraffic(const string& ident, double min_dist) {
 322         // Ugly hack - don't let VFR Cessnas operate at a hardwired list of major airports
 323         // This will go eventually once airport .xml files specify the traffic profile
 324         if(ident == "KSFO" || ident == "KDFW" || ident == "EGLL" || ident == "KORD" || ident == "KJFK"
 325                            || ident == "KMSP" || ident == "KLAX" || ident == "KBOS" || ident == "KEDW"
 326                                            || ident == "KSEA" || ident == "EHAM") {
 327                 return;
 328         }
 329
 330         /*
 331         // TODO - check for military airports - this should be in the current data.
 332         // UGGH - there's no point at the moment - everything is labelled civil in basic.dat!
 333         FGAirport a = fgFindAirportID(ident, &a);
 334         if(a) {
 335                 cout << "CODE IS " << a.code << '\n';
 336         } else {
 337                 // UG - can't find the airport!
 338                 return;
 339         }
 340         */
 341
 342         Point3D aptpos = fgGetAirportPos(ident);        // TODO - check for elev of -9999
 343         //cout << "ident = " << ident << ", elev = " << aptpos.elev() << '\n';
 344
 345         // Operate from airports at 3000ft and below only to avoid the default cloud layers and since we don't degrade AI performance with altitude.
 346         if(aptpos.elev() > 3000) {
 347                 //cout << "High alt airports not yet supported - returning\n";
 348                 return;
 349         }
 350
 351         // Rough hack for plane type - make 70% of the planes cessnas, the rest pipers.
 352         bool cessna = true;
 353
 354         // Get the time and only operate VFR in the (approximate) daytime.
 355         struct tm *t = globals->get_time_params()->getGmt();
 356         int loc_time = t->tm_hour + int(aptpos.lon() / (360.0 / 24.0));
 357         while (loc_time < 0)
 358                 loc_time += 24;
 359         while (loc_time >= 24)
 360                 loc_time -= 24;
 361
 362         //cout << "loc_time = " << loc_time << '\n';
 363         if(loc_time < 7 || loc_time > 19) return;
 364
 365         // Check that the visibility is OK for IFR operation.
 366         double visibility;
 367         FGEnvironment stationweather =
 368             ((FGEnvironmentMgr *)globals->get_subsystem("environment"))
 369               ->getEnvironment(aptpos.lat(), aptpos.lon(), aptpos.elev());      // TODO - check whether this should take ft or m for elev.
 370         visibility = stationweather.get_visibility_m();
 371         // Technically we can do VFR down to 1 mile (1600m) but that's pretty murky!
 372         //cout << "vis = " << visibility << '\n';
 373         if(visibility < 3000) return;
 374
 375         ATC->AIRegisterAirport(ident);
 376
 377         // Next - get the distance from user to the airport.
 378         Point3D userpos = Point3D(lon_node->getDoubleValue(), lat_node->getDoubleValue(), elev_node->getDoubleValue());
 379         double d = dclGetHorizontalSeparation(userpos, aptpos); // in meters
 380
 381         int lev = fgGetInt("/sim/ai-traffic/level");
 382         if(lev < 1 || lev > 3) lev = 2;
 383         if(visibility < 6000) lev = 1;
 384         //cout << "level = " << lev << '\n';
 385
 386         // Next - generate any local / circuit traffic
 387
 388         /*
 389         // --------------------------- THIS BLOCK IS JUST FOR TESTING - COMMENT OUT BEFORE RELEASE ---------------
 390         // Finally - generate VFR approaching traffic
 391         //if(d > 2000) {
 392         if(ident == "KPOC") {
 393                 double ad = 2000.0;
 394                 double avd = 3000.0;    // average spacing of arriving traffic in meters - relate to airport business and AI density setting one day!
 395                 //while(ad < (d < 10000 ? 12000 : d + 2000)) {
 396                 for(int i=0; i<8; ++i) {
 397                         double dd = sg_random() * avd;
 398                         // put a minimum spacing in for now since I don't think tower will cope otherwise!
 399                         if(dd < 1500) dd = 1500;
 400                         //ad += dd;
 401                         ad += dd;
 402                         double dir = int(sg_random() * 36);
 403                         if(dir == 36) dir--;
 404                         dir *= 10;
 405                         //dir = 180;
 406                         if(sg_random() < 0.3) cessna = false;
 407                         else cessna = true;
 408                         string s = GenerateShortForm(GenerateUniqueCallsign(), (cessna ? "Cessna-" : "Piper-"));
 409                         FGAIGAVFRTraffic* t = new FGAIGAVFRTraffic();
 410                         t->SetModel(cessna ? _defaultModel : _piperModel);
 411                         //cout << "Generating VFR traffic " << s << " inbound to " << ident << " " << ad << " meters out from " << dir << " degrees\n";
 412                         Point3D tpos = dclUpdatePosition(aptpos, dir, 6.0, ad);
 413                         if(tpos.elev() > (aptpos.elev() + 3000.0)) tpos.setelev(aptpos.elev() + 3000.0);
 414                         t->Init(tpos, ident, s);
 415                         ai_list.push_back(t);
 416                 }
 417         }
 418         activated[ident] = 1;
 419         return;
 420         //---------------------------------------------------------------------------------------------------
 421         */
 422
 423         double ad;   // Minimum distance out of first arriving plane in meters.
 424         double mind; // Minimum spacing of traffic in meters
 425         double avd;  // average spacing of arriving traffic in meters - relate to airport business and AI density setting one day!
 426         // Finally - generate VFR approaching traffic
 427         //if(d > 2000) {
 428         if(1) {
 429                 if(lev == 3) {
 430                         ad = 5000.0;
 431                         mind = 2000.0;
 432                         avd = 6000.0;
 433                 } else if(lev == 2) {
 434                         ad = 8000.0;
 435                         mind = 4000.0;
 436                         avd = 10000.0;
 437                 } else {
 438                         ad = 9000.0;    // Start the first aircraft at least 9K out for now.
 439                         mind = 6000.0;
 440                         avd = 15000.0;
 441                 }
 442                 /*
 443                 // Check if there is already arriving traffic at this airport
 444                 cout << "BING A " << ident << '\n';
 445                 if(traffic.find(ident) != traffic.end()) {
 446                         cout << "BING B " << ident << '\n';
 447                         ai_list_type lst = traffic[ident];
 448                         cout << "BING C " << ident << '\n';
 449                         if(lst.size()) {
 450                                 cout << "BING D " << ident << '\n';
 451                                 double cd = dclGetHorizontalSeparation(aptpos, (*lst.rbegin())->GetPos());
 452                                 cout << "ident = " << ident << ", cd = " << cd << '\n';
 453                                 if(cd > ad) ad = cd;
 454                         }
 455                 }
 456                 */
 457                 if(min_dist != 0) ad = min_dist;
 458                 //cout << "ident = " << ident << ", ad = " << ad << '\n';
 459                 while(ad < (d < 5000 ? 15000 : d + 10000)) {
 460                         double dd = mind + (sg_random() * (avd - mind));
 461                         ad += dd;
 462                         double dir = int(sg_random() * 36);
 463                         if(dir == 36) dir--;
 464                         dir *= 10;
 465
 466                         if(sg_random() < 0.3) cessna = false;
 467                         else cessna = true;
 468                         string s = GenerateShortForm(GenerateUniqueCallsign(), (cessna ? "Cessna-" : "Piper-"));
 469                         FGAIGAVFRTraffic* t = new FGAIGAVFRTraffic();
 470                         t->SetModel(cessna ? _defaultModel : (_havePiperModel ? _piperModel : _defaultModel));
 471                         //cout << "Generating VFR traffic " << s << " inbound to " << ident << " " << ad << " meters out from " << dir << " degrees\n";
 472                         Point3D tpos = dclUpdatePosition(aptpos, dir, 6.0, ad);
 473                         if(tpos.elev() > (aptpos.elev() + 3000.0)) tpos.setelev(aptpos.elev() + 3000.0);        // FEET yuk :-(
 474                         t->Init(tpos, ident, s);
 475                         ai_list.push_back(t);
 476                         traffic[ident].push_back(t);
 477                 }
 478         }
 479 }
 480
 481 /*
 482 // Generate a VFR arrival at airport apt, at least distance d (meters) out.
 483 void FGAIMgr::GenerateVFRArrival(const string& apt, double d) {
 484 }
 485 */
 486
 487 // Search for valid airports in the vicinity of the user and activate them if necessary
 488 void FGAIMgr::SearchByPos(double range) {
 489         //cout << "In SearchByPos(...)" << endl;
 490
 491         // get bucket number for plane position
 492         lon = lon_node->getDoubleValue();
 493         lat = lat_node->getDoubleValue();
 494         elev = elev_node->getDoubleValue() * SG_FEET_TO_METER;
 495         SGBucket buck(lon, lat);
 496
 497         // get neigboring buckets
 498         int bx = (int)( range*SG_NM_TO_METER / buck.get_width_m() / 2);
 499         //cout << "bx = " << bx << endl;
 500         int by = (int)( range*SG_NM_TO_METER / buck.get_height_m() / 2 );
 501         //cout << "by = " << by << endl;
 502
 503         // Search for airports with facitities files --------------------------
 504         // loop over bucket range
 505         for ( int i=-bx; i<=bx; i++) {
 506                 //cout << "i loop\n";
 507                 for ( int j=-by; j<=by; j++) {
 508                         //cout << "j loop\n";
 509                         buck = sgBucketOffset(lon, lat, i, j);
 510                         long int bucket = buck.gen_index();
 511                         //cout << "bucket is " << bucket << endl;
 512                         if(facilities.find(bucket) != facilities.end()) {
 513                                 ID_list_type* apts = facilities[bucket];
 514                                 ID_list_iterator current = apts->begin();
 515                                 ID_list_iterator last = apts->end();
 516
 517                                 //cout << "Size of apts is " << apts->size() << endl;
 518
 519                                 //double rlon = lon * SGD_DEGREES_TO_RADIANS;
 520                                 //double rlat = lat * SGD_DEGREES_TO_RADIANS;
 521                                 //Point3D aircraft = sgGeodToCart( Point3D(rlon, rlat, elev) );
 522                                 //Point3D airport;
 523                                 for(; current != last; ++current) {
 524                                         //cout << "Found " << *current << endl;;
 525                                         if(activated.find(*current) == activated.end()) {
 526                                                 //cout << "Activating " << *current << endl;
 527                                                 //FGAirport a;
 528                                                 //if(dclFindAirportID(*current, &a)) {
 529                                                         //      // We can do something here based on distance from the user if we wish.
 530                                                 //}
 531                                                 //string s = *current;
 532                                                 //cout << "s = " << s << '\n';
 533                                                 ActivateAirport(*current);
 534                                                 //ActivateSimpleAirport(*current);      // TODO - put this back to ActivateAirport when that code is done.
 535                                                 //cout << "Activation done" << endl;
 536                                         } else {
 537                                                 //cout << *current << " already activated" << endl;
 538                                         }
 539                                 }
 540                         }
 541                 }
 542         }
 543         //-------------------------------------------------------------
 544
 545         // Search for any towered airports in the vicinity ------------
 546         comm_list_type towered;
 547         comm_list_iterator twd_itr;
 548
 549         int num_twd = current_commlist->FindByPos(lon, lat, elev, range, &towered, TOWER);
 550         if (num_twd != 0) {
 551                 double closest = 1000000;
 552                 string s = "";
 553                 for(twd_itr = towered.begin(); twd_itr != towered.end(); twd_itr++) {
 554                         // Only activate the closest airport not already activated each time.
 555                         if(activated.find(twd_itr->ident) == activated.end()) {
 556                                 double sep = dclGetHorizontalSeparation(Point3D(lon, lat, elev), fgGetAirportPos(twd_itr->ident));
 557                                 if(sep < closest) {
 558                                         closest = sep;
 559                                         s = twd_itr->ident;
 560                                 }
 561
 562                         }
 563                 }
 564                 if(s.size()) {
 565                         // TODO - find out why empty strings come through here when all in-range airports done.
 566                         GenerateSimpleAirportTraffic(s);
 567                         //cout << "**************ACTIVATING SIMPLE AIRPORT, ident = " << s << '\n';
 568                         activated[s] = 1;
 569                 }
 570         }
 571 }
 572
 573 string FGAIMgr::GenerateCallsign() {
 574         // For now we'll just generate US callsigns until we can regionally identify airports.
 575         string s = "N";
 576         // Add 3 to 5 numbers and make up to 5 with letters.
 577         //sg_srandom_time();
 578         double d = sg_random();
 579         int n = int(d * 3);
 580         if(n == 3) --n;
 581         //cout << "First n, n = " << n << '\n';
 582         int j = 3 + n;
 583         //cout << "j = " << j << '\n';
 584         for(int i=0; i<j; ++i) {
 585                 int n = int(sg_random() * 10);
 586                 if(n == 10) --n;
 587                 s += (char)('0' + n);
 588         }
 589         for(int i=j; i<5; ++i) {
 590                 int n = int(sg_random() * 26);
 591                 if(n == 26) --n;
 592                 //cout << "Alpha, n = " << n << '\n';
 593                 s += (char)('A' + n);
 594         }
 595         //cout << "s = " << s << '\n';
 596         return(s);
 597 }
 598
 599 string FGAIMgr::GenerateUniqueCallsign() {
 600         while(1) {
 601                 string s = GenerateCallsign();
 602                 if(!ai_callsigns_used[s]) {
 603                         ai_callsigns_used[s] = 1;
 604                         return(s);
 605                 }
 606         }
 607 }
 608
 609 // This will be moved somewhere else eventually!!!!
 610 string FGAIMgr::GenerateShortForm(const string& callsign, const string& plane_str, bool local) {
 611         //cout << callsign << '\n';
 612         string s;
 613         if(local) s = "Trainer-";
 614         else s = plane_str;
 615         for(int i=3; i>0; --i) {
 616                 char c = callsign[callsign.size() - i];
 617                 //cout << c << '\n';
 618                 string tmp = "";
 619                 tmp += c;
 620                 if(isalpha(c)) s += GetPhoneticIdent(c);
 621                 else s += ConvertNumToSpokenDigits(tmp);
 622                 if(i > 1) s += '-';
 623         }
 624         return(s);
 625 }