FiveM पालतू और साथी सिस्टम: वफादार साथी स्क्रिप्टिंग

जीवित रोलप्ले साथी के रूप में पालतू जानवर

पालतू जानवर रोलप्ले सर्वरों में एक अनूठा भावनात्मक आयाम लाते हैं जिसे कोई अन्य प्रणाली दोहरा नहीं सकती। एक खिलाड़ी जो अपने कुत्ते के साथ शहर में चलता है, एक दृश्य व्यक्तित्व बनाता है जो हर बातचीत को समृद्ध करता है। पालतू साथी साधारण गतिविधियों जैसे दुकान तक चलना को भी immersive क्षणों में बदल देते हैं। जब अन्य खिलाड़ी आपके जर्मन शेफर्ड को देखते हैं या आपकी बिल्ली के बारे में पूछते हैं, तो वे स्वाभाविक बातचीत की शुरुआत करते हैं। सामाजिक तत्व से परे, पालतू जानवर कार्यात्मक भूमिकाएँ भी निभा सकते हैं जैसे कि मालिकों को घुसपैठियों के बारे में चेतावनी देने वाले गार्ड डॉग, खोज में सहायता करने वाले पुलिस K-9 यूनिट, अस्पताल रोलप्ले में भावनात्मक समर्थन जानवर, या शिकार के साथी जो शिकार का पता लगाने में मदद करते हैं। पालतू प्रणाली बनाने के लिए पेड स्पॉनिंग और डिस्पॉनिंग, AI फॉलो व्यवहार, एनीमेशन एकीकरण, भूख और खुशी जैसी आवश्यकताओं का सिमुलेशन, सत्रों के बीच स्थिरता, और स्वाभाविक इशारों और वॉयस कमांड के माध्यम से मालिक को उनके साथी को नियंत्रित करने वाले इंटरैक्शन कमांड को संभालना आवश्यक है।

उपलब्ध पशु मॉडल और विन्यास

GTA V में कई पशु पेड मॉडल शामिल हैं जो साथी के रूप में अच्छी तरह काम करते हैं। कुत्ते सबसे बहुमुखी हैं, जिनमें मॉडल जैसे a_c_shepherd German Shepherds के लिए, a_c_husky Huskies के लिए, a_c_poodle Poodles के लिए, a_c_rottweiler Rottweilers के लिए, a_c_retriever Retrievers के लिए, और a_c_chop प्रसिद्ध Chop मॉडल के लिए। बिल्ली उपयोग करती हैं a_c_cat_01. विदेशी विकल्पों के लिए, वहाँ खरगोश हैं जो a_c_rabbit_01 और यहां तक कि पक्षी भी a_c_crow. प्रत्येक पालतू प्रकार के लिए एक साझा फ़ाइल में अलग व्यवहार पैरामीटर कॉन्फ़िगर किए जाने चाहिए। कुत्ते करीब चलते हैं और मध्यम गति से वाहनों के साथ दौड़ सकते हैं। बिल्लियाँ अधिक स्वतंत्र होती हैं, कभी-कभी थोड़ी दूर भटकती हैं फिर वापस आती हैं। पक्षी खिलाड़ी के कंधे पर एंटिटी अटैचमेंट का उपयोग करके बैठ सकते हैं। प्रत्येक पालतू प्रकार की फॉलो दूरी, गति गुणक, निष्क्रिय एनीमेशन, इंटरैक्शन एनीमेशन, और विशेष क्षमताएं परिभाषित करें ताकि प्रत्येक प्रजाति के लिए विशिष्ट व्यक्तित्व बनाए जा सकें।

-- 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'},
    },
}

स्पॉनिंग और फॉलो व्यवहार

