Comandos yexports

exports['qs-core']:GetPlayer(source)

Parámetros: source — ID de servidor del jugador.

Devuelve: una tabla de jugador, o nil si no hay ningún personaje cargado. Contiene source, citizenid, PlayerData (una copia tomada en el momento de la llamada: citizenid, license, name, charinfo, money, job, inventory, metadata, position, skin, is_dead, cid) y todos los métodos del jugador: getCitizenId, getCharInfo, getPed, getCoords, getMoney, addMoney, removeMoney, setMoney, getJob, setJob, setJobDuty, getGang, setGang, isDead, getMetadata, setMetadata, getSkin, setSkin, addItem, removeItem, hasItem, canCarryItem, getItemCount, getSlotView, getItemBySlot, setItemInfo, setBusy, emit y save.

Ejemplo: local player = exports['qs-core']:GetPlayer(source); player:addMoney('cash', 100, 'reward')

exports['qs-core']:GetPlayerByCitizenId(citizenid)

Parámetros: citizenid — el ID del personaje (QS seguido de 6 caracteres).

Devuelve: la misma tabla de jugador que GetPlayer, o nil cuando ese personaje no está conectado. Para personajes desconectados usa GetOfflinePlayerByCitizenId.

Ejemplo: local player = exports['qs-core']:GetPlayerByCitizenId('QSA1B2C3')

exports['qs-core']:GetPlayers()

Parámetros: ninguno.

Devuelve: una lista de tablas de jugador, una por personaje cargado.

Ejemplo: for _, p in ipairs(exports['qs-core']:GetPlayers()) do print(p.source, p.citizenid) end

exports['qs-core']:GetCharacters(source)

Parámetros: source — ID de servidor del jugador.

Devuelve: los personajes de la cuenta ordenados por slot, cada uno { citizenid, cid, name, charinfo, money, job, skin, position }. Tabla vacía si el jugador no tiene identificador de licencia.

Ejemplo: local chars = exports['qs-core']:GetCharacters(source)

exports['qs-core']:CreateCharacter(source, charinfo, skin?, cid?)

Parámetros: charinfo — { firstname, lastname, dob, sex, nationality }; skin — tabla de apariencia opcional; cid — número de slot opcional.

Devuelve: los datos del nuevo personaje, o nil, err con err = 'no_license', 'max_characters' (límite Config.MaxCharacters) o 'slot_taken'. El personaje empieza con Config.Accounts, Config.DefaultJob y Config.DefaultSpawn. No se carga — llama a LoadCharacter a continuación.

Ejemplo: local data, err = exports['qs-core']:CreateCharacter(source, { firstname = 'John', lastname = 'Doe', dob = '1990-01-01', sex = 'male', nationality = 'USA' })

exports['qs-core']:LoadCharacter(source, citizenid, isNew?)

Parámetros: citizenid — un personaje de este jugador; isNew — true justo después de la creación (ítems iniciales, editor).

Devuelve: true, o false, err con err = 'no_license', 'not_found' o 'not_owner'. Dispara qs:server:playerLoaded, qs:server:characterLoaded y hace aparecer al jugador.

Ejemplo: local ok, err = exports['qs-core']:LoadCharacter(source, data.citizenid, true)

exports['qs-core']:Logout(source)

Parámetros: source — ID de servidor del jugador.

Devuelve: true, o false si no había ningún personaje cargado. Guarda, descarga el personaje y dispara qs:server:playerUnloaded y qs:client:playerUnloaded. Con qs-coremulticharacter se vuelve a abrir la pantalla de selección.

Ejemplo: exports['qs-core']:Logout(source)

exports['qs-core']:DeleteCharacter(citizenid)

Parámetros: citizenid — personaje a eliminar.

Devuelve: nada. Borra la fila de players sin comprobar a quién pertenece, así que compruébalo tú primero (por ejemplo, con GetCharacters).

Ejemplo: exports['qs-core']:DeleteCharacter('QSA1B2C3')

exports['qs-core']:GetOfflinePlayerByCitizenId(citizenid)
exports['qs-core']:SaveOfflinePlayer(citizenid, patch)

Parámetros: citizenid — cualquier personaje; patch — tabla con los campos de nivel superior a reemplazar (money, job, metadata, charinfo, inventory, position, skin…).

