Fahrzeuge

import { spawnVehicle, vehicleKeys, fuel, garages, vehicleFromNet } from "@aicore-fivem/lib/server";

SpawnenCopy Anchor Link

spawnVehicleCopy Anchor Link

Erstellt ein vernetztes Fahrzeug auf dem Server und richtet es in einem Aufruf ein: Kennzeichen, Sprit, Aussehen, Verriegelung, Routing-Bucket, Schlüssel für den richtigen Zweck, ein Fahrer und Beifahrer. Nutze es für jedes Skript-Fahrzeug (Job-Fahrzeuge, Mietwagen, Garagenfahrzeuge, Admin-Spawns).

Seite: Server · Wartet: ja (Promise in TypeScript, hält in Lua den Thread an)

spawnVehicle(options: SpawnVehicleOptions): Promise<number | null>

local vehicle = aiLib.spawnVehicle(options) -- Entity oder nil, innerhalb eines Threads aufrufen

ParameterCopy Anchor Link

SpawnVehicleOptionsCopy Anchor Link

RückgabewertCopy Anchor Link

Promise<number | null>: das Entity-Handle des Fahrzeugs. null, wenn das Modell nicht existiert (der asker-Client hat es gemeldet), die Entity nicht innerhalb von 5 Sekunden erstellt wurde oder der Typ unbekannt ist.

BeispielCopy Anchor Link

import { onClientCallback, spawnVehicle, hasCharacter, near } from "@aicore-fivem/lib/server";
import { fail } from "@aicore-fivem/lib/shared";

const DEPOT = { x: 895.4, y: -179.3, z: 74.7 };

onClientCallback(
  "my-taxi:start",
  async (source) => {
    const vehicle = await spawnVehicle({
      model: "taxi",
      coords: { x: 899.1, y: -180.6, z: 73.8, heading: 238 },
      asker: source,
      keysTo: source,
      purpose: "job",
      driver: source,
      fuel: 100,
      setup: { dirt: 0 },
    });
    if (!vehicle) return fail("SPAWN_FAILED");
    return { ok: true, netId: NetworkGetNetworkIdFromEntity(vehicle) };
  },
  { guards: [hasCharacter(), near(DEPOT, 5)], lock: true },
);

vehicleTypeCopy Anchor Link

Der Spawn-Typ eines Modells, beim Client eines Spielers erfragt. Nutze es, um zu prüfen, ob ein Modell existiert, bevor du Geld nimmst.

Seite: Server · Wartet: ja (Promise)

vehicleType(model: string, asker: number): Promise<string | null>

Kein Lua-Zwilling: aiLib.spawnVehicle mit asker prüft es und gibt bei einem unbekannten Modell nil zurück.

RückgabewertCopy Anchor Link

Promise<string | null>: automobile, bike, boat, heli, plane, submarine, trailer oder train; null, wenn das Spiel kein solches Fahrzeug hat oder der Client keine gültige Antwort gab. Eine Antwort wird für alle behalten, sobald sich die Clients zweier verschiedener Spieler darauf geeinigt haben, sodass ein modifizierter Client nur seine eigenen Spawns kaputt machen kann.

BeispielCopy Anchor Link

import { onClientCallback, vehicleType } from "@aicore-fivem/lib/server";
import { fail, oneArg, readText } from "@aicore-fivem/lib/shared";

onClientCallback("my-dealer:buy", { args: oneArg((v) => readText(v, 32)), lock: true }, async (source, model) => {
  if (!(await vehicleType(model, source))) return fail("UNKNOWN_MODEL");
  // das Geld nehmen, dann spawnVehicle(...)
  return { ok: true };
});

randomPlateCopy Anchor Link

Ein zufälliges Kennzeichen wie das des Spiels (zwei Ziffern, drei Buchstaben, drei Ziffern), oder dein Präfix gefolgt von Ziffern.

Seite: Server · Wartet: nein

randomPlate(prefix?: string): string

Kein Lua-Zwilling (aiLib.spawnVehicle setzt ein zufälliges Kennzeichen, wenn du keins übergibst).

Rückgabewert: ein Kennzeichen mit 8 Zeichen (42ABC123, oder TAXI1234 für randomPlate("TAXI")). Es wird nicht auf Eindeutigkeit geprüft: Prüfe deine eigene Tabelle, bevor du es speicherst.

const plate = randomPlate("RENT");

Fahrzeuge findenCopy Anchor Link

nearestVehicleToCopy Anchor Link