किसी भी पालतू प्रणाली का मूल फॉलो AI है जो जानवर को स्वाभाविक रूप से उसके मालिक के पीछे ट्रेल करता है। जब कोई खिलाड़ी अपना पालतू स्पॉन करता है, तो उनके स्थान पर पेड बनाएं उपयोग करके CreatePed उपयुक्त मॉडल के साथ। पेड को गैर-स्थायी के रूप में सेट करें SetEntityAsMissionEntity और इसे मालिक के अनुकूल बनाने के लिए रिलेशनशिप समूहों का उपयोग करके कॉन्फ़िगर करें। फॉलो व्यवहार एक क्लाइंट-साइड लूप का उपयोग करता है जो लगातार पालतू और मालिक के बीच की दूरी की गणना करता है। जब दूरी फॉलो थ्रेशोल्ड से अधिक हो जाती है, तो पालतू को मालिक के पीछे और किनारे की ओर थोड़ी दूरी पर एक स्थिति की ओर दौड़ने का कार्य दें, जिसका उपयोग TaskFollowToOffsetOfEntityयह नेटिव पाथफाइंडिंग को स्वचालित रूप से संभालता है, जिससे पालतू बाधाओं के चारों ओर नेविगेट करता है, फुटपाथ पर चलता है, और ट्रैफिक से बचता है। जब मालिक चलना बंद कर देता है और पालतू अपनी फॉलो दूरी तक पहुंच जाता है, तो बैठने या लेटने जैसी एक निष्क्रिय एनिमेशन चलाएं। यदि मालिक वाहन में बैठता है और चला जाता है, तो पालतू को वाहन में टेलीपोर्ट करें यदि वह उपयुक्त प्रकार का है, या पालतू को डीस्पॉन करें और जब मालिक वाहन से बाहर निकले तो उसे पुनः स्पॉन करें ताकि पालतू नक्शे पर खो न जाए।

-- 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

पालतू जानवरों की आवश्यकताएँ और बंधन प्रणाली

एक आवश्यकताएँ प्रणाली पालतू स्वामित्व को निरंतर जिम्मेदारी और गहराई देती है। भूख, खुशी, और स्वास्थ्य को 0 से 100 के बीच मानों के रूप में ट्रैक करें जो वास्तविक समय में घटते हैं। भूख हर 5 मिनट में 1 अंक घटती है जब पालतू सक्रिय होता है। खुशी धीरे-धीरे घटती है, हर 10 मिनट में 1 अंक, लेकिन जब मालिक पालतू को सहलाता है, खेलता है, या ट्रीट देता है तो काफी बढ़ती है। स्वास्थ्य 100 पर रहता है जब तक भूख 20 से नीचे नहीं गिरती, तब यह गिरना शुरू हो जाता है। जब भूख शून्य हो जाती है, तो पालतू सुस्त हो जाता है धीमी गति और उदास एनीमेशन के साथ। जब स्वास्थ्य बहुत कम हो जाता है, तो पालतू को ठीक होने के लिए पशु चिकित्सा देखभाल की आवश्यकता होती है। खिलाड़ी अपने पालतू को उनके इन्वेंटरी से खाद्य आइटम का उपयोग करके खिलाते हैं। विभिन्न खाद्य प्रकार भूख को अलग-अलग मात्रा में पुनर्स्थापित करते हैं: बेसिक पालतू भोजन 30 अंक पुनर्स्थापित करता है, प्रीमियम भोजन 60, और ट्रीट्स 10 पुनर्स्थापित करते हैं लेकिन खुशी को 15 बढ़ाते हैं। बंधन स्तर मालिक और पालतू के बीच संचयी संबंध को ट्रैक करता है, सकारात्मक इंटरैक्शन के माध्यम से बढ़ता है और उपेक्षा के कारण घटता है। उच्च बंधन स्तर विशेष इंटरैक्शन अनलॉक करता है और पालतू की आदेशों के प्रति प्रतिक्रिया को बेहतर बनाता है।

-- 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)

इंटरैक्शन कमांड और एनिमेशन

खिलाड़ियों को उनके पालतू के साथ इंटरैक्ट करने के लिए कमांड्स का समृद्ध सेट दें। एक रेडियल मेनू या कमांड सिस्टम में विकल्प होने चाहिए जैसे बैठना, रुकना, पीछा करना, आना, लेटना, हाथ मिलाना, लाना, और बोलना। प्रत्येक कमांड GTA V में निर्मित क्रिएचर एनिमेशन डिक्शनरीज़ का उपयोग करके पालतू पेड पर संबंधित एनिमेशन ट्रिगर करता है। बैठने का कमांड उपयोग करता है creatures@dog@amb@ sit_enter और sit_loop क्लिप्स के साथ। लेटना समान परिवेश एनिमेशन का उपयोग करता है। फेच के लिए, एक छोटा गेंद प्रॉप स्पॉन करें, इसे एक परवलयाकार मार्ग का उपयोग करके फेंकें, और पालतू को गेंद के लैंडिंग स्थान पर दौड़ने, एक संलग्नक का उपयोग करके इसे उठाने और मालिक को वापस लाने का कार्य दें। speak कमांड एक भौंकने वाली ऑडियो को ट्रिगर करता है PlayPedAmbientSpeechNative। पालतू को सहलाने के लिए, खिलाड़ी के ped पर घुटने टेकने वाली एनिमेशन चलाएं और साथ ही पालतू पर खुश पूंछ हिलाने वाली एनिमेशन चलाएं। ये इंटरैक्शन केवल सजावटी नहीं हैं; प्रत्येक एक खुशी और बंधन के आँकड़े बढ़ाता है, उन खिलाड़ियों को इनाम देता है जो अपने साथी के साथ सक्रिय रूप से जुड़ते हैं बजाय इसे एक निष्क्रिय अनुयायी के रूप में देखने के।

