Fixes up new MSFS approach format parsing

src/fs/bgl/ap/approachleg.cpp

@@ -63,33 +63,36 @@ ApproachLeg::ApproachLeg(io::BinaryStream *bs, rec::ApprRecordType recType)
   altitude2 = bs->readFloat();
 
   // Determine type by using record id =============================
-  // MSFS SID STAR records before and after 1.16.1
-  bool msfsSidStar = recType == rec::RUNWAY_TRANSITIONS_MSFS || recType == rec::COMMON_ROUTE_LEGS_MSFS ||
-                     recType == rec::ENROUTE_TRANSITIONS_MSFS;
-
   // New MSFS records since 1.16.1 ======
-  bool msfsNew = recType == rec::LEGS_MSFS_NEW || recType == rec::MISSED_LEGS_MSFS_NEW ||
-                 recType == rec::TRANSITION_LEGS_MSFS_NEW || recType == rec::COMMON_ROUTE_LEGS_MSFS_NEW ||
-                 recType == rec::ENROUTE_TRANSITIONS_MSFS_NEW || msfsSidStar;
+  bool msfsNew = recType == rec::LEGS_MSFS_NEW ||
+                 recType == rec::MISSED_LEGS_MSFS_NEW ||
+                 recType == rec::TRANSITION_LEGS_MSFS_NEW ||
+                 recType == rec::RUNWAY_TRANSITION_LEGS_MSFS_NEW ||
+                 recType == rec::COMMON_ROUTE_LEGS_MSFS_NEW ||
+                 recType == rec::ENROUTE_TRANSITION_LEGS_MSFS_NEW;
 
   // Common MSFS records
-  bool msfs = recType == rec::LEGS_MSFS || recType == rec::MISSED_LEGS_MSFS || recType == rec::TRANSITION_LEGS_MSFS ||
-              msfsNew || msfsSidStar;
+  bool msfs = msfsNew ||
+              recType == rec::LEGS_MSFS ||
+              recType == rec::MISSED_LEGS_MSFS ||
+              recType == rec::TRANSITION_LEGS_MSFS ||
+              recType == rec::RUNWAY_TRANSITION_LEGS_MSFS ||
+              recType == rec::COMMON_ROUTE_LEGS_MSFS ||
+              recType == rec::ENROUTE_TRANSITION_LEGS_MSFS;
 
   if(msfs)
   {
     // Not type given - assuming max speed
     speedLimit = bs->readFloat();
     bs->readFloat(); // verticalAngle - ignored for now
+    bs->skip(8); // unknown
 
     if(msfsNew)
     {
       // New MSFS structure
       // Check for constant radius turn legs - these need the center point in the recommended fix
       if(type == leg::RF)
       {
-        bs->skip(8);
-
         // if(!recommendedFixIdent.isEmpty())
         // qWarning() << Q_FUNC_INFO << "Recommended fix overlap in RF leg"
         // << recommendedFixIdent << "/" << recommendedFixRegion;
@@ -105,11 +108,8 @@ ApproachLeg::ApproachLeg(io::BinaryStream *bs, rec::ApprRecordType recType)
       }
       else
         // Skip center fix data
-        bs->skip(16);
+        bs->skip(8);
     }
-    else
-      // Old MSFS structure
-      bs->skip(8);
   }
 }
 

src/fs/bgl/ap/sidstar.cpp

@@ -80,6 +80,9 @@ SidStar::SidStar(const NavDatabaseOptions *options, BinaryStream *bs)
            * The common route legs are similar to the base of an approach, except
            * these will be combined with each runway transition leg set to produce
            * an individual STAR (or SID?)
+           *
+           * NOTE: Unlike enroute and runway transitions, these legs are direct
+           * children of the procedure!
            */
           int numLegs = bs->readUShort();
           for(int i = 0; i < numLegs; i++)