Devuelve: GetOfflinePlayerByCitizenId devuelve { Offline = true, citizenid, license, name, charinfo, money, job, inventory, metadata, position, skin, is_dead, cid } leído de la base de datos, o nil. SaveOfflinePlayer devuelve true una vez escrito. Úsalos solo para personajes desconectados: un personaje conectado se sobrescribe con su propio siguiente guardado.

Ejemplo: local row = exports['qs-core']:GetOfflinePlayerByCitizenId(cid); row.money.bank = row.money.bank + 500; exports['qs-core']:SaveOfflinePlayer(cid, { money = row.money })

exports['qs-core']:SetPlayerDead(source, state)

Parámetros: state — true pone al jugador en estado de caído, false lo reanima.

Devuelve: true, o false si no hay ningún personaje cargado.

Ejemplo: exports['qs-core']:SetPlayerDead(source, false)

exports['qs-core']:GetMoney(source, account)

Parámetros: account — una cuenta de Config.Accounts: cash, bank o black_money.

Devuelve: el saldo, o 0.

Ejemplo: local bank = exports['qs-core']:GetMoney(source, 'bank')

exports['qs-core']:AddMoney(source, account, amount, reason?)

Parámetros: account — cash, bank o black_money; amount — mayor que 0; reason — texto opcional que se pasa a qs:server:moneyChange.

Devuelve: true, o false si la cuenta no existe o la cantidad no es positiva.

Ejemplo: exports['qs-core']:AddMoney(source, 'bank', 500, 'bonus')

exports['qs-core']:RemoveMoney(source, account, amount, reason?)

Parámetros: igual que AddMoney.

Devuelve: true, o false si el saldo es demasiado bajo, la cuenta no existe o la cantidad no es positiva.

Ejemplo: if exports['qs-core']:RemoveMoney(source, 'cash', 250, 'shop') then ... end

exports['qs-core']:SetMoney(source, account, amount)

Parámetros: amount — 0 o más.

Devuelve: true o false. No dispara qs:server:moneyChange.

Ejemplo: exports['qs-core']:SetMoney(source, 'black_money', 0)

exports['qs-core']:GetAccountMoney(source, account)
exports['qs-core']:AddAccountMoney(source, account, amount, reason?)
exports['qs-core']:RemoveAccountMoney(source, account, amount, reason?)
exports['qs-core']:SetAccountMoney(source, account, amount)

Parámetros: account — cash (alias money) y bank son los mismos saldos que GetMoney; cualquier otro nombre, como crypto, es una cuenta extra guardada en los metadatos del personaje (accounts_extra) y creada con el primer uso.

Devuelve: un número para GetAccountMoney, true/false para los demás. Estas son las funciones que usan los puentes de ESX y QBCore. Para black_money, usa GetMoney / AddMoney — ese es el saldo en el que paga qs-coredrugs.

Ejemplo: exports['qs-core']:AddAccountMoney(source, 'crypto', 10, 'mining')

exports['qs-core']:SetJob(source, name, grade?)

Parámetros: name — un trabajo que exista en qs-core/shared/jobs.lua o que se haya registrado en tiempo de ejecución; grade — por defecto 0. Un rango que no existe pasa al rango más bajo.

Devuelve: true, o false para un trabajo desconocido. Dispara qs:server:jobChange.

Ejemplo: exports['qs-core']:SetJob(source, 'police', 1)

exports['qs-core']:RegisterJob(name, def)
exports['qs-core']:RegisterJobs({ [name] = def, ... })

Parámetros: def — { label, defaultDuty, grades = { [0] = { name, label, salary, isBoss } } }. Si falta label, se usa el nombre; si falta grades, se convierte en un rango employee con salario 0. Solo del lado del servidor, y solo hasta el siguiente reinicio.

Devuelve: true, o false con argumentos no válidos. Registrar un nombre existente lo reemplaza.

Ejemplo: exports['qs-core']:RegisterJob('mechanic', { label = 'Mechanic', grades = { [0] = { name = 'apprentice', label = 'Apprentice', salary = 300 } } })

exports['qs-core']:UpdateJob(name, def)
exports['qs-core']:RemoveJob(name)
exports['qs-core']:GetJobs()

Parámetros: name — un trabajo existente; def — definición completa (reemplaza, no combina).

Devuelve: UpdateJob y RemoveJob devuelven false si el trabajo no existe. GetJobs devuelve todos los trabajos indexados por nombre.

Ejemplo: local jobs = exports['qs-core']:GetJobs(); print(jobs.police.label)

exports['qs-core']:SetJobDuty(source, onDuty)

