@hla4ts/spacekit 0.1.0

package/src/spacefom-entities.ts

@@ -0,0 +1,546 @@
+import { decodeHLAinteger64Time, encodeHLAinteger64Time } from "@hla4ts/hla-api";
+import { FomAttribute, FomObjectClass } from "./decorators.ts";
+import { SpacekitEntity } from "./entity.ts";
+import type { SpaceFomExecutionMode } from "@hla4ts/spacefom";
+import {
+  decodeAttitudeQuaternion,
+  decodeFloat64LE,
+  decodeHLAunicodeString,
+  decodeInt16LE,
+  decodeMatrix3,
+  decodeSpaceTimeCoordinateState,
+  decodeVector3,
+  encodeAttitudeQuaternion,
+  encodeFloat64LE,
+  encodeHLAunicodeString,
+  encodeInt16LE,
+  encodeMatrix3,
+  encodeSpaceTimeCoordinateState,
+  encodeVector3,
+  type AttitudeQuaternion,
+  type Matrix3,
+  type SpaceTimeCoordinateState,
+  type Vector3,
+} from "@hla4ts/spacefom";
+
+export interface ExecutionConfigurationAttributes {
+  root_frame_name: string;
+  scenario_time_epoch: number;
+  current_execution_mode: SpaceFomExecutionMode;
+  next_execution_mode: SpaceFomExecutionMode;
+  next_mode_scenario_time: number;
+  next_mode_cte_time: number;
+  least_common_time_step: bigint;
+}
+
+@FomObjectClass({ name: ExecutionConfiguration.className, sharing: "Subscribe" })
+export class ExecutionConfiguration
+  extends SpacekitEntity<ExecutionConfigurationAttributes>
+  implements ExecutionConfigurationAttributes
+{
+  static readonly className: string = "HLAobjectRoot.ExecutionConfiguration";
+
+  @FomAttribute({
+    name: "root_frame_name",
+    dataType: "HLAunicodeString",
+    updateType: "Static",
+    updateCondition: "during initialization",
+    ownership: "NoTransfer",
+    sharing: "Subscribe",
+    transportation: "HLAreliable",
+    order: "TimeStamp",
+    encode: encodeHLAunicodeString,
+    decode: decodeHLAunicodeString,
+  })
+  root_frame_name: string;
+
+  @FomAttribute({
+    name: "scenario_time_epoch",
+    dataType: "HLAfloat64LE",
+    updateType: "Static",
+    updateCondition: "during initialization",
+    ownership: "NoTransfer",
+    sharing: "Subscribe",
+    transportation: "HLAreliable",
+    order: "TimeStamp",
+    encode: encodeFloat64LE,
+    decode: decodeFloat64LE,
+  })
+  scenario_time_epoch: number;
+
+  @FomAttribute({
+    name: "current_execution_mode",
+    dataType: "HLAinteger16LE",
+    updateType: "Periodic",
+    updateCondition: "when changes",
+    ownership: "NoTransfer",
+    sharing: "Subscribe",
+    transportation: "HLAreliable",
+    order: "TimeStamp",
+    encode: encodeInt16LE,
+    decode: decodeInt16LE,
+  })
+  current_execution_mode: SpaceFomExecutionMode;
+
+  @FomAttribute({
+    name: "next_execution_mode",
+    dataType: "HLAinteger16LE",
+    updateType: "Periodic",
+    updateCondition: "when changes",
+    ownership: "NoTransfer",
+    sharing: "Subscribe",
+    transportation: "HLAreliable",
+    order: "TimeStamp",
+    encode: encodeInt16LE,
+    decode: decodeInt16LE,
+  })
+  next_execution_mode: SpaceFomExecutionMode;
+
+  @FomAttribute({
+    name: "next_mode_scenario_time",
+    dataType: "HLAfloat64LE",
+    updateType: "Periodic",
+    updateCondition: "when changes",
+    ownership: "NoTransfer",
+    sharing: "Subscribe",
+    transportation: "HLAreliable",
+    order: "TimeStamp",
+    encode: encodeFloat64LE,
+    decode: decodeFloat64LE,
+  })
+  next_mode_scenario_time: number;
+
+  @FomAttribute({
+    name: "next_mode_cte_time",
+    dataType: "HLAfloat64LE",
+    updateType: "Periodic",
+    updateCondition: "when changes",
+    ownership: "NoTransfer",
+    sharing: "Subscribe",
+    transportation: "HLAreliable",
+    order: "TimeStamp",
+    encode: encodeFloat64LE,
+    decode: decodeFloat64LE,
+  })
+  next_mode_cte_time: number;
+
+  @FomAttribute({
+    name: "least_common_time_step",
+    dataType: "HLAinteger64Time",
+    updateType: "Static",
+    updateCondition: "during initialization",
+    ownership: "NoTransfer",
+    sharing: "Subscribe",
+    transportation: "HLAreliable",
+    order: "TimeStamp",
+    encode: encodeHLAinteger64Time,
+    decode: decodeHLAinteger64Time,
+  })
+  least_common_time_step: bigint;
+
+  constructor(partial: Partial<ExecutionConfigurationAttributes> = {}) {
+    super();
+    this.root_frame_name = partial.root_frame_name ?? "";
+    this.scenario_time_epoch = partial.scenario_time_epoch ?? 0;
+    this.current_execution_mode = partial.current_execution_mode ?? 0;
+    this.next_execution_mode = partial.next_execution_mode ?? 0;
+    this.next_mode_scenario_time = partial.next_mode_scenario_time ?? 0;
+    this.next_mode_cte_time = partial.next_mode_cte_time ?? 0;
+    this.least_common_time_step = partial.least_common_time_step ?? 0n;
+  }
+
+  toAttributes(): ExecutionConfigurationAttributes {
+    return {
+      root_frame_name: this.root_frame_name,
+      scenario_time_epoch: this.scenario_time_epoch,
+      current_execution_mode: this.current_execution_mode,
+      next_execution_mode: this.next_execution_mode,
+      next_mode_scenario_time: this.next_mode_scenario_time,
+      next_mode_cte_time: this.next_mode_cte_time,
+      least_common_time_step: this.least_common_time_step,
+    };
+  }
+}
+
+export interface ReferenceFrameAttributes {
+  name: string;
+  parent_name: string;
+  state: SpaceTimeCoordinateState;
+}
+
+@FomObjectClass({ name: ReferenceFrame.className, sharing: "Subscribe" })
+export class ReferenceFrame
+  extends SpacekitEntity<ReferenceFrameAttributes>
+  implements ReferenceFrameAttributes
+{
+  static readonly className: string = "HLAobjectRoot.ReferenceFrame";
+
+  @FomAttribute({
+    name: "name",
+    dataType: "HLAunicodeString",
+    updateType: "Static",
+    updateCondition: "during initialization",
+    ownership: "NoTransfer",
+    sharing: "Subscribe",
+    transportation: "HLAreliable",
+    order: "TimeStamp",
+    encode: encodeHLAunicodeString,
+    decode: decodeHLAunicodeString,
+  })
+  name: string;
+
+  @FomAttribute({
+    name: "parent_name",
+    dataType: "HLAunicodeString",
+    updateType: "Static",
+    updateCondition: "during initialization",
+    ownership: "NoTransfer",
+    sharing: "Subscribe",
+    transportation: "HLAreliable",
+    order: "TimeStamp",
+    encode: encodeHLAunicodeString,
+    decode: decodeHLAunicodeString,
+  })
+  parent_name: string;
+
+  @FomAttribute({
+    name: "state",
+    dataType: "SpaceTimeCoordinateState",
+    updateType: "Periodic",
+    updateCondition: "when changes",
+    ownership: "NoTransfer",
+    sharing: "Subscribe",
+    transportation: "HLAreliable",
+    order: "TimeStamp",
+    encode: encodeSpaceTimeCoordinateState,
+    decode: decodeSpaceTimeCoordinateState,
+  })
+  state: SpaceTimeCoordinateState;
+
+  constructor(partial: Partial<ReferenceFrameAttributes> = {}) {
+    super();
+    this.name = partial.name ?? "";
+    this.parent_name = partial.parent_name ?? "";
+    this.state = partial.state ?? defaultState();
+  }
+
+  toAttributes(): ReferenceFrameAttributes {
+    return {
+      name: this.name,
+      parent_name: this.parent_name,
+      state: this.state,
+    };
+  }
+}
+
+export interface PhysicalEntityAttributes {
+  name: string;
+  type: string;
+  status: string;
+  parent_reference_frame: string;
+  state: SpaceTimeCoordinateState;
+  acceleration: Vector3;
+  rotational_acceleration: Vector3;
+  center_of_mass: Vector3;
+  body_wrt_structural: AttitudeQuaternion;
+}
+
+@FomObjectClass({ name: PhysicalEntity.className, sharing: "PublishSubscribe" })
+export class PhysicalEntity
+  extends SpacekitEntity<PhysicalEntityAttributes>
+  implements PhysicalEntityAttributes
+{
+  static readonly className: string = "HLAobjectRoot.PhysicalEntity";
+
+  @FomAttribute({
+    name: "name",
+    dataType: "HLAunicodeString",
+    updateType: "Static",
+    updateCondition: "during initialization",
+    ownership: "NoTransfer",
+    sharing: "PublishSubscribe",
+    transportation: "HLAreliable",
+    order: "TimeStamp",
+    encode: encodeHLAunicodeString,
+    decode: decodeHLAunicodeString,
+  })
+  name: string;
+
+  @FomAttribute({
+    name: "type",
+    dataType: "HLAunicodeString",
+    updateType: "Static",
+    updateCondition: "during initialization",
+    ownership: "NoTransfer",
+    sharing: "PublishSubscribe",
+    transportation: "HLAreliable",
+    order: "TimeStamp",
+    encode: encodeHLAunicodeString,
+    decode: decodeHLAunicodeString,
+  })
+  type: string;
+
+  @FomAttribute({
+    name: "status",
+    dataType: "HLAunicodeString",
+    updateType: "Static",
+    updateCondition: "during initialization",
+    ownership: "NoTransfer",
+    sharing: "PublishSubscribe",
+    transportation: "HLAreliable",
+    order: "TimeStamp",
+    encode: encodeHLAunicodeString,
+    decode: decodeHLAunicodeString,
+  })
+  status: string;
+
+  @FomAttribute({
+    name: "parent_reference_frame",
+    dataType: "HLAunicodeString",
+    updateType: "Static",
+    updateCondition: "during initialization",
+    ownership: "NoTransfer",
+    sharing: "PublishSubscribe",
+    transportation: "HLAreliable",
+    order: "TimeStamp",
+    encode: encodeHLAunicodeString,
+    decode: decodeHLAunicodeString,
+  })
+  parent_reference_frame: string;
+
+  @FomAttribute({
+    name: "state",
+    dataType: "SpaceTimeCoordinateState",
+    updateType: "Periodic",
+    updateCondition: "when changes",
+    ownership: "DivestAcquire",
+    sharing: "PublishSubscribe",
+    transportation: "HLAreliable",
+    order: "TimeStamp",
+    encode: encodeSpaceTimeCoordinateState,
+    decode: decodeSpaceTimeCoordinateState,
+  })
+  state: SpaceTimeCoordinateState;
+
+  @FomAttribute({
+    name: "acceleration",
+    dataType: "HLAfixedArray",
+    updateType: "Periodic",
+    updateCondition: "when changes",
+    ownership: "DivestAcquire",
+    sharing: "PublishSubscribe",
+    transportation: "HLAreliable",
+    order: "TimeStamp",
+    encode: encodeVector3,
+    decode: decodeVector3,
+  })
+  acceleration: Vector3;
+
+  @FomAttribute({
+    name: "rotational_acceleration",
+    dataType: "HLAfixedArray",
+    updateType: "Periodic",
+    updateCondition: "when changes",
+    ownership: "DivestAcquire",
+    sharing: "PublishSubscribe",
+    transportation: "HLAreliable",
+    order: "TimeStamp",
+    encode: encodeVector3,
+    decode: decodeVector3,
+  })
+  rotational_acceleration: Vector3;
+
+  @FomAttribute({
+    name: "center_of_mass",
+    dataType: "HLAfixedArray",
+    updateType: "Static",
+    updateCondition: "during initialization",
+    ownership: "NoTransfer",
+    sharing: "PublishSubscribe",
+    transportation: "HLAreliable",
+    order: "TimeStamp",
+    encode: encodeVector3,
+    decode: decodeVector3,
+  })
+  center_of_mass: Vector3;
+
+  @FomAttribute({
+    name: "body_wrt_structural",
+    dataType: "HLAfixedRecord",
+    updateType: "Static",
+    updateCondition: "during initialization",
+    ownership: "NoTransfer",
+    sharing: "PublishSubscribe",
+    transportation: "HLAreliable",
+    order: "TimeStamp",
+    encode: encodeAttitudeQuaternion,
+    decode: decodeAttitudeQuaternion,
+  })
+  body_wrt_structural: AttitudeQuaternion;
+
+  constructor(name: string, partial: Partial<PhysicalEntityAttributes> = {}) {
+    super();
+    this.name = name;
+    this.type = partial.type ?? "";
+    this.status = partial.status ?? "";
+    this.parent_reference_frame = partial.parent_reference_frame ?? "";
+    this.state = partial.state ?? defaultState();
+    this.acceleration = partial.acceleration ?? [0, 0, 0];
+    this.rotational_acceleration = partial.rotational_acceleration ?? [0, 0, 0];
+    this.center_of_mass = partial.center_of_mass ?? [0, 0, 0];
+    this.body_wrt_structural =
+      partial.body_wrt_structural ?? { scalar: 1, vector: [0, 0, 0] };
+  }
+
+  toAttributes(): PhysicalEntityAttributes {
+    return {
+      name: this.name,
+      type: this.type,
+      status: this.status,
+      parent_reference_frame: this.parent_reference_frame,
+      state: this.state,
+      acceleration: this.acceleration,
+      rotational_acceleration: this.rotational_acceleration,
+      center_of_mass: this.center_of_mass,
+      body_wrt_structural: this.body_wrt_structural,
+    };
+  }
+}
+
+export interface DynamicalEntityAttributes extends PhysicalEntityAttributes {
+  force: Vector3;
+  torque: Vector3;
+  mass: number;
+  mass_rate: number;
+  inertia: Matrix3;
+  inertia_rate: Matrix3;
+}
+
+@FomObjectClass({ name: DynamicalEntity.className, sharing: "PublishSubscribe" })
+export class DynamicalEntity extends PhysicalEntity implements DynamicalEntityAttributes {
+  static readonly className: string = "HLAobjectRoot.PhysicalEntity.DynamicalEntity";
+
+  @FomAttribute({
+    name: "force",
+    dataType: "HLAfixedArray",
+    updateType: "Periodic",
+    updateCondition: "when changes",
+    ownership: "DivestAcquire",
+    sharing: "PublishSubscribe",
+    transportation: "HLAreliable",
+    order: "TimeStamp",
+    encode: encodeVector3,
+    decode: decodeVector3,
+  })
+  force: Vector3;
+
+  @FomAttribute({
+    name: "torque",
+    dataType: "HLAfixedArray",
+    updateType: "Periodic",
+    updateCondition: "when changes",
+    ownership: "DivestAcquire",
+    sharing: "PublishSubscribe",
+    transportation: "HLAreliable",
+    order: "TimeStamp",
+    encode: encodeVector3,
+    decode: decodeVector3,
+  })
+  torque: Vector3;
+
+  @FomAttribute({
+    name: "mass",
+    dataType: "HLAfloat64LE",
+    updateType: "Periodic",
+    updateCondition: "when changes",
+    ownership: "DivestAcquire",
+    sharing: "PublishSubscribe",
+    transportation: "HLAreliable",
+    order: "TimeStamp",
+    encode: encodeFloat64LE,
+    decode: decodeFloat64LE,
+  })
+  mass: number;
+
+  @FomAttribute({
+    name: "mass_rate",
+    dataType: "HLAfloat64LE",
+    updateType: "Periodic",
+    updateCondition: "when changes",
+    ownership: "DivestAcquire",
+    sharing: "PublishSubscribe",
+    transportation: "HLAreliable",
+    order: "TimeStamp",
+    encode: encodeFloat64LE,
+    decode: decodeFloat64LE,
+  })
+  mass_rate: number;
+
+  @FomAttribute({
+    name: "inertia",
+    dataType: "HLAfixedArray",
+    updateType: "Periodic",
+    updateCondition: "when changes",
+    ownership: "DivestAcquire",
+    sharing: "PublishSubscribe",
+    transportation: "HLAreliable",
+    order: "TimeStamp",
+    encode: encodeMatrix3,
+    decode: decodeMatrix3,
+  })
+  inertia: Matrix3;
+
+  @FomAttribute({
+    name: "inertia_rate",
+    dataType: "HLAfixedArray",
+    updateType: "Periodic",
+    updateCondition: "when changes",
+    ownership: "DivestAcquire",
+    sharing: "PublishSubscribe",
+    transportation: "HLAreliable",
+    order: "TimeStamp",
+    encode: encodeMatrix3,
+    decode: decodeMatrix3,
+  })
+  inertia_rate: Matrix3;
+
+  constructor(name: string, partial: Partial<DynamicalEntityAttributes> = {}) {
+    super(name, partial);
+    this.force = partial.force ?? [0, 0, 0];
+    this.torque = partial.torque ?? [0, 0, 0];
+    this.mass = partial.mass ?? 0;
+    this.mass_rate = partial.mass_rate ?? 0;
+    this.inertia = partial.inertia ?? zeroMatrix();
+    this.inertia_rate = partial.inertia_rate ?? zeroMatrix();
+  }
+
+  override toAttributes(): DynamicalEntityAttributes {
+    return {
+      ...super.toAttributes(),
+      force: this.force,
+      torque: this.torque,
+      mass: this.mass,
+      mass_rate: this.mass_rate,
+      inertia: this.inertia,
+      inertia_rate: this.inertia_rate,
+    };
+  }
+}
+
+function defaultState(): SpaceTimeCoordinateState {
+  return {
+    translation: {
+      position: [0, 0, 0],
+      velocity: [0, 0, 0],
+    },
+    rotation: {
+      attitude: { scalar: 1, vector: [0, 0, 0] },
+      angularVelocity: [0, 0, 0],
+    },
+    time: 0,
+  };
+}
+
+function zeroMatrix(): Matrix3 {
+  return [0, 0, 0, 0, 0, 0, 0, 0, 0];
+}

