Spawn Pilot (Transversal)

SPAWN PILOT (TRANSVERSAL)

When creating your aircraft for Microsoft Flight Simulator 2024 there is one navigation service that will be used under all conditions and that is the one to spawn the aircraft pilot (also called the "Transversal" because it is required by all careers and even freeflight). Even if you do not include the necessary files for this, the simulation will use a "generic" spawn sequence for the pilot, however it's recommended that you create your own spawn file for each aircraft you make so that it's fully integrated into the simulation. Also note that this file must be included for your aircraft to be eligible for the various other Career Activities, and will always be used for Preflight regardless of the flight mode.

For an aircraft to correctly spawn the pilot (and - optionally - the copilot), you will need to have first set up the Navigation Graph for the aircraft. This graph must be called the following:

navigation_graph_pilot.cfg

If you only have one variation of your aircraft - or if the different variations have no impact on the spawning area of the pilot character - you can put this file in the Common folder of your aircraft. If it's specific to a particular Preset or Attachment, you should put it in the corresponding folder. For example, you might want to spawn in a different location if the same aircraft has classic wheels or if it's using larger amphibious landing gear. In these cases you can supply a common version of the file with only the shared nodes, and then in the presets supply another version of the file with the unique nodes for the variation and they will be merged as part of the merge process.

The Default Pilot Navigation Graph

Before going into detail about how to set up your own pilot navigation graph it's important to talk about the default pilot graph that is added to all aircraft in the simulation. This file is added to ensure backwards compatibility for Microsoft Flight Simulator 2020 aircraft, and will be applied to all aircraft in the following way:

The default pilot navigation graph is loaded.
If there is a custom pilot navigation graph for the aircraft this is then loaded, but not applied.
The simulation will then parse the custom navigation graph nodes looking for nodes with the same tags as those found in the default graph.
If two nodes with the same tags are found, the data of the second node will replace the data of the first one.
The final merged file is applied.

For example, say we have this in the default pilot navigation graph:

[Node.0]
tag = PILOT
pos = 0,2,3
rot = 0,0,90
interactiveObject = DEFAULT_SEAT

But in the pilot navigation graph included with the aircraft we have this:

[Node.3]
tag = PILOT
pos = 1,0.5,0
interactiveObject = SPECIFIC_SEAT

After the merge process has finished there will be one pilot navigation graph that has this:

[Node.x]
tag = PILOT
pos = 1,0.5,0
rot = 0,0,90
interactiveObject = SPECIFIC_SEAT

The default navigation graph has the following nodes which will need to be overridden in your aircraft pilot navigation graph:

SPAWN_EXTERIOR - Exterior spawn point for the pilot avatar.

SPAWN_EXTERIOR_RTC - Exterior spawn point for the pilot used for RTC events.

PILOT_SEAT - This is where the seat logic object will be spawned, which has it's own navigation graph with the PILOT node. The seat logic object is a SimObject that has no model associated with it, but will simply spawn a default seat-belt SimObject and generate interactions using Interaction XML. The exact series of events for this are as follows:
- The PILOT_SEAT node has the interactiveObject parameter which will spawn the SEAT_DEFAULT_Pilot SimObject (this name comes from the title parameter given in the sim.cfg file of the SimObject).
- The SEAT_DEFAULT_Pilot SimObject is a logic object and contains no model, only a navigation graph file - navigation_graph_seat_pilot.cfg.
- The navigation_graph_seat_pilot.cfg contains the PILOT node, and also references a couple of Interaction Presets: Seat_pilot_enter and Seat_pilot_exit. These presets control the interaction between the user pilot avatar and the entry/exit of the aircraft, and do not trigger any aircraft animations, simply "teleporting" the pilot avatar inside/outside when an interaction is detected. It is worth noting that the PILOT node will also use the modelNode parameter with PILOT_0 for the node name. This is to position the pilot avatar correctly on the seats, since legacy aircraft had the root node positioned on the avatar waist, not the feet, and should have a PILOT_0 (and PILOT_1 for copilot) node in the model glTF. The legacy node position is illustrated in the following image:

These nodes are explained in more detail below, but be aware that it is recommended that you override these nodes in your aircraft pilot navigation graph since these are not meant to be used except for legacy aircraft and initial testing of Microsoft Flight Simulator 2024 aircraft. This is because the placement of the nodes may not match that of your own aircraft and will potentially spawn objects that cause issues with your own aircraft attachments and interactions.

