src/ATC/AILocalTraffic.hxx

   1 // FGAILocalTraffic - AIEntity derived class with enough logic to
   2 // fly and interact with the traffic pattern.
   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 #ifndef _FG_AILocalTraffic_HXX
  23 #define _FG_AILocalTraffic_HXX
  24
  25 #include <simgear/math/point3d.hxx>
  26 #include <Main/fg_props.hxx>
  27
  28 #include "tower.hxx"
  29 #include "AIPlane.hxx"
  30 #include "ATCProjection.hxx"
  31 #include "ground.hxx"
  32
  33 #include <string>
  34 SG_USING_STD(string);
  35
  36 enum TaxiState {
  37         TD_INBOUND,
  38         TD_OUTBOUND,
  39         TD_NONE,
  40         TD_LINING_UP
  41 };
  42
  43 enum OperatingState {
  44         IN_PATTERN,
  45         TAXIING,
  46         PARKED,
  47         EN_ROUTE
  48 };
  49
  50 struct StartOfDescent {
  51         PatternLeg leg;
  52         double x;       // Runway aligned orthopos
  53         double y;       // ditto
  54 };
  55
  56 class FGAILocalTraffic : public FGAIPlane {
  57
  58 public:
  59
  60         // At the moment we expect the expanded short form callsign - eventually we will just want the reg + type.
  61         FGAILocalTraffic();
  62         ~FGAILocalTraffic();
  63
  64         // Initialise
  65         bool Init(const string& callsign, const string& ICAO, OperatingState initialState = PARKED, PatternLeg initialLeg = DOWNWIND);
  66
  67         // Run the internal calculations
  68         void Update(double dt);
  69
  70         // Go out and practice circuits
  71         void FlyCircuits(int numCircuits, bool tag);
  72
  73         // Return what type of landing we're doing on this circuit
  74         LandingType GetLandingOption();
  75
  76         // TODO - this will get more complex and moved into the main class
  77         // body eventually since the position approved to taxi to will have
  78         // to be passed.
  79         inline void ApproveTaxiRequest() {taxiRequestCleared = true;}
  80
  81         inline void DenyTaxiRequest() {taxiRequestCleared = false;}
  82
  83         void RegisterTransmission(int code);
  84
  85         // Process callbacks sent by base class
  86         // (These codes are not related to the codes above)
  87         void ProcessCallback(int code);
  88
  89         // This is a hack and will probably go eventually
  90         inline bool AtHoldShort() {return holdingShort;}
  91
  92 protected:
  93
  94         // Attempt to enter the traffic pattern in a reasonably intelligent manner
  95         void EnterTrafficPattern(double dt);
  96
  97         // Set up the internal state to be consistent for a downwind entry.
  98         void DownwindEntry();
  99
 100         // Ditto for straight-in
 101         void StraightInEntry(bool des = false);
 102
 103         // Do what is necessary to land and parkup at home airport
 104         void ReturnToBase(double dt);
 105
 106         // Airport/runway/pattern details
 107         string airportID;       // The ICAO code of the airport that we're operating around
 108         double aptElev;         // Airport elevation
 109         FGGround* ground;       // A pointer to the ground control.
 110         FGTower* tower; // A pointer to the tower control.
 111         bool _controlled;       // Set true if we find tower control working for the airport, false otherwise.
 112         RunwayDetails rwy;
 113         double patternDirection;        // 1 for right, -1 for left (This is double because we multiply/divide turn rates
 114         // with it to get RH/LH turns - DON'T convert it to int under ANY circumstances!!
 115         double glideAngle;              // Assumed to be visual glidepath angle for FGAILocalTraffic - can be found at www.airnav.com
 116         // Its conceivable that patternDirection and glidePath could be moved into the RunwayDetails structure.
 117
 118         // Its possible that this might be moved out to the ground/airport class at some point.
 119         FGATCAlignedProjection ortho;   // Orthogonal mapping of the local area with the threshold at the origin
 120         // and the runway aligned with the y axis.
 121
 122         void GetAirportDetails(const string& id);
 123
 124         void GetRwyDetails(const string& id);
 125
 126         double responseCounter;         // timer in seconds to allow response to requests to be a little while after them
 127         // Will almost certainly get moved to FGAIPlane.
 128
 129 private:
 130         FGATCMgr* ATC;
 131         // This is purely for synactic convienience to avoid writing globals->get_ATC_mgr()-> all through the code!
 132
 133         // High-level stuff
 134         OperatingState operatingState;
 135         int circuitsToFly;      //Number of circuits still to do in this session NOT INCLUDING THE CURRENT ONE
 136         bool touchAndGo;        //True if circuits should be flown touch and go, false for full stop
 137         bool transmitted;       // Set true when a position report for the current leg has been transmitted.
 138
 139         // Performance characteristics of the plane in knots and ft/min - some of this might get moved out into FGAIPlane
 140         double Vr;
 141         double best_rate_of_climb_speed;
 142         double best_rate_of_climb;
 143         double nominal_climb_speed;
 144         double nominal_climb_rate;
 145         double nominal_circuit_speed;
 146         double min_circuit_speed;
 147         double max_circuit_speed;
 148         double nominal_descent_rate;
 149         double nominal_approach_speed;
 150         double nominal_final_speed;
 151         double stall_speed_landing_config;
 152         double nominal_taxi_speed;
 153
 154         // Physical/rendering stuff
 155         double wheelOffset;             // Height above ground at which we need to render the plane whilst taxiing
 156         bool elevInitGood;              // We have had at least one good elev reading
 157         bool inAir;                             // True when off the ground
 158
 159         // environment - some of this might get moved into FGAIPlane
 160         SGPropertyNode* wind_from_hdg;  //degrees
 161         SGPropertyNode* wind_speed_knots;               //knots
 162
 163         // Pattern details that (may) change
 164         int numInPattern;               // Number of planes in the pattern (this might get more complicated if high performance GA aircraft fly a higher pattern eventually)
 165         int numAhead;           // More importantly - how many of them are ahead of us?
 166         double distToNext;              // And even more importantly, how near are we getting to the one immediately ahead?
 167         //PatternLeg leg;               // Our current position in the pattern - now moved to FGAIPlane
 168         StartOfDescent SoD;             // Start of descent calculated wrt wind, pattern size & altitude, glideslope etc
 169         bool descending;                // We're in the coming down phase of the pattern
 170         double targetDescentRate;       // m/s
 171
 172         // Taxiing details
 173         // At the moment this assumes that all taxiing in is to gates (a loose term that includes
 174         // any permitted parking spot) and that all taxiing out is to runways.
 175         bool parked;
 176         bool taxiing;
 177         bool taxiRequestPending;
 178         bool taxiRequestCleared;
 179         TaxiState taxiState;
 180         double desiredTaxiHeading;
 181         double taxiTurnRadius;
 182         double nominalTaxiSpeed;
 183         Gate* ourGate;
 184         ground_network_path_type path;  // a path through the ground network for the plane to taxi
 185         unsigned int taxiPathPos;       // position of iterator in taxi path when applicable
 186         node* nextTaxiNode;     // next node in taxi path
 187         node* holdShortNode;
 188         //Runway out_dest; //FIXME - implement this
 189         bool holdingShort;
 190         bool reportReadyForDeparture;   // set true when ATC has requested that the plane report when ready for departure
 191         bool clearedToLineUp;
 192         bool clearedToTakeOff;
 193         bool _clearedToLand;    // also implies cleared for the option.
 194         bool liningUp;  // Set true when the turn onto the runway heading is commenced when taxiing out
 195         bool goAround;  // Set true if need to go-around
 196         bool goAroundCalled;    // Set true during go-around only after we have called our go-around on the radio
 197         bool contactTower;      // we have been told to contact tower
 198         bool contactGround;     // we have been told to contact ground
 199         bool changeFreq;        // true when we need to change frequency
 200         bool _taxiToGA;         // Temporary mega-hack indicating we are to taxi to the GA parking and disconnect from tower control.
 201         bool _removeSelf;       // Indicates that we wish to remove this instance.  The use of a variable is a hack to allow time for messages to purge before removal, due to the fagility of the current dialog system.
 202         atc_type changeFreqType;        // the service we need to change to
 203         bool freeTaxi;  // False if the airport has a facilities file with a logical taxi network defined, true if we need to calculate our own taxiing points.
 204
 205         // Hack for getting close to the runway when atan can go pear-shaped
 206         double _savedSlope;
 207
 208         void FlyTrafficPattern(double dt);
 209
 210         // TODO - need to add something to define what option we are flying - Touch and go / Stop and go / Landing properly / others?
 211
 212         void TransmitPatternPositionReport();
 213
 214         void CalculateSoD(double base_leg_pos, double downwind_leg_pos, bool pattern_direction);
 215
 216         void ExitRunway(const Point3D& orthopos);
 217
 218         void StartTaxi();
 219
 220         void Taxi(double dt);
 221
 222         void GetNextTaxiNode();
 223
 224         void DoGroundElev();
 225
 226         // Set when the plane should be invisible *regardless of distance from user*.
 227         bool _invisible;
 228 };
 229
 230 #endif  // _FG_AILocalTraffic_HXX