Início › Documentação › Exports · origen_ilegalv2

Exports · origen_ilegalv2

Todos os exports estão registados sob o nome do recurso origen_ilegalv2. A tabela abaixo separa-os pelo lado de execução: usa o lado correto ou a chamada será ignorada sem aviso.

Exports do servidor

Dados de gangues

GetPlayerGang(source) → string | nil

Devolve o ID da gangue do jogador indicado, ou nil se não tiver nenhuma.

lua
local gangId = exports['origen_ilegalv2']:GetPlayerGang(source)

GetPlayerGangData(source) → { id, label } | nil

Devolve o id da gangue do jogador e o seu label visível.

lua
local data = exports['origen_ilegalv2']:GetPlayerGangData(source)
if data then
    print(data.id, data.label)
end

GetPlayerGangByCid(citizenid) → table | nil

Procura a pertença a uma gangue a partir do identificador do cidadão. Útil para painéis de administração e leituras entre recursos.

lua
local info = exports['origen_ilegalv2']:GetPlayerGangByCid(citizenid)
-- { id, name, label, rankName, rankGrade, isLeader }

GetGangInfo(gangId) → table | nil

Devolve um retrato consolidado de uma gangue. É o export recomendado para recursos externos que precisam de mais do que o ID ou o nome: agrega os dados em memória e uma única contagem na base de dados dos territórios numa só chamada.

lua
local info = exports['origen_ilegalv2']:GetGangInfo('vagos')
if not info then return end -- gang doesn't exist or isn't loaded

Campos devolvidos:

