From 8074f5aebb484a1dd727106160157c54473e5882 Mon Sep 17 00:00:00 2001 From: masterdraco Date: Mon, 19 Oct 2026 12:39:57 +0200 Subject: [PATCH] =?UTF-8?q?fix:=20dr=C3=A5bevis=20afl=C3=A6sning=20behandl?= =?UTF-8?q?es=20som=20fuldt=20m=C3=A5l=20(1.62.375)?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- CHANGELOG.md | 1 + FS25_ADSmartPickup/adStrayUnload.lua | 20 +++++---- FS25_ADSmartPickup/adUnloadWait.lua | 65 +++++++++++++++++++++++++--- FS25_ADSmartPickup/modDesc.xml | 2 +- 4 files changed, 74 insertions(+), 14 deletions(-) diff --git a/CHANGELOG.md b/CHANGELOG.md index 7b63339..59a6bf1 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.375** Dråbevis aflæsning = fuldt mål: holder en vogn ved målet, og der kommer under 2.000 l/min af (og den ville være over 30 min om at blive tom), behandles målet som fuldt efter 3 min — en flow-vogn kører til Wait eller et andet mål (kun når det betaler sig) og prøver tidligst igen efter 10 min; en vogn uden flow tømmes på et lager (in-game 19/10 12:35: 8280 TTV med 511.950 l alfalfa ved Large Steel Silo Input, 1.300 l på 7 min, vognene bag holdt 14+ min). Store vogne, der tømmer normalt, afbrydes ikke; AD's blinkende tippe-flag nulstiller ikke tiden. - **1.62.374** Gylle som gødning: salget holder kun gylle tilbage til marker med en afgrøde i vækst, der mangler gødning (de marker flåden faktisk gøder) — ikke hele sæsonens behov. Er der ingen (fx efter høst), sælges al gyllen, så stalden ikke stopper (brugerønske 19/10 12:32). - **1.62.373** Manuel mejetærsker uden skærebord vælges kun, når gården har et ledigt skærebord (frakoblet eller på skærebordsvogn, ikke reserveret), der passer til den og kan tage afgrøden (in-game 19/10 12:14: F7 med gulerødder bad spilleren køre 'Mejetærsker 6' ud, selv om intet af dens skærebord kan høste gulerødder). En opgave der allerede venter på spilleren vælges ikke om — stop og start marken. - **1.62.372** Oprydning: gårdens egen gylle/digestat/møg på en udbringer sælges, når "Gylle som gødning" er slået fra (brugerønske 19/10 12:07 — 'Series 8 TTV 9' blev parkeret med 976.260 l gylle); med indstillingen til bliver den på vognen til markerne. Købt gødning, kalk og frø sælges stadig aldrig. diff --git a/FS25_ADSmartPickup/adStrayUnload.lua b/FS25_ADSmartPickup/adStrayUnload.lua index 7831ffa..226408c 100644 --- a/FS25_ADSmartPickup/adStrayUnload.lua +++ b/FS25_ADSmartPickup/adStrayUnload.lua @@ -26,9 +26,12 @@ function ADStrayUnload.isFull(free, capacity) return type(free) == "number" and type(capacity) == "number" and capacity > 0 and free < ADStrayUnload.MIN_FREE end --- Er der aflæsset nok siden mark til, at tiden starter forfra? -function ADStrayUnload.progressed(mark, rest) - return type(mark) == "number" and type(rest) == "number" and mark - rest >= ADStrayUnload.PROGRESS_LITERS +-- Dryp: ville vognen med farten (dropped l på heldMs) være tom senere end ETA_MS? Ingen fart = dryp. +ADStrayUnload.ETA_MS = 30 * 60 * 1000 +ADStrayUnload.RATE_LPM = 2000 -- absolut fartgrænse (som ADUnloadWait.DRIP_RATE_LPM) +function ADStrayUnload.dripping(dropped, heldMs, rest) + if (dropped or 0) <= 0 or (heldMs or 0) <= 0 then return true end + return dropped * 60000 / heldMs < ADStrayUnload.RATE_LPM and (rest or 0) * heldMs / dropped > ADStrayUnload.ETA_MS end -- ---- spil-adapter ---- @@ -36,9 +39,6 @@ end local timerMs = 0 local held = setmetatable({}, {__mode = "k"}) -- køretøj -> ms ved fuldt mål local restMark = setmetatable({}, {__mode = "k"}) -- køretøj -> liter da tiden sidst startede forfra --- Så meget skal læsset falde, før tiden starter forfra: et fuldt mål, der kun æder lidt (oliemølle: ~3 l/15 s), er --- stadig fuldt (review før: hver liter nulstillede tiden) -ADStrayUnload.PROGRESS_LITERS = 1000 ADStrayUnload.GRACE_MS = 15000 local gap = setmetatable({}, {__mode = "k"}) -- køretøj -> ms uden "fast" mens tiden løber @@ -114,11 +114,15 @@ function ADStrayUnload.tick(adEnv, dt) if not stuck and not keep then restMark[vehicle], held[vehicle], gap[vehicle] = nil, nil, nil elseif stuck then - -- læsset falder mærkbart: den aflæsser — tæl forfra - if restMark[vehicle] == nil or ADStrayUnload.progressed(restMark[vehicle], rest) then restMark[vehicle], held[vehicle] = rest, 0 end + if restMark[vehicle] == nil then restMark[vehicle], held[vehicle] = rest, 0 end held[vehicle] = (held[vehicle] or 0) + elapsed end local action = stuck and ADStrayUnload.step({stuck = true, heldMs = held[vehicle], limitMs = (tonumber(minutes) or 0) * 60000}) or "wait" + -- tiden er gået: tømmer den for alvor (tom inden for ADUnloadWait.DRIP_ETA_MS med den nuværende fart)? Så nyt vindue. + -- Ellers er det dryp (in-game 19/10 12:35: ~180 l/min med 511.000 l nulstillede den gamle 1.000 l-grænse hele tiden) + if action == "act" and not ADStrayUnload.dripping(restMark[vehicle] - rest, held[vehicle], rest) then + restMark[vehicle], held[vehicle], action = rest, 0, "wait" + end if action == "act" then held[vehicle], restMark[vehicle], gap[vehicle] = nil, nil, nil local okAct, err = pcall(act, adEnv, vehicle, targetName, rest, fillType, minutes, targetId) diff --git a/FS25_ADSmartPickup/adUnloadWait.lua b/FS25_ADSmartPickup/adUnloadWait.lua index b838216..c21566d 100644 --- a/FS25_ADSmartPickup/adUnloadWait.lua +++ b/FS25_ADSmartPickup/adUnloadWait.lua @@ -29,6 +29,25 @@ ADUnloadWait.LOG_PREFIX = "ADSmartPickup: " -- køretøj -> {task, homeDestinationID, waitMarker, fillType, rest} local waits = setmetatable({}, {__mode = "k"}) local warnedNoWaitPoint = setmetatable({}, {__mode = "k"}) +local dripMarks = setmetatable({}, {__mode = "k"}) -- køretøj -> {rest, at}: læsset da den kom til målet + +-- Tømmer vognen kun dråbevis? Et mål med lidt plads, der kun æder lidt ad gangen (gæringssilo, oliemølle), tømmer en +-- stor vogn aldrig — og vognene bag holder (in-game 19/10 12:35: 8280 TTV ved Large Steel Silo Input, 1.300 l af på +-- 7 min med 511.000 l på vognen). s = {dropped, heldMs, rest, minMs, etaMs}: efter minMs ved målet tømmer den +-- langsommere end DRIP_RATE_LPM OG ville være tom senere end etaMs -> true = behandles som fuldt mål. Fartgrænsen er +-- absolut (review 19/10: et ETA-krav alene ramte store vogne, der tømte helt normalt — 941.000 l ved 12.000 l/min) +ADUnloadWait.DRIP_MIN_MS = 3 * 60 * 1000 +ADUnloadWait.DRIP_ETA_MS = 30 * 60 * 1000 +ADUnloadWait.DRIP_RATE_LPM = 2000 +ADUnloadWait.DRIP_GAP_MS = 15000 -- så længe væk fra målet (AD's tippe-flag blinker) før vinduet starter forfra +ADUnloadWait.DRIP_RETURN_MS = 10 * 60 * 1000 -- dråbevis mål: tidligst tilbage efter så lang tid ved Wait +function ADUnloadWait.isDripping(s) + if (s.heldMs or 0) < (s.minMs or ADUnloadWait.DRIP_MIN_MS) then return false end + local dropped = s.dropped or 0 + if dropped <= 0 then return true end + local perMinute = dropped * 60000 / s.heldMs + return perMinute < ADUnloadWait.DRIP_RATE_LPM and (s.rest or 0) * s.heldMs / dropped > (s.etaMs or ADUnloadWait.DRIP_ETA_MS) +end local isInstalled = false -- Den vare og mængde der er tilbage på vognen (største fyldte aflæsselige enhed). @@ -269,7 +288,7 @@ local function startWaiting(adEnv, task) -- tæller IKKE med: ved et fuldt fodertrug bliver isUnloading stående for evigt, selv om -- intet løber — og så blokerede traktoren stalden i stedet for at køre til Wait. if not isAtUnloadTarget(adEnv, vehicle) then - return + return -- dryp-vinduet ryddes ikke her (tippe-flaget blinker); et gammelt vindue forkastes ved næste tjek end -- Efter et bytte er opgavens mål en silo, ikke AD's rigtige aflæsningsmål (anden markør); -- der skal AD bare læsse af som normalt, uden Wait-logik. @@ -317,13 +336,39 @@ local function startWaiting(adEnv, task) if isRejected then free = 0 end - if free == nil or free >= ADUnloadWait.MIN_FREE_TO_UNLOAD then + local dripping = false + if free ~= nil and free >= ADUnloadWait.MIN_FREE_TO_UNLOAD then + -- plads, men tømmer den overhovedet? (dråbevis = som fuldt; ellers lad AD tippe) + local nowMs = ADUtil.now() + local mark = dripMarks[vehicle] + -- nyt vindue: første gang, andet mål/vare, mere læs på, eller væk fra målet over DRIP_GAP_MS (review 19/10) + if mark == nil or mark.targetId ~= target.id or mark.fillType ~= fillType or rest > mark.rest + or nowMs - (mark.seen or mark.at) > ADUnloadWait.DRIP_GAP_MS then + dripMarks[vehicle] = {rest = rest, at = nowMs, seen = nowMs, targetId = target.id, fillType = fillType} + return + end + mark.seen = nowMs + local heldMs = nowMs - mark.at + if not ADUnloadWait.isDripping({dropped = mark.rest - rest, heldMs = heldMs, rest = rest}) then + -- tømmer for alvor (eller endnu for tidligt at sige): nyt vindue, når det gamle er brugt + if heldMs >= ADUnloadWait.DRIP_MIN_MS then + dripMarks[vehicle] = {rest = rest, at = nowMs, seen = nowMs, targetId = target.id, fillType = fillType} + end + return + end + dripMarks[vehicle] = nil + dripping = true + Logging.info(ADUnloadWait.LOG_PREFIX .. "'%s' tømmer kun dråbevis ved %s (%.0f l på %d min, %.0f l tilbage) — behandles som fuldt mål", + tostring(ADRuns.vehicleLabel(vehicle)), tostring(target.name), mark.rest - rest, math.floor(heldMs / 60000), rest) + elseif free == nil then return end -- Run med flere mål: resten køres til det af run'ets andre mål der har mest plads til varen, -- før der ventes (en 2,4M l-vogn kan ellers aldrig komme af med resten ved én svinesti) local other, otherFree = findOtherTargetForRest(adEnv, vehicle, fillType, target.id) + -- dråbevis: målet har måske mere plads end det andet — kun videre, når det betaler sig (ellers frem og tilbage) + if other ~= nil and dripping and not ADUnloadWait.isWorthLeavingWait(otherFree, free, rest) then other = nil end if other ~= nil then vehicle.ad.stateModule:setSecondMarkerByWayPointId(other.id) redirect(task, other.id) @@ -356,12 +401,20 @@ local function startWaiting(adEnv, task) end warnedNoWaitPoint[vehicle] = nil ADWaitPool.claim(candidate.marker.id, vehicle) - waits[vehicle] = {task = task, homeDestinationID = task.destinationID, waitMarker = candidate.marker, fillType = fillType, rest = rest} + -- dråbevis: målet melder plads, men tager næsten intet — ikke straks tilbage (ellers frem og tilbage mellem Wait og målet) + waits[vehicle] = {task = task, homeDestinationID = task.destinationID, waitMarker = candidate.marker, fillType = fillType, rest = rest, + dripHoldMs = dripping and 0 or nil} -- AD tipper (og holder vognen stille) så længe den står nær sit EGET mål — også i små -- portioner, når målet forbruger løbende. Derfor peger AD's mål på Wait-punktet imens. redirectForUnload(task, candidate.marker.id) local fillTypeName = g_fillTypeManager ~= nil and g_fillTypeManager:getFillTypeNameByIndex(fillType) or tostring(fillType) - Logging.info(ADUnloadWait.LOG_PREFIX .. "'%s' venter ved %s (markør %s): %.0f l %s rest, målet har kun %.0f l fri", tostring(ADRuns.vehicleLabel(vehicle)), tostring(candidate.marker.name), tostring(candidate.marker.markerIndex or candidate.marker.id), rest, tostring(fillTypeName), free) + if dripping then + Logging.info(ADUnloadWait.LOG_PREFIX .. "'%s' venter ved %s (markør %s): %.0f l %s rest — målet tager kun dråbevis imod (melder %.0f l fri); tidligst tilbage om %d min", + tostring(ADRuns.vehicleLabel(vehicle)), tostring(candidate.marker.name), tostring(candidate.marker.markerIndex or candidate.marker.id), rest, + tostring(fillTypeName), free, math.floor(ADUnloadWait.DRIP_RETURN_MS / 60000)) + else + Logging.info(ADUnloadWait.LOG_PREFIX .. "'%s' venter ved %s (markør %s): %.0f l %s rest, målet har kun %.0f l fri", tostring(ADRuns.vehicleLabel(vehicle)), tostring(candidate.marker.name), tostring(candidate.marker.markerIndex or candidate.marker.id), rest, tostring(fillTypeName), free) + end end -- Ventende køretøj: er der nu plads til hele resten, køres tilbage til målet. @@ -413,7 +466,9 @@ local function updateWaiting(adEnv, task, wait, dt) -- run'ets "kør hjem under X %" (fri ≥ (100-X) % af kapaciteten), ellers standardreglen local run = ADRunsController ~= nil and activeRunOf(vehicle) or nil local freeFraction = run ~= nil and run.returnBelowPercent ~= nil and (1 - run.returnBelowPercent / 100) or nil - if free == nil or not ADSupplyPlanner.canUnloadRest(free, rest, capacity, freeFraction) then + if wait.dripHoldMs ~= nil then wait.dripHoldMs = wait.dripHoldMs + (dt or 0) end + local dripHold = wait.dripHoldMs ~= nil and wait.dripHoldMs < ADUnloadWait.DRIP_RETURN_MS + if dripHold or free == nil or not ADSupplyPlanner.canUnloadRest(free, rest, capacity, freeFraction) then -- et af run'ets andre mål har plads: kør resten derhen i stedet for at vente på hjemmet (in-game 15/10: -- 941.000 l TMR ventede i timevis ved Farm Wait 1 på Kostald 1, mens Kostald 2 stod uden foder) wait.otherCheckMs = (wait.otherCheckMs or ADUnloadWait.OTHER_TARGET_CHECK_MS) + (dt or 0) diff --git a/FS25_ADSmartPickup/modDesc.xml b/FS25_ADSmartPickup/modDesc.xml index 82be40e..e3d7803 100644 --- a/FS25_ADSmartPickup/modDesc.xml +++ b/FS25_ADSmartPickup/modDesc.xml @@ -1,7 +1,7 @@ masterdraco - 1.62.374.0 + 1.62.375.0 <en>AD Smart Pickup</en>