Das nächstgelegene Fahrzeug innerhalb von metres um einen Spieler, das deinen Filter besteht. Das Fahrzeug, in dem der Spieler sitzt, hat Vorrang.

Seite: Server · Wartet: nein

nearestVehicleTo(source: number, metres: number, filter?: (vehicle: number) => boolean): number

local vehicle = aiLib.nearestVehicleTo(source, metres, filter) -- Entity oder 0

Rückgabewert: die Fahrzeug-Entity, oder 0, wenn keins da ist.

const vehicle = nearestVehicleTo(source, 5);
if (!vehicle) return fail("NO_VEHICLE");

nearestVehicleAtCopy Anchor Link

Das nächstgelegene Fahrzeug innerhalb von metres um einen Punkt. Nutze es, um zu prüfen, ob ein Spawnplatz frei ist.

Seite: Server · Wartet: nein

nearestVehicleAt(point: { x: number; y: number; z: number }, metres: number, filter?: (vehicle: number) => boolean): number

Kein Lua-Zwilling.

Rückgabewert: die Fahrzeug-Entity, oder 0, wenn keins da ist. Geht jedes Fahrzeug durch, wie nearestVehicleTo.

const SPOT = { x: 899.1, y: -180.6, z: 73.8 };
if (nearestVehicleAt(SPOT, 3)) return fail("SPOT_BLOCKED");

Entities aus Client-EingabenCopy Anchor Link

Ein Client sendet eine Netzwerk-ID, nie ein Entity-Handle. Diese Helfer machen aus einer Net-ID die lebende Server-Entity und prüfen sie, sodass du nie NetworkGetEntityFromNetworkId + DoesEntityExist + GetEntityType von Hand aufrufst.

entityFromNetCopy Anchor Link

Die lebende Entity hinter der Netzwerk-ID eines Clients.

Seite: Server · Wartet: nein

entityFromNet(netId: unknown, type?: 1 | 2 | 3): number

Kein Lua-Zwilling (Lua hat vehicleFromNet).

Rückgabewert: die Entity, oder 0, wenn der Wert keine positive ganze Zahl ist, nicht vernetzt, verschwunden oder von einem anderen Typ.

const prop = entityFromNet(rawNetId, 3);
if (!prop) return fail("NOT_FOUND");

pedFromNetCopy Anchor Link

entityFromNet(netId, 1): der lebende Ped, oder 0.

Seite: Server · Wartet: nein

pedFromNet(netId: unknown): number

Kein Lua-Zwilling.

const ped = pedFromNet(rawNetId);

vehicleFromNetCopy Anchor Link

entityFromNet(netId, 2): das lebende Fahrzeug, oder 0.

Seite: Server · Wartet: nein

vehicleFromNet(netId: unknown): number

local vehicle = aiLib.vehicleFromNet(netId) -- Entity oder 0

const vehicle = vehicleFromNet(rawNetId);
if (!vehicle) return fail("NO_VEHICLE");

vehicleNearPlayerCopy Anchor Link

Das Fahrzeug hinter der Netzwerk-ID eines Clients, aber nur, wenn der Spieler in seiner Nähe ist (oder auf seinem Fahrersitz).

Seite: Server · Wartet: nein

vehicleNearPlayer(source: number, netId: unknown, options?: { metres?: number; driver?: boolean }): number

local vehicle = aiLib.vehicleNearPlayer(source, netId, options) -- Entity oder 0

Rückgabewert: das Fahrzeug, oder 0, wenn die ID schlecht ist, das Fahrzeug verschwunden ist oder der Spieler zu weit weg / nicht der Fahrer ist.

onClientCallback("my-tow:hook", { args: oneArg(readId), lock: true }, (source, netId) => {
  const vehicle = vehicleNearPlayer(source, netId, { metres: 6 });
  if (!vehicle) return fail("TOO_FAR");
  return { ok: true };
});

SchlüsselCopy Anchor Link

vehicleKeys läuft über die Schlüssel-Ebene von ai-core: Das Schlüssel-Skript, das der Server betreibt (ai-vehiclekeys, oder ein anderes, das der Betreiber wählt), antwortet. Ein Fahrzeug ist ein Server-Entity-Handle oder ein Kennzeichen.

vehicleKeys.giveCopy Anchor Link

Gibt einem Spieler die Schlüssel eines Fahrzeugs.

Seite: Server · Wartet: nein

vehicleKeys.give(source: number, vehicle: number | string, purpose?: KeyPurpose): void

aiLib.vehicleKeys.give(source, vehicle, purpose)

