Criar Árvores de Skills e Talentos para FiveM

Por que as árvores de habilidades transformam os servidores de RPG

A maioria dos servidores de roleplay FiveM dependem de progressão baseada em trabalho, onde um jogador escolhe uma carreira e tem acesso instantâneo a todas as suas ferramentas e habilidades. Embora funcional, esta abordagem não proporciona qualquer sensação de crescimento ou investimento a longo prazo. As árvores de habilidades mudam fundamentalmente essa dinâmica. Ao introduzir a progressão no estilo RPG, os jogadores ganham experiência por meio de suas ações e gastam pontos de habilidade para desbloquear habilidades, vantagens e bônus passivos em árvores de talentos ramificadas. Um mecânico que conserta centenas de carros torna-se gradualmente mais rápido e eficiente. Um criminoso que arromba fechaduras repetidamente torna-se melhor nisso. Isso cria um desenvolvimento significativo do personagem que recompensa a dedicação e faz com que cada personagem se sinta único. A chave é projetar um sistema que aprimore o RPG em vez de transformar seu servidor em um MMO, mantendo os bônus sutis o suficiente para que as diferenças de habilidade complementem os cenários de RP em vez de dominá-los.

Projetando a estrutura de dados da árvore de habilidades

Uma árvore de habilidades bem projetada começa com uma estrutura de dados limpa. Cada árvore de habilidades pertence a uma categoria como combate, artesanato, direção, medicina ou criminal. Dentro de cada árvore, nós individuais representam habilidades que podem ser desbloqueadas. Cada nó possui um identificador exclusivo, um nome de exibição, uma descrição, um nível máximo, um custo de pontos por nível, nós de pré-requisito que devem ser desbloqueados primeiro e o efeito de jogo real que ele aplica. Armazene as definições de árvore em um arquivo de configuração compartilhado para que o servidor e o cliente possam referenciá-las. O progresso do jogador é uma estrutura de dados separada que rastreia quais nós eles desbloquearam e em que nível, junto com seus pontos de habilidade não gastos disponíveis. Manter a definição da árvore separada do progresso do jogador significa que você pode atualizar ou reequilibrar a árvore sem migrar os dados do jogador, desde que os identificadores dos nós permaneçam estáveis.

-- shared/skill_trees.lua
SkillTrees = {
    mechanic = {
        label = 'Mechanic',
        icon  = 'fa-wrench',
        nodes = {
            quickFix = {
                label    = 'Quick Fix',
                desc     = 'Reduce vehicle repair time',
                maxLevel = 5,
                cost     = 1,
                prereqs  = {},
                effect   = {type = 'repair_speed', perLevel = 0.10},
            },
            engineExpert = {
                label    = 'Engine Expert',
                desc     = 'Repair engines to higher condition',
                maxLevel = 3,
                cost     = 2,
                prereqs  = {'quickFix'},
                effect   = {type = 'engine_quality', perLevel = 0.15},
            },
            bodyworkMaster = {
                label    = 'Bodywork Master',
                desc     = 'Repair body damage more effectively',
                maxLevel = 3,
                cost     = 2,
                prereqs  = {'quickFix'},
                effect   = {type = 'body_quality', perLevel = 0.15},
            },
            turboTuner = {
                label    = 'Turbo Tuner',
                desc     = 'Unlock performance tuning abilities',
                maxLevel = 1,
                cost     = 5,
                prereqs  = {'engineExpert'},
                effect   = {type = 'unlock_tuning', perLevel = 1},
            },
        },
    },
    criminal = {
        label = 'Street Smarts',
        icon  = 'fa-mask',
        nodes = {
            lockpicking = {
                label    = 'Lockpicking',
                desc     = 'Pick locks faster with fewer failures',
                maxLevel = 5,
                cost     = 1,
                prereqs  = {},
                effect   = {type = 'lockpick_speed', perLevel = 0.12},
            },
            silentStep = {
                label    = 'Silent Step',
                desc     = 'Reduce noise while crouching',
                maxLevel = 3,
                cost     = 2,
                prereqs  = {'lockpicking'},
                effect   = {type = 'noise_reduction', perLevel = 0.20},
            },
            safecracker = {
                label    = 'Safecracker',
                desc     = 'Attempt to crack safes',
                maxLevel = 1,
                cost     = 4,
                prereqs  = {'lockpicking'},
                effect   = {type = 'unlock_safecrack', perLevel = 1},
            },
        },
    },
}

Acompanhamento e nivelamento de experiência