Parámetros: onDuty — booleano.

Devuelve: true o false. Guarda la marca en los metadatos y en el trabajo del personaje, y dispara qs:server:jobChange y el qs:client:onDutyUpdate del cliente. El Player.Functions.SetJobDuty del puente de QBCore lo usa.

Ejemplo: exports['qs-core']:SetJobDuty(source, true)

exports['qs-core']:GetPlayersOnDuty(jobName)

Parámetros: jobName — nombre del trabajo.

Devuelve: dos valores: una lista de IDs de servidor y su cantidad, para los jugadores con ese trabajo cuya marca de servicio no es false.

Ejemplo: local sources, count = exports['qs-core']:GetPlayersOnDuty('police')

exports['qs-core']:SetGang(source, name, grade?)
exports['qs-core']:GetGangForPlayer(source)

Parámetros: name — un nombre de banda en minúsculas; grade — por defecto 0.

Devuelve: SetGang devuelve true/false y dispara qs:server:gangChange. GetGangForPlayer devuelve { name, label, isboss, grade = { name, level } }, o la banda none.

Ejemplo: exports['qs-core']:SetGang(source, 'ballas', 2)

exports['qs-core']:RegisterGang(name, def)
exports['qs-core']:RegisterGangs({ [name] = def, ... })
exports['qs-core']:GetGang(name)
exports['qs-core']:GetGangs()
exports['qs-core']:RemoveGang(name)

Parámetros: def — { label, grades = { [0] = { name, label, isBoss } } }. Usa nombres en minúsculas. Si faltan los rangos, se crea un solo rango member.

Devuelve: true/false; GetGang devuelve la definición o nil. RemoveGang rechaza none. También está disponible en el cliente, con su propia copia de la lista.

Ejemplo: exports['qs-core']:RegisterGang('ballas', { label = 'Ballas', grades = { [0] = { name = 'member', label = 'Member' }, [1] = { name = 'boss', label = 'OG', isBoss = true } } })

exports['qs-core']:GetMetadata(source, key?)
exports['qs-core']:SetMetadata(source, key, value)

Parámetros: key — cualquier clave de metadatos (hunger, thirst, gang, onduty, accounts_extra o las tuyas); sin clave, GetMetadata devuelve la tabla completa.

Devuelve: el valor (un false guardado vuelve como nil); SetMetadata devuelve true/false y envía qs:metadata:set al jugador, que el HUD usa para el hambre y la sed.

Ejemplo: exports['qs-core']:SetMetadata(source, 'hunger', 100)

exports['qs-core']:GetSkin(source)
exports['qs-core']:SetSkin(source, skin)

Parámetros: skin — la tabla de apariencia que usa qs-clothing.

Devuelve: GetSkin devuelve la tabla o nil; SetSkin devuelve true/false, aplica la skin al jugador al instante y la guarda con el siguiente guardado del personaje.

Ejemplo: local skin = exports['qs-core']:GetSkin(source)

exports['qs-core']:RegisterItem(name, def)
exports['qs-core']:RegisterItems({ [name] = def, ... })

Parámetros: def — { label, weight, useable, description, image, stack, unique, weapon, ammo }. El peso está en gramos; useable = true es necesario para que el ítem haga algo al usarse; weapon = 'WEAPON_X' hace que equipe un arma. Registrar un nombre existente lo reemplaza.

Devuelve: RegisterItem devuelve true/false. Registra los ítems en el servidor: el cliente mantiene un catálogo aparte.

Ejemplo: exports['qs-core']:RegisterItem('pizza', { label = 'Pizza', weight = 500, useable = true, description = 'A hot slice.' })

exports['qs-core']:GetItem(name)
exports['qs-core']:GetItems()
exports['qs-core']:UpdateItemDefinition(name, def)
exports['qs-core']:RemoveItemDefinition(name)

Parámetros: name — nombre del ítem; def — definición completa (reemplaza, no combina).

Devuelve: una definición o nil; el catálogo completo; true/false (false cuando el ítem no existe).

Ejemplo: local def = exports['qs-core']:GetItem('water'); print(def.label, def.weight)

exports['qs-core']:AddItem(source, item, count?, slot?, info?)

Parámetros: count — por defecto 1; slot — slot preferido; info — tabla de metadatos por ítem (números de serie, datos de pruebas…).

