System farmingu FiveM: Uprawy, zwierzęta i łańcuchy sprzedaży

Filozofia projektowania systemu farmingu

System rolnictwa wprowadza zupełnie inne tempo na serwerach roleplay FiveM, oferując graczom relaksującą alternatywę dla pełnych adrenaliny działań przestępczych i pracy w policji. Najlepsze systemy rolnicze tworzą samowystarczalną pętlę ekonomiczną, w której gracze kupują nasiona, sadzą uprawy na wyznaczonych polach, dbają o nie w cyklach wzrostu w czasie rzeczywistym, zbierają plony i sprzedają je na rynku z zyskiem. Wyzwanie projektowe polega na stworzeniu systemu na tyle angażującego, by gracze regularnie wracali, ale nie tak czasochłonnego, by stał się uciążliwym obowiązkiem. Zastosuj cykle wzrostu w czasie rzeczywistym, które trwają nawet wtedy, gdy gracz jest offline, dzięki czemu rolnicy po zalogowaniu widzą swoje uprawy na różnych etapach wzrostu. Główny model danych musi śledzić każdą pojedynczą grządkę z jej pozycją, rodzajem uprawy, aktualnym etapem wzrostu, znacznikiem czasu posadzenia, poziomem nawodnienia i wskaźnikiem jakości. Zapisuj wszystko po stronie serwera w bazie danych, aby stan gospodarstwa zachowywał się po restartach serwera i był chroniony przed manipulacjami po stronie klienta.

Sadzenie roślin i schemat bazy danych

System sadzenia zaczyna się od wybrania nasion z ekwipunku przez gracza i umieszczenia ich w wyznaczonych strefach uprawnych. Zdefiniuj pola uprawne jako konfigurowalne strefy wielokątne na mapie, w których sadzenie jest dozwolone, co uniemożliwi graczom uprawę na chodnikach lub wewnątrz budynków. Każda działka rolna powinna mieć ograniczoną liczbę miejsc w zależności od powierzchni gruntu, a gracze mogą wynajmować lub kupować ziemię uprawną za pośrednictwem NPC lub systemu nieruchomości. Gdy gracz zasadzi nasiono, utwórz wpis w bazie danych, który będzie śledzić roślinę przez cały jej cykl życia. Oto praktyczny schemat bazy danych i serwerowy handler sadzenia:

CREATE TABLE IF NOT EXISTS farm_crops (
    id INT AUTO_INCREMENT PRIMARY KEY,
    owner VARCHAR(50) NOT NULL,
    farm_id VARCHAR(50) NOT NULL,
    crop_type VARCHAR(50) NOT NULL,
    position_x FLOAT NOT NULL,
    position_y FLOAT NOT NULL,
    position_z FLOAT NOT NULL,
    planted_at BIGINT NOT NULL,
    growth_stage INT DEFAULT 0,
    water_level FLOAT DEFAULT 100.0,
    quality FLOAT DEFAULT 1.0,
    is_harvestable TINYINT DEFAULT 0,
    is_dead TINYINT DEFAULT 0,
    last_watered BIGINT DEFAULT 0,
    INDEX idx_owner (owner),
    INDEX idx_farm (farm_id)
);

CREATE TABLE IF NOT EXISTS farm_plots (
    id INT AUTO_INCREMENT PRIMARY KEY,
    farm_id VARCHAR(50) NOT NULL UNIQUE,
    owner VARCHAR(50) DEFAULT NULL,
    max_slots INT DEFAULT 20,
    rent_price INT DEFAULT 500,
    coords_center_x FLOAT NOT NULL,
    coords_center_y FLOAT NOT NULL,
    coords_center_z FLOAT NOT NULL,
    radius FLOAT DEFAULT 30.0
);