A experiência deve ser obtida organicamente por meio de ações de jogo, e não por meio de loops repetitivos. Acompanhe a experiência por categoria da árvore de habilidades para que realizar trabalho mecânico ganhe XP mecânico, cometer crimes ganhe XP criminal e assim por diante. Defina limites de experiência para cada nível e, quando um jogador ultrapassa um limite, ele ganha um ou mais pontos de habilidade para gastar nessa árvore. Use retornos decrescentes em ações idênticas repetidas para desencorajar loops de exploração. Por exemplo, o primeiro conserto de veículo em uma janela de 10 minutos pode conceder 50 XP, mas os reparos subsequentes concedem 25, depois 10 e depois 5. Isso recompensa uma jogabilidade variada em vez de repetições estúpidas. O servidor deve ser a única autoridade em concessões de XP, nunca confiando no cliente para relatar seus próprios valores de experiência. Acione eventos XP a partir da lógica do servidor após verificar se a ação realmente ocorreu.

-- server/experience.lua
local XP_THRESHOLDS = {0, 100, 300, 600, 1000, 1500, 2200, 3000, 4000, 5500}

local recentActions = {}

function GrantXP(playerId, tree, amount, actionType)
    local identifier = GetPlayerIdentifier(playerId, 0)
    local now = os.time()

    -- Diminishing returns for repeated actions
    local key = identifier .. ':' .. tree .. ':' .. actionType
    if not recentActions[key] then
        recentActions[key] = {count = 0, resetAt = now + 600}
    end
    local ra = recentActions[key]
    if now > ra.resetAt then
        ra.count = 0
        ra.resetAt = now + 600
    end
    ra.count = ra.count + 1

    local multiplier = math.max(0.1, 1.0 - (ra.count - 1) * 0.25)
    local finalXP = math.floor(amount * multiplier)

    -- Update database
    MySQL.update([[
        UPDATE character_skills SET xp = xp + ?
        WHERE identifier = ? AND tree = ?
    ]], {finalXP, identifier, tree})

    -- Check for level up
    local data = MySQL.single.await([[
        SELECT xp, level, points FROM character_skills
        WHERE identifier = ? AND tree = ?
    ]], {identifier, tree})

    if data then
        local nextThreshold = XP_THRESHOLDS[data.level + 2]
        if nextThreshold and data.xp >= nextThreshold then
            local newLevel = data.level + 1
            MySQL.update([[
                UPDATE character_skills
                SET level = ?, points = points + 1
                WHERE identifier = ? AND tree = ?
            ]], {newLevel, identifier, tree})
            TriggerClientEvent('skills:levelUp', playerId, tree, newLevel)
        end
    end

    TriggerClientEvent('skills:xpGained', playerId, tree, finalXP)
end

Aplicando efeitos de habilidade à jogabilidade

Os efeitos das habilidades são onde o sistema se torna tangível para os jogadores. Cada nó desbloqueado modifica uma mecânica de jogo específica de forma mensurável. Implemente um resolvedor de efeitos central que receba um identificador de jogador e um tipo de efeito e, em seguida, calcule o bônus total de todos os nós desbloqueados que contribuem para esse efeito. Quando outro script precisa saber o bônus de velocidade de reparo de um jogador, ele chama esse resolvedor e recebe de volta um multiplicador. Isso mantém seu sistema de habilidades dissociado de outros recursos. Outros scripts não precisam saber sobre árvores de habilidades, nós ou níveis; eles apenas pedem um valor de bônus por tipo. Para habilidades desbloqueáveis, como arrombamento de cofre ou ajuste turbo, o resolvedor retorna um booleano indicando se o jogador possui o nó necessário. Essa arquitetura facilita a integração de habilidades em scripts existentes com alterações mínimas de código.

-- server/effects.lua
local playerSkillCache = {}

function GetSkillBonus(playerId, effectType)
    local identifier = GetPlayerIdentifier(playerId, 0)
    local cache = playerSkillCache[identifier]
    if not cache then return 0.0 end

    local total = 0.0
    for treeName, treeDef in pairs(SkillTrees) do
        for nodeId, nodeDef in pairs(treeDef.nodes) do
            if nodeDef.effect.type == effectType then
                local unlocked = cache[treeName] and cache[treeName][nodeId] or 0
                total = total + (nodeDef.effect.perLevel * unlocked)
            end
        end
    end
    return total
end

function HasSkillUnlock(playerId, effectType)
    return GetSkillBonus(playerId, effectType) > 0
end

