Aetheria/Packages/org.gamecult.aetheria.state/Runtime/AetheriaRuntimeInputCapabilityDocuments.cs
2026-07-17 04:42:42 +01:00

501 lines
28 KiB
C#

using System;
using System.Collections.Generic;
using System.Linq;
using GameCult.Caching;
using GameCult.Eve.Surface;
using MessagePack;
namespace GameCult.Aetheria.State.Verse
{
[MessagePackObject]
public sealed class AetheriaRuntimeInputGestureDocument
{
[Key(0)] public string Kind { get; set; } = "direct";
[Key(1)] public string[] Controls { get; set; } = Array.Empty<string>();
[Key(2)] public int MaxStepIntervalMs { get; set; } = 650;
[Key(3)] public string CompletionControl { get; set; } = "";
}
[MessagePackObject]
public sealed class AetheriaRuntimeInputBindingDocument
{
[Key(0)] public string BindingId { get; set; } = "";
[Key(1)] public string ActionId { get; set; } = "";
[Key(2)] public AetheriaRuntimeInputGestureDocument Gesture { get; set; } = new AetheriaRuntimeInputGestureDocument();
[Key(3)] public bool ActionBar { get; set; }
}
[MessagePackObject]
public sealed class AetheriaRuntimeInputActionDocument
{
[Key(0)] public string ActionId { get; set; } = "";
[Key(1)] public string Label { get; set; } = "";
[Key(2)] public string Operation { get; set; } = "";
[Key(3)] public string Context { get; set; } = "pilot";
[Key(4)] public string Category { get; set; } = "ship";
[Key(5)] public string Availability { get; set; } = "available";
[Key(6)] public string SourceRef { get; set; } = "";
[Key(7)] public Dictionary<string, string> Payload { get; set; } = new Dictionary<string, string>(StringComparer.Ordinal);
[Key(8)] public AetheriaRuntimeInputValueDocument? InputValue { get; set; }
}
[MessagePackObject]
public sealed class AetheriaRuntimeInputValueDocument
{
[Key(0)] public string Model { get; set; } = "";
[Key(1)] public string PayloadKey { get; set; } = "";
}
[MessagePackObject]
public sealed class AetheriaRuntimeInputProfileDocument
{
[Key(0)] public string ProfileId { get; set; } = "";
[Key(1)] public string DeviceClass { get; set; } = "";
[Key(2)] public AetheriaRuntimeInputBindingDocument[] Bindings { get; set; } = Array.Empty<AetheriaRuntimeInputBindingDocument>();
}
[MessagePackObject]
public sealed class AetheriaRuntimeInputCapabilityDocument
{
public const string SchemaId = "gamecult.eve.input_capability.v1";
[Key(0)] public string Schema { get; set; } = SchemaId;
[Key(1)] public string ProviderId { get; set; } = "aetheria";
[Key(2)] public string CapabilityId { get; set; } = "aetheria.pilot.input";
[Key(3)] public long Version { get; set; }
[Key(4)] public AetheriaRuntimeInputActionDocument[] Actions { get; set; } = Array.Empty<AetheriaRuntimeInputActionDocument>();
[Key(5)] public AetheriaRuntimeInputProfileDocument[] DefaultProfiles { get; set; } = Array.Empty<AetheriaRuntimeInputProfileDocument>();
public static AetheriaRuntimeInputCapabilityDocument FromFrame(
AetheriaRuntimeDaemonFrameDocument frame,
bool includeSimulationClock = false,
AetheriaRuntimeCatalogSnapshot? catalog = null)
{
var run = frame?.Run ?? new AetheriaRuntimeRunCheckpointCommit();
var entity = run.Zones.SelectMany(zone => zone.Entities).FirstOrDefault(candidate =>
string.Equals(run.EntityRecordKey(run.CurrentZoneIndex, candidate.EntityIndex), run.CurrentEntityKey, StringComparison.Ordinal));
var actions = CoreActions(entity).ToList();
if (includeSimulationClock)
{
actions.Add(Action("simulation.pause", "Pause", "SetSimulationRate", "simulation", "terminus-clock", ("scalarValue", "0")));
actions.Add(Action("simulation.step", "Advance One Step", "AdvanceSimulationStep", "simulation", "terminus-clock"));
actions.Add(Action("simulation.rate.quarter", "Quarter Speed", "SetSimulationRate", "simulation", "terminus-clock", ("scalarValue", "0.25")));
actions.Add(Action("simulation.rate.half", "Half Speed", "SetSimulationRate", "simulation", "terminus-clock", ("scalarValue", "0.5")));
actions.Add(Action("simulation.rate.realtime", "Real Time", "SetSimulationRate", "simulation", "terminus-clock", ("scalarValue", "1")));
actions.Add(Action("simulation.rate.double", "2x Speed", "SetSimulationRate", "simulation", "terminus-clock", ("scalarValue", "2")));
actions.Add(Action("simulation.rate.quadruple", "4x Speed", "SetSimulationRate", "simulation", "terminus-clock", ("scalarValue", "4")));
actions.Add(Action("simulation.rate.eight", "8x Speed", "SetSimulationRate", "simulation", "terminus-clock", ("scalarValue", "8")));
actions.Add(Action("simulation.rate.sixteen", "16x Speed", "SetSimulationRate", "simulation", "terminus-clock", ("scalarValue", "16")));
actions.Add(Action("simulation.rate.thirty-two", "32x Speed", "SetSimulationRate", "simulation", "terminus-clock", ("scalarValue", "32")));
actions.Add(Action("simulation.rate.sixty-four", "64x Speed", "SetSimulationRate", "simulation", "terminus-clock", ("scalarValue", "64")));
actions.Add(Action("simulation.rate.one-twenty-eight", "128x Speed", "SetSimulationRate", "simulation", "terminus-clock", ("scalarValue", "128")));
}
if (entity != null)
{
actions.AddRange((entity.WeaponGroups ?? Array.Empty<IReadOnlyList<int>>()).Select((_, index) => WeaponGroupAction(run, entity, index)));
actions.AddRange(EquipmentBehaviorActions(run, entity, catalog));
actions.AddRange(ConsumableActions(run, entity, catalog));
actions.AddRange(TradeActions(run, entity, catalog));
}
return new AetheriaRuntimeInputCapabilityDocument { Version = frame?.FrameId ?? 0, Actions = actions.ToArray(), DefaultProfiles = BuildDefaultProfiles(actions) };
}
private static IEnumerable<AetheriaRuntimeInputActionDocument> ConsumableActions(
AetheriaRuntimeRunCheckpointCommit run,
AetheriaRuntimeEntitySnapshotCommit entity,
AetheriaRuntimeCatalogSnapshot? catalog)
{
if (catalog == null)
yield break;
var cargoItems = (entity.CargoContents ?? Array.Empty<AetheriaRuntimeCargoBayLoadoutCommit>())
.SelectMany(bay => bay?.Items ?? Array.Empty<AetheriaRuntimeLoadoutItemSlotCommit>())
.Where(slot => slot?.Item != null)
.Select(slot => slot.Item)
.ToArray();
var activeEffects = (entity.ActiveConsumables ?? Array.Empty<AetheriaRuntimeActiveConsumableCommit>())
.Where(effect => effect != null)
.ToArray();
var itemKeys = cargoItems.Select(item => item.ItemKey)
.Concat(activeEffects.Select(effect => effect.ItemKey))
.Where(itemKey => !string.IsNullOrWhiteSpace(itemKey))
.Distinct(StringComparer.Ordinal);
foreach (var itemKey in itemKeys)
{
var item = catalog.FindItem(itemKey);
if (item == null || !string.Equals(item.Category, AetheriaRuntimeItemCategories.Consumable, StringComparison.Ordinal))
continue;
var quantity = cargoItems
.Where(candidate => string.Equals(candidate.ItemKey, itemKey, StringComparison.Ordinal))
.Sum(candidate => Math.Max(1, candidate.Quantity));
var matchingEffects = activeEffects
.Where(effect => string.Equals(effect.ItemKey, itemKey, StringComparison.Ordinal))
.ToArray();
var active = matchingEffects.FirstOrDefault();
var remainingRatio = active == null || active.Duration <= 0
? 0
: Math.Max(0, Math.Min(1, active.RemainingDuration / active.Duration));
var action = Action(
$"cargo.{itemKey}.use",
$"Use {item.Name ?? itemKey}",
"ActivateConsumable",
"consumable",
$"{run.CurrentEntityKey}#consumable/{itemKey}",
("itemKey", itemKey),
("quantityRemaining", quantity.ToString(System.Globalization.CultureInfo.InvariantCulture)),
("activeEffectCount", matchingEffects.Length.ToString(System.Globalization.CultureInfo.InvariantCulture)),
("remainingDurationSeconds", (active?.RemainingDuration ?? 0).ToString("R", System.Globalization.CultureInfo.InvariantCulture)),
("durationSeconds", (active?.Duration ?? item.Duration).ToString("R", System.Globalization.CultureInfo.InvariantCulture)),
("fillValue", remainingRatio.ToString("R", System.Globalization.CultureInfo.InvariantCulture)),
("fillModel", "remaining-ratio.v1"));
action.Availability = AetheriaRuntimeConsumableSimulation.CanActivate(entity, catalog, itemKey)
? "available"
: "unavailable";
yield return action;
}
}
private static IEnumerable<AetheriaRuntimeInputActionDocument> EquipmentBehaviorActions(
AetheriaRuntimeRunCheckpointCommit run,
AetheriaRuntimeEntitySnapshotCommit entity,
AetheriaRuntimeCatalogSnapshot? catalog)
{
if (catalog == null)
yield break;
var states = (entity.BehaviorStates ?? Array.Empty<AetheriaRuntimeBehaviorStateCommit>())
.Where(value => value != null && string.Equals(value.OwnerKind,
AetheriaRuntimeBehaviorStateProjector.EquipmentOwnerKind, StringComparison.Ordinal))
.ToDictionary(value => (value.OwnerIndex, value.BehaviorIndex));
var online = (entity.EquipmentStates ?? Array.Empty<AetheriaRuntimeEquipmentStateCommit>())
.Where(value => value != null).ToDictionary(value => value.EquipmentIndex);
var equipment = entity.Equipment ?? Array.Empty<AetheriaRuntimeLoadoutItemSlotCommit>();
for (var equipmentIndex = 0; equipmentIndex < equipment.Count; equipmentIndex++)
{
var installed = equipment[equipmentIndex]?.Item;
var item = catalog.FindItem(installed?.ItemKey ?? "");
if (installed == null || item == null)
continue;
var available = installed.Enabled && installed.Durability > 0.01 &&
(!online.TryGetValue(equipmentIndex, out var equipmentState) || equipmentState.Online);
var payloads = item.BehaviorPayloads ?? Array.Empty<AetheriaRuntimeBehaviorPayload>();
for (var behaviorIndex = 0; behaviorIndex < payloads.Count; behaviorIndex++)
{
var payload = payloads[behaviorIndex];
if (payload == null || !states.TryGetValue((equipmentIndex, behaviorIndex), out var state))
continue;
var source = $"{run.CurrentEntityKey}#equipment/{equipmentIndex}/behavior/{behaviorIndex}";
var actionId = $"equipment.{equipmentIndex}.behavior.{behaviorIndex}";
if (string.Equals(payload.Kind, "Switch", StringComparison.Ordinal) ||
string.Equals(payload.Kind, "Trigger", StringComparison.Ordinal))
{
var action = Action(
actionId,
$"{(payload.Kind == "Trigger" ? "Trigger" : "Activate")} {item.Name}",
"SetBehaviorActive",
"equipment",
source,
("equipmentIndex", equipmentIndex.ToString()),
("behaviorIndex", behaviorIndex.ToString()),
("active", "0"),
("currentValue", state.SwitchActivated ? "1" : "0"));
action.Availability = available ? "available" : "unavailable";
action.InputValue = new AetheriaRuntimeInputValueDocument
{
Model = "button-hold.v1",
PayloadKey = "active"
};
yield return action;
continue;
}
if (!string.Equals(payload.Kind, "Thermotoggle", StringComparison.Ordinal) ||
!ReadBool(payload, 3))
continue;
var thermostat = Action(
actionId,
$"Set {item.Name} Target Temperature",
"SetThermotoggleTargetTemperature",
"equipment",
source,
("targetEntityKey", run.CurrentEntityKey),
("equipmentIndex", equipmentIndex.ToString()),
("behaviorIndex", behaviorIndex.ToString()),
("scalarValue", state.ThermotoggleTargetTemperature.ToString("R", System.Globalization.CultureInfo.InvariantCulture)),
("currentValue", state.ThermotoggleTargetTemperature.ToString("R", System.Globalization.CultureInfo.InvariantCulture)),
("unit", "kelvin"));
thermostat.Availability = available ? "available" : "unavailable";
thermostat.InputValue = new AetheriaRuntimeInputValueDocument
{
Model = "scalar.v1",
PayloadKey = "scalarValue"
};
yield return thermostat;
}
}
}
private static AetheriaRuntimeInputActionDocument WeaponGroupAction(
AetheriaRuntimeRunCheckpointCommit run,
AetheriaRuntimeEntitySnapshotCommit entity,
int weaponGroup)
{
var activeGroups = entity.ActiveWeaponGroups ?? Array.Empty<bool>();
var active = weaponGroup < activeGroups.Count && activeGroups[weaponGroup];
var action = Action(
$"weapon-group.{weaponGroup}.fire",
$"Fire Weapon Group {weaponGroup + 1}",
"SetWeaponGroupActive",
"weapon-group",
$"{run.CurrentEntityKey}#weapon-group/{weaponGroup}",
("weaponGroup", weaponGroup.ToString()),
("active", "0"),
("currentValue", active ? "1" : "0"));
action.InputValue = new AetheriaRuntimeInputValueDocument
{
Model = "button-hold.v1",
PayloadKey = "active"
};
return action;
}
private static bool ReadBool(AetheriaRuntimeBehaviorPayload payload, int key) =>
(payload.Fields ?? Array.Empty<AetheriaRuntimeBehaviorField>())
.FirstOrDefault(field => field != null && field.Key == key)?.Value?.BoolValue ?? false;
private static IEnumerable<AetheriaRuntimeInputActionDocument> TradeActions(
AetheriaRuntimeRunCheckpointCommit run,
AetheriaRuntimeEntitySnapshotCommit entity,
AetheriaRuntimeCatalogSnapshot? catalog)
{
if (catalog == null)
yield break;
var zone = (run.Zones ?? Array.Empty<AetheriaRuntimeZoneSnapshotCommit>())
.FirstOrDefault(candidate => candidate != null && candidate.ZoneIndex == run.CurrentZoneIndex);
var parent = (zone?.Entities ?? Array.Empty<AetheriaRuntimeEntitySnapshotCommit>())
.FirstOrDefault(candidate => candidate != null &&
(candidate.DockingBayAssignments ?? Array.Empty<int>()).Contains(entity.EntityIndex));
if (parent == null)
yield break;
var stationKey = AetheriaRuntimeRunCheckpointCommit.EntityRecordKey(
run.RunId,
run.CurrentZoneIndex,
parent.EntityIndex);
var cargo = parent.CargoContents ?? Array.Empty<AetheriaRuntimeCargoBayLoadoutCommit>();
for (var bayIndex = 0; bayIndex < cargo.Count; bayIndex++)
{
foreach (var slot in cargo[bayIndex]?.Items ?? Array.Empty<AetheriaRuntimeLoadoutItemSlotCommit>())
{
var itemKey = slot?.Item?.ItemKey ?? "";
var typedItem = catalog.FindItem(itemKey);
if (typedItem == null || slot?.Item == null || slot.Item.Quantity <= 0)
continue;
var value = AetheriaRuntimeDaemonTradeItemQueries.TradeItemValue(
typedItem,
slot.Item,
catalog.TradeValueSettings).Price;
var createsShip = !string.IsNullOrWhiteSpace(typedItem.HullType);
var canReceive = createsShip
? (parent.DockingBayAssignments ?? Array.Empty<int>()).Any(index => index < 0)
: AetheriaRuntimeCargoCapacityQueries.UnitsThatFit(entity, catalog, itemKey, 0) > 0;
var action = Action(
$"trade.buy.{StableToken(itemKey)}.{bayIndex}.{slot.X}.{slot.Y}",
$"Buy {typedItem.Name} ({value})",
"TradePurchase",
"trade",
$"{stationKey}#cargo/{bayIndex}/{slot.X}/{slot.Y}",
("itemKey", itemKey),
("quantity", "1"),
("stationEntityKey", stationKey),
("stationCargoIndex", bayIndex.ToString()),
("targetEntityKey", run.CurrentEntityKey),
("targetCargoIndex", "0"),
("sourceX", slot.X.ToString()),
("sourceY", slot.Y.ToString()));
action.Availability = value >= 0 && run.Credits >= value && canReceive
? "available"
: "unavailable";
yield return action;
}
}
var sellerCargo = entity.CargoContents ?? Array.Empty<AetheriaRuntimeCargoBayLoadoutCommit>();
for (var bayIndex = 0; bayIndex < sellerCargo.Count; bayIndex++)
{
foreach (var slot in sellerCargo[bayIndex]?.Items ?? Array.Empty<AetheriaRuntimeLoadoutItemSlotCommit>())
{
var itemKey = slot?.Item?.ItemKey ?? "";
var typedItem = catalog.FindItem(itemKey);
if (typedItem == null || slot?.Item == null || slot.Item.Quantity <= 0)
continue;
var value = AetheriaRuntimeDaemonTradeItemQueries.TradeItemValue(
typedItem,
slot.Item,
catalog.TradeValueSettings).Price;
var stationCanReceive = Enumerable.Range(0, parent.CargoBays?.Count ?? 0)
.Any(stationBayIndex =>
stationBayIndex < (parent.CargoContents?.Count ?? 0) &&
AetheriaRuntimeCargoCapacityQueries.UnitsThatFit(
parent,
catalog,
itemKey,
stationBayIndex) > 0);
var action = Action(
$"trade.sell.{StableToken(itemKey)}.{bayIndex}.{slot.X}.{slot.Y}",
$"Sell {typedItem.Name} (+{value})",
"TradeSale",
"trade",
$"{run.CurrentEntityKey}#cargo/{bayIndex}/{slot.X}/{slot.Y}",
("itemKey", itemKey),
("quantity", "1"),
("sourceCargoIndex", bayIndex.ToString()),
("sourceX", slot.X.ToString()),
("sourceY", slot.Y.ToString()));
action.Availability = value >= 0 && stationCanReceive
? "available"
: "unavailable";
yield return action;
}
}
}
private static string StableToken(string value) =>
new string((value ?? "").Select(character => char.IsLetterOrDigit(character) ? char.ToLowerInvariant(character) : '-').ToArray()).Trim('-');
private static IEnumerable<AetheriaRuntimeInputActionDocument> CoreActions(
AetheriaRuntimeEntitySnapshotCommit? entity)
{
var scoop = Action("pilot.scoop", "Scoop", "SetTractorPower", "ship", "pilot", ("scalarValue", "0"));
scoop.InputValue = new AetheriaRuntimeInputValueDocument
{
Model = "button-hold.v1",
PayloadKey = "scalarValue"
};
yield return scoop;
yield return Action("pilot.interact", "Interact", "Interact", "ship", "pilot");
yield return Action("pilot.dock", "Dock", "DockNearest", "ship", "pilot");
yield return Action("pilot.undock", "Undock", "Undock", "ship", "pilot");
var visibleHostileCount = (entity?.Contacts ?? Array.Empty<AetheriaRuntimeEntityContactCommit>())
.Count(contact => contact != null && contact.Visible && contact.Hostile);
var currentTarget = entity?.TargetEntityIndex ?? -1;
yield return TargetAction("pilot.target-nearest", "Target Nearest", "TargetNearest",
visibleHostileCount > 0, currentTarget, visibleHostileCount);
yield return TargetAction("pilot.target-previous", "Target Previous", "TargetPrevious",
visibleHostileCount > 0, currentTarget, visibleHostileCount);
yield return TargetAction("pilot.target-next", "Target Next", "TargetNext",
visibleHostileCount > 0, currentTarget, visibleHostileCount);
yield return TargetAction("pilot.target-clear", "Clear Target", "ClearTarget",
currentTarget >= 0, currentTarget, visibleHostileCount);
}
private static AetheriaRuntimeInputActionDocument TargetAction(
string id,
string label,
string operation,
bool available,
int currentTarget,
int visibleHostileCount)
{
var action = Action(
id,
label,
operation,
"targeting",
"pilot",
("currentTargetEntityIndex", currentTarget.ToString(System.Globalization.CultureInfo.InvariantCulture)),
("visibleHostileCount", visibleHostileCount.ToString(System.Globalization.CultureInfo.InvariantCulture)));
action.Availability = available ? "available" : "unavailable";
return action;
}
private static AetheriaRuntimeInputActionDocument Action(string id, string label, string operation, string category, string source, params (string Key, string Value)[] payload) =>
new AetheriaRuntimeInputActionDocument { ActionId = id, Label = label, Operation = "aetheria.daemon.commands." + operation, Category = category, SourceRef = source, Payload = payload.ToDictionary(entry => entry.Key, entry => entry.Value, StringComparer.Ordinal) };
private static AetheriaRuntimeInputProfileDocument[] BuildDefaultProfiles(IReadOnlyCollection<AetheriaRuntimeInputActionDocument> actions)
{
return new[]
{
Profile("keyboard-mouse", "keyboard-mouse", DefaultBindings(actions, "mouse.primary", "gamepad.rightTrigger", keyboard: true)),
Profile("gamepad", "gamepad", DefaultBindings(actions, "mouse.primary", "gamepad.rightTrigger", keyboard: false))
};
}
private static AetheriaRuntimeInputBindingDocument[] DefaultBindings(
IReadOnlyCollection<AetheriaRuntimeInputActionDocument> actions,
string keyboardFireControl,
string gamepadFireControl,
bool keyboard)
{
var bindings = new List<AetheriaRuntimeInputBindingDocument>();
var fire = actions.FirstOrDefault(action => string.Equals(action.Category, "weapon-group", StringComparison.Ordinal));
if (fire != null)
bindings.Add(Binding("fire.default", fire.ActionId, "direct", keyboard ? keyboardFireControl : gamepadFireControl));
bindings.Add(keyboard
? Binding("scoop.shift", "pilot.scoop", "direct", "keyboard.leftShift")
: Binding("scoop.sequence", "pilot.scoop", "sequence", "gamepad.dpad.down", "gamepad.dpad.right"));
bindings.Add(keyboard
? Binding("interact.f", "pilot.interact", "direct", "keyboard.f")
: Binding("interact.sequence", "pilot.interact", "sequence", "gamepad.dpad.down", "gamepad.dpad.up"));
if (keyboard)
{
bindings.Add(Binding("target.nearest.t", "pilot.target-nearest", "direct", "keyboard.t"));
bindings.Add(Binding("target.previous.y", "pilot.target-previous", "direct", "keyboard.y"));
bindings.Add(Binding("target.next.u", "pilot.target-next", "direct", "keyboard.u"));
}
if (actions.Any(action => string.Equals(action.ActionId, "simulation.pause", StringComparison.Ordinal)))
bindings.Add(keyboard
? Binding("simulation.pause", "simulation.pause", "direct", "keyboard.pause")
: Binding("simulation.pause.sequence", "simulation.pause", "sequence", "gamepad.dpad.left", "gamepad.dpad.left"));
return bindings.ToArray();
}
public EveInputCapabilityDocument ToEveDocument() => new EveInputCapabilityDocument
{
ProviderId = ProviderId,
CapabilityId = CapabilityId,
Version = Version,
Actions = Actions.Select(action => new EveInputActionDocument
{
ActionId = action.ActionId,
Label = action.Label,
Operation = action.Operation,
Context = action.Context,
Category = action.Category,
Availability = action.Availability,
SourceRef = action.SourceRef,
Payload = new Dictionary<string, string>(action.Payload, StringComparer.Ordinal),
InputValue = action.InputValue == null
? null
: new EveInputValueDocument
{
Model = action.InputValue.Model,
PayloadKey = action.InputValue.PayloadKey
}
}).ToArray(),
DefaultProfiles = DefaultProfiles.Select(profile => new EveInputProfileDocument
{
ProfileId = profile.ProfileId,
DeviceClass = profile.DeviceClass,
Bindings = profile.Bindings.Select(binding => new EveInputBindingDocument
{
BindingId = binding.BindingId,
ActionId = binding.ActionId,
ActionBar = binding.ActionBar,
Gesture = new EveInputGestureDocument
{
Kind = binding.Gesture.Kind,
Controls = binding.Gesture.Controls,
MaxStepIntervalMs = binding.Gesture.MaxStepIntervalMs,
CompletionControl = binding.Gesture.CompletionControl
}
}).ToArray()
}).ToArray()
};
private static AetheriaRuntimeInputProfileDocument Profile(string id, string device, params AetheriaRuntimeInputBindingDocument[] bindings) => new AetheriaRuntimeInputProfileDocument { ProfileId = id, DeviceClass = device, Bindings = bindings };
private static AetheriaRuntimeInputBindingDocument Binding(string id, string action, string kind, params string[] controls) => new AetheriaRuntimeInputBindingDocument { BindingId = id, ActionId = action, Gesture = new AetheriaRuntimeInputGestureDocument { Kind = kind, Controls = controls }, ActionBar = true };
}
}