-- "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(ADUtil.farmId(), 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(ADUtil.farmId(), adEnv, {enableIds = {}, replan = true}) end