Files
fs25-adsmartpickup/FS25_ADSmartPickup/adFlowSleep.lua
T

558 lines
29 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
-- 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
-- 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 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 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, 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
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))), choice, targetId
end
end
return false, nil
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
local function wake(adEnv, run, byId, why)
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)
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, why)
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()
-- 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; traktor og vogn er ledige til andet%s",
tostring(run.name), why or string.format("intet at lave i %d min", 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
-- 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)
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, choice, choiceTarget = false, nil, nil, nil
if 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
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)
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
-- 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) then
sleep(adEnv, run, byId)
return
end
-- gødningsreserven holder salget: sov efter kort tomgang, så gyllevognene kan gøde (ikke 10 min ved Wait)
if idle and run.kind == "outbound" and idleSince[run.id] ~= nil and now - idleSince[run.id] >= ADFlowSleep.RESERVE_SLEEP_GRACE_MS
and ADOutbound ~= nil and ADOutbound.getRunStatus ~= nil
and ADFlowSleep.heldForFields(ADOutbound.getRunStatus(run.id).reasons) then
sleep(adEnv, run, byId, "gyllen er reserveret til markerne")
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