Rückgabewert: void.

vehicleKeys.give(source, vehicle, "rental");

vehicleKeys.removeCopy Anchor Link

Nimmt einem Spieler die Schlüssel eines Fahrzeugs.

Seite: Server · Wartet: nein

vehicleKeys.remove(source: number, vehicle: number | string): void

aiLib.vehicleKeys.remove(source, vehicle)

Rückgabewert: void.

vehicleKeys.remove(source, "RENT1234");

vehicleKeys.hasCopy Anchor Link

Ob ein Spieler die Schlüssel hat.

Seite: Server · Wartet: nein

vehicleKeys.has(source: number, vehicle: number | string): boolean

local has = aiLib.vehicleKeys.has(source, vehicle)

Rückgabewert: boolean. true auch, wenn das Schlüssel-Skript es nicht sagen kann oder keins läuft, nutze es also nicht als einzige Sperre für etwas Wertvolles.

if (!vehicleKeys.has(source, vehicle)) return fail("NO_KEYS");

SpritCopy Anchor Link

fuel liest und setzt den Sprit eines Fahrzeugs (0 bis 100) über die Sprit-Ebene von ai-core, egal welches Sprit-Skript läuft. Kein Lua-Zwilling auf dem Server: Rufe die Exports GetVehicleFuel / SetVehicleFuel von ai-core auf.

fuel.getCopy Anchor Link

Seite: Server · Wartet: nein

fuel.get(vehicle: number): number | null

Rückgabewert: der Stand einer Server-Fahrzeug-Entity (0 bis 100), oder null, wenn sie keinen hat.

const level = fuel.get(vehicle) ?? 0;

fuel.setCopy Anchor Link

Seite: Server · Wartet: nein

fuel.set(vehicle: number, level: number): boolean

Rückgabewert: true, wenn gesetzt, false bei einem falschen Fahrzeug.

fuel.set(vehicle, 100);

fuel.providerCopy Anchor Link

Seite: Server · Wartet: nein

fuel.provider(): string | null

Rückgabewert: der Ressourcenname des Sprit-Skripts, das antwortet (ai-fuel, ox_fuel, LegacyFuel...), oder null, wenn keins läuft.

console.log(`fuel through ${fuel.provider() ?? "nothing"}`);

GaragenCopy Anchor Link

garages läuft über die Garagen-Ebene von ai-core, egal welches Garagen-Skript läuft; jedes Skript beantwortet nur, was es bereitstellt. Kein Lua-Zwilling.

garages.impoundCopy Anchor Link

Schickt ein Fahrzeug in den Abschlepphof oder öffnet das Abschleppformular des Garagen-Skripts für by.

Seite: Server · Wartet: nein

garages.impound(vehicle: number, by?: number): boolean

Rückgabewert: true, wenn das Garagen-Skript es übernommen hat. false, wenn nichts es übernommen hat: Lösche das Fahrzeug selbst.

if (!garages.impound(vehicle, source)) DeleteEntity(vehicle);

garages.storeCopy Anchor Link

Stellt ein Fahrzeug in einer Garage ein.

Seite: Server · Wartet: nein

garages.store(vehicle: number, garage?: string | null, by?: number): boolean

Rückgabewert: true, wenn eingestellt, false, wenn nichts es übernommen hat.

if (!garages.store(vehicle, "legion", source)) return fail("STORE_FAILED");

garages.openCopy Anchor Link

Öffnet das Garagenmenü des Garagen-Skripts für einen Spieler.

Seite: Server · Wartet: nein

garages.open(source: number, garage?: string | null): boolean

Rückgabewert: true, wenn geöffnet, false, wenn das Skript kein solches Menü hat.

garages.open(source, "pillbox");

garages.storedCopy Anchor Link

Die Fahrzeuge eines Spielers in Garagen oder im Abschlepphof.

Seite: Server · Wartet: ja (Promise)

garages.stored(source: number): Promise<GaragedVehicle[] | null>

Rückgabewert: GaragedVehicle[] (plate, model, garage, impounded), oder null, wenn das Skript es nicht sagen kann oder ai-core gestoppt ist.

const list = await garages.stored(source);
const impounded = list?.filter((v) => v.impounded).length ?? 0;

garages.providerCopy Anchor Link

Seite: Server · Wartet: nein

garages.provider(): string | null

Rückgabewert: das Garagen-Skript, das antwortet, oder null, wenn keins läuft.

if (!garages.provider()) console.warn("no garage script runs");