RegisterNetEvent('farming:server:plantCrop', function(cropType, position)
    local src = source
    local Player = QBCore.Functions.GetPlayer(src)
    if not Player then return end

    local citizenid = Player.PlayerData.citizenid
    local seedItem = 'seed_' .. cropType

    if not Player.Functions.GetItemByName(seedItem) then
        return TriggerClientEvent('QBCore:Notify', src, 'You need seeds to plant', 'error')
    end

    local farmId = GetFarmAtPosition(position)
    if not farmId then
        return TriggerClientEvent('QBCore:Notify', src, 'You can only plant on farmland', 'error')
    end

    local currentCrops = MySQL.scalar.await(
        'SELECT COUNT(*) FROM farm_crops WHERE farm_id = ? AND is_dead = 0',
        {farmId}
    )
    local maxSlots = MySQL.scalar.await(
        'SELECT max_slots FROM farm_plots WHERE farm_id = ?', {farmId}
    )

    if currentCrops >= maxSlots then
        return TriggerClientEvent('QBCore:Notify', src, 'Farm is full', 'error')
    end

    Player.Functions.RemoveItem(seedItem, 1)

    MySQL.insert(
        'INSERT INTO farm_crops (owner, farm_id, crop_type, position_x, position_y, position_z, planted_at, last_watered) VALUES (?, ?, ?, ?, ?, ?, ?, ?)',
        {citizenid, farmId, cropType, position.x, position.y, position.z, os.time(), os.time()}
    )

    TriggerClientEvent('QBCore:Notify', src, 'Planted ' .. cropType, 'success')
    TriggerClientEvent('farming:client:spawnCropProp', -1, position, cropType, 0)
end)

Każdy rodzaj uprawy powinien mieć różne parametry wzrostu zdefiniowane w tabeli konfiguracyjnej. Pszenica może rosnąć w 30 minut czasu rzeczywistego w 4 fazach, podczas gdy konopie lub winogrona mogą wymagać kilku godzin i 6 faz, nagradzając cierpliwych rolników plonami o wyższej wartości. Faza wzrostu określa, który model propa jest wyświetlany w świecie gry, przechodząc z małego kiełka w dojrzałą roślinę wraz z upływem czasu.

Silnik cyklu wzrostu i podlewanie

Silnik cyklu wzrostu to pętla server-side, która okresowo sprawdza wszystkie posadzone uprawy i rozwija ich fazy wzrostu na podstawie upływu czasu oraz warunków, takich jak poziom wody. Uruchamiaj to jako cykliczny wątek serwera, który wykonuje się co kilka minut, obliczając, czy dana uprawa powinna przejść do następnej fazy w oparciu o czas trwania wzrostu dla danego typu uprawy oraz czas od posadzenia. Poziom wody to główna mechanika angażująca graczy: uprawy zużywają wodę z czasem, a jeśli poziom wody spadnie do zera, wzrost zostaje wstrzymany, a jakość uprawy spada. Gracze muszą wracać na swoją farmę i używać konewki lub systemu nawadniania, aby uzupełnić poziom wody. Oto silnik wzrostu server-side:

local CropConfig = {
    wheat = {
        stages = 4,
        growthTime = 1800,    -- 30 min total, ~7.5 min per stage
        waterConsumption = 5, -- per cycle
        baseYield = 5,
        sellPrice = 50
    },
    corn = {
        stages = 5,
        growthTime = 3600,
        waterConsumption = 7,
        baseYield = 4,
        sellPrice = 80
    },
    tomato = {
        stages = 4,
        growthTime = 2400,
        waterConsumption = 8,
        baseYield = 6,
        sellPrice = 65
    },
    grape = {
        stages = 6,
        growthTime = 7200,
        waterConsumption = 4,
        baseYield = 8,
        sellPrice = 120
    }
}

CreateThread(function()
    while true do
        Wait(60000 * 5) -- Run every 5 minutes

        local crops = MySQL.query.await(
            'SELECT * FROM farm_crops WHERE is_dead = 0 AND is_harvestable = 0'
        )

        for _, crop in ipairs(crops or {}) do
            local config = CropConfig[crop.crop_type]
            if not config then goto continue end

            local elapsed = os.time() - crop.planted_at
            local stageTime = config.growthTime / config.stages
            local expectedStage = math.min(math.floor(elapsed / stageTime), config.stages)

            -- Degrade water
            local newWater = math.max(0, crop.water_level - config.waterConsumption)
            local newQuality = crop.quality

            -- Quality degrades without water
            if newWater <= 0 then
                newQuality = math.max(0.3, crop.quality - 0.05)
                expectedStage = crop.growth_stage -- Pause growth
            end

            local isHarvestable = expectedStage >= config.stages and newWater > 0

            if expectedStage ~= crop.growth_stage or newWater ~= crop.water_level then
                MySQL.update(
                    'UPDATE farm_crops SET growth_stage = ?, water_level = ?, quality = ?, is_harvestable = ? WHERE id = ?',
                    {expectedStage, newWater, newQuality, isHarvestable and 1 or 0, crop.id}
                )

                if expectedStage ~= crop.growth_stage then
                    TriggerClientEvent('farming:client:updateCropStage', -1,
                        crop.id, expectedStage, crop.crop_type,
                        vector3(crop.position_x, crop.position_y, crop.position_z))
                end
            end

            :continue:
        end
    end
end)