Campo Tipo Descrição
id string ID interno da gangue
label string Nome visível
leader string Identificador do líder (citizenid / license)
color string Cor hexadecimal (#rrggbb)
is_active boolean Se a gangue está atualmente ativa (points > 0)
level number Nível da gangue (1+)
exp number XP atual dentro do nível atual
points number Pontos da gangue (0–100). Se chegar a 0, a gangue é desativada
money number Saldo do banco da gangue
member_count number Total de membros registados
online_count number Membros ligados neste momento
max_members number Máximo de membros permitido (origen_gang_config)
max_vehicles number Máximo de veículos permitido
territory_count number Territórios atualmente controlados (contagem em direto na base de dados)
base_territory string|nil ID do território base da gangue
created_at string|nil Marca temporal de criação

Exemplo de utilização:

lua
local info = exports['origen_ilegalv2']:GetGangInfo('vagos')
 
-- Gate by level
if info.level < 3 then
    return cb({ success = false, reason = 'gang_level_too_low' })
end
 
-- Gate by territories
if info.territory_count < 2 then
    return cb({ success = false, reason = 'not_enough_territories' })
end
 
-- Check capacity before inviting
if info.member_count >= info.max_members then
    return cb({ success = false, reason = 'gang_full' })
end
 
print(string.format(
    '[%s] Level %d | Members %d/%d | Territories %d | Bank $%d',
    info.label,
    info.level,
    info.member_count, info.max_members,
    info.territory_count,
    info.money
))

territory_count é o único campo que consulta a base de dados; tudo o resto é lido diretamente da instância de Gang em memória. A consulta é um único SELECT COUNT(*), pelo que é seguro chamá-la em cada pedido.

GetGangById(gangId) → { id, label, name, money, level } | nil

lua
local gang = exports['origen_ilegalv2']:GetGangById('vagos')

GetGangByName(gangName) → { id, label, name, money } | nil

lua
local gang = exports['origen_ilegalv2']:GetGangByName('vagos')

GetGangs() → table<gangId, { id, label }>

Devolve todas as instâncias de gangues ativas indexadas por ID.

lua
local gangs = exports['origen_ilegalv2']:GetGangs()
for id, gang in pairs(gangs) do
    print(id, gang.label)
end

GetGangLevelById(gangId) → number | nil

Devolve o nível atual de uma gangue. Devolve nil se a gangue não existir.

lua
local level = exports['origen_ilegalv2']:GetGangLevelById('vagos')
if level and level >= 5 then
    -- unlock tier-2 content
end

setGang(identifier, gangName, rankId) → boolean

Export de compatibilidade. Atribui um jogador, por identificador, a uma gangue com nome no grau indicado, retirando-o antes da sua gangue atual.

lua
exports['origen_ilegalv2']:setGang(identifier, 'vagos', 1)

Atalhos de interface

OpenGangMenuBySource(source) → boolean

Abre a NUI do painel da gangue para um jogador que já está numa gangue.

lua
exports['origen_ilegalv2']:OpenGangMenuBySource(source)

OpenGangCreationBySource(source) → boolean

Abre o assistente de criação de gangues para um jogador. O jogador tem de ter can_create_gang = 1 em origen_gang_permissions.

lua
exports['origen_ilegalv2']:OpenGangCreationBySource(source)

Laboratórios

GetPlayerLabState(source) → { lab_id, lab_type, bucket, world_exit } | nil

Devolve em que laboratório está atualmente um jogador. nil se o jogador não estiver em nenhum laboratório.

lua
local state = exports['origen_ilegalv2']:GetPlayerLabState(source)
if state then
    print(state.lab_id, state.lab_type)
end

AdminLabsGetAll() → table[]

Devolve todas as linhas de laboratórios da base de dados (em cache). Usa-se internamente nas verificações de acesso aos laboratórios.

lua
local labs = exports['origen_ilegalv2']:AdminLabsGetAll()

AdminLabsInvalidateCache()

Esvazia a cache de laboratórios em memória, de modo que a chamada seguinte a AdminLabsGetAll volte a consultar a base de dados.

lua
exports['origen_ilegalv2']:AdminLabsInvalidateCache()

MethLabResetPlayerState(source)

Reinicia à força o estado de produção do laboratório de meta de um jogador (útil para o expulsar a meio de um ciclo).

lua
exports['origen_ilegalv2']:MethLabResetPlayerState(source)

CokeLabResetPlayerState(source)

Reinicia à força o estado de produção do laboratório de cocaína de um jogador.

lua
exports['origen_ilegalv2']:CokeLabResetPlayerState(source)

WeedLabResetPlayerState(source)

Reinicia à força o estado do laboratório de erva de um jogador (liberta os pontos de secagem que ocupe).

lua
exports['origen_ilegalv2']:WeedLabResetPlayerState(source)

Fabrico

CraftingPointsGetAll() → table[]

Devolve todos os pontos de fabrico base (definidos pelo administrador, sem incluir as instâncias de laboratório) a partir da cache da base de dados.

lua
local points = exports['origen_ilegalv2']:CraftingPointsGetAll()

CraftingLabInstancesGetAll() → table[]

Devolve todas as instâncias de pontos de fabrico que foram compradas dentro de laboratórios (apenas em tempo de execução, não são pontos base).

lua
local instances = exports['origen_ilegalv2']:CraftingLabInstancesGetAll()

CraftingPointsInvalidateCache()

Invalida tanto a cache de pontos base como a de instâncias de laboratório.

lua
exports['origen_ilegalv2']:CraftingPointsInvalidateCache()

Lojas

StoresGetAll() → table[]

Devolve todas as lojas de gangues a partir da cache da base de dados.

lua
local stores = exports['origen_ilegalv2']:StoresGetAll()

StoresInvalidateCache()

Esvazia a cache de lojas em memória.

SellStoresGetAll() → table[]

Devolve todas as lojas de venda de gangues a partir da cache da base de dados.

lua
local sellStores = exports['origen_ilegalv2']:SellStoresGetAll()

SellStoresInvalidateCache()

Esvazia a cache de lojas de venda em memória.

Territórios

CaptureTerritory(territoryId, gangId) → boolean

Atribui um território a uma gangue por código. Provoca uma atualização do mapa no cliente de todos os jogadores.

lua
local ok = exports['origen_ilegalv2']:CaptureTerritory('davis', 'vagos')

ReleaseTerritory(territoryId) → boolean

Retira a propriedade da gangue sobre um território (define gang_id = NULL). Provoca uma atualização do mapa no cliente.

lua
exports['origen_ilegalv2']:ReleaseTerritory('davis')

AddTerritoryReputation(territoryId, gangId, amount) → { success, message? }

Adiciona pontos de reputação a uma gangue num território. Valida que a gangue e o território existem e que os territórios base estão protegidos.

lua
local result = exports['origen_ilegalv2']:AddTerritoryReputation('davis', 'vagos', 10.0)
if result.success then ... end

RemoveTerritoryReputation(territoryId, gangId, amount) → { success, message? }

Retira pontos de reputação a uma gangue num território.

SetTerritoryReputation(territoryId, gangId, amount) → { success, message? }

Define a reputação de uma gangue num território para um valor exato (0–100).

GetGangTerritoryReputation(territoryId, gangId) → number

Devolve o valor atual de reputação de uma gangue num território.

lua
local rep = exports['origen_ilegalv2']:GetGangTerritoryReputation('davis', 'vagos')

GetAllTerritoryReputations(territoryId) → table[]

Devolve todas as linhas de reputação de um território, ordenadas da maior para a menor reputação.

ClearTerritoryReputations(territoryId) → { success, message? }

Elimina todos os dados de reputação de um território e liberta a propriedade da gangue.

GetTerritoryStabilization(territoryId) → { active, remaining_seconds, remaining_minutes }

Devolve se um território está dentro da sua janela de estabilização posterior à captura.

lua
local stab = exports['origen_ilegalv2']:GetTerritoryStabilization('davis')
if stab.active then
    print('Locked for', stab.remaining_minutes, 'more minutes')
end

GetTerritoryCaptureBlock(territoryId) → { active, remaining_seconds, remaining_minutes, cooldown_days }

Devolve se o cooldown de captura de cada território (campo capture_cooldown_until da base de dados) ainda está ativo.

GetPlayersInTerritory(territoryId) → table[]

Devolve a lista de sources de jogadores que o sistema de presença tem atualmente registados dentro de um território.

lua
local players = exports['origen_ilegalv2']:GetPlayersInTerritory('davis')

GetGangMembersInTerritory(territoryId, gangId) → table[]

Devolve apenas os membros de uma gangue concreta que estão atualmente dentro de um território.

GetPlayerPresenceData(source) → table | nil

Devolve o estado de acompanhamento de presença de um jogador: em que território está, há quanto tempo lá está, etc.

IsPlayerInTerritory(source, territoryId) → boolean

Devolve true se, segundo o sistema de presença do servidor, um jogador está atualmente dentro do território indicado.

lua
local inside = exports['origen_ilegalv2']:IsPlayerInTerritory(source, 'davis')

Venda de droga

GetDrugSellLevel(source) → number (0–100)

Devolve o nível de venda na rua de um jogador (um valor de progressão de 0 a 100 que aumenta com as vendas bem-sucedidas).

lua
local level = exports['origen_ilegalv2']:GetDrugSellLevel(source)

ProcessDrugSaleReputation(source)

Dispara manualmente o processamento de reputação de território por uma venda de droga de um jogador: a mesma lógica que se executa com origen_gang:drugSales:saleCompleted.

lua
exports['origen_ilegalv2']:ProcessDrugSaleReputation(source)

GetPlayerSalesInfo(source) → { salesThisHour, maxSalesPerHour, remainingSales, nextResetIn }

Devolve as estatísticas de vendas de droga da hora atual de um jogador face ao limite de reputação do território.

lua
local info = exports['origen_ilegalv2']:GetPlayerSalesInfo(source)
print(info.remainingSales, 'sales left this hour')

Veículos

GetGangVehicles(gangId) → table[]

Devolve todas as linhas de veículos de origen_gang_vehicles de uma gangue.

lua
local vehicles = exports['origen_ilegalv2']:GetGangVehicles('vagos')

GetVehicleCatalog(gangId) → table[]

Devolve as entradas ativadas do catálogo de veículos de uma gangue a partir de origen_gang_vehicle_catalog.

Organização — Tarefas

AddOrganizationTask(taskDef) → boolean

Regista uma tarefa no catálogo global. Se task_key já existir, a linha é atualizada.

lua
exports['origen_ilegalv2']:AddOrganizationTask({
    task_key      = 'deliver_supplies',
    label         = 'Deliver Supplies',
    description   = 'Complete 3 supply runs.',
    category      = 'supply',
    is_repeatable = false,
    meta          = { reward = 5000 },
})

Chama-o dentro de AddEventHandler('onResourceStart', ...): o OrgPanels não está pronto antes de o recurso acabar de carregar.

CompleteGangTask(gangId, taskKey, opts?) → { ok, error?, times_completed }

lua
local result = exports['origen_ilegalv2']:CompleteGangTask('vagos', 'deliver_supplies', {
    completed_by = identifier,
})

IsGangTaskCompleted(gangId, taskKey) → boolean

lua
local done = exports['origen_ilegalv2']:IsGangTaskCompleted('vagos', 'deliver_supplies')

GetGangTasks(gangId) → table[]

Devolve o catálogo completo de tarefas com o estado de conclusão de cada gangue.

Organização — Melhorias

AddOrganizationUpgrade(upgradeDef) → boolean

lua
exports['origen_ilegalv2']:AddOrganizationUpgrade({
    upgrade_key    = 'tier2_robberies',
    label          = 'Tier 2 Robberies',
    type           = 'robbery_unlock',
    required_tasks = { 'deliver_supplies' },
    effect         = { feature = 'robberies:tier2' },
})

UnlockGangUpgrade(gangId, upgradeKey, opts?) → { ok, error?, missing_tasks? }

Valida as dependências de tarefas antes de desbloquear. error = 'missing_dependencies' inclui missing_tasks: [{ task_key, label }].

HasGangUpgrade(gangId, upgradeKey) → boolean

IsGangFeatureUnlocked(gangId, featureKey) → boolean

Verifica se alguma melhoria desbloqueada de uma gangue tem effect.feature == featureKey.

lua
local ok = exports['origen_ilegalv2']:IsGangFeatureUnlocked('vagos', 'robberies:tier2')

GetGangUpgrades(gangId) → table[]

Devolve o catálogo completo de melhorias com o estado de desbloqueio de cada gangue e a resolução de dependências.

Pedidos de assalto

GetRobberyRequestConfig() → table | nil

Devolve a configuração do módulo de pedidos de assalto, indexada para consulta rápida pelo origen_police. Devolve nil se o módulo estiver desativado.

O origen_police consome este export internamente para validar os ID de pedido, os cooldowns e os intervalos de participantes sem se acoplar à tabela Config completa.

lua
local cfg = exports['origen_ilegalv2']:GetRobberyRequestConfig()
if not cfg then return end -- module disabled
 
local entry = cfg.requestsById['paleto_bank']
-- entry = { id, label, image, requiredCops, minParticipants, maxParticipants, cooldownSeconds }

Campos devolvidos:

Campo Tipo Descrição
enabled boolean Sempre true (devolve-se nil quando está desativado)
pendingExpireMinutes number TTL dos pedidos pending, em minutos
approvedExpireMinutes number TTL dos pedidos approved, em minutos
requestsById table<robberyId, entry> Todas as entradas de assalto ativas indexadas por id para pesquisa em O(1)

GetRobberyRequestStatus(source, robberyId) → { ok, status, error? }

Devolve o estado normalizado do pedido de assalto da gangue para um source de jogador e um ID de assalto dados. Resolve a gangue internamente: quem chama só precisa do source do jogador.

lua
local res = exports['origen_ilegalv2']:GetRobberyRequestStatus(source, 'paleto_bank')
if res.ok and res.status == 'approved' then
    -- allow the robbery to start
end

Parâmetros:

Parâmetro Tipo Descrição
source number Source do servidor do jogador
robberyId string ID do assalto tal como definido em Config.RobberyRequest.Requests

Devolve:

Campo Tipo Descrição
ok boolean false se não foi possível resolver o source ou a gangue
status string "pending" | "approved" | "rejected" | "not_requested"
error string? Presente quando ok = false: "invalid_source" | "no_gang"

Os estados internos (cancelled, expired, started) são normalizados para "not_requested", de modo que os integradores nunca tenham de os tratar.

HasApprovedRobberyRequest(source, robberyId) → boolean

Atalho booleano para a verificação mais habitual: devolve true apenas quando o pedido da gangue está no estado approved. Ideal para condicionais diretas nos scripts de assaltos.

lua
if exports['origen_ilegalv2']:HasApprovedRobberyRequest(source, 'paleto_bank') then
    -- start the robbery flow
end

Devolve false se o source não for válido, o jogador não tiver gangue ou o pedido estiver em qualquer estado diferente de approved.

Exports do cliente

Gangue

GetPlayerGang() → table | nil

Devolve a tabela de dados da gangue atual do jogador local (o mesmo objeto que a NUI usa). nil se não estiver numa gangue.

lua
local gang = exports['origen_ilegalv2']:GetPlayerGang()
if gang then
    print(gang.id, gang.label)
end

OpenGangMenu()

Abre a NUI do painel da gangue para o jogador local.

lua
exports['origen_ilegalv2']:OpenGangMenu()

OpenGangCreation()

Abre o assistente de criação de gangues para o jogador local.

lua
exports['origen_ilegalv2']:OpenGangCreation()

Laboratórios

GetInsideLab() → { lab_id, lab_type, lab_name } | nil

Devolve o laboratório em que o jogador local está atualmente, ou nil se não estiver em nenhum. Usam-no todos os scripts de cliente de laboratórios para proteger as interações.

lua
local lab = exports['origen_ilegalv2']:GetInsideLab()
if lab and lab.lab_type == 'meth' then ... end

IsGangLabOpen() → boolean

Devolve true se o painel NUI do portátil do laboratório estiver aberto.

lua
if exports['origen_ilegalv2']:IsGangLabOpen() then
    -- don't open another menu on top
end

CloseGangLab()

Fecha por código o painel NUI do portátil do laboratório.

MethLabResetProduction()

Reinicia o estado de produção do laboratório de meta no cliente (apaga a fase atual, os temporizadores e os modificadores).

lua
exports['origen_ilegalv2']:MethLabResetProduction()

CokeLabResetProduction()

Reinicia o estado de produção do laboratório de cocaína no cliente.

InitLabStashPoints(stashes)

Inicializa as zonas de interação lib.points dos pontos de arrecadação do laboratório. O ciclo de vida do laboratório chama-o internamente à entrada; só precisas dele se estiveres a construir uma integração de laboratório personalizada.

ClearLabStashPoints()

Remove todos os pontos de interação ativos das arrecadações do laboratório e esconde qualquer HelpText aberto.

ApplyLabIplState(labType, iplModules)

Aplica o estado de IPL das melhorias do laboratório (alterações de props do interior) para o tipo de laboratório e o retrato de módulos indicados. Chama-se internamente quando um jogador entra num laboratório; só precisas dele para integrações personalizadas.

Territórios

GetTerritories() → table<territoryId, territory>

Devolve o mapa completo de territórios carregado atualmente no cliente.

lua
local territories = exports['origen_ilegalv2']:GetTerritories()

GetTerritoryById(territoryId) → table | nil

Devolve um único território por ID a partir da cache do cliente.

lua
local t = exports['origen_ilegalv2']:GetTerritoryById('davis')

IsPlayerInTerritory(territoryId) → boolean

Devolve true se a posição atual do jogador local estiver dentro da zona do território indicado.

lua
local inside = exports['origen_ilegalv2']:IsPlayerInTerritory('davis')

GetPlayerPresenceData() → table

Devolve o estado de acompanhamento de presença do cliente: { isInTerritory, currentTerritory, timeInZone, ... }.

lua
local presence = exports['origen_ilegalv2']:GetPlayerPresenceData()
if presence.isInTerritory then
    print('In territory:', presence.currentTerritory)
end

GetCurrentTerritory() → table | nil

Devolve o objeto do território em que o jogador local está atualmente, ou nil se estiver fora de todas as zonas.

lua
local territory = exports['origen_ilegalv2']:GetCurrentTerritory()

Venda de droga

SellDrugToNearestPed(drugName)

Dispara por código uma tentativa de vender uma droga ao ped elegível mais próximo: a mesma lógica do modo passivo de venda na rua, mas invocável a partir de fora.

lua
exports['origen_ilegalv2']:SellDrugToNearestPed('packaged_weed')

Fabrico

IsCraftingMenuOpen() → boolean

Devolve true se o painel NUI de fabrico estiver aberto.

CloseCraftingMenu()

Fecha o painel NUI de fabrico e limpa o estado de vigilância do servidor.

Lojas

IsStoreMenuOpen() → boolean

Devolve true se a NUI da loja da gangue estiver aberta.

CloseStoreMenu()

Fecha a NUI da loja da gangue.

IsSellMenuOpen() → boolean

Devolve true se a NUI da loja de venda da gangue estiver aberta.

CloseSellMenu()

Fecha a NUI da loja de venda da gangue.

Algemas

IsHandcuffed() → boolean

Devolve true se o jogador local estiver atualmente algemado pela ação de algemar do menu rápido da gangue.

lua
if exports['origen_ilegalv2']:IsHandcuffed() then
    -- prevent certain actions
end

RemoveHandCuff()

Retira à força as algemas ao jogador local (desanexa o prop, limpa as tarefas e volta a permitir disparar).

lua
exports['origen_ilegalv2']:RemoveHandCuff()

Painel de administração

openManagement()

Abre a NUI do painel de gestão de administração como se fosse aberto a partir de um hub externo (ativa a flag openedFromHub para que o painel salte o seu atraso normal de captura do foco).

lua
exports['origen_ilegalv2']:openManagement()

IsOpenedFromHub() → boolean

Devolve se o painel de administração foi aberto pela última vez através de openManagement().

ResetHubFlag()

Limpa a flag openedFromHub.