feat: Alt automatisk som hel markplan — behov i ha + overskud, bedste pasform, græsmarker med, nulstil mine valg, genplan ved markkøb — 1.62.283

This commit is contained in:
2026-10-17 02:35:05 +02:00
parent 10622416fc
commit 6e380377a1
10 changed files with 320 additions and 115 deletions
+246 -86
View File
@@ -1,33 +1,18 @@
-- "Alt automatisk" (brugerønske 17/10): én knap i Marker-fanen slår alle marker til og frigiver dem til kæderne.
-- Først dækker kædeplanen gårdens forbrug (stalde, fabrikker); resten af markerne uden mål fordeles skiftevis 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 nu eller inden for de næste perioder. Slåmarker (græs),
-- kontraktmarker og marker med et mål (spillerens eller kædens) får intet nyt mål. Kæderne må skifte det valgte
-- mål senere (kilden er "auto", ikke "user").
-- 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.
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"
-- candidates = {{name, value, canSow, canHarvest, plantableSoon}} -> den bedste {name, value} | nil
-- (højeste værdi; ved lighed alfabetisk, så valget er stabilt)
function ADAutoCrop.pickBest(candidates)
local best = nil
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
if best == nil or value > best.value or (value == best.value and tostring(candidate.name) < tostring(best.name)) then
best = {name = candidate.name, value = value}
end
end
end
return best
end
ADAutoCrop.TOP_COUNT = 3
-- De n bedste afgrøder (samme krav som pickBest), bedste først. -> {navn, ...}
-- 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
@@ -45,17 +30,6 @@ function ADAutoCrop.pickTop(candidates, n)
return names
end
-- Skiftevis fordeling: markerne (sorteret efter id) får fruits[1], fruits[2], ... rundt. -> {[markId] = afgrøde}
function ADAutoCrop.spread(fieldIds, fruits)
local result = {}
if fruits == nil or #fruits == 0 then return result end
local ids = {}
for _, id in ipairs(fieldIds or {}) do table.insert(ids, id) end
table.sort(ids)
for index, id in ipairs(ids) do result[id] = fruits[((index - 1) % #fruits) + 1] end
return result
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
@@ -65,13 +39,9 @@ function ADAutoCrop.plantableSoon(isPlantableIn, period)
return false
end
-- Hvad knappen gør ved én mark. field = ADFieldModel-mark, info = {kind}. -> nil (rør ikke) | {target = navn|nil}
function ADAutoCrop.planFor(field, info, bestName)
if field == nil or field.contract then return nil end
local plan = field.plan or {}
local hasTarget = plan.targetFruit ~= nil and plan.targetFruit ~= ""
local wantsTarget = not hasTarget and (info == nil or info.kind ~= "mowable") and bestName ~= nil
return {target = wantsTarget and bestName or nil}
-- 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 ----
@@ -136,37 +106,155 @@ function ADAutoCrop.describe(candidates)
#(candidates or {}), counts.sow, counts.harvest, counts.soon, counts.price, table.concat(top, ", "))
end
-- Kædeplanens markskift (gårdens forbrug) lagt ind direkte — uden kædens loft på skift pr. runde.
-- -> antal marker kæden fik. Fejl i kædeberegningen logges; så fordeles alle marker på top-afgrøderne.
local function coverFarmNeeds(adEnv)
if adEnv == nil or ADChain == nil or ADChain.evaluate == nil then return 0 end
local ok, result = pcall(ADChain.evaluate, adEnv, false)
if not ok or result == nil then
Logging.warning("ADSmartPickup: Alt automatisk: kædeplanen kunne ikke beregnes: %s", tostring(result))
return 0
end
local covered = 0
for _, action in ipairs(result.actions or {}) do
-- markens nuværende tilstand afgør (et gammelt kæderesultat må aldrig overskrive spillerens eget mål)
local field = action.mode == "auto" and ADFieldJobs.getField(action.fieldId) or nil
if field ~= nil and field.plan.targetSource ~= "user" and ADFieldModel.isEnabled(field) and not field.contract then
local okSet, err = pcall(function()
ADFieldJobs.setField(ADFieldModel.setTarget(field, action.to, "chain", action.product))
end)
if okSet then
Logging.info("ADSmartPickup: Alt automatisk: F%s -> %s til gårdens forbrug (%s)", tostring(action.fieldId), tostring(action.to), tostring(action.reason))
covered = covered + 1
else
Logging.warning("ADSmartPickup: Alt automatisk: F%s kunne ikke sættes til %s: %s", tostring(action.fieldId), tostring(action.to), tostring(err))
end
end
end
return covered
-- ---- 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
-- Knappen: slå alle marker til og frigiv dem til kæderne, dæk gårdens forbrug, fordel resten på top-afgrøderne.
-- -> {enabled, chain, targeted, fruits = {navn, ...}} | {scanning = true}
function ADAutoCrop.applyAll(farmId, adEnv)
-- 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
function ADAutoCrop.needs(demand, yields, products, skip, factor)
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
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 * (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)
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
Logging.info("ADSmartPickup: Alt automatisk: markerne scannes stadig — intet ændret")
@@ -176,33 +264,105 @@ function ADAutoCrop.applyAll(farmId, adEnv)
Logging.info("ADSmartPickup: Alt automatisk: %s", ADAutoCrop.describe(candidates))
local top = ADAutoCrop.pickTop(candidates, ADAutoCrop.TOP_COUNT)
-- 1: alle (undtagen kontrakter) til og frigivet
local enabled, infos = 0, {}
local enabled = 0
for _, info in ipairs(ADFields.list() or {}) do
local field = ADFieldJobs.getField(info.id)
if ADAutoCrop.planFor(field, info, nil) ~= nil then
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
table.insert(infos, info)
end
end
-- 2: gårdens forbrug
local chain = coverFarmNeeds(adEnv)
-- 3: resten uden mål -> top-afgrøderne skiftevis
local open = {}
for _, info in ipairs(infos) do
local plan = ADAutoCrop.planFor(ADFieldJobs.getField(info.id), info, top[1])
if plan ~= nil and plan.target ~= nil then table.insert(open, info.id) 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
local targeted = 0
for id, fruit in pairs(ADAutoCrop.spread(open, top)) do
ADFieldJobs.setField(ADFieldModel.setTarget(ADFieldJobs.getField(id), fruit, ADAutoCrop.SOURCE))
Logging.info("ADSmartPickup: Alt automatisk: F%s mål-afgrøde %s", tostring(id), tostring(fruit))
targeted = targeted + 1
-- 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
Logging.info("ADSmartPickup: Alt automatisk: gårdens behov (12 mdr.): %s", haList(needs, "needHa"))
-- 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
Logging.info("ADSmartPickup: Alt automatisk: F%s -> %s til gårdens forbrug (%s)", tostring(id), tostring(choice.fruit), tostring(choice.reason))
else
targeted = targeted + 1
Logging.info("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)
if adEnv ~= nil and ADChain ~= nil and ADChain.evaluate ~= nil then pcall(ADChain.evaluate, adEnv, false) end
Logging.info("ADSmartPickup: Alt automatisk: %d marker slået til, %d til gårdens forbrug, %d fordelt på %s", enabled, chain, targeted,
pcall(ADChain.evaluate, adEnv, false)
Logging.info("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}
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)
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 not changed or ADSettings == nil or ADSettings.get("autoAll") ~= 1 then return end
Logging.info("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