Planification et cycle de vie

import { every, onStop, caller, ByResource, Reasons } from "@aicore-fivem/lib/fivem";
import { sleep, waitFor } from "@aicore-fivem/lib/shared";

Travail périodiqueCopy Anchor Link

everyCopy Anchor Link

Exécute une fonction toutes les ms millisecondes (0 = à chaque frame) depuis le planificateur unique de votre ressource. Utilisez-le à la place de setInterval, setTick ou d’une boucle CreateThread avec Wait : toutes les tâches d’une ressource partagent un seul tick, et ce tick n’existe que tant qu’au moins une tâche est activée, si bien qu’une ressource inactive ne coûte rien dans resmon.

Côté : client et serveur · Attend : non

every(ms: number, fn: () => unknown, options?: EveryOptions): Job

local job = aiLib.every(ms, fn, options) -- job:set(active), job:stop(), job.running

ParamètresCopy Anchor Link

EveryOptionsCopy Anchor Link

RetourCopy Anchor Link

Job : un handle pour activer et désactiver la tâche.

ExempleCopy Anchor Link

Une tâche à chaque frame qui ne tourne que tant qu’elle a quelque chose à faire :

import { every, cache, onCache } from "@aicore-fivem/lib/client";

// Masque le réticule à chaque frame, mais seulement tant qu’une arme est en main.
const hideCrosshair = every(0, () => HideHudComponentThisFrame(14), {
  active: cache.weapon !== false,
  name: "hide crosshair",
});

onCache("weapon", (weapon) => hideCrosshair.set(weapon !== false));

AttenteCopy Anchor Link

sleepCopy Anchor Link

Attend ms millisecondes.

Côté : client, serveur et NUI · Attend : oui (Promise)

sleep(ms: number): Promise<void>

Lua : pas d’équivalent ; utilisez Wait(ms) dans un thread.

ParamètresCopy Anchor Link

RetourCopy Anchor Link

Promise<void> qui se résout après ms millisecondes.

ExempleCopy Anchor Link

import { sleep } from "@aicore-fivem/lib/shared";
import { fadeOut, fadeIn } from "@aicore-fivem/lib/client";

async function blink(): Promise<void> {
  await fadeOut(300);
  await sleep(1000);
  await fadeIn(300);
}

waitForCopy Anchor Link

Vérifie une condition jusqu’à ce qu’elle donne une valeur, puis renvoie cette valeur. Utilisez-le pour attendre quelque chose que le jeu fait à son propre rythme : qu’une entité existe, qu’un modèle se charge, qu’une valeur arrive.

Côté : client, serveur et NUI · Attend : oui (Promise en TypeScript, cède la main (yield) du thread en Lua)

waitFor<T>(check: () => T | undefined, timeoutMs?: number | false, intervalMs?: number): Promise<T>

local value = aiLib.waitFor(check, timeout, interval) -- la valeur, ou nil après le délai ; à appeler dans un thread

ParamètresCopy Anchor Link

RetourCopy Anchor Link

TypeScript : Promise<T> qui se résout avec la première valeur renvoyée par check qui n’était pas undefined. Elle est rejetée avec Error("waitFor timed out after <ms> ms") après le délai.

Lua : la valeur, ou nil après le délai (aucune erreur levée).

ExempleCopy Anchor Link

import { waitFor } from "@aicore-fivem/lib/shared";

async function vehicleFromNet(netId: number): Promise<number | null> {
  try {
    return await waitFor(() => {
      const vehicle = NetworkGetEntityFromNetworkId(netId);
      return DoesEntityExist(vehicle) ? vehicle : undefined;
    }, 5000);
  } catch {
    return null; // pas streamé dans les 5 secondes
  }
}

Cycle de vie de la ressourceCopy Anchor Link

onStopCopy Anchor Link

Exécute une fonction quand votre ressource s’arrête (du côté où tourne le code). Utilisez-le pour supprimer ce que des natives ont créé et que rien d’autre ne retire : entités que vous avez fait apparaître, caméras, focus NUI.