The Pilot Navigation Graph

Within the pilot navigation graph (navigation_graph_pilot.cfg) for your aircraft you will need to have the following tagged nodes to be able to override the default pilot graph, which is recommended:

SPAWN_EXTERIOR
A single node that defines where the pilot avatar will spawn when starting a freeflight or when leaving the aircraft. This node should be placed on the ground (you can use the projectOnGround parameter for this) close to the aircraft to ensure that the pilot spawns correctly.
- SPAWN_EXTERIOR_*
  This is an optional node that may be used to spawn the pilot avatar somewhere else, depending on the interactions that have been setup for entering/exiting the aircraft. Normally this is used for aircraft that have left and right doors, both of which can be opened, so - for example - you would have SPAWN_EXTERIOR on the left of the aircraft, and SPAWN_EXTERIOR_SECOND on the right, but you can set up multiple additional spawn points if required and then reference them individually in the interaction file.

SPAWN_EXTERIOR_RTC
This is a single node which is used at the end of the RTC walking event - or, when this RTC doesn't exist - to spawn the pilot into the world when on a career activity or any other flight except freeflight. This node should be about 2 meters from the nose of the aircraft and the character animation for the pilot will start approximately 4m away from this node (see the image in the Calculating Career / RTC Spawn Position section)

SEAT_PILOT
This node is required if you wish to overwrite the default pilot navigation graph. To overwrite the node you will need to add this node into your custom pilot navigation graph, and then you have two choices:
- set the interactiveObject parameter to "NONE" and add the PILOT node into the same navigation graph file (navigation_graph_pilot.cfg) as the other nodes for spawning. This file will also need to include references to the correct interaction files for entering and exiting the aircraft (and optionally interacting with the seatbelt).
- set the interactiveObject parameter to the title of the SimObject that you have created to be a part of the cockpit and that contains the relevant PILOT node and interactions (this object must be part of the aircraft package). This means the navigation_graph_pilot.cfg does not need the PILOT node, nor anything else related to interactions as this should be in the navigation graph included with the spawned interactive object. For example, you could create a seat SimObject, and in the seat have a navigation graph that contains the PILOT node and interactions, and then spawn the seat SimObject on the SEAT_PILOT node and let the seat attachment deal with pilot position, seat-belts, and interactions.

PILOT
This node marks where the pilot will be sitting in the aircraft. The node is normally placed at the position where the pilot avatars feet will go, as shown in the following image:

Where this node is created will depend on the SEAT_PILOT node setup, but it does not have to be on the same navigation graph as the other navigation_graph_pilot.cfg nodes, as long as it is in a navigation_graph_pilot.cfg created somewhere as part of the modular aircraft creation, or in a different navigation CFG that was part of the seat SimObject package. Basically, as long as a node with the PILOT tag exists when a flight is started, then it will be detected and used for the pilot. This node will also need to setup certain interactions - as explained in the Interactions section below - as well as have a mass section assigned to it, as explained here: Weight Distribution. Note that if you do not have a PILOT_0 node in the seat or interior glTF, or wish to use the pos parameter to position the node, you will have to include the modelNode parameter and either:
- Set it to "NONE" to override the default value and use the pos to position the node
- Set it to the actual name of the node where you wish to position the pilots feet.

COPILOT
This optional node marks where the copilot will be sitting in the aircraft. This node may or may not be used depending on the criteria of the career activity or chosen flight mode. As with the PILOT node this should be placed where the copilot's feet should be positioned, and can be in another graph on an attachment or in a preset. As long as a node with the COILOT tag exists when a flight is started - and the aircraft.cfg has been setup correctly - then it will be detected and used (if appropriate for the flight/activity). For the aircraft.cfg you will need to set up the [PILOT] section as follows:
```
[PILOT]
cabin_service = CopilotService
generated_copilot = Copilot
copilot_behavior = COPILOT
```
For some careers this node can serve a dual purpose, since it can seat a passenger instead of a copilot. For this to be available the node should also have the SIT tag, and the sharedSeat parameter should be set to true, eg:
```
[Node.1]
pos = 0, 0, 0
tag = COPILOT,SIT
sharedSeat = true
```
NOTE: You will also need to ensure that the Passengers navigation graph is set up to use this node if you want NPC's other than the copilot to sit on it.As with the PILOT, if you do not have a PILOT_1 node in the seat or interior glTF, or wish to use the pos parameter to position the node, you will have to include the modelNode parameter and either:
- Set it to "NONE" to override the default value and use the pos to position the node
- Set it to the actual name of the node where you wish to position the copilots feet.
This node will also need to setup certain interactions - as explained in the Interactions section below - as well as have a mass section assigned to it, as explained here: Weight Distribution.

