Système d'animaux et compagnons pour FiveM

Les animaux de compagnie comme compagnons de jeu de rôle vivants

Les animaux de compagnie apportent une dimension émotionnelle unique aux serveurs de jeu de rôle qu'aucun autre système ne peut reproduire. Un joueur se promenant dans la ville avec son chien trottant à ses côtés crée une personnalité visuelle qui enrichit chaque interaction. Les compagnons de compagnie transforment les activités banales comme se rendre au magasin en moments immersifs. Ils créent des amorces de conversation organiques lorsque d'autres joueurs remarquent ton berger allemand ou posent des questions sur ton chat. Au-delà de l'élément social, les animaux de compagnie peuvent jouer un rôle fonctionnel en tant que chiens de garde qui alertent les propriétaires des intrus, unités de police K-9 qui aident aux recherches, animaux de soutien émotionnel dans les jeux de rôle à l'hôpital ou compagnons de chasse qui aident à traquer les proies. Construire un système pour animaux de compagnie nécessite la gestion de l'apparition et de la disparition des enfants, le comportement de suivi de l'IA, l'intégration d'animations, des besoins de simulation comme la faim et le bonheur, la persistance au fil des sessions et des commandes d'interaction qui permettent au propriétaire de contrôler son compagnon via des gestes naturels et des commandes vocales.

Modèles d'animaux et configuration disponibles

GTA V comprend plusieurs modèles d'animaux qui fonctionnent bien comme compagnons. Les chiens sont les plus polyvalents avec des modèles comme a_c_shepherd pour les bergers allemands, a_c_husky pour les Huskies, a_c_poodle pour les caniches, a_c_rottweiler pour les rottweilers, a_c_retriever pour les retrievers, et a_c_chop pour le modèle emblématique Chop. Les chats utilisent a_c_cat_01. Pour les options exotiques, il y a des lapins avec a_c_rabbit_01 et même des oiseaux avec a_c_crow. Chaque type d'animal doit avoir des paramètres de comportement différents configurés dans un fichier partagé. Les chiens suivent de près et peuvent courir à côté des véhicules à vitesse modérée. Les chats sont plus indépendants et parcourent parfois de courtes distances avant de revenir. Les oiseaux pouvaient se percher sur l'épaule du joueur en utilisant l'attachement d'entité. Définissez la distance de suivi, le multiplicateur de vitesse de déplacement, les animations inactives, les animations d'interaction et les capacités spéciales de chaque type d'animal pour créer des personnalités distinctes pour chaque espèce.

-- shared/config.lua
Config = {}

Config.PetTypes = {
    shepherd = {
        model       = 'a_c_shepherd',
        label       = 'German Shepherd',
        price       = 5000,
        followDist  = 2.5,
        runDist     = 8.0,
        maxSpeed    = 7.0,
        category    = 'dog',
        abilities   = {'guard', 'fetch', 'search'},
        idleAnims   = {'sit', 'lie_down', 'sniff'},
    },
    husky = {
        model       = 'a_c_husky',
        label       = 'Husky',
        price       = 6000,
        followDist  = 3.0,
        runDist     = 10.0,
        maxSpeed    = 8.0,
        category    = 'dog',
        abilities   = {'fetch', 'howl'},
        idleAnims   = {'sit', 'lie_down', 'play'},
    },
    cat = {
        model       = 'a_c_cat_01',
        label       = 'Cat',
        price       = 2000,
        followDist  = 4.0,
        runDist     = 6.0,
        maxSpeed    = 5.0,
        category    = 'cat',
        abilities   = {'purr', 'hunt_rodent'},
        idleAnims   = {'sit', 'groom', 'sleep'},
    },
    poodle = {
        model       = 'a_c_poodle',
        label       = 'Poodle',
        price       = 4000,
        followDist  = 2.0,
        runDist     = 6.0,
        maxSpeed    = 5.5,
        category    = 'dog',
        abilities   = {'fetch', 'trick'},
        idleAnims   = {'sit', 'beg', 'spin'},
    },
    rottweiler = {
        model       = 'a_c_rottweiler',
        label       = 'Rottweiler',
        price       = 7000,
        followDist  = 2.0,
        runDist     = 8.0,
        maxSpeed    = 7.5,
        category    = 'dog',
        abilities   = {'guard', 'attack', 'intimidate'},
        idleAnims   = {'sit', 'lie_down', 'bark'},
    },
}