Devuelve: true o false. Con qs-coreinventory falla para ítems desconocidos, cuando el jugador superaría el límite de peso (Too heavy to carry) o no tiene espacio (Inventory full).

Ejemplo: exports['qs-core']:AddItem(source, 'water', 2)

exports['qs-core']:RemoveItem(source, item, count?, slot?)

Parámetros: count — por defecto 1; slot — tomar solo de ese slot.

Devuelve: true, o false si el jugador no tiene suficiente.

Ejemplo: exports['qs-core']:RemoveItem(source, 'lockpick', 1)

exports['qs-core']:HasItem(source, item, count?)
exports['qs-core']:GetItemCount(source, item)
exports['qs-core']:CanCarryItem(source, item, count?)

Parámetros: count — por defecto 1.

Devuelve: HasItem y CanCarryItem devuelven booleanos (CanCarryItem comprueba el peso y el espacio libre sin cambiar nada); GetItemCount devuelve el total de todos los slots.

Ejemplo: if exports['qs-core']:CanCarryItem(source, 'stone', 3) then exports['qs-core']:AddItem(source, 'stone', 3) end

exports['qs-core']:GetSlotView(source)
exports['qs-core']:GetItemBySlot(source, slot)

Parámetros: slot — número de slot.

Devuelve: GetSlotView devuelve todos los slots, cada uno false (vacío) o { slot, name, label, count, weight, useable, description, image, max, info } con qs-coreinventory. GetItemBySlot devuelve una de esas entradas o nil.

Ejemplo: local item = exports['qs-core']:GetItemBySlot(source, 1)

exports['qs-core']:SetItemInfo(source, slot, info)

Parámetros: info — la nueva tabla de metadatos del ítem de ese slot (reemplaza la anterior).

Devuelve: true o false.

Ejemplo: exports['qs-core']:SetItemInfo(source, slot, { serial = 'AB1234' })

exports['qs-core']:RegisterUsableItem(item, handler)

Parámetros: handler — con qs-coreinventory, function(source, slot, info). El ítem debe estar registrado con useable = true. El inventario no quita el ítem; hazlo en el handler si es consumible. Un handler por ítem: gana el último registro.

Devuelve: true. Las llamadas hechas antes de que se inicie el inventario se ponen en cola y se aplican cuando se inicia.

Ejemplo: exports['qs-core']:RegisterUsableItem('pizza', function(source, slot) exports['qs-core']:RemoveItem(source, 'pizza', 1, slot) end)

exports['qs-core']:RegisterStash(id, label?, slots?, maxWeight?, columns?)

Parámetros: id — ID único del stash. qs-coreinventory valores predeterminados: etiqueta Stash, 50 slots, 100000 g, 5 columnas. El contenido se guarda en stash_inventories.

Devuelve: true o false. Los jugadores lo abren con una zona de stash del cliente (RegisterStashZone) o con qs-coreinventory de OpenStash.

Ejemplo: exports['qs-core']:RegisterStash('mechanic_locker', 'Mechanic Locker', 40, 150000, 5)

exports['qs-core']:SetBusy(source, ms)

Parámetros: ms — milisegundos durante los que el jugador no puede usar ítems.

Devuelve: nada. Solo tiene efecto con qs-coreinventory.

Ejemplo: exports['qs-core']:SetBusy(source, 3000)

exports['qs-core']:GetInventory(source)
exports['qs-core']:SetInventory(source, list)

Parámetros: list — la lista de slots tal como se guarda en players.inventory, cada entrada { name, count, info } o false.

Devuelve: la lista / true. Es mejor usar AddItem y RemoveItem, que además actualizan la pantalla de inventario del jugador.

Ejemplo: exports['qs-core']:SetInventory(source, {})

exports['qs-core']:GetCitizenVehicles(citizenid)

Parámetros: citizenid — ID del personaje.

Devuelve: todas las filas de vehículos de ese personaje, con props ya decodificados. GetOwnedVehicles(citizenid) es la misma función con su nombre anterior.

Ejemplo: local cars = exports['qs-core']:GetCitizenVehicles(player.citizenid)

exports['qs-core']:GetGarageVehicles(citizenid, garage)

Parámetros: garage — un ID de garaje, como legion_square.

Devuelve: las filas del personaje cuyo garage es igual a ese ID.

Ejemplo: local cars = exports['qs-core']:GetGarageVehicles(cid, 'pillbox_hill_garage')

exports['qs-core']:GetVehicleByPlate(plate)
exports['qs-core']:PlateExists(plate)