Côté : client et serveur · Attend : non

onStop(fn: () => void): void

Lua : pas d’équivalent ; utilisez AddEventHandler('onResourceStop', function(name) if name == GetCurrentResourceName() then ... end end).

ParamètresCopy Anchor Link

RetourCopy Anchor Link

void.

ExempleCopy Anchor Link

import { onStop } from "@aicore-fivem/lib/server";

const spawned = new Set<number>();

onStop(() => {
  for (const entity of spawned) if (DoesEntityExist(entity)) DeleteEntity(entity);
});

callerCopy Anchor Link

Le nom de la ressource qui a appelé l’export en cours d’exécution. Dans votre propre code (hors d’un appel d’export), c’est le nom de votre ressource.

Côté : client et serveur · Attend : non

caller(): string

Lua : pas d’équivalent ; utilisez GetInvokingResource() or GetCurrentResourceName().

RetourCopy Anchor Link

string : le nom de la ressource appelante, ou le nom de cette ressource quand aucune autre ressource n’appelle.

ExempleCopy Anchor Link

import { registerExport, caller } from "@aicore-fivem/lib/server";

registerExport("Ping", () => {
  console.log(`${caller()} asked for a ping`);
  return true;
});

ByResourceCopy Anchor Link

Une map dont les entrées appartiennent à la ressource qui les a définies. Quand cette ressource s’arrête, ses entrées sont retirées d’un coup (et onDrop s’exécute pour chacune). Utilisez-la pour ce que d’autres ressources enregistrent via vos exports : hooks, invites, objets, entrées de menu.

Côté : client et serveur · Attend : non

new ByResource<K, V>(options?: { onDrop?: (resource: string, key: K, value: V) => void })

Lua : pas d’équivalent.

ParamètresCopy Anchor Link

MéthodesCopy Anchor Link

ExempleCopy Anchor Link

import { ByResource, registerExport } from "@aicore-fivem/lib/server";
import { readText } from "@aicore-fivem/lib/shared";

type Hook = (source: number, text: string) => boolean;
const hooks = new ByResource<string, Hook>({
  onDrop: (resource, id) => console.log(`${resource} stopped: hook ${id} removed`),
});

// Une autre ressource : exports["my-chat"].AddHook("swear-filter", (source, text) => ...)
registerExport("AddHook", (id: unknown, hook: unknown) => {
  const name = readText(id, 64);
  if (name === null || typeof hook !== "function") return false;
  hooks.set(name, hook as Hook); // propriétaire = la ressource qui appelle AddHook
  return true;
});

export function allowed(source: number, text: string): boolean {
  for (const hook of hooks.values()) if (!hook(source, text)) return false;
  return true;
}

ReasonsCopy Anchor Link

Un interrupteur qui est activé tant qu’au moins une raison est définie. Chaque ressource définit ses propres raisons nommées, et les raisons d’une ressource qui s’arrête sont effacées. Utilisez-le pour « masquer le HUD », « mettre la synchro en pause », « bloquer le menu » : plusieurs scripts peuvent le demander en même temps, et l’état ne revient en arrière que lorsque le dernier relâche.

Côté : client et serveur · Attend : non

new Reasons()

Lua : pas d’équivalent.

MéthodesCopy Anchor Link

ExempleCopy Anchor Link

import { Reasons, registerExport } from "@aicore-fivem/lib/client";
import { readText } from "@aicore-fivem/lib/shared";

const hidden = new Reasons();
hidden.onChange((any) => SendNUIMessage({ action: "visible", value: !any }));

// Autres ressources : exports["my-hud"].Hide("cutscene") et exports["my-hud"].Show("cutscene")
registerExport("Hide", (reason: unknown) => {
  const name = readText(reason, 64);
  if (name !== null) hidden.set(name, true);
});
registerExport("Show", (reason: unknown) => {
  const name = readText(reason, 64);
  if (name !== null) hidden.set(name, false);
});