पर्सिस्टेंस और पेट शॉप एकीकरण

पालतू जानवरों को सर्वर सत्रों के बीच स्थायी होना चाहिए ताकि खिलाड़ी हर पुनःआरंभ पर अपने साथियों को न खोएं। डेटाबेस में पालतू डेटा स्टोर करें जिसमें मालिक की पहचान, पालतू प्रकार, कस्टम नाम, वर्तमान आवश्यकताओं के मान, बंधन स्तर, और कोई भी अनलॉक किए गए ट्रिक्स या क्षमताएँ शामिल हों। जब मालिक लॉग इन करता है, तो उनके पालतू डेटा को क्वेरी करें और कमांड के माध्यम से इसे स्पॉन करने का विकल्प दें या स्वचालित रूप से यदि वे पिछली बार डिस्कनेक्ट होने पर इसे सक्रिय रखते थे। एक तार्किक मानचित्र स्थान पर स्थित इन-गेम पालतू दुकान के माध्यम से पालतू अधिग्रहण को एकीकृत करें। पालतू दुकान NUI उपलब्ध पालतू प्रकारों को उनके मॉडल के पूर्वावलोकन क्षेत्र में प्रस्तुत करती है, कीमतें और विवरण। खरीद के बाद, खिलाड़ी अपने नए पालतू का नाम रखता है और यह उनके बगल में स्पॉन होता है। एक वैकल्पिक पालतू गोद लेने केंद्र जोड़ने पर विचार करें जिसमें कम कीमतें हों लेकिन यादृच्छिक पालतू प्रकार हों, जो एक चैरिटेबल रोलप्ले कोण जोड़ता है। सर्वर अर्थव्यवस्थाओं के लिए, पालतू जानवरों को स्वास्थ्य पुनर्स्थापन के लिए पशु चिकित्सक यात्राओं, उपस्थिति बोनस के लिए ग्रूमिंग, और नए कमांड एनीमेशन अनलॉक करने वाले प्रशिक्षण सत्रों जैसी आवधिक खर्चों की आवश्यकता हो सकती है, जो आपके व्यापक आर्थिक प्रणाली के साथ एक यथार्थवादी पालतू स्वामित्व लागत बनाता है।

-- 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

पुलिस K-9 इंटीग्रेशन और विशेष भूमिकाएं

कानून प्रवर्तन रोलप्ले के लिए, पालतू प्रणाली को एक पूर्ण K-9 यूनिट एकीकरण में विस्तारित करें। पुलिस कुत्तों को विशेष क्षमताएं मिलती हैं जो नागरिक पालतू जानवरों के लिए उपलब्ध नहीं हैं। खोज कमांड K-9 को पास के वाहनों या इमारतों की सूंघने और कॉन्फ़िगर किए गए प्रतिबंधित वस्तुओं पर भौंकने और स्रोत के पास बैठने के लिए बनाता है। इसे लागू करने के लिए, खोज कमांड जारी होने पर पास के खिलाड़ियों या वाहन ट्रंक के इन्वेंटरी में फ्लैग की गई वस्तुओं की जांच करें। ट्रैक कमांड K-9 को गंध के निशान का पालन करने के लिए बनाता है, जिसे आप भाग रहे संदिग्ध के स्थानों की ब्रेडक्रम्ब ट्रेल बनाकर और कुत्ते को उनका पालन करने का कार्य देकर लागू कर सकते हैं। अपह्रण कमांड K-9 को लक्ष्य की ओर दौड़ने और हमला एनिमेशन चलाने के लिए बनाता है, जिससे अधिकारियों को संदिग्धों को गैर-घातक तरीके से पकड़ने का विकल्प मिलता है। इन क्षमताओं को केवल पुलिस नौकरी और K-9 हैंडलर प्रमाणपत्र वाले खिलाड़ियों तक सीमित करें। K-9 को पुलिस वेस्ट पहननी चाहिए, जो पेड कंपोनेंट वेरिएशंस या प्रॉप अटैचमेंट्स का उपयोग करके नागरिक पालतू जानवरों से दृश्य रूप से अलग हो। यह विशेषज्ञता पुलिस विभाग की पदानुक्रम में एक अनूठा और अत्यधिक मांग वाला पद बनाती है।