Files
fs25-adsmartpickup/FS25_ADSmartPickup/adFieldFertilizer.lua
T

202 lines
11 KiB
Lua
Raw Blame History

This file contains ambiguous Unicode characters
This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.
-- AD Field Fertilizer
-- "Gylle som gødning" (indstillingen slurryFertilizer, brugerønske 17/10): gårdens egen gylle, digestat og møg bruges
-- på markerne før købt gødning. To ting: (1) flåden foretrækker en spreder/gyllevogn med gårdens egne varer, når
-- gården har varen på lager; (2) udkørslen (salg af gylle) holder sæsonens behov tilbage: markernes areal × liter
-- pr. ha × antal gødninger pr. sæson (spillets fertMax). Påfyldningen vælger i forvejen gårdens egne tanke først
-- (ADFieldWork.findRefillMarker). Ren logik øverst (testes med luajit), spil-adapter nederst.
ADFieldFertilizer = {}
ADFieldFertilizer.LOG_PREFIX = "ADSmartPickup: gødning: "
-- gårdens egne gødningsvarer (sprederens/gyllevognens fyld)
ADFieldFertilizer.OWN_FILL_TYPES = {LIQUIDMANURE = true, DIGESTATE = true, MANURE = true}
-- gødninger pr. sæson når spillet ikke oplyser fertMax
ADFieldFertilizer.DEFAULT_PASSES = 2
-- lager tælles højst så tit (ms)
ADFieldFertilizer.STOCK_CACHE_MS = 10000
-- reserven er aldrig mere end denne andel af gårdens lagerkapacitet for varen: en fuld tank skal kunne tømmes
-- (ellers stopper stalden, når gyllen ikke kan komme af vejen) — review 17/10
ADFieldFertilizer.RESERVE_CAPACITY_SHARE = 0.8
-- ---- ren logik ----
-- Spillets forbrug (Sprayer:getSprayerUsage): liter/ms = scale × litersPerSecond × speedLimit (km/t) × arbejdsbredde
-- (m) × 0,001; areal/s = bredde × speedLimit/3,6 m². Liter pr. ha = 36 000 × scale × litersPerSecond — uafhængigt af
-- bredde og fart.
function ADFieldFertilizer.litersPerHa(litersPerSecond, scale)
if litersPerSecond == nil or litersPerSecond <= 0 then return 0 end
return 36000 * (scale or 1) * litersPerSecond
end
-- Behovet nu: fields = {{areaHa, fertilize (markplanens pleje, nil = til), passes (gødninger der mangler =
-- fertMax - fert), growing (afgrøde i vækst; nil = tæller)}} -> liter, ha. Færdiggødede marker (passes 0) tæller ikke,
-- og heller ikke marker uden afgrøde i vækst (høstet, pløjet, klar til høst): de gødes først om lang tid, og imens
-- skal gyllen sælges, så stalden ikke stopper (brugerønske 19/10 12:32).
function ADFieldFertilizer.seasonDemand(fields, litersPerHa)
local liters, hectares = 0, 0
if litersPerHa == nil or litersPerHa <= 0 then return 0, 0 end
for _, field in ipairs(fields or {}) do
local area = field.areaHa or 0
local passes = field.passes or ADFieldFertilizer.DEFAULT_PASSES
if field.fertilize ~= false and field.growing ~= false and area > 0 and passes > 0 then
hectares = hectares + area
liters = liters + area * litersPerHa * passes
end
end
return liters, hectares
end
-- Reserven, der holdes tilbage fra salg: behovet, men højst RESERVE_CAPACITY_SHARE af lagerkapaciteten. Ukendt
-- kapacitet (0) -> ingen reserve: en uloftet reserve kunne spærre al salg (review 17/10).
function ADFieldFertilizer.cappedReserve(demandLiters, capacityLiters)
if (capacityLiters or 0) <= 0 then return 0 end
return math.min(demandLiters or 0, capacityLiters * ADFieldFertilizer.RESERVE_CAPACITY_SHARE)
end
-- Spreder/gyllevogn med gårdens egen vare? candidate.sprayNames = varer sprederen kan tage (sæt {navn = true} eller liste)
function ADFieldFertilizer.usesOwnGoods(candidate)
local names = candidate ~= nil and candidate.sprayNames or nil
if names == nil then return false end
for key, value in pairs(names) do
local name = type(key) == "number" and value or key
if value and ADFieldFertilizer.OWN_FILL_TYPES[name] then return true end
end
return false
end
-- Skal egen gylle foretrækkes til marken? s = {enabled, ownStockLiters, fieldNeedLiters, minSharePercent,
-- minStockLiters}: indstillingen til, og lageret dækker mindst minSharePercent af markens behov (brugerønske 17/10:
-- "mindst 80 %, resten købes" — påfyldningen går selv til købestationen, når de egne tanke er tomme). Mindst
-- minStockLiters (påfyldningens egen grænse), så sprederen ikke kører tomt efter gylle.
function ADFieldFertilizer.shouldPrefer(s)
if s == nil or s.enabled ~= true then return false end
local stock = s.ownStockLiters or 0
if stock < (s.minStockLiters or 0) then return false end
local need = (s.fieldNeedLiters or 0) * ((s.minSharePercent or 0) / 100)
return stock >= need
end
-- ---- spil-adapter ----
function ADFieldFertilizer.isEnabled()
return ADSettings ~= nil and ADSettings.get ~= nil and ADSettings.get("slurryFertilizer") == 1
end
function ADFieldFertilizer.minSharePercent()
local value = ADSettings ~= nil and ADSettings.get ~= nil and tonumber(ADSettings.get("slurryMinShare")) or nil
return value or 80
end
local stockCache = {} -- "farmId:fillTypeName" -> {at, liters, capacity}
-- Gårdens egen beholdning og lagerkapacitet for varen (stalde, tanke, BGA; uden købestationer): liter, liter
function ADFieldFertilizer.ownStock(name, farmId)
local key = tostring(farmId) .. ":" .. tostring(name)
local nowMs = ADUtil.now()
local cached = stockCache[key]
if cached ~= nil and nowMs - cached.at < ADFieldFertilizer.STOCK_CACHE_MS then return cached.liters, cached.capacity end
local liters, capacity, seen = 0, 0, {}
pcall(function()
local fillType = g_fillTypeManager:getFillTypeIndexByName(name)
if fillType == nil then return end
for _, station in pairs(g_currentMission.storageSystem:getLoadingStations()) do
local isShop = station.owningPlaceable ~= nil and station.owningPlaceable.spec_buyingStation ~= nil
if not isShop and g_currentMission.accessHandler:canFarmAccess(farmId, station) then
for _, storage in pairs(station.sourceStorages or {}) do
-- delte lagre (tank som udvidelse af stalden) tælles én gang
if not seen[storage] then
seen[storage] = true
local okL, level = pcall(storage.getFillLevel, storage, fillType)
local okC, cap = pcall(storage.getCapacity, storage, fillType)
if okL and (level or 0) > 0 then liters = liters + level end
if okC and (cap or 0) > 0 and (okL and (level or 0) > 0 or (storage.capacities ~= nil and storage.capacities[fillType] ~= nil)) then
capacity = capacity + cap
end
end
end
end
end
end)
stockCache[key] = {at = nowMs, liters = liters, capacity = capacity}
return liters, capacity
end
-- Gårdens egne gødningsvarer på lager i alt (alle OWN_FILL_TYPES)
function ADFieldFertilizer.ownStockLiters(farmId)
local total = 0
for name in pairs(ADFieldFertilizer.OWN_FILL_TYPES) do
total = total + (ADFieldFertilizer.ownStock(name, farmId))
end
return total
end
-- Markens behov for én gødning med varen (liter)
local function fieldNeedLiters(name, areaHa)
local fillType = g_fillTypeManager ~= nil and g_fillTypeManager:getFillTypeIndexByName(name) or nil
if fillType == nil then return 0 end
return (areaHa or 0) * ADFieldFertilizer.litersPerHaFor(fillType)
end
-- Flådens fortrinsregel for en gødningsopgave på en mark (areaHa): candidate -> bool, eller nil når reglen ikke
-- gælder. En gyllevogn/spreder foretrækkes, når gården har mindst minSharePercent af markens behov for DENS vare.
function ADFieldFertilizer.preferCandidate(farmId, areaHa)
if not ADFieldFertilizer.isEnabled() then return nil end
farmId = farmId or (g_currentMission ~= nil and g_currentMission.getFarmId ~= nil and g_currentMission:getFarmId()) or 1
local minStock = ADFieldWork ~= nil and ADFieldWork.MIN_REFILL_STOCK_L or 500
local share = ADFieldFertilizer.minSharePercent()
return function(candidate)
if not ADFieldFertilizer.usesOwnGoods(candidate) then return false end
for key, value in pairs(candidate.sprayNames or {}) do
local name = type(key) == "number" and value or key
if value and ADFieldFertilizer.OWN_FILL_TYPES[name] then
local stock = ADFieldFertilizer.ownStock(name, farmId)
if ADFieldFertilizer.shouldPrefer({enabled = true, ownStockLiters = stock, minStockLiters = minStock,
fieldNeedLiters = fieldNeedLiters(name, areaHa), minSharePercent = share}) then
return true
end
end
end
return false
end
end
-- Liter pr. ha for varen efter spillets sprøjtetype (scale 1: vognens egen skala kendes ikke her)
function ADFieldFertilizer.litersPerHaFor(fillType)
local manager = g_sprayTypeManager
if manager == nil or manager.getSprayTypeByFillTypeIndex == nil then return 0 end
local ok, sprayType = pcall(manager.getSprayTypeByFillTypeIndex, manager, fillType)
return ok and sprayType ~= nil and ADFieldFertilizer.litersPerHa(sprayType.litersPerSecond, 1) or 0
end
-- Markerne til sæsonbehovet: gårdens egne dyrkbare marker (ikke kontrakter) med gødning i plejen; passes = de
-- gødninger, marken mangler endnu (fertMax - fert)
local function fieldsForDemand()
local fields = {}
if ADFields == nil or ADFields.list == nil then return fields end
for _, info in ipairs(ADFields.list() or {}) do
local ok, entry = pcall(function()
if ADContracts ~= nil and ADContracts.isContractField ~= nil and ADContracts.isContractField(info.id) then return nil end
local plan = ADFieldJobs ~= nil and ADFieldJobs.getField ~= nil and ADFieldJobs.getField(info.id).plan or {}
local passes = info.fertMax ~= nil and math.max(0, info.fertMax - (info.fert or 0)) or nil
return {areaHa = ADFields.polygonAreaHa(info.verts), fertilize = plan.fertilize ~= false, passes = passes,
growing = info.growing == true}
end)
if ok and entry ~= nil then table.insert(fields, entry) end
end
return fields
end
-- Udkørslens reserve for varen: liter, ha (0 når reglen ikke gælder eller varen ikke er gårdens egen gødning).
-- Behovet, men højst RESERVE_CAPACITY_SHARE af gårdens lagerkapacitet for varen.
function ADFieldFertilizer.demandLiters(fillType, farmId)
if not ADFieldFertilizer.isEnabled() then return 0, 0 end
local name = g_fillTypeManager ~= nil and g_fillTypeManager:getFillTypeNameByIndex(fillType) or nil
if name == nil or not ADFieldFertilizer.OWN_FILL_TYPES[name] then return 0, 0 end
local liters, hectares = ADFieldFertilizer.seasonDemand(fieldsForDemand(), ADFieldFertilizer.litersPerHaFor(fillType))
local _, capacity = ADFieldFertilizer.ownStock(name, farmId)
if liters > 0 and capacity <= 0 and not ADFieldFertilizer.capacityWarned then
ADFieldFertilizer.capacityWarned = true
Logging.warning(ADFieldFertilizer.LOG_PREFIX .. "gårdens lagerkapacitet for %s kunne ikke læses — ingen reserve til markerne", tostring(name))
end
return ADFieldFertilizer.cappedReserve(liters, capacity), hectares
end