Apparition et comportement de suivi

Le cœur de tout système pour animaux de compagnie est l’IA de suivi qui fait que l’animal suit naturellement son propriétaire. Lorsqu'un joueur fait apparaître son animal de compagnie, créez le ped à sa position en utilisant CreatePed avec le modèle approprié. Définissez le ped comme non persistant en utilisant SetEntityAsMissionEntity et configurez-le pour qu'il soit convivial pour le propriétaire à l'aide de groupes de relations. Le comportement de suivi utilise une boucle côté client qui calcule en permanence la distance entre l'animal et son propriétaire. Lorsque la distance dépasse le seuil de suivi, demandez à l'animal de courir vers une position légèrement derrière et sur le côté du propriétaire en utilisant TaskFollowToOffsetOfEntity. Ce natif gère automatiquement la recherche de chemin, permettant à l'animal de contourner les obstacles, de marcher sur les trottoirs et d'éviter la circulation. Lorsque le propriétaire arrête de bouger et que l'animal atteint sa distance de suivi, jouez une animation inactive comme s'asseoir ou s'allonger. Si le propriétaire monte dans un véhicule et s'en va, téléportez l'animal dans le véhicule s'il est d'un type approprié, ou faites-le disparaître et réapparaissez-le lorsque le propriétaire quitte le véhicule pour éviter qu'il ne se perde sur la carte.

-- client/pet_behavior.lua
local activePet = nil
local petData   = nil

function SpawnPet(petType, name)
    if activePet then DespawnPet() end

    local config = Config.PetTypes[petType]
    if not config then return end

    local ped = PlayerPedId()
    local coords = GetOffsetFromEntityInWorldCoords(ped, 1.5, 1.5, 0.0)

    RequestModel(config.model)
    while not HasModelLoaded(config.model) do Wait(10) end

    activePet = CreatePed(28, config.model,
        coords.x, coords.y, coords.z, 0.0, true, false)

    SetEntityAsMissionEntity(activePet, true, true)
    SetBlockingOfNonTemporaryEvents(activePet, true)
    SetPedCanBeTargetted(activePet, false)
    SetPedCanRagdoll(activePet, false)

    -- Set relationship so pet doesn't attack owner
    local playerGroup = GetHashKey('PLAYER')
    local petGroup = GetHashKey('PET_COMPANION')
    AddRelationshipGroup('PET_COMPANION')
    SetPedRelationshipGroupHash(activePet, petGroup)
    SetRelationshipBetweenGroups(0, petGroup, playerGroup)
    SetRelationshipBetweenGroups(0, playerGroup, petGroup)

    petData = {type = petType, name = name, config = config}

    -- Start follow loop
    CreateThread(PetFollowLoop)
end

function PetFollowLoop()
    while activePet and DoesEntityExist(activePet) do
        local ped = PlayerPedId()
        local petCoords = GetEntityCoords(activePet)
        local ownerCoords = GetEntityCoords(ped)
        local dist = #(petCoords - ownerCoords)

        if dist > 50.0 then
            -- Teleport if too far
            SetEntityCoords(activePet,
                ownerCoords.x, ownerCoords.y, ownerCoords.z)
        elseif dist > petData.config.runDist then
            -- Run to owner
            TaskFollowToOffsetOfEntity(activePet, ped,
                0.0, -1.5, 0.0, petData.config.maxSpeed,
                -1, 1.0, true)
        elseif dist > petData.config.followDist then
            -- Walk to owner
            TaskFollowToOffsetOfEntity(activePet, ped,
                0.0, -1.5, 0.0, 2.0, -1, 1.0, true)
        else
            -- Idle nearby
            if not IsEntityPlayingAnim(activePet, 'creatures@dog@amb@', 'sit_enter', 3) then
                if math.random() > 0.95 then
                    PlayIdleAnimation()
                end
            end
        end

        Wait(500)
    end
end

Besoins des animaux de compagnie et système de liaison