Mechanika podlewania powinna być interaktywna, a nie uciążliwa. Daj graczowi konewkę, która uruchamia animację przy uprawach, oraz podlewaj kilka pobliskich roślin w jednej akcji zamiast wymagać podlewania pojedynczo. W przypadku większych farm wprowadź ulepszenie w postaci systemu nawadniania, który automatycznie podlewa wszystkie uprawy na działce w regularnych odstępach czasu, co ogranicza pracę ręczną, ale wymaga początkowej inwestycji w materiały. Wyświetlaj poziom nawodnienia i postęp wzrostu każdej rośliny za pomocą małego wskaźnika nad obiektem, gdy gracz na niego patrzy, używając tekstu 3D lub nakładki systemu target.

Zbiory i jakość plonów

Zbiory to kluczowy moment, który sprawia, że cały cykl rolnictwa daje satysfakcję. Gdy uprawa osiągnie ostateczną fazę wzrostu i została odpowiednio nawodniona, staje się gotowa do zbioru. Gracz wchodzi w interakcję z rośliną, odtwarza animację zbierania i otrzymuje plony do ekwipunku. Ilość i jakość plonów zależą od tego, jak dobrze gracz dbał o uprawę w trakcie jej cyklu wzrostu: regularne podlewanie daje przedmioty wyższej jakości, które można sprzedać drożej, podczas gdy zaniedbane uprawy przynoszą mniej plonów o niższej jakości. Wdróż mnożnik jakości, który wpływa zarówno na liczbę zebranych plonów, jak i cenę sprzedaży, tworząc silną motywację do uważnej uprawy. Po zbiorze usuń uprawę z bazy danych i skasuj prop ze świata gry, zwalniając miejsce na grządce do ponownego posadzenia. Rozważ dodanie mechaniki kompostowania, w której zbiory niskiej jakości można przekształcić w nawóz podnoszący jakość przyszłych upraw, tworząc obieg bezodpadowy nagradzający stałą aktywność rolniczą.

System hodowli zwierząt

Zwierzęta dodają drugi wymiar do rozgrywki na farmie i tworzą dodatkowe źródła przychodów. Wprowadź możliwe do kupienia zwierzęta, takie jak kury, krowy i owce, umieszczane w wyznaczonych zagrodach na terenie farmy. Każdy gatunek zwierzęcia ma własny cykl produkcyjny: kury znoszą jajka co kilka godzin, krowy dają mleko codziennie, a owce można okresowo strzyc na wełnę. Zwierzęta wymagają karmienia plonami z ekwipunku gracza, co bezpośrednio łączy system upraw z systemem zwierząt i tworzy zamknięty obieg gospodarczy. Oto konfiguracja oraz system karmienia zwierząt gospodarskich:

Config.Animals = {
    chicken = {
        model = 'a_c_hen',
        purchasePrice = 500,
        feedItem = 'wheat',
        feedInterval = 3600,       -- needs feeding every hour
        productionItem = 'eggs',
        productionAmount = 3,
        productionInterval = 7200, -- produces every 2 hours
        maxPerFarm = 10
    },
    cow = {
        model = 'a_c_cow',
        purchasePrice = 3000,
        feedItem = 'corn',
        feedInterval = 5400,
        productionItem = 'milk',
        productionAmount = 2,
        productionInterval = 14400,
        maxPerFarm = 5
    },
    sheep = {
        model = 'a_c_sheep',
        purchasePrice = 1500,
        feedItem = 'wheat',
        feedInterval = 4800,
        productionItem = 'wool',
        productionAmount = 1,
        productionInterval = 21600,
        maxPerFarm = 8
    }
}

RegisterNetEvent('farming:server:feedAnimal', function(animalId)
    local src = source
    local Player = QBCore.Functions.GetPlayer(src)
    if not Player then return end

    local animal = MySQL.query.await(
        'SELECT * FROM farm_animals WHERE id = ? AND owner = ?',
        {animalId, Player.PlayerData.citizenid}
    )

    if not animal or not animal[1] then return end
    animal = animal[1]

    local config = Config.Animals[animal.animal_type]
    if not Player.Functions.GetItemByName(config.feedItem) then
        return TriggerClientEvent('QBCore:Notify', src, 'Need ' .. config.feedItem .. ' to feed', 'error')
    end

    Player.Functions.RemoveItem(config.feedItem, 1)

    MySQL.update(
        'UPDATE farm_animals SET last_fed = ?, hunger = 100 WHERE id = ?',
        {os.time(), animalId}
    )

    TriggerClientEvent('QBCore:Notify', src, 'Animal fed successfully', 'success')
end)

