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
+1
View File
@@ -8,6 +8,7 @@ står i [docs/BRUGERMANUAL.md](docs/BRUGERMANUAL.md) (dansk) og [docs/USER_MANUA
## 1.62 — Kæder slås selv til
- **1.62.283** "Alt automatisk" er nu en **hel markplan** (brugerønsker 17/10): gårdens forbrug beregnes forfra (12 mdr. + indstillingen **Overskud til gårdens forbrug**, standard 10 %) og dækkes med de marker der **passer bedst i størrelse** (marker der allerede har afgrøden først); resten fordeles jævnt i ha på de 3 mest indbringende salgsafgrøder. **Græsmarker er med** (overskydende græs sås om efter sidste slæt; eng er fast). Nyt link **[Alt automatisk + nulstil mine valg]**. Planen **laves om ved markkøb/-salg** (Til/Fra i Indstillinger). Ingen afgrøder ændres, hvis gården ikke kan læses helt.
- **1.62.282** "Alt automatisk" udvidet (brugerønsker 17/10): **gårdens forbrug dækkes først** — kædeplanen (stalde/fabrikker, fx græs/kløver/lucerne til køerne) sætter de marker der skal til, uden kædens loft på skift pr. runde; spillerens egne mål røres aldrig. **Resten spredes skiftevis på de 3 mest indbringende afgrøder** (spredt høst). Afgrøder vurderes over **hele året** (i november kan intet sås før marts). Knappen venter, til markscanningen er færdig. Ny markering **[Gård]** i Auto-kolonnen for marker der dyrker til gårdens eget forbrug.
- **1.62.281** Diagnose: **"Alt automatisk" logger hvorfor ingen afgrøde blev valgt** (in-game 17/10: 28 marker slået til, men 0 fik mål). Loggen viser hvor mange afgrøder der kan sås, høstes, sås snart og har en pris, plus de mest værdifulde med deres flag.
- **1.62.280** Rettet: **udkørsels-kilde ved en stald blev afvist, når en silo stod nærmere markøren** (in-game 17/10: Milk Run sprang "Milk Collection" ved Kostald 1 over — mælketanken 32 m væk, Silo 3 nærmere). Er markøren en bygnings tildelte læssemarkør, bruges den bygning, med den af dens læssestationer hvis trigger står nærmest markøren. Siloer, objektlagre og stalde med pallespawnere følger de gamle regler.
+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
+6
View File
@@ -34,6 +34,12 @@ ADSettings.KEYS = {
-- flow-genstart (ADLaunchGate; brugerønske 16/10, erstatter markarbejdets egen afstand)
startAllStaggerSec = {default = 10, min = 1, max = 300, choices = {1, 5, 10, 15, 20, 30, 45, 60, 90, 120}, format = "%s s",
text = "s: mindste tid mellem hver maskine der sendes ud (Start alle, markarbejde, marksiloer, flows)"},
-- "Alt automatisk": så mange procent ekstra areal til gårdens eget forbrug (overskud der ligger i silo som buffer)
farmSurplusPercent = {default = 10, min = 0, max = 100, choices = {0, 5, 10, 15, 20, 25, 30, 40, 50}, format = "%s %%",
text = "%: ekstra areal til gårdens forbrug ved Alt automatisk (buffer i silo)"},
-- "Alt automatisk" er brugt: planen laves om, når gården får/mister marker (sættes af knappen; kan slås fra her)
autoAll = {default = 0, min = 0, max = 1, choices = {1, 0}, labels = {"spu_set_autoAll_on", "spu_set_autoAll_off"},
text = "1/0: Alt automatisk laver planen om, når gården køber eller sælger marker"},
}
local values = {global = {}, byBuilding = {}}
+6
View File
@@ -1814,6 +1814,12 @@ function ADSmartPickup:update(dt)
Logging.warning(ADSmartPickup.LOG_PREFIX .. "markarbejde fejlede: %s", tostring(errFields))
end
end
if ADAutoCrop ~= nil then
local okAuto, errAuto = pcall(ADAutoCrop.tick, getAutoDriveEnv(), dt)
if not okAuto then
Logging.warning(ADSmartPickup.LOG_PREFIX .. "Alt automatisk-genplan fejlede: %s", tostring(errAuto))
end
end
if ADChain ~= nil then
local okChain, errChain = pcall(ADChain.tick, getAutoDriveEnv(), dt)
if not okChain then
+13 -4
View File
@@ -133,7 +133,8 @@ function SmartPickupFrame:fillFieldRows(adEnv)
self:addTextRow(i18n:getText("spu_field_scanning"))
else
self:addTextRow(i18n:getText("spu_field_hint"))
self:addLinkRow(i18n:getText("spu_field_autoAll"), function(frame) frame:onClickAutoAll() end)
self:addLinkRow(i18n:getText("spu_field_autoAll"), function(frame) frame:onClickAutoAll(false) end)
self:addLinkRow(i18n:getText("spu_field_autoAllReset"), function(frame) frame:onClickAutoAll(true) end)
-- Stop alt-pausen gemmes med savegamet: sig det tydeligt her (in-game 29/9: "jeg har ikke trykket stop")
if ADFieldJobs.state.paused then self:addTextRow(i18n:getText("spu_field_pausedBanner")) end
-- markflåden på "kun med flueben" uden flueben: intet kan sendes ud (in-game 26/9 — alle marker "no machine")
@@ -386,21 +387,29 @@ function SmartPickupFrame:toggleFieldEnabled(id)
end
-- "Alt automatisk": bekræft først — knappen ændrer alle marker (ADAutoCrop.applyAll).
function SmartPickupFrame:onClickAutoAll()
function SmartPickupFrame:onClickAutoAll(resetUser)
self:safe(function(frame)
YesNoDialog.show(SmartPickupFrame.onAutoAllResult, frame, frame.i18n:getText("spu_field_autoAllConfirm"), frame.i18n:getText("spu_field_autoAllTitle"))
frame.autoAllResetUser = resetUser == true
YesNoDialog.show(SmartPickupFrame.onAutoAllResult, frame,
frame.i18n:getText(resetUser and "spu_field_autoAllResetConfirm" or "spu_field_autoAllConfirm"), frame.i18n:getText("spu_field_autoAllTitle"))
end)
end
function SmartPickupFrame:onAutoAllResult(yes)
self:safe(function(frame)
if not yes then return end
local result = ADAutoCrop.applyAll(g_currentMission:getFarmId(), frame.getAdEnv())
local result = ADAutoCrop.applyAll(g_currentMission:getFarmId(), frame.getAdEnv(), {resetUser = frame.autoAllResetUser == true})
if result.scanning then
frame.statusOverride = frame.i18n:getText("spu_field_autoAllScanning")
frame.statusOverrideTicks = SmartPickupFrame.STATUS_OVERRIDE_TICKS
return
end
if result.failed ~= nil then
frame.statusOverride = string.format(frame.i18n:getText("spu_field_autoAllFailed"), result.enabled)
frame.statusOverrideTicks = SmartPickupFrame.STATUS_OVERRIDE_TICKS
frame:requestRebuild()
return
end
local titles = {}
for _, name in ipairs(result.fruits or {}) do table.insert(titles, frame:fruitTitle(name)) end
frame.statusOverride = string.format(frame.i18n:getText("spu_field_autoAllDone"), result.enabled, result.chain, result.targeted,
+9 -2
View File
@@ -131,9 +131,12 @@
<text name="spu_field_scanning" text="Marker indlæses ... (én mark pr. sekund)"/>
<text name="spu_field_hint" text="[Til]/[Fra]: skal moden selv køre marken (nye marker er fra). [Gård]: dyrker til gårdens eget forbrug. Klik på en mark for at se og rette dens opsætning."/>
<text name="spu_field_autoAll" text="[Alt automatisk] Slå alle marker til og lad moden vælge afgrøde"/>
<text name="spu_field_autoAllReset" text="[Alt automatisk + nulstil mine valg] Også marker hvor du selv har valgt afgrøde"/>
<text name="spu_field_autoAllResetConfirm" text="Som Alt automatisk, men også de afgrøder du selv har valgt, regnes forfra — alle marker (undtagen kontrakter og græsmarker) indgår i planen. Fortsæt?"/>
<text name="spu_field_autoAllTitle" text="Alt automatisk"/>
<text name="spu_field_autoAllConfirm" text="Alle marker slås til og frigives til kæderne. Først sættes de marker, gårdens stalde og fabrikker mangler afgrøder fra; resten uden mål-afgrøde fordeles skiftevis på de 3 mest indbringende afgrøder, gårdens maskiner kan så og høste. Græsmarker, kontrakter og marker med valgt afgrøde beholder deres afgrøde. Fortsæt?"/>
<text name="spu_field_autoAllDone" text="Alt automatisk: %d marker slået til, %d til gårdens forbrug, %d fordelt på %s"/>
<text name="spu_field_autoAllConfirm" text="Alle marker slås til og frigives 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 på de 3 mest indbringende afgrøder, gårdens maskiner kan så og høste. Kontrakter, græsmarker og marker hvor du selv har valgt afgrøde, røres ikke. Fortsæt?"/>
<text name="spu_field_autoAllDone" text="Alt automatisk: %d marker slået til, %d til gårdens forbrug, %d til salg på %s"/>
<text name="spu_field_autoAllFailed" text="Alt automatisk: %d marker slået til, men gårdens behov kunne ikke beregnes — ingen afgrøder ændret (se loggen)"/>
<text name="spu_field_autoAllScanning" text="Alt automatisk: markerne scannes stadig — prøv igen om lidt"/>
<text name="spu_field_fleetEmpty" text="! Markflåden står på &quot;kun med flueben&quot;, men ingen maskiner har flueben — intet kan sendes ud. Åbn Markflåde og vælg &quot;Brug alle ledige maskiner&quot;."/>
<text name="spu_field_showAll" text="Vis alle marker (%d skjult)"/>
@@ -576,6 +579,10 @@
<text name="spu_set_waitHomeMinutes" text="Wait: ventetid før resten køres hjem i gårdens lager"/>
<text name="spu_set_troughRefillPercent" text="Fodertrug: kør først når truget er fyldt højst"/>
<text name="spu_set_startAllStaggerSec" text="Tid mellem hver maskine der sendes ud"/>
<text name="spu_set_farmSurplusPercent" text="Overskud til gårdens forbrug (Alt automatisk)"/>
<text name="spu_set_autoAll" text="Alt automatisk: ny plan ved markkøb/-salg"/>
<text name="spu_set_autoAll_on" text="Til"/>
<text name="spu_set_autoAll_off" text="Fra"/>
<text name="spu_fs_enabled" text="Hent marksiloer hjem automatisk"/>
<text name="spu_fs_maxVehicles" text="Maks. vogne ude"/>
<text name="spu_fs_minLiters" text="Mindste mængde pr. vare"/>
+9 -2
View File
@@ -131,9 +131,12 @@
<text name="spu_field_scanning" text="Loading fields ... (one field per second)"/>
<text name="spu_field_hint" text="[On]/[Off]: should the mod run the field by itself (new fields are off). [Farm]: grows for the farm&apos;s own use. Click a field to see and change its setup."/>
<text name="spu_field_autoAll" text="[All automatic] Turn every field on and let the mod choose the crop"/>
<text name="spu_field_autoAllReset" text="[All automatic + reset my choices] Also fields where you chose the crop"/>
<text name="spu_field_autoAllResetConfirm" text="Like All automatic, but the crops you chose yourself are recalculated too — every field (except contracts and grass fields) is part of the plan. Continue?"/>
<text name="spu_field_autoAllTitle" text="All automatic"/>
<text name="spu_field_autoAllConfirm" text="Every field is turned on and released to chains. First, fields are set to the crops the farm&apos;s barns and factories are short of; the rest without a target crop are spread over the 3 most profitable crops the farm can sow and harvest. Grass fields, contracts and fields with a chosen crop keep their crop. Continue?"/>
<text name="spu_field_autoAllDone" text="All automatic: %d fields turned on, %d for the farm&apos;s own use, %d spread over %s"/>
<text name="spu_field_autoAllConfirm" text="Every field is turned on and released to chains. The farm&apos;s own use (barns, factories) is recalculated and covered with the fields that fit best in size; the rest are spread evenly over the 3 most profitable crops the farm can sow and harvest. Contracts, grass fields and fields where you chose the crop are left alone. Continue?"/>
<text name="spu_field_autoAllDone" text="All automatic: %d fields turned on, %d for the farm&apos;s own use, %d for sale on %s"/>
<text name="spu_field_autoAllFailed" text="All automatic: %d fields turned on, but the farm&apos;s needs could not be calculated — no crops changed (see the log)"/>
<text name="spu_field_autoAllScanning" text="All automatic: fields are still being scanned — try again shortly"/>
<text name="spu_field_fleetEmpty" text="! The field fleet is set to &quot;only ticked&quot;, but no machine is ticked — nothing can be sent out. Open Field fleet and choose &quot;Use all free machines&quot;."/>
<text name="spu_field_showAll" text="Show all fields (%d hidden)"/>
@@ -576,6 +579,10 @@
<text name="spu_set_waitHomeMinutes" text="Wait: time before the rest is taken home to the farm store"/>
<text name="spu_set_troughRefillPercent" text="Trough: only go when the trough is at most this full"/>
<text name="spu_set_startAllStaggerSec" text="Time between each machine sent out"/>
<text name="spu_set_farmSurplusPercent" text="Surplus for the farm&apos;s own use (All automatic)"/>
<text name="spu_set_autoAll" text="All automatic: new plan when fields are bought/sold"/>
<text name="spu_set_autoAll_on" text="On"/>
<text name="spu_set_autoAll_off" text="Off"/>
<text name="spu_fs_enabled" text="Bring field silos home automatically"/>
<text name="spu_fs_maxVehicles" text="Max. vehicles out"/>
<text name="spu_fs_minLiters" text="Minimum amount per product"/>
+1 -1
View File
@@ -1,7 +1,7 @@
<?xml version="1.0" encoding="utf-8" standalone="no"?>
<modDesc descVersion="107">
<author>masterdraco</author>
<version>1.62.282.0</version>
<version>1.62.283.0</version>
<title>
<en>AD Smart Pickup</en>
</title>
+14 -10
View File
@@ -1275,18 +1275,22 @@ ukrudt nok, og højst to gange af hver slags pr. vækstsæson. En strigle tager
### Alt automatisk: alle marker på én gang
Øverst i Marker-fanen står linket **[Alt automatisk] Slå alle marker til og lad moden vælge afgrøde**. Efter en
bekræftelse gør det tre ting:
Øverst i Marker-fanen står to links:
1. Alle marker (undtagen kontrakter) slås **[Til]** og frigives til kæderne.
2. **Gårdens eget forbrug først:** kædeplanen sætter de marker, stalde og fabrikker mangler afgrøder fra (fx græs,
kløver eller lucerne til køerne). De marker vises med **[Gård]** i Auto-kolonnen.
3. Resten af markerne uden mål-afgrøde fordeles **skiftevis på de 3 mest indbringende afgrøder** (udbytte × bedste
salgspris), som gårdens maskiner både kan så og høste. Afgrøder vurderes over hele året: klargøringen kører
straks, såningen venter på afgrødens såtid.
- **[Alt automatisk]** slår alle marker (undtagen kontrakter) **[Til]**, frigiver dem til kæderne og lægger en plan:
1. **Gårdens forbrug beregnes forfra:** stalde og fabrikkers behov over 12 måneder, omregnet til hektar, plus
**overskuddet** fra indstillingen *Overskud til gårdens forbrug* (standard 10 %, ligger som buffer i silo).
2. Behovet dækkes med de marker der **passer bedst i størrelse** — den mindste mark der dækker, ellers den største
og så videre. Marker hvor afgrøden allerede står (fx græs til græsbehov), tages først, så intet pløjes unødigt.
De marker vises med **[Gård]** i Auto-kolonnen.
3. **Resten bliver salgsafgrøder**, fordelt jævnt i hektar på de 3 mest indbringende afgrøder (udbytte × bedste
salgspris), som gårdens maskiner kan så og høste. Overskydende græsmarker slås en sidste gang og sås så om.
- **[Alt automatisk + nulstil mine valg]** gør det samme, men regner også de afgrøder forfra, du selv har valgt.
Græsmarker, kontrakter og marker hvor du selv har valgt afgrøde, beholder deres afgrøde. Knappen venter, til
markscanningen efter indlæsning er færdig. Loggen viser hvilke marker der fik hvad.
Kontrakter og eng røres aldrig; uden "nulstil" heller ikke marker hvor du selv har valgt afgrøde. Afgrøder vurderes
over hele året: klargøringen kører straks, såningen venter på såtiden. Knappen venter, til markscanningen er færdig,
og ændrer ingen afgrøder, hvis gården ikke kan læses helt. Når knappen er brugt, laves planen om, når gården køber
eller sælger marker (indstillingen *Alt automatisk: ny plan ved markkøb/-salg*). Loggen viser behov og fordeling.
### Vælg og glem: afgrøde på marken
+15 -10
View File
@@ -1316,18 +1316,23 @@ handles small weeds.
### All automatic: every field at once
At the top of the Fields tab is the link **[All automatic] Turn every field on and let the mod choose the crop**.
After a confirmation it does three things:
At the top of the Fields tab are two links:
1. Every field (except contracts) is turned **[On]** and released to chains.
2. **The farm's own use first:** the chain plan sets the fields that barns and factories are short of crops from
(e.g. grass, clover or alfalfa for the cows). Those fields show **[Farm]** in the Auto column.
3. The remaining fields without a target crop are **spread in turn over the 3 most profitable crops** (yield × best
sell price) that the farm's machines can both sow and harvest. Crops are judged over the whole year: preparation
runs right away, sowing waits for the crop's sowing season.
- **[All automatic]** turns every field (except contracts) **[On]**, releases it to chains and makes a plan:
1. **The farm's own use is recalculated:** the needs of barns and factories over 12 months, converted to hectares,
plus the **surplus** from the setting *Surplus for the farm's own use* (default 10 %, kept as a buffer in silo).
2. The need is covered with the fields that **fit best in size** — the smallest field that covers it, otherwise the
largest and so on. Fields already growing the crop (e.g. grass for a grass need) are taken first, so nothing is
ploughed needlessly. Those fields show **[Farm]** in the Auto column.
3. **The rest become cash crops**, spread evenly in hectares over the 3 most profitable crops (yield × best sell
price) the farm's machines can sow and harvest. Surplus grass fields are mown a last time and then re-sown.
- **[All automatic + reset my choices]** does the same, but also recalculates the crops you chose yourself.
Grass fields, contracts and fields where you chose the crop yourself keep their crop. The button waits until the
field scan after loading is done. The log shows which field got what.
Contracts and meadows are never touched; without "reset" neither are fields where you chose the crop. Crops are
judged over the whole year: preparation runs right away, sowing waits for the season. The button waits until the
field scan is done and changes no crops if the farm can't be read in full. Once used, the plan is redone when the
farm buys or sells fields (setting *All automatic: new plan when fields are bought/sold*). The log shows needs and
the allocation.
### Pick and forget: a crop on the field