From 92ed8faeda18bf6af1c4d07bad13f5e8eaeee563 Mon Sep 17 00:00:00 2001 From: masterdraco Date: Sun, 18 Oct 2026 00:18:13 +0200 Subject: [PATCH] =?UTF-8?q?fix:=20kopieret=20kursus=20tjekkes=20mod=20mark?= =?UTF-8?q?ens=20omrids=20+=20sk=C3=A5r-sikring=20f=C3=B8r=20jordbearbejdn?= =?UTF-8?q?ing=20(1.62.332)?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit - adFieldWork: sourceCourse validerer gemt/maskinens kursus mod info.verts (ADFieldWork.courseOnField, mindst 50 % af punkterne på marken eller inden for 15 m); ellers laver Courseplay et nyt kursus. In-game 17/10 23:53: F42's læssevogn kørte BiG M 450's F100-kursus; F36/F39 fik samme kursus fra én skårlægger. - adWindrowCheck: soilGuard/soilGuardFor — harve/plov/såning/mulcher sendes ikke ud med >= 5000 l græs-/høskår; marken går tilbage til opsamling (højst 2 gange, derefter Fra). adFieldJobs.soilGuard anvender det. - Review-rettelser: Fra via ADFieldModel.stop (passiv mark), tæller kun efter anvendelse, plan uden opsamlingstrin -> Fra, ceil i sampling, engangslog ved ukontrollerbart kursus, lastDecision, windDownHelpers, pcall. - Tests: SG1-SG15, CF1-CF10, SG-J1-J7; manualer + changelog. --- CHANGELOG.md | 1 + FS25_ADSmartPickup/adFieldJobs.lua | 44 ++++++++++++++ FS25_ADSmartPickup/adFieldWork.lua | 83 ++++++++++++++++++++++----- FS25_ADSmartPickup/adWindrowCheck.lua | 54 ++++++++++++++++- FS25_ADSmartPickup/modDesc.xml | 2 +- docs/BRUGERMANUAL.md | 5 ++ docs/USER_MANUAL.md | 5 ++ 7 files changed, 179 insertions(+), 15 deletions(-) diff --git a/CHANGELOG.md b/CHANGELOG.md index c953b72..c67e6ef 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -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.332** To fejl fra 17/10 23:53–00:06: (1) **Kopieret kursus på en anden mark.** Læssevognen kører skårlæggerens (eller rivens/høsterens) kursus; de huskede kopier er væk efter genindlæsning, så den faldt tilbage på maskinens *nuværende* kursus — og havde skårlæggeren siden slået en anden mark, kørte læssevognen dér (F42's vogn kørte BiG M 450's F100-kursus; F36 og F39 fik samme kursus fra én skårlægger). Nu tjekkes kurset mod markens omrids (mindst halvdelen af punkterne på marken eller inden for 15 m), ellers laver Courseplay et nyt (loggen: *"… kursus ligger på en anden mark — Courseplay laver et nyt kursus"*). (2) **Sikring før jordbearbejdning:** harve, plov, såmaskine eller mulcher sendes ikke ud på en mark med mindst 5.000 l græs-/høskår — marken går tilbage til opsamling (højst to gange, derefter sættes den på Fra med besked). F36 gik ellers til harvning med græsset liggende efter en "færdig" læssevogn på det forkerte kursus. - **1.62.331** Skår-tjek: før en vender, rive eller opsamler sendes ud (faserne vendes/rives/samles op/halm samles), læses spillets højdekort over markens omrids — ligger der ingen skår (under 200 l), springes trinnet over, som var det gjort (brugerspørgsmål 17/10 19:38: 4 mio. l hø samlet i hånden; ellers kørte opsamlerne ud, fandt intet og stoppede først efter 3 min). Svaret gemmes 2 min pr. mark; kontraktmarker tjekkes ikke. Nyt modul adWindrowCheck.lua. - **1.62.330** Rodårsagen til F39/F42 (17/10 18:33 og 19:27): et **frakoblet** redskabs AD-parkering blev ikke fundet i spilleropslaget (AutoDrive.getAllUnits kender ikke et løst redskab), så riven "GA 4731" stod "uden parkering", og spilleren blev bedt koble den på — mens puljen, der læser parkeringen direkte, hentede den selv. Parkeringen læses nu fra redskabet selv først. - **1.62.329** Spillerkørsel: en spilleropgave, spilleren ikke er begyndt på, slippes igen, når gården selv kan klare rollen (et sæt med parkering, eller et puljeredskab med parkering — også når det er i brug, så marken venter i kø). In-game 17/10 18:33: F39 bad spilleren koble GA 4731 på, mens riven hang på Tømmevogn 7 på vej til sin parkering; puljen rev bagefter F40 med samme rive, men F39 hang på spilleren i en halv time. Loggen skriver nu også, hvorfor spilleren spørges ("spilleren spørges om rake: 'Tømmevogn 7' uden parkering"). diff --git a/FS25_ADSmartPickup/adFieldJobs.lua b/FS25_ADSmartPickup/adFieldJobs.lua index 5580d52..37270dd 100644 --- a/FS25_ADSmartPickup/adFieldJobs.lua +++ b/FS25_ADSmartPickup/adFieldJobs.lua @@ -218,6 +218,39 @@ function ADFieldJobs.distanceToPolygon(x, z, verts) return best end + +-- Skår på marken, da jordbearbejdningen skulle sendes ud: tilbage til opsamling ("collect") eller marken på Fra ("off"). +-- Marken skal have et opsamlingstrin i sin plan (review: en høstmark eller en slåafgrøde med product = "harvest" har +-- ikke "collecting" i kæden); ellers sættes den på Fra ligesom efter for mange forsøg. Stoppes som fra menuen +-- (ADFieldModel.stop: trin -> idle/ready, held, mode = manual), så den bliver passiv og ikke tygger videre hvert sekund. +function ADFieldJobs.soilGuard(adEnv, field, info, guard, liters) + local text + local stages = ADFieldModel.workStages(field.plan, field.kind, info.needs, field.lastFruit) or {} + local hasCollecting = false + for _, stage in ipairs(stages) do if stage == "collecting" then hasCollecting = true end end + if guard == "collect" and hasCollecting then + ADFieldJobs.setField(ADFieldModel.with(field, {stage = "collecting", retryAt = 0, reason = false})) + if ADWindrowCheck.soilGuardApplied ~= nil then ADWindrowCheck.soilGuardApplied(info.id) end + text = string.format("%s -> collecting: der ligger stadig mindst %d l skår på marken — opsamling først", + tostring(field.stage), math.floor((liters or 0) + 0.5)) + else + ADFieldJobs.forgetFinished(info.id) + ADFieldJobs.setField(ADFieldModel.stop(field)) + if ADWindrowCheck.forget ~= nil then ADWindrowCheck.forget(info.id) end + text = hasCollecting + and string.format("F%s: der ligger stadig mindst %d l skår efter %d ekstra opsamlinger — marken er sat på Fra, saml resten selv", + tostring(info.id), math.floor((liters or 0) + 0.5), ADWindrowCheck.SOIL_GUARD_PASSES) + or string.format("F%s: der ligger mindst %d l skår på marken, men planen har intet opsamlingstrin — marken er sat på Fra, saml dem selv", + tostring(info.id), math.floor((liters or 0) + 0.5)) + ADFieldJobs.notify(text, true) + end + ADFieldJobs.waitingSince[info.id] = nil + if ADFieldWork ~= nil and ADFieldWork.windDownHelpers ~= nil then pcall(ADFieldWork.windDownHelpers, adEnv, info.id, field.stage) end + if #ADFieldJobs.assignmentsFor(info.id) > 0 and ADFieldWork ~= nil and ADFieldWork.stopAll ~= nil then pcall(ADFieldWork.stopAll, adEnv, info.id) end + ADFieldJobs.log(info.id, "%s", text) + ADFieldJobs.save() +end + -- Det skannede omrids er grovt (4-6 hjørner), og en læssevogn på forageren står ofte lige uden for det -- (in-game 6/10: 6230 TTV 3+4 på F7 blev ikke genkendt efter genindlæsning, og F7 fik en 3. læssevogn). -- Derfor: maskinen ELLER dens huskede CP-waypoint (extra) inde på marken, ellers nærmeste mark inden for margen. @@ -740,8 +773,19 @@ local function stepField(adEnv, info, env) local okSkip, skip = pcall(ADWindrowCheck.skipsStage, adEnv, field, info) if okSkip and skip then decision = {action = "advance", role = decision.role, noWindrow = true} end end + -- jordbearbejdning med skår på marken (17/10 00:06: F36 til harvning med græsset liggende): opsamling først + if decision.action == "dispatch" and ADWindrowCheck ~= nil and ADWindrowCheck.soilGuardFor ~= nil then + local okGuard, guard, liters = pcall(ADWindrowCheck.soilGuardFor, adEnv, field, info) + if okGuard and guard ~= nil then + ADFieldJobs.lastDecision[info.id] = {action = "none", reason = "skår på marken"} + local okApply, err = pcall(ADFieldJobs.soilGuard, adEnv, field, info, guard, liters) + if not okApply then Logging.warning(ADFieldJobs.LOG_PREFIX .. "F%s skår-sikring: %s", tostring(info.id), tostring(err)) end + return + end + end ADFieldJobs.lastDecision[info.id] = decision if decision.action == "start" then + if ADWindrowCheck ~= nil and ADWindrowCheck.forget ~= nil then ADWindrowCheck.forget(info.id) end local started = ADFieldModel.start(field, info.kind, info.needs, info.fruitName) started.lastFruit = info.kind == "harvest" and info.fruitName or field.lastFruit ADFieldJobs.setField(started) diff --git a/FS25_ADSmartPickup/adFieldWork.lua b/FS25_ADSmartPickup/adFieldWork.lua index c534932..2b3bf5d 100644 --- a/FS25_ADSmartPickup/adFieldWork.lua +++ b/FS25_ADSmartPickup/adFieldWork.lua @@ -377,17 +377,74 @@ local function coursesOf(fieldId) return ADFieldJobs.courses[fieldId] end --- Kurset et trin skal genbruge ("mower"/"rake"/"harvester"): gemt kopi, ellers maskinens nuværende kursus. -local function sourceCourse(adEnv, field, source) - local saved = coursesOf(field.id)[source] - if saved ~= nil then return saved end - local vehicleIds = {mower = field.mowVehicleId, rake = field.rakeVehicleId, harvester = field.harvestVehicleId} - local vehicleId = vehicleIds[source] - if vehicleId == nil then return nil end - for _, vehicle in ipairs(ADRunsController.getFarmVehicles(adEnv)) do - if ADRunsController.getVehicleId(vehicle) == vehicleId then return ADCpBridge.getCourse(vehicle) end +-- Hvor stor en del af kursets punkter ligger på marken (inde i omridset eller inden for marginen)? nil uden punkter. +-- Ren funktion til test: insidePolygon(x, z, verts) og distanceToPolygon(x, z, verts) gives med. +ADFieldWork.COURSE_ON_FIELD_MARGIN_M = 15 +ADFieldWork.COURSE_ON_FIELD_MIN = 0.5 +function ADFieldWork.courseOnField(points, verts, insidePolygon, distanceToPolygon, marginM) + if type(points) ~= "table" or #points == 0 or type(verts) ~= "table" or #verts < 3 then return nil end + local margin = marginM or ADFieldWork.COURSE_ON_FIELD_MARGIN_M + local hits = 0 + for _, p in ipairs(points) do + if insidePolygon(p.x, p.z, verts) or (distanceToPolygon ~= nil and distanceToPolygon(p.x, p.z, verts) <= margin) then + hits = hits + 1 + end end - return nil + return hits / #points +end + +-- Op til maxSamples jævnt fordelte vejpunkter (x, z) fra et Courseplay-kursus; tom liste når kurset ikke kan læses. +ADFieldWork.COURSE_SAMPLES = 40 +local function coursePoints(course, maxSamples) + local points = {} + if course == nil or course.getNumberOfWaypoints == nil or course.getWaypoint == nil then return points end + local okN, n = pcall(course.getNumberOfWaypoints, course) + if not okN or type(n) ~= "number" or n < 1 then return points end + local step = math.max(1, math.ceil(n / (maxSamples or ADFieldWork.COURSE_SAMPLES))) + for i = 1, n, step do + local okWp, wp = pcall(course.getWaypoint, course, i) + if okWp and type(wp) == "table" and type(wp.x) == "number" and type(wp.z) == "number" then + table.insert(points, {x = wp.x, z = wp.z}) + end + end + return points +end + +-- Kurset et trin skal genbruge ("mower"/"rake"/"harvester"): gemt kopi, ellers maskinens nuværende kursus. +-- Maskinens nuværende kursus kan høre til en ANDEN mark: de huskede kopier er væk efter genindlæsning, og +-- slåmaskinen har siden slået et andet sted (in-game 17/10: F42's læssevogn kørte BiG M 450's F100-kursus, +-- og F36/F39 fik det samme kursus fra én slåmaskine). Derfor tjekkes kurset mod markens omrids (info.verts). +local courseUncheckedLogged = {} -- fieldId -> {source = true} +local function sourceCourse(adEnv, field, info, source) + local course, origin = coursesOf(field.id)[source], "gemt" + if course == nil then + local vehicleIds = {mower = field.mowVehicleId, rake = field.rakeVehicleId, harvester = field.harvestVehicleId} + local vehicleId = vehicleIds[source] + if vehicleId == nil then return nil end + for _, vehicle in ipairs(ADRunsController.getFarmVehicles(adEnv)) do + if ADRunsController.getVehicleId(vehicle) == vehicleId then + course, origin = ADCpBridge.getCourse(vehicle), "maskinens nuværende" + break + end + end + end + if course == nil then return nil end + local verts = info ~= nil and info.verts or nil + local onField = ADFieldWork.courseOnField(coursePoints(course), verts, ADFieldJobs.insidePolygon, ADFieldJobs.distanceToPolygon) + if onField == nil then + -- kan ikke bedømmes (omrids ukendt eller kurset uden læsbare punkter): kurset bruges som før, men sig det én gang pr. mark + courseUncheckedLogged[field.id] = courseUncheckedLogged[field.id] or {} + if not courseUncheckedLogged[field.id][source] then + courseUncheckedLogged[field.id][source] = true + log(field.id, "%s %s-kursus kunne ikke tjekkes mod markens omrids — bruges som det er", origin, source) + end + elseif onField < ADFieldWork.COURSE_ON_FIELD_MIN then + log(field.id, "%s %s-kursus ligger på en anden mark (%d %% af punkterne på marken) — Courseplay laver et nyt kursus", + origin, source, math.floor(onField * 100 + 0.5)) + if origin == "gemt" then coursesOf(field.id)[source] = nil end + return nil + end + return course end local function copyCourse(course) @@ -1221,10 +1278,10 @@ local function beginBaleCollector(adEnv, field, info, assignment) end -- Multi-tool: følgere venter på lederens kursus for trinnet og kopierer det med deres bane. -local function courseOptions(adEnv, field, assignment) +local function courseOptions(adEnv, field, info, assignment) local source = ADFieldModel.courseSource(field, assignment.role) if source ~= nil then - local course = sourceCourse(adEnv, field, source) + local course = sourceCourse(adEnv, field, info, source) if course == nil then log(field.id, "intet %s-kursus kendt — Courseplay laver et nyt kursus til %s", source, assignment.role) end @@ -1423,7 +1480,7 @@ local function beginWork(adEnv, field, info, assignment) end assignment.unfoldedForWidth = nil applyCourseTweaks(field, info, assignment, vehicle) - local opts, source = courseOptions(adEnv, field, assignment) + local opts, source = courseOptions(adEnv, field, info, assignment) if opts == nil then -- følger uden lederens kursus endnu if assignment.phase ~= "waitingCourse" then diff --git a/FS25_ADSmartPickup/adWindrowCheck.lua b/FS25_ADSmartPickup/adWindrowCheck.lua index ce75ac1..fa8a410 100644 --- a/FS25_ADSmartPickup/adWindrowCheck.lua +++ b/FS25_ADSmartPickup/adWindrowCheck.lua @@ -14,6 +14,13 @@ ADWindrowCheck.MAX_CELLS = 2500 -- større marker tjekkes ikke (0 = alt tj -- Faser hvor skårene er forudsætningen ADWindrowCheck.STAGES = {tedding = true, raking = true, collecting = true, strawCollecting = true} +-- Jordbearbejdning der ødelægger skår, som stadig ligger på marken (in-game 17/10 00:06: F36 gik til harvning efter +-- en læssevogn på et kursus fra en anden mark — "der ligger græs over det hele"). Mindst SOIL_GUARD_LITERS græs-/ +-- høskår på marken sender den tilbage til opsamling, højst SOIL_GUARD_PASSES gange; derefter sættes marken på Fra. +ADWindrowCheck.SOIL_STAGES = {cultivating = true, plowing = true, sowing = true, mulching = true} +ADWindrowCheck.SOIL_GUARD_LITERS = 5000 +ADWindrowCheck.SOIL_GUARD_PASSES = 2 + -- Omridsets kasse -> felter (parallelogrammer som spillet vil have dem) med midtpunkt inde i omridset. -- verts = {{x, z}} -> {{sx, sz, wx, wz, hx, hz}} function ADWindrowCheck.cells(verts, cellM, insidePolygon) @@ -67,9 +74,22 @@ function ADWindrowCheck.shouldSkip(s) return (s.liters or 0) < ADWindrowCheck.MIN_LITERS end +-- Jordbearbejdning med skår på marken? s = {stage, contract, liters, fillTypes, cells, reads, passes} +-- -> "collect" (tilbage til opsamling), "off" (for mange forsøg: marken sættes på Fra) eller nil (kør videre). +-- Aldrig på kontraktmarker, og kun når spillet faktisk svarede (reads > 0) og der lå mindst SOIL_GUARD_LITERS. +function ADWindrowCheck.soilGuard(s) + if s == nil or not ADWindrowCheck.SOIL_STAGES[s.stage] then return nil end + if s.contract then return nil end + if (s.fillTypes or 0) == 0 or (s.cells or 0) == 0 or (s.reads or 0) == 0 then return nil end + if (s.liters or 0) < ADWindrowCheck.SOIL_GUARD_LITERS then return nil end + if (s.passes or 0) >= ADWindrowCheck.SOIL_GUARD_PASSES then return "off" end + return "collect" +end + -- ---- spil-adapter ---- -local cache = {} -- fieldId -> {at, stage, liters} +local cache = {} -- fieldId -> {at, stage, skip} +local soilCache = {} -- fieldId -> {at, stage, liters, reads, fillTypes, cells} local function now() if ADUtil ~= nil and ADUtil.now ~= nil then return ADUtil.now() end @@ -134,6 +154,38 @@ function ADWindrowCheck.skipsStage(adEnv, field, info) return skip end +-- Skår på marken før jordbearbejdning: -> afgørelse ("collect"/"off"/nil), liter. Målt igen pr. CACHE_MS; antal +-- gange marken er sendt tilbage huskes pr. mark (nulstilles ved genindlæsning — højst to ekstra ture pr. session). +local soilPasses = {} +function ADWindrowCheck.soilGuardFor(adEnv, field, info) + if field == nil or info == nil or not ADWindrowCheck.SOIL_STAGES[field.stage] or field.contract then return nil, 0 end + if DensityMapHeightUtil == nil or DensityMapHeightUtil.getFillLevelAtArea == nil then return nil, 0 end + local t = now() + local entry = soilCache[field.id] + if entry == nil or entry.stage ~= field.stage or t - entry.at >= ADWindrowCheck.CACHE_MS then + local fillTypes = ADWindrowCheck.fillTypesFor(field, info, nil) + local cells = ADWindrowCheck.cells(info.verts, ADWindrowCheck.CELL_M) + local liters, reads = 0, 0 + if #fillTypes > 0 and #cells > 0 and (ADWindrowCheck.MAX_CELLS <= 0 or #cells <= ADWindrowCheck.MAX_CELLS) then + liters, reads = litersOnField(cells, fillTypes, ADWindrowCheck.SOIL_GUARD_LITERS) + end + entry = {at = t, stage = field.stage, liters = liters, reads = reads, fillTypes = #fillTypes, cells = #cells} + soilCache[field.id] = entry + end + local decision = ADWindrowCheck.soilGuard({stage = field.stage, contract = field.contract, liters = entry.liters, + fillTypes = entry.fillTypes, cells = entry.cells, reads = entry.reads, passes = soilPasses[field.id]}) + return decision, entry.liters +end + +-- Marken ER sendt tilbage til opsamling (review: en fejl i anvendelsen må ikke bruge et forsøg): tæl forsøget og mål igen næste gang. +function ADWindrowCheck.soilGuardApplied(fieldId) + soilPasses[fieldId] = (soilPasses[fieldId] or 0) + 1 + soilCache[fieldId] = nil +end + +-- Glem alt om marken (ny omgang, stoppet, tilbage til ready): målinger og forsøgstæller. function ADWindrowCheck.forget(fieldId) cache[fieldId] = nil + soilCache[fieldId] = nil + soilPasses[fieldId] = nil end diff --git a/FS25_ADSmartPickup/modDesc.xml b/FS25_ADSmartPickup/modDesc.xml index 4a9d2be..e56121a 100644 --- a/FS25_ADSmartPickup/modDesc.xml +++ b/FS25_ADSmartPickup/modDesc.xml @@ -1,7 +1,7 @@ masterdraco - 1.62.331.0 + 1.62.332.0 <en>AD Smart Pickup</en> diff --git a/docs/BRUGERMANUAL.md b/docs/BRUGERMANUAL.md index ed86afe..574724a 100644 --- a/docs/BRUGERMANUAL.md +++ b/docs/BRUGERMANUAL.md @@ -1552,6 +1552,11 @@ Har du flere skærebord, tager modden det nærmeste, der kan høste afgrøden. - **Ingen skår, intet arbejde:** før en vender, rive eller opsamler sendes ud, kigger moden efter skår på marken (spillets højdekort). Ligger der ingen — fx fordi du selv har samlet høet — springes trinnet over, som var det gjort (loggen: *"ingen skår på marken — collecting springes over"*). Kontraktmarker tjekkes ikke. +- **Skår før jordbearbejdning:** harve, plov, såmaskine eller mulcher sendes ikke ud, mens der ligger mindst + 5.000 l græs- eller høskår på marken — marken går tilbage til opsamling (loggen: *"cultivating -> collecting: der + ligger stadig mindst … l skår"*). Sker det to gange, sættes marken på **Fra** med en besked: saml resten selv. +- **Kopieret kursus skal passe til marken:** læssevognen kører skårlæggerens/rivens kursus. Ligger det kursus på en + anden mark (fx fordi skårlæggeren har slået et andet sted siden), laver Courseplay et nyt i stedet. ### Vejr, påfyldning og beskeder diff --git a/docs/USER_MANUAL.md b/docs/USER_MANUAL.md index 57342d2..072aab8 100644 --- a/docs/USER_MANUAL.md +++ b/docs/USER_MANUAL.md @@ -1600,6 +1600,11 @@ If you have several headers, the mod takes the nearest one that can harvest the - **No windrows, no work:** before a tedder, rake or loader wagon is sent out, the mod checks the field for windrows (the game's height map). If there are none — e.g. because you collected the hay yourself — the step is skipped as if done (log: *"ingen skår på marken — collecting springes over"*). Contract fields are not checked. +- **Windrows before soil work:** a cultivator, plough, seeder or mulcher is not sent out while at least 5,000 l of + grass or hay windrows lie on the field — the field goes back to collecting (log: *"cultivating -> collecting: der + ligger stadig mindst … l skår"*). If that happens twice, the field is switched **off** with a message: collect the rest yourself. +- **A copied course must fit the field:** the loader wagon drives the mower's/rake's course. If that course lies on + another field (e.g. the mower has mown elsewhere since), Courseplay generates a new one instead. ### Weather, refilling and messages