Bridge/API Layer - Lua ↔ UI Communication

// Method 1: useBridge composable
import { useBridge } from '@/bridge'
const { lua, api, events, streams } = useBridge()

// Method 2: Direct imports
import { lua } from '@/bridge'

// Method 3: Via useLibStore (in apps)
import { useLibStore } from '@/services'
const { $game } = useLibStore()
// $game.lua, $game.events, $game.streams, $game.api

import { useEvents } from '@/services/events'

// Auto-cleanup on component unmount
const events = useEvents()

events.on('MyEvent', (data) => {
  console.log('Received:', data)
})

events.once('OneTimeEvent', (data) => {
  // Only fires once
})

// Manual cleanup (if needed)
events.off('MyEvent', handler)

events.emit('MyCustomEvent', { data: 'value' })

import { useStreams } from '@/services/events'

// Subscribe to streams (auto-cleanup on unmount)
useStreams(['electrics', 'sensors'], (streams) => {
  if (streams.electrics) {
    const speed = streams.electrics.wheelspeed
    const rpm = streams.electrics.rpm
  }
  if (streams.sensors) {
    const yaw = streams.sensors.yaw
  }
})

import { useBridge } from '@/bridge'
const { streams, events } = useBridge()

// Subscribe
streams.add(['electrics', 'engineInfo'])

// Listen for updates
events.on('onStreamsUpdate', (data) => {
  console.log('Speed:', data.electrics?.wheelspeed)
})

// Unsubscribe
streams.remove(['electrics', 'engineInfo'])

// electrics stream
{
  wheelspeed: 15.5,       // m/s
  rpm: 3500,
  gear: 3,
  gearIndex: 4,           // Including neutral/reverse
  fuel: 0.75,
  lowbeam: true,
  highbeam: false,
  signal_L: false,
  signal_R: false,
  hazard: false,
  ignitionLevel: 2,       // 0=off, 1=acc, 2=on
  parkingbrake: 0,
  abs: false,
  esc: false
}

// sensors stream
{
  yaw: 1.57,              // radians
  pitch: 0.02,
  roll: 0.01,
  gravity: { x: 0, y: 0, z: -9.81 },
  gx: 0.1,                // G-forces
  gy: 0.0,
  gz: 1.0
}

// engineInfo stream
{
  maxRPM: 7000,
  idleRPM: 800,
  shiftUpRPM: 6500,
  shiftDownRPM: 2000
}

import { lua } from '@/bridge'

// Call extension function (returns Promise)
const result = await lua.extensions.myExtension.myFunction(arg1, arg2)

// Call career module
await lua.career_modules_fuel.requestRefuelingTransactionData()

// Call core function
const details = await lua.core_vehicles.getCurrentVehicleDetails()

// Check extension state
const isActive = await lua.career_career.isActive()

// bridge/LuaFunctionSignatures.js
export default {
  career_career: {
    isActive: () => {},                              // No params
    createOrLoadCareerAndStart: (id, auto, tut) =>  // Typed params
      [String, Any, Boolean]
  },
  
  guihooks: {
    trigger: hookName => String                      // String param
  },
  
  core_vehicles: {
    getCurrentVehicleDetails: () => {}               // No params, returns object
  }
}

import { runRaw } from '@/bridge/libs/Lua.js'

// Execute arbitrary Lua code
const result = await runRaw('extensions.myMod.customFunction("arg")')

// Without promise (fire-and-forget)
runRaw('print("Hello from JS")', false)

import { useBridge } from '@/bridge'
const { api } = useBridge()

// Execute on active vehicle (VE context)
api.activeObjectLua('electrics.setIgnitionLevel(2)')

// Execute on game engine
api.engineLua('print("Hello")', (result) => {
  console.log('Result:', result)
})

// bridge/libs/Hooks.js
const mainHookHandler = function(hookName, args) {
  // Dispatch to Vue event bus
  window.vueEventBus?.emit(hookName, ...args)
  
  // Dispatch to Angular (legacy)
  window.globalAngularRootScope?.$broadcast(hookName, ...args)
}

// bridge/coordinator/lite.js

// Before broadcasting streams
coordinator.beforeBroadcast()

// Emit stream update
vueEventBus.emit('onStreamsUpdate', data)

// After broadcast - wait for Vue.nextTick and Angular $timeout
coordinator.afterBroadcast(() => {
  // Signal game engine that UI frame is complete
  window.beamng?.uiFrameCallback?.()
})

import { gameBlurrer } from '@/bridge'

// Register a blur region (returns an ID string)
const id = gameBlurrer.register({ x: 0, y: 0, width: 100, height: 100 })

// Update a registered blur region
gameBlurrer.update(id, { x: 10, y: 10, width: 200, height: 200 })

// Unregister a blur region
gameBlurrer.unregister(id)

import { useBridge } from '@/bridge'
const { units } = useBridge()

// Unit settings are keyed by category
// e.g. 'uiUnitLength', 'uiUnitTemperature', 'uiUnitWeight', etc.
// Categories: length, speed, temperature, weight, consumptionRate,
//             torque, energy, date, power, volume, pressure

// The units object provides conversion methods per category
// Settings can be 'metric'/'imperial' or specific unit strings like 'bhp', 'psi', 'gal'

import { onMounted, ref } from 'vue'
import { lua } from '@/bridge'

const data = ref(null)

onMounted(async () => {
  data.value = await lua.myExtension.getData()
})

import { ref, onMounted, onUnmounted } from 'vue'
import { useBridge } from '@/bridge'

const { events } = useBridge()
const isActive = ref(false)

function onStateChange(data) {
  isActive.value = data.active
}

onMounted(() => {
  events.on('MyStateChanged', onStateChange)
})

onUnmounted(() => {
  events.off('MyStateChanged', onStateChange)
})

import { ref, onMounted, onUnmounted } from 'vue'
import { useLibStore } from '@/services'

const { $game } = useLibStore()
const speed = ref(0)
const vehicleName = ref('')

onMounted(() => {
  // Stream for continuous data
  $game.streams.add(['electrics'])
  $game.events.on('onStreamsUpdate', onStreams)
  
  // Event for discrete changes
  $game.events.on('VehicleChange', onVehicleChange)
})

onUnmounted(() => {
  $game.streams.remove(['electrics'])
  $game.events.off('onStreamsUpdate', onStreams)
  $game.events.off('VehicleChange', onVehicleChange)
})

function onStreams(streams) {
  speed.value = streams.electrics?.wheelspeed || 0
}

async function onVehicleChange() {
  const details = await $game.lua.core_vehicles.getCurrentVehicleDetails()
  vehicleName.value = details?.configs?.Name || 'Unknown'
}