package/src/spacefom-interactions.ts

@@ -0,0 +1,33 @@
+import { FomInteractionClass, FomParameter } from "./decorators.ts";
+import type { SpaceFomMtrMode } from "@hla4ts/spacefom";
+import { decodeInt16LE, encodeInt16LE } from "@hla4ts/spacefom";
+
+export interface ModeTransitionRequestParameters {
+  execution_mode: SpaceFomMtrMode;
+}
+
+@FomInteractionClass({
+  name: ModeTransitionRequest.className,
+  sharing: "PublishSubscribe",
+  transportation: "HLAreliable",
+  order: "Receive",
+})
+export class ModeTransitionRequest implements ModeTransitionRequestParameters {
+  static readonly className: string = "HLAinteractionRoot.ModeTransitionRequest";
+
+  @FomParameter({
+    name: "execution_mode",
+    dataType: "HLAinteger16LE",
+    encode: encodeInt16LE,
+    decode: decodeInt16LE,
+  })
+  execution_mode: SpaceFomMtrMode;
+
+  constructor(execution_mode: SpaceFomMtrMode) {
+    this.execution_mode = execution_mode;
+  }
+
+  toParameters(): ModeTransitionRequestParameters {
+    return { execution_mode: this.execution_mode };
+  }
+}

package/src/time-advance.ts