-- Export for other resources
exports('GetSkillBonus', GetSkillBonus)
exports('HasSkillUnlock', HasSkillUnlock)

-- Example: another resource checking repair speed
-- local bonus = exports['skillsystem']:GetSkillBonus(source, 'repair_speed')
-- local repairTime = baseTime * (1.0 - bonus)

Construindo a Árvore de Habilidades NUI

A apresentação visual da sua árvore de habilidades afeta diretamente o envolvimento dos jogadores com o sistema de progressão. Crie um painel NUI que exiba cada árvore como um gráfico ramificado com nós conectados por linhas mostrando pré-requisitos. Os nós desbloqueados devem brilhar ou pulsar com cores, os nós bloqueados, mas disponíveis, devem aparecer ligeiramente esmaecidos e os nós cujos pré-requisitos não foram atendidos devem estar esmaecidos. Mostre o nível atual do jogador, a barra de progresso de XP e os pontos de habilidade disponíveis com destaque na parte superior. Quando um jogador clica em um nó, exibe sua descrição, o nível atual fora do máximo, o custo para atualizar e o bônus de efeito por nível. Inclua uma etapa de confirmação antes de gastar pontos, pois os jogadores podem querer planejar suas construções com cuidado. Use transições CSS suaves para mudanças de estado para que a atualização de um nó seja recompensadora com um breve flash ou animação em escala. Considere adicionar uma opção de redefinição, gratuita ou com custo de moeda do jogo, para que os jogadores possam respeitar suas construções se o meta mudar ou se quiserem tentar um estilo de jogo diferente.

Considerações de equilíbrio e anti-exploração

O equilíbrio é a parte mais difícil de qualquer sistema de progressão. Se os bônus forem muito fortes, os jogadores de alto nível se tornarão intocáveis ​​e os novos jogadores se sentirão desesperados. Se os bônus forem muito fracos, ninguém se importa com a progressão. Comece de forma conservadora com bônus de 5 a 15 por cento por habilidade no nível máximo e monitore o feedback dos jogadores. Implemente a validação do lado do servidor para cada alocação de pontos de habilidade. Quando um jogador solicitar a atualização de um nó, verifique se ele tem pontos suficientes, se todos os pré-requisitos foram atendidos e se o nó ainda não está no nível máximo. Nunca confie no estado do cliente para essas verificações. Adicione registro para todas as transações de pontos de habilidade para que você possa detectar e reverter explorações. Solicitações de alocação de habilidades com limite de taxa para evitar tentativas rápidas de exploração. Para cenários competitivos, considere limites de habilidade que limitem quantas árvores um único personagem pode investir, forçando escolhas significativas em vez de permitir que um jogador maximize tudo. Isso cria diversas construções de personagens e incentiva a cooperação entre jogadores com conjuntos de habilidades complementares.

Esquema de banco de dados e estratégia de migração

Projete seu esquema de banco de dados para lidar com dados de habilidades atuais e futuras expansões de árvore de maneira elegante. Armazene as alocações de habilidades do jogador como linhas individuais por árvore e por personagem, em vez de um único blob JSON. Isso torna eficiente a consulta de habilidades específicas e permite a agregação em nível de banco de dados para análise. Inclua colunas para o nome da árvore, nível atual, XP total, pontos disponíveis e uma coluna JSON para alocações de nós nessa árvore. Quando você adiciona novas árvores de habilidades ou nós em atualizações futuras, os dados existentes dos jogadores permanecem intactos porque os novos nós simplesmente começam no nível zero. Se você renomear ou remover um nó, lide com a migração devolvendo os pontos gastos ao pool disponível do jogador para aquela árvore. Versão das definições da sua árvore para que a lógica de migração saiba quais alterações aplicar. Essa abordagem inovadora evita migrações de dados dolorosas à medida que seu sistema de habilidades evolui ao longo de meses de operação do servidor.

-- SQL schema
CREATE TABLE IF NOT EXISTS character_skills (
    id          INT AUTO_INCREMENT PRIMARY KEY,
    identifier  VARCHAR(64) NOT NULL,
    char_slot   INT DEFAULT 1,
    tree        VARCHAR(32) NOT NULL,
    level       INT DEFAULT 0,
    xp          INT DEFAULT 0,
    points      INT DEFAULT 0,
    allocations JSON DEFAULT '{}',
    created_at  TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
    updated_at  TIMESTAMP DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP,
    UNIQUE KEY unique_char_tree (identifier, char_slot, tree),
    INDEX idx_identifier (identifier)
);