Zwierzęta, które nie są karmione na czas, stają się nieszczęśliwe, co zmniejsza ich wydajność produkcyjną. Pozostawione bez jedzenia zbyt długo, całkowicie przestają produkować. Wyświetlaj status zwierzęcia za pomocą interakcji target, która pokazuje poziom głodu, zadowolenie i czas do kolejnej produkcji. Tworzy to dla rolników codzienną rutynę doglądania, która utrzymuje ich zaangażowanie na serwerze między cyklami wzrostu upraw.

System rynku i sprzedaż produktów

System rynku łączy rolników z szerszą gospodarką serwera. Utwórz lokalizacje handlarzy NPC na targowiskach, w sklepach spożywczych i restauracjach na całej mapie, gdzie gracze mogą sprzedawać swoje plony. Wdróż dynamiczny system cen, w którym ceny wahają się w zależności od podaży i popytu: jeśli wielu rolników uprawia pszenicę, jej ceny spadają, co zachęca do różnicowania upraw. Śledź całkowity wolumen sprzedaży dla każdego rodzaju upraw w ruchomych oknach czasowych i odpowiednio dostosowuj ceny. Produkty premium z upraw wysokiej jakości sprzedają się z mnożnikiem powyżej ceny bazowej, nagradzając staranne rolnictwo. Rozważ dodanie opcji handlu między graczami, gdzie rolnicy mogą rozstawiać stragany w wyznaczonych miejscach, sprzedając bezpośrednio innym graczom po własnych cenach. Tworzy to naturalne interakcje roleplay między rolnikami a kupcami i pozwala przedsiębiorczym graczom zarabiać na kupowaniu tanich produktów hurtowo i sprzedawaniu ich z marżą detaliczną w ruchliwych miejscach.

Wpływ pogody na rolnictwo

Integracja pogody wprowadza do rolnictwa nieprzewidywalność i strategię. Podepnij się pod system pogodowy swojego serwera, aby nakładać modyfikatory na wzrost upraw i zużycie wody. Deszcz naturalnie nawadnia wszystkie uprawy na zewnątrz, zmniejszając potrzebę ręcznego podlewania w okresach deszczowych. Ekstremalny upał zwiększa zużycie wody, zmuszając rolników do częstszego podlewania w czasie gorącej pogody. Burze mogą uszkodzić plony, obniżając ich jakość lub wręcz niszcząc zbyt długo niezebrane zbiory. Mrozy w sezonie zimowym mogą całkowicie zniszczyć niektóre rodzaje upraw, zmuszając rolników do wyboru odmian odpornych na chłód lub inwestowania w szklarnie chroniące uprawy przed wpływem pogody. Wdróż system prognozy pogody dostępny w aplikacji na telefonie w grze lub w transmisji telewizyjnej, aby rolnicy mogli planować harmonogram sadzenia w oparciu o nadchodzące warunki: dodaje to warstwę planowania strategicznego i wynosi rozgrywkę rolniczą ponad prostą mechanikę kliknij i czekaj.

Ulepszenia farmy i progresja

System progresji daje farmerom długoterminowe cele i nagradza regularną grę. Zacznij od zaoferowania graczom małego pola mieszczącego kilka upraw, a następnie pozwól im odblokowywać rozbudowę za punkty farming XP lub bezpośredni zakup. Każdy poziom ulepszenia odblokowuje nowe możliwości: automatyczne systemy zraszaczy dbające o podlewanie, większe zagrody na więcej zwierząt, stodołę do magazynowania nadwyżek plonów, stacje przetwórcze zamieniające surowce w towary o wyższej wartości, np. pszenicę w mąkę lub winogrona w wino, oraz traktor przyspieszający sadzenie i zbieranie plonów na dużych polach. Śledź farming XP niezależnie od pozostałej progresji na serwerze, aby stworzyć dedykowaną umiejętność rolnictwa poprawiającą jakość plonów i skracającą czas wzrostu na wyższych poziomach. System przetwarzania jest szczególnie istotny dla ekonomii, ponieważ dodaje etapy zwiększające wartość między surowcami a produktami końcowymi, stwarzając okazje do roleplayu łańcucha dostaw, w którym farmerzy sprzedają surowce prowadzonym przez graczy piekarniom, winiarniom lub restauracjom przetwarzającym je na produkty gotowe dla konsumentów.