Files
fs25-adsmartpickup/FS25_ADSmartPickup/adAutoCrop.lua
T

436 lines
23 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.
-- "Alt automatisk" (brugerønske 17/10): én knap i Marker-fanen slår alle marker til og frigiver dem til kæderne.
-- Gårdens forbrug (stalde, fabrikker) beregnes forfra og dækkes med de marker der passer bedst i størrelse; resten
-- fordeles jævnt (ha) på de TOP_COUNT mest indbringende afgrøder (spredt høst): udbytte (l/ha) × bedste salgspris, blandt afgrøder
-- gårdens maskiner kan både så og høste, og som kan sås i løbet af året. Kontrakter, slåmarker/eng og spillerens
-- egne mål og eng røres ikke; græsmarker er med (behov tager marker der allerede har afgrøden først); tidligere mål
-- fra moden/kæden beregnes forfra. Kæderne må skifte målene senere.
-- info-log bag "Detaljeret log" (ADLog i adSettings.lua; uden ADLog — tests — direkte til Logging)
local function logInfo(...) return (ADLog or Logging).info(...) end
ADAutoCrop = {}
-- hele året frem (brugerønske 17/10): klargøringen kører straks, såningen venter på afgrødens såtid — i november
-- (periode 9) kan intet sås før marts (2 perioder frem gav 0 afgrøder)
ADAutoCrop.LOOKAHEAD_PERIODS = 11
ADAutoCrop.SOURCE = "auto"
ADAutoCrop.TOP_COUNT = 3
-- De n bedste afgrøder (kan sås, høstes, har såtid og en pris), bedste først. -> {navn, ...}
function ADAutoCrop.pickTop(candidates, n)
local valid = {}
for _, candidate in ipairs(candidates or {}) do
local value = tonumber(candidate.value) or 0
if candidate.canSow and candidate.canHarvest and candidate.plantableSoon and value > 0 then
table.insert(valid, {name = candidate.name, value = value})
end
end
table.sort(valid, function(a, b)
if a.value ~= b.value then return a.value > b.value end
return tostring(a.name) < tostring(b.name)
end)
local names = {}
for index = 1, math.min(n or 1, #valid) do table.insert(names, valid[index].name) end
return names
end
-- Kan afgrøden sås i perioden eller de næste LOOKAHEAD_PERIODS (periode 1-12, går rundt)?
function ADAutoCrop.plantableSoon(isPlantableIn, period)
if period == nil or period < 1 then return isPlantableIn(period) end
for offset = 0, ADAutoCrop.LOOKAHEAD_PERIODS do
if isPlantableIn(((period - 1 + offset) % 12) + 1) then return true end
end
return false
end
-- Må knappen røre marken? Kontraktmarker kører kontrakten og springes over.
function ADAutoCrop.isEligible(field)
return field ~= nil and not field.contract
end
-- ---- spillet ----
-- Afgrøder gårdens maskiner kan så og høste (alle ejede køretøjer/redskaber, også afkoblede skærebord).
function ADAutoCrop.farmCapabilities(farmId)
local sow, harvest = {}, {}
local vehicles = g_currentMission ~= nil and g_currentMission.vehicleSystem ~= nil and g_currentMission.vehicleSystem.vehicles or {}
for _, vehicle in pairs(vehicles) do
local ok = pcall(function()
if vehicle.getOwnerFarmId == nil or vehicle:getOwnerFarmId() ~= farmId then return end
local seeds = vehicle.spec_sowingMachine ~= nil and vehicle.spec_sowingMachine.seeds or nil
for _, fruit in pairs(seeds or {}) do sow[fruit] = true end
for fruit in pairs(ADCpBridge.harvestFruitSet(vehicle.spec_cutter)) do harvest[fruit] = true end
if vehicle.spec_vineCutter ~= nil then
for fruit in pairs(ADCpBridge.vineFruitSet(vehicle.spec_vineCutter)) do harvest[fruit] = true end
end
end)
if not ok then Logging.warning("ADSmartPickup: Alt automatisk: et køretøj kunne ikke læses") end
end
return sow, harvest
end
-- Kandidater: alle afgrøder der kan sås, med værdi pr. ha og om gården/årstiden tillader dem.
function ADAutoCrop.candidates(farmId)
local sow, harvest = ADAutoCrop.farmCapabilities(farmId)
local mowable = ADFields ~= nil and ADFields.getMowable ~= nil and ADFields.getMowable() or {}
local period = g_currentMission ~= nil and g_currentMission.environment ~= nil and g_currentMission.environment.currentPeriod or nil
local list = {}
for _, fruit in ipairs(g_fruitTypeManager ~= nil and g_fruitTypeManager.fruitTypes or {}) do
if fruit.allowsSeeding ~= false and fruit.fillType ~= nil and fruit.name ~= nil and not mowable[fruit.index] then
local okPrice, quote = pcall(ADSources.getMarketQuote, fruit.fillType.index)
local price = okPrice and quote ~= nil and tonumber(quote.price) or 0
local perHa = (tonumber(fruit.literPerSqm) or 0) * 10000
table.insert(list, {name = fruit.name, value = perHa * price, canSow = sow[fruit.index] == true,
canHarvest = harvest[fruit.index] == true,
plantableSoon = ADAutoCrop.plantableSoon(function(p) return ADCpBridge.isPlantableIn(fruit, p) end, period)})
end
end
return list
end
-- Diagnose: hvor mange afgrøder hver betingelse udelukker + de mest værdifulde med deres flag.
function ADAutoCrop.describe(candidates)
local counts = {sow = 0, harvest = 0, soon = 0, price = 0}
local sorted = {}
for _, c in ipairs(candidates or {}) do
if c.canSow then counts.sow = counts.sow + 1 end
if c.canHarvest then counts.harvest = counts.harvest + 1 end
if c.plantableSoon then counts.soon = counts.soon + 1 end
if (tonumber(c.value) or 0) > 0 then counts.price = counts.price + 1 end
table.insert(sorted, c)
end
table.sort(sorted, function(a, b) return (tonumber(a.value) or 0) > (tonumber(b.value) or 0) end)
local top = {}
for index = 1, math.min(8, #sorted) do
local c = sorted[index]
table.insert(top, string.format("%s %.0f %s%s%s", tostring(c.name), tonumber(c.value) or 0,
c.canSow and "S" or "-", c.canHarvest and "H" or "-", c.plantableSoon and "T" or "-"))
end
return string.format("%d afgrøder: kan sås %d, kan høstes %d, såtid snart %d, har pris %d | top: %s (S=så H=høst T=tid)",
#(candidates or {}), counts.sow, counts.harvest, counts.soon, counts.price, table.concat(top, ", "))
end
-- ---- fordeling af marker (ren logik) ----
-- Brugerønske 17/10: "omberegn alt hvad der er brug for og allokér de størrelser af marker der passer til det gården
-- skal bruge" — gårdens forbrug dækkes med mindst muligt overskud, resten bliver salgsafgrøder.
-- Mindste mangel (ha) der får en mark: mindre rester dækkes af lageret (som i ADCropPlan.MIN_HA)
ADAutoCrop.MIN_NEED_HA = 0.5
-- Dyrker marken (fast udbud) det behovet skal bruge? need = {fruit, product, fruits}
local function fieldCovers(field, need)
local planned = (field.targetFruit ~= nil and field.targetFruit ~= "") and field.targetFruit or field.fruit
local sameCrop = planned == need.fruit or (need.fruits ~= nil and planned ~= nil and need.fruits[planned] == true)
if not sameCrop then return false end
if need.product == nil then return true end
local product = field.product
if product == nil or product == "" or product == "auto" then product = "silage" end
return product == need.product
end
-- Er marken fast (tæller som udbud, flyttes ikke)? Eng/varige afgrøder og spillerens egne mål. Slåmarker (græs) er
-- med i planen (brugerønske 17/10): overskydende græs bliver salgsafgrøde efter sidste slæt.
-- resetUser ("nulstil mine valg"): spillerens mål regnes også forfra.
function ADAutoCrop.isFixed(field, resetUser)
return field.permanent == true or (field.targetSource == "user" and not resetUser)
end
-- Står behovets afgrøde allerede på marken (ingen ompløjning)? Kun afgrøden, ikke produktet (hø/ensilage er gratis at skifte).
local function growsNeed(field, need)
local current = field.fruit
return current ~= nil and (current == need.fruit or (need.fruits ~= nil and need.fruits[current] == true))
end
-- Behov i ha over 12 måneder pr. markvare. demand = {[nøgle] = l/måned}, yields = {[nøgle] = l/ha},
-- products = {[nøgle] = {fruit, product, fruits}}, skip = {[afgrøde] = true} (kan ikke være mål),
-- factor = overskud (1.1 = 10 % ekstra til silo-buffer; nil = 1).
-- -> {{key, fruit, product, fruits, needHa}} største først
-- cutsOf(afgrøde) -> antal høst pr. år (nil = 1); kæden og knappen bruger samme ADCropPlan.cutsPerYear
function ADAutoCrop.needs(demand, yields, products, skip, factor, cutsOf)
local list = {}
for key, perMonth in pairs(demand or {}) do
local perHa = (yields or {})[key] or 0
local spec = (products or {})[key]
local fruit = spec ~= nil and spec.fruit or key
if perHa > 0 and (perMonth or 0) > 0 and not (skip or {})[fruit] then
local cuts = math.max(1, (cutsOf ~= nil and cutsOf(fruit)) or 1)
table.insert(list, {key = key, fruit = fruit, product = spec ~= nil and spec.product or nil,
fruits = spec ~= nil and spec.fruits or nil, needHa = perMonth * 12 / (perHa * cuts) * (factor or 1)})
end
end
table.sort(list, function(a, b)
if a.needHa ~= b.needHa then return a.needHa > b.needHa end
return tostring(a.key) < tostring(b.key)
end)
return list
end
-- Mindste frie mark der dækker resten; ellers den største (så færrest mulige marker bruges). Marker hvor afgrøden
-- allerede står, tages først (ingen ompløjning). -> indeks
local function bestFit(free, remaining, need)
local function pick(accept)
local fit, largest = nil, nil
for index, field in ipairs(free) do
if accept(field) then
local area = field.areaHa or 0
if area >= remaining and (fit == nil or area < (free[fit].areaHa or 0)) then fit = index end
if largest == nil or area > (free[largest].areaHa or 0) then largest = index end
end
end
return fit or largest
end
return pick(function(field) return growsNeed(field, need) end) or pick(function() return true end)
end
-- Salgsafgrøderne: største mark først til den afgrøde der har færrest ha indtil nu (jævn fordeling).
local function spreadByArea(free, fruits, assigned)
if #fruits == 0 then return end
local sorted, totals = {}, {}
for _, field in ipairs(free) do table.insert(sorted, field) end
table.sort(sorted, function(a, b)
if (a.areaHa or 0) ~= (b.areaHa or 0) then return (a.areaHa or 0) > (b.areaHa or 0) end
return a.id < b.id
end)
for _, fruit in ipairs(fruits) do totals[fruit] = 0 end
for _, field in ipairs(sorted) do
local pick = fruits[1]
for _, fruit in ipairs(fruits) do if totals[fruit] < totals[pick] then pick = fruit end end
totals[pick] = totals[pick] + (field.areaHa or 0)
assigned[field.id] = {fruit = pick, source = ADAutoCrop.SOURCE}
end
end
-- needs (ADAutoCrop.needs), fields = {{id, areaHa, fruit, targetFruit, targetSource, product, permanent, excluded, enabled}},
-- cashFruits = top-afgrøderne. -> assigned {[id] = {fruit, product, source, reason}}, uncovered {{key, missingHa}}
function ADAutoCrop.allocate(needs, fields, cashFruits, resetUser)
local free, fixed = {}, {}
for _, field in ipairs(fields or {}) do
-- slået fra i marklisten: moden dyrker den ikke — hverken udbud eller fri
if field.enabled ~= false then
if ADAutoCrop.isFixed(field, resetUser) then table.insert(fixed, field) else table.insert(free, field) end
end
end
local assigned, uncovered = {}, {}
for _, need in ipairs(needs or {}) do
local remaining = need.needHa
for _, field in ipairs(fixed) do
if fieldCovers(field, need) then remaining = remaining - (field.areaHa or 0) end
end
while remaining > ADAutoCrop.MIN_NEED_HA and #free > 0 do
local index = bestFit(free, remaining, need)
local field = table.remove(free, index)
assigned[field.id] = {fruit = need.fruit, product = need.product, source = "chain", reason = need.key}
remaining = remaining - (field.areaHa or 0)
end
if remaining > ADAutoCrop.MIN_NEED_HA then table.insert(uncovered, {key = need.key, missingHa = remaining}) end
end
spreadByArea(free, cashFruits or {}, assigned)
return assigned, uncovered
end
-- Gårdens behov og markerne fra kæden (frisk beregning, kæden handler ikke selv). -> needs, fields | nil, fejltekst
local function farmPlanInput(adEnv)
if adEnv == nil or ADChain == nil or ADChain.evaluate == nil then return nil, "kæden findes ikke" end
local before = ADChain.last
local ok, result = pcall(ADChain.evaluate, adEnv, false)
if not ok or result == nil or result.chain == nil or result.data == nil then return nil, tostring(result) end
-- evaluate giver det gamle resultat tilbage, når gården ikke kunne læses: det må aldrig fordeles efter
if result == before then return nil, "gården kunne ikke læses (gammelt kæderesultat)" end
local data, chain = result.data, result.chain
if data.fieldsIncomplete then return nil, "marklisten er ufuldstændig" end
-- delvist læst (opskrifter/stalde/forbrug): behovet ville være for lavt, og jorden gik til salg
if data.partial then return nil, "gården blev kun delvist læst" end
local surplus = ADSettings ~= nil and ADSettings.get("farmSurplusPercent") or 0
local needs = ADAutoCrop.needs(chain.fieldDemand, data.yields, chain.fieldProducts, data.unswitchable, 1 + (tonumber(surplus) or 0) / 100,
ADCropPlan.cutsPerYear)
local fields = {}
for _, entry in ipairs(data.fields or {}) do
if not ADFieldJobs.getField(entry.id).contract then table.insert(fields, entry) end
end
return needs, fields
end
local function haList(list, field)
local parts = {}
for _, item in ipairs(list or {}) do table.insert(parts, string.format("%s %.1f ha", tostring(item.key), tonumber(item[field]) or 0)) end
return #parts > 0 and table.concat(parts, ", ") or "ingen"
end
-- Knappen: slå alle marker til og frigiv dem til kæderne, beregn gårdens behov forfra og læg de marker der passer
-- bedst i størrelse til det; resten bliver salgsafgrøder. Spillerens egne mål, eng og slåmarker røres ikke.
-- -> {enabled, chain, targeted, fruits = {navn, ...}, uncovered} | {scanning = true} | {failed = tekst}
-- opts.enableIds = {[id] = true}: genplan efter markkøb — kun de nye marker slås til (spillerens [Fra] respekteres).
-- opts.resetUser: "nulstil mine valg" — spillerens egne mål regnes også forfra.
function ADAutoCrop.applyAll(farmId, adEnv, opts)
-- markscanningen skal være færdig, ellers får kun en del af markerne besked (og kædens udbud er ufuldstændigt)
if ADFields.isScanComplete ~= nil and not ADFields.isScanComplete() then
logInfo("ADSmartPickup: Alt automatisk: markerne scannes stadig — intet ændret")
return {scanning = true, enabled = 0, chain = 0, targeted = 0}
end
local candidates = ADAutoCrop.candidates(farmId)
logInfo("ADSmartPickup: Alt automatisk: %s", ADAutoCrop.describe(candidates))
local top = ADAutoCrop.pickTop(candidates, ADAutoCrop.TOP_COUNT)
-- 1: alle (undtagen kontrakter) til og frigivet
local enabled = 0
for _, info in ipairs(ADFields.list() or {}) do
local field = ADFieldJobs.getField(info.id)
local wanted = opts == nil or opts.enableIds == nil or opts.enableIds[info.id] == true
if ADAutoCrop.isEligible(field) and wanted then
ADFieldJobs.setField(ADFieldModel.with(ADFieldModel.setEnabled(field, true), {plan = {chainFree = true}}))
enabled = enabled + 1
end
end
-- knappen er brugt: planen følger med, når gården får eller mister marker (ADAutoCrop.tick)
if ADSettings ~= nil and (opts == nil or not opts.replan) then
ADSettings.set("autoAll", 1)
pcall(ADSettings.save)
end
-- 2: gårdens behov forfra; uden dem fordeles intet (driften må aldrig komme til at mangle)
local needs, fields = farmPlanInput(adEnv)
if needs == nil then
ADFieldJobs.save()
Logging.warning("ADSmartPickup: Alt automatisk: gårdens behov kunne ikke beregnes (%s) — %d marker slået til, ingen afgrøder ændret", tostring(fields), enabled)
return {failed = tostring(fields), enabled = enabled, chain = 0, targeted = 0}
end
logInfo("ADSmartPickup: Alt automatisk: gårdens behov (12 mdr.): %s", haList(needs, "needHa"))
ADAutoCrop.knownNeeds = ADAutoCrop.needSignature(needs) -- udgangspunkt for "behovet er ændret"-tjekket (tickNeeds)
-- 3: fordel
local resetUser = opts ~= nil and opts.resetUser == true
local assigned, uncovered = ADAutoCrop.allocate(needs, fields, top, resetUser)
local chain, targeted = 0, 0
for id, choice in pairs(assigned) do
local okSet, err = pcall(function()
local updated = ADFieldModel.setTarget(ADFieldJobs.getField(id), choice.fruit, choice.source, choice.product)
-- et tidligere hø/ensilage-produkt må ikke hænge ved en salgsafgrøde (setTarget skriver kun silage/hay)
if choice.product == nil then updated = ADFieldModel.with(updated, {plan = {product = "auto"}}) end
ADFieldJobs.setField(updated)
end)
if not okSet then
Logging.warning("ADSmartPickup: Alt automatisk: F%s kunne ikke sættes til %s: %s", tostring(id), tostring(choice.fruit), tostring(err))
elseif choice.source == "chain" then
chain = chain + 1
logInfo("ADSmartPickup: Alt automatisk: F%s -> %s til gårdens forbrug (%s)", tostring(id), tostring(choice.fruit), tostring(choice.reason))
else
targeted = targeted + 1
logInfo("ADSmartPickup: Alt automatisk: F%s -> %s (salg)", tostring(id), tostring(choice.fruit))
end
end
if #uncovered > 0 then
Logging.warning("ADSmartPickup: Alt automatisk: for få marker til gårdens behov — mangler: %s", haList(uncovered, "missingHa"))
end
ADFieldJobs.save()
-- kæde-fanen skal se de nye mål (ellers viser den planen fra før knappen)
pcall(ADChain.evaluate, adEnv, false)
logInfo("ADSmartPickup: Alt automatisk: %d marker slået til, %d til gårdens forbrug, %d til salg på %s", enabled, chain, targeted,
#top > 0 and table.concat(top, ", ") or "- (ingen afgrøde gården kan så og høste)")
return {enabled = enabled, chain = chain, targeted = targeted, fruits = top, uncovered = uncovered}
end
-- ---- genplan når gården får eller mister marker ----
ADAutoCrop.TICK_MS = 10000
ADAutoCrop.RETRY_MS = 50000
ADAutoCrop.timer = 0
ADAutoCrop.knownFields = nil -- {[id] = true} ved sidste tjek (nil = ikke set endnu efter indlæsning)
-- Alle gårdens marker (også kontrakter — en kontrakt der slutter, er ikke en ny mark). -> {[id] = true}
function ADAutoCrop.ownedFieldSet()
local set = {}
for _, info in ipairs(ADFields.list() or {}) do set[info.id] = true end
return set
end
-- Nye og forsvundne marker mellem to sæt. -> added {[id] = true}, changed (bool)
function ADAutoCrop.fieldChanges(before, after)
local added, changed = {}, false
for id in pairs(after or {}) do
if not (before or {})[id] then added[id] = true changed = true end
end
for id in pairs(before or {}) do
if not (after or {})[id] then changed = true end
end
return added, changed
end
function ADAutoCrop.tick(adEnv, dt)
ADAutoCrop.timer = ADAutoCrop.timer + (dt or 0)
ADAutoCrop.needTimer = ADAutoCrop.needTimer + (dt or 0)
if ADAutoCrop.timer < ADAutoCrop.TICK_MS then return end
ADAutoCrop.timer = 0
if ADFields.isScanComplete ~= nil and not ADFields.isScanComplete() then return end
local current = ADAutoCrop.ownedFieldSet()
if ADAutoCrop.knownFields == nil then
ADAutoCrop.knownFields = current
return
end
local previous = ADAutoCrop.knownFields
local added, changed = ADAutoCrop.fieldChanges(previous, current)
ADAutoCrop.knownFields = current
if ADSettings == nil or ADSettings.get("autoAll") ~= 1 then return end
if not changed then return ADAutoCrop.tickNeeds(adEnv) end
logInfo("ADSmartPickup: Alt automatisk: gårdens marker er ændret — planen laves om")
local result = ADAutoCrop.applyAll(g_currentMission:getFarmId(), adEnv, {enableIds = added, replan = true})
-- mislykket (gården kunne ikke læses, scanning): prøv igen ved næste tjek
if result == nil or result.failed ~= nil or result.scanning then
ADAutoCrop.knownFields = previous
ADAutoCrop.timer = -ADAutoCrop.RETRY_MS -- næste forsøg om ~1 min, ikke hvert 10. sekund
end
end
-- ---- genplan når gårdens behov ændrer sig (flere dyr, ny fabrik, ændret overskud) — brugerspørgsmål 17/10 ----
ADAutoCrop.NEED_CHECK_MS = 300000 -- så tit sammenlignes behovet (kædens beregning er ikke gratis)
ADAutoCrop.NEED_CHANGE_RATIO = 0.10 -- så stor en andel af det gamle behov skal ændringen være, før planen laves om
ADAutoCrop.needTimer = 0
ADAutoCrop.knownNeeds = nil -- {[key] = ha} ved sidste plan/tjek (nil = ikke set endnu)
function ADAutoCrop.needSignature(needs)
local signature = {}
for _, item in ipairs(needs or {}) do signature[item.key] = tonumber(item.needHa) or 0 end
return signature
end
-- Ren: er behovet ændret nok til en ny plan? Et behov der kommer til eller forsvinder (over MIN_NEED_HA) tæller altid.
function ADAutoCrop.needsChanged(before, after, ratio)
ratio = ratio or ADAutoCrop.NEED_CHANGE_RATIO
local keys = {}
for key in pairs(before or {}) do keys[key] = true end
for key in pairs(after or {}) do keys[key] = true end
for key in pairs(keys) do
local a, b = (before or {})[key] or 0, (after or {})[key] or 0
local delta = math.abs(b - a)
if delta >= ADAutoCrop.MIN_NEED_HA and delta > math.max(a, b) * ratio then return true end
end
return false
end
-- Gårdens behov nu -> {[key] = ha} | nil (gården kunne ikke læses)
function ADAutoCrop.currentNeeds(adEnv)
local needs = farmPlanInput(adEnv)
return needs ~= nil and ADAutoCrop.needSignature(needs) or nil
end
local function describeSignature(signature)
local parts = {}
for key, ha in pairs(signature or {}) do table.insert(parts, string.format("%s %.1f ha", tostring(key), ha)) end
table.sort(parts)
return #parts > 0 and table.concat(parts, ", ") or "intet"
end
-- Hvert NEED_CHECK_MS: er gårdens behov ændret mere end NEED_CHANGE_RATIO, laves planen om. Marker spilleren har slået
-- fra, slås ikke til igen (enableIds = {}); spillerens egne mål røres ikke.
function ADAutoCrop.tickNeeds(adEnv)
if ADAutoCrop.needTimer < ADAutoCrop.NEED_CHECK_MS then return end
ADAutoCrop.needTimer = 0
local now = ADAutoCrop.currentNeeds(adEnv)
if now == nil then return end -- gården kunne ikke læses: igen om NEED_CHECK_MS
if ADAutoCrop.knownNeeds == nil then
ADAutoCrop.knownNeeds = now
return
end
if not ADAutoCrop.needsChanged(ADAutoCrop.knownNeeds, now) then return end
logInfo("ADSmartPickup: Alt automatisk: gårdens behov er ændret (%s -> %s) — planen laves om",
describeSignature(ADAutoCrop.knownNeeds), describeSignature(now))
-- lykkes det ikke, står knownNeeds uændret, og der prøves igen ved næste tjek
ADAutoCrop.applyAll(g_currentMission:getFarmId(), adEnv, {enableIds = {}, replan = true})
end