Un système de besoins confère aux propriétaires d’animaux une responsabilité et une profondeur continues. Suivez la faim, le bonheur et la santé sous forme de valeurs comprises entre 0 et 100 qui décroissent en temps réel. La faim diminue de 1 point toutes les 5 minutes en temps réel pendant lesquelles l'animal apparaît. Le bonheur diminue plus lentement, à raison de 1 point toutes les 10 minutes, mais augmente considérablement lorsque le propriétaire interagit avec l'animal en le caressant, en jouant à rapporter ou en lui donnant des friandises. La santé reste à 100 à moins que la faim ne descende en dessous de 20, moment auquel elle commence à décliner. Lorsque la faim atteint zéro, l'animal devient léthargique avec des mouvements plus lents et des animations tristes. Lorsque la santé devient trop faible, l’animal a besoin de soins vétérinaires pour récupérer. Les joueurs nourrissent leurs animaux de compagnie en utilisant les aliments de leur inventaire sur l'entité de l'animal. Différents types d'aliments rétablissent différentes quantités de faim : la nourriture de base pour animaux de compagnie restaure 30 points, la nourriture de qualité supérieure en restaure 60 et les friandises en restaurent 10 mais augmentent le bonheur de 15. Le niveau de liaison suit la relation cumulative entre le propriétaire et l'animal, augmentant grâce aux interactions positives et diminuant par la négligence. Des niveaux de liaison plus élevés débloquent des interactions spéciales et améliorent la réactivité de l'animal aux commandes.

-- server/pet_needs.lua
local petStates = {}

function InitPetState(ownerId, petId)
    petStates[ownerId] = {
        petId     = petId,
        hunger    = 100,
        happiness = 80,
        health    = 100,
        bond      = 0,
        lastFed   = os.time(),
        lastPet   = os.time(),
    }
end

-- Decay loop runs every 60 seconds
CreateThread(function()
    while true do
        Wait(60000)
        local now = os.time()
        for ownerId, state in pairs(petStates) do
            -- Hunger decay: 1 point per 5 minutes
            local minutesSinceFed = (now - state.lastFed) / 60
            state.hunger = math.max(0,
                100 - math.floor(minutesSinceFed / 5))

            -- Happiness decay
            local minutesSincePet = (now - state.lastPet) / 60
            state.happiness = math.max(0,
                math.min(100, state.happiness -
                    math.floor(minutesSincePet / 10)))

            -- Health decays when starving
            if state.hunger < 20 then
                state.health = math.max(0,
                    state.health - 1)
            end

            -- Sync to client
            local player = GetPlayerFromIdentifier(ownerId)
            if player then
                TriggerClientEvent('pet:syncState', player, state)
            end
        end
    end
end)

RegisterNetEvent('pet:feed', function(foodItem)
    local src = source
    local id = GetPlayerIdentifier(src, 0)
    local state = petStates[id]
    if not state then return end

    local foodValues = {
        petfood        = {hunger = 30, happiness = 5},
        premium_food   = {hunger = 60, happiness = 10},
        pet_treat      = {hunger = 10, happiness = 15},
    }

    local food = foodValues[foodItem]
    if not food then return end

    -- Remove item from inventory
    local removed = exports['ox_inventory']:RemoveItem(src, foodItem, 1)
    if not removed then return end

    state.hunger = math.min(100, state.hunger + food.hunger)
    state.happiness = math.min(100, state.happiness + food.happiness)
    state.lastFed = os.time()
    state.bond = state.bond + 1

    TriggerClientEvent('pet:syncState', src, state)
    TriggerClientEvent('pet:feedAnimation', src)
end)

Commandes d'interaction et animations

Offrez aux joueurs un riche ensemble de commandes pour interagir avec leur animal de compagnie. Un menu radial ou un système de commande doit offrir des options telles que s'asseoir, rester, suivre, venir, s'allonger, secouer, aller chercher et parler. Chaque commande déclenche une animation correspondante sur l'animal de compagnie à l'aide des dictionnaires d'animation de créatures intégrés à GTA V. La commande sit utilise des animations de creatures@dog@amb@ avec les clips sit_enter et sit_loop. Allongez-tu utilise des animations ambiantes similaires. Pour récupérer, générez un petit accessoire de balle, lancez-le en utilisant une trajectoire parabolique et demandez à l'animal de courir jusqu'à la position d'atterrissage de la balle, de le ramasser à l'aide d'un accessoire et de le rendre au propriétaire. La commande speak déclenche un aboiement audio en utilisant PlayPedAmbientSpeechNative. Pour caresser, jouez une animation à genoux sur le joueur tout en jouant simultanément une joyeuse animation de remuement de la queue sur l'animal. Ces interactions ne sont pas seulement cosmétiques ; chacun augmente les statistiques de bonheur et de lien, récompensant les joueurs qui s'engagent activement avec leur compagnon plutôt que de le traiter comme un suiveur passif.

