JoyPro2 Discord GitHub
Reference

Relations page: search, tick, add (and the JoyPro assistant)

Show:

From docs/relation-builder.md in the repository (generated, always the current text).

A relation is one function, for example "Throttle ALL". It holds that function's action in every game and aircraft (DCS F-16C "Thrust", IL-2 "Engines throttle control", Star Citizen "Strafe forward / backward" ...), all on one input of the stick. The Relations page builds it the way JoyPro 1 did: name it, search what it does over every game, tick what belongs, add. On top of that JoyPro suggests what else means the same, and the JoyPro assistant does it from a sentence. Binding the relation to a button or axis happens on the Binds page.

The Relations page with an open relation

#The page

  • Left: the relations (search, the filter bar, Ctrl/Shift for several, Bulk changes, Groups). Each card shows its bind as device, input and modifiers: WarBRD · BTN 8 · Shift A (the tooltip has the full device name); not bound when it has none.
  • Top right: New relation ("Name it, then tick its actions.") and Auto-build relations from all my actions... ("Builds relations for the whole profile: the same function of every aircraft and game together"), More (refresh, import/export, next relation with suggestions, save).
  • The open relation: its name in a text box (edit in place: Enter or leaving the box renames, Esc cancels; engine relations rename), its kind (Axis / Button), its input (or Not bound yet: Binds page), the function chip (see The function chip), Suggest missing (n), Expand with AI, Duplicate (a menu: Duplicate, Duplicate without bind = relations mass duplicate --no-bind), delete; the row wraps in a narrow window. Below, Its actions: one row per game action with the game badge, the aircraft, the title and the kind, x removes it after "Remove this action?" (with Do not ask again; Settings > Confirmations asks again). A click on a DCS action opens its aircraft (below).
  • Order of the actions: drag a card by its grip (a line shows where it lands), or Alt+Up / Alt+Down, or the card's context menu (Move up / down / to the top / to the bottom). The engine keeps the order in the profile (relations item move <relation> --node game:id --to <position>|--up|--down), one undo step per move.
  • Relation card context menu (right-click in the list): Duplicate, Duplicate without bind, Delete.
  • Many actions at once: Add selected and Add all send one engine call; single Add / Dismiss clicks in a row are sent together (one call per batch, one reload at the end). Outdated background reads (suggestions, search, aircraft of a relation that changed again) are dropped instead of queued.
  • No relation open: "Pick a relation or make one" and the four steps; they show only then (never over a relation's actions). A refresh of the relation list (after an edit, an undo, a save) keeps the open relation open; when it leaves the list (deleted, filtered out) its actions leave the editor with it.
  • Right, four panels: Add actions (with Open catalog next to the search), Suggested for this relation (n), Catalog, JoyPro assistant; More > Suggest missing for every relation... shows the review list there.

#The function chip

What the relation stands for in every aircraft and game, from the function catalog (engine/EngineRelationPurpose.cs, one rule for the chip, Suggest missing, AI fill and Auto Assign). A majority is not enough: many users keep relations per physical button position, like the real cockpit ("Throttle - Boat - Aft": Magic in the M-2000C, the RWR lights in the Viggen, flaps in the F-5E, the drag chute in the F-4E), and one function over all of that is wrong.

Chip When (relations suggest FunctionState)
Function: <name> (green) set (picked by the user), named (the relation is named after the function, Auto Group does so) or covered: at least 80 % of the switched-on actions the catalog knows are that function (a catalog substitute for it counts), and at least two of them (or its only action)
Different functions per aircraft mixed: the catalog knows its actions as different functions and none reaches 80 %. Tooltip: "This relation is a button position: each aircraft uses it for its own function"
Function: none cleared: the user picked "None"
Set function unknown: the catalog knows too little of it

A click opens a small picker: a catalog function of the relation's kind (with a search box), None: each aircraft uses it for its own function, and Automatic (only after a choice). Saved in the profile (Relation.Function: slot id, none, or empty = automatic; Ctrl+Z undoes it). CLI: relations function <relation> [--set <function>|--none|--auto], relations function --list [--axis|--button] [--query text].

A mixed or cleared relation gets no function-based suggestion: no catalog, style, function map or title suggestions (only the same DCS id in aircraft where it means the same, i.e. its variants); AI fill leaves it out (ButtonPositions in its result, "left to you"); Auto Assign places it without a function slot (the user's own layout first). The function map's meanings follow the same 80 % rule. Auto Group's learned style respects the user's choice (a set function claims the relation, none teaches nothing).

#Binds page: what the relation does

Under the selected row's header the Binds page shows a read-only peek at its relation (MainWindowViewModel.BindPeek.cs, relations show): What it does: n actions in m games, the actions grouped by game, each with its title, its aircraft count (a click shows the names) and axis / button, and Open in Relations (the relation editor with this relation). Hide / Show folds it; the state is remembered (list-preferences.json BindPeekOpen), folded it reads nothing.

A relation has one bind (device, input, modifiers, axis tuning); with the experimental setting "Several inputs per relation" it can have more, each with its own device, modifiers and tuning (multi-bind.md): the relation editor shows "+1" next to the bind chip.

#Filters (Relations and Binds pages)

Both pages have the same filter bar (ListFilterViewModel, Views/Controls/ListFilterBar.axaml), each with its own ticks, remembered in <settings>\list-preferences.json (the typed search is not remembered):

  • Search (Ctrl+F): every word somewhere in what the box next to it says (remembered per page with the ticks): Name + actions (default: the relation's name and the titles of its actions, from engine relations list --titles), Name, or Everything (also games, aircraft, groups, device, input and modifiers). Devices, games and aircraft are otherwise picked with their filters, so "throttle" does not list every relation bound on a device called "... Throttle". The best fits come first: the relation called as the search, then names starting with it, then names with every word, then relations found by their actions (each part in the page's sort). The Binds page works the same.
  • Groups: tick groups (several: any of them), No group for relations without one.
  • Games: tick a game for every relation with a switched-on action of it; open it (>) to tick only some of its aircraft (All / None act on the aircraft shown, so typing A-10 and All ticks every A-10 version). DCS ticked, None, then A-10A, A-10C and A-10C II: only relations with an action for those aircraft. Games with one list (IL-2, Star Citizen ...) have no aircraft.
  • Devices: the devices of the binds (two of the same model keep a part of their id).
  • Bound / Not bound and Axes / Buttons: switches (a second click switches back to all).
  • Sort (the button right of the filters, ListSortViewModel, Views/Controls/ListSortBar.axaml): sort levels in order, each a key and a direction (A to Z / Z to A), with up / down / remove, Add level and Name only. Keys: name, device (as shown, alias-aware), input (natural: axes X, Y, Z, RX, RY, RZ, sliders, then BTN 2 before BTN 10, then hats, then keys), axis / button, games, aircraft count, group, bound / not bound, modifiers (relations have no change date, so there is no "last changed"). Unbound rows go after the bound ones; equal rows go by name. No level = by name (the old order). Each list remembers its levels (list-preferences.json Sorts); it works on top of the filters and the search, Follow input and the selection stay.

The filters combine (all must fit). Every tick shows how many relations it would show with the other filters as they are; ticks that would show nothing are dimmed. Under the bar the active filters are chips with x, n of 524 shown and Clear all. Opening a relation the filters hide (a new relation, "Open" in a review, Next relation with suggestions) clears them. The relations are filter subjects built once per list, so a filter change is set lookups: on the user's profile with 524 relations and 3 300 actions a change takes a few milliseconds (the journey test checks < 300 ms).

On the Relations page the whole block (filters, bound / axes switches, chips, sort and the search scope box) folds up under Filters (2.6.0; at 1280x800 it took a third of the narrow pane's height). Folded, the line under the header says what is on: the active filters, the search scope when it is not "Name + actions", the sort when it is not by name, and n of 524 shown (No filters · 524 in all when nothing is on). Open / folded is remembered (list-preferences.json RelationFiltersOpen, open by default; MainWindowViewModel.RelationFilterPanel.cs).

#Browse the catalog

Open catalog (next to the search) or the Catalog tab: not what a search finds, but everything a game or an aircraft has (engine relations browse). Pick the game (the profile's games first) and, for DCS, the aircraft (the profile's first; the open relation's own aircraft is picked when it opens). The actions come in the game's own categories (DCS HOTAS, Landing gear panel ...; an action in "Control Stick; HOTAS" is in both); games without categories of their own are grouped by JoyPro's function categories ("Engine and power", "Weapons"). A category opens with a click, shows how many of its actions your relations use, and ticks all of its rows with its box. Each action shows in this relation, in '<relation>' and, when that relation is bound, bound: WarBRD · BTN 8. Only free hides what is used, the filter box opens the categories with a match. Ticked actions go in with Add selected (n) (or Create relation with n actions); a DCS action takes its ticked aircraft (the browsed one; its aircraft selector adds more with the same meaning). The open relation's kind decides what is listed (an axis relation: only axes). The list builds only the rows in view, so a filter or Open all on a big aircraft (the F-4E has 1635 actions) stays instant.

The filter (2.6.4, a user's RMFD OSB 20 on Falcon BMS: seven rows, all open and equal, by category, RMFD neither first nor marked, while relations search said name / Recommended for RMFD and related for the rest) keeps a row when:

  • its title has every word as typed (20 is in OSB-20), a word typed without the title's separator included (OSB20 and OSB-20 find OSB-20 and OSB 20, CatalogJoinedWord), or a DCS key of its title (cms_aft);
  • or its id has every word (KEY_AXIS_ELEVATOR_SET, d68), never some words in the title and the others in the id: OSB 3 on the F-16 is not OSB 1 because its id d3001... has a 3;
  • or its category's name has every word (the whole category);
  • or relations search (asked for the open list: game, aircraft, kind) lists it under section name or, with Same meaning on, function: thrust finds the throttles, RMFD OSB 20 DCS's Right MFD OSB 20.

Rows of section related are no hits: the Catalog's layout is the game's categories, with no place for a folded "Related" as in Add actions, and the filter is there to narrow the list. Only when nothing at all is a hit it lists them (as Add actions opens Related when nothing is above it, so the filter never ends empty while the search has something), and the status line says so ("no action has these words: related actions shown (1)"). Same meaning is the same remembered switch as in Add actions (the chip is in both, and in Settings > Relations): off, the status line says how many rows it hides ("7 with the same meaning hidden"), and no related row is listed.

While a filter text is on, Recommended follows the words: the chip is the search's own flag for that row, not the browse's best action per function, and no row has it until the search has answered (below three letters it never asks). Without a filter text it is the browse's again. Without a sort level the search's best rows and their categories come first (the recommended ones first of all); a sort level keeps its order.

Sort (the catalog and the search results have the same sort bar as the Relations and Binds lists, ListSortViewModel.ForActions, remembered as catalog / action-search): game, aircraft, category, title, axis / button, last updated (the date of the game's command list; DCS: of the aircraft's DB file). No level = their own order (the catalog by the game's categories, the search best matches first). A first level Category orders the catalog's categories, a first level Game the search's games; the other levels order the rows inside. The search still shows each game's best matches (Show n more loads the rest); the levels order what is shown.

Titles are never raw ids or lua keys. Every title shown (relation cards, bind peek, catalog, search, layout titles and cheat sheets, sync changes, describe-group proposals) goes through one resolver (engine/DcsCommandNames.cs, shared by the engine and the GUI): the DB title; a DCS localization key in it ("Input.SpitfireLFMkIX.pitch_minus", "29Fulcrum:Inp:...") takes DCS's English text (<DCS>\l10n\en\LC_MESSAGES\input.mo); else the title the profile stored for the node (relations show lists it as stored-title lines); else the same command in a sibling DB file (_easy, CW); else a readable form of the key ("Flaps 1"). A command no list and no profile names says "Command not in this aircraft's current list". See DCS "Command names". A key or id still finds the command (search, catalog filter): pitch_minus, flaps_1, Input.SpitfireLFMkIX.pitch_minus, 29Fulcrum:Inp:... or a DCS command id such as dnilp3007unilcd2vdnilvp-1vunil list it by its readable title (DcsCommandNames.KeyMatches: the stored key, or the keys DCS's English catalog has for the title).

Readable names outside DCS (engine/EngineReadableNames.cs). The game lists keep the game's ids (the integrations use them); catalog, search, suggestions and the relation editor show:

  • categories: a table per game where the game has group names of its own (MSFS contexts AIRCRAFT -> "Aircraft", BASIC_CONTROL_HELICOPTER -> "Basic controls: helicopter"; Elite ship_flight -> "Ship: flight"; Star Citizen action maps spaceship_movement -> "Flight: movement"; X-Plane FMS2 -> "FMS 2"; VTOL VR NumPad -> "Number pad"), else an id-like category as words (flight_controls -> "Flight controls", BMS 2.06 AUX COMM PANEL -> "2.06 Aux Comm Panel"); a readable one ("Helicopter and plane") stays as the game writes it;
  • titles: Star Citizen's own names from its global.ini (engine starcitizen labels builds DB\StarCitizen\labels.tsv from Data.p4k, read only, also after db refresh-starcitizen; without it v_strafe_up -> "Strafe up"); two controls with the same game name are told apart by their id ("Pitch" / "Pitch (mouse)"); MSFS 2020 lists with raw event names take MSFS 2024's menu name of the event, else the name made from the event; underscores, run-together words ("HeliBrakes" -> "Heli Brakes") and titles in capitals ("TOGGLE PUSHBACK") as words; abbreviations stay in capitals;
  • JoyPro's own action texts (engine/ActionTexts.cs, shared with the GUI): DB\Functions\ActionTexts\<GameId>.tsv (id<TAB>name<TAB>menu section<TAB>explanation, written for JoyPro, shipped). The name stands in for a title that is no words: empty, the id, the id in words ("Rb pitch") or a string-table key (IL-2 inprb_pitch -> "Mouse turret aim: up/down"); for IL-2 Korea it always wins (its own text is not readable). The menu section is the category (IL-2 GB / Korea: the Key Mapping tabs). The explanation is the "what it does" line (source joypro, after the cockpit guide and the sim's own description, before the general text of the function). Tables: IL2Game, IL2Korea (every action), IL2CoD, IL2CoDBlitz, FalconBMS (the titles no game text explains). Correction tables (MSFS2024, StarCitizen, XPlane11, XPlane12; ActionTexts.CorrectionGames) only hold titles whose shorthand JoyPro writes out ("EFB Back" -> "Electronic Flight Bag (EFB): Back", "Weapon preset qid" -> the game's QIDs, "Rotate X Axis" -> "Photo Mode Camera: Pan Left/Right Axis"): their name always wins, the category stays the game's. Meanings come from the game's own descriptions; MSFS names a few events opposite to their id (UI_DISPLAY_CFD_OFF = "CFD ON", ADF whole/fract, ENGINE_BYPASS): its menu name and description agree there, so JoyPro follows the menu. The function map cache and the DB refresh of IL-2 GB follow them;
  • shorthand of the games' own titles written out (not DCS: its titles are the module's): "Step Dn" -> "Step Down", "Rotor Gov" -> "Rotor Governor", "Fms" -> "FMS" (ActionTexts.ExpandAbbreviations);
  • engine relations action-info --coverage [--all-examples] counts per game the titles with an unexplained abbreviation (a 2-4 letter piece of the id or a word without vowels that is no known word or cockpit label: ActionTexts.UnexplainedAbbreviation) and titles that are only a word and an axis letter ("Cursor X"); quality gate I2/I4 fail on them outside DCS.

Every button has a tooltip. No list on the page scrolls sideways: long titles end in "...", aircraft lists show the first ones and +n, chips wrap. Tested at 1280x800 and 1920x1080 (RelationBuilderRenderTests).

#Make a relation, step by step

  1. New relation (Ctrl+N), type its name (Throttle ALL). Left empty, it is named after its first action.
  2. Add actions: type what it does (throttle). An opened relation starts with an empty box (2.6.2; before, the box held the relation's name, which users found "usually irrelevant"); the empty box says where to start and offers Suggested for this relation (which suggests by the relation itself) and Open catalog. The box is only filled by Find similar and Replace of a Check card and by Back (the search as it was). The search runs while you type (300 ms after the last key) over every game and aircraft (engine relations search "<words>" [--axis|--button] [--plane ...] --limit 400). The engine knows synonyms: throttle also finds thrust and the helicopter collective, flare the countermeasure dispense switches.
  3. The rows come grouped by game (DCS · 48 actions), each with a tick box, the title (the words you typed marked), the aircraft, the kind, why it was found ("same function: Throttle") and one tag when other relations have it switched on (for at least one of its aircraft; the engine's InRelations without the open relation; the same tag on the suggestions, from their InOtherRelations): none, in '<relation>' (a click opens it) or in 3 relations (a click lists them under the row, a name opens that relation). The search stays; Back to '' above the opened relation's name (and the header's Back, Alt+Left) returns to the relation and its search as they were (builder-search in the navigation entry). Actions already in the open relation are not shown at their rank: greyed, without a tick box, in a group Already in this relation at the bottom of every list (by game, by function, with game chips, after Show more, with or without the aircraft filter); Tick all shown and Add selected leave them out, and the header counts only what can be added (10 actions in 1 game + 1 already in this relation). The list has three sections (2.6.2, see Same function and Related): Name has every word (n) (titles with every typed word, the engine's Literal), Same function (n) (actions of the function the words were read as, by its name, a synonym or a description) and Related (n) (looser links, folded until a click opens it; open by itself when nothing is above it). A section stays above the next in every sort (own order, Sort: Game and the other levels order the rows within a section), by game and by function, with game chips and after Show more (a game in several sections has its Show n more on its last header in view). Before 2.6.1 a Game sort level sorted a game's rows by title, which put "Exterior Lights Master ..." above MASTER RESET for master reset; 2.6.1 had two sections, the second, Same meaning, held everything that was no name match, and users' "brakes" showed only landing gear and hook switches there. Only the rows in view are built (a virtualizing list): a search over every game lists up to 160 rows. Each game's main control of the function comes first, marked main control; a title that does not name the function says it: AXIS ELEVATOR SET — Pitch axis (elevator).
  4. Filters: All / Axes / Buttons (a relation holds one kind; an open relation with actions shows only its own, an empty one every kind), the game chips of the result with how many actions each game has (none ticked = every game, the best 12 rows of each: --limit 200 --per-game 12; a ticked chip searches that game again for all its rows; the first eight as chips, +n more games for the rest). The chips stay on (2.6.3, a user adding Falcon BMS to one relation after the other): for the next search, for every relation opened and after a restart (ui-settings.json addActionsGames); they are the first chips, also with an empty box. With chips on, a new search asks the engine twice: over every game for the other chips' numbers, then the chosen games for the rows. A chosen game without a result says so with what the others have and Show all games (never an empty list or a silent reset); the chips of Suggested for this relation stay the same way (suggestedGames). And the aircraft picker. By function groups the rows by the function they are (the engine's FunctionGroups) instead of by game. Each row shows how it was found (main control, exact title, same function, synonym, by description, name match, related; the chip's tooltip says why in a sentence), and a typo offers Did you mean: throttle?. Same meaning next to All / Axes / Buttons (on by default, remembered in ui-settings.json addActionsSameMeaning, the same switch in Settings > Relations): off lists only the name matches and the status line says how many it hides. Nothing new (2.6.4): a search never reads as "found nothing" while actions are in the open relation. Every result in the relation and nothing new hidden (switch on or off): no callout, only the status line No new actions: the 2 found are already in this relation (see below). The name matches in the relation and others hidden by the switch: the callout No new actions with every word of "X": the 2 found are already in this relation (see below). 4 more found by what they do are hidden because Same meaning is off. with Show same meaning. No name match anywhere the search looked and only hidden rows: No action found whose name has every word of "X". 2 found by what they do are hidden because Same meaning is off. (not "no action's name": the kind, aircraft and game filters may have narrowed the search). Only rows of the relation, all hidden: No new actions: the 2 found by what they do are already in this relation, hidden because Same meaning is off. Nothing found for ..., with or without game chips, only when the search has no row at all. With the switch off the status line counts what is listed, not what it hides: No new actions + 2 already in this relation · understood as Weapon release (pickle) · 11 with the same meaning hidden (Same meaning is off) · 5 more in this relation hidden. The search needs no open profile (the profile only marks which relations use a row). Under a game, Show n more loads the rest of that game's hits for the same search (--game <game> --limit 400), Show less folds them; Expand all / Collapse all above the list do every game. The state stays while the query, kind and aircraft stay the same; ticks survive expanding and collapsing.
  5. Tick what belongs: a row, or the box of a game for all or none of its rows; Tick all shown, Clear ticks. A DCS row adds only its ticked aircraft (Same id, different meaning).
  6. Create relation with n actions (engine relations add <name> --axis --node game:id:planes ...). Axes and buttons together are refused with a hint. The new relation opens.

For an open relation the same panel says Add selected (n) (engine relations suggest apply <relation> --add game:id:planes ...). Rows whose aircraft are all in the relation are marked already in this relation, cannot be ticked and are greyed at the bottom; their aircraft line names their own aircraft (two rows of one title, such as the F-4E's pilot and WSO "Bomb Release Button", are told apart by it), their aircraft button says 1 of 3 aircraft in this relation, and the list it opens only shows: nothing there can be ticked, because the row adds nothing (2.6.4). A row the relation has for only some of its aircraft stays addable: it says already in this relation for 19 of 20 aircraft, its aircraft line and Add selected hold only the free ones, and in its aircraft list the others are marked and have no tick to change (BuilderSearchResultItem.MarkInOpenRelation, "some" from the row's own same-meaning aircraft; a user's "F1 Cockpit view" had ground_unit, whose id means something else or nothing, and not su-25T, so before 2.6.3 it looked like a new action). Adding merges into the node. Ticks survive a new search when the same action comes back. Every change can be undone with Ctrl+Z.

#How the search finds things

Like a search engine over every game and aircraft at once, built on the function map; one row per command and meaning, with every aircraft where the command means that and the relations that already use it.

  • Names and synonyms: throttle finds every game's throttle, thrust (DCS FC3), the helicopters' collective, Star Citizen's strafe longitudinal, Elite's Forward Thrust Axis and X4's Accelerate.
  • What it does: make the plane go faster, drop countermeasures, talk to the tower, move sideways (space), lower the landing gear, look around, lock target: the functions' plain-English descriptions (BM25 over names, synonyms, game terms and descriptions) and a lexicon of words that mean much the same (drop ~ release ~ deploy).
  • Directions: gear up, tms aft, zoom in, trim nose up: rows in that direction first, toggles and rows without a direction after, the opposite direction never.
  • Typos: one per word (two in long words); a misspelt word is corrected against every word JoyPro knows and the result says Did you mean: throttle.
  • Plain words still work for everything the map does not know: whole words, word starts (disp finds "Dispense"), the readable id and the game's category; rare words weigh more than common ones.
  • Titles with every word (2.6.0): every title that has all the typed words (whole words or word starts from three letters; +, -, brackets and punctuation of the query are only separators: tacan channel (xx0x) - [inc] is tacan channel xx 0 x inc; a - or + on its own is no direction either, only one glued to a word (zoom-) or the word itself; of titles with as many other words, a step or direction ([Inc], [Next]) before a fixed position (- 0)) is a hit, also when its words alone are generic (master, reset, inc). Unless the query names a function with all its words (pitch, gear up: that function's rows lead as below), the titles with every word as a whole word come before every row that only means the same (a word start alone does not lead: "guns hot" puts no "HOTAS" title first), the whole title typed first (master reset = MASTER RESET), then those with the fewest other words (Literal in the JSON). A DCS title's trailing tag says what the command does ([Inc], [Dec], [Next], [Toggle], [CW]); only seat and panel tags ([FWD], [SimPit], [WSO] ...) are dropped (before 2.6.0 every trailing tag was dropped and the dash before it read as "minus": [Inc], [Next] and [Toggle] were "decrease").
  • Every word covered (2.6.1): a query of several words that some result covers completely lists only what covers all of them. A result covers the query when its title has every word (above), or when it was found as a function that explains every word: by the name, synonym or description that found it, by one of its names and synonyms (Master caution reset has master and reset), or by the direction it was read with when the function really has actions in that direction (at least two and one in twenty, or its own list of directions: gear up is the gear's up; one air-conditioning "master switch - RESET" gives the master power no reset). The functions and rows that explain only some of the words go, also from "understood as": master reset in the F-14 lists MASTER RESET and Master Caution Reset and is understood as the master caution reset, not every master function by its first word. Filler and stop words (the, please, turn), numbers and fragments of one or two letters that are no direction (xx, 0, x of tacan channel (xx0x) - inc: the TACAN channel step still covers that query) need no cover. A function found through a synonym of the whole phrase still covers it (undercarriage up, drop flares, fahrwerk ausfahren), and when nothing covers every word the partial meanings stay, so plain-language queries (make the plane go faster) work as before. A single word is never cut (master lists all 35 F-14 titles with it, reset still lists MASTER RESET).
  • Ranking: the exact title first, then the function by its own words (Throttle Left), then by a synonym or game term (Collective), then by what the query describes, then plain word matches. Rows of the function's natural kind (a throttle axis, a gear button) rank before the others. The function's primary axis leads its game (see Function map): pitch in MSFS is the elevator axis, then the helicopter cyclic, never the hot-air balloon's burner pitch above it; throttle in FSX is Throttle axis (all engines) before Throttle 1 axis.
  • Grouped: Groups (per game) and FunctionGroups (per function, then game). Within --limit every game with a function hit keeps its best rows, so a search over all games shows every game's throttle; --per-game N caps the rows of one game.
  • Singular and plural are one word: the tokenizer drops a plural s (brakes = brake, flaps, lights), ies is y (batteries), and since 2.6.2 es after ch, sh, ss and x (switches = switch, flashes, passes, boxes; not axes, caches, aches ...: EngineFunctionMap.Stem). Titles, ids, phrases and queries go through the same rule, so brakes name-matches "Wheel Brake" and master switches "MASTER Switch - ALL". The title's highlight marks the singular too ("Brake" for brakes; before 2.6.2 the name matches looked unmatched).

Every search row has a Section (relations search JSON, EngineRelationSearch.Explain), decided from what found it (2.6.2, users' brakes report on 2.6.1: "Same meaning" showed only F-4E sim-pit gear and hook switches, "I don't see any connection"):

Section Rule (engine data) List
name the title has every typed word (Literal: whole words or word starts from three letters, plurals as above) Name has every word, first
function not name, found as an action of a function the query was read as (Resolved, not Related) with match exact, function (its own words), synonym (a synonym or game term) or described (what the query describes); or the game id or key typed Same function, open
related everything else: a function only related to the query (RelatedBy: function), the function catalog alone, its title without the function's words (catalog), a word found only in the category (category: "Gears, Brakes, Hook" for brakes; the engine's Why says Category match, before 2.6.2 Title match (32%)), some of the words in the title (some-words), only a word start, a typo or the game id (similar) Related, folded, with its count

The reasons in words come from the row's Understood (the function the query was read as, "Wheel brakes"), UnderstoodBy (name, synonym, description, related), QueryTerm (the word or phrase that read it: thrust, go faster), ActionFunction (the row's own function: "Wheel brakes axis"), GameTerm (the game's word when it is another: collective), RelatedBy, TitleWords, CategoryWords and CloseWords (the typed words found in the title, only in the category, only as something similar). The GUI's tooltip on the row's chip and the line under its title (BuilderSearchResultItem.ReasonText):

  • name: "The title has every word you typed; its function is 'Wheel brakes axis'."
  • function: "'brakes' is understood as 'Wheel brakes'; this action's function is 'Wheel brakes axis'.", "'thrust' is a synonym of 'Throttle'; this action's function is 'Throttle (left) axis'.", "What you typed describes 'Throttle'; this action's function is 'Throttle increase'." (+ "The game calls it 'collective'.")
  • related: "Related: its category 'Gears, Brakes, Hook' has the word 'brakes'; its title has none of the words you typed.", "Related: its title has only some of the words you typed ('landing').", "Related: only something like 'flare' was found (a word start, a typo or the game's id), not the word itself.", "Related: JoyPro's function list reads this action as '...', but its title does not say so.", "Related: '...' is close to what you typed, but it is not the same function; this action is '...'."

The ranking does not change (the sections only group what the search finds; engine relations phrase-check gives the same pass rates and the same failing phrases before and after 2.6.2). relations browse rows have no section.

#Words that tell actions apart

A number or a side the query names tells actions of one function apart (2.6.3, a user's LMFD OSB 15: FMFD: OSB-15 Button - Push was recommended and LMFD: OSB-15 Button - Push was "another action for the same thing"; AVIONICS: MFD Switch - OFF and DCS's APU Fire Pushbutton were "Same function" too):

  • The panel tag is part of the name. CleanTitle takes Falcon BMS's LMFD: off a title so that the function rules read OSB-15 Button - Push (a GEAR: panel is no gear function). The name search (Entry.Words, WordIndex.Shown) also has it: LMFD OSB 15, lmfd osb15 and LMFD OSB-15 are name matches, as the Catalog tab's plain filter always found them (it reads the raw title). Tokenize splits OSB-15 and OSB15 into osb + 15; the title's highlight does too (HighlightTextBlock.Parts), and marks Left MFD for LMFD.
  • Such a word is needed (EngineRelationSearch.DistinguishingWords): a number (15), a side (left, right, lh, rh, port, starboard, LMFD, RMFD, LMFCD, LDDI, MPCDL ...), another display (FMFD, TMFD) or a position (top, bottom, center, upper ...). A row found as the function without it goes down and to Related (RelatedBy: lacks-word, MissingWords; "Related: it is an action of 'MFD button (OSB)', but its title does not have 'LMFD'."). LMFD is left: DCS's Left MFD OSB 15 has it.
  • What is not such a word: the number of an aircraft's name (F-16, A-10, Mi 8: one or two letters before it), a word of the function's own name that found it (fox 2, center view), and up, down, forward, aft (directions of the functions, with their own rules: gear up still finds War Thunder's Toggle Gear). An axis of a function without one axis per side stays for a side (yaw left is still the rudder); left throttle wants the left lever.
  • A title with every word leads when the query has such a word, and a number alone next to a named function brings no second one (15 of OSB 15 was read as the "SPO-15" radar warning receiver). The key of a display's OSB (left 15) is that key when the query names no side, so OSB 15 is an action of the MFD buttons in the F-16 too.

engine relations phrase-check (gate check I11) on 2.6.2 and 2.6.3: see docs/releases/v2.6.3.md.

Sim-pit switch axes: the F-4E lists 199 [SimPit] ... (Switch) / (Button) / (Knob) commands (pilot and WSO) as axis commands (DCS ids a3016cd20 ...): Heatblur made them for home cockpits that wire a switch or a potentiometer as an axis. They are axes in the game, so the search lists them among axes; the row says axis (sim-pit switch) with a tooltip instead of a bare axis (BuilderSearchResultItem.IsSimPitSwitchAxis).

#Same id, different meaning

A DCS command id is no function of its own. a2001cdnil is "Pitch" in the jets, "Flight Control Cyclic Pitch" in the helicopters; a clickable cockpit id like d3002pnilunilcd3vd1vpnilvunil (device 3, command 3002) is "Hydraulic Emergency Release Knob" in the P-51D, "Fuel Densitometer Selection Switch Cover - OPEN" in the F-86F and "Bomb control handle - PASSIVE" in the La-7; dnilp95u215... is "Trim: Nose Up" in most jets and "Trim: Nose Down" on the F-16's HOTAS. On a full set of lists (122 DCS aircraft lists, 24 472 ids) 10 839 ids are shared by several aircraft and 3 289 of them mean something else in some aircraft (8 232 aircraft entries), 987 have near variants. The niche ones are the worst: cockpit switches, electrics, radios, magnetos, voice chat (d1731...: 20 meanings). Every other game has one list per game (one meaning per id); the same rules apply there and find nothing (relations meanings).

So a search hit, a suggestion and a relation action are (id, aircraft), each aircraft with its own title and category (engine\EngineIdMeanings.cs):

Compared to the row's meaning When Grouped
same normalised title (the game's tags and prefixes off, lower case, plural s off) and normalised category equal yes
near same words in another order (Pitch Trim Up / Trim pitch up), the same title in another category, the same title with a note in brackets (... (call radio menu)), one plain word more or less, or up to two words more on one side (Start dispensing / UV-26 Start Dispense) yes, flagged near for review
differs anything else; always when the titles are opposite directions (Nose Up / Nose Down), name other numbers (Station 1 / Station 2) or differ in a direction word no: its own row, listed as "same id, different meaning in n aircraft (left out)"

A row's head is its most common meaning; a relation action's meaning is the one whose title shares the most words with the relation's name, else the most common one. Modules that list only input names (Input.SpitfireLFMkIX.uc_1) compare as their twin list (SpitfireLFMkIX_easy: "Undercarriage DOWN").

Everything that builds relations keeps to it:

  • Search and resolve: one row per id and meaning (Variants, Near, SameIdDifferent, MeaningNote in the JSON); an aircraft whose own title names another function is not read as the catalog's function for an id that means different things (CatalogAgainstTitle).
  • Suggestions: the "same id" source proposes only aircraft where the id is same (90) or near (75) to the relation's own aircraft; no suggestion for an id the relation has with another meaning.
  • The assistant: its tools return one line per meaning, a line says "same id means something else in n other aircraft (not in this line)", and the system prompt tells the model that ids are per aircraft.
  • Auto Group, Group by description, the setup wizard, relations add --node DCS:<id> without aircraft: an aircraft whose meaning differs from the node's (and whose own title the function map does not read as the same function and direction) is left out: in the node switched off, listed (MeaningExcluded, MeaningNotes), one tick brings it back. A node spec without aircraft takes the id's most common meaning.
  • Export: a node exports its bind only for its switched-on aircraft (RelationItem.AIRCRAFT, as in JoyPro 1).

In the GUI every DCS row of Add actions and every DCS action of the open relation has an aircraft selector: a-10a, A-10C +69 more / 82 of 84 aircraft · 14 aircraft use this command for something else (show) (and · n aircraft have another name for it for another title of the same function); a click on the action itself, its chevron (v / ^) or that line opens it; closed, the card shows its one-line summary (game, aircraft). Every collapsible header of the app (Expanders, Settings sections) opens and closes from anywhere on its row, the chevron included (Styles/DesignStyles.axaml, Styles/SettingsSection.axaml). It lists every aircraft with that id in groups by what the id means there: Same meaning: 'Pitch' (60), Nearly the same (9), Another name, does the same (14) (a helicopter's Flight Control Cyclic Pitch: the function map reads it as pitch, no mixed meaning), Not in its list (2), Does something else here (its own name shown), each aircraft with its own title and category and a tick; All, None, Only same meaning (same and near), Only same function (also the other titles of the function), Only same title, Invert (on the shown aircraft), a filter box; Space toggles, Shift+click ticks a range. A search row starts with its same and near aircraft ticked and the other meanings unticked and adds only its ticked aircraft; an action's Apply saves its ticks in one step (relations aircraft set, one undo step) and the list stays open. Actions whose ticked aircraft mix meanings are flagged inside their card (In 1 ticked aircraft this command is not '...' but something else; only another function counts, not another title of the same function). The card's title is the action's main meaning, not a list of every title (2.6.2): each other meaning of its ticked aircraft is a line under it (F-16C Block 50: KY-58 MODE Knob - RV (different function)), the other names of the same function one line (also called: Thrust (13), Power Levers (Both) (2)). Other games' actions show their title in the game (Pitch axis, AXIS ELEVATOR SET), not their id. Opening a relation puts its name into the Add actions search; a game's header counts like its chip (12 of 44 actions). Games with one list per game have no selector.

An action with its aircraft open, a search row with its aircraft, the profile check

Repair: relations check-aircraft finds actions with switched-on aircraft whose meaning differs from the action's; those the function map reads as the same function (Cyclic Pitch in a Pitch action) are listed but kept, and so is a helicopter's engine throttle against the throttle or power levers of other aircraft (the Ka-50 III's Throttle against the AH-64D's Power Levers (Both) or the A-10C's Throttle Both: one control, the engine's power; the check's own rule, EngineIdMeanings.SameEnginePower). An aircraft that came from the user's own bind files (a DCS import or a take-over, RelationItem.FromGameFiles, recorded since 2.6.2) is never the side proposed to go (Imported in the answer, never in Drop), and when the node has such aircraft switched on, their meaning is the node's meaning (Title; an aircraft a builder or an old load correction added never outvotes them). Planes lists the switched-on aircraft with the node's meaning. The open relation shows a neutral question (blue, info icon; orange is kept for real problems) that counts only this relation and names the button, the aircraft and what the command does in each (up to three aircraft per meaning, then and n more; 2.6.2): This button does different things in different aircraft. BTN 20 does different things in these aircraft: F/A-18C: RADAR Switch - EMERG · F-16C Block 50: KY-58 MODE Knob - RV. Where should BTN 20 work?. Show what this command does in the other 35 aircraft opens the list: per aircraft its name, what the command is called there and a use here tick. The buttons say the outcome: Only in the F/A-18C (take it off the F-16C Block 50) switches the others off (relations aircraft set --off, one undo step per action; they stay listed), Keep it in both (F-16C Block 50 keeps KY-58 MODE Knob - RV) (Keep it in all (...) for more meanings, Keep it everywhere for several actions) changes nothing in the profile and only stops asking on this PC (its tooltip says so), Decide later hides the question until the next start. Kept aircraft (Keep it in both, use here) are remembered in list-preferences.json (KeptAircraft: relation|game|id|plane, this PC only, not undoable) and not asked about again. The profile-wide number is the small link Check all relations (n actions) above the editor: it runs the check again and lists every flagged action (a click opens its relation) with Switch them all off (--apply, one undo step; one run per action when the user keeps aircraft). On a real profile (443 relations, 2 760 actions): 220 actions with differing aircraft, 165 actions in 129 relations to repair, 360 aircraft to switch off, 398 kept as the same function.

#Suggested for this relation (no AI)

engine relations suggest <relation> [--min high|medium|low] [--game g1|g2]. Deterministic; the sources:

Source Score Example reason
The function catalog (DB/Functions, checked against the manuals): the relation's function (The function chip; none for a button position) 95 when the function covers the relation, lower when the catalog knows only a few of its actions (substitutes: 70 to 45) "Same function as F-16C_50 'Countermeasures Management Switch - Fwd'"
Your style: what you put on this function in aircraft that lack it (Auto Group's learned habits, at least two separate decisions in your own relations) 80 "Your style: 'TMS Up' where 'CMS FWD' is missing"
The same DCS command id in more aircraft, only where it means the same there 90 with the same title, 75 when near; never when it means something else "Same command id as in F-16C_50, same title"
Similar titles in any game (never the opposite direction) 70 / 55 / 40 "Title match: 'Countermeasures Dispense' (87%)"

Confidence: high from 85, medium from 55, else weak. Weak matches are hidden until Also weak matches.

  • Add takes one row, Add all (n) every row shown that no other relation uses, x dismisses one for good (suggest apply --never: kept in the relation switched off, never suggested again; Dismissed for this relation on the left lists them, Restore (--remove) takes one out).
  • Already in another relation: such a row says Already in 'Flare' and offers Move here (--take).
  • Looks wrong: entries an old auto-fill put into the relation, with Move to / Remove (Suggest additions). Also a button in an axis relation (or an axis in a button relation: "'UFC 3 Key' is a button in A-10C II; 'Pitch' is an axis relation"), with Move to the button relation of its function.
  • Outliers seed nothing: an action of the other kind, or one the catalog files under a function no other action of the relation shares (the relation has a function of its own), says nothing about what the relation is: no suggestion comes from it, it only shows under Looks wrong. check-aircraft ("Same id, different meaning") leaves actions of the other kind out of its count (OtherKindNodes).
  • The relation's meaning is the union of its actions' functions, weighted (a function counts fully when the relation is named after it or when at least half of its actions are it). The header shows it.
  • The panel belongs to the open relation only: opening another one clears the suggestions, Looks wrong, the dismissed list and the function chip at once (the engine run takes a while), and a row left over from the relation before never acts on the new one.

Games often have two to four actions for one function (Elite "Pitch Axis" / "(Alternate)" / "(Landing)", MSFS "Elevator Axis" / "Elevator Set" / "Aileron / Elevator", Arma 3 plane and helicopter pitch, IL-2 Korea "Pitch (Elevator)" / "Mc pitch" / "Rb pitch"). Per game (DCS: per aircraft) one is Recommended (ranked first, ticked for Add ticked); the others sit collapsed under it (+2 other actions in this game), never ticked, each with one line Differs: .... EngineActionChoice with the generic rules of DB/Functions/action-variants.json (nothing written per action):

  • the recommended action: no variant rule fits, no word of its own the function does not explain, the function's canonical control (PrimaryRank), the higher score, the shorter title;
  • variant rules (title or the game's category): trim, alternate set, landing mode, mouse, combined axis (Aileron / Elevator), gyroscope, another seat, view / camera, weapon aiming, propeller, reset, "free"; a rule whose words are the function's own (trim for Pitch trim) does not count;
  • a word the game gives no meaning for: variant ('Mc') - meaning not documented by the game (never guessed), only when the action has every word of the recommended one and more (Pitch Mc next to Pitch); no rule and no such word: the game does not say how it differs, only for a real twin of the recommended action (the same words without axis/set/ex: MSFS Elevator Set next to Elevator Axis). Another control the function map merely groups with it (Condition Lever 1 Axis next to Condition Lever Axis) gets no hint;
  • families: a helicopter (or ground vehicle) action next to a plane action of the same game is recommended too, for helicopters / for planes (space games: for ships);
  • a game or aircraft the relation has an action for already gets no recommendation.

In a search Recommended follows the query (2.6.3, EngineRelationSearch.FollowQuery; the suggestions above and the catalog keep the rules as they are). A row's fit (QueryFit): 4 the whole title typed, 3 every typed word in the title or an action of the function the query names with all of its words, 2 a function it only partly names or describes, 0 Related. Per game (DCS: per aircraft) only the rows of the best fit compete by the rules above, so a row never gets it from a row that fits better, a Related row never gets it, and a title with every word can win without a function of the map. A row that fits best is no Differs: of one that fits worse. The same control on another panel is an action of its own, not a variant: OSB 15 in Falcon BMS recommends the OSB of every display, none says "differs". In the suggestions the panel's side counts when the relation's name says it (MFD LEFT BTN12: the LMFD's OSB, PanelSideRank).

Every row shows the game's readable name (EngineActionInfo.Readable: MSFS / FSX / P3D events whose list has no menu name get one from the event name, KEY_AXIS_ELEVATOR_SET -> Elevator Axis; an id shown as its title gets its words), the function and the id small underneath, and what it does: the cockpit guide's "What does it do?" text of the control it is (through the cockpit pictures' commands), else the sim's own description (MSFS en-US.locPak ..._DESC), else the general explanation of its function (_templates.json, by the function, functionTemplates in action-variants.json where the name alone would pick a wrong one), else nothing. The index is kept in <data>\Cache\action-info.tsv. The same marks and texts are in relations search (Add actions), relations browse (catalog) and the relation's nodes (tooltip). engine relations action-info --coverage [--game g] counts per game: readable names, explanations by source, functions with a recommended action that is no variant.

  • More → Next relation with suggestions (suggest --all --min medium) opens the next relation that can grow.

#Suggest missing

Suggest missing (n) on the open relation opens the panel in sections (each suggestion knows what the relation lacks, Missing / NewGame / NewPlanes of relations suggest):

  1. Games not in this relation yet: the same function in a game the relation has no switched-on action of.
  2. Aircraft not in this relation yet: DCS actions for aircraft it has none for (new for F-16C_50, FA-18C_hornet).
  3. Used in other relations: they fit but another relation has them (Already in 'Flare', Move here); never added by Add all or Add ticked.
  4. More for aircraft already in it: other actions of the function for aircraft the relation covers.

High before medium before weak, then by score. Tick rows (or a section's box) and Add ticked (n), or Add per row. The button's count is the free suggestions of sections 1 and 2.

For every relation: More → Suggest missing for every relation... (relations suggest --all --missing --min medium --per-relation 25; the fast sources only, about 18 s on 524 relations): per relation what it lacks that no other relation uses ("5 new games · 12 more aircraft · 3 used elsewhere"), new games first, a tick per row and per relation, Add ticked (n) (one suggest apply per relation, each one undo step), Open opens the relation with all its suggestions.

#The JoyPro assistant

engine relations assistant "<message>" [--relation <name>] [--llm auto|on|off] [--max-steps N] [--show-prompt]. One sentence; JoyPro changes the relations at once (the page shows them right away) and answers with what it did:

"Throttle ALL": created · added DCS 48 aircraft, Star Citizen 2, IL-2 5 · now 160 actions

with the steps it took (What JoyPro did), ids it rejected, and Undo this: one answer is one engine command, so one undo snapshot takes the whole answer back (Ctrl+Z works too). Relation names in the answer open the relation. Expand with AI on the open relation sends --relation <name>: "this relation" and "it" mean that one. Every game works the same way (game names, ship words, questions; see ai-plans.md).

#With the local AI model: a tool loop

The model (the optional local AI model: the catalog model the user downloaded, or their own llama.cpp and GGUF) works only through JoyPro's tools. JoyPro starts the model once per answer (EngineLlm.Session: start, load, many requests, kill; a job object kills it with the engine) and loops:

  1. The model answers with exactly one JSON tool call. A GBNF grammar allows nothing else (one flat object per tool).
  2. JoyPro runs the tool on the profile and answers with RESULT lines (or ERROR ...).
  3. Until the model calls done, or 16 steps (--max-steps). Three answers that are no tool call in a row end the turn; the same call twice in a row is refused. Older results shrink to their first line when the conversation outgrows the context (16k for the user's own model, 12k for the large catalog model).
Tool What JoyPro does
{"tool":"list_relations"} the relations with kind, action count and games
{"tool":"show_relation","relation":"NAME"} the relation's actions as ids (A<n>) and a set id (S<n>)
{"tool":"resolve","query":"WHAT IT DOES","kind":"axis|button|any","games":["XPlane12"]} (games optional) the offline brain: relations resolve on the function map, every game's action of the functions the words name, with synonyms and game terms (throttle = thrust, collective, Star Citizen's strafe longitudinal); side actions left out ("throttle" never brings "Throttle friction"); the word search when the map knows none of the words
{"tool":"search","query":"WORDS","kind":"...","games":["DCS"]} the word search over every game's titles (relations search)
{"tool":"suggest","relation":"NAME","games":["StarCitizen"]} the relation's suggestions with confidence and reason (relations suggest), only for those games when given ("expand Roll with Star Citizen")
{"tool":"create_relation","name":"NAME","kind":"axis|button"} a new, empty relation (refused when the name exists)
{"tool":"rename_relation","relation":"NAME","new_name":"NAME"} renames it (the bind stays)
{"tool":"add_to_relation","relation":"NAME","ids":["A3","S2"]} adds the actions (S<n>: every action of that result)
{"tool":"remove_from_relation","relation":"NAME","ids":["A4"]} takes them out
{"tool":"done","reply":"..."} ends the turn with a sentence for the user

Result lines look like A12 DCS F-16C_50, F-15C +17 | Thrust | axis | in 'Throttle'; a result shows at most 45 lines plus the titles of the rest, and its set id covers all of them.

Checks: an id counts only when a RESULT of this turn showed it; anything else is rejected, listed in the answer and sent back to the model as an error. An axis into a button relation (or the other way round) is skipped. Nothing is deleted (there is no delete tool), a relation the turn created and left empty is dropped at the end, and an unknown relation name gets "Did you mean ...".

The system prompt (DB/Llm/models.json → relationAssistant.system, with a built-in copy in EngineRelationAssistant.DefaultSystemPrompt) explains relations, lists the tools in the JSON form above and sets the rules: only ids from RESULT lines; only actions that do exactly what was asked, never buttons in an axis relation, no side actions sharing a word (trim, friction, cutoff, mixture, propeller, brakes, zoom, lateral or vertical thrust, mining, turret); add a whole set only when every line fits; throttle, thrust, power lever, helicopter collective and spaceship forward/backward thrust are axes, a twin's left and right throttle both belong to an all-throttle relation; create only what was asked, never touch other relations; be quick, then done in plain words; a DCS id belongs to its aircraft: each RESULT line is one meaning with only the aircraft where the id means that, and the aircraft a line says were left out ("same id means something else in n other aircraft") are never added through it. relationAssistant.example is one worked conversation (a "Gear" relation) in the exact format of a real turn. --show-prompt prints the conversation and the grammar without running anything.

#Without the model: the offline brain

The same box understands simple commands with resolve; anything else is answered with what needs the model (and nothing changes):

Command Does
Throttle ALL: all throttle axes creates "Throttle ALL" (axis, from the words) with every resolved action
... into one relation called Throttle ALL including collectives and spaceship forward/backward thrusters the name ends at "including"; each part (thrust, collective, forward/backward thrust) is resolved and added
create Gear with landing gear toggle same, for a button relation
add the collectives [to Throttle] adds to the named or the open relation
remove War Thunder [from Throttle] removes the relation's actions whose game, aircraft or title has the words
rename [Throttle] to Throttle ALL renames the named or the open relation

--llm auto (the GUI's default with the model switched on) uses the model when it is usable and falls back to the offline brain when it is not or does not start (the answer says why); --llm on fails without a usable model; --llm off never starts it.

#Auto-build relations from all my actions (whole profile)

The button's subtitle says what happens: a wizard opens in place of the open relation's view (it comes back with Close and back to my relation at the wizard's top). Leaving the Relations page closes the wizard, the AI panels and the new relation form, so the page always opens in its normal state.

Auto-build relations from all my actions... has Auto Group (by function, with presets) and Group by description (several relations from one sentence). Auto Assign ("Put relations on my buttons automatically") is on the Binds page.

#Function map

DB/Functions/function-map.json is JoyPro's own knowledge of what an action does (no AI, deterministic, shipped with JoyPro like the function catalog). 188 functions in 13 categories (flight controls, engine, weapons, countermeasures, HOTAS switches, sensors and displays, navigation and autopilot, communication, view, lights, systems, spaceship, simulator), each with:

  • id, name, category, kind (axis / button / both) and only (no other kind can be it);
  • synonyms (English, matched as whole words in titles, plural s ignored) and terms per game or class ("StarCitizen": ["strafe longitudinal"], "class:heli": ["throttle"], "class:space": ["boost"]);
  • not: words that rule the function out ("Throttle Cutoff" is no throttle axis, "CB ..." is a circuit breaker);
  • bare and context (2.6.0): synonyms too general on their own count in a title only together with one of the context words. "Lock" is a target lock in "Auto lock on nearest aircraft", "Radar - STT Lock" or "Target toggle lock", but not in "Ramp Control Sequence Valve Lock - LOCK" (CH-47F), "Droppable tank lock" or "Lock pilot body position"; the same for "unlock", "reject" and "deselect" of the target unlock. Searches are not affected (a typed "lock" still finds the target lock);
  • dirs: the function's direction words (noseup = "nose up", "aft", "pull"), sided (per engine or wheel), keyed (PTT 1, OSB 12, UFC 7);
  • slots: the function catalog's slots it stands for ("cms_fwd_start_program_or_just_flare": "@0.85" for flares);
  • related: functions a search lists along with it; plus describe (plain-English phrases, slang, paraphrases and German: "fast travel", "go to hyperspace", "drop the wheels", "Fahrwerk ausfahren"; matched in queries only, never in titles), plain (everyday sentences: words of the function's search document only), lexicon and queryFiller for described queries.

Words people use. Every function has a phrase set in engine/tests/fixtures/phrases/phrases.json: its name, synonyms, slang and paraphrases, two or three everyday sentences ("the button that makes my ship go really far really fast") and German phrases (2232 in all). describe and plain carry them into the map. engine relations phrase-check --file <phrases.json> [--entries search|catalog|assistant|plan|describe] [--functions ...] [--kinds ...] checks every phrase offline on every entry point (the search box, the catalog filter, the JoyPro assistant, Manage / Edit with AI, By description): the function must come first (second for a phrase that may also mean another function, ambiguous_with), and the top rows of each game must be it (the opposite direction counts as wrong). The quality gate's I11 runs it (docs/testing.md). A sentence ("open the thing so I can climb out") is read as a whole: a name that covers only a small part of it does not decide when another function's document fits the whole sentence clearly better. Typos count only for long words JoyPro does not know ("warp" never finds "Warm Air" or "Warn"), and a generic word (drive, set, system, mode) alone never makes a match. The catalog filter finds rows by meaning too (the search's name and function rows in the open list, Browse the catalog). By description and Manage / Edit with AI use the map where the word rules know nothing or something else: every function, not only the catalog's.

Every action of every game list on the PC is mapped at run time: the function catalog where it knows the action (slot -> function), the map's rules for everything else (a synonym or game term in the title or the game's readable id, the not words, axis or button, the aircraft class: helicopter, spaceship), one function where clear, up to three with weights where not. A catalog slot shared by several functions keeps a function only when the title has none of that function's not words: the slot atc_engage (F/A-18 "ATC" = auto throttle control) is also linked to the ATC request of Star Citizen, and MSFS "Arm Auto Throttle" read as "ATC / docking request" (2.2.6 report); "auto throttle" is one of the ATC request's not words, and the autothrottle's not words now have "request", "docking", "air traffic" (regression: engine\tests\smoke\functionmap.ps1, search "atc" in MSFS 2024). New games, aircraft and catalog refreshes are covered by the rules, not by a fixed table. The mapped index is kept in <data>\Cache\function-map.bin and rebuilt when a game list, DB\Functions or the engine changes.

Primary axes. An axis function (pitch, roll, yaw, throttle, mixture, brakes ...) has a canonical axis per game: an axis action whose title has nothing but the function's name, synonyms or game terms, axis words (axis, set, control, joystick, all engines, MSFS EX1), the two ends of the axis (Pedals: left / right pedal) and, for a function per engine or wheel, a side or engine number, and that mainly is this function (weight 0.9 or more). MSFS AXIS ELEVATOR SET / Elevator Axis, FSX Elevator (pitch) axis, DCS Pitch, IL-2 Plane control: pitch, Star Citizen v pitch are primary; a variant has a word of its own and is not: AXIS BURNER PITCH SET (balloon), GYROSCOPE PITCH AXIS, SET CYCLIC LONGITUDINAL AXIS, Pitch Axis (Alternate), Copilot pitch, inpmc_pitch. Among primaries the name before later synonyms, the lever for all engines before one engine, and the function catalog's own pick before an axis only the rules found (MSFS KEY_AXIS_ELEVATOR_SET before the older KEY_ELEVATOR_SET). Search (EngineFunctionMap.PrimaryRank, EngineRelationSearch) puts the primary axis first in its game when the query is about that one function by its main word (pitch, throttle, rudder) or describes it; asked by a variant's word (collective, elevator) the rows with that word lead and the primary axis only leads the other synonym rows. A query about two functions (cut the throttle), with a direction (pitch up) or a related function gets no primary boost. relations resolve ranks the same way. The not words keep the look-alikes out of the flight axes altogether: balloon burner, gyroscope axes, flight director and AP pitch reference, ADI / horizon / boresight adjustment, STAB AUG, head tracker, turret, Star Citizen's character customizer and EVA, DCS vehicle pedals.

On a full set of lists (80 327 actions of 31 games) 73 % of all actions map to a function (95 % of the FSX/P3D lists, 89 % of War Thunder, 84 % of Falcon BMS, 72 % of DCS; the rest are panel knobs, cameras and menus). tools\relations\check-function-map.ps1 measures coverage, search quality on tools\relations\search-eval.tsv (218 name, synonym, game-term, direction, described, held-out and typo queries; pitch, roll, yaw, rudder and throttle also name the first row of every game: 107 of 107 right, 85 before the primary axes) and mapping precision on the hand-labelled tools\relations\function-labels.tsv.

#Engine API

The commands the GUI and the local-model layer call. All print JSON without --text (stdout, or the file of --out); all are read-only. --profile is optional: it only fills InRelations and the relation of suggest. A node spec for relations add --node / suggest apply --add is Game:Id:Plane1|Plane2 (DCS: the aircraft; other games: the game id once).

relations search "<words>" [--game g1|g2] [--plane p1|p2] [--category <name>] [--axis|--button] [--limit N] [--per-game N] [--batch <file>] (exit 1 when there are neither words nor a category):

{ "Query": "throtle", "Category": "", "DidYouMean": "throttle",
  "Functions": ["Throttle", "Helicopter engine throttle / power lever"], "FunctionIds": ["throttle", "engine_power_lever"],
  "Resolved": [ { "Id": "throttle", "Name": "Throttle", "Category": "engine", "Kind": "axis", "Dir": "", "Term": "Throttle",
                  "Related": false, "Described": false } ],
  "Results": [ { "Game": "DCS", "Id": "a2087cdnil", "Title": "Flight Control Collective", "Category": "", "IsAxis": true,
                 "Planes": ["CH-47F", "UH-1H"], "Score": 850, "Match": "synonym", "Why": "Function 'Throttle axis' ('collective')",
                 "Function": "throttle", "Dir": "", "Term": "collective", "Functions": ["throttle"], "Weight": 1.0,
                 "InRelations": [] } ],
  "Groups": [ { "Game": "DCS", "Count": 16, "Total": 760, "Best": 1330, "Functions": 16 } ],
  "FunctionGroups": [ { "Function": "throttle", "Name": "Throttle", "Count": 70, "Games": ["DCS", "WarThunder"] } ],
  "Total": 1272, "More": true, "ElapsedMilliseconds": 101, "LoadMilliseconds": 190, "Warnings": [], "Errors": [] }
  • Primary: the function's main control in its game, asked for by the function's own words (MSFS AXIS ELEVATOR SET for pitch); it leads its game. FunctionLabel: what the row was found as (Pitch axis (elevator), empty for word matches); Display: the title to show, with — <FunctionLabel> when the title does not name the function.
  • Match: exact (the title is the query), function (the query's function, by its own words), synonym (by a synonym or game term), described (the query describes the function), words (a plain word match), category. Results are ranked by Score; Groups / FunctionGroups give the order of the groups.
  • Functions of a row: every function the action is (weight 0.5 or more), id or id:dir.
  • DCS rows (also of resolve and suggest): Planes are the aircraft where the id has the row's meaning; Variants lists every meaning of the id: { "Title", "Category", "Match": "same|near|differs", "Note", "Included", "Planes" } (Included: in the row); Near and SameIdDifferent count the near aircraft and those left out, MeaningNote says it in words ("same id, different meaning in 14 aircraft (left out)").

relations browse [--game <game> [--plane p1|p2]] [--axis|--button] (alias relations catalog): without a game every game with its aircraft (Games: [{ Game, Actions, InRelations, Planes: [{ Plane, Actions, InRelations }] }]); with a game (DCS: and its aircraft) every action as search rows (Results, the aircraft's own title and category, Match "category", InRelations, Variants), Categories: [{ Name, Count, InRelations }] and CategorySource ("game", or "joypro" for games without categories). The table header of a game list is no action.

relations suggest --all --missing [--min ...] [--per-relation N] (default 25, 0 = all): per relation (Relations) IsAxis, Suggestions (free missing ones), NewGames, UsedElsewhere and Items (the suggestions, new games first). Every suggestion of relations suggest also has Missing ("game", "aircraft" or ""), NewGame and NewPlanes.

relations aircraft <relation> [--node game:id]: every action with every aircraft that has its id:

{ "Relation": "Pitch", "Changed": 0, "Nodes": [ { "Game": "DCS", "Id": "a2001cdnil", "Title": "Pitch", "Category": "Flight Control",
    "Active": 3, "Available": 4, "Differs": 0, "DiffersSameFunction": 0, "Near": 0, "Excluded": 1, "Mixed": false, "Badge": "3 of 4 aircraft",
    "Aircraft": [ { "Plane": "UH-1H", "Title": "Collective", "Category": "Flight Control", "State": "off", "Match": "differs", "Note": "",
                    "SameFunction": false } ] } ], "Errors": [] }

State: on, off (in the action, switched off), absent (has the id, not in the action); Match against the action's meaning, unknown when the id is not in that aircraft's list. relations aircraft set <relation> --node game:id [--on p1|p2] [--off p3] changes one action's aircraft in one step (one undo step; --on also adds aircraft).

One action on in two relations. The same action of the same aircraft switched on in two relations is the same game command on two inputs (DCS writes both binds). The load correction's "add the DB's other aircraft of an id" step (--auto-add-db-items, runs when the profile's DB fingerprint differs: since 2.3.1 the fingerprint covers only the command lists the correction reads, DCS, IL-2 and Star Citizen, plus the version of the correction rules; before, JoyPro's own release data (device catalog, drawings, cockpits) counted too, so every update corrected every profile again; since 2.6.0 a save of a command that loads without corrections, such as devices exchange, keeps the fingerprint the profile had instead of stamping the current one, so the next load still corrects) puts a new aircraft into a node switched on only when no other relation has that action of that aircraft on and, in DCS, its title of the id means what the node's switched-on aircraft mean (same / near / same function); otherwise it goes in switched off ("left out"). Before 2.3.1 it switched the aircraft on in every node of the id, so a profile could collect such duplicates without any user action (a user's DCS import of 21 Oct added 330 aircraft, 77 of them duplicates such as the AH-64 force trim on a MFBB and a MOZA button).

#Load correction: only aircraft new in the command lists (2.6.2)

"Auto Add DB Items" is for a module that came into the command lists after the profile was corrected or saved (JoyPro 1's "Auto Add on new DB Items": its nodes held every aircraft of their id, so an aircraft missing in a node was one the lists had not had). JoyPro 2's imports put only the bound aircraft into a node, so up to 2.6.1 every change of the lists (Refresh DB, which 2.6.1 asked everyone with DCS mods to do, or a JoyPro update with new lists) switched on every aircraft of a node's id the user had never bound, as long as nothing else was on that input and the meaning fitted: a user's THROTTLE - SLIDER -HELO POWER BOTH (AH-64D CPG and Pilot, Ka-50 III, Mosquito) got F-15C, A-10C, MiG-29, Su-25 and Default by the shared FC3 thrust id, 446 aircraft in 180 relations in one step, saved under the label of the next click. Since 2.6.2:

  • the profile keeps the aircraft of the lists next to its DB fingerprint (Pr0file.DatabasePlanes, game<TAB>aircraft; DCS one list per aircraft, IL-2 and Star Citizen one per game), stamped with the fingerprint (a command that loads without corrections keeps the set the profile had);
  • the pass switches an aircraft on only when it is not in that set (a newly added module or aircraft), and never a pseudo aircraft (Default, the cameras, the radio menu: EngineDcsExport.IsNonAircraftLayer); an aircraft that was in the lists and simply not chosen stays out of the node (not even "left out"); the other checks stay (nothing else on the input, no other relation with the action, the meaning fits);
  • a profile without a set (every profile before 2.6.2) gets it recorded and nothing switched on that time; so does a game whose lists the set does not have yet (a game installed later);
  • an id that a DCS patch or a mod adds to an aircraft that was in the lists already is not switched on: that aircraft was the user's to set up, and JoyPro 1's purpose was new modules; the command shows in the aircraft's list and in Add actions (the mod commands since 2.6.1 as "Found in your DCS files") for the user to add;
  • what the pass changes in the relations (an aircraft switched on, a remapped command, a command no longer in a list taken out) is a history step of its own, Updated to the new command lists: n aircraft in m relations, saved before the command's own step (never folded into it, never merged with the next click); only a command that saves the profile anyway saves it, and opening a profile (profile load); a preview or read-only command (relations suggest, a dry run, sync diff, setup plan) shows the corrected profile but leaves the file alone;
  • the correction report (--correction-report) has an added entry per aircraft switched on (relation-item-auto-add) next to the left-out ones, and a db-plane-set entry (recorded or compared, the new aircraft).

Repair for profiles 2.6.1 and earlier filled up: engine profile auto-added reads the profile history: a step made by a change (not an undo, a restore, an import, a take-over or a builder like Auto Group) whose version has another DB fingerprint than the one it was made on and in which aircraft went from "not in the node" to "on" in existing nodes of at least 3 relations (relations its label names, such as Adding 1 actions to 'Pitch', are the user's). Offered are the aircraft of those steps that are still on now and that no import brought since; Relations says per relation what goes (Remove) and what stays (Keeps, KeepsAircraft). On a user's profile (history of 2 and 3 Nov) it finds step #117: 448 entries in 180 relations, of them 426 aircraft in 167 relations and 22 input layers (13 relations have only a layer), THROTTLE - SLIDER -HELO POWER BOTH back to its 4 aircraft. --apply [--skip "key;key"] takes them out (the node gets back to the aircraft it had; the skipped ones stay), --keep stops asking; either is one profile version (Took out aircraft JoyPro added: n aircraft in m relations, Took out input layers JoyPro added: n in m relations when no aircraft went, or Kept the aircraft JoyPro added, one undo step) and marks the steps as looked at (Pr0file.ReviewedAutoAdds). Nothing changes without one of them. The app asks after a profile opens (a notice under the bar: JoyPro switched on 426 aircraft you did not choose, in 167 relations, on 03.11.2026., the list per relation and aircraft to untick, Take them out, Keep these aircraft, Later).

Input layers are no aircraft. Default and the other EngineDcsExport.IsNonAircraftLayer layers are marked NonAircraft on their entry and counted in NonAircraft on the result; Aircraft and RelationCount are real aircraft only. An export writes such a layer to Config\Input\<layer>\ like an aircraft folder and never into a module's; the module's files are byte for byte the same with and without it (checked on a user's profile), and nuke and "clean all aircraft" skip the layers. Whether DCS itself reads the Default folder for a module is not something the code can show; a user reports it does not. A profile with only such layers gets no notice and its entries stay (a user had 17 such rows, "17 aircraft", all Default); the command still lists them and --apply works. With real aircraft too they come last in the list as Default (not an aircraft), ticked like the rest.

What is never offered. The history label is what the step was called when it was made, so BuilderLabels has both the engine's name of a command and the GUI's busy words, past and present (Import from, Importing, Taking over, Auto grouping, Assigning controls, Creating relations from your description, Manage with AI, Merging copied relations, Game setup, ...); it missed Importing from DCS and Taking over the game's changes until 2.6.3, so a user's import of 21 Oct (329 aircraft) was offered for removal. A label is matched per part of a joined label (Opening the profile + Importing from DCS: one click, several saves). Two guards do not depend on the step's own label (a GUI label can go into the history translated): the step right after a Before import from checkpoint, and a step that made 3 or more new relations or binds (the old pass made none). No signal says more: nothing in the history records what the game's files held, an export writes the old pass's aircraft into those files as well, and RelationItem.FromGameFiles exists only for imports since 2.6.2. An import that also held the old pass's aircraft (the old pass ran inside the same save) is therefore offered in no part: a real bind must never be called a mistake. relations check-aircraft still looks at those.

relations duplicates lists them as cards per relation pair (Groups: the relations with device and input, the actions with their aircraft as the cockpit catalog names them, Suggested or SuggestOff, Confidence 0-100, Reasons) and as single actions (Duplicates, key game|id|aircraft). Fixes, each one profile version (one undo step): --keep <relation> --keys "k;k" (or --node game:id --plane p1|p2), --off, --ignore (formerly --keep-both, still read; saved in the profile, Pr0file.KeptDuplicates: no warning while these relations or fewer of them have it; when one more relation gets it the warning shows again with ShownAgain and NowAlsoIn/NoLongerIn; --list-kept lists the ignored ones, --forget-kept [--keys] warns again about these or, without keys, about every ignored warning; a fix drops entries whose action is on in one relation only now, engine/EngineIgnoredWarnings.cs), --rule suggested|name|first|device:<kind>|relation:<words> [--min-confidence N] [--apply], --instruction "<words>" [--llm off|auto|on] [--apply] (phrase rules: "keep in ", "everything else in ...", "switch off ...", "prefer the throttle"; the local AI model only rewrites what they do not understand into such phrases), --changes "key=>relation;key=>-" (a preview's ticked changes exactly as shown), --keys-only (only the keys, for the before/after comparison of imports). Without --apply a rule or instruction is a preview (Changes).

Confidence. The profile history decides first: going back from the newest version, the first one where only one of the relations had the action of the aircraft on is where it belongs (96), none of them (94: switch it off in all) - unless the version that brought the second one was the user's own edit of that relation (its label names it, or a small summary does; then only the reason "you added it yourself"). Without the history: a relation where the aircraft is alone in its node (the load correction never makes such a node), the relation's function (chip: set, named, covered) or what its name says (function map) against the action's function, the aircraft's meaning of the id against the node's other aircraft; a button position ("Different functions per aircraft") is neutral; 92 only for "alone here, means something else there", 85 for alone against not alone, else at most 80 by the lead. A relation pair the user kept before lowers it by 25. relations duplicates --evaluate <older.pr0file> [--no-history] measures it against the version before the duplicates came: on a real profile (81 duplicates, truth = its version from before the import) every suggestion is right at every threshold with the history; without it 22 of 22 at 90% and more, 23 of 23 at 85%, 24 of 26 at 80% (the other 2 are right binds too: none of the relations had them, they stay in the one of their function); on two more profiles corrupted by the old load correction (414 and 194 duplicates) every suggestion at 85% and more is right.

Export page, "Problems found by the check" (docs/ui/check.md, Views/Controls/CheckProblemsPanel.axaml): since 2.5.0 every card in plain words - a short title ("Same command on two buttons"), the buttons as device · button with their relation ("LEFT VPC Throttle MT-50 CM · BTN 9 ('A10 - DMS Down') ↔ VKB-Sim Gunfighter · BTN 16 ('Sensor Select Aft')"), one sentence what happens in the game, aircraft -> command (3 rows, "Show all"), "Caused by: on " when the profile history tells (CausedBy, CausedSummary, CausedAt of the group: the version that brought most of its actions into the second relation; one whose change names other relations only is skipped), one recommended fix (the suggestion), "Keep only on X" / "Ignore" / "More" (switch it off on both buttons), an "Open ''" button per relation that opens it with exactly the card's commands and aircraft marked (Back returns to the card), and the confidence with its reasons in the collapsed details. Only aircraft ticked in both relations count. A command the aircraft's current list no longer has is Unknown (its Title is the name the relation stored): the card says "unknown command '...'" and offers "Remove the unknown command" / "Find similar". Fixes for many: "Fix automatically when JoyPro is at least X% sure" (slider, default 90, saved) with "Fix the sure ones (n of m at X% or more)", "Fix all with a rule", "Fix with AI" - each shows a preview of every change with a tick and applies the ticked ones in one step. "Also right after imports and take-overs" (off at first, saved) fixes the sure ones of an import at once. Imports (DCS, IL-2, Star Citizen, the other games) and watcher take-overs compare the duplicates before and after and say on the Relations page when they put actions into a second relation ("Review them" opens the check).

#The check's errors

relations conflicts [--keys "k;k"] [--keep <relation> | --keep-action <id> | --off | --ignore | --remove-actions | --forget-kept] [--include-kept | --list-kept] (engine/EngineCheckConflicts.cs) gives profile validate's two errors in detail; validate prints the same lines from it:

  • InputConflicts: an input (device, input, modifiers) bound in several relations that all have an action of the same aircraft on (Key "game:plane§device§input[§modifier]", Message = the validate line, Sides: each relation with its actions { Id, Title, Unknown }). The app: "One button does two things", one card per input and relation set with the aircraft in its table. --keep <relation> switches the aircraft off in the other relations of the conflict.
  • ActionConflicts: a relation with two actions of one aircraft (or game) on (Key "game|plane|relation"). The app: "One button runs two commands". --keep-action <id> switches the relation's other actions of the game off for the aircraft; --off all of them. A game without aircraft lists (War Thunder, MSFS, Arma ...) names the game as the aircraft of all its actions; there actions of different vehicle classes (the function map's class: helicopter, spaceship, else fixed wing) are different vehicles, as the aircraft of DCS are: the plane's throttle and the helicopter's collective on one axis are no error (2.6.0). Only actions of the same class are, and the conflict lists just those. The same holds for InputConflicts: two relations on one input count only when they carry actions of the same vehicle class of such a game.
  • --ignore (formerly --keep-both, still read) saves "input||" / "active||" in Pr0file.KeptDuplicates (an older entry of the same key is replaced): the check does not name it again while these relations (actions) or fewer of them have it. One more joins: it is listed again with ShownAgain and NowAlsoIn (relations; for ActionConflicts action ids). --list-kept lists only the ignored ones (Kept), --forget-kept [--keys] names them again (without keys every ignored conflict). A fix drops entries whose conflict is gone. --remove-actions --keys "game|id|plane;..." takes actions (unknown ones) out of every relation. Each fix is one profile version (one undo step). profile validate --text prints "Ignored: n" (the profile's entries) when there are some, so the app reads the ignored ones for its list even when nothing else is left.

#Dismissed suggestions

Pr0file.DismissedSuggestions ("relationgameidplane", engine/EngineDismissedSuggestions.cs): what the user dismissed for a relation. relations suggest does not propose it and lists it under Dismissed; Auto Group and the grouping in words keep it out of that relation; suggest apply --remove (Restore) takes it off the list; a renamed relation keeps it. Opening a profile (profile load) takes every action with no aircraft ticked out of its relation and puts its aircraft onto this list (before 2.5.0 a dismissed suggestion was such an action): one history step of its own ("Removed 12 actions with no aircraft ticked from 9 relations"), logged, Undo brings them back, nothing on the next load. An action with one aircraft ticked and every relation (also one without a bind) always stays.

relations check-aircraft [--relation <name>] [--apply] [--include-same-function]: { Relations, Nodes, AffectedNodes, AffectedRelations, AircraftToDrop, AircraftSameFunction, Applied, Dropped, Found: [ { Relation, Game, Id, Title, Category, Active, Available, Meanings: [variants], Drop: [planes], SameFunction: [planes] } ] }. --apply switches the Drop aircraft off.

relations meanings [--game g] [--top N]: per game the lists, ids, ids shared by several lists, ids with another meaning in some (Mixed, AircraftLeftOut), ids with near variants, and the ids with the most meanings.

  • --batch <file>: one query per line (or the second column of a tab-separated line); prints a JSON array of results.

relations resolve "<query>" [--game g1|g2] [--plane p1|p2] [--axis|--button] [--per-game N] (default 25 per game, 0 = all): the query as function ids and the matching actions, grouped by game, best game first. The local-model layer's tool:

{ "Query": "drop countermeasures", "DidYouMean": "", "Direction": "", "Extra": [],
  "Functions": [ { "Id": "cm_dispense", "Name": "Countermeasures dispense", "Category": "countermeasures", "Kind": "button",
                   "Dir": "", "Term": "countermeasure", "Score": 10, "Related": false, "Described": false, "Synonyms": ["..."] } ],
  "Games": [ { "Game": "WarThunder", "Count": 3, "Actions": [ { "Game": "WarThunder", "Id": "ID_FLARES", "Title": "Fire countermeasures",
      "Category": "Aircraft", "IsAxis": false, "Planes": ["WarThunder"], "Function": "cm_dispense", "Dir": "", "Weight": 0.8,
      "Source": "catalog", "Term": "countermeasure", "Why": "Same function: Countermeasures dispense (function catalog)" } ] } ],
  "Total": 208, "ElapsedMilliseconds": 12, "Warnings": [], "Errors": [] }

relations functions [--category <id>] [--query "<words>"] [--coverage] [--dump <file.tsv>]: the map itself:

{ "Version": 1, "Source": "...\\DB\\Functions\\function-map.json",
  "Totals": { "Functions": 188, "Synonyms": 3625, "Terms": 151, "Actions": 80307, "Mapped": 58820 },
  "Categories": { "engine": "Engine and power" },
  "Functions": [ { "Id": "throttle", "Name": "Throttle", "Category": "engine", "CategoryName": "Engine and power", "Kind": "axis",
                   "Only": "", "Description": "...", "Synonyms": ["throttle", "thrust", "collective"], "Terms": { "StarCitizen": ["strafe longitudinal"] },
                   "Directions": ["increase", "decrease", "max", "min"], "Slots": ["throttleleft:left"], "Related": ["engine_power_lever"],
                   "Actions": 1305, "Games": { "DCS": 760, "WarThunder": 2 } } ],
  "Coverage": [ { "Game": "WarThunder", "Planes": 1, "Actions": 290, "Mapped": 259, "Catalog": 109, "Rules": 150, "Percent": 89.3,
                  "Functions": 79, "Unmapped": ["..."] } ],
  "LoadMilliseconds": 190, "ReadMilliseconds": 185, "FromCache": true, "ElapsedMilliseconds": 230, "Warnings": [] }

relations suggest <relation> (see Suggested for this relation) adds MapFunctions (what the relation is in the function map: Id, Name, Dir, Weight, Reference) and per suggestion Function (the map's function id when the map proposed it); Source is function map for those rows, their Why reads Same function: Throttle axis. Dismissed, InOtherRelations and suggest apply are unchanged.

#Tests

  • Engine: engine/tests/smoke/functionmap.ps1 (the function map on fixtures: a query table for search / resolve with names, synonyms, game terms, directions, descriptions and a typo, the primary axis first in its game on MSFS 2024 and FSX fixtures, as the GUI asks (--limit 200 --per-game 12, with and without --axis; balloon burner, gyroscope, prop pitch, AP / flight director pitch and trim not read as pitch), the map cache, suggestions from the map, Auto Group's map rows); real game lists (not in the smoke test): powershell -File tools\relations\check-function-map.ps1 [-DataDir <copy>] (coverage per game, search quality on tools\relations\search-eval.tsv, mapping precision on tools\relations\function-labels.tsv).
  • Engine: engine/tests/smoke/searchranking.ps1 (real game lists): pitch, roll, yaw, throttle, brakes with and without --axis as the GUI asks: the main control first and Primary in MSFS 2020 / 2024, X-Plane 11 / 12, DCS, FSX / P3D, IL-2, War Thunder and Falcon BMS; in every game the function's rows before the word matches; MSFS's AXIS ELEVATOR SET — Pitch axis (elevator), the balloon's BURNER PITCH INC a plain word match.
  • Engine: engine/tests/smoke/searchliteral.ps1 (real game lists): titles with every word, every word covered, and (2.6.2) the sections: brakes with Axes for the F-4E and the Spitfire names every Wheel Brake axis (name), the seven category hits related by category with Category match, thrust the throttles as function by a synonym, make the plane go faster by its description, master switches name-matches "MASTER Switch", Browse has no sections; (2.6.3) LMFD OSB 15, lmfd osb15 and LMFD OSB-15 in Falcon BMS (the LMFD row the one recommended name match, the others related by lacks-word), OSB 15 in BMS and the DCS F-16, LMFD OSB 15 in the F-16 and what must stay (gear up Toggle Gear, yaw left the rudder axis, F-16 thrust, center view).
  • GUI: TesterBatch264Tests: the real engine with "Stick Red Button" holding the F-4E's "Bomb Release Button" of pilot and WSO, Same meaning off: the callout, the status line's counts, the rows' aircraft line and button, the list they open; every kind of row and the cases of the callout. Pictures and texts: JOYPRO_264_RENDER_OUT.
  • GUI: TesterBatch263Tests (a row with some of its aircraft in the relation, the highlight, the game chips over relations and new searches, nothing in the chosen games, the left filter, "Which model?", its click and the answer after a restart), GameChipsPersistTests. Pictures: JOYPRO_263_RENDER_OUT, JOYPRO_263_ENGINE, JOYPRO_263_PROFILE.
  • GUI: gui/JoyPro.Gui.Tests/SameMeaningTests.cs: the real engine with "Wheel Brakes (analog)" (the Spitfire's axis) for a user's aircraft: the empty start, "brakes" (name matches, Related (7) folded and opened, the reasons, axis (sim-pit switch)), Same meaning off (only names, the hidden count; thrust: "no name match" and Show same meaning), the switch surviving a restart and in Settings > Relations, the reason texts, the plural highlight; JOYPRO_SAMEMEANING_RENDER_OUT=<folder> renders it light and dark.
  • Engine: engine/tests/smoke/peraircraft.ps1 (same id, different meaning, on fixtures in engine\tests\fixtures\per-aircraft\DB where a2001cdnil is "Pitch" in three jets and "Collective" in the UH-1H, a cockpit switch id is another switch per module, dnilp95u215 is nose up / nose down, and Pitch Trim Up / Trim pitch up are near): the search splits and reports, resolve, suggest, the assistant, Auto Group and a node spec without aircraft leave the helicopter out, relations aircraft [set], the DCS export writes only the selected aircraft, relations check-aircraft finds and repairs a mixed action.
  • Engine: engine/tests/smoke/relationbuilder.ps1 (suggestions, search, chat) and relationassistant.ps1: the offline commands (create and fill, rename, remove a game, a free sentence that needs the model, --llm on without a model, --show-prompt), and the tool loop through engine llm fake-server with a scripted conversation (JOYPRO_LLM_FAKE_RESPONSE, answers separated by a line #next): one model process for the whole turn, six requests, an invented id rejected, a button skipped in an axis relation, an invalid answer answered with an error, the step limit, a repeated call refused, an empty new relation dropped, the model process gone afterwards.
  • GUI: gui/JoyPro.Gui.Tests/RelationBuilderTests.cs (search as you type over every game, game chips, ticks by row and by game, Add selected, a new relation from ticked axes, mixed kinds refused, rename in place, suggestions add / add all / dismiss / restore / move / misfits, the assistant applied at once with its summary, rejected ids and one Undo, Expand with AI, the offline path and "needs the model", Auto Assign on the Binds page) and AircraftSelectorTests.cs (the aircraft selector: All / None / Only same title / Invert / filter, Shift+click ranges, the badge, a row that adds only its ticked aircraft, ticks kept over a new search, Show n more / Show less / Collapse all, an action's Apply in one engine run, the profile check notice and its repair) and RelationBuilderRenderTests.cs (the page at 1280x800 and 1920x1080: no horizontal scroll bar, every button inside the window, a refresh of the list keeps the relation and the steps never show over its actions; with JOYPRO_UI_DESIGN_OUT the pictures below). RelationStudioRealProfileRenderTests.cs renders a real profile through the real engine (opt-in: JOYPRO_REL_REAL_OUT, JOYPRO_REL_REAL_ENGINE, JOYPRO_REL_REAL_PROFILE, a copy is used).
Add actions New relation
The JoyPro assistant Light theme