@@ -105,56 +108,54 @@ SidStar::SidStar(const NavDatabaseOptions *options, BinaryStream *bs)
           Record legRec(options, bs);
           int numLegs = bs->readUShort();
           for(int i = 0; i < numLegs; i++)
-          {
-            qint64 pos = bs->tellg();
-            ApproachLeg leg(bs, recType);
-
-            // Have to apply a hack here and check if the leg is valid - move back 8 bytes and read again if not
-            // These legs have different sizes without any apparent indication
-            if(i > 0 && !leg.isValid())
-            {
-              // Go back and read again
-              bs->seekg(pos - 8);
-              leg = ApproachLeg(bs, recType);
-            }
+            legs.append(ApproachLeg(bs, legRec.getId<rec::ApprRecordType>()));
 
-            // Approach will be filtered out later if invalid
-            legs.append(leg);
-          }
           /* And finally, we'll add it to our hash of runways. */
           runwayTransitionLegs.insert(runwayName, legs);
         }
         break;
 
       case rec::ENROUTE_TRANSITIONS_MSFS:
+      case rec::ENROUTE_TRANSITIONS_MSFS_NEW:
         {
           /*
            * These are effectively the transitions for a SID/STAR. The normal Transition
            * class does quite understand these though...
            * Either we fix that, or modify the database writer... yuck.
            */
+          QString name;
           (void)bs->readUByte(); /* transitionCt */
           bs->skip(1); /* unknown byte, usually zero */
+          if(rec::ENROUTE_TRANSITIONS_MSFS_NEW == recType)
+          {
+            name = bs->readString(8, atools::io::UTF8);
+          }
           /* Create a container for the transition legs */
           QList<ApproachLeg> legs;
           /* This will always be followed by 1 ENROUTE_TRANSITION_LEGS_MSFS record */
           Record legRec(options, bs);
           int numLegs = bs->readUShort();
           for(int i = 0; i < numLegs; i++)
-            legs.append(ApproachLeg(bs, recType));
-          insertEnrouteTransition(legs);
-        }
-        break;
+            legs.append(ApproachLeg(bs, legRec.getId<rec::ApprRecordType>()));
 
-      case rec::ENROUTE_TRANSITIONS_MSFS_NEW:
-        // Same as above
-        {
-          QList<atools::fs::bgl::ApproachLeg> legs;
-          int numLegs = bs->readUShort();
-          bs->skip(16); // Name (8) and unknown
-          for(int i = 0; i < numLegs; i++)
-            legs.append(ApproachLeg(bs, recType));
-          insertEnrouteTransition(legs);
+          if(rec::ENROUTE_TRANSITIONS_MSFS_NEW != recType)
+          {
+            /* Now to figure out the "key" for this transition... */
+            if(rec::MSFS_SID == id)
+            {
+              /* For SID, the transition ident is the LAST leg's fix. */
+              name = legs.last().getFixIdent();
+            }
+            else if(rec::MSFS_STAR == id)
+            {
+              /* For STAR, the transition ident is the FIRST leg's fix */
+              name = legs.first().getFixIdent();
+            }
+          }
+          if(!legs.isEmpty())
+            enrouteTransitions.insert(name, legs);
+          else
+            qWarning() << Q_FUNC_INFO << "No enroute transition found" << getDescription();
         }
         break;
 
@@ -172,27 +173,6 @@ SidStar::~SidStar()
 {
 }
 