Parámetros: plate — texto de la matrícula sin espacios al final.

Devuelve: la fila o nil; true/false.

Ejemplo: local row = exports['qs-core']:GetVehicleByPlate('QS4F2K9')

exports['qs-core']:CreateOwnedVehicle(data)

Parámetros: data — { citizenid, license, plate, model, garage, state, fuel, engine, body, props }. Valores predeterminados: garaje legion, estado 1, combustible 100, motor y carrocería 1000.0, props {}. Un ID de garaje que no está configurado en qs-garage hace que el vehículo aparezca en todos los garajes hasta que se guarde una vez.

Devuelve: el ID de la nueva fila.

Ejemplo: exports['qs-core']:CreateOwnedVehicle({ citizenid = player.citizenid, license = player.PlayerData.license, plate = 'QS12345', model = 'sultan' })

exports['qs-core']:UpdateOwnedVehicle(plate, data)
exports['qs-core']:SetVehicleState(plate, state, garage?)

Parámetros: data — { garage, state, fuel, engine, body, props }. UpdateOwnedVehicle escribe las seis columnas, así que lee la fila primero y pasa todos los campos. SetVehicleState solo cambia state (y garage cuando se indica).

Devuelve: nada.

Ejemplo: exports['qs-core']:SetVehicleState('QS12345', 1, 'legion_square')

exports['qs-core']:SpawnVehicle(source, model, coords?, warp?)

Parámetros: model — nombre o hash; coords — vec4 o { x, y, z, w }, por defecto la posición del jugador; warp — sentar al jugador en el asiento del conductor.

Devuelve: el network id del vehículo, o nil si no se pudo crear. No da llaves — consulta qs-corevehiclekeys más abajo.

Ejemplo: local netId = exports['qs-core']:SpawnVehicle(source, 'adder', nil, true)

exports['qs-core']:GetPlayerVehiclesQBShape(citizenid)

Parámetros: citizenid — ID del personaje.

Devuelve: los vehículos del personaje con la forma de las filas player_vehicles de QBCore: citizenid, license, vehicle, hash, mods, plate, garage, fuel, engine, body, state.

Ejemplo: local vehicles = exports['qs-core']:GetPlayerVehiclesQBShape(cid)

exports['qs-core']:HasPermission(source, permission)

Parámetros: permission — un nombre como admin, o una lista de nombres (basta con que coincida uno).

Devuelve: true para la consola, para user, o cuando el jugador tiene el ACE <permission>, qbcore.<permission> o group.<permission>. admin, god y mod también pasan con group.admin o command.

Ejemplo: if exports['qs-core']:HasPermission(source, { 'admin', 'mod' }) then ... end

exports['qs-core']:AddPermission(source, permission)
exports['qs-core']:RemovePermission(source, permission)
exports['qs-core']:GetPermission(source)

Parámetros: permission — un nombre como mod.

Devuelve: AddPermission / RemovePermission devuelven true/false y añaden o quitan los ACE qbcore.<permission> y group.<permission> en la licencia del jugador hasta el siguiente reinicio. GetPermission devuelve { god = true, admin = true, mod = true } solo con los que tiene el jugador. Para un grupo que sobreviva a los reinicios, usa /setgroup.

Ejemplo: exports['qs-core']:AddPermission(source, 'mod')

ExecuteCommand(('setgroup %d %s'):format(targetId, 'admin'))

Parámetros: no hay export para los grupos; ejecuta el comando, que un recurso ejecuta con derechos de consola. Es lo que hace el menú de administración.

Devuelve: nada. El grupo se guarda en player_groups, se aplica al instante y se vuelve a aplicar cada vez que el jugador se conecta.

Ejemplo: ExecuteCommand(('removegroup %d'):format(targetId))

exports['qs-core']:IsPlayerBanned(licenseOrSource)

Parámetros: un ID de servidor o un identificador license:… completo.

Devuelve: banned, reason, expiresUnix. Cuenta cada baneo activo de la licencia, y un baneo permanente tiene prioridad sobre uno temporal; expiresUnix es el final como timestamp Unix, o nil para un baneo permanente. false cuando no hay ningún baneo activo, y siempre false cuando Config.EnableBans = false.

Ejemplo: local banned, reason, expires = exports['qs-core']:IsPlayerBanned(source)

exports['qs-core']:AddBan(source, minutes, reason, adminName)

Parámetros: minutes — 0 o nil para un baneo permanente; adminName — se guarda como banned_by.

