Server

These exports keep custom logic in sync with Nexure Racing. Mix and match them to automate scheduling, power scoreboard bots, or drive framework integrations.

`nx_racing.createRace`

exports.nx_racing:createRace(data)

data is a table describing the race:

Field	Type	Description
`track`	`table`	`{ random = boolean, verified = boolean, trackId = number }` lets you pick a random verified track or a specific ID.
`laps`	`number`	Number of laps.
`startTime`	`number`	Milliseconds until the race starts.
`phasingOn`	`boolean`	Enable collision phasing.
`phasingTime`	`number`	Duration of phasing in milliseconds.
`buyIn`	`number`	Entry fee (`0` for free).
`camera`	`string`	`"unset"` or `"first"` to control enforcement.
`class`	`number`	`0` for all classes, otherwise index from `Config.vehicleClasses.classes`.
`moneyPrize`	`number`	Prize pool (`0` for unranked).
`raceType`	`string`	`"ranked"` or `"unranked"`; ranked races require a `moneyPrize`.

-- Random verified ranked race
exports.nx_racing:createRace({
  track = { random = true, verified = true },
  laps = 5,
  startTime = 10_000,
  phasingOn = true,
  phasingTime = 15_000,
  buyIn = 500,
  camera = 'unset',
  class = 0,
  moneyPrize = 10_000,
  raceType = 'ranked'
})

-- Unranked race on a specific track
exports.nx_racing:createRace({
  track = { random = false, trackId = 12 },
  laps = 3,
  startTime = 5_000,
  phasingOn = false,
  phasingTime = 0,
  buyIn = 0,
  camera = 'first',
  class = 1,
  moneyPrize = 0,
  raceType = 'unranked'
})

`nx_racing.getActiveRaces`

local activeRaces = exports.nx_racing:getActiveRaces()

Returns a table (possibly empty) of open or in-progress races:

Field	Type	Description
`raceId`	`number`	Unique race identifier.
`trackId`	`number`	Track identifier.
`status`	`number`	`0` = open for participants, `1` = running.

local races = exports.nx_racing:getActiveRaces()

if #races == 0 then
  print('No active races')
else
  for _, race in ipairs(races) do
    print(('Race %d on track %d (status %d)'):format(race.raceId, race.trackId, race.status))
  end
end

`nx_racing.getOngoingRaceData`

local raceData = exports.nx_racing:getOngoingRaceData(raceId)

raceId (number): ID from getActiveRaces or an event payload.

Returns false if the race does not exist or has finished.

Field	Type	Description
`status`	`number`	Race status.
`createdTime`	`number`	Timestamp of creation.
`raceType`	`string`	e.g. `timeTrial`, `circuit`.
`moneyPrize`	`number`	Prize pool.
`trackId`	`number`	Track identifier.
`trackName`	`string`	Track name.
`trackType`	`string`	Track type.
`trackLaps`	`number`	Lap count.
`track`	`table`	Track metadata.
`phasingOn`	`boolean`	Phasing enabled.
`phasingTime`	`number`	Phasing duration in seconds.
`checkpoints`	`table`	Checkpoint data.
`players`	`table`	Detailed racer entries.
`playerList`	`table`	Player identifiers.
`buyIn`	`number`	Entry fee.
`camera`	`boolean`	Whether a forced camera was set.
`class`	`number`	Allowed class.
`totalRaceDistance`	`number`	Distance in meters.

local details = exports.nx_racing:getOngoingRaceData(123)

if details then
  print(('Track: %s (%d racers)'):format(details.trackName, #details.players))
else
  print('Race not found or already finished')
end

`nx_racing.getRacer`

local racer = exports.nx_racing:getRacer(source)

source (number): Player server ID.

Returns false if the player cannot be resolved.

Field	Type	Description
`id`	`number`	Racing ID.
`name`	`string`	Display name.
`avatar`	`string`	Avatar URL.
`mmr`	`number`	Current ranking MMR.

local racer = exports.nx_racing:getRacer(source)
if racer then
  print(('Racer %s has %d MMR'):format(racer.name, racer.mmr))
else
  print('Player not registered')
end

`nx_racing.getRacerById`

local racer = exports.nx_racing:getRacerById(racerId)

racerId (number): Racing ID assigned by Nexure Racing.

Returns false if no racer matches.

Field	Type	Description
`source`	`number`	Current server source (if online).
`id`	`number`	Racer ID.
`name`	`string`	Display name.
`avatar`	`string`	Avatar URL.
`mmr`	`number`	Matchmaking rating.

local racer = exports.nx_racing:getRacerById(12345)
if racer then
  print(('Player %s (source %s)'):format(racer.name, racer.source))
else
  print('No racer with that ID')
end

`nx_racing.getRacerByIdentifier`

local racer = exports.nx_racing:getRacerByIdentifier(identifier)

identifier (string): Framework identifier stored by the racing system.

Returns false if the identifier cannot be found.

Field	Type	Description
`id`	`number`	Racer ID.
`name`	`string`	Player name.
`avatar`	`string`	Avatar URL.
`mmr`	`number`	Matchmaking rating.

local racer = exports.nx_racing:getRacerByIdentifier('player_123')
if racer then
  print(('MMR: %d'):format(racer.mmr))
else
  print('Identifier not registered')
end

Uses MySQL.single.await, so keep identifier lookups efficient.

nx_racing.createRace

nx_racing.getActiveRaces

nx_racing.getOngoingRaceData

nx_racing.getRacer

nx_racing.getRacerById

nx_racing.getRacerByIdentifier