Files
fs25-adsmartpickup/FS25_ADSmartPickup/adFlowSleep.lua
T

981 lines
52 KiB
Lua

-- AD Flow Sleep
-- Dvale for flows: har alle et flows traktorer holdt ved Wait uden noget at lave i SLEEP_AFTER_MS (tomme, med vogn
-- bagpå), stoppes flowet som med Stop-knappen — vognen sættes på sin parkering og traktoren kører hjem, så begge er
-- ledige for maskinpuljen/markarbejdet — og markeres run.sleeping. Hvert WAKE_CHECK_MS spørges flowets planlægning
-- (udkørsel: ADOutboundPlanner; forsyning: ADSmartPickup.findSupplyPickup) med den parkerede vogn som "køretøj", om
-- der er en tur. Så vækkes flowet: er traktoren lånt ud, tager den nærmeste ledige traktor der kan trække vognen
-- dens plads. Lastbiler med eget lad (mælkebil, pallebil) sover også: de kører til deres egen parkering i stedet for
-- at holde ved Wait, og vækkes på samme måde (aldrig byttet ud). Spilleren der trykker Start/Stop sletter dvalen.
-- Ren logik øverst (testes med luajit), spil-adapter nederst.
ADFlowSleep = {}
ADFlowSleep.LOG_PREFIX = "ADSmartPickup: dvale: "
ADFlowSleep.SLEEP_AFTER_MS = 10 * 60 * 1000 -- tomgang så længe før flowet sover
ADFlowSleep.WAKE_CHECK_MS = 60 * 1000 -- så tit et sovende flow tjekkes for arbejde
ADFlowSleep.TICK_MS = 1000
ADFlowSleep.MIN_CARGO_LITERS = 100 -- mindre end dette på vognen = tom (som ADFlowWagons.EMPTY_MIN_LITERS)
ADFlowSleep.MAX_CHECK_FAILURES = 3 -- arbejdstjek der fejler så mange gange i træk vækker flowet alligevel
-- ---- ren logik ----
-- s = {stopped, vehicles = {{holding, hasWagon, ownBody, cargo} | false}} (false = traktoren findes ikke) -> tomgang?
-- ownBody = lastbil med eget lad: tæller som traktor med vogn.
-- allowCargo: last på vognen er i orden (gødningsreserven: gyllen på vognen er netop det, markerne skal have)
function ADFlowSleep.isIdle(s)
if s.stopped or #(s.vehicles or {}) == 0 then return false end
for _, vehicle in ipairs(s.vehicles) do
if not vehicle or not vehicle.holding or not (vehicle.hasWagon or vehicle.ownBody)
or (not s.allowCargo and (vehicle.cargo or 0) >= ADFlowSleep.MIN_CARGO_LITERS) then
return false
end
end
return true
end
-- Tomgangsuret: starter ved første tomgang, nulstilles (nil) så snart flowet laver noget.
function ADFlowSleep.track(since, isIdle, nowMs)
if not isIdle then return nil end
return since or nowMs
end
function ADFlowSleep.shouldSleep(since, nowMs, afterMs)
return since ~= nil and nowMs - since >= (afterMs or ADFlowSleep.SLEEP_AFTER_MS)
end
-- Flow med lånt traktor (brugerønske 19/10: "burde der ikke være en option ... lån et ledigt køretøj, specielt med
-- sådan en som honning" — for at spare på økonomien): flowet ejer kun sin vogn (run.borrowWagonId). Har det en tur,
-- låner det en ledig traktor, der henter vognen ved Connect; efter turen sover det hurtigt, vognen sættes på plads, og
-- traktoren slippes igen (ikke låst til flowet som en fast traktor).
ADFlowSleep.BORROW_SLEEP_AFTER_MS = 2 * 60 * 1000
function ADFlowSleep.sleepAfterMs(run)
return (run ~= nil and run.borrowWagonId ~= nil) and ADFlowSleep.BORROW_SLEEP_AFTER_MS or ADFlowSleep.SLEEP_AFTER_MS
end
-- s = {borrow, stopped, sleeping, hasTractor, tractorBusy} -> "await" (startet uden traktor: vent i dvale på en tur) |
-- "release" (stoppet/sovende, og traktoren er færdig med vognen) | nil
function ADFlowSleep.borrowAction(s)
if not s.borrow then return nil end
if not s.hasTractor then return (not s.stopped) and "await" or nil end
if (s.stopped or s.sleeping) and not s.tractorBusy then return "release" end
return nil
end
-- Traktoren der lånes. Sidder vognen allerede på en traktor, er det den — hvis den er ledig, ellers ingen (en anden
-- kan ikke hente vognen). Ellers bedst egnede ledige (som ved opvågning). s = {attacher = {id, free} | nil, candidates,
-- wagon, bestFit} -> {id, …} eller nil
function ADFlowSleep.chooseBorrowed(s)
if s.attacher ~= nil then return s.attacher.free and s.attacher or nil end
return ADFlowSleep.chooseTractor({candidates = s.candidates, wagon = s.wagon, bestFit = s.bestFit})
end
-- Holdes et salgs-flow tilbage af gødningsreserven ("… reserveret til markerne (183 ha)")? Så er der intet at
-- vente på ved Wait: flowet sover straks, og traktor + gyllevogn er ledige til gødningen (brugerønske 17/10:
-- "de skal jo ikke sælge gylle imens der gødes"). reasons = planlæggerens grunde (ADOutbound.getRunStatus).
ADFlowSleep.RESERVE_SLEEP_GRACE_MS = 60 * 1000 -- idle så længe før reserve-dvalen (ikke straks efter en opvågning)
function ADFlowSleep.heldForFields(reasons)
for _, reason in ipairs(reasons or {}) do
if type(reason) == "string" and string.find(reason, "reserveret til markerne", 1, true) then return true end
end
return false
end
-- Pause før næste vågn-tjek efter falske opvågninger (vågnede, men sov igen uden en tur): 10 -> 30 -> 60 min.
ADFlowSleep.FALSE_WAKE_BACKOFF_MS = {10 * 60 * 1000, 30 * 60 * 1000, 60 * 60 * 1000}
function ADFlowSleep.wakeBackoffMs(falseWakes)
if (falseWakes or 0) <= 0 then return ADFlowSleep.WAKE_CHECK_MS end
local steps = ADFlowSleep.FALSE_WAKE_BACKOFF_MS
return steps[math.min(falseWakes, #steps)]
end
function ADFlowSleep.isCheckDue(lastCheck, nowMs, falseWakes)
return lastCheck == nil or nowMs - lastCheck >= ADFlowSleep.wakeBackoffMs(falseWakes)
end
-- Falske opvågninger i træk efter en ny dvale. previous = tælleren hvis flowet er vækket af dvalen (nil = første
-- dvale); hadTrip = flowet har haft last på siden opvågningen.
function ADFlowSleep.falseWakesAfterSleep(previous, hadTrip)
if previous == nil or hadTrip then return 0 end
return previous + 1
end
-- ---- hvorfor sover flowet? (in-game 17/10: 'Coop Egg Pickup' stod "sleeping" med fulde hønsehuse, fordi ægprisen
-- lå på 86 % af top mod krævet 90 — men det stod ingen steder) ----
ADFlowSleep.REASON_LOG_MS = 60 * 60 * 1000 -- samme grund logges højst så tit pr. flow
-- Grundtekst til oversigt/log: planlæggerens grund, ellers en kort standard pr. flowtype.
function ADFlowSleep.sleepReasonText(why, kind)
if why ~= nil and why ~= "" then return why end
if kind == "outbound" then return "intet at køre ud med" end
return "intet at hente til målene"
end
-- Skal grunden logges nu? last = {ms, text} fra sidste logning (nil = aldrig). Ny tekst logges straks, samme tekst
-- igen først efter REASON_LOG_MS.
-- Kort form til oversigtens smalle statuscelle: første grund, uden "af top" og uden lager-delen
-- ("EGG 86 % af top (kræver 90), lager 100 %; MILK …" -> "EGG 86 % (kræver 90)"). Hele teksten står i loggen.
function ADFlowSleep.shortReason(text)
if text == nil then return nil end
local first = string.match(text, "^(.-);") or text
first = string.gsub(first, " af top", "")
first = string.gsub(first, ",%s*lager [^,]*$", "")
return first
end
function ADFlowSleep.reasonLogDue(last, nowMs, text)
if last == nil or last.text ~= text then return true end
return nowMs - (last.ms or 0) >= ADFlowSleep.REASON_LOG_MS
end
local function nearest(list, x, z)
local best, bestDistance = nil, math.huge
for _, item in ipairs(list or {}) do
local d = ((item.x or 0) - (x or 0)) ^ 2 + ((item.z or 0) - (z or 0)) ^ 2
if d < bestDistance then best, bestDistance = item, d end
end
return best
end
-- Traktor ved opvågning. s = {own, ownFree, candidates, wagon = {x, z, neededHp}, bestFit?(candidates, wagon)}:
-- egen hvis ledig; ellers bedste ledige (bestFit, ellers nærmeste vognen); ellers egen (startes og venter på den).
function ADFlowSleep.chooseTractor(s)
if s.own ~= nil and s.ownFree then return s.own end
local wagon = s.wagon or {}
local other = nil
if #(s.candidates or {}) > 0 then
other = s.bestFit ~= nil and s.bestFit(s.candidates, wagon) or nearest(s.candidates, wagon.x, wagon.z)
end
return other or s.own
end
-- Ny vehicleIds-liste og vogntabel hvor newId tager oldId's plads og vogn. Originalen røres ikke.
function ADFlowSleep.swapTractor(run, oldId, newId)
local ids, wagons = {}, {}
for _, id in ipairs(run.vehicleIds or {}) do table.insert(ids, id == oldId and newId or id) end
for tractorId, wagonId in pairs(run.wagons or {}) do wagons[tractorId] = wagonId end
if oldId ~= newId then
wagons[newId] = wagons[oldId]
wagons[oldId] = nil
end
return ids, wagons
end
-- Ekstra vogne flyttes fra den gamle traktor til den nye. -> ny tabel
function ADFlowSleep.swapSpares(spares, oldId, newId)
local copy = ADRuns.copySpares(spares)
if oldId ~= newId and copy[oldId] ~= nil then
copy[newId] = copy[oldId]
copy[oldId] = nil
end
return copy
end
-- Arbejdstjekket fejlede: én fejl mere -> ny tæller, vækkes nu? Et tjek der altid fejler må ikke efterlade flowet
-- sovende for altid, men én fejl må heller ikke vække det (ellers vågner og sover det hvert 11. minut).
function ADFlowSleep.onCheckError(failures)
local count = (failures or 0) + 1
return count, count >= ADFlowSleep.MAX_CHECK_FAILURES
end
-- Fik opvågningen mindst én traktor i gang? results = ADRunsController.startRun's poster {ok, reason}.
function ADFlowSleep.anyStarted(results)
for _, result in ipairs(results or {}) do
if result.ok then return true end
end
return false
end
-- Flowets egen hjemtur efter dvale (tømmer/kører hjem) — traktoren er ikke lånt ud, den skal bare bruges igen.
function ADFlowSleep.isOwnTrip(wagonStatus)
return wagonStatus == "homing" or wagonStatus == "emptying"
end
-- Må flowets egen traktor køre turen? s = {exists, lentOut, onOwnTrip, carriesOwnWagon}. Kun lånt ud (markopgave,
-- Courseplay, marksilo, et andet flow) er optaget; flowets egen vogn på eller egen hjemtur er netop rigtigt.
function ADFlowSleep.ownUsable(s)
return s.exists == true and not s.lentOut
end
-- Ledig traktor i et KØRENDE flow (ikke stoppet, ikke i dvale, uendelige runder): AutoDrive slukket, ikke lånt ud og
-- ingen spiller bag rattet. Den første returneres (én start pr. tjek). members = {{id, active, usable, controlled}}.
-- (in-game 15/10: '130 Cow Food and Straw' 2 og 3 holdt stille i timevis, mens nr. 1 ventede med fuldt læs — flowet
-- "kørte", så hverken dvale eller "Start alle" rørte dem)
function ADFlowSleep.pickIdleMember(run, members)
if run == nil or run.stopped or run.sleeping or (run.loops or 0) > 0 then return nil end
for _, member in ipairs(members or {}) do
if not member.active and member.usable and not member.controlled then return member.id end
end
return nil
end
-- Pause efter en start der ikke lykkedes (fx ingen vogn) eller som venter på/henter vognen, så loggen ikke fyldes.
ADFlowSleep.RESTART_FAILED_BACKOFF_MS = 10 * 60 * 1000
-- Har spilleren siddet i traktoren for nylig, er den stoppet med vilje: lad den stå så længe.
ADFlowSleep.MANUAL_GRACE_MS = 10 * 60 * 1000
-- Ingen genstart lige efter indlæsning: AutoDrive genoptager selv aktive traktorer de første sekunder.
ADFlowSleep.RESTART_STARTUP_DELAY_MS = 60 * 1000
function ADFlowSleep.restartNeedsBackoff(result)
return result == nil or not result.ok or result.reason == "waitingWagon" or result.reason == "fetchingWagon"
end
-- Vogn parkeret med læs (brugerønske 19/10): vækkes flowet? Et mål skal kunne tage læsset — truget under tærsklen
-- (allow), triggeren ved markøren tager varen (takes) og fri plads til hele læsset eller mindst den største af
-- MIN_FREE_TO_LEAVE_WAIT og PARK_WAKE_SHARE af læsset (review 19/10: en vogn med 1 mio. l venter til ≥ 250.000 l er
-- fri, ikke 20.000 l — ellers kører den ud, leverer en smule og parkerer igen). entries = {{free, capacity, allow, takes}}
-- Et mål der slet ikke kan rumme så meget, kræver højst PARK_WAKE_CAPACITY_SHARE af sin kapacitet fri (in-game 19/10:
-- 'Chicken Food' med 259.388 l hvede ventede på 64.847 l fri ved hønsehuse med 12.938 l kapacitet — vågnede aldrig)
ADFlowSleep.LOADED_WAKE_MIN_FREE = 20000 -- reserve, hvis ADUnloadWait ikke er indlæst
ADFlowSleep.PARK_WAKE_SHARE = 0.25
ADFlowSleep.PARK_WAKE_CAPACITY_SHARE = 0.5
function ADFlowSleep.loadedWakeNeed(rest)
local minFree = ADUnloadWait ~= nil and ADUnloadWait.MIN_FREE_TO_LEAVE_WAIT or ADFlowSleep.LOADED_WAKE_MIN_FREE
return math.min(rest, math.max(minFree, ADFlowSleep.PARK_WAKE_SHARE * rest))
end
-- Laveste krav til fri plads over målene (til statusteksten). -> liter
function ADFlowSleep.loadedWakeNeedFor(rest, entries, capacityShare)
local need = ADFlowSleep.loadedWakeNeed(rest)
local share = capacityShare or ADFlowSleep.PARK_WAKE_CAPACITY_SHARE
local lowest = need
for _, entry in ipairs(entries or {}) do
if type(entry.capacity) == "number" and entry.capacity > 0 then lowest = math.min(lowest, share * entry.capacity) end
end
return lowest
end
-- capacityShare: andelen af målets kapacitet, der skal være fri — som Wait-reglen (flowets "kør hjem under X %" ->
-- 1 - X/100), ellers PARK_WAKE_CAPACITY_SHARE (review 19/10: ellers vågnede den før Wait-reglen og ventede så ved Wait)
function ADFlowSleep.loadedWakeDue(rest, entries, capacityShare)
if rest == nil or rest <= 0 then return false end
local need = ADFlowSleep.loadedWakeNeed(rest)
local share = capacityShare or ADFlowSleep.PARK_WAKE_CAPACITY_SHARE
for _, entry in ipairs(entries or {}) do
local entryNeed = need
if type(entry.capacity) == "number" and entry.capacity > 0 then
entryNeed = math.min(need, share * entry.capacity)
end
if entry.allow and entry.takes and entry.free ~= nil and entry.free >= entryNeed then return true end
end
return false
end
-- Er traktorens aktive vogn parkeret med læs?
function ADFlowSleep.isParkedMember(run, tractorId)
local wagonId = ((run or {}).wagons or {})[tractorId]
return wagonId ~= nil and ((run or {}).parkedLoaded or {})[wagonId] == true
end
-- Flowet uden traktorer hvis vogn er parkeret med læs (og uden deres ekstra vogne): til den almindelige arbejdsplan,
-- så en parkeret, læsset vogn aldrig regnes som en tom vogn der kan hente mere (review 19/10). Originalen røres ikke.
function ADFlowSleep.withoutParked(run)
local ids, wagons, spares = {}, {}, {}
for _, id in ipairs(run.vehicleIds or {}) do
if not ADFlowSleep.isParkedMember(run, id) then
table.insert(ids, id)
wagons[id] = (run.wagons or {})[id]
end
end
local parked = run.parkedLoaded or {}
for _, id in ipairs(ids) do
local kept = {}
for _, wagonId in ipairs((run.spareWagons or {})[id] or {}) do
if not parked[wagonId] then table.insert(kept, wagonId) end
end
if #kept > 0 then spares[id] = kept end
end
return setmetatable({vehicleIds = ids, wagons = wagons, spareWagons = spares}, {__index = run})
end
-- Er en af flowets traktorer stadig på sin hjemtur (vognen køres til P / tømmes)? statuses = ADFlowWagons.statusOf pr.
-- traktor. Så vækkes et flow med parkeret læs ikke endnu (review 19/10).
function ADFlowSleep.parkTripBusy(statuses)
for _, status in ipairs(statuses or {}) do
if ADFlowSleep.isOwnTrip(status) then return true end
end
return false
end
-- ---- spil-adapter ----
local sleepReason = {} -- runId -> grund fra seneste vågn-tjek uden tur (vises i oversigten)
local reasonLogged = {} -- runId -> {ms, text} for seneste loggede grund
local idleSince = {} -- runId -> ms
local reserveIdleSince = {} -- runId -> ms: tomgang (last tilladt) mens gødningsreserven holder salget
local lastCheck = {} -- runId -> ms
local checkFailures = {} -- runId -> fejlede arbejdstjek i træk
local wakeState = {} -- runId -> {falseWakes, woke (vækket af dvalen), hadTrip (last siden opvågningen)}
local loggedErrors = {}
local timerMs = 0
local function nowMs()
if g_currentMission ~= nil and type(g_currentMission.time) == "number" then return g_currentMission.time end
return os.clock() * 1000
end
local function logOnce(key, text)
if loggedErrors[key] then return end
loggedErrors[key] = true
Logging.warning(ADFlowSleep.LOG_PREFIX .. "%s", tostring(text))
end
-- Alle køretøjer (også frakoblede vogne, som ikke står i AutoDrives liste).
local function findVehicle(id)
if id == nil then return nil end
for _, vehicle in pairs(g_currentMission.vehicleSystem.vehicles) do
if ADRunsController.getVehicleId(vehicle) == id then return vehicle end
end
return nil
end
local function cargoOf(adEnv, vehicle)
local autoDrive = adEnv.AutoDrive
if autoDrive == nil or autoDrive.getAllUnits == nil or autoDrive.getAllFillLevels == nil then return 0 end
local level = autoDrive.getAllFillLevels(autoDrive.getAllUnits(vehicle))
return type(level) == "number" and level or 0
end
local function hasCargoWagon(vehicle)
for _, implement in ipairs(ADHitch.rearImplementsOf(vehicle)) do
local object = implement.object
if object ~= nil and (object.spec_fillUnit ~= nil or object.spec_trailer ~= nil) then return true end
end
return false
end
-- Lastbil med eget lad (samme kriterie som ADPool.isPuller's ownBody).
local function hasOwnBody(vehicle)
return vehicle ~= nil and (vehicle.spec_trailer ~= nil or vehicle.spec_dischargeable ~= nil)
end
local function vehicleState(adEnv, vehicle)
local held = ADOutbound ~= nil and ADOutbound.getHoldFor ~= nil and ADOutbound.getHoldFor(vehicle) ~= nil
-- venter med rest-last ved et fuldt mål (ADUnloadWait) er ikke tomgang
local waitingWithLoad = ADUnloadWait ~= nil and ADUnloadWait.getWaitFor ~= nil and ADUnloadWait.getWaitFor(vehicle) ~= nil
return {holding = held and not waitingWithLoad, hasWagon = hasCargoWagon(vehicle), ownBody = hasOwnBody(vehicle),
cargo = cargoOf(adEnv, vehicle)}
end
-- Vognen (eller lastbilen selv) som planlægningen kan regne med: kapacitet og varer den kan bære.
local function cargoVehicleOf(run, byId, onlyTractorId)
for _, tractorId in ipairs(run.vehicleIds or {}) do
if onlyTractorId == nil or tractorId == onlyTractorId then
local wagon = findVehicle((run.wagons or {})[tractorId])
if wagon ~= nil then return wagon end
local tractor = byId[tractorId]
if tractor ~= nil and (hasCargoWagon(tractor) or hasOwnBody(tractor)) then return tractor end
end
end
-- lånt traktor: ingen traktor endnu — planen regner med flowets vogn
if onlyTractorId == nil and #(run.vehicleIds or {}) == 0 and run.borrowWagonId ~= nil then return findVehicle(run.borrowWagonId) end
return nil
end
-- Har flowet en tur nu? -> bool, begrundelse. onlyTractorId: regn med netop den traktors vogn (ledig traktor i et
-- kørende flow — en anden traktors fulde vogn ville aldrig give en tur).
function ADFlowSleep.hasWork(adEnv, run, byId, onlyTractorId)
local cargo = cargoVehicleOf(run, byId, onlyTractorId)
if cargo == nil then return onlyTractorId == nil, "ingen vogn at regne med" end
if run.kind == "outbound" then
local trip, reasons = ADOutboundPlanner.plan(ADOutbound.buildPlanInput(adEnv, run, cargo))
if trip == nil then
-- planlæggerens grunde ("EGG 86 % af top (kræver 90), lager 100 %") — det er dem, spilleren skal se
return false, #(reasons or {}) > 0 and table.concat(reasons, "; ") or nil
end
return true, string.format("%s til %s, vogn '%s'", table.concat(trip.names or {}, "+"),
tostring(trip.targetName or "?"), tostring(ADRuns.vehicleLabel(cargo)))
end
-- den aktive vogn først, så traktorernes ekstra vogne (ADWagonSwap: én traktor, flere vogne) — har en af dem en
-- tur, har flowet arbejde (traktoren skifter vogn ved start)
local cargos = {cargo}
for tractorId, list in pairs(run.spareWagons or {}) do
if onlyTractorId == nil or tractorId == onlyTractorId then
for _, wagonId in ipairs(list) do
local spare = findVehicle(wagonId)
-- kun en vogn traktoren faktisk kan hente (ikke udlånt, reserveret eller uden Connect — review)
if spare ~= nil and spare ~= cargo and (ADWagonSwap == nil or ADWagonSwap.isFetchable(adEnv, spare, wagonId)) then
table.insert(cargos, spare)
end
end
end
end
for index, candidate in ipairs(cargos) do
local ingredients = ADRunsController.getRunIngredients(adEnv, run, candidate)
if index > 1 and ADWagonSwap ~= nil then ingredients = ADWagonSwap.goodsFor(candidate, ingredients) end
for _, targetId in ipairs(ADRunsController.getRunTargets(run)) do
local choice = index == 1 and ADSmartPickup.findSupplyPickup(adEnv, candidate, ingredients, targetId)
or ADSmartPickup.probeSupplyPickup(adEnv, candidate, ingredients, targetId)
if choice ~= nil then
local name = g_fillTypeManager ~= nil and g_fillTypeManager:getFillTypeNameByIndex(choice.fillType) or tostring(choice.fillType)
return true, string.format("hent %s ved %s (%.0f l der, mål mangler %.0f l), vogn '%s'", tostring(name),
tostring(choice.markerName), choice.level or -1, choice.need ~= nil and choice.need.freeSpace or -1,
tostring(ADRuns.vehicleLabel(candidate))), choice, targetId
end
end
end
return false, nil
end
-- Har en af flowets vogne parkeret med læs et mål, der kan tage læsset? -> bool, begrundelse. Vogne der er væk, er
-- tømt, eller hvis vare intet mål tager, ryddes (så gælder den almindelige dvale/hasWork igen).
local function fillTypeName(fillType)
return g_fillTypeManager ~= nil and tostring(g_fillTypeManager:getFillTypeNameByIndex(fillType)) or tostring(fillType)
end
-- Én parkeret vogn: kan et af flowets mål tage læsset nu? -> bool, begrundelse. Rydder flaget, når vognen er væk/tømt,
-- eller når intet mål tager varen (så hentes vognen som normalt og tømmes som forkert last).
function ADFlowSleep.parkedWagonDue(adEnv, run, wagonId)
if not (run.parkedLoaded or {})[wagonId] then return true, nil end
local wagon = findVehicle(wagonId)
local liters, fillType = 0, nil
if wagon ~= nil and ADFlowWagons ~= nil and ADFlowWagons.cargoOf ~= nil then liters, fillType = ADFlowWagons.cargoOf(adEnv, wagon) end
if wagon == nil or fillType == nil or liters < ADFlowSleep.MIN_CARGO_LITERS then
run.parkedLoaded = ADRuns.clearParked(run.parkedLoaded, wagonId)
Logging.info(ADFlowSleep.LOG_PREFIX .. "'%s': vognen %s er ikke længere parkeret med læs", tostring(run.name), tostring(wagonId))
return true, nil
end
local entries, anyAccepts = {}, false
local targets = ADRunsController.getRunTargets(run)
for _, targetId in ipairs(targets) do
local accepted = ADSmartPickup.getTargetFreeCapacity(adEnv, wagon, fillType, true, targetId)
local free, capacity = ADSmartPickup.getTargetFreeCapacity(adEnv, wagon, fillType, false, targetId)
local takes = ADUnloadWait.markerTakes(adEnv, wagon, targetId, fillType)
if accepted ~= false and takes then anyAccepts = true end
table.insert(entries, {free = free, capacity = capacity, takes = takes,
allow = ADUnloadWait.troughAllows(adEnv, wagon, targetId, fillType)})
end
if #targets > 0 and not anyAccepts then
-- intet mål tager varen: flaget ryddes — flowet henter vognen som normalt og tømmer den (forkert last)
run.parkedLoaded = ADRuns.clearParked(run.parkedLoaded, wagonId)
Logging.info(ADFlowSleep.LOG_PREFIX .. "'%s': ingen af målene tager %s fra '%s' — vognen tømmes som normalt",
tostring(run.name), fillTypeName(fillType), tostring(ADRuns.vehicleLabel(wagon)))
return true, nil
end
local share = run.returnBelowPercent ~= nil and (1 - run.returnBelowPercent / 100) or nil
if ADFlowSleep.loadedWakeDue(liters, entries, share) then
return true, string.format("et mål kan tage det parkerede læs (%.0f l %s på '%s') — leveres først", liters,
fillTypeName(fillType), tostring(ADRuns.vehicleLabel(wagon)))
end
return false, string.format("venter på plads til det parkerede læs (%.0f l %s, kræver %.0f l fri)", liters,
fillTypeName(fillType), ADFlowSleep.loadedWakeNeedFor(liters, entries, share))
end
-- Har en af flowets vogne parkeret med læs et mål, der kan tage læsset? -> bool, begrundelse. Kun vogne der stadig er
-- parkeret med læs tæller som arbejde (et ryddet flag giver ingen vækning her — så gælder hasWork).
function ADFlowSleep.hasLoadedWork(adEnv, run)
local ids = {}
for wagonId in pairs(run.parkedLoaded or {}) do table.insert(ids, wagonId) end
table.sort(ids)
local lastWhy = nil
for _, wagonId in ipairs(ids) do
local due, why = ADFlowSleep.parkedWagonDue(adEnv, run, wagonId)
if due and why ~= nil then return true, why end
if why ~= nil then lastWhy = why end
end
return false, lastWhy
end
local positionOf = ADUtil.positionOf
local function isOwnFree(vehicle, tractorId, run)
if vehicle == nil then return false end
local status = ADFlowWagons ~= nil and ADFlowWagons.statusOf ~= nil and ADFlowWagons.statusOf(vehicle) or nil
local onOwnTrip = ADFlowSleep.isOwnTrip(status)
local otherRun = ADRunsController.getRunForVehicle(vehicle)
local lentOut = (otherRun ~= nil and otherRun ~= run)
or (ADFieldJobs ~= nil and ADFieldJobs.state ~= nil and ADFieldJobs.state.assignments ~= nil and ADFieldJobs.state.assignments[tractorId] ~= nil)
or (ADCpBridge ~= nil and ADCpBridge.isWorking ~= nil and ADCpBridge.isWorking(vehicle) == true)
or (ADFieldSilos ~= nil and ADFieldSilos.isLoaned ~= nil and ADFieldSilos.isLoaned(vehicle) == true)
or (not onOwnTrip and ADPool ~= nil and ADPool.isReturning ~= nil and ADPool.isReturning(vehicle) == true)
return ADFlowSleep.ownUsable({exists = true, lentOut = lentOut, onOwnTrip = onOwnTrip})
end
-- Ledige puljetraktorer der ikke hører til noget flow (heller ikke et sovende/stoppet) og ikke er reserveret.
local function freeTractors(adEnv, taken)
local _, tractors = ADPool.collect(adEnv, function(vehicle) return ADFieldWork.isBusyVehicle(vehicle, ADRunsController.getVehicleId(vehicle)) end)
local blocked = ADPool.blocked(nowMs())
local result = {}
for _, tractor in ipairs(tractors or {}) do
if not blocked[tractor.id] and not taken[tractor.id] and not tractor.offNetwork
and ADRunsController.getRunForVehicle(tractor.vehicle) == nil then
table.insert(result, tractor)
end
end
return result
end
-- Seneste vågn-tjeks grund for et sovende flow: planlæggerens tekst, false = ingen tur uden nærmere grund (GUI'et
-- oversætter selv efter flowtype), nil = intet vågn-tjek endnu.
function ADFlowSleep.getSleepReason(runId)
return sleepReason[runId]
end
local function noteNoWork(run, why, now)
local text = ADFlowSleep.sleepReasonText(why, run.kind)
sleepReason[run.id] = (why ~= nil and why ~= "") and why or false
if run.kind == "outbound" and why ~= nil and ADOutbound ~= nil and ADOutbound.setRunReasons ~= nil then
pcall(ADOutbound.setRunReasons, run.id, {why})
end
if ADFlowSleep.reasonLogDue(reasonLogged[run.id], now, text) then
reasonLogged[run.id] = {ms = now, text = text}
Logging.info(ADFlowSleep.LOG_PREFIX .. "'%s' sover videre: %s", tostring(run.name), text)
end
end
-- Sættet (traktor med flowets vogn på) er lånt ud til markarbejde (gøder): flowet må ikke vækkes, før det er
-- færdigt — en anden traktor kan ikke tage vognen, og flowet ville stå "tændt" og vente (review 17/10)
local function lentOutWithWagon(run, byId)
for _, tractorId in ipairs(run.vehicleIds or {}) do
local own = byId[tractorId]
local wagonId = (run.wagons or {})[tractorId]
if own ~= nil and wagonId ~= nil then
for _, implement in ipairs(ADHitch.rearImplementsOf(own)) do
if ADRunsController.getVehicleId(implement.object) == wagonId and not isOwnFree(own, tractorId, run) then
return ADRuns.vehicleLabel(own)
end
end
end
end
return nil
end
local function carriesWagon(vehicle, wagonId)
for _, implement in ipairs(vehicle ~= nil and ADHitch.rearImplementsOf(vehicle) or {}) do
if ADRunsController.getVehicleId(implement.object) == wagonId then return true end
end
return false
end
-- Lånt traktor til flowets vogn: sættes på flowet (vehicleIds + vogn) — opvågningen starter den så som en solo-traktor
-- med husket vogn (henter vognen ved Connect). -> true når der er en traktor
local function staffBorrowed(adEnv, run, now)
local wagon = findVehicle(run.borrowWagonId)
if wagon == nil then
noteNoWork(run, string.format("flowets vogn (%s) findes ikke længere", tostring(run.borrowWagonId)), now)
return false
end
local wagonName = tostring(ADRuns.vehicleLabel(wagon))
if ADPlayerClaim ~= nil and ADPlayerClaim.claims(wagon) then
noteNoWork(run, string.format("spilleren bruger vognen '%s'", wagonName), now)
return false
end
local attacher = wagon.getAttacherVehicle ~= nil and wagon:getAttacherVehicle() or nil
local attacherInfo = nil
if attacher ~= nil then
local id = ADRunsController.getVehicleId(attacher)
local module = attacher.ad ~= nil and attacher.ad.stateModule or nil
local free = id ~= nil and ADRunsController.getRunForVehicle(attacher) == nil and not (module ~= nil and module:isActive())
and not (attacher.getIsControlled ~= nil and attacher:getIsControlled()) and not ADFieldWork.isBusyVehicle(attacher, id)
attacherInfo = {id = id, name = tostring(ADRuns.vehicleLabel(attacher)), free = free}
end
local candidates = {}
if attacherInfo == nil then
local okFree, list = pcall(freeTractors, adEnv, {})
candidates = okFree and list or {}
end
local x, z = positionOf(wagon)
local okHp, neededHp = pcall(ADPool.readNeededHp, wagon)
local chosen = ADFlowSleep.chooseBorrowed({attacher = attacherInfo, candidates = candidates,
wagon = {x = x, z = z, neededHp = okHp and neededHp or nil},
bestFit = function(list, implement) return ADPool.bestFit(list, implement, "unloader") end})
if chosen == nil then
noteNoWork(run, attacherInfo ~= nil and string.format("vognen '%s' sidder på '%s', som er optaget", wagonName, attacherInfo.name)
or string.format("ingen ledig traktor kan trække '%s'", wagonName), now)
return false
end
run.vehicleIds = {chosen.id}
run.wagons = {[chosen.id] = run.borrowWagonId}
run.spareWagons = {}
Logging.info(ADFlowSleep.LOG_PREFIX .. "'%s' låner '%s' til vognen '%s'", tostring(run.name), tostring(chosen.name or chosen.id), wagonName)
return true
end
local borrowRetryAt = {} -- runId -> ms: lånt traktor kunne ikke starte — ikke låne igen før (review 19/10: ellers blev en
-- ny puljetraktor hentet og sendt hjem ved hvert vågn-tjek)
-- Bruger spilleren en af flowets traktorer eller vogne (ADPlayerClaim)? Så sover flowet videre — ikke byt traktoren ud
-- (review 19/10: at sætte sig ind i flowets traktor fik ellers opvågningen til at give flowet en anden traktor for altid).
-- -> navnet eller nil
local function playerUses(run, byId)
if ADPlayerClaim == nil then return nil end
for _, tractorId in ipairs(run.vehicleIds or {}) do
local own = byId[tractorId]
if own ~= nil and ADPlayerClaim.claims(own) then return tostring(ADRuns.vehicleLabel(own)) end
end
for _, wagonId in ipairs(ADRuns.wagonIdsOf(run)) do
local wagon = findVehicle(wagonId)
if wagon ~= nil and ADPlayerClaim.claims(wagon) then return tostring(ADRuns.vehicleLabel(wagon)) end
end
return nil
end
local function wake(adEnv, run, byId, why)
local used = playerUses(run, byId)
if used ~= nil then
noteNoWork(run, string.format("spilleren bruger '%s'", used), nowMs())
return
end
if run.borrowWagonId ~= nil and #(run.vehicleIds or {}) == 0 then
local now = nowMs()
if borrowRetryAt[run.id] ~= nil and now < borrowRetryAt[run.id] then
noteNoWork(run, string.format("lånt traktor kunne ikke starte — prøver igen om %d min",
math.ceil((borrowRetryAt[run.id] - now) / 60000)), now)
return
end
borrowRetryAt[run.id] = nil
local okStaff, staffed = pcall(staffBorrowed, adEnv, run, nowMs())
if not okStaff then logOnce("borrow:" .. tostring(run.id), string.format("'%s': lån af traktor fejlede: %s", tostring(run.name), tostring(staffed))) end
if not (okStaff and staffed) then return end
end
local busySet = lentOutWithWagon(run, byId)
if busySet ~= nil then
local text = string.format("sættet '%s' er lånt ud (gøder)", tostring(busySet))
if ADFlowSleep.reasonLogDue(reasonLogged[run.id], nowMs(), text) then
reasonLogged[run.id] = {ms = nowMs(), text = text}
Logging.info(ADFlowSleep.LOG_PREFIX .. "'%s' har arbejde, men %s — sover videre", tostring(run.name), text)
end
return
end
run.sleeping = nil
sleepReason[run.id] = nil
reasonLogged[run.id] = nil
-- dvale-tjekkets gamle grunde må ikke sende flowet i dvale igen, før planlæggeren har kørt (review 17/10)
if run.kind == "outbound" and ADOutbound ~= nil and ADOutbound.setRunReasons ~= nil then pcall(ADOutbound.setRunReasons, run.id, {}) end
local taken = {}
for _, tractorId in ipairs(run.vehicleIds or {}) do
local own = byId[tractorId]
local wagonId = (run.wagons or {})[tractorId]
local wagonOnOwn = false
for _, implement in ipairs(own ~= nil and ADHitch.rearImplementsOf(own) or {}) do
if wagonId ~= nil and ADRunsController.getVehicleId(implement.object) == wagonId then wagonOnOwn = true end
end
-- vognen sidder på den egne traktor: aldrig byt (en anden traktor ville vente på vognen for evigt)
-- lastbil med eget lad: aldrig byt (en traktor kan ikke tage dens tur)
if not wagonOnOwn and not hasOwnBody(own) and not isOwnFree(own, tractorId, run) then
local wagon = findVehicle(wagonId)
local x, z = positionOf(wagon or own)
local okHp, neededHp = pcall(ADPool.readNeededHp, wagon)
local okFree, candidates = pcall(freeTractors, adEnv, taken)
local chosen = ADFlowSleep.chooseTractor({own = own ~= nil and {id = tractorId} or nil, ownFree = false,
candidates = okFree and candidates or {}, wagon = {x = x, z = z, neededHp = okHp and neededHp or nil},
bestFit = function(list, implement) return ADPool.bestFit(list, implement, "unloader") end})
if chosen ~= nil and chosen.id ~= tractorId then
run.vehicleIds, run.wagons = ADFlowSleep.swapTractor(run, tractorId, chosen.id)
-- ekstra vogne følger med til den nye traktor (ADWagonSwap)
run.spareWagons = ADFlowSleep.swapSpares(run.spareWagons, tractorId, chosen.id)
taken[chosen.id] = true
Logging.info(ADFlowSleep.LOG_PREFIX .. "'%s': '%s' er optaget — '%s' tager turen", tostring(run.name),
own ~= nil and tostring(ADRuns.vehicleLabel(own)) or tostring(tractorId), tostring(chosen.name or chosen.id))
end
end
end
Logging.info(ADFlowSleep.LOG_PREFIX .. "'%s' vågner (%s)", tostring(run.name), tostring(why or "arbejde"))
local results = ADRunsController.startRun(adEnv, run.id)
if not ADFlowSleep.anyStarted(results) then
-- ingen traktor kunne starte (fx ugyldig markør): tilbage i dvale, ellers står flowet "tændt" uden at køre
local reasons = {}
for _, result in ipairs(results or {}) do table.insert(reasons, tostring(result.reason)) end
ADRunsController.stopRun(adEnv, run.id)
run.sleeping = true
if run.borrowWagonId ~= nil then borrowRetryAt[run.id] = nowMs() + ADFlowSleep.RESTART_FAILED_BACKOFF_MS end
Logging.info(ADFlowSleep.LOG_PREFIX .. "'%s' kunne ikke starte (%s) — sover videre", tostring(run.name), table.concat(reasons, ", "))
end
end
-- Lastbiler uden parkering bliver holdende ved Wait, når flowet sover — skriv det i loggen.
local function logTrucksWithoutPark(adEnv, run, byId)
for _, id in ipairs(run.vehicleIds or {}) do
local vehicle = byId[id]
local okPark, park = pcall(ADFieldWork.parkMarkerId, adEnv, vehicle)
if vehicle ~= nil and hasOwnBody(vehicle) and not (okPark and park ~= nil) then
Logging.info(ADFlowSleep.LOG_PREFIX .. "'%s' har ingen parkering — bliver stående ved Wait (giv den en P-plads i AutoDrive)",
tostring(ADRuns.vehicleLabel(vehicle)))
end
end
end
-- keepWagons: sættet bliver samlet, hvor det står (gødningsreserven) — markflåden tager det som gødningsmaskine
local function sleep(adEnv, run, byId, why, keepWagons)
if not keepWagons then logTrucksWithoutPark(adEnv, run, byId) end
local state = wakeState[run.id] or {}
local falseWakes = ADFlowSleep.falseWakesAfterSleep(state.woke and (state.falseWakes or 0) or nil, state.hadTrip == true)
wakeState[run.id] = {falseWakes = falseWakes}
ADRunsController.stopRun(adEnv, run.id, keepWagons)
run.sleeping = true
idleSince[run.id] = nil
lastCheck[run.id] = nowMs()
-- ny dvale: ingen gammel grund i oversigten, og første vågn-tjek må logge sin grund igen
sleepReason[run.id] = nil
reasonLogged[run.id] = nil
Logging.info(ADFlowSleep.LOG_PREFIX .. "'%s' sover — %s; %s%s",
tostring(run.name), why or string.format("intet at lave i %d min", math.floor(ADFlowSleep.sleepAfterMs(run) / 60000)),
keepWagons and "sættet bliver samlet og er ledigt til markflåden (gødning)" or "traktor og vogn er ledige til andet", falseWakes > 0
and string.format(" (vågnede uden tur %d gang(e) i træk — næste tjek om %d min)", falseWakes, math.floor(ADFlowSleep.wakeBackoffMs(falseWakes) / 60000)) or "")
end
local function farmVehiclesById(adEnv)
local byId = {}
for _, vehicle in ipairs(ADRunsController.getFarmVehicles(adEnv)) do
local id = ADRunsController.getVehicleId(vehicle)
if id ~= nil then byId[id] = vehicle end
end
return byId
end
-- Læg flowet i dvale udefra (ADFlowWagons: læsset vogn parkeres på sin P-plads): stopper flowet og sender traktorerne hjem.
function ADFlowSleep.sleepRun(adEnv, run, reasonText)
sleep(adEnv, run, farmVehiclesById(adEnv), reasonText)
end
local restartDue = {} -- runId -> ms hvor næste tjek for ledige traktorer må køre
local restartWaiting = {} -- runId -> true mens en ledig traktor med arbejde står i udsendelsesportens kø
local lastControlled = setmetatable({}, {__mode = "k"}) -- køretøj -> ms hvor spilleren sidst sad i den
-- Ren: skal endnu en traktor ud? Kun når målet mangler mere end flowets andre vogne allerede har med (in-game 16/10:
-- 'Cow Food 2' sendt ud efter 14.583 l, mens 'Cow Food 1' ventede ved Wait med 157.921 l af samme foder).
function ADFlowSleep.needsMoreThanCarried(freeSpace, carriedByOthers)
if freeSpace == nil then return true end
return freeSpace > (carriedByOthers or 0)
end
-- Liter af varen som flowets ANDRE traktorer har med uden at være meldt "på vej" til målet (fx en rest ved Wait).
-- Meldt på vej er allerede trukket fra målets behov (findSupplyPickup/getPending) — ikke to gange (review 16/10).
local function carriedByOthers(adEnv, run, byId, exceptId, fillType, targetId)
local total = 0
if ADSmartPickup.carriedLiters == nil or fillType == nil then return total end
for _, id in ipairs(run.vehicleIds or {}) do
local vehicle = byId[id]
if id ~= exceptId and vehicle ~= nil then
local route = ADSmartPickup.getEnRoute ~= nil and ADSmartPickup.getEnRoute(vehicle) or nil
local carried = ADSmartPickup.carriedLiters(adEnv, vehicle, fillType) or 0
local counted = route ~= nil and route.fillType == fillType and (targetId == nil or route.wayPointId == targetId)
-- meldt på vej: kun det den har med ud over det meldte (planlagt mængde kan være mindre end lasten)
if counted then carried = math.max(0, carried - (tonumber(route.liters) or 0)) end
total = total + carried
end
end
return total
end
local function restartIdleMember(adEnv, run, byId, now)
local members = {}
for _, id in ipairs(run.vehicleIds or {}) do
local vehicle = byId[id]
if vehicle ~= nil and vehicle.getIsControlled ~= nil and vehicle:getIsControlled() == true then lastControlled[vehicle] = now end
end
if restartDue[run.id] == nil then restartDue[run.id] = now + ADFlowSleep.RESTART_STARTUP_DELAY_MS end
if now < restartDue[run.id] then return end
local gateName = "flow:" .. tostring(run.id)
-- står allerede i portens kø: regn ikke det hele igen hvert sekund, før det er vores tur
if restartWaiting[run.id] and ADLaunchGate ~= nil and not ADLaunchGate.isOpen(gateName) then return end
restartWaiting[run.id] = nil
for _, id in ipairs(run.vehicleIds or {}) do
local vehicle = byId[id]
if vehicle ~= nil then
local module = vehicle.ad ~= nil and vehicle.ad.stateModule or nil
-- vogn-logikken er i gang (henter, venter på, tømmer eller kører hjem): ikke vores at starte
local wagonBusy = ADFlowWagons ~= nil and ADFlowWagons.statusOf ~= nil and ADFlowWagons.statusOf(vehicle) ~= nil
local recentlyDriven = lastControlled[vehicle] ~= nil and now - lastControlled[vehicle] < ADFlowSleep.MANUAL_GRACE_MS
-- står i "Start alle"-køen: køen starter den (in-game 16/10: Cow Food 3 blev startet uden om køen)
local queued = ADRunsController.isQueuedToStart ~= nil and ADRunsController.isQueuedToStart(id)
local usable = not wagonBusy and not queued and isOwnFree(vehicle, id, run)
-- vognen står parkeret med læs: kun brugbar, når et mål kan tage læsset (ellers spærrede den for de andre)
if usable and ADFlowSleep.isParkedMember(run, id) then
local okDue, due = pcall(ADFlowSleep.parkedWagonDue, adEnv, run, (run.wagons or {})[id])
usable = okDue and due == true
end
table.insert(members, {id = id, active = module ~= nil and module.isActive ~= nil and module:isActive(),
usable = usable, controlled = recentlyDriven})
end
end
local id = ADFlowSleep.pickIdleMember(run, members)
local hasWork, why, choice, choiceTarget = false, nil, nil, nil
if id ~= nil and ADFlowSleep.isParkedMember(run, id) then
-- (brugbar = et mål kan tage det parkerede læs) — hentes og leveres først
hasWork, why = true, "det parkerede læs kan leveres"
elseif id ~= nil then
hasWork, why, choice, choiceTarget = ADFlowSleep.hasWork(adEnv, run, byId, id)
end
-- de andre vogne har allerede nok med til det målet mangler: ingen ekstra tur
if hasWork and choice ~= nil and choice.need ~= nil then
local carried = carriedByOthers(adEnv, run, byId, id, choice.fillType, choiceTarget)
if not ADFlowSleep.needsMoreThanCarried(choice.need.freeSpace, carried) then hasWork = false end
end
if not hasWork then
restartDue[run.id] = now + ADFlowSleep.WAKE_CHECK_MS
if ADLaunchGate ~= nil then ADLaunchGate.done(gateName) end
return
end
-- fælles udsendelsesport: står i kø og prøver igen ved næste tick (uden at skubbe minut-tjekket)
if ADLaunchGate ~= nil and not ADLaunchGate.isOpen(gateName) then
restartWaiting[run.id] = true
return
end
restartDue[run.id] = now + ADFlowSleep.WAKE_CHECK_MS
Logging.info(ADFlowSleep.LOG_PREFIX .. "'%s': '%s' holder stille i det kørende flow — startes (%s)", tostring(run.name),
tostring(ADRuns.vehicleLabel(byId[id])), tostring(why))
local result = ADRunsController.startVehicle(adEnv, run, byId[id])
if ADLaunchGate ~= nil then
if result ~= nil and result.ok then ADLaunchGate.markLaunched(gateName) else ADLaunchGate.done(gateName) end
end
if ADFlowSleep.restartNeedsBackoff(result) then restartDue[run.id] = now + ADFlowSleep.RESTART_FAILED_BACKOFF_MS end
end
-- Overlever dvalen en genindlæsning? Ikke når moden er sat på pause ("Stop alt og parkér" — intet starter før
-- "Start alle"): et gem fra før 1.62.334 kan holde et flow som stoppet+sovende, og det vækkede sig selv (18/10 01:19).
-- Kun ved indlæsning — et flow spilleren starter under pausen må gerne sove og vågne. s = {sleeping, stopped, paused}
function ADFlowSleep.keepsSleepAfterLoad(s)
if s == nil or not s.sleeping or not s.stopped then return false end
return s.paused ~= true
end
local function modPaused()
return ADFieldJobs ~= nil and ADFieldJobs.state ~= nil and ADFieldJobs.state.paused == true
end
local loadChecked = false
local function cancelSleepIfPaused()
if loadChecked then return end
-- pause-flaget læses først i ADFieldJobs.load (ca. 1 s efter start) — vent på det (review)
if ADFieldJobs == nil or not ADFieldJobs.loaded then return end
if ADRunsController.store == nil or ADRunsController.store.runs == nil then return end
loadChecked = true
local paused = modPaused()
for _, run in ipairs(ADRunsController.store.runs or {}) do
if run.sleeping and not ADFlowSleep.keepsSleepAfterLoad({sleeping = run.sleeping, stopped = run.stopped, paused = paused}) then
run.sleeping = nil
Logging.info(ADFlowSleep.LOG_PREFIX .. "'%s': dvalen aflyst ved indlæsning (moden er sat på pause med Stop alt)", tostring(run.name))
end
end
end
-- Flow med lånt traktor: startet uden traktor -> dvale (vågn-tjekket låner en, når der er en tur); stoppet/sovende
-- og traktoren færdig med vognen (sat på plads, ingen tømning/hjemtur fra flow-vognene) -> traktoren slippes.
local function tickBorrow(run, byId)
if run.borrowWagonId == nil then return end
local ids = run.vehicleIds or {}
local busy = false
for _, id in ipairs(ids) do
local vehicle = byId[id]
local status = vehicle ~= nil and ADFlowWagons ~= nil and ADFlowWagons.statusOf ~= nil and ADFlowWagons.statusOf(vehicle) or nil
if status ~= nil or carriesWagon(vehicle, run.borrowWagonId) then busy = true end
end
local action = ADFlowSleep.borrowAction({borrow = true, stopped = run.stopped, sleeping = run.sleeping, hasTractor = #ids > 0, tractorBusy = busy})
if action == "await" then
run.stopped, run.sleeping = true, true
lastCheck[run.id], idleSince[run.id] = nil, nil
Logging.info(ADFlowSleep.LOG_PREFIX .. "'%s' venter på en tur — en ledig traktor lånes, når der er en", tostring(run.name))
elseif action == "release" then
local names = {}
for _, id in ipairs(ids) do table.insert(names, byId[id] ~= nil and tostring(ADRuns.vehicleLabel(byId[id])) or tostring(id)) end
run.vehicleIds, run.wagons, run.spareWagons = {}, {}, {}
Logging.info(ADFlowSleep.LOG_PREFIX .. "'%s' slipper den lånte traktor '%s' — vognen står på sin plads, traktoren er ledig",
tostring(run.name), table.concat(names, ", "))
end
end
local function tickRun(adEnv, run, byId, now)
tickBorrow(run, byId)
if run.sleeping and run.stopped then
if not ADFlowSleep.isCheckDue(lastCheck[run.id], now, (wakeState[run.id] or {}).falseWakes) then return end
local hasParked = next(run.parkedLoaded or {}) ~= nil
-- parkeringsturen er ikke færdig (vognen køres stadig til sin P): intet tjek endnu, prøv igen næste tick
if hasParked then
local statuses = {}
for _, id in ipairs(run.vehicleIds or {}) do
local vehicle = byId[id]
if vehicle ~= nil and ADFlowWagons ~= nil and ADFlowWagons.statusOf ~= nil then table.insert(statuses, ADFlowWagons.statusOf(vehicle)) end
end
if ADFlowSleep.parkTripBusy(statuses) then return end
end
lastCheck[run.id] = now
-- vogn parkeret med læs: vækning når et mål kan tage læsset (leveres først) ELLER når flowets andre traktorer/vogne
-- har arbejde — den parkerede vogn regnes ikke med i den almindelige plan (withoutParked), og dens traktor bliver
-- hjemme ved opvågningen, til læsset kan leveres (ADFlowWagons.beforeStart)
local ok, hasWork, why
if hasParked then
ok, hasWork, why = pcall(ADFlowSleep.hasLoadedWork, adEnv, run)
if ok and not hasWork then
local loadedWhy = why
local view = ADFlowSleep.withoutParked(run)
if #view.vehicleIds > 0 then ok, hasWork, why = pcall(ADFlowSleep.hasWork, adEnv, view, byId) end
if ok and not hasWork then why = loadedWhy or why end
end
else
ok, hasWork, why = pcall(ADFlowSleep.hasWork, adEnv, run, byId)
end
if ok then
checkFailures[run.id] = nil
else
logOnce("hasWork:" .. tostring(run.id), string.format("'%s': arbejdstjek fejlede: %s", tostring(run.name), tostring(hasWork)))
local wakeNow
checkFailures[run.id], wakeNow = ADFlowSleep.onCheckError(checkFailures[run.id])
hasWork, why = wakeNow, "arbejdstjekket fejlede " .. tostring(checkFailures[run.id]) .. " gange"
if wakeNow then checkFailures[run.id] = nil end
end
if hasWork then
local state = wakeState[run.id] or {}
wakeState[run.id] = {falseWakes = state.falseWakes or 0, woke = true, hadTrip = false}
wake(adEnv, run, byId, why)
else
noteNoWork(run, why, now)
end
return
end
-- startet af spilleren (fx "Start alle") mens det sov
if run.sleeping and not run.stopped then run.sleeping = nil end
local vehicles = {}
local state = wakeState[run.id]
for index, id in ipairs(run.vehicleIds or {}) do
local vehicle = byId[id]
vehicles[index] = vehicle ~= nil and vehicleState(adEnv, vehicle) or false
-- traktoren venter hjemme på sin vogn, der står parkeret med læs: tæller som tomgang, så flowet kan sove igen
local module = vehicle ~= nil and vehicle.ad ~= nil and vehicle.ad.stateModule or nil
if vehicles[index] and ADFlowSleep.isParkedMember(run, id) and #ADHitch.rearImplementsOf(vehicle) == 0
and not (module ~= nil and module:isActive()) then
vehicles[index] = {holding = true, hasWagon = true, cargo = 0}
end
-- last på efter opvågningen = opvågningen var ægte
if state ~= nil and state.woke and vehicles[index] and (vehicles[index].cargo or 0) >= ADFlowSleep.MIN_CARGO_LITERS then
state.hadTrip = true
end
end
local idle = ADFlowSleep.isIdle({stopped = run.stopped, vehicles = vehicles})
idleSince[run.id] = ADFlowSleep.track(idleSince[run.id], idle, now)
if ADFlowSleep.shouldSleep(idleSince[run.id], now, ADFlowSleep.sleepAfterMs(run)) then
sleep(adEnv, run, byId)
return
end
-- gødningsreserven holder salget: sov efter kort tomgang med vognen på (også med gylle i), så sættet kan gøde
-- samlet (ikke 10 min ved Wait, ingen tur hjem)
if run.kind == "outbound" and ADOutbound ~= nil and ADOutbound.getRunStatus ~= nil
and ADFlowSleep.heldForFields(ADOutbound.getRunStatus(run.id).reasons) then
local idleWithCargo = ADFlowSleep.isIdle({stopped = run.stopped, vehicles = vehicles, allowCargo = true})
reserveIdleSince[run.id] = ADFlowSleep.track(reserveIdleSince[run.id], idleWithCargo, now)
if reserveIdleSince[run.id] ~= nil and now - reserveIdleSince[run.id] >= ADFlowSleep.RESERVE_SLEEP_GRACE_MS then
reserveIdleSince[run.id] = nil
sleep(adEnv, run, byId, "gyllen er reserveret til markerne", true)
return
end
else
reserveIdleSince[run.id] = nil
end
restartIdleMember(adEnv, run, byId, now)
end
function ADFlowSleep.tick(adEnv, dt)
timerMs = timerMs + (dt or 0)
if timerMs < ADFlowSleep.TICK_MS then return end
timerMs = 0
if adEnv == nil or ADRunsController == nil or ADRunsController.store == nil then return end
local byId = farmVehiclesById(adEnv)
local now = nowMs()
pcall(cancelSleepIfPaused)
if not loadChecked then return end -- ingen vækning, før gemmets pause-flag er læst
for _, run in ipairs(ADRunsController.store.runs or {}) do
local ok, err = pcall(tickRun, adEnv, run, byId, now)
if not ok then logOnce("tick:" .. tostring(run.id), string.format("'%s': %s", tostring(run.name), tostring(err))) end
end
end