-void SidStar::insertEnrouteTransition(const QList<ApproachLeg>& legs)
-{
-  if(!legs.isEmpty())
-  {
-    /* Now to figure out the "key" for this transition... */
-    if(rec::MSFS_SID == id)
-    {
-      /* For SID, the transition ident is the LAST leg's fix. */
-      enrouteTransitions.insert(legs.last().getFixIdent(), legs);
-    }
-    else if(rec::MSFS_STAR == id)
-    {
-      /* For STAR, the transition ident is the FIRST leg's fix */
-      enrouteTransitions.insert(legs.first().getFixIdent(), legs);
-    }
-  }
-  else
-    qWarning() << Q_FUNC_INFO << "No enroute transition found" << getDescription();
-
-}
-
 QDebug operator<<(QDebug out, const SidStar& record)
 {
   QDebugStateSaver saver(out);

src/fs/bgl/ap/sidstar.h

@@ -74,7 +74,6 @@ class SidStar :
 
 private:
   friend QDebug operator<<(QDebug out, const atools::fs::bgl::SidStar& record);
-  void insertEnrouteTransition(const QList<ApproachLeg>& legs);
 
   QList<atools::fs::bgl::ApproachLeg> commonRouteLegs;
   QHash<QString, QList<atools::fs::bgl::ApproachLeg> > enrouteTransitions;

src/fs/bgl/recordtypes.cpp

@@ -342,12 +342,6 @@ QString approachRecordTypeStr(rec::ApprRecordType type)
 {
   switch(type)
   {
-    case rec::ENROUTE_TRANSITIONS_MSFS_NEW:
-      return "ENROUTE_TRANSITIONS_MSFS_NEW";
-
-    case rec::COMMON_ROUTE_LEGS_MSFS_NEW:
-      return "COMMON_ROUTE_LEGS_MSFS_NEW";
-
     case rec::LEGS:
       return "LEGS";
 
@@ -389,14 +383,23 @@ QString approachRecordTypeStr(rec::ApprRecordType type)
     case rec::ENROUTE_TRANSITIONS_MSFS:
       return "ENROUTE_TRANSITIONS_MSFS";
 
+    case rec::ENROUTE_TRANSITIONS_MSFS_NEW:
+      return "ENROUTE_TRANSITIONS_MSFS_NEW";
+
     case rec::RUNWAY_TRANSITION_LEGS_MSFS:
       return "RUNWAY_TRANSITION_LEGS_MSFS";
 
     case rec::COMMON_ROUTE_LEGS_MSFS:
       return "COMMON_ROUTE_LEGS_MSFS";
 
+    case rec::COMMON_ROUTE_LEGS_MSFS_NEW:
+      return "COMMON_ROUTE_LEGS_MSFS_NEW";
+
     case rec::ENROUTE_TRANSITION_LEGS_MSFS:
       return "ENROUTE_TRANSITION_LEGS_MSFS";
+
+    case rec::ENROUTE_TRANSITION_LEGS_MSFS_NEW:
+      return "ENROUTE_TRANSITION_LEGS_MSFS_NEW";
   }
   qWarning().nospace().noquote() << "Invalid approach record type " << type;
   return "INVALID";

src/fs/bgl/recordtypes.h

@@ -152,16 +152,18 @@ enum ApprRecordType
 
   /* MSFS SID and STAR */
   RUNWAY_TRANSITIONS_MSFS = 0x0046,
+
   ENROUTE_TRANSITIONS_MSFS = 0x0047,
+  ENROUTE_TRANSITIONS_MSFS_NEW = 0x004a,
 
   RUNWAY_TRANSITION_LEGS_MSFS = 0x00e4,
-  COMMON_ROUTE_LEGS_MSFS = 0x00e5,
-  ENROUTE_TRANSITION_LEGS_MSFS = 0x00e6,
+  RUNWAY_TRANSITION_LEGS_MSFS_NEW = 0x00ef,
 
-  /* New types for SID and STAR */
-  ENROUTE_TRANSITIONS_MSFS_NEW = 0x004a,
-  COMMON_ROUTE_LEGS_MSFS_NEW = 0x00f0
+  COMMON_ROUTE_LEGS_MSFS = 0x00e5,
+  COMMON_ROUTE_LEGS_MSFS_NEW = 0x00f0,
 
+  ENROUTE_TRANSITION_LEGS_MSFS = 0x00e6,
+  ENROUTE_TRANSITION_LEGS_MSFS_NEW = 0x00f1
 };
 
 QString approachRecordTypeStr(ApprRecordType type);