@@ -0,0 +1,46 @@
+import { decodeHLAinteger64Time, encodeHLAinteger64Time, type LogicalTime } from "@hla4ts/hla-api";
+import type { RTIAmbassador } from "@hla4ts/hla-api";
+import type { FederateHandlers } from "./types.ts";
+
+export class TimeAdvanceController {
+  readonly handlers: FederateHandlers;
+  private _resolveGrant: ((time: bigint) => void) | null = null;
+  private _rejectGrant: ((err: Error) => void) | null = null;
+  private _lastGrantedTimeMicros: bigint | null = null;
+
+  constructor() {
+    this.handlers = {
+      timeAdvanceGrant: (time: LogicalTime) => {
+        const timeMicros = decodeHLAinteger64Time(time);
+        this._lastGrantedTimeMicros = timeMicros;
+        if (this._resolveGrant) {
+          this._resolveGrant(timeMicros);
+          this._resolveGrant = null;
+          this._rejectGrant = null;
+        }
+      },
+    };
+  }
+
+  get lastGrantedTimeMicros(): bigint | null {
+    return this._lastGrantedTimeMicros;
+  }
+
+  async advanceTo(rti: RTIAmbassador, timeMicros: bigint): Promise<bigint> {
+    const requestTime = encodeHLAinteger64Time(timeMicros);
+    const promise = new Promise<bigint>((resolve, reject) => {
+      this._resolveGrant = resolve;
+      this._rejectGrant = reject;
+    });
+    await rti.timeAdvanceRequest(requestTime);
+    return promise;
+  }
+
+  cancel(err: Error): void {
+    if (this._rejectGrant) {
+      this._rejectGrant(err);
+      this._resolveGrant = null;
+      this._rejectGrant = null;
+    }
+  }
+}

package/src/types.ts

@@ -0,0 +1,27 @@
+import type { RTIAmbassadorOptions, ConnectionOptions } from "@hla4ts/hla-api";
+import type { FomModuleSet } from "@hla4ts/hla-api";
+import type { FomRegistry, FomModel, FomOutputFormat, FomOutputOptions } from "@hla4ts/fom-codegen";
+export interface SpacekitFomConfig {
+  /** Base FOM modules already available in the federation. */
+  baseModules?: FomModuleSet;
+  /** Extension module generated from registry/model/xml. */
+  extension?: {
+    registry?: FomRegistry;
+    model?: FomModel;
+    xml?: string;
+    format?: FomOutputFormat;
+    outputOptions?: Partial<FomOutputOptions>;
+  };
+}
+
+export interface SpacekitFederateConfig {
+  rti: RTIAmbassadorOptions;
+  connection: ConnectionOptions;
+  federationName: string;
+  federateType: string;
+  federateName?: string;
+  fom?: SpacekitFomConfig;
+  resignAction?: import("@hla4ts/hla-api").ResignAction;
+}
+
+export type FederateHandlers = Partial<import("@hla4ts/hla-api").FederateAmbassador>;