Files
fs25-adsmartpickup/FS25_ADSmartPickup/adFlowSleep.lua
T

450 lines
23 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.
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 (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)
return since ~= nil and nowMs - since >= ADFlowSleep.SLEEP_AFTER_MS
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
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
-- 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
-- ---- spil-adapter ----
local idleSince = {} -- runId -> ms
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
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 = ADOutboundPlanner.plan(ADOutbound.buildPlanInput(adEnv, run, cargo))
return trip ~= nil, trip ~= nil and string.format("%s til %s, vogn '%s'", table.concat(trip.names or {}, "+"),
tostring(trip.targetName or "?"), tostring(ADRuns.vehicleLabel(cargo))) or nil
end
local ingredients = ADRunsController.getRunIngredients(adEnv, run, cargo)
for _, targetId in ipairs(ADRunsController.getRunTargets(run)) do
local choice = ADSmartPickup.findSupplyPickup(adEnv, cargo, 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(cargo)))
end
end
return false, nil
end
local function positionOf(vehicle)
if vehicle == nil or vehicle.rootNode == nil then return nil, nil end
local x, _, z = getWorldTranslation(vehicle.rootNode)
return x, z
end
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
local function wake(adEnv, run, byId, why)
run.sleeping = nil
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)
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
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
local function sleep(adEnv, run, byId)
logTrucksWithoutPark(adEnv, run, byId)
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)
run.sleeping = true
idleSince[run.id] = nil
lastCheck[run.id] = nowMs()
Logging.info(ADFlowSleep.LOG_PREFIX .. "'%s' sover — intet at lave i %d min; traktor og vogn er ledige til andet%s",
tostring(run.name), math.floor(ADFlowSleep.SLEEP_AFTER_MS / 60000), 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
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
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)
table.insert(members, {id = id, active = module ~= nil and module.isActive ~= nil and module:isActive(),
usable = not wagonBusy and not queued and isOwnFree(vehicle, id, run), controlled = recentlyDriven})
end
end
local id = ADFlowSleep.pickIdleMember(run, members)
local hasWork, why = false, nil
if id ~= nil then hasWork, why = ADFlowSleep.hasWork(adEnv, run, byId, id) 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
local function tickRun(adEnv, run, byId, now)
if run.sleeping and run.stopped then
if not ADFlowSleep.isCheckDue(lastCheck[run.id], now, (wakeState[run.id] or {}).falseWakes) then return end
lastCheck[run.id] = now
local ok, hasWork, why = pcall(ADFlowSleep.hasWork, adEnv, run, byId)
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)
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
-- 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
idleSince[run.id] = ADFlowSleep.track(idleSince[run.id], ADFlowSleep.isIdle({stopped = run.stopped, vehicles = vehicles}), now)
if ADFlowSleep.shouldSleep(idleSince[run.id], now) then
sleep(adEnv, run, byId)
return
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()
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