Persistance et intégration de l'animalerie

Les animaux de compagnie doivent persister au fil des sessions du serveur afin que les joueurs ne perdent pas leurs compagnons à chaque redémarrage. Stockez les données de l'animal dans la base de données, y compris l'identifiant du propriétaire, le type d'animal, le nom personnalisé, les valeurs des besoins actuels, le niveau de liaison et toutes les astuces ou capacités débloquées. Lorsque le propriétaire se connecte, interrogez les données de son animal et proposez-lui de le faire apparaître via une commande ou automatiquement s'il l'avait actif lors de sa dernière déconnexion. Intégrez l'acquisition d'animaux de compagnie via une animalerie en jeu située à une position logique sur la carte. L'animalerie NUI affiche les types d'animaux disponibles avec leurs modèles rendus dans une zone d'aperçu, les prix et les descriptions. Après l'achat, le joueur nomme son nouvel animal de compagnie et celui-ci apparaît à côté de lui. Envisagez d'ajouter un centre d'adoption d'animaux de compagnie comme alternative avec des prix plus bas mais des types d'animaux de compagnie aléatoires, en ajoutant un angle de jeu de rôle caritatif. Pour les économies de serveur, les animaux de compagnie peuvent également nécessiter des dépenses périodiques telles que des visites chez le vétérinaire pour restaurer leur santé, un toilettage pour des bonus d'apparence et des séances de formation qui débloquent de nouvelles animations de commande, créant ainsi un coût de possession d'animal réaliste qui s'intègre à ton système économique plus large.

-- SQL schema
CREATE TABLE IF NOT EXISTS pets (
    id          INT AUTO_INCREMENT PRIMARY KEY,
    owner_id    VARCHAR(64) NOT NULL,
    char_slot   INT DEFAULT 1,
    pet_type    VARCHAR(32) NOT NULL,
    pet_name    VARCHAR(64) NOT NULL,
    hunger      INT DEFAULT 100,
    happiness   INT DEFAULT 80,
    health      INT DEFAULT 100,
    bond        INT DEFAULT 0,
    tricks      JSON DEFAULT '[]',
    is_active   TINYINT DEFAULT 0,
    created_at  TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
    updated_at  TIMESTAMP DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP,
    INDEX idx_owner (owner_id, char_slot)
);

-- server/persistence.lua
function SavePet(ownerId, charSlot, state)
    MySQL.update([[
        UPDATE pets SET
            hunger = ?, happiness = ?, health = ?,
            bond = ?, is_active = 1, updated_at = NOW()
        WHERE owner_id = ? AND char_slot = ?
    ]], {
        state.hunger, state.happiness, state.health,
        state.bond, ownerId, charSlot
    })
end

function LoadPet(ownerId, charSlot)
    return MySQL.single.await([[
        SELECT * FROM pets
        WHERE owner_id = ? AND char_slot = ?
        AND is_active = 1
    ]], {ownerId, charSlot})
end

Intégration de la police K-9 et rôles spéciaux

Pour le jeu de rôle des forces de l'ordre, étendez le système d'animaux de compagnie en une intégration complète d'unités K-9. Les chiens policiers acquièrent des capacités spéciales non disponibles pour les animaux de compagnie civils. La commande de recherche permet au K-9 de renifler les véhicules ou les bâtiments à proximité et d'alerter sur les objets de contrebande configurables en aboyant et en s'asseyant à côté de la source. Implémentez cela en vérifiant les inventaires des joueurs à proximité ou les coffres des véhicules pour les éléments signalés lorsque la commande de recherche est émise. La commande track permet au K-9 de suivre une piste olfactive, que tu peux mettre en œuvre en créant un fil d'Ariane des positions d'un suspect en fuite et en chargeant le chien de le suivre. La commande d'appréhension fait sprinter le K-9 vers une cible et joue une animation d'attaque, donnant aux officiers une option non létale pour les éliminations suspectes. Limitez ces capacités aux joueurs ayant le poste de policier et une certification de gestionnaire K-9. Le K-9 doit porter un gilet de police utilisant des variantes de composants pédestres ou des accessoires pour le distinguer visuellement des animaux de compagnie civils. Cette spécialisation crée un poste unique et très recherché au sein de la hiérarchie des services de police.