Interactions

Both of the nodes PILOT and COPILOT will require the use of Interaction XML to deal with certain animations and interactions that the pilot / copilot /passenger character models can perform. You can create this yourself, however it is strongly recommended that you use the Interaction Presets instead and simply ensure that you have setup your animations and objects correctly work with these presets. The rest of this section is dedicated to setup of each node to use the relevant supplied presets.

Pilot Interactions

The PILOT node needs to deal with moving the pilot avatar inside/outside the aircraft and interacting with the door objects (where applicable and depending on the aircraft). It also has to optionally deal with the seatbelts if the aircraft has been setup with any. The simulation has several Interaction Presets that can be used in the interactionFile.n parameter of the pilot navigation graph and we recommend that you use these presets to set up your own aircraft unless you require something particularly specialised.

The setup for these interaction presets is as follows for entering / exiting the aircraft (seatbelt interactions are explained in the Seatbelt Interactions section):

If the aircraft has no animated doors - use the presets Seat_pilot_enter.xml / Seat_pilot_exit.xml. The setup for the navigation graph PILOT node to use these interactions would be something like this:

[Node.1]
pos = 0,0,0
tag = PILOT
interactionFile.0 = FilePath: InteractionsPreset\Asobo\Seat\Seat_pilot_enter #Param: INTERACTION_NAME:SIT_REMOTELY , VARIABLE_TRIGGER:ENTER_AIRCRAFT , ANIMATION_SIT:IDLES_Leaned
interactionFile.1 = FilePath: InteractionsPreset\Asobo\Seat\Seat_pilot_exit #Param: INTERACTION_NAME:EXIT_REMOTELY , VARIABLE_TRIGGER:EXIT_AIRCRAFT , TAG_TELEPORT:SPAWN_EXTERIOR

If the aircraft has animated doors - use the presets Seat_pilot_open_enter.xml / Seat_pilot_open_exit.xml. The setup for the navigation graph PILOT node to use these interactions would be something like this:

[Node.1]
pos = 0, 0, 0
tag = PILOT
interactionFile.0 = FilePath:InteractionsPreset\Asobo\Seat\Seat_pilot_open_enter #Param:INTERACTION_NAME:SIT_REMOTELY, VARIABLE_TRIGGER:ENTER_AIRCRAFT, ANIMATION_SIT:IDLES_Leaned, ANIMATION_GET:INTERACTIVE POINT OPEN:'DoorFrontLeft'_n, ANIMATION_SET:INTERACTIVE POINT GOAL:'DoorFrontLeft'_n
interactionFile.1 = FilePath:InteractionsPreset\Asobo\Seat\Seat_pilot_open_exit #Param:INTERACTION_NAME:EXIT_REMOTELY, VARIABLE_TRIGGER:EXIT_AIRCRAFT, TAG_TELEPORT:SPAWN_EXTERIOR, ANIMATION_GET:INTERACTIVE POINT OPEN:'DoorFrontLeft'_n, ANIMATION_SET:INTERACTIVE POINT GOAL:'DoorFrontLeft'_n

Copilot Interactions

The COPILOT node needs to deal with having a copilot (or optional passenger) sit on the copilot seat. It can also optionally deal with the seatbelts if the aircraft has been setup with any. The simulation has several Interaction Presets that can be used in the interactionFile.n parameter of the copilot navigation graph and we recommend that you use these presets to set up your own aircraft unless you require something particularly specialised.

If the COPILOT node does not require seatbelts then the only interaction file you need to add is the following (seatbelt interactions are explained in the Seatbelt Interactions section):

For the copilot to use a seat with no seatbelt you need the Seat_without_seatbelt.xml interaction file. The setup for the navigation graph COPILOT node to use this interaction would be something like this:
```
[Node.1]
pos = 0,0,0
tag = COPILOT,SIT
sharedSeat = True
interactionFile.0 = FilePath: InteractionsPreset\Asobo\Seat\Seat_without_seatbelt #Param: ANIMATION_SIT:IDLES_Leaned 
```

Seatbelt Interactions