Devuelve: true, o false si el jugador no tiene licencia. El jugador es expulsado de inmediato.

Ejemplo: exports['qs-core']:AddBan(source, 1440, 'Exploiting', 'Anticheat')

exports['qs-core']:RemoveBan(license)
exports['qs-core']:ExploitBan(source, origin?)

Parámetros: license — identificador license:… completo; origin — texto que se guarda como motivo.

Devuelve: RemoveBan borra todos los baneos de ese identificador y devuelve true. ExploitBan banea de forma permanente con banned_by = 'Anti Cheat'.

Ejemplo: exports['qs-core']:ExploitBan(source, 'triggered protected event')

exports['qs-core']:RegisterCallback(name, function(source, ...) return ... end)

Parámetros: name — nombre del callback; el handler recibe el jugador y los argumentos del cliente, y lo que devuelva se envía de vuelta.

Devuelve: nada. El cliente lo llama con TriggerCallback.

Ejemplo: exports['qs-core']:RegisterCallback('myshop:getCash', function(source) return exports['qs-core']:GetMoney(source, 'cash') end)

exports['qs-core']:RegisterQBCallback(name, function(source, cb, ...) cb(...) end)

Parámetros: handler estilo QBCore que responde mediante cb.

Devuelve: nada. Los clientes lo llaman con TriggerQBCallback o QBCore.Functions.TriggerCallback.

Ejemplo: exports['qs-core']:RegisterQBCallback('myshop:getBank', function(source, cb) cb(exports['qs-core']:GetMoney(source, 'bank')) end)

TriggerClientEvent('qs:client:notify', source, message, type?, duration?, title?)

Parámetros: type — success, error, info (predeterminado) o primary; duration — milisegundos, por defecto 4000; title — opcional, por defecto un título traducido según el tipo. Usa -1 como source para notificar a todos. No hay export de servidor: este evento es la API del servidor.

Devuelve: nada.

Ejemplo: TriggerClientEvent('qs:client:notify', source, 'Order delivered', 'success', 5000)

exports['qs-core']:GetCoreObject()

Parámetros: ninguno.

Devuelve: la tabla core: Players, Config, Jobs, Gangs, Utils y las funciones core. Lee de ella los valores de configuración; para jugadores, usa GetPlayer — los objetos de jugador tomados de esta tabla en otro recurso no tienen métodos.

Ejemplo: local QS = exports['qs-core']:GetCoreObject(); print(QS.Config.MaxCharacters)

exports['qs-core']:RateLimit(key, max, windowMs)

Parámetros: key — nombre del bucket; max — llamadas permitidas por ventana; windowMs — duración de la ventana. Los buckets los comparten todos los recursos, así que pon como prefijo de las claves el nombre de tu recurso.

Devuelve: true mientras no se supera el límite, false cuando se supera.

Ejemplo: if not exports['qs-core']:RateLimit(('myshop:buy:%d'):format(source), 1, 1000) then return end

exports['qs-core']:RegisterFrameworkCommand(name, help, arguments, argsrequired, callback, permission?)
exports['qs-core']:RefreshCommands(source)

Parámetros: comando estilo QBCore (es lo que llama QBCore.Commands.Add): arguments — { { name, help } } para la sugerencia del chat; argsrequired — rechazar con menos argumentos; callback(source, args, raw); permission — por defecto user, comprobado con HasPermission.

Devuelve: nada. RefreshCommands vuelve a enviar todas las sugerencias del chat a un jugador (se hace automáticamente al cargar un personaje).

Ejemplo: exports['qs-core']:RegisterFrameworkCommand('healme', 'Heal yourself', {}, false, function(source) TriggerClientEvent('qs:client:revive', source) end, 'admin')

exports['qs-core']:GetColors()

Parámetros: ninguno.

Devuelve: en el servidor, la paleta predeterminada Config.Theme (primary, accent, text, panel, health…).

Ejemplo: local theme = exports['qs-core']:GetColors()

exports['qs-core']:GetPlayerData()

Parámetros: ninguno.

Devuelve: el personaje local, o nil antes de que se cargue un personaje: { source, citizenid, license, name, charinfo, money, job, metadata, gang, onduty, position, skin, is_dead, isNew }. El dinero, el trabajo, la banda, el servicio y los metadatos se mantienen actualizados.

Ejemplo: local data = exports['qs-core']:GetPlayerData(); print(data.job.label)

