src/Traffic/TrafficMgr.cxx

   1 /******************************************************************************
   2  * TrafficMGr.cxx
   3  * Written by Durk Talsma, started May 5, 2004.
   4  *
   5  * This program is free software; you can redistribute it and/or
   6  * modify it under the terms of the GNU General Public License as
   7  * published by the Free Software Foundation; either version 2 of the
   8  * License, or (at your option) any later version.
   9  *
  10  * This program is distributed in the hope that it will be useful, but
  11  * WITHOUT ANY WARRANTY; without even the implied warranty of
  12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  13  * General Public License for more details.
  14  *
  15  * You should have received a copy of the GNU General Public License
  16  * along with this program; if not, write to the Free Software
  17  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
  18  *
  19  *
  20  **************************************************************************/
  21
  22 /* This a prototype version of a top-level flight plan manager for Flightgear.
  23  * It parses the fgtraffic.txt file and determine for a specific time/date,
  24  * where each aircraft listed in this file is at the current time.
  25  *
  26  * I'm currently assuming the following simplifications:
  27  * 1) The earth is a perfect sphere
  28  * 2) Each aircraft flies a perfect great circle route.
  29  * 3) Each aircraft flies at a constant speed (with infinite accelerations and
  30  *    decelerations)
  31  * 4) Each aircraft leaves at exactly the departure time.
  32  * 5) Each aircraft arrives at exactly the specified arrival time.
  33  *
  34  *
  35  *****************************************************************************/
  36
  37 #ifdef HAVE_CONFIG_H
  38 #  include "config.h"
  39 #endif
  40
  41 #include <stdlib.h>
  42 #include <time.h>
  43 #include <iostream>
  44 #include <fstream>
  45
  46
  47 #include <string>
  48 #include <vector>
  49 #include <algorithm>
  50
  51 #include <plib/sg.h>
  52 #include <plib/ul.h>
  53
  54 #include <simgear/compiler.h>
  55 #include <simgear/math/polar3d.hxx>
  56 #include <simgear/math/sg_geodesy.hxx>
  57 #include <simgear/misc/sg_path.hxx>
  58 #include <simgear/props/props.hxx>
  59 #include <simgear/route/waypoint.hxx>
  60 #include <simgear/structure/subsystem_mgr.hxx>
  61 #include <simgear/xml/easyxml.hxx>
  62
  63 #include <AIModel/AIAircraft.hxx>
  64 #include <AIModel/AIFlightPlan.hxx>
  65 #include <AIModel/AIBase.hxx>
  66 #include <Airports/simple.hxx>
  67 #include <Main/fg_init.hxx>
  68
  69
  70
  71 #include "TrafficMgr.hxx"
  72
  73 SG_USING_STD(sort);
  74
  75 /******************************************************************************
  76  * TrafficManager
  77  *****************************************************************************/
  78 FGTrafficManager::FGTrafficManager()
  79 {
  80   score = 0;
  81   runCount = 0;
  82 }
  83
  84 FGTrafficManager:: ~FGTrafficManager()
  85 {
  86   for (ScheduleVectorIterator sched = scheduledAircraft.begin(); sched != scheduledAircraft.end(); sched++)
  87     {
  88       delete (*sched);
  89     }
  90   scheduledAircraft.clear();
  91   // for (FGScheduledFlightVecIterator flt = flights.begin(); flt != flights.end(); flt++)
  92 //     {
  93 //       delete (*flt);
  94 //     }
  95 //   flights.clear();
  96 }
  97
  98
  99 void FGTrafficManager::init()
 100 {
 101   //cerr << "Initializing Schedules" << endl;
 102   //time_t now = time(NULL) + fgGetLong("/sim/time/warp");
 103   //currAircraft = scheduledAircraft.begin();
 104   //while (currAircraft != scheduledAircraft.end())
 105   //  {
 106   //    if (!(currAircraft->init()))
 107   //    {
 108   //      currAircraft=scheduledAircraft.erase(currAircraft);
 109   //      //cerr << "Erasing " << currAircraft->getRegistration() << endl;
 110   //    }
 111   //   else
 112   //    {
 113   //      currAircraft++;
 114   //    }
 115   //   }
 116   // Sort by points: Aircraft with frequent visits to the
 117   // startup airport will be processed first
 118   ulDir* d, *d2;
 119   ulDirEnt* dent, *dent2;
 120   SGPath aircraftDir = globals->get_fg_root();
 121
 122   /* keep the following three lines (which mimicks the old "fixed path" behavior)
 123    * until we have some AI models with traffic in the base package
 124    */
 125   SGPath path = aircraftDir;
 126   path.append("/Traffic/fgtraffic.xml");
 127   readXML(path.str(),*this);
 128
 129   aircraftDir.append("AI/Aircraft/");
 130   if (aircraftDir.exists())
 131     {
 132       if((d = ulOpenDir(aircraftDir.c_str())) == NULL)
 133         return;
 134       while((dent = ulReadDir(d)) != NULL) {
 135         //cerr << "Scanning : " << dent->d_name << endl;
 136         if (string(dent->d_name) != string(".")  &&
 137             string(dent->d_name) != string("..") &&
 138             dent->d_isdir)
 139           {
 140             SGPath currACDir = aircraftDir;
 141             currACDir.append(dent->d_name);
 142             if ((d2 = ulOpenDir(currACDir.c_str())) == NULL)
 143               return;
 144             while ((dent2 = ulReadDir(d2)) != NULL) {
 145               SGPath currFile = currACDir;
 146               currFile.append(dent2->d_name);
 147               if (currFile.extension() == string("xml"))
 148                 {
 149                   //cerr << "found " << dent2->d_name << " for parsing" << endl;
 150                   SGPath currFile = currACDir;
 151                   currFile.append(dent2->d_name);
 152                   SG_LOG(SG_GENERAL, SG_INFO, "Scanning " << currFile.str() << " for traffic");
 153                   readXML(currFile.str(),*this);
 154                 }
 155             }
 156             ulCloseDir(d2);
 157           }
 158       }
 159       ulCloseDir(d);
 160     }
 161   // Sort by points: Aircraft with frequent visits to the
 162   // startup airport will be processed first
 163   sort(scheduledAircraft.begin(), scheduledAircraft.end(), compareSchedules);
 164   currAircraft = scheduledAircraft.begin();
 165   currAircraftClosest = scheduledAircraft.begin();
 166   //cerr << "Done initializing schedules" << endl;
 167 }
 168
 169 void FGTrafficManager::update(double something)
 170 {
 171   //SG_LOG( SG_GENERAL, SG_INFO, "Running TrafficManager::Update() ");
 172   if (runCount < 1000)
 173     {
 174       runCount++;
 175       return;
 176     }
 177   time_t now = time(NULL) + fgGetLong("/sim/time/warp");
 178   if (scheduledAircraft.size() == 0) {
 179     //SG_LOG( SG_GENERAL, SG_INFO, "Returned Running TrafficManager::Update() ");
 180     return;
 181   }
 182   if(currAircraft == scheduledAircraft.end())
 183     {
 184       //cerr << "resetting schedule " << endl;
 185       currAircraft = scheduledAircraft.begin();
 186     }
 187   if (!((*currAircraft)->update(now)))
 188     {
 189       // after proper initialization, we shouldnt get here.
 190       // But let's make sure
 191       cerr << "Failed to update aircraft schedule in traffic manager" << endl;
 192     }
 193   currAircraft++;
 194   //SG_LOG( SG_GENERAL, SG_INFO, "Done Running TrafficManager::Update() ");
 195 }
 196
 197 void FGTrafficManager::release(int id)
 198 {
 199   releaseList.push_back(id);
 200 }
 201
 202 bool FGTrafficManager::isReleased(int id)
 203 {
 204   IdListIterator i = releaseList.begin();
 205   while (i != releaseList.end())
 206     {
 207       if ((*i) == id)
 208         {
 209           releaseList.erase(i);
 210           return true;
 211         }
 212       i++;
 213     }
 214   return false;
 215 }
 216
 217 void  FGTrafficManager::startXML () {
 218   //cout << "Start XML" << endl;
 219 }
 220
 221 void  FGTrafficManager::endXML () {
 222   //cout << "End XML" << endl;
 223 }
 224
 225 void  FGTrafficManager::startElement (const char * name, const XMLAttributes &atts) {
 226   const char * attval;
 227   //cout << "Start element " << name << endl;
 228   //FGTrafficManager temp;
 229   //for (int i = 0; i < atts.size(); i++)
 230   //  if (string(atts.getName(i)) == string("include"))
 231   attval = atts.getValue("include");
 232   if (attval != 0)
 233       {
 234         //cout << "including " << attval << endl;
 235         SGPath path =
 236           globals->get_fg_root();
 237         path.append("/Traffic/");
 238         path.append(attval);
 239         readXML(path.str(), *this);
 240       }
 241   //  cout << "  " << atts.getName(i) << '=' << atts.getValue(i) << endl;
 242 }
 243
 244 void  FGTrafficManager::endElement (const char * name) {
 245   //cout << "End element " << name << endl;
 246   string element(name);
 247   if (element == string("model"))
 248     mdl = value;
 249   else if (element == string("livery"))
 250     livery = value;
 251   else if (element == string("registration"))
 252     registration = value;
 253   else if (element == string("airline"))
 254     airline = value;
 255   else if (element == string("actype"))
 256     acType = value;
 257   else if (element == string("flighttype"))
 258     flighttype = value;
 259   else if (element == string("radius"))
 260     radius = atoi(value.c_str());
 261   else if (element == string("offset"))
 262     offset = atoi(value.c_str());
 263   else if (element == string("performance-class"))
 264     m_class = value;
 265   else if (element == string("heavy"))
 266     {
 267       if(value == string("true"))
 268         heavy = true;
 269       else
 270         heavy = false;
 271     }
 272   else if (element == string("callsign"))
 273     callsign = value;
 274   else if (element == string("fltrules"))
 275     fltrules = value;
 276   else if (element == string("port"))
 277     port = value;
 278   else if (element == string("time"))
 279     timeString = value;
 280   else if (element == string("departure"))
 281     {
 282       departurePort = port;
 283       departureTime = timeString;
 284     }
 285   else if (element == string("cruise-alt"))
 286     cruiseAlt = atoi(value.c_str());
 287   else if (element == string("arrival"))
 288     {
 289       arrivalPort = port;
 290       arrivalTime = timeString;
 291     }
 292   else if (element == string("repeat"))
 293     repeat = value;
 294   else if (element == string("flight"))
 295     {
 296       // We have loaded and parsed all the information belonging to this flight
 297       // so we temporarily store it.
 298       //cerr << "Pusing back flight " << callsign << endl;
 299       //cerr << callsign  <<  " " << fltrules     << " "<< departurePort << " " <<  arrivalPort << " "
 300       //   << cruiseAlt <<  " " << departureTime<< " "<< arrivalTime   << " " << repeat << endl;
 301
 302       //Prioritize aircraft
 303       string apt = fgGetString("/sim/presets/airport-id");
 304       //cerr << "Airport information: " << apt << " " << departurePort << " " << arrivalPort << endl;
 305       if (departurePort == apt) score++;
 306       flights.push_back(new FGScheduledFlight(callsign,
 307                                           fltrules,
 308                                           departurePort,
 309                                           arrivalPort,
 310                                           cruiseAlt,
 311                                           departureTime,
 312                                           arrivalTime,
 313                                           repeat));
 314     }
 315   else if (element == string("aircraft"))
 316     {
 317       //cerr << "Pushing back aircraft " << registration << endl;
 318       scheduledAircraft.push_back(new FGAISchedule(mdl,
 319                                                livery,
 320                                                registration,
 321                                                heavy,
 322                                                acType,
 323                                                airline,
 324                                                m_class,
 325                                                flighttype,
 326                                                radius,
 327                                                offset,
 328                                                score,
 329                                                flights));
 330      //  while(flights.begin() != flights.end()) {
 331 //      flights.pop_back();
 332 //       }
 333       for (FGScheduledFlightVecIterator flt = flights.begin(); flt != flights.end(); flt++)
 334     {
 335       delete (*flt);
 336     }
 337   flights.clear();
 338       SG_LOG( SG_GENERAL, SG_BULK, "Reading aircraft : "
 339               << registration
 340               << " with prioritization score "
 341               << score);
 342       score = 0;
 343     }
 344 }
 345
 346 void  FGTrafficManager::data (const char * s, int len) {
 347   string token = string(s,len);
 348   //cout << "Character data " << string(s,len) << endl;
 349   if ((token.find(" ") == string::npos && (token.find('\n')) == string::npos))
 350       value += token;
 351   else
 352     value = string("");
 353 }
 354
 355 void  FGTrafficManager::pi (const char * target, const char * data) {
 356   //cout << "Processing instruction " << target << ' ' << data << endl;
 357 }
 358
 359 void  FGTrafficManager::warning (const char * message, int line, int column) {
 360   SG_LOG(SG_IO, SG_WARN, "Warning: " << message << " (" << line << ',' << column << ')');
 361 }
 362
 363 void  FGTrafficManager::error (const char * message, int line, int column) {
 364   SG_LOG(SG_IO, SG_ALERT, "Error: " << message << " (" << line << ',' << column << ')');
 365 }