Both the PILOT and COPILOT node are used for seating the pilot avatar or copilot generated character. If the seats of the aircraft have seatbelts, then both these nodes will need to have additional interactions defined in the interactionFile.n parameter for their node. We strongly recommend that you use the following included Interaction Presets to set up the seatbelt interactions:

Seat_with_seatbelt.xml - This preset is used to set the animation to use while the character is on the seat. You can find a list of available poses in the Avatar / NPC Animation Presets section of the documentation. Note that the PILOT node does not need to use this interaction as the sitting animation is defined in the aircraft enter preset.
Seatbelt.xml - This preset is used to spawn the seatbelt SimObjects that contain the seatbelt models along with the fasten/unfasten animations.

IMPORTANT! For seatbelts to work, they must have been setup as outlined on the Seats And Seatbelts page, and both the above interaction presets need to be included on each of the nodes that require seatbelts, except for the PILOT node.

Here is an example of a PILOT node which has been correctly setup to use seatbelts:

[Node.0]
pos = 0, 0, 0
tag = PILOT
interactionFile.0 = FilePath:InteractionsPreset\Asobo\Seat\Seat_pilot_open_enter #Param:INTERACTION_NAME:SIT_REMOTELY, VARIABLE_TRIGGER:ENTER_AIRCRAFT, ANIMATION_SIT:IDLES_Leaned,ANIMATION_GET:INTERACTIVE POINT OPEN:'DoorFrontLeft'_n, ANIMATION_SET:INTERACTIVE POINT GOAL:'DoorFrontLeft'_n
interactionFile.1 = FilePath:InteractionsPreset\Asobo\Seat\Seatbelt #Param: SEATBELT_FASTEN:SEATBELT_DA62_Pilot_Fasten , SEATBELT_UNFASTEN:SEATBELT_DA62_Pilot_Unfasten

Here is an example of a COPILOT node which has been correctly setup to use seatbelts:

[Node.1]
pos = 0, 0, 0
tag = COPILOT,DIRECTOR,SIT
sharedSeat = True
interactionFile.0 = FilePath: InteractionsPreset\Asobo\Seat\Seat_with_seatbelt #Param: ANIMATION_SIT:IDLES_Leaned
interactionFile.1 = FilePath: InteractionsPreset\Asobo\Seat\Seatbelt #Param: SEATBELT_FASTEN:SEATBELT_DA62_Copilot_Fasten , SEATBELT_UNFASTEN:SEATBELT_DA62_Copilot_Unfasten

Weight Distribution

For the pilot (and copilot) weight to be included in the simulation and contribute to the overall weight of the aircraft, you will need to configure a station_load.N section (found in the flight_model.cfg) for each of them. When creating the stations, the weight input for the station load should be set to 0, as it will be modified by the pilot and copilot themselves in the simulation to reflect the actual weight being distributed in the area. The X/Y/Z position should be in the approximate center of each of the seats for the pilot and copilot.

Having created the station loads, they will need to be assigned to Mass Sections, which are created in the Navigation Graph. Each mass section should have a name that represents the station it is assigned to (pilot/copilot), and its fill proportion should be set to 1. When it comes to the maximum mass, the average weight per-person would be approximately 85kg, so setting the max weight to this or a little more should give a decent starting point for the weight calculations.

Once the mass sections have been set up, they will need to be added into the Main Graph section of the navigation graph, and it will also need to be added to the Mass Section parameter for the PILOT node (and COPILOT node if required).

Calculating Career / RTC Spawn Position

When it comes to calculating the position of the SPAWN_EXTERIOR_RTC node, it can be a little difficult to know exactly where around the aircraft it should be placed. The general rule is that the SPAWN_EXTERIOR_RTC node should be about 2m from the aircraft, since the RTC camera will follow the pilot as it walks to the node (and this walk will be over the space of approximately 4m) and then end on reaching the node. You can place the node "by eye", but it's better not to leave things to chance and so the best way to calculate the position is as follows:

Calculating Preflight RTC/Career Spawn Nodes

The node needs to be placed relative to the Datum Reference Point point, which is the (0, 0, 0) position. Knowing the length of the aircraft and the position of the datum means you can calculate where the nose of the aircraft is. From there you can add a 2m "buffer zone" (which is required in case the model isn't exactly where you'd expect it to be), and then place the SPAWN_EXTERIOR_RTC. Note that the node doesn't have to fall directly in front of the aircraft, and can be placed approximately anywhere around the marked circle, as long as the walk animation does not cross any part of the aircraft (for example, you can't place it such that the animation would walk through the aircraft wing).