exports['qs-core']:Notify(message, type?, duration?, title?)

Parámetros: type — success, error, info (predeterminado) o primary; duration — milisegundos, por defecto 4000.

Devuelve: nada.

Ejemplo: exports['qs-core']:Notify('Vehicle repaired', 'success')

exports['qs-core']:Progress({ duration = 3000, label = '', disableMovement = false, canCancel = false })

Parámetros: duration — milisegundos; label — texto de la barra; disableMovement — bloquear caminar, correr y saltar; canCancel — permitir que X cancele. La llamada espera hasta que termina la barra.

Devuelve: true al completarse, false al cancelarse o cuando ya hay otra barra en curso.

Ejemplo: if exports['qs-core']:Progress({ duration = 5000, label = 'Repairing', canCancel = true }) then ... end

exports['qs-core']:CancelProgress()
exports['qs-core']:IsBusy()

Parámetros: ninguno.

Devuelve: IsBusy devuelve true mientras hay una barra de progreso en curso.

Ejemplo: if exports['qs-core']:IsBusy() then return end

exports['qs-core']:Lockpick(rounds?)

Parámetros: rounds — de 1 a 6, por defecto 3. El jugador fija los pines con SPACE y se rinde con ESC o BACKSPACE; 30 segundos de inactividad cuentan como fallo. La llamada espera hasta que termina.

Devuelve: true si tiene éxito, false si no.

Ejemplo: if exports['qs-core']:Lockpick(4) then ... end

exports['qs-core']:HasItem(item, count?)
exports['qs-core']:GetItemCount(item)

Parámetros: count — por defecto 1.

Devuelve: booleano / número, leído de la copia del cliente del inventario activo.

Ejemplo: if exports['qs-core']:HasItem('lockpick') then ... end

exports['qs-core']:RegisterStashZone(id, coords, opts?)
exports['qs-core']:RemoveStashZone(id)

Parámetros: id — un stash registrado en el servidor; coords — vector3; opts.radius — por defecto 2.0 m. Con qs-coreinventory, al abrir el inventario dentro de la zona se muestra el stash como segundo panel.

Devuelve: true o false.

Ejemplo: exports['qs-core']:RegisterStashZone('mechanic_locker', vector3(-347.2, -133.6, 39.0), { radius = 1.5 })

exports['qs-core']:TriggerCallback(name, function(...) end, ...)
exports['qs-core']:TriggerQBCallback(name, function(...) end, ...)

Parámetros: name — un callback registrado con RegisterCallback / RegisterQBCallback; los argumentos extra se envían al handler.

Devuelve: nada; la función recibe la respuesta del servidor.

Ejemplo: exports['qs-core']:TriggerCallback('myshop:getCash', function(cash) print(cash) end)

exports['qs-core']:IsDead()
exports['qs-core']:SetDownAnimPaused(state)

Parámetros: state — true evita que el bucle de caído vuelva a reproducir la animación de tendido mientras reproduces la tuya (la camilla de EMS lo usa).

Devuelve: IsDead devuelve true mientras el jugador está caído.

Ejemplo: if exports['qs-core']:IsDead() then return end

exports['qs-core']:IsNoclipActive()
exports['qs-core']:ToggleNoclip(state?)

Parámetros: llama a ToggleNoclip() sin argumentos para alternarlo, o con true para activarlo. No comprueba permisos — llámalo solo para administradores.

Devuelve: IsNoclipActive devuelve un booleano.

Ejemplo: if not exports['qs-core']:IsNoclipActive() then exports['qs-core']:ToggleNoclip() end

exports['qs-core']:GetColors()
exports['qs-core']:SetClientColors(palette)
exports['qs-core']:HasSavedColors()

Parámetros: palette — una tabla con las mismas claves que Config.Theme.

Devuelve: GetColors devuelve la paleta guardada del jugador o Config.Theme; SetClientColors aplica una paleta solo para esta sesión (no se guarda) y dispara qs:client:colorsChanged; HasSavedColors indica si el jugador eligió sus propios colores.

Ejemplo: SendNUIMessage({ action = 'theme', data = exports['qs-core']:GetColors() })

exports['qs-coreinventory']:AddItem(source, item, count, slot?, info?)
exports['qs-coreinventory']:RemoveItem(source, item, count, slot?)
exports['qs-coreinventory']:GetItemCount(source, item)
exports['qs-coreinventory']:HasItem(source, item, count?)
exports['qs-coreinventory']:CanCarryItem(source, item, count?, info?)
exports['qs-coreinventory']:GetSlotView(source)
exports['qs-coreinventory']:GetItemBySlot(source, slot)
exports['qs-coreinventory']:SetItemInfo(source, slot, info)
exports['qs-coreinventory']:RegisterUsableItem(item, function(source, slot, info) end)
exports['qs-coreinventory']:RegisterStash(id, label?, slots?, maxWeight?, columns?)
exports['qs-coreinventory']:SetBusy(source, ms)
exports['qs-coreinventory']:IsBusy(source)

Las mismas operaciones que los exports de ítems de qs-core, pero ligadas a este inventario. Es mejor usar las versiones de qs-core, que siguen funcionando si cambias a qs-inventory; IsBusy solo existe aquí.

exports['qs-coreinventory']:OpenStash(id, opts?)
exports['qs-coreinventory']:RegisterStashZone(id, coords, opts?)
exports['qs-coreinventory']:RemoveStashZone(id)
exports['qs-coreinventory']:HasItem(item, count?)
exports['qs-coreinventory']:GetItemCount(item)

OpenStash abre el inventario con el stash id como segundo panel, desde cualquier lugar (sin necesidad de zona). Devuelve false si el inventario ya está abierto. opts = { label, slots, maxWeight, columns } solo se usa para un stash que no se registró en el servidor.

exports['qs-corevehiclekeys']:GiveKeys(plate)
exports['qs-corevehiclekeys']:RemoveKeys(plate)
exports['qs-corevehiclekeys']:HasKeys(plate)
exports['qs-corevehiclekeys']:GetKeys()

Las llaves se guardan por sesión en el cliente. Da las llaves después de hacer aparecer un vehículo desde tu propio script, o el conductor no podrá arrancarlo. Desde el servidor, envía TriggerClientEvent('vehiclekeys:client:SetOwner', source, plate) — el mismo evento que usan los scripts de QBCore. Ejemplo: exports['qs-corevehiclekeys']:GiveKeys(GetVehicleNumberPlateText(vehicle))

exports['qs-clothing']:ApplyAppearance(skin, sex?)
exports['qs-clothing']:OpenCreator(sex, function(skin) end)
exports['qs-clothing']:IsCreatorOpen()

ApplyAppearance define el modelo freemode y toda la ropa, los props y los tatuajes a partir de una tabla de skin (una skin vacía aplica el aspecto predeterminado de sex). Para cambiar la apariencia guardada de un jugador desde el servidor, usa SetSkin de qs-core. Para abrir el editor, dispara qs-clothing:client:open.

exports['qs-police']:Alert(coords, label?)

Envía una alerta de despacho — notificación y blip parpadeante durante 60 segundos — a todos los jugadores con el trabajo police. coords debe ser una tabla simple { x, y, z }; un vector3 se ignora, así que conviértelo primero. Sin etiqueta, la alerta dice Shots fired. Ejemplo: local c = GetEntityCoords(GetPlayerPed(source)); exports['qs-police']:Alert({ x = c.x, y = c.y, z = c.z }, 'Store robbery')

qs-banking no tiene exports. Los saldos bancarios son la cuenta bank de qs-core, así que un script que paga o cobra en una cuenta bancaria usa exports['qs-core']:AddMoney(source, 'bank', amount, reason) y RemoveMoney. Los números de cuenta y el historial de transacciones se guardan en bank_accounts y bank_transactions.

exports['es_extended']:getSharedObject()                 -- shared
exports['qb-core']:GetCoreObject()                       -- shared
exports['LegacyFuel']:GetFuel(vehicle)                   -- client
exports['LegacyFuel']:SetFuel(vehicle, fuel)             -- client, 0-100
exports['progressbar']:Progress(data, function(cancelled) end) -- client
exports['qb-management']:AddMoney(job, amount)           -- server, also GetAccount, RemoveMoney, GetGangAccount, AddGangMoney, RemoveGangMoney
exports['esx_society']:addMoney(account, amount)         -- server, also getSociety, getSocietyMoney, removeMoney
exports['qb-vehiclekeys']:GiveKeys(source, plate)        -- server; client: GiveKeys, RemoveKeys, HasKeys, GetKeys

Responden con los nombres que ya llaman los scripts de ESX y QBCore, y redirigen a Quasar Framework. La lista completa está en Compatibilidad con ESX y QBCore.