202 lines
11 KiB
Lua
202 lines
11